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