001
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.io.ByteArrayFileInputStream;
022 import com.liferay.portal.kernel.log.Log;
023 import com.liferay.portal.kernel.log.LogFactoryUtil;
024 import com.liferay.portal.kernel.util.CharPool;
025 import com.liferay.portal.kernel.util.ContentTypes;
026 import com.liferay.portal.kernel.util.GetterUtil;
027 import com.liferay.portal.kernel.util.HtmlUtil;
028 import com.liferay.portal.kernel.util.MimeTypesUtil;
029 import com.liferay.portal.kernel.util.ParamUtil;
030 import com.liferay.portal.kernel.util.PropsKeys;
031 import com.liferay.portal.kernel.util.StreamUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.UniqueList;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.model.Group;
038 import com.liferay.portal.model.Organization;
039 import com.liferay.portal.service.GroupLocalServiceUtil;
040 import com.liferay.portal.service.OrganizationLocalServiceUtil;
041 import com.liferay.portal.theme.ThemeDisplay;
042 import com.liferay.portal.upload.LiferayFileItem;
043 import com.liferay.portal.upload.LiferayFileItemFactory;
044 import com.liferay.portal.upload.LiferayFileUpload;
045 import com.liferay.portal.upload.LiferayServletRequest;
046 import com.liferay.portal.upload.UploadServletRequestImpl;
047 import com.liferay.portal.util.PrefsPropsUtil;
048 import com.liferay.portal.util.PropsValues;
049
050 import java.io.InputStream;
051 import java.io.PrintWriter;
052
053 import java.util.HashMap;
054 import java.util.LinkedHashMap;
055 import java.util.List;
056 import java.util.Map;
057
058 import javax.servlet.http.HttpServletRequest;
059 import javax.servlet.http.HttpServletResponse;
060
061 import javax.xml.parsers.DocumentBuilder;
062 import javax.xml.parsers.DocumentBuilderFactory;
063 import javax.xml.parsers.ParserConfigurationException;
064 import javax.xml.transform.Transformer;
065 import javax.xml.transform.TransformerFactory;
066 import javax.xml.transform.dom.DOMSource;
067 import javax.xml.transform.stream.StreamResult;
068
069 import org.apache.commons.fileupload.FileItem;
070 import org.apache.commons.fileupload.disk.DiskFileItem;
071 import org.apache.commons.fileupload.servlet.ServletFileUpload;
072
073 import org.w3c.dom.Document;
074 import org.w3c.dom.Element;
075 import org.w3c.dom.Node;
076
077
081 public abstract class BaseCommandReceiver implements CommandReceiver {
082
083 @Override
084 public void createFolder(
085 CommandArgument commandArgument, HttpServletRequest request,
086 HttpServletResponse response) {
087
088 Document document = _createDocument();
089
090 Node rootNode = _createRoot(
091 document, commandArgument.getCommand(), commandArgument.getType(),
092 commandArgument.getCurrentFolder(), StringPool.BLANK);
093
094 Element errorElement = document.createElement("Error");
095
096 rootNode.appendChild(errorElement);
097
098 String returnValue = "0";
099
100 try {
101 returnValue = createFolder(commandArgument);
102 }
103 catch (FCKException fcke) {
104 Throwable cause = fcke.getCause();
105
106 returnValue = "110";
107
108 if (cause != null) {
109 String causeString = GetterUtil.getString(cause.toString());
110
111 if (causeString.contains("DuplicateFolderNameException")) {
112 returnValue = "101";
113 }
114 else if (causeString.contains("FolderNameException")) {
115 returnValue = "102";
116 }
117 else if (causeString.contains("NoSuchGroupException") ||
118 causeString.contains("PrincipalException")) {
119
120 returnValue = "103";
121 }
122 else {
123 throw fcke;
124 }
125 }
126 }
127
128 errorElement.setAttribute("number", returnValue);
129
130 _writeDocument(document, response);
131 }
132
133 @Override
134 public void fileUpload(
135 CommandArgument commandArgument, HttpServletRequest request,
136 HttpServletResponse response) {
137
138 InputStream inputStream = null;
139
140 String returnValue = null;
141
142 try {
143 ServletFileUpload servletFileUpload = new LiferayFileUpload(
144 new LiferayFileItemFactory(
145 UploadServletRequestImpl.getTempDir()), request);
146
147 servletFileUpload.setFileSizeMax(
148 PrefsPropsUtil.getLong(
149 PropsKeys.UPLOAD_SERVLET_REQUEST_IMPL_MAX_SIZE));
150
151 LiferayServletRequest liferayServletRequest =
152 new LiferayServletRequest(request);
153
154 List<FileItem> fileItems = servletFileUpload.parseRequest(
155 liferayServletRequest);
156
157 Map<String, Object> fields = new HashMap<String, Object>();
158
159 for (FileItem fileItem : fileItems) {
160 if (fileItem.isFormField()) {
161 fields.put(fileItem.getFieldName(), fileItem.getString());
162 }
163 else {
164 fields.put(fileItem.getFieldName(), fileItem);
165 }
166 }
167
168 DiskFileItem diskFileItem = (DiskFileItem)fields.get("NewFile");
169
170 String fileName = StringUtil.replace(
171 diskFileItem.getName(), CharPool.BACK_SLASH, CharPool.SLASH);
172 String[] fileNameArray = StringUtil.split(fileName, '/');
173 fileName = fileNameArray[fileNameArray.length - 1];
174
175 String contentType = diskFileItem.getContentType();
176
177 if (Validator.isNull(contentType) ||
178 contentType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
179
180 contentType = MimeTypesUtil.getContentType(
181 diskFileItem.getStoreLocation());
182 }
183
184 if (diskFileItem.isInMemory()) {
185 inputStream = diskFileItem.getInputStream();
186 }
187 else {
188 inputStream = new ByteArrayFileInputStream(
189 diskFileItem.getStoreLocation(),
190 LiferayFileItem.THRESHOLD_SIZE);
191 }
192
193 long size = diskFileItem.getSize();
194
195 returnValue = fileUpload(
196 commandArgument, fileName, inputStream, contentType, size);
197 }
198 catch (Exception e) {
199 FCKException fcke = null;
200
201 if (e instanceof FCKException) {
202 fcke = (FCKException)e;
203 }
204 else {
205 fcke = new FCKException(e);
206 }
207
208 Throwable cause = fcke.getCause();
209
210 returnValue = "203";
211
212 if (cause != null) {
213 String causeString = GetterUtil.getString(cause.toString());
214
215 if (causeString.contains("DuplicateFileException")) {
216 returnValue = "201";
217 }
218 else if (causeString.contains("NoSuchFolderException")||
219 causeString.contains("NoSuchGroupException")) {
220
221 returnValue = "204";
222 }
223 else if (causeString.contains("ImageNameException")) {
224 returnValue = "205";
225 }
226 else if (causeString.contains("FileExtensionException") ||
227 causeString.contains("FileNameException")) {
228
229 returnValue = "206";
230 }
231 else if (causeString.contains("PrincipalException")) {
232 returnValue = "207";
233 }
234 else if (causeString.contains("FileSizeException") ||
235 causeString.contains("ImageSizeException") ||
236 causeString.contains("SizeLimitExceededException")) {
237
238 returnValue = "208";
239 }
240 else if (causeString.contains("SystemException")) {
241 returnValue = "209";
242 }
243 else if (causeString.contains("AssetCategoryException")) {
244 returnValue = "212";
245 }
246 else {
247 throw fcke;
248 }
249 }
250
251 _writeUploadResponse(returnValue, response);
252 }
253 finally {
254 StreamUtil.cleanUp(inputStream);
255 }
256
257 _writeUploadResponse(returnValue, response);
258 }
259
260 @Override
261 public void getFolders(
262 CommandArgument commandArgument, HttpServletRequest request,
263 HttpServletResponse response) {
264
265 Document document = _createDocument();
266
267 Node rootNode = _createRoot(
268 document, commandArgument.getCommand(), commandArgument.getType(),
269 commandArgument.getCurrentFolder(), getPath(commandArgument));
270
271 getFolders(commandArgument, document, rootNode);
272
273 _writeDocument(document, response);
274 }
275
276 @Override
277 public void getFoldersAndFiles(
278 CommandArgument commandArgument, HttpServletRequest request,
279 HttpServletResponse response) {
280
281 Document document = _createDocument();
282
283 Node rootNode = _createRoot(
284 document, commandArgument.getCommand(), commandArgument.getType(),
285 commandArgument.getCurrentFolder(), getPath(commandArgument));
286
287 getFoldersAndFiles(commandArgument, document, rootNode);
288
289 _writeDocument(document, response);
290 }
291
292 protected abstract String createFolder(CommandArgument commandArgument);
293
294 protected abstract String fileUpload(
295 CommandArgument commandArgument, String fileName,
296 InputStream inputStream, String contentType, long size);
297
298 protected abstract void getFolders(
299 CommandArgument commandArgument, Document document, Node rootNode);
300
301 protected abstract void getFoldersAndFiles(
302 CommandArgument commandArgument, Document document, Node rootNode);
303
304 protected String getPath(CommandArgument commandArgument) {
305 return StringPool.BLANK;
306 }
307
308 protected void getRootFolders(
309 CommandArgument commandArgument, Document document,
310 Element foldersElement)
311 throws Exception {
312
313 List<Group> groups = new UniqueList<Group>();
314
315 LinkedHashMap<String, Object> groupParams =
316 new LinkedHashMap<String, Object>();
317
318 groupParams.put("usersGroups", new Long(commandArgument.getUserId()));
319
320 groups.addAll(
321 GroupLocalServiceUtil.search(
322 commandArgument.getCompanyId(), null, null, groupParams,
323 QueryUtil.ALL_POS, QueryUtil.ALL_POS));
324
325 List<Organization> userOrgs =
326 OrganizationLocalServiceUtil.getUserOrganizations(
327 commandArgument.getUserId());
328
329 for (Organization organization : userOrgs) {
330 groups.add(0, organization.getGroup());
331 }
332
333 if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
334 PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
335
336 Group userGroup = GroupLocalServiceUtil.getUserGroup(
337 commandArgument.getCompanyId(), commandArgument.getUserId());
338
339 groups.add(0, userGroup);
340 }
341
342 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
343 commandArgument.getCompanyId());
344
345 groups.add(0, companyGroup);
346
347 ThemeDisplay themeDisplay = commandArgument.getThemeDisplay();
348
349 long doAsGroupId = themeDisplay.getDoAsGroupId();
350
351 HttpServletRequest request = commandArgument.getHttpServletRequest();
352
353 String portletId = ParamUtil.getString(request, "p_p_id");
354
355 for (Group group : groups) {
356 Element folderElement = document.createElement("Folder");
357
358 foldersElement.appendChild(folderElement);
359
360 long groupId = group.getGroupId();
361 String descriptiveName = group.getDescriptiveName();
362
363 if (group.hasStagingGroup()) {
364 Group stagingGroup = group.getStagingGroup();
365
366 if ((stagingGroup.getGroupId() == doAsGroupId) &&
367 group.isStagedPortlet(portletId) &&
368 !group.isStagedRemotely() && isStagedData(group)) {
369
370 groupId = stagingGroup.getGroupId();
371 descriptiveName = stagingGroup.getDescriptiveName();
372 }
373 }
374
375 folderElement.setAttribute(
376 "name", groupId + " - " + HtmlUtil.escape(descriptiveName));
377 }
378 }
379
380 protected String getSize() {
381 return getSize(0);
382 }
383
384 protected String getSize(long size) {
385 return String.valueOf(Math.ceil(size / 1000));
386 }
387
388 protected boolean isStagedData(Group group) {
389 return true;
390 }
391
392 private Document _createDocument() {
393 try {
394 DocumentBuilderFactory documentBuilderFactory =
395 DocumentBuilderFactory.newInstance();
396
397 DocumentBuilder documentBuilder =
398 documentBuilderFactory.newDocumentBuilder();
399
400 return documentBuilder.newDocument();
401 }
402 catch (ParserConfigurationException pce) {
403 throw new FCKException(pce);
404 }
405 }
406
407 private Node _createRoot(
408 Document document, String command, String resourceType, String path,
409 String url) {
410
411 Element rootElement = document.createElement("Connector");
412
413 document.appendChild(rootElement);
414
415 rootElement.setAttribute("command", command);
416 rootElement.setAttribute("resourceType", resourceType);
417
418 Element currentFolderElement = document.createElement("CurrentFolder");
419
420 rootElement.appendChild(currentFolderElement);
421
422 currentFolderElement.setAttribute("path", path);
423 currentFolderElement.setAttribute("url", url);
424
425 return rootElement;
426 }
427
428 private void _writeDocument(
429 Document document, HttpServletResponse response) {
430
431 try {
432 Element documentElement = document.getDocumentElement();
433
434 documentElement.normalize();
435
436 TransformerFactory transformerFactory =
437 TransformerFactory.newInstance();
438
439 Transformer transformer = transformerFactory.newTransformer();
440
441 DOMSource domSource = new DOMSource(document);
442
443 if (_log.isDebugEnabled()) {
444 StreamResult streamResult = new StreamResult(System.out);
445
446 transformer.transform(domSource, streamResult);
447 }
448
449 response.setContentType("text/xml; charset=UTF-8");
450 response.setHeader("Cache-Control", "no-cache");
451
452 PrintWriter printWriter = response.getWriter();
453
454 StreamResult streamResult = new StreamResult(printWriter);
455
456 transformer.transform(domSource, streamResult);
457
458 printWriter.flush();
459 printWriter.close();
460 }
461 catch (Exception e) {
462 throw new FCKException(e);
463 }
464 }
465
466 private void _writeUploadResponse(
467 String returnValue, HttpServletResponse response) {
468
469 try {
470 StringBundler sb = new StringBundler(7);
471
472 String newName = StringPool.BLANK;
473
474 sb.append("<script type=\"text/javascript\">");
475 sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
476 sb.append(returnValue);
477 sb.append(",'");
478 sb.append(newName);
479 sb.append("');");
480 sb.append("</script>");
481
482 response.setContentType("text/html; charset=UTF-8");
483 response.setHeader("Cache-Control", "no-cache");
484
485 PrintWriter printWriter = null;
486
487 printWriter = response.getWriter();
488
489 printWriter.print(sb.toString());
490
491 printWriter.flush();
492 printWriter.close();
493 }
494 catch (Exception e) {
495 throw new FCKException(e);
496 }
497 }
498
499 private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
500
501 }