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.StringBundler;
25  import com.liferay.portal.kernel.util.StringPool;
26  import com.liferay.portal.kernel.util.StringUtil;
27  import com.liferay.portal.model.Group;
28  import com.liferay.portal.model.Organization;
29  import com.liferay.portal.service.GroupLocalServiceUtil;
30  import com.liferay.portal.service.OrganizationLocalServiceUtil;
31  import com.liferay.portal.upload.LiferayFileItemFactory;
32  import com.liferay.portal.upload.UploadServletRequestImpl;
33  import com.liferay.portal.util.PropsValues;
34  
35  import java.io.File;
36  import java.io.PrintWriter;
37  
38  import java.util.HashMap;
39  import java.util.LinkedHashMap;
40  import java.util.List;
41  import java.util.Map;
42  
43  import javax.servlet.http.HttpServletRequest;
44  import javax.servlet.http.HttpServletResponse;
45  
46  import javax.xml.parsers.DocumentBuilder;
47  import javax.xml.parsers.DocumentBuilderFactory;
48  import javax.xml.parsers.ParserConfigurationException;
49  import javax.xml.transform.Transformer;
50  import javax.xml.transform.TransformerFactory;
51  import javax.xml.transform.dom.DOMSource;
52  import javax.xml.transform.stream.StreamResult;
53  
54  import org.apache.commons.fileupload.FileItem;
55  import org.apache.commons.fileupload.FileUploadException;
56  import org.apache.commons.fileupload.disk.DiskFileItem;
57  import org.apache.commons.fileupload.servlet.ServletFileUpload;
58  
59  import org.w3c.dom.Document;
60  import org.w3c.dom.Element;
61  import org.w3c.dom.Node;
62  
63  /**
64   * <a href="BaseCommandReceiver.java.html"><b><i>View Source</i></b></a>
65   *
66   * @author Ivica Cardic
67   */
68  public abstract class BaseCommandReceiver implements CommandReceiver {
69  
70      public void createFolder(
71          CommandArgument argument, HttpServletRequest request,
72          HttpServletResponse response) {
73  
74          Document doc = _createDocument();
75  
76          Node root = _createRoot(
77              doc, argument.getCommand(), argument.getType(),
78              argument.getCurrentFolder(), StringPool.BLANK);
79  
80          Element errorEl = doc.createElement("Error");
81  
82          root.appendChild(errorEl);
83  
84          String returnValue = "0";
85  
86          try {
87              returnValue = createFolder(argument);
88          }
89          catch (FCKException fcke) {
90              Throwable cause = fcke.getCause();
91  
92              returnValue = "110";
93  
94              if (cause != null) {
95                  String causeString = GetterUtil.getString(cause.toString());
96  
97                  if (causeString.indexOf("DuplicateFolderNameException") != -1) {
98                      returnValue = "101";
99                  }
100                 else if (causeString.indexOf("FolderNameException") != -1) {
101                     returnValue = "102";
102                 }
103                 else if (causeString.indexOf("NoSuchGroupException") != -1) {
104                     returnValue = "103";
105                 }
106                 else {
107                     throw fcke;
108                 }
109             }
110         }
111 
112         errorEl.setAttribute("number", returnValue);
113 
114         _writeDocument(doc, response);
115     }
116 
117     public void getFolders(
118         CommandArgument argument, HttpServletRequest request,
119         HttpServletResponse response) {
120 
121         Document doc = _createDocument();
122 
123         Node root = _createRoot(
124             doc, argument.getCommand(), argument.getType(),
125             argument.getCurrentFolder(), getPath(argument));
126 
127         getFolders(argument, doc, root);
128 
129         _writeDocument(doc, response);
130     }
131 
132     public void getFoldersAndFiles(
133         CommandArgument argument, HttpServletRequest request,
134         HttpServletResponse response) {
135 
136         Document doc = _createDocument();
137 
138         Node root = _createRoot(
139             doc, argument.getCommand(), argument.getType(),
140             argument.getCurrentFolder(), getPath(argument));
141 
142         getFoldersAndFiles(argument, doc, root);
143 
144         _writeDocument(doc, response);
145     }
146 
147     public void fileUpload(
148         CommandArgument argument, HttpServletRequest request,
149         HttpServletResponse response) {
150 
151         ServletFileUpload upload = new ServletFileUpload(
152             new LiferayFileItemFactory(
153                 UploadServletRequestImpl.DEFAULT_TEMP_DIR));
154 
155         List<FileItem> items = null;
156 
157         try {
158             items = upload.parseRequest(request);
159         }
160         catch (FileUploadException fue) {
161             throw new FCKException(fue);
162         }
163 
164         Map<String, Object> fields = new HashMap<String, Object>();
165 
166         for (FileItem item : items) {
167             if (item.isFormField()) {
168                 fields.put(item.getFieldName(), item.getString());
169             }
170             else {
171                 fields.put(item.getFieldName(), item);
172             }
173         }
174 
175         DiskFileItem fileItem = (DiskFileItem)fields.get("NewFile");
176 
177         String fileName = StringUtil.replace(fileItem.getName(), "\\", "/");
178         String[] fileNameArray = StringUtil.split(fileName, "/");
179         fileName = fileNameArray[fileNameArray.length - 1];
180 
181         String extension = _getExtension(fileName);
182 
183         String returnValue = null;
184 
185         try {
186             returnValue = fileUpload(
187                 argument, fileName, fileItem.getStoreLocation(), extension);
188         }
189         catch (FCKException fcke) {
190             Throwable cause = fcke.getCause();
191 
192             returnValue = "203";
193 
194             if (cause != null) {
195                 String causeString = GetterUtil.getString(cause.toString());
196 
197                 if ((causeString.indexOf("NoSuchFolderException") != -1) ||
198                     (causeString.indexOf("NoSuchGroupException") != -1)) {
199 
200                     returnValue = "204";
201                 }
202                 else if (causeString.indexOf("ImageNameException") != -1) {
203                     returnValue = "205";
204                 }
205                 else if (causeString.indexOf("FileNameException") != -1) {
206                     returnValue = "206";
207                 }
208                 else if (causeString.indexOf("PrincipalException") != -1) {
209                     returnValue = "207";
210                 }
211                 else {
212                     throw fcke;
213                 }
214             }
215 
216             _writeUploadResponse(returnValue, response);
217         }
218 
219         _writeUploadResponse(returnValue, response);
220     }
221 
222     protected abstract String createFolder(CommandArgument argument);
223 
224     protected abstract String fileUpload(
225         CommandArgument argument, String fileName, File file, String extension);
226 
227     protected abstract void getFolders(
228         CommandArgument argument, Document doc, Node root);
229 
230     protected abstract void getFoldersAndFiles(
231         CommandArgument argument, Document doc, Node root);
232 
233     protected void getRootFolders(
234             CommandArgument argument, Document doc, Element foldersEl)
235         throws Exception {
236 
237         LinkedHashMap<String, Object> groupParams =
238             new LinkedHashMap<String, Object>();
239 
240         groupParams.put("usersGroups", new Long(argument.getUserId()));
241 
242         List<Group> groups = GroupLocalServiceUtil.search(
243             argument.getCompanyId(), null, null, groupParams, QueryUtil.ALL_POS,
244             QueryUtil.ALL_POS);
245 
246         List<Organization> userOrgs =
247             OrganizationLocalServiceUtil.getUserOrganizations(
248                 argument.getUserId(), true);
249 
250         for (Organization organization : userOrgs) {
251             groups.add(0, organization.getGroup());
252         }
253 
254         if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
255             PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
256 
257             Group userGroup = GroupLocalServiceUtil.getUserGroup(
258                 argument.getCompanyId(), argument.getUserId());
259 
260             groups.add(0, userGroup);
261         }
262 
263         for (Group group : groups) {
264             Element folderEl = doc.createElement("Folder");
265 
266             foldersEl.appendChild(folderEl);
267 
268             folderEl.setAttribute(
269                 "name",
270                 group.getGroupId() + " - " + group.getDescriptiveName());
271         }
272     }
273 
274     protected String getPath(CommandArgument argument) {
275         return StringPool.BLANK;
276     }
277 
278     protected String getSize() {
279         return getSize(0);
280     }
281 
282     protected String getSize(int size) {
283         return String.valueOf(Math.ceil(size / 1000));
284     }
285 
286     private Document _createDocument() {
287         try {
288             Document doc = null;
289 
290             DocumentBuilderFactory factory =
291                 DocumentBuilderFactory.newInstance();
292 
293             DocumentBuilder builder = null;
294 
295             builder = factory.newDocumentBuilder();
296 
297             doc = builder.newDocument();
298 
299             return doc;
300         }
301         catch (ParserConfigurationException pce) {
302             throw new FCKException(pce);
303         }
304     }
305 
306     private Node _createRoot(
307         Document doc, String commandStr, String typeStr, String currentPath,
308         String currentUrl) {
309 
310         Element root = doc.createElement("Connector");
311 
312         doc.appendChild(root);
313 
314         root.setAttribute("command", commandStr);
315         root.setAttribute("resourceType", typeStr);
316 
317         Element el = doc.createElement("CurrentFolder");
318 
319         root.appendChild(el);
320 
321         el.setAttribute("path", currentPath);
322         el.setAttribute("url", currentUrl);
323 
324         return root;
325     }
326 
327     private String _getExtension(String fileName) {
328         return fileName.substring(fileName.lastIndexOf(".") + 1);
329     }
330 
331     private void _writeDocument(Document doc, HttpServletResponse response) {
332         try {
333             doc.getDocumentElement().normalize();
334 
335             TransformerFactory transformerFactory =
336                 TransformerFactory.newInstance();
337 
338             Transformer transformer = transformerFactory.newTransformer();
339 
340             DOMSource source = new DOMSource(doc);
341 
342             if (_log.isDebugEnabled()) {
343                 StreamResult result = new StreamResult(System.out);
344 
345                 transformer.transform(source, result);
346             }
347 
348             response.setContentType("text/xml; charset=UTF-8");
349             response.setHeader("Cache-Control", "no-cache");
350 
351             PrintWriter out = response.getWriter();
352 
353             StreamResult result = new StreamResult(out);
354 
355             transformer.transform(source, result);
356 
357             out.flush();
358             out.close();
359         }
360         catch (Exception e) {
361             throw new FCKException(e);
362         }
363     }
364 
365     private void _writeUploadResponse(
366         String returnValue, HttpServletResponse response) {
367 
368         try {
369             StringBundler sb = new StringBundler(7);
370 
371             String newName = StringPool.BLANK;
372 
373             sb.append("<script type=\"text/javascript\">");
374             sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
375             sb.append(returnValue);
376             sb.append(",'");
377             sb.append(newName);
378             sb.append("');");
379             sb.append("</script>");
380 
381             response.setContentType("text/html; charset=UTF-8");
382             response.setHeader("Cache-Control", "no-cache");
383 
384             PrintWriter out = null;
385 
386             out = response.getWriter();
387 
388             out.print(sb.toString());
389 
390             out.flush();
391             out.close();
392         }
393         catch (Exception e) {
394             throw new FCKException(e);
395         }
396     }
397 
398     private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
399 
400 }