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.log.Log;
022    import com.liferay.portal.kernel.log.LogFactoryUtil;
023    import com.liferay.portal.kernel.util.CharPool;
024    import com.liferay.portal.kernel.util.GetterUtil;
025    import com.liferay.portal.kernel.util.HtmlUtil;
026    import com.liferay.portal.kernel.util.StringBundler;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.model.Group;
030    import com.liferay.portal.model.Organization;
031    import com.liferay.portal.service.GroupLocalServiceUtil;
032    import com.liferay.portal.service.OrganizationLocalServiceUtil;
033    import com.liferay.portal.theme.ThemeDisplay;
034    import com.liferay.portal.upload.LiferayFileItemFactory;
035    import com.liferay.portal.upload.UploadServletRequestImpl;
036    import com.liferay.portal.util.PropsValues;
037    
038    import java.io.File;
039    import java.io.PrintWriter;
040    
041    import java.util.HashMap;
042    import java.util.LinkedHashMap;
043    import java.util.List;
044    import java.util.Map;
045    
046    import javax.servlet.http.HttpServletRequest;
047    import javax.servlet.http.HttpServletResponse;
048    
049    import javax.xml.parsers.DocumentBuilder;
050    import javax.xml.parsers.DocumentBuilderFactory;
051    import javax.xml.parsers.ParserConfigurationException;
052    import javax.xml.transform.Transformer;
053    import javax.xml.transform.TransformerFactory;
054    import javax.xml.transform.dom.DOMSource;
055    import javax.xml.transform.stream.StreamResult;
056    
057    import org.apache.commons.fileupload.FileItem;
058    import org.apache.commons.fileupload.FileUploadException;
059    import org.apache.commons.fileupload.disk.DiskFileItem;
060    import org.apache.commons.fileupload.servlet.ServletFileUpload;
061    
062    import org.w3c.dom.Document;
063    import org.w3c.dom.Element;
064    import org.w3c.dom.Node;
065    
066    /**
067     * @author Ivica Cardic
068     */
069    public abstract class BaseCommandReceiver implements CommandReceiver {
070    
071            public void createFolder(
072                    CommandArgument argument, HttpServletRequest request,
073                    HttpServletResponse response) {
074    
075                    Document doc = _createDocument();
076    
077                    Node root = _createRoot(
078                            doc, argument.getCommand(), argument.getType(),
079                            argument.getCurrentFolder(), StringPool.BLANK);
080    
081                    Element errorEl = doc.createElement("Error");
082    
083                    root.appendChild(errorEl);
084    
085                    String returnValue = "0";
086    
087                    try {
088                            returnValue = createFolder(argument);
089                    }
090                    catch (FCKException fcke) {
091                            Throwable cause = fcke.getCause();
092    
093                            returnValue = "110";
094    
095                            if (cause != null) {
096                                    String causeString = GetterUtil.getString(cause.toString());
097    
098                                    if (causeString.indexOf("DuplicateFolderNameException") != -1) {
099                                            returnValue = "101";
100                                    }
101                                    else if (causeString.indexOf("FolderNameException") != -1) {
102                                            returnValue = "102";
103                                    }
104                                    else if (causeString.indexOf("NoSuchGroupException") != -1) {
105                                            returnValue = "103";
106                                    }
107                                    else {
108                                            throw fcke;
109                                    }
110                            }
111                    }
112    
113                    errorEl.setAttribute("number", returnValue);
114    
115                    _writeDocument(doc, response);
116            }
117    
118            public void getFolders(
119                    CommandArgument argument, HttpServletRequest request,
120                    HttpServletResponse response) {
121    
122                    Document doc = _createDocument();
123    
124                    Node root = _createRoot(
125                            doc, argument.getCommand(), argument.getType(),
126                            argument.getCurrentFolder(), getPath(argument));
127    
128                    getFolders(argument, doc, root);
129    
130                    _writeDocument(doc, response);
131            }
132    
133            public void getFoldersAndFiles(
134                    CommandArgument argument, HttpServletRequest request,
135                    HttpServletResponse response) {
136    
137                    Document doc = _createDocument();
138    
139                    Node root = _createRoot(
140                            doc, argument.getCommand(), argument.getType(),
141                            argument.getCurrentFolder(), getPath(argument));
142    
143                    getFoldersAndFiles(argument, doc, root);
144    
145                    _writeDocument(doc, response);
146            }
147    
148            public void fileUpload(
149                    CommandArgument argument, HttpServletRequest request,
150                    HttpServletResponse response) {
151    
152                    ServletFileUpload upload = new ServletFileUpload(
153                            new LiferayFileItemFactory(
154                                    UploadServletRequestImpl.DEFAULT_TEMP_DIR));
155    
156                    List<FileItem> items = null;
157    
158                    try {
159                            items = upload.parseRequest(request);
160                    }
161                    catch (FileUploadException fue) {
162                            throw new FCKException(fue);
163                    }
164    
165                    Map<String, Object> fields = new HashMap<String, Object>();
166    
167                    for (FileItem item : items) {
168                            if (item.isFormField()) {
169                                    fields.put(item.getFieldName(), item.getString());
170                            }
171                            else {
172                                    fields.put(item.getFieldName(), item);
173                            }
174                    }
175    
176                    DiskFileItem fileItem = (DiskFileItem)fields.get("NewFile");
177    
178                    String fileName = StringUtil.replace(fileItem.getName(), "\\", "/");
179                    String[] fileNameArray = StringUtil.split(fileName, "/");
180                    fileName = fileNameArray[fileNameArray.length - 1];
181    
182                    String extension = _getExtension(fileName);
183    
184                    String returnValue = null;
185    
186                    try {
187                            returnValue = fileUpload(
188                                    argument, fileName, fileItem.getStoreLocation(), extension);
189                    }
190                    catch (FCKException fcke) {
191                            Throwable cause = fcke.getCause();
192    
193                            returnValue = "203";
194    
195                            if (cause != null) {
196                                    String causeString = GetterUtil.getString(cause.toString());
197    
198                                    if ((causeString.indexOf("NoSuchFolderException") != -1) ||
199                                            (causeString.indexOf("NoSuchGroupException") != -1)) {
200    
201                                            returnValue = "204";
202                                    }
203                                    else if (causeString.indexOf("ImageNameException") != -1) {
204                                            returnValue = "205";
205                                    }
206                                    else if (causeString.indexOf("FileNameException") != -1) {
207                                            returnValue = "206";
208                                    }
209                                    else if (causeString.indexOf("PrincipalException") != -1) {
210                                            returnValue = "207";
211                                    }
212                                    else {
213                                            throw fcke;
214                                    }
215                            }
216    
217                            _writeUploadResponse(returnValue, response);
218                    }
219    
220                    _writeUploadResponse(returnValue, response);
221            }
222    
223            protected abstract String createFolder(CommandArgument argument);
224    
225            protected abstract String fileUpload(
226                    CommandArgument argument, String fileName, File file, String extension);
227    
228            protected abstract void getFolders(
229                    CommandArgument argument, Document doc, Node root);
230    
231            protected abstract void getFoldersAndFiles(
232                    CommandArgument argument, Document doc, Node root);
233    
234            protected void getRootFolders(
235                            CommandArgument argument, Document doc, Element foldersEl)
236                    throws Exception {
237    
238                    LinkedHashMap<String, Object> groupParams =
239                            new LinkedHashMap<String, Object>();
240    
241                    groupParams.put("usersGroups", new Long(argument.getUserId()));
242    
243                    List<Group> groups = GroupLocalServiceUtil.search(
244                            argument.getCompanyId(), null, null, groupParams, QueryUtil.ALL_POS,
245                            QueryUtil.ALL_POS);
246    
247                    List<Organization> userOrgs =
248                            OrganizationLocalServiceUtil.getUserOrganizations(
249                                    argument.getUserId(), true);
250    
251                    for (Organization organization : userOrgs) {
252                            groups.add(0, organization.getGroup());
253                    }
254    
255                    if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
256                            PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
257    
258                            Group userGroup = GroupLocalServiceUtil.getUserGroup(
259                                    argument.getCompanyId(), argument.getUserId());
260    
261                            groups.add(0, userGroup);
262                    }
263    
264                    ThemeDisplay themeDisplay = argument.getThemeDisplay();
265    
266                    long scopeGroupId = themeDisplay.getScopeGroupId();
267    
268                    for (Group group : groups) {
269                            Element folderEl = doc.createElement("Folder");
270    
271                            foldersEl.appendChild(folderEl);
272    
273                            boolean setNameAttribute = false;
274    
275                            if (group.hasStagingGroup()) {
276                                    Group stagingGroup = group.getStagingGroup();
277    
278                                    if (stagingGroup.getGroupId() == scopeGroupId) {
279                                            folderEl.setAttribute(
280                                                    "name",
281                                                    stagingGroup.getGroupId() + " - " +
282                                                            HtmlUtil.escape(stagingGroup.getDescriptiveName()));
283    
284                                            setNameAttribute = true;
285                                    }
286                            }
287    
288                            if (!setNameAttribute) {
289                                    folderEl.setAttribute(
290                                            "name",
291                                            group.getGroupId() + " - " +
292                                                    HtmlUtil.escape(group.getDescriptiveName()));
293                            }
294                    }
295            }
296    
297            protected String getPath(CommandArgument argument) {
298                    return StringPool.BLANK;
299            }
300    
301            protected String getSize() {
302                    return getSize(0);
303            }
304    
305            protected String getSize(long size) {
306                    return String.valueOf(Math.ceil(size / 1000));
307            }
308    
309            private Document _createDocument() {
310                    try {
311                            Document doc = null;
312    
313                            DocumentBuilderFactory factory =
314                                    DocumentBuilderFactory.newInstance();
315    
316                            DocumentBuilder builder = null;
317    
318                            builder = factory.newDocumentBuilder();
319    
320                            doc = builder.newDocument();
321    
322                            return doc;
323                    }
324                    catch (ParserConfigurationException pce) {
325                            throw new FCKException(pce);
326                    }
327            }
328    
329            private Node _createRoot(
330                    Document doc, String commandStr, String typeStr, String currentPath,
331                    String currentUrl) {
332    
333                    Element root = doc.createElement("Connector");
334    
335                    doc.appendChild(root);
336    
337                    root.setAttribute("command", commandStr);
338                    root.setAttribute("resourceType", typeStr);
339    
340                    Element el = doc.createElement("CurrentFolder");
341    
342                    root.appendChild(el);
343    
344                    el.setAttribute("path", currentPath);
345                    el.setAttribute("url", currentUrl);
346    
347                    return root;
348            }
349    
350            private String _getExtension(String fileName) {
351                    return fileName.substring(fileName.lastIndexOf(CharPool.PERIOD) + 1);
352            }
353    
354            private void _writeDocument(Document doc, HttpServletResponse response) {
355                    try {
356                            doc.getDocumentElement().normalize();
357    
358                            TransformerFactory transformerFactory =
359                                    TransformerFactory.newInstance();
360    
361                            Transformer transformer = transformerFactory.newTransformer();
362    
363                            DOMSource source = new DOMSource(doc);
364    
365                            if (_log.isDebugEnabled()) {
366                                    StreamResult result = new StreamResult(System.out);
367    
368                                    transformer.transform(source, result);
369                            }
370    
371                            response.setContentType("text/xml; charset=UTF-8");
372                            response.setHeader("Cache-Control", "no-cache");
373    
374                            PrintWriter out = response.getWriter();
375    
376                            StreamResult result = new StreamResult(out);
377    
378                            transformer.transform(source, result);
379    
380                            out.flush();
381                            out.close();
382                    }
383                    catch (Exception e) {
384                            throw new FCKException(e);
385                    }
386            }
387    
388            private void _writeUploadResponse(
389                    String returnValue, HttpServletResponse response) {
390    
391                    try {
392                            StringBundler sb = new StringBundler(7);
393    
394                            String newName = StringPool.BLANK;
395    
396                            sb.append("<script type=\"text/javascript\">");
397                            sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
398                            sb.append(returnValue);
399                            sb.append(",'");
400                            sb.append(newName);
401                            sb.append("');");
402                            sb.append("</script>");
403    
404                            response.setContentType("text/html; charset=UTF-8");
405                            response.setHeader("Cache-Control", "no-cache");
406    
407                            PrintWriter out = null;
408    
409                            out = response.getWriter();
410    
411                            out.print(sb.toString());
412    
413                            out.flush();
414                            out.close();
415                    }
416                    catch (Exception e) {
417                            throw new FCKException(e);
418                    }
419            }
420    
421            private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
422    
423    }