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             if (group.hasStagingGroup()) {
270                 Group stagingGroup = group.getStagingGroup();
271 
272                 folderEl.setAttribute(
273                     "name",
274                     stagingGroup.getGroupId() + " - " +
275                         HtmlUtil.escape(stagingGroup.getDescriptiveName()));
276             }
277             else {
278                 folderEl.setAttribute(
279                     "name",
280                     group.getGroupId() + " - " +
281                         HtmlUtil.escape(group.getDescriptiveName()));
282             }
283         }
284     }
285 
286     protected String getPath(CommandArgument argument) {
287         return StringPool.BLANK;
288     }
289 
290     protected String getSize() {
291         return getSize(0);
292     }
293 
294     protected String getSize(long size) {
295         return String.valueOf(Math.ceil(size / 1000));
296     }
297 
298     private Document _createDocument() {
299         try {
300             Document doc = null;
301 
302             DocumentBuilderFactory factory =
303                 DocumentBuilderFactory.newInstance();
304 
305             DocumentBuilder builder = null;
306 
307             builder = factory.newDocumentBuilder();
308 
309             doc = builder.newDocument();
310 
311             return doc;
312         }
313         catch (ParserConfigurationException pce) {
314             throw new FCKException(pce);
315         }
316     }
317 
318     private Node _createRoot(
319         Document doc, String commandStr, String typeStr, String currentPath,
320         String currentUrl) {
321 
322         Element root = doc.createElement("Connector");
323 
324         doc.appendChild(root);
325 
326         root.setAttribute("command", commandStr);
327         root.setAttribute("resourceType", typeStr);
328 
329         Element el = doc.createElement("CurrentFolder");
330 
331         root.appendChild(el);
332 
333         el.setAttribute("path", currentPath);
334         el.setAttribute("url", currentUrl);
335 
336         return root;
337     }
338 
339     private String _getExtension(String fileName) {
340         return fileName.substring(fileName.lastIndexOf(".") + 1);
341     }
342 
343     private void _writeDocument(Document doc, HttpServletResponse response) {
344         try {
345             doc.getDocumentElement().normalize();
346 
347             TransformerFactory transformerFactory =
348                 TransformerFactory.newInstance();
349 
350             Transformer transformer = transformerFactory.newTransformer();
351 
352             DOMSource source = new DOMSource(doc);
353 
354             if (_log.isDebugEnabled()) {
355                 StreamResult result = new StreamResult(System.out);
356 
357                 transformer.transform(source, result);
358             }
359 
360             response.setContentType("text/xml; charset=UTF-8");
361             response.setHeader("Cache-Control", "no-cache");
362 
363             PrintWriter out = response.getWriter();
364 
365             StreamResult result = new StreamResult(out);
366 
367             transformer.transform(source, result);
368 
369             out.flush();
370             out.close();
371         }
372         catch (Exception e) {
373             throw new FCKException(e);
374         }
375     }
376 
377     private void _writeUploadResponse(
378         String returnValue, HttpServletResponse response) {
379 
380         try {
381             StringBundler sb = new StringBundler(7);
382 
383             String newName = StringPool.BLANK;
384 
385             sb.append("<script type=\"text/javascript\">");
386             sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
387             sb.append(returnValue);
388             sb.append(",'");
389             sb.append(newName);
390             sb.append("');");
391             sb.append("</script>");
392 
393             response.setContentType("text/html; charset=UTF-8");
394             response.setHeader("Cache-Control", "no-cache");
395 
396             PrintWriter out = null;
397 
398             out = response.getWriter();
399 
400             out.print(sb.toString());
401 
402             out.flush();
403             out.close();
404         }
405         catch (Exception e) {
406             throw new FCKException(e);
407         }
408     }
409 
410     private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
411 
412 }