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