001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.documentlibrary.action;
016    
017    import com.liferay.portal.DuplicateLockException;
018    import com.liferay.portal.NoSuchRepositoryEntryException;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.json.JSONArray;
022    import com.liferay.portal.kernel.json.JSONFactoryUtil;
023    import com.liferay.portal.kernel.json.JSONObject;
024    import com.liferay.portal.kernel.portlet.LiferayWindowState;
025    import com.liferay.portal.kernel.repository.model.FileEntry;
026    import com.liferay.portal.kernel.repository.model.Folder;
027    import com.liferay.portal.kernel.servlet.ServletResponseConstants;
028    import com.liferay.portal.kernel.servlet.SessionErrors;
029    import com.liferay.portal.kernel.servlet.SessionMessages;
030    import com.liferay.portal.kernel.upload.LiferayFileItemException;
031    import com.liferay.portal.kernel.upload.UploadException;
032    import com.liferay.portal.kernel.upload.UploadPortletRequest;
033    import com.liferay.portal.kernel.util.Constants;
034    import com.liferay.portal.kernel.util.ContentTypes;
035    import com.liferay.portal.kernel.util.FileUtil;
036    import com.liferay.portal.kernel.util.HttpUtil;
037    import com.liferay.portal.kernel.util.KeyValuePair;
038    import com.liferay.portal.kernel.util.MimeTypesUtil;
039    import com.liferay.portal.kernel.util.ParamUtil;
040    import com.liferay.portal.kernel.util.PropsKeys;
041    import com.liferay.portal.kernel.util.StreamUtil;
042    import com.liferay.portal.kernel.util.StringBundler;
043    import com.liferay.portal.kernel.util.StringPool;
044    import com.liferay.portal.kernel.util.StringUtil;
045    import com.liferay.portal.kernel.util.TempFileUtil;
046    import com.liferay.portal.kernel.util.Validator;
047    import com.liferay.portal.kernel.workflow.WorkflowConstants;
048    import com.liferay.portal.security.auth.PrincipalException;
049    import com.liferay.portal.service.ServiceContext;
050    import com.liferay.portal.service.ServiceContextFactory;
051    import com.liferay.portal.struts.ActionConstants;
052    import com.liferay.portal.struts.PortletAction;
053    import com.liferay.portal.theme.ThemeDisplay;
054    import com.liferay.portal.util.PortalUtil;
055    import com.liferay.portal.util.PortletKeys;
056    import com.liferay.portal.util.PrefsPropsUtil;
057    import com.liferay.portal.util.WebKeys;
058    import com.liferay.portlet.PortletURLImpl;
059    import com.liferay.portlet.asset.AssetCategoryException;
060    import com.liferay.portlet.asset.AssetTagException;
061    import com.liferay.portlet.asset.model.AssetVocabulary;
062    import com.liferay.portlet.assetpublisher.util.AssetPublisherUtil;
063    import com.liferay.portlet.documentlibrary.DuplicateFileException;
064    import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
065    import com.liferay.portlet.documentlibrary.FileExtensionException;
066    import com.liferay.portlet.documentlibrary.FileMimeTypeException;
067    import com.liferay.portlet.documentlibrary.FileNameException;
068    import com.liferay.portlet.documentlibrary.FileSizeException;
069    import com.liferay.portlet.documentlibrary.InvalidFileEntryTypeException;
070    import com.liferay.portlet.documentlibrary.InvalidFileVersionException;
071    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
072    import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
073    import com.liferay.portlet.documentlibrary.NoSuchFolderException;
074    import com.liferay.portlet.documentlibrary.SourceFileNameException;
075    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
076    import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
077    import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
078    import com.liferay.portlet.documentlibrary.util.DLUtil;
079    import com.liferay.portlet.dynamicdatamapping.StorageFieldRequiredException;
080    import com.liferay.portlet.trash.util.TrashUtil;
081    
082    import java.io.InputStream;
083    
084    import java.util.ArrayList;
085    import java.util.Arrays;
086    import java.util.HashMap;
087    import java.util.HashSet;
088    import java.util.List;
089    import java.util.Map;
090    import java.util.Set;
091    
092    import javax.portlet.ActionRequest;
093    import javax.portlet.ActionResponse;
094    import javax.portlet.PortletConfig;
095    import javax.portlet.PortletContext;
096    import javax.portlet.PortletPreferences;
097    import javax.portlet.PortletRequest;
098    import javax.portlet.PortletRequestDispatcher;
099    import javax.portlet.PortletResponse;
100    import javax.portlet.RenderRequest;
101    import javax.portlet.RenderResponse;
102    import javax.portlet.ResourceRequest;
103    import javax.portlet.ResourceResponse;
104    import javax.portlet.WindowState;
105    
106    import javax.servlet.http.HttpServletResponse;
107    
108    import org.apache.commons.fileupload.FileUploadBase.IOFileUploadException;
109    import org.apache.struts.action.ActionForm;
110    import org.apache.struts.action.ActionForward;
111    import org.apache.struts.action.ActionMapping;
112    
113    /**
114     * @author Brian Wing Shun Chan
115     * @author Alexander Chow
116     * @author Sergio Gonz??lez
117     * @author Manuel de la Pe??a
118     * @author Levente Hud??k
119     * @author Kenneth Chang
120     */
121    public class EditFileEntryAction extends PortletAction {
122    
123            public static final String TEMP_RANDOM_SUFFIX = "--tempRandomSuffix--";
124    
125            @Override
126            public void processAction(
127                            ActionMapping actionMapping, ActionForm actionForm,
128                            PortletConfig portletConfig, ActionRequest actionRequest,
129                            ActionResponse actionResponse)
130                    throws Exception {
131    
132                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
133    
134                    FileEntry fileEntry = null;
135    
136                    try {
137                            if (Validator.isNull(cmd)) {
138                                    UploadException uploadException =
139                                            (UploadException)actionRequest.getAttribute(
140                                                    WebKeys.UPLOAD_EXCEPTION);
141    
142                                    if (uploadException != null) {
143                                            if (uploadException.isExceededLiferayFileItemSizeLimit()) {
144                                                    throw new LiferayFileItemException();
145                                            }
146                                            else if (uploadException.isExceededSizeLimit()) {
147                                                    throw new FileSizeException(uploadException.getCause());
148                                            }
149    
150                                            throw new PortalException(uploadException.getCause());
151                                    }
152                            }
153                            else if (cmd.equals(Constants.ADD) ||
154                                             cmd.equals(Constants.ADD_DYNAMIC) ||
155                                             cmd.equals(Constants.UPDATE) ||
156                                             cmd.equals(Constants.UPDATE_AND_CHECKIN)) {
157    
158                                    fileEntry = updateFileEntry(
159                                            portletConfig, actionRequest, actionResponse);
160                            }
161                            else if (cmd.equals(Constants.ADD_MULTIPLE)) {
162                                    addMultipleFileEntries(
163                                            portletConfig, actionRequest, actionResponse);
164    
165                                    hideDefaultSuccessMessage(actionRequest);
166                            }
167                            else if (cmd.equals(Constants.ADD_TEMP)) {
168                                    addTempFileEntry(actionRequest, actionResponse);
169                            }
170                            else if (cmd.equals(Constants.DELETE)) {
171                                    deleteFileEntry(actionRequest, false);
172                            }
173                            else if (cmd.equals(Constants.DELETE_TEMP)) {
174                                    deleteTempFileEntry(actionRequest, actionResponse);
175                            }
176                            else if (cmd.equals(Constants.CANCEL_CHECKOUT)) {
177                                    cancelFileEntriesCheckOut(actionRequest);
178                            }
179                            else if (cmd.equals(Constants.CHECKIN)) {
180                                    checkInFileEntries(actionRequest);
181                            }
182                            else if (cmd.equals(Constants.CHECKOUT)) {
183                                    checkOutFileEntries(actionRequest);
184                            }
185                            else if (cmd.equals(Constants.MOVE)) {
186                                    moveFileEntries(actionRequest, false);
187                            }
188                            else if (cmd.equals(Constants.MOVE_FROM_TRASH)) {
189                                    moveFileEntries(actionRequest, true);
190                            }
191                            else if (cmd.equals(Constants.MOVE_TO_TRASH)) {
192                                    deleteFileEntry(actionRequest, true);
193                            }
194                            else if (cmd.equals(Constants.REVERT)) {
195                                    revertFileEntry(actionRequest);
196                            }
197    
198                            WindowState windowState = actionRequest.getWindowState();
199    
200                            if (cmd.equals(Constants.ADD_TEMP) ||
201                                    cmd.equals(Constants.DELETE_TEMP)) {
202    
203                                    setForward(actionRequest, ActionConstants.COMMON_NULL);
204                            }
205                            else if (cmd.equals(Constants.PREVIEW)) {
206                            }
207                            else if (!cmd.equals(Constants.MOVE_FROM_TRASH) &&
208                                             !windowState.equals(LiferayWindowState.POP_UP)) {
209    
210                                    sendRedirect(actionRequest, actionResponse);
211                            }
212                            else {
213                                    String redirect = ParamUtil.getString(
214                                            actionRequest, "redirect");
215                                    int workflowAction = ParamUtil.getInteger(
216                                            actionRequest, "workflowAction",
217                                            WorkflowConstants.ACTION_SAVE_DRAFT);
218    
219                                    if ((fileEntry != null) &&
220                                            (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT)) {
221    
222                                            redirect = getSaveAndContinueRedirect(
223                                                    portletConfig, actionRequest, fileEntry, redirect);
224    
225                                            sendRedirect(actionRequest, actionResponse, redirect);
226                                    }
227                                    else {
228                                            if (!windowState.equals(LiferayWindowState.POP_UP)) {
229                                                    sendRedirect(actionRequest, actionResponse);
230                                            }
231                                            else {
232                                                    redirect = PortalUtil.escapeRedirect(
233                                                            ParamUtil.getString(actionRequest, "redirect"));
234    
235                                                    if (Validator.isNotNull(redirect)) {
236                                                            if (cmd.equals(Constants.ADD) &&
237                                                                    (fileEntry != null)) {
238    
239                                                                    String portletId = HttpUtil.getParameter(
240                                                                            redirect, "p_p_id", false);
241    
242                                                                    String namespace =
243                                                                            PortalUtil.getPortletNamespace(portletId);
244    
245                                                                    redirect = HttpUtil.addParameter(
246                                                                            redirect, namespace + "className",
247                                                                            DLFileEntry.class.getName());
248                                                                    redirect = HttpUtil.addParameter(
249                                                                            redirect, namespace + "classPK",
250                                                                            fileEntry.getFileEntryId());
251                                                            }
252    
253                                                            actionResponse.sendRedirect(redirect);
254                                                    }
255                                            }
256                                    }
257                            }
258                    }
259                    catch (Exception e) {
260                            handleUploadException(
261                                    portletConfig, actionRequest, actionResponse, cmd, e);
262                    }
263            }
264    
265            @Override
266            public ActionForward render(
267                            ActionMapping actionMapping, ActionForm actionForm,
268                            PortletConfig portletConfig, RenderRequest renderRequest,
269                            RenderResponse renderResponse)
270                    throws Exception {
271    
272                    try {
273                            ActionUtil.getFileEntry(renderRequest);
274                    }
275                    catch (Exception e) {
276                            if (e instanceof NoSuchFileEntryException ||
277                                    e instanceof NoSuchFileVersionException ||
278                                    e instanceof NoSuchRepositoryEntryException ||
279                                    e instanceof PrincipalException) {
280    
281                                    SessionErrors.add(renderRequest, e.getClass());
282    
283                                    return actionMapping.findForward(
284                                            "portlet.document_library.error");
285                            }
286                            else {
287                                    throw e;
288                            }
289                    }
290    
291                    String forward = "portlet.document_library.edit_file_entry";
292    
293                    return actionMapping.findForward(getForward(renderRequest, forward));
294            }
295    
296            @Override
297            public void serveResource(
298                            ActionMapping actionMapping, ActionForm actionForm,
299                            PortletConfig portletConfig, ResourceRequest resourceRequest,
300                            ResourceResponse resourceResponse)
301                    throws Exception {
302    
303                    PortletContext portletContext = portletConfig.getPortletContext();
304    
305                    PortletRequestDispatcher portletRequestDispatcher =
306                            portletContext.getRequestDispatcher(
307                                    "/html/portlet/document_library/" +
308                                            "upload_multiple_file_entries_resources.jsp");
309    
310                    portletRequestDispatcher.include(resourceRequest, resourceResponse);
311            }
312    
313            protected void addMultipleFileEntries(
314                            PortletConfig portletConfig, ActionRequest actionRequest,
315                            ActionResponse actionResponse)
316                    throws Exception {
317    
318                    List<KeyValuePair> validFileNameKVPs = new ArrayList<KeyValuePair>();
319                    List<KeyValuePair> invalidFileNameKVPs = new ArrayList<KeyValuePair>();
320    
321                    String[] selectedFileNames = ParamUtil.getParameterValues(
322                            actionRequest, "selectedFileName", new String[0], false);
323    
324                    for (String selectedFileName : selectedFileNames) {
325                            addMultipleFileEntries(
326                                    portletConfig, actionRequest, actionResponse, selectedFileName,
327                                    validFileNameKVPs, invalidFileNameKVPs);
328                    }
329    
330                    JSONArray jsonArray = JSONFactoryUtil.createJSONArray();
331    
332                    for (KeyValuePair validFileNameKVP : validFileNameKVPs) {
333                            String fileName = validFileNameKVP.getKey();
334                            String originalFileName = validFileNameKVP.getValue();
335    
336                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
337    
338                            jsonObject.put("added", Boolean.TRUE);
339                            jsonObject.put("fileName", fileName);
340                            jsonObject.put("originalFileName", originalFileName);
341    
342                            jsonArray.put(jsonObject);
343                    }
344    
345                    for (KeyValuePair invalidFileNameKVP : invalidFileNameKVPs) {
346                            String fileName = invalidFileNameKVP.getKey();
347                            String errorMessage = invalidFileNameKVP.getValue();
348    
349                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
350    
351                            jsonObject.put("added", Boolean.FALSE);
352                            jsonObject.put("errorMessage", errorMessage);
353                            jsonObject.put("fileName", fileName);
354                            jsonObject.put("originalFileName", fileName);
355    
356                            jsonArray.put(jsonObject);
357                    }
358    
359                    writeJSON(actionRequest, actionResponse, jsonArray);
360            }
361    
362            protected void addMultipleFileEntries(
363                            PortletConfig portletConfig, ActionRequest actionRequest,
364                            ActionResponse actionResponse, String selectedFileName,
365                            List<KeyValuePair> validFileNameKVPs,
366                            List<KeyValuePair> invalidFileNameKVPs)
367                    throws Exception {
368    
369                    String originalSelectedFileName = selectedFileName;
370    
371                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
372                            WebKeys.THEME_DISPLAY);
373    
374                    long repositoryId = ParamUtil.getLong(actionRequest, "repositoryId");
375                    long folderId = ParamUtil.getLong(actionRequest, "folderId");
376                    String description = ParamUtil.getString(actionRequest, "description");
377                    String changeLog = ParamUtil.getString(actionRequest, "changeLog");
378    
379                    FileEntry tempFileEntry = null;
380    
381                    try {
382                            tempFileEntry = TempFileUtil.getTempFile(
383                                    themeDisplay.getScopeGroupId(), themeDisplay.getUserId(),
384                                    selectedFileName, _TEMP_FOLDER_NAME);
385    
386                            String mimeType = tempFileEntry.getMimeType();
387    
388                            String extension = FileUtil.getExtension(selectedFileName);
389    
390                            int pos = selectedFileName.lastIndexOf(TEMP_RANDOM_SUFFIX);
391    
392                            if (pos != -1) {
393                                    selectedFileName = selectedFileName.substring(0, pos);
394    
395                                    if (Validator.isNotNull(extension)) {
396                                            selectedFileName =
397                                                    selectedFileName + StringPool.PERIOD + extension;
398                                    }
399                            }
400    
401                            while (true) {
402                                    try {
403                                            DLAppLocalServiceUtil.getFileEntry(
404                                                    themeDisplay.getScopeGroupId(), folderId,
405                                                    selectedFileName);
406    
407                                            StringBundler sb = new StringBundler(5);
408    
409                                            sb.append(FileUtil.stripExtension(selectedFileName));
410                                            sb.append(StringPool.DASH);
411                                            sb.append(StringUtil.randomString());
412    
413                                            if (Validator.isNotNull(extension)) {
414                                                    sb.append(StringPool.PERIOD);
415                                                    sb.append(extension);
416                                            }
417    
418                                            selectedFileName = sb.toString();
419                                    }
420                                    catch (Exception e) {
421                                            break;
422                                    }
423                            }
424    
425                            InputStream inputStream = tempFileEntry.getContentStream();
426                            long size = tempFileEntry.getSize();
427    
428                            ServiceContext serviceContext = ServiceContextFactory.getInstance(
429                                    DLFileEntry.class.getName(), actionRequest);
430    
431                            FileEntry fileEntry = DLAppServiceUtil.addFileEntry(
432                                    repositoryId, folderId, selectedFileName, mimeType,
433                                    selectedFileName, description, changeLog, inputStream, size,
434                                    serviceContext);
435    
436                            AssetPublisherUtil.addAndStoreSelection(
437                                    actionRequest, DLFileEntry.class.getName(),
438                                    fileEntry.getFileEntryId(), -1);
439    
440                            AssetPublisherUtil.addRecentFolderId(
441                                    actionRequest, DLFileEntry.class.getName(), folderId);
442    
443                            validFileNameKVPs.add(
444                                    new KeyValuePair(selectedFileName, originalSelectedFileName));
445    
446                            return;
447                    }
448                    catch (Exception e) {
449                            String errorMessage = getAddMultipleFileEntriesErrorMessage(
450                                    portletConfig, actionRequest, actionResponse, e);
451    
452                            invalidFileNameKVPs.add(
453                                    new KeyValuePair(originalSelectedFileName, errorMessage));
454                    }
455                    finally {
456                            if (tempFileEntry != null) {
457                                    TempFileUtil.deleteTempFile(tempFileEntry.getFileEntryId());
458                            }
459                    }
460            }
461    
462            protected void addTempFileEntry(
463                            ActionRequest actionRequest, ActionResponse actionResponse)
464                    throws Exception {
465    
466                    UploadPortletRequest uploadPortletRequest =
467                            PortalUtil.getUploadPortletRequest(actionRequest);
468    
469                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
470                            WebKeys.THEME_DISPLAY);
471    
472                    long folderId = ParamUtil.getLong(uploadPortletRequest, "folderId");
473                    String sourceFileName = uploadPortletRequest.getFileName("file");
474    
475                    StringBundler sb = new StringBundler(5);
476    
477                    sb.append(FileUtil.stripExtension(sourceFileName));
478                    sb.append(TEMP_RANDOM_SUFFIX);
479                    sb.append(StringUtil.randomString());
480    
481                    String extension = FileUtil.getExtension(sourceFileName);
482    
483                    if (Validator.isNotNull(extension)) {
484                            sb.append(StringPool.PERIOD);
485                            sb.append(extension);
486                    }
487    
488                    sourceFileName = sb.toString();
489    
490                    String title = sourceFileName;
491    
492                    InputStream inputStream = null;
493    
494                    try {
495                            inputStream = uploadPortletRequest.getFileAsStream("file");
496    
497                            String contentType = uploadPortletRequest.getContentType("file");
498    
499                            DLAppServiceUtil.addTempFileEntry(
500                                    themeDisplay.getScopeGroupId(), folderId, sourceFileName,
501                                    _TEMP_FOLDER_NAME, inputStream, contentType);
502    
503                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
504    
505                            jsonObject.put("name", sourceFileName);
506                            jsonObject.put("title", title);
507    
508                            writeJSON(actionRequest, actionResponse, jsonObject);
509                    }
510                    catch (Exception e) {
511                            UploadException uploadException =
512                                    (UploadException)actionRequest.getAttribute(
513                                            WebKeys.UPLOAD_EXCEPTION);
514    
515                            if ((uploadException != null) &&
516                                    (uploadException.getCause() instanceof IOFileUploadException)) {
517    
518                                    // Cancelled a temporary upload
519    
520                            }
521                            else if ((uploadException != null) &&
522                                             uploadException.isExceededSizeLimit()) {
523    
524                                    throw new FileSizeException(uploadException.getCause());
525                            }
526                            else {
527                                    throw e;
528                            }
529                    }
530                    finally {
531                            StreamUtil.cleanUp(inputStream);
532                    }
533            }
534    
535            protected void cancelFileEntriesCheckOut(ActionRequest actionRequest)
536                    throws Exception {
537    
538                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
539    
540                    if (fileEntryId > 0) {
541                            DLAppServiceUtil.cancelCheckOut(fileEntryId);
542                    }
543                    else {
544                            long[] fileEntryIds = StringUtil.split(
545                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
546    
547                            for (int i = 0; i < fileEntryIds.length; i++) {
548                                    DLAppServiceUtil.cancelCheckOut(fileEntryIds[i]);
549                            }
550                    }
551            }
552    
553            protected void checkInFileEntries(ActionRequest actionRequest)
554                    throws Exception {
555    
556                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
557    
558                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
559                            actionRequest);
560    
561                    if (fileEntryId > 0) {
562                            DLAppServiceUtil.checkInFileEntry(
563                                    fileEntryId, false, StringPool.BLANK, serviceContext);
564                    }
565                    else {
566                            long[] fileEntryIds = StringUtil.split(
567                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
568    
569                            for (int i = 0; i < fileEntryIds.length; i++) {
570                                    DLAppServiceUtil.checkInFileEntry(
571                                            fileEntryIds[i], false, StringPool.BLANK, serviceContext);
572                            }
573                    }
574            }
575    
576            protected void checkOutFileEntries(ActionRequest actionRequest)
577                    throws Exception {
578    
579                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
580    
581                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
582                            actionRequest);
583    
584                    if (fileEntryId > 0) {
585                            DLAppServiceUtil.checkOutFileEntry(fileEntryId, serviceContext);
586                    }
587                    else {
588                            long[] fileEntryIds = StringUtil.split(
589                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
590    
591                            for (int i = 0; i < fileEntryIds.length; i++) {
592                                    DLAppServiceUtil.checkOutFileEntry(
593                                            fileEntryIds[i], serviceContext);
594                            }
595                    }
596            }
597    
598            protected void deleteFileEntry(
599                            ActionRequest actionRequest, boolean moveToTrash)
600                    throws Exception {
601    
602                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
603    
604                    if (fileEntryId == 0) {
605                            return;
606                    }
607    
608                    String version = ParamUtil.getString(actionRequest, "version");
609    
610                    if (Validator.isNotNull(version)) {
611                            DLAppServiceUtil.deleteFileVersion(fileEntryId, version);
612    
613                            return;
614                    }
615    
616                    if (!moveToTrash) {
617                            DLAppServiceUtil.deleteFileEntry(fileEntryId);
618    
619                            return;
620                    }
621    
622                    FileEntry fileEntry = DLAppServiceUtil.moveFileEntryToTrash(
623                            fileEntryId);
624    
625                    Map<String, String[]> data = new HashMap<String, String[]>();
626    
627                    data.put(
628                            "deleteEntryClassName", new String[] {DLFileEntry.class.getName()});
629    
630                    if (fileEntry != null) {
631                            data.put(
632                                    "deleteEntryTitle",
633                                    new String[] {
634                                            TrashUtil.getOriginalTitle(fileEntry.getTitle())});
635                    }
636    
637                    data.put(
638                            "restoreFileEntryIds", new String[] {String.valueOf(fileEntryId)});
639    
640                    SessionMessages.add(
641                            actionRequest,
642                            PortalUtil.getPortletId(actionRequest) +
643                                    SessionMessages.KEY_SUFFIX_DELETE_SUCCESS_DATA,
644                            data);
645    
646                    hideDefaultSuccessMessage(actionRequest);
647            }
648    
649            protected void deleteTempFileEntry(
650                            ActionRequest actionRequest, ActionResponse actionResponse)
651                    throws Exception {
652    
653                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
654                            WebKeys.THEME_DISPLAY);
655    
656                    long folderId = ParamUtil.getLong(actionRequest, "folderId");
657                    String fileName = ParamUtil.getString(actionRequest, "fileName");
658    
659                    JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
660    
661                    try {
662                            DLAppServiceUtil.deleteTempFileEntry(
663                                    themeDisplay.getScopeGroupId(), folderId, fileName,
664                                    _TEMP_FOLDER_NAME);
665    
666                            jsonObject.put("deleted", Boolean.TRUE);
667                    }
668                    catch (Exception e) {
669                            String errorMessage = themeDisplay.translate(
670                                    "an-unexpected-error-occurred-while-deleting-the-file");
671    
672                            jsonObject.put("deleted", Boolean.FALSE);
673                            jsonObject.put("errorMessage", errorMessage);
674                    }
675    
676                    writeJSON(actionRequest, actionResponse, jsonObject);
677            }
678    
679            protected String getAddMultipleFileEntriesErrorMessage(
680                            PortletConfig portletConfig, ActionRequest actionRequest,
681                            ActionResponse actionResponse, Exception e)
682                    throws Exception {
683    
684                    String errorMessage = null;
685    
686                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
687                            WebKeys.THEME_DISPLAY);
688    
689                    if (e instanceof AssetCategoryException) {
690                            AssetCategoryException ace = (AssetCategoryException)e;
691    
692                            AssetVocabulary assetVocabulary = ace.getVocabulary();
693    
694                            String vocabularyTitle = StringPool.BLANK;
695    
696                            if (assetVocabulary != null) {
697                                    vocabularyTitle = assetVocabulary.getTitle(
698                                            themeDisplay.getLocale());
699                            }
700    
701                            if (ace.getType() == AssetCategoryException.AT_LEAST_ONE_CATEGORY) {
702                                    errorMessage = themeDisplay.translate(
703                                            "please-select-at-least-one-category-for-x",
704                                            vocabularyTitle);
705                            }
706                            else if (ace.getType() ==
707                                                    AssetCategoryException.TOO_MANY_CATEGORIES) {
708    
709                                    errorMessage = themeDisplay.translate(
710                                            "you-cannot-select-more-than-one-category-for-x",
711                                            vocabularyTitle);
712                            }
713                    }
714                    else if (e instanceof DuplicateFileException) {
715                            errorMessage = themeDisplay.translate(
716                                    "the-folder-you-selected-already-has-an-entry-with-this-name." +
717                                            "-please-select-a-different-folder");
718                    }
719                    else if (e instanceof FileExtensionException) {
720                            errorMessage = themeDisplay.translate(
721                                    "please-enter-a-file-with-a-valid-extension-x",
722                                            StringUtil.merge(
723                                                    getAllowedFileExtensions(
724                                                            portletConfig, actionRequest, actionResponse)));
725                    }
726                    else if (e instanceof FileNameException) {
727                            errorMessage = themeDisplay.translate(
728                                    "please-enter-a-file-with-a-valid-file-name");
729                    }
730                    else if (e instanceof FileSizeException) {
731                            long maxSizeMB = PrefsPropsUtil.getLong(
732                                    PropsKeys.DL_FILE_MAX_SIZE) / 1024 / 1024;
733    
734                            errorMessage = themeDisplay.translate(
735                                    "file-size-is-larger-than-x-megabytes", maxSizeMB);
736                    }
737                    else if (e instanceof InvalidFileEntryTypeException) {
738                            errorMessage = themeDisplay.translate(
739                                    "the-document-type-you-selected-is-not-valid-for-this-folder");
740                    }
741                    else {
742                            errorMessage = themeDisplay.translate(
743                                    "an-unexpected-error-occurred-while-saving-your-document");
744                    }
745    
746                    return errorMessage;
747            }
748    
749            protected String[] getAllowedFileExtensions(
750                            PortletConfig portletConfig, PortletRequest portletRequest,
751                            PortletResponse portletResponse)
752                    throws PortalException, SystemException {
753    
754                    String portletName = portletConfig.getPortletName();
755    
756                    if (!portletName.equals(PortletKeys.MEDIA_GALLERY_DISPLAY)) {
757                            return PrefsPropsUtil.getStringArray(
758                                    PropsKeys.DL_FILE_EXTENSIONS, StringPool.COMMA);
759                    }
760                    else {
761                            PortletPreferences portletPreferences = getStrictPortletSetup(
762                                    portletRequest);
763    
764                            if (portletPreferences == null) {
765                                    portletPreferences = portletRequest.getPreferences();
766                            }
767    
768                            Set<String> extensions = new HashSet<String>();
769    
770                            String[] mimeTypes = DLUtil.getMediaGalleryMimeTypes(
771                                    portletPreferences, portletRequest);
772    
773                            for (String mimeType : mimeTypes) {
774                                    extensions.addAll(MimeTypesUtil.getExtensions(mimeType));
775                            }
776    
777                            return extensions.toArray(new String[extensions.size()]);
778                    }
779            }
780    
781            protected String getSaveAndContinueRedirect(
782                            PortletConfig portletConfig, ActionRequest actionRequest,
783                            FileEntry fileEntry, String redirect)
784                    throws Exception {
785    
786                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
787                            WebKeys.THEME_DISPLAY);
788    
789                    PortletURLImpl portletURL = new PortletURLImpl(
790                            actionRequest, portletConfig.getPortletName(),
791                            themeDisplay.getPlid(), PortletRequest.RENDER_PHASE);
792    
793                    portletURL.setParameter(
794                            "struts_action", "/document_library/edit_file_entry");
795                    portletURL.setParameter(Constants.CMD, Constants.UPDATE, false);
796                    portletURL.setParameter("redirect", redirect, false);
797    
798                    String referringPortletResource = ParamUtil.getString(
799                            actionRequest, "referringPortletResource");
800    
801                    portletURL.setParameter(
802                            "referringPortletResource", referringPortletResource, false);
803    
804                    portletURL.setParameter(
805                            "groupId", String.valueOf(fileEntry.getGroupId()), false);
806                    portletURL.setParameter(
807                            "fileEntryId", String.valueOf(fileEntry.getFileEntryId()), false);
808                    portletURL.setParameter(
809                            "version", String.valueOf(fileEntry.getVersion()), false);
810                    portletURL.setWindowState(actionRequest.getWindowState());
811    
812                    return portletURL.toString();
813            }
814    
815            protected void handleUploadException(
816                            PortletConfig portletConfig, ActionRequest actionRequest,
817                            ActionResponse actionResponse, String cmd, Exception e)
818                    throws Exception {
819    
820                    if (e instanceof AssetCategoryException ||
821                            e instanceof AssetTagException) {
822    
823                            SessionErrors.add(actionRequest, e.getClass(), e);
824                    }
825                    else if (e instanceof DuplicateFileException ||
826                                     e instanceof DuplicateFolderNameException ||
827                                     e instanceof LiferayFileItemException ||
828                                     e instanceof FileExtensionException ||
829                                     e instanceof FileMimeTypeException ||
830                                     e instanceof FileNameException ||
831                                     e instanceof FileSizeException ||
832                                     e instanceof NoSuchFolderException ||
833                                     e instanceof SourceFileNameException ||
834                                     e instanceof StorageFieldRequiredException) {
835    
836                            if (Validator.isNull(cmd)) {
837                                    UploadException uploadException =
838                                            (UploadException)actionRequest.getAttribute(
839                                                    WebKeys.UPLOAD_EXCEPTION);
840    
841                                    if (uploadException != null) {
842                                            String uploadExceptionRedirect = ParamUtil.getString(
843                                                    actionRequest, "uploadExceptionRedirect");
844    
845                                            actionResponse.sendRedirect(uploadExceptionRedirect);
846                                    }
847    
848                                    SessionErrors.add(actionRequest, e.getClass());
849    
850                                    return;
851                            }
852                            else if (!cmd.equals(Constants.ADD_DYNAMIC) &&
853                                             !cmd.equals(Constants.ADD_MULTIPLE) &&
854                                             !cmd.equals(Constants.ADD_TEMP)) {
855    
856                                    SessionErrors.add(actionRequest, e.getClass());
857    
858                                    return;
859                            }
860    
861                            if (e instanceof DuplicateFileException ||
862                                    e instanceof FileExtensionException ||
863                                    e instanceof FileNameException ||
864                                    e instanceof FileSizeException) {
865    
866                                    HttpServletResponse response =
867                                            PortalUtil.getHttpServletResponse(actionResponse);
868    
869                                    response.setContentType(ContentTypes.TEXT_HTML);
870                                    response.setStatus(HttpServletResponse.SC_OK);
871    
872                                    String errorMessage = StringPool.BLANK;
873                                    int errorType = 0;
874    
875                                    ThemeDisplay themeDisplay =
876                                            (ThemeDisplay)actionRequest.getAttribute(
877                                                    WebKeys.THEME_DISPLAY);
878    
879                                    if (e instanceof DuplicateFileException) {
880                                            errorMessage = themeDisplay.translate(
881                                                    "please-enter-a-unique-document-name");
882                                            errorType =
883                                                    ServletResponseConstants.SC_DUPLICATE_FILE_EXCEPTION;
884                                    }
885                                    else if (e instanceof FileExtensionException) {
886                                            errorMessage = themeDisplay.translate(
887                                                    "please-enter-a-file-with-a-valid-extension-x",
888                                                    StringUtil.merge(
889                                                            getAllowedFileExtensions(
890                                                                    portletConfig, actionRequest, actionResponse)));
891                                            errorType =
892                                                    ServletResponseConstants.SC_FILE_EXTENSION_EXCEPTION;
893                                    }
894                                    else if (e instanceof FileNameException) {
895                                            errorMessage = themeDisplay.translate(
896                                                    "please-enter-a-file-with-a-valid-file-name");
897                                            errorType = ServletResponseConstants.SC_FILE_NAME_EXCEPTION;
898                                    }
899                                    else if (e instanceof FileSizeException) {
900                                            long fileMaxSize = PrefsPropsUtil.getLong(
901                                                    PropsKeys.DL_FILE_MAX_SIZE);
902    
903                                            if (fileMaxSize == 0) {
904                                                    fileMaxSize = PrefsPropsUtil.getLong(
905                                                            PropsKeys.UPLOAD_SERVLET_REQUEST_IMPL_MAX_SIZE);
906                                            }
907    
908                                            fileMaxSize /= 1024;
909    
910                                            errorMessage = themeDisplay.translate(
911                                                    "please-enter-a-file-with-a-valid-file-size-no-larger" +
912                                                            "-than-x",
913                                                    fileMaxSize);
914    
915                                            errorType = ServletResponseConstants.SC_FILE_SIZE_EXCEPTION;
916                                    }
917    
918                                    JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
919    
920                                    jsonObject.put("message", errorMessage);
921                                    jsonObject.put("status", errorType);
922    
923                                    writeJSON(actionRequest, actionResponse, jsonObject);
924                            }
925    
926                            SessionErrors.add(actionRequest, e.getClass());
927                    }
928                    else if (e instanceof DuplicateLockException ||
929                                     e instanceof InvalidFileVersionException ||
930                                     e instanceof NoSuchFileEntryException ||
931                                     e instanceof PrincipalException) {
932    
933                            if (e instanceof DuplicateLockException) {
934                                    DuplicateLockException dle = (DuplicateLockException)e;
935    
936                                    SessionErrors.add(actionRequest, dle.getClass(), dle.getLock());
937                            }
938                            else {
939                                    SessionErrors.add(actionRequest, e.getClass());
940                            }
941    
942                            setForward(actionRequest, "portlet.document_library.error");
943                    }
944                    else {
945                            throw e;
946                    }
947            }
948    
949            protected void moveFileEntries(
950                            ActionRequest actionRequest, boolean moveFromTrash)
951                    throws Exception {
952    
953                    long[] fileEntryIds = null;
954    
955                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
956    
957                    if (fileEntryId > 0) {
958                            fileEntryIds = new long[] {fileEntryId};
959                    }
960                    else {
961                            fileEntryIds = StringUtil.split(
962                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
963                    }
964    
965                    long newFolderId = ParamUtil.getLong(actionRequest, "newFolderId");
966    
967                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
968                            DLFileEntry.class.getName(), actionRequest);
969    
970                    for (long moveFileEntryId : fileEntryIds) {
971                            if (moveFromTrash) {
972                                    DLAppServiceUtil.moveFileEntryFromTrash(
973                                            moveFileEntryId, newFolderId, serviceContext);
974                            }
975    
976                            else {
977                                    DLAppServiceUtil.moveFileEntry(
978                                            moveFileEntryId, newFolderId, serviceContext);
979                            }
980                    }
981            }
982    
983            protected void revertFileEntry(ActionRequest actionRequest)
984                    throws Exception {
985    
986                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
987                    String version = ParamUtil.getString(actionRequest, "version");
988    
989                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
990                            DLFileEntry.class.getName(), actionRequest);
991    
992                    DLAppServiceUtil.revertFileEntry(fileEntryId, version, serviceContext);
993            }
994    
995            protected FileEntry updateFileEntry(
996                            PortletConfig portletConfig, ActionRequest actionRequest,
997                            ActionResponse actionResponse)
998                    throws Exception {
999    
1000                    UploadPortletRequest uploadPortletRequest =
1001                            PortalUtil.getUploadPortletRequest(actionRequest);
1002    
1003                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
1004                            WebKeys.THEME_DISPLAY);
1005    
1006                    String cmd = ParamUtil.getString(uploadPortletRequest, Constants.CMD);
1007    
1008                    long fileEntryId = ParamUtil.getLong(
1009                            uploadPortletRequest, "fileEntryId");
1010    
1011                    long repositoryId = ParamUtil.getLong(
1012                            uploadPortletRequest, "repositoryId");
1013                    long folderId = ParamUtil.getLong(uploadPortletRequest, "folderId");
1014                    String sourceFileName = uploadPortletRequest.getFileName("file");
1015                    String title = ParamUtil.getString(uploadPortletRequest, "title");
1016                    String description = ParamUtil.getString(
1017                            uploadPortletRequest, "description");
1018                    String changeLog = ParamUtil.getString(
1019                            uploadPortletRequest, "changeLog");
1020                    boolean majorVersion = ParamUtil.getBoolean(
1021                            uploadPortletRequest, "majorVersion");
1022    
1023                    if (folderId > 0) {
1024                            Folder folder = DLAppServiceUtil.getFolder(folderId);
1025    
1026                            if (folder.getGroupId() != themeDisplay.getScopeGroupId()) {
1027                                    throw new NoSuchFolderException("{folderId=" + folderId + "}");
1028                            }
1029                    }
1030    
1031                    InputStream inputStream = null;
1032    
1033                    try {
1034                            String contentType = uploadPortletRequest.getContentType("file");
1035    
1036                            long size = uploadPortletRequest.getSize("file");
1037    
1038                            if ((cmd.equals(Constants.ADD) ||
1039                                     cmd.equals(Constants.ADD_DYNAMIC)) &&
1040                                    (size == 0)) {
1041    
1042                                    contentType = MimeTypesUtil.getContentType(title);
1043                            }
1044    
1045                            if (cmd.equals(Constants.ADD) ||
1046                                    cmd.equals(Constants.ADD_DYNAMIC) || (size > 0)) {
1047    
1048                                    String portletName = portletConfig.getPortletName();
1049    
1050                                    if (portletName.equals(PortletKeys.MEDIA_GALLERY_DISPLAY)) {
1051                                            PortletPreferences portletPreferences =
1052                                                    getStrictPortletSetup(actionRequest);
1053    
1054                                            if (portletPreferences == null) {
1055                                                    portletPreferences = actionRequest.getPreferences();
1056                                            }
1057    
1058                                            String[] mimeTypes = DLUtil.getMediaGalleryMimeTypes(
1059                                                    portletPreferences, actionRequest);
1060    
1061                                            if (Arrays.binarySearch(mimeTypes, contentType) < 0) {
1062                                                    throw new FileMimeTypeException(contentType);
1063                                            }
1064                                    }
1065                            }
1066    
1067                            inputStream = uploadPortletRequest.getFileAsStream("file");
1068    
1069                            ServiceContext serviceContext = ServiceContextFactory.getInstance(
1070                                    DLFileEntry.class.getName(), uploadPortletRequest);
1071    
1072                            FileEntry fileEntry = null;
1073    
1074                            if (cmd.equals(Constants.ADD) ||
1075                                    cmd.equals(Constants.ADD_DYNAMIC)) {
1076    
1077                                    // Add file entry
1078    
1079                                    fileEntry = DLAppServiceUtil.addFileEntry(
1080                                            repositoryId, folderId, sourceFileName, contentType, title,
1081                                            description, changeLog, inputStream, size, serviceContext);
1082    
1083                                    AssetPublisherUtil.addAndStoreSelection(
1084                                            actionRequest, DLFileEntry.class.getName(),
1085                                            fileEntry.getFileEntryId(), -1);
1086    
1087                                    if (cmd.equals(Constants.ADD_DYNAMIC)) {
1088                                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
1089    
1090                                            jsonObject.put("fileEntryId", fileEntry.getFileEntryId());
1091    
1092                                            writeJSON(actionRequest, actionResponse, jsonObject);
1093                                    }
1094                            }
1095                            else if (cmd.equals(Constants.UPDATE_AND_CHECKIN)) {
1096    
1097                                    // Update file entry and checkin
1098    
1099                                    fileEntry = DLAppServiceUtil.updateFileEntryAndCheckIn(
1100                                            fileEntryId, sourceFileName, contentType, title,
1101                                            description, changeLog, majorVersion, inputStream, size,
1102                                            serviceContext);
1103                            }
1104                            else {
1105    
1106                                    // Update file entry
1107    
1108                                    fileEntry = DLAppServiceUtil.updateFileEntry(
1109                                            fileEntryId, sourceFileName, contentType, title,
1110                                            description, changeLog, majorVersion, inputStream, size,
1111                                            serviceContext);
1112                            }
1113    
1114                            AssetPublisherUtil.addRecentFolderId(
1115                                    actionRequest, DLFileEntry.class.getName(), folderId);
1116    
1117                            return fileEntry;
1118                    }
1119                    catch (Exception e) {
1120                            UploadException uploadException =
1121                                    (UploadException)actionRequest.getAttribute(
1122                                            WebKeys.UPLOAD_EXCEPTION);
1123    
1124                            if (uploadException != null) {
1125                                    if (uploadException.isExceededLiferayFileItemSizeLimit()) {
1126                                            throw new LiferayFileItemException();
1127                                    }
1128                                    else if (uploadException.isExceededSizeLimit()) {
1129                                            throw new FileSizeException(uploadException.getCause());
1130                                    }
1131                            }
1132    
1133                            throw e;
1134                    }
1135                    finally {
1136                            StreamUtil.cleanUp(inputStream);
1137                    }
1138            }
1139    
1140            private static final String _TEMP_FOLDER_NAME =
1141                    EditFileEntryAction.class.getName();
1142    
1143    }