001    /**
002     * Copyright (c) 2000-2011 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 getFolders(
132                    CommandArgument commandArgument, HttpServletRequest request,
133                    HttpServletResponse response) {
134    
135                    Document document = _createDocument();
136    
137                    Node rootNode = _createRoot(
138                            document, commandArgument.getCommand(), commandArgument.getType(),
139                            commandArgument.getCurrentFolder(), getPath(commandArgument));
140    
141                    getFolders(commandArgument, document, rootNode);
142    
143                    _writeDocument(document, response);
144            }
145    
146            public void getFoldersAndFiles(
147                    CommandArgument commandArgument, HttpServletRequest request,
148                    HttpServletResponse response) {
149    
150                    Document document = _createDocument();
151    
152                    Node rootNode = _createRoot(
153                            document, commandArgument.getCommand(), commandArgument.getType(),
154                            commandArgument.getCurrentFolder(), getPath(commandArgument));
155    
156                    getFoldersAndFiles(commandArgument, document, rootNode);
157    
158                    _writeDocument(document, response);
159            }
160    
161            public void fileUpload(
162                    CommandArgument commandArgument, HttpServletRequest request,
163                    HttpServletResponse response) {
164    
165                    InputStream inputStream = null;
166    
167                    String returnValue = null;
168    
169                    try {
170                            ServletFileUpload servletFileUpload = new LiferayFileUpload(
171                                    new LiferayFileItemFactory(
172                                            UploadServletRequestImpl.getTempDir()), request);
173    
174                            servletFileUpload.setFileSizeMax(
175                                    PrefsPropsUtil.getLong(
176                                            PropsKeys.UPLOAD_SERVLET_REQUEST_IMPL_MAX_SIZE));
177    
178                            LiferayServletRequest liferayServletRequest =
179                                    new LiferayServletRequest(request);
180    
181                            List<FileItem> fileItems = servletFileUpload.parseRequest(
182                                    liferayServletRequest);
183    
184                            Map<String, Object> fields = new HashMap<String, Object>();
185    
186                            for (FileItem fileItem : fileItems) {
187                                    if (fileItem.isFormField()) {
188                                            fields.put(fileItem.getFieldName(), fileItem.getString());
189                                    }
190                                    else {
191                                            fields.put(fileItem.getFieldName(), fileItem);
192                                    }
193                            }
194    
195                            DiskFileItem diskFileItem = (DiskFileItem)fields.get("NewFile");
196    
197                            String fileName = StringUtil.replace(
198                                    diskFileItem.getName(), CharPool.BACK_SLASH, CharPool.SLASH);
199                            String[] fileNameArray = StringUtil.split(fileName, '/');
200                            fileName = fileNameArray[fileNameArray.length - 1];
201    
202                            String contentType = diskFileItem.getContentType();
203    
204                            if (Validator.isNull(contentType) ||
205                                    contentType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
206    
207                                    contentType = MimeTypesUtil.getContentType(
208                                            diskFileItem.getStoreLocation());
209                            }
210    
211                            if (diskFileItem.isInMemory()) {
212                                    inputStream = diskFileItem.getInputStream();
213                            }
214                            else {
215                                    inputStream = new ByteArrayFileInputStream(
216                                            diskFileItem.getStoreLocation(),
217                                            LiferayFileItem.THRESHOLD_SIZE);
218                            }
219    
220                            long size = diskFileItem.getSize();
221    
222                            returnValue = fileUpload(
223                                    commandArgument, fileName, inputStream, contentType, size);
224                    }
225                    catch (Exception e) {
226                            FCKException fcke = null;
227    
228                            if (e instanceof FCKException) {
229                                    fcke = (FCKException)e;
230                            }
231                            else {
232                                    fcke = new FCKException(e);
233                            }
234    
235                            Throwable cause = fcke.getCause();
236    
237                            returnValue = "203";
238    
239                            if (cause != null) {
240                                    String causeString = GetterUtil.getString(cause.toString());
241    
242                                    if (causeString.contains("NoSuchFolderException")||
243                                            causeString.contains("NoSuchGroupException")) {
244    
245                                            returnValue = "204";
246                                    }
247                                    else if (causeString.contains("ImageNameException")) {
248                                            returnValue = "205";
249                                    }
250                                    else if (causeString.contains("FileExtensionException") ||
251                                                     causeString.contains("FileNameException")) {
252    
253                                            returnValue = "206";
254                                    }
255                                    else if (causeString.contains("PrincipalException")) {
256                                            returnValue = "207";
257                                    }
258                                    else if (causeString.contains("ImageSizeException") ||
259                                                     causeString.contains("FileSizeException")) {
260    
261                                            returnValue = "208";
262                                    }
263                                    else if (causeString.contains("SystemException")) {
264                                            returnValue = "209";
265                                    }
266                                    else {
267                                            throw fcke;
268                                    }
269                            }
270    
271                            _writeUploadResponse(returnValue, response);
272                    }
273                    finally {
274                            StreamUtil.cleanUp(inputStream);
275                    }
276    
277                    _writeUploadResponse(returnValue, 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 void getRootFolders(
293                            CommandArgument commandArgument, Document document,
294                            Element foldersElement)
295                    throws Exception {
296    
297                    LinkedHashMap<String, Object> groupParams =
298                            new LinkedHashMap<String, Object>();
299    
300                    groupParams.put("usersGroups", new Long(commandArgument.getUserId()));
301    
302                    List<Group> groups = GroupLocalServiceUtil.search(
303                            commandArgument.getCompanyId(), null, null, groupParams,
304                            QueryUtil.ALL_POS, QueryUtil.ALL_POS);
305    
306                    List<Organization> userOrgs =
307                            OrganizationLocalServiceUtil.getUserOrganizations(
308                                    commandArgument.getUserId());
309    
310                    for (Organization organization : userOrgs) {
311                            groups.add(0, organization.getGroup());
312                    }
313    
314                    if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
315                            PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
316    
317                            Group userGroup = GroupLocalServiceUtil.getUserGroup(
318                                    commandArgument.getCompanyId(), commandArgument.getUserId());
319    
320                            groups.add(0, userGroup);
321                    }
322    
323                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
324                            commandArgument.getCompanyId());
325    
326                    groups.add(0, companyGroup);
327    
328                    ThemeDisplay themeDisplay = commandArgument.getThemeDisplay();
329    
330                    long scopeGroupId = themeDisplay.getScopeGroupId();
331    
332                    HttpServletRequest request = commandArgument.getHttpServletRequest();
333    
334                    String portletId = ParamUtil.getString(request, "p_p_id");
335    
336                    for (Group group : groups) {
337                            Element folderElement = document.createElement("Folder");
338    
339                            foldersElement.appendChild(folderElement);
340    
341                            boolean setNameAttribute = false;
342    
343                            if (group.hasStagingGroup()) {
344                                    Group stagingGroup = group.getStagingGroup();
345    
346                                    if ((stagingGroup.getGroupId() == scopeGroupId) &&
347                                            group.isStagedPortlet(portletId) &&
348                                            !group.isStagedRemotely() && isStagedData(group)) {
349    
350                                            folderElement.setAttribute(
351                                                    "name",
352                                                    stagingGroup.getGroupId() + " - " +
353                                                            HtmlUtil.escape(stagingGroup.getDescriptiveName()));
354    
355                                            setNameAttribute = true;
356                                    }
357                            }
358    
359                            if (!setNameAttribute) {
360                                    folderElement.setAttribute(
361                                            "name",
362                                            group.getGroupId() + " - " +
363                                                    HtmlUtil.escape(group.getDescriptiveName()));
364                            }
365                    }
366            }
367    
368            protected String getPath(CommandArgument commandArgument) {
369                    return StringPool.BLANK;
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,
401                    String path, 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    }