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(), true);
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(
354 stagingGroup.getDescriptiveName()));
355
356 setNameAttribute = true;
357 }
358 }
359
360 if (!setNameAttribute) {
361 folderElement.setAttribute(
362 "name",
363 group.getGroupId() + " - " +
364 HtmlUtil.escape(group.getDescriptiveName()));
365 }
366 }
367 }
368
369 protected String getPath(CommandArgument commandArgument) {
370 return StringPool.BLANK;
371 }
372
373 protected String getSize() {
374 return getSize(0);
375 }
376
377 protected String getSize(long size) {
378 return String.valueOf(Math.ceil(size / 1000));
379 }
380
381 protected boolean isStagedData(Group group) {
382 return true;
383 }
384
385 private Document _createDocument() {
386 try {
387 DocumentBuilderFactory documentBuilderFactory =
388 DocumentBuilderFactory.newInstance();
389
390 DocumentBuilder documentBuilder =
391 documentBuilderFactory.newDocumentBuilder();
392
393 return documentBuilder.newDocument();
394 }
395 catch (ParserConfigurationException pce) {
396 throw new FCKException(pce);
397 }
398 }
399
400 private Node _createRoot(
401 Document document, String command, String resourceType,
402 String path, String url) {
403
404 Element rootElement = document.createElement("Connector");
405
406 document.appendChild(rootElement);
407
408 rootElement.setAttribute("command", command);
409 rootElement.setAttribute("resourceType", resourceType);
410
411 Element currentFolderElement = document.createElement("CurrentFolder");
412
413 rootElement.appendChild(currentFolderElement);
414
415 currentFolderElement.setAttribute("path", path);
416 currentFolderElement.setAttribute("url", url);
417
418 return rootElement;
419 }
420
421 private void _writeDocument(
422 Document document, HttpServletResponse response) {
423
424 try {
425 Element documentElement = document.getDocumentElement();
426
427 documentElement.normalize();
428
429 TransformerFactory transformerFactory =
430 TransformerFactory.newInstance();
431
432 Transformer transformer = transformerFactory.newTransformer();
433
434 DOMSource domSource = new DOMSource(document);
435
436 if (_log.isDebugEnabled()) {
437 StreamResult streamResult = new StreamResult(System.out);
438
439 transformer.transform(domSource, streamResult);
440 }
441
442 response.setContentType("text/xml; charset=UTF-8");
443 response.setHeader("Cache-Control", "no-cache");
444
445 PrintWriter printWriter = response.getWriter();
446
447 StreamResult streamResult = new StreamResult(printWriter);
448
449 transformer.transform(domSource, streamResult);
450
451 printWriter.flush();
452 printWriter.close();
453 }
454 catch (Exception e) {
455 throw new FCKException(e);
456 }
457 }
458
459 private void _writeUploadResponse(
460 String returnValue, HttpServletResponse response) {
461
462 try {
463 StringBundler sb = new StringBundler(7);
464
465 String newName = StringPool.BLANK;
466
467 sb.append("<script type=\"text/javascript\">");
468 sb.append("window.parent.frames['frmUpload'].OnUploadCompleted(");
469 sb.append(returnValue);
470 sb.append(",'");
471 sb.append(newName);
472 sb.append("');");
473 sb.append("</script>");
474
475 response.setContentType("text/html; charset=UTF-8");
476 response.setHeader("Cache-Control", "no-cache");
477
478 PrintWriter printWriter = null;
479
480 printWriter = response.getWriter();
481
482 printWriter.print(sb.toString());
483
484 printWriter.flush();
485 printWriter.close();
486 }
487 catch (Exception e) {
488 throw new FCKException(e);
489 }
490 }
491
492 private static Log _log = LogFactoryUtil.getLog(BaseCommandReceiver.class);
493
494 }