001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.editor.fckeditor.receiver.impl;
016    
017    import com.liferay.portal.editor.fckeditor.command.CommandArgument;
018    import com.liferay.portal.editor.fckeditor.exception.FCKException;
019    import com.liferay.portal.editor.fckeditor.receiver.CommandReceiver;
020    import com.liferay.portal.kernel.dao.orm.QueryUtil;
021    import com.liferay.portal.kernel.io.ByteArrayFileInputStream;
022    import com.liferay.portal.kernel.log.Log;
023    import com.liferay.portal.kernel.log.LogFactoryUtil;
024    import com.liferay.portal.kernel.util.CharPool;
025    import com.liferay.portal.kernel.util.ContentTypes;
026    import com.liferay.portal.kernel.util.GetterUtil;
027    import com.liferay.portal.kernel.util.HtmlUtil;
028    import com.liferay.portal.kernel.util.MimeTypesUtil;
029    import com.liferay.portal.kernel.util.ParamUtil;
030    import com.liferay.portal.kernel.util.PropsKeys;
031    import com.liferay.portal.kernel.util.StreamUtil;
032    import com.liferay.portal.kernel.util.StringBundler;
033    import com.liferay.portal.kernel.util.StringPool;
034    import com.liferay.portal.kernel.util.StringUtil;
035    import com.liferay.portal.kernel.util.Validator;
036    import com.liferay.portal.model.Group;
037    import com.liferay.portal.model.Organization;
038    import com.liferay.portal.service.GroupLocalServiceUtil;
039    import com.liferay.portal.service.OrganizationLocalServiceUtil;
040    import com.liferay.portal.theme.ThemeDisplay;
041    import com.liferay.portal.upload.LiferayFileItem;
042    import com.liferay.portal.upload.LiferayFileItemFactory;
043    import com.liferay.portal.upload.LiferayFileUpload;
044    import com.liferay.portal.upload.LiferayServletRequest;
045    import com.liferay.portal.upload.UploadServletRequestImpl;
046    import com.liferay.portal.util.PrefsPropsUtil;
047    import com.liferay.portal.util.PropsValues;
048    
049    import java.io.InputStream;
050    import java.io.PrintWriter;
051    
052    import java.util.HashMap;
053    import java.util.LinkedHashMap;
054    import java.util.List;
055    import java.util.Map;
056    
057    import javax.servlet.http.HttpServletRequest;
058    import javax.servlet.http.HttpServletResponse;
059    
060    import javax.xml.parsers.DocumentBuilder;
061    import javax.xml.parsers.DocumentBuilderFactory;
062    import javax.xml.parsers.ParserConfigurationException;
063    import javax.xml.transform.Transformer;
064    import javax.xml.transform.TransformerFactory;
065    import javax.xml.transform.dom.DOMSource;
066    import javax.xml.transform.stream.StreamResult;
067    
068    import org.apache.commons.fileupload.FileItem;
069    import org.apache.commons.fileupload.disk.DiskFileItem;
070    import org.apache.commons.fileupload.servlet.ServletFileUpload;
071    
072    import org.w3c.dom.Document;
073    import org.w3c.dom.Element;
074    import org.w3c.dom.Node;
075    
076    /**
077     * @author Ivica Cardic
078     * @author Raymond Augé
079     */
080    public abstract class BaseCommandReceiver implements CommandReceiver {
081    
082            public void createFolder(
083                    CommandArgument commandArgument, HttpServletRequest request,
084                    HttpServletResponse response) {
085    
086                    Document document = _createDocument();
087    
088                    Node rootNode = _createRoot(
089                            document, commandArgument.getCommand(), commandArgument.getType(),
090                            commandArgument.getCurrentFolder(), StringPool.BLANK);
091    
092                    Element errorElement = document.createElement("Error");
093    
094                    rootNode.appendChild(errorElement);
095    
096                    String returnValue = "0";
097    
098                    try {
099                            returnValue = createFolder(commandArgument);
100                    }
101                    catch (FCKException fcke) {
102                            Throwable cause = fcke.getCause();
103    
104                            returnValue = "110";
105    
106                            if (cause != null) {
107                                    String causeString = GetterUtil.getString(cause.toString());
108    
109                                    if (causeString.contains("DuplicateFolderNameException")) {
110                                            returnValue = "101";
111                                    }
112                                    else if (causeString.contains("FolderNameException")) {
113                                            returnValue = "102";
114                                    }
115                                    else if (causeString.contains("NoSuchGroupException") ||
116                                                     causeString.contains("PrincipalException")) {
117    
118                                            returnValue = "103";
119                                    }
120                                    else {
121                                            throw fcke;
122                                    }
123                            }
124                    }
125    
126                    errorElement.setAttribute("number", returnValue);
127    
128                    _writeDocument(document, response);
129            }
130    
131            public void fileUpload(
132                    CommandArgument commandArgument, HttpServletRequest request,
133                    HttpServletResponse response) {
134    
135                    InputStream inputStream = null;
136    
137                    String returnValue = null;
138    
139                    try {
140                            ServletFileUpload servletFileUpload = new LiferayFileUpload(
141                                    new LiferayFileItemFactory(
142                                            UploadServletRequestImpl.getTempDir()), request);
143    
144                            servletFileUpload.setFileSizeMax(
145                                    PrefsPropsUtil.getLong(
146                                            PropsKeys.UPLOAD_SERVLET_REQUEST_IMPL_MAX_SIZE));
147    
148                            LiferayServletRequest liferayServletRequest =
149                                    new LiferayServletRequest(request);
150    
151                            List<FileItem> fileItems = servletFileUpload.parseRequest(
152                                    liferayServletRequest);
153    
154                            Map<String, Object> fields = new HashMap<String, Object>();
155    
156                            for (FileItem fileItem : fileItems) {
157                                    if (fileItem.isFormField()) {
158                                            fields.put(fileItem.getFieldName(), fileItem.getString());
159                                    }
160                                    else {
161                                            fields.put(fileItem.getFieldName(), fileItem);
162                                    }
163                            }
164    
165                            DiskFileItem diskFileItem = (DiskFileItem)fields.get("NewFile");
166    
167                            String fileName = StringUtil.replace(
168                                    diskFileItem.getName(), CharPool.BACK_SLASH, CharPool.SLASH);
169                            String[] fileNameArray = StringUtil.split(fileName, '/');
170                            fileName = fileNameArray[fileNameArray.length - 1];
171    
172                            String contentType = diskFileItem.getContentType();
173    
174                            if (Validator.isNull(contentType) ||
175                                    contentType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
176    
177                                    contentType = MimeTypesUtil.getContentType(
178                                            diskFileItem.getStoreLocation());
179                            }
180    
181                            if (diskFileItem.isInMemory()) {
182                                    inputStream = diskFileItem.getInputStream();
183                            }
184                            else {
185                                    inputStream = new ByteArrayFileInputStream(
186                                            diskFileItem.getStoreLocation(),
187                                            LiferayFileItem.THRESHOLD_SIZE);
188                            }
189    
190                            long size = diskFileItem.getSize();
191    
192                            returnValue = fileUpload(
193                                    commandArgument, fileName, inputStream, contentType, size);
194                    }
195                    catch (Exception e) {
196                            FCKException fcke = null;
197    
198                            if (e instanceof FCKException) {
199                                    fcke = (FCKException)e;
200                            }
201                            else {
202                                    fcke = new FCKException(e);
203                            }
204    
205                            Throwable cause = fcke.getCause();
206    
207                            returnValue = "203";
208    
209                            if (cause != null) {
210                                    String causeString = GetterUtil.getString(cause.toString());
211    
212                                    if (causeString.contains("NoSuchFolderException")||
213                                            causeString.contains("NoSuchGroupException")) {
214    
215                                            returnValue = "204";
216                                    }
217                                    else if (causeString.contains("ImageNameException")) {
218                                            returnValue = "205";
219                                    }
220                                    else if (causeString.contains("FileExtensionException") ||
221                                                     causeString.contains("FileNameException")) {
222    
223                                            returnValue = "206";
224                                    }
225                                    else if (causeString.contains("PrincipalException")) {
226                                            returnValue = "207";
227                                    }
228                                    else if (causeString.contains("ImageSizeException") ||
229                                                     causeString.contains("FileSizeException")) {
230    
231                                            returnValue = "208";
232                                    }
233                                    else if (causeString.contains("SystemException")) {
234                                            returnValue = "209";
235                                    }
236                                    else {
237                                            throw fcke;
238                                    }
239                            }
240    
241                            _writeUploadResponse(returnValue, response);
242                    }
243                    finally {
244                            StreamUtil.cleanUp(inputStream);
245                    }
246    
247                    _writeUploadResponse(returnValue, response);
248            }
249    
250            public void getFolders(
251                    CommandArgument commandArgument, HttpServletRequest request,
252                    HttpServletResponse response) {
253    
254                    Document document = _createDocument();
255    
256                    Node rootNode = _createRoot(
257                            document, commandArgument.getCommand(), commandArgument.getType(),
258                            commandArgument.getCurrentFolder(), getPath(commandArgument));
259    
260                    getFolders(commandArgument, document, rootNode);
261    
262                    _writeDocument(document, response);
263            }
264    
265            public void getFoldersAndFiles(
266                    CommandArgument commandArgument, HttpServletRequest request,
267                    HttpServletResponse response) {
268    
269                    Document document = _createDocument();
270    
271                    Node rootNode = _createRoot(
272                            document, commandArgument.getCommand(), commandArgument.getType(),
273                            commandArgument.getCurrentFolder(), getPath(commandArgument));
274    
275                    getFoldersAndFiles(commandArgument, document, rootNode);
276    
277                    _writeDocument(document, response);
278            }
279    
280            protected abstract String createFolder(CommandArgument commandArgument);
281    
282            protected abstract String fileUpload(
283                    CommandArgument commandArgument, String fileName,
284                    InputStream inputStream, String contentType, long size);
285    
286            protected abstract void getFolders(
287                    CommandArgument commandArgument, Document document, Node rootNode);
288    
289            protected abstract void getFoldersAndFiles(
290                    CommandArgument commandArgument, Document document, Node rootNode);
291    
292            protected String getPath(CommandArgument commandArgument) {
293                    return StringPool.BLANK;
294            }
295    
296            protected void getRootFolders(
297                            CommandArgument commandArgument, Document document,
298                            Element foldersElement)
299                    throws Exception {
300    
301                    LinkedHashMap<String, Object> groupParams =
302                            new LinkedHashMap<String, Object>();
303    
304                    groupParams.put("usersGroups", new Long(commandArgument.getUserId()));
305    
306                    List<Group> groups = GroupLocalServiceUtil.search(
307                            commandArgument.getCompanyId(), null, null, groupParams,
308                            QueryUtil.ALL_POS, QueryUtil.ALL_POS);
309    
310                    List<Organization> userOrgs =
311                            OrganizationLocalServiceUtil.getUserOrganizations(
312                                    commandArgument.getUserId());
313    
314                    for (Organization organization : userOrgs) {
315                            groups.add(0, organization.getGroup());
316                    }
317    
318                    if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
319                            PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
320    
321                            Group userGroup = GroupLocalServiceUtil.getUserGroup(
322                                    commandArgument.getCompanyId(), commandArgument.getUserId());
323    
324                            groups.add(0, userGroup);
325                    }
326    
327                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
328                            commandArgument.getCompanyId());
329    
330                    groups.add(0, companyGroup);
331    
332                    ThemeDisplay themeDisplay = commandArgument.getThemeDisplay();
333    
334                    long scopeGroupId = themeDisplay.getScopeGroupId();
335    
336                    HttpServletRequest request = commandArgument.getHttpServletRequest();
337    
338                    String portletId = ParamUtil.getString(request, "p_p_id");
339    
340                    for (Group group : groups) {
341                            Element folderElement = document.createElement("Folder");
342    
343                            foldersElement.appendChild(folderElement);
344    
345                            boolean setNameAttribute = false;
346    
347                            if (group.hasStagingGroup()) {
348                                    Group stagingGroup = group.getStagingGroup();
349    
350                                    if ((stagingGroup.getGroupId() == scopeGroupId) &&
351                                            group.isStagedPortlet(portletId) &&
352                                            !group.isStagedRemotely() && isStagedData(group)) {
353    
354                                            folderElement.setAttribute(
355                                                    "name",
356                                                    stagingGroup.getGroupId() + " - " +
357                                                            HtmlUtil.escape(stagingGroup.getDescriptiveName()));
358    
359                                            setNameAttribute = true;
360                                    }
361                            }
362    
363                            if (!setNameAttribute) {
364                                    folderElement.setAttribute(
365                                            "name",
366                                            group.getGroupId() + " - " +
367                                                    HtmlUtil.escape(group.getDescriptiveName()));
368                            }
369                    }
370            }
371    
372            protected String getSize() {
373                    return getSize(0);
374            }
375    
376            protected String getSize(long size) {
377                    return String.valueOf(Math.ceil(size / 1000));
378            }
379    
380            protected boolean isStagedData(Group group) {
381                    return true;
382            }
383    
384            private Document _createDocument() {
385                    try {
386                            DocumentBuilderFactory documentBuilderFactory =
387                                    DocumentBuilderFactory.newInstance();
388    
389                            DocumentBuilder documentBuilder =
390                                    documentBuilderFactory.newDocumentBuilder();
391    
392                            return documentBuilder.newDocument();
393                    }
394                    catch (ParserConfigurationException pce) {
395                            throw new FCKException(pce);
396                    }
397            }
398    
399            private Node _createRoot(
400                    Document document, String command, String resourceType, String path,
401                    String url) {
402    
403                    Element rootElement = document.createElement("Connector");
404    
405                    document.appendChild(rootElement);
406    
407                    rootElement.setAttribute("command", command);
408                    rootElement.setAttribute("resourceType", resourceType);
409    
410                    Element currentFolderElement = document.createElement("CurrentFolder");
411    
412                    rootElement.appendChild(currentFolderElement);
413    
414                    currentFolderElement.setAttribute("path", path);
415                    currentFolderElement.setAttribute("url", url);
416    
417                    return rootElement;
418            }
419    
420            private void _writeDocument(
421                    Document document, HttpServletResponse response) {
422    
423                    try {
424                            Element documentElement = document.getDocumentElement();
425    
426                            documentElement.normalize();
427    
428                            TransformerFactory transformerFactory =
429                                    TransformerFactory.newInstance();
430    
431                            Transformer transformer = transformerFactory.newTransformer();
432    
433                            DOMSource domSource = new DOMSource(document);
434    
435                            if (_log.isDebugEnabled()) {
436                                    StreamResult streamResult = new StreamResult(System.out);
437    
438                                    transformer.transform(domSource, streamResult);
439                            }
440    
441                            response.setContentType("text/xml; charset=UTF-8");
442                            response.setHeader("Cache-Control", "no-cache");
443    
444                            PrintWriter printWriter = response.getWriter();
445    
446                            StreamResult streamResult = new StreamResult(printWriter);
447    
448                            transformer.transform(domSource, streamResult);
449    
450                            printWriter.flush();
451                            printWriter.close();
452                    }
453                    catch (Exception e) {
454                            throw new FCKException(e);
455                    }
456            }
457    
458            private void _writeUploadResponse(
459                    String returnValue, HttpServletResponse response) {
460    
461                    try {
462                            StringBundler sb = new StringBundler(7);
463    
464                            String newName = StringPool.BLANK;
465    
466                            sb.append("<script type=\"text/javascript\">");
467                            sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
468                            sb.append(returnValue);
469                            sb.append(",'");
470                            sb.append(newName);
471                            sb.append("');");
472                            sb.append("</script>");
473    
474                            response.setContentType("text/html; charset=UTF-8");
475                            response.setHeader("Cache-Control", "no-cache");
476    
477                            PrintWriter printWriter = null;
478    
479                            printWriter = response.getWriter();
480    
481                            printWriter.print(sb.toString());
482    
483                            printWriter.flush();
484                            printWriter.close();
485                    }
486                    catch (Exception e) {
487                            throw new FCKException(e);
488                    }
489            }
490    
491            private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
492    
493    }