1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.editor.fckeditor.receiver.impl;
16  
17  import com.liferay.portal.editor.fckeditor.command.CommandArgument;
18  import com.liferay.portal.editor.fckeditor.exception.FCKException;
19  import com.liferay.portal.editor.fckeditor.receiver.CommandReceiver;
20  import com.liferay.portal.kernel.dao.orm.QueryUtil;
21  import com.liferay.portal.kernel.log.Log;
22  import com.liferay.portal.kernel.log.LogFactoryUtil;
23  import com.liferay.portal.kernel.util.GetterUtil;
24  import com.liferay.portal.kernel.util.HtmlUtil;
25  import com.liferay.portal.kernel.util.StringBundler;
26  import com.liferay.portal.kernel.util.StringPool;
27  import com.liferay.portal.kernel.util.StringUtil;
28  import com.liferay.portal.model.Group;
29  import com.liferay.portal.model.Organization;
30  import com.liferay.portal.service.GroupLocalServiceUtil;
31  import com.liferay.portal.service.OrganizationLocalServiceUtil;
32  import com.liferay.portal.upload.LiferayFileItemFactory;
33  import com.liferay.portal.upload.UploadServletRequestImpl;
34  import com.liferay.portal.util.PropsValues;
35  
36  import java.io.File;
37  import java.io.PrintWriter;
38  
39  import java.util.HashMap;
40  import java.util.LinkedHashMap;
41  import java.util.List;
42  import java.util.Map;
43  
44  import javax.servlet.http.HttpServletRequest;
45  import javax.servlet.http.HttpServletResponse;
46  
47  import javax.xml.parsers.DocumentBuilder;
48  import javax.xml.parsers.DocumentBuilderFactory;
49  import javax.xml.parsers.ParserConfigurationException;
50  import javax.xml.transform.Transformer;
51  import javax.xml.transform.TransformerFactory;
52  import javax.xml.transform.dom.DOMSource;
53  import javax.xml.transform.stream.StreamResult;
54  
55  import org.apache.commons.fileupload.FileItem;
56  import org.apache.commons.fileupload.FileUploadException;
57  import org.apache.commons.fileupload.disk.DiskFileItem;
58  import org.apache.commons.fileupload.servlet.ServletFileUpload;
59  
60  import org.w3c.dom.Document;
61  import org.w3c.dom.Element;
62  import org.w3c.dom.Node;
63  
64  /**
65   * <a href="BaseCommandReceiver.java.html"><b><i>View Source</i></b></a>
66   *
67   * @author Ivica Cardic
68   */
69  public abstract class BaseCommandReceiver implements CommandReceiver {
70  
71      public void createFolder(
72          CommandArgument argument, HttpServletRequest request,
73          HttpServletResponse response) {
74  
75          Document doc = _createDocument();
76  
77          Node root = _createRoot(
78              doc, argument.getCommand(), argument.getType(),
79              argument.getCurrentFolder(), StringPool.BLANK);
80  
81          Element errorEl = doc.createElement("Error");
82  
83          root.appendChild(errorEl);
84  
85          String returnValue = "0";
86  
87          try {
88              returnValue = createFolder(argument);
89          }
90          catch (FCKException fcke) {
91              Throwable cause = fcke.getCause();
92  
93              returnValue = "110";
94  
95              if (cause != null) {
96                  String causeString = GetterUtil.getString(cause.toString());
97  
98                  if (causeString.indexOf("DuplicateFolderNameException") != -1) {
99                      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         for (Group group : groups) {
265             Element folderEl = doc.createElement("Folder");
266 
267             foldersEl.appendChild(folderEl);
268 
269             folderEl.setAttribute(
270                 "name",
271                 group.getGroupId() + " - " +
272                     HtmlUtil.escape(group.getDescriptiveName()));
273         }
274     }
275 
276     protected String getPath(CommandArgument argument) {
277         return StringPool.BLANK;
278     }
279 
280     protected String getSize() {
281         return getSize(0);
282     }
283 
284     protected String getSize(long size) {
285         return String.valueOf(Math.ceil(size / 1000));
286     }
287 
288     private Document _createDocument() {
289         try {
290             Document doc = null;
291 
292             DocumentBuilderFactory factory =
293                 DocumentBuilderFactory.newInstance();
294 
295             DocumentBuilder builder = null;
296 
297             builder = factory.newDocumentBuilder();
298 
299             doc = builder.newDocument();
300 
301             return doc;
302         }
303         catch (ParserConfigurationException pce) {
304             throw new FCKException(pce);
305         }
306     }
307 
308     private Node _createRoot(
309         Document doc, String commandStr, String typeStr, String currentPath,
310         String currentUrl) {
311 
312         Element root = doc.createElement("Connector");
313 
314         doc.appendChild(root);
315 
316         root.setAttribute("command", commandStr);
317         root.setAttribute("resourceType", typeStr);
318 
319         Element el = doc.createElement("CurrentFolder");
320 
321         root.appendChild(el);
322 
323         el.setAttribute("path", currentPath);
324         el.setAttribute("url", currentUrl);
325 
326         return root;
327     }
328 
329     private String _getExtension(String fileName) {
330         return fileName.substring(fileName.lastIndexOf(".") + 1);
331     }
332 
333     private void _writeDocument(Document doc, HttpServletResponse response) {
334         try {
335             doc.getDocumentElement().normalize();
336 
337             TransformerFactory transformerFactory =
338                 TransformerFactory.newInstance();
339 
340             Transformer transformer = transformerFactory.newTransformer();
341 
342             DOMSource source = new DOMSource(doc);
343 
344             if (_log.isDebugEnabled()) {
345                 StreamResult result = new StreamResult(System.out);
346 
347                 transformer.transform(source, result);
348             }
349 
350             response.setContentType("text/xml; charset=UTF-8");
351             response.setHeader("Cache-Control", "no-cache");
352 
353             PrintWriter out = response.getWriter();
354 
355             StreamResult result = new StreamResult(out);
356 
357             transformer.transform(source, result);
358 
359             out.flush();
360             out.close();
361         }
362         catch (Exception e) {
363             throw new FCKException(e);
364         }
365     }
366 
367     private void _writeUploadResponse(
368         String returnValue, HttpServletResponse response) {
369 
370         try {
371             StringBundler sb = new StringBundler(7);
372 
373             String newName = StringPool.BLANK;
374 
375             sb.append("<script type=\"text/javascript\">");
376             sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
377             sb.append(returnValue);
378             sb.append(",'");
379             sb.append(newName);
380             sb.append("');");
381             sb.append("</script>");
382 
383             response.setContentType("text/html; charset=UTF-8");
384             response.setHeader("Cache-Control", "no-cache");
385 
386             PrintWriter out = null;
387 
388             out = response.getWriter();
389 
390             out.print(sb.toString());
391 
392             out.flush();
393             out.close();
394         }
395         catch (Exception e) {
396             throw new FCKException(e);
397         }
398     }
399 
400     private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
401 
402 }