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