001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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(
179                            fileItem.getName(), CharPool.BACK_SLASH, CharPool.SLASH);
180                    String[] fileNameArray = StringUtil.split(fileName, "/");
181                    fileName = fileNameArray[fileNameArray.length - 1];
182    
183                    String extension = _getExtension(fileName);
184    
185                    String returnValue = null;
186    
187                    try {
188                            returnValue = fileUpload(
189                                    argument, fileName, fileItem.getStoreLocation(), extension);
190                    }
191                    catch (FCKException fcke) {
192                            Throwable cause = fcke.getCause();
193    
194                            returnValue = "203";
195    
196                            if (cause != null) {
197                                    String causeString = GetterUtil.getString(cause.toString());
198    
199                                    if ((causeString.indexOf("NoSuchFolderException") != -1) ||
200                                            (causeString.indexOf("NoSuchGroupException") != -1)) {
201    
202                                            returnValue = "204";
203                                    }
204                                    else if (causeString.indexOf("ImageNameException") != -1) {
205                                            returnValue = "205";
206                                    }
207                                    else if (causeString.indexOf("FileNameException") != -1) {
208                                            returnValue = "206";
209                                    }
210                                    else if (causeString.indexOf("PrincipalException") != -1) {
211                                            returnValue = "207";
212                                    }
213                                    else {
214                                            throw fcke;
215                                    }
216                            }
217    
218                            _writeUploadResponse(returnValue, response);
219                    }
220    
221                    _writeUploadResponse(returnValue, response);
222            }
223    
224            protected abstract String createFolder(CommandArgument argument);
225    
226            protected abstract String fileUpload(
227                    CommandArgument argument, String fileName, File file, String extension);
228    
229            protected abstract void getFolders(
230                    CommandArgument argument, Document doc, Node root);
231    
232            protected abstract void getFoldersAndFiles(
233                    CommandArgument argument, Document doc, Node root);
234    
235            protected void getRootFolders(
236                            CommandArgument argument, Document doc, Element foldersEl)
237                    throws Exception {
238    
239                    LinkedHashMap<String, Object> groupParams =
240                            new LinkedHashMap<String, Object>();
241    
242                    groupParams.put("usersGroups", new Long(argument.getUserId()));
243    
244                    List<Group> groups = GroupLocalServiceUtil.search(
245                            argument.getCompanyId(), null, null, groupParams, QueryUtil.ALL_POS,
246                            QueryUtil.ALL_POS);
247    
248                    List<Organization> userOrgs =
249                            OrganizationLocalServiceUtil.getUserOrganizations(
250                                    argument.getUserId(), true);
251    
252                    for (Organization organization : userOrgs) {
253                            groups.add(0, organization.getGroup());
254                    }
255    
256                    if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
257                            PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
258    
259                            Group userGroup = GroupLocalServiceUtil.getUserGroup(
260                                    argument.getCompanyId(), argument.getUserId());
261    
262                            groups.add(0, userGroup);
263                    }
264    
265                    ThemeDisplay themeDisplay = argument.getThemeDisplay();
266    
267                    long scopeGroupId = themeDisplay.getScopeGroupId();
268    
269                    for (Group group : groups) {
270                            Element folderEl = doc.createElement("Folder");
271    
272                            foldersEl.appendChild(folderEl);
273    
274                            boolean setNameAttribute = false;
275    
276                            if (group.hasStagingGroup()) {
277                                    Group stagingGroup = group.getStagingGroup();
278    
279                                    if (stagingGroup.getGroupId() == scopeGroupId) {
280                                            folderEl.setAttribute(
281                                                    "name",
282                                                    stagingGroup.getGroupId() + " - " +
283                                                            HtmlUtil.escape(stagingGroup.getDescriptiveName()));
284    
285                                            setNameAttribute = true;
286                                    }
287                            }
288    
289                            if (!setNameAttribute) {
290                                    folderEl.setAttribute(
291                                            "name",
292                                            group.getGroupId() + " - " +
293                                                    HtmlUtil.escape(group.getDescriptiveName()));
294                            }
295                    }
296            }
297    
298            protected String getPath(CommandArgument argument) {
299                    return StringPool.BLANK;
300            }
301    
302            protected String getSize() {
303                    return getSize(0);
304            }
305    
306            protected String getSize(long size) {
307                    return String.valueOf(Math.ceil(size / 1000));
308            }
309    
310            private Document _createDocument() {
311                    try {
312                            Document doc = null;
313    
314                            DocumentBuilderFactory factory =
315                                    DocumentBuilderFactory.newInstance();
316    
317                            DocumentBuilder builder = null;
318    
319                            builder = factory.newDocumentBuilder();
320    
321                            doc = builder.newDocument();
322    
323                            return doc;
324                    }
325                    catch (ParserConfigurationException pce) {
326                            throw new FCKException(pce);
327                    }
328            }
329    
330            private Node _createRoot(
331                    Document doc, String commandStr, String typeStr, String currentPath,
332                    String currentUrl) {
333    
334                    Element root = doc.createElement("Connector");
335    
336                    doc.appendChild(root);
337    
338                    root.setAttribute("command", commandStr);
339                    root.setAttribute("resourceType", typeStr);
340    
341                    Element el = doc.createElement("CurrentFolder");
342    
343                    root.appendChild(el);
344    
345                    el.setAttribute("path", currentPath);
346                    el.setAttribute("url", currentUrl);
347    
348                    return root;
349            }
350    
351            private String _getExtension(String fileName) {
352                    return fileName.substring(fileName.lastIndexOf(CharPool.PERIOD) + 1);
353            }
354    
355            private void _writeDocument(Document doc, HttpServletResponse response) {
356                    try {
357                            doc.getDocumentElement().normalize();
358    
359                            TransformerFactory transformerFactory =
360                                    TransformerFactory.newInstance();
361    
362                            Transformer transformer = transformerFactory.newTransformer();
363    
364                            DOMSource source = new DOMSource(doc);
365    
366                            if (_log.isDebugEnabled()) {
367                                    StreamResult result = new StreamResult(System.out);
368    
369                                    transformer.transform(source, result);
370                            }
371    
372                            response.setContentType("text/xml; charset=UTF-8");
373                            response.setHeader("Cache-Control", "no-cache");
374    
375                            PrintWriter out = response.getWriter();
376    
377                            StreamResult result = new StreamResult(out);
378    
379                            transformer.transform(source, result);
380    
381                            out.flush();
382                            out.close();
383                    }
384                    catch (Exception e) {
385                            throw new FCKException(e);
386                    }
387            }
388    
389            private void _writeUploadResponse(
390                    String returnValue, HttpServletResponse response) {
391    
392                    try {
393                            StringBundler sb = new StringBundler(7);
394    
395                            String newName = StringPool.BLANK;
396    
397                            sb.append("<script type=\"text/javascript\">");
398                            sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
399                            sb.append(returnValue);
400                            sb.append(",'");
401                            sb.append(newName);
402                            sb.append("');");
403                            sb.append("</script>");
404    
405                            response.setContentType("text/html; charset=UTF-8");
406                            response.setHeader("Cache-Control", "no-cache");
407    
408                            PrintWriter out = null;
409    
410                            out = response.getWriter();
411    
412                            out.print(sb.toString());
413    
414                            out.flush();
415                            out.close();
416                    }
417                    catch (Exception e) {
418                            throw new FCKException(e);
419                    }
420            }
421    
422            private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
423    
424    }