001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.documentlibrary.action;
016    
017    import com.liferay.portal.DuplicateLockException;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.json.JSONArray;
020    import com.liferay.portal.kernel.json.JSONFactoryUtil;
021    import com.liferay.portal.kernel.json.JSONObject;
022    import com.liferay.portal.kernel.language.LanguageUtil;
023    import com.liferay.portal.kernel.portlet.LiferayWindowState;
024    import com.liferay.portal.kernel.repository.model.FileEntry;
025    import com.liferay.portal.kernel.repository.model.Folder;
026    import com.liferay.portal.kernel.servlet.ServletResponseConstants;
027    import com.liferay.portal.kernel.servlet.SessionErrors;
028    import com.liferay.portal.kernel.upload.UploadException;
029    import com.liferay.portal.kernel.upload.UploadPortletRequest;
030    import com.liferay.portal.kernel.util.Constants;
031    import com.liferay.portal.kernel.util.KeyValuePair;
032    import com.liferay.portal.kernel.util.MimeTypesUtil;
033    import com.liferay.portal.kernel.util.ParamUtil;
034    import com.liferay.portal.kernel.util.PropsKeys;
035    import com.liferay.portal.kernel.util.StreamUtil;
036    import com.liferay.portal.kernel.util.StringPool;
037    import com.liferay.portal.kernel.util.StringUtil;
038    import com.liferay.portal.kernel.util.TempFileUtil;
039    import com.liferay.portal.kernel.util.Validator;
040    import com.liferay.portal.security.auth.PrincipalException;
041    import com.liferay.portal.service.ServiceContext;
042    import com.liferay.portal.service.ServiceContextFactory;
043    import com.liferay.portal.struts.ActionConstants;
044    import com.liferay.portal.struts.PortletAction;
045    import com.liferay.portal.theme.ThemeDisplay;
046    import com.liferay.portal.util.PortalUtil;
047    import com.liferay.portal.util.PortletKeys;
048    import com.liferay.portal.util.PrefsPropsUtil;
049    import com.liferay.portal.util.WebKeys;
050    import com.liferay.portlet.PortletPreferencesFactoryUtil;
051    import com.liferay.portlet.asset.AssetCategoryException;
052    import com.liferay.portlet.asset.AssetTagException;
053    import com.liferay.portlet.asset.model.AssetVocabulary;
054    import com.liferay.portlet.assetpublisher.util.AssetPublisherUtil;
055    import com.liferay.portlet.documentlibrary.DuplicateFileException;
056    import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
057    import com.liferay.portlet.documentlibrary.FileExtensionException;
058    import com.liferay.portlet.documentlibrary.FileMimeTypeException;
059    import com.liferay.portlet.documentlibrary.FileNameException;
060    import com.liferay.portlet.documentlibrary.FileSizeException;
061    import com.liferay.portlet.documentlibrary.InvalidFileEntryTypeException;
062    import com.liferay.portlet.documentlibrary.InvalidFileVersionException;
063    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
064    import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
065    import com.liferay.portlet.documentlibrary.NoSuchFolderException;
066    import com.liferay.portlet.documentlibrary.SourceFileNameException;
067    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
068    import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
069    import com.liferay.portlet.documentlibrary.util.DLUtil;
070    import com.liferay.portlet.dynamicdatamapping.StorageFieldRequiredException;
071    
072    import java.io.InputStream;
073    
074    import java.util.ArrayList;
075    import java.util.Arrays;
076    import java.util.List;
077    
078    import javax.portlet.ActionRequest;
079    import javax.portlet.ActionResponse;
080    import javax.portlet.PortletConfig;
081    import javax.portlet.PortletContext;
082    import javax.portlet.PortletPreferences;
083    import javax.portlet.PortletRequestDispatcher;
084    import javax.portlet.RenderRequest;
085    import javax.portlet.RenderResponse;
086    import javax.portlet.ResourceRequest;
087    import javax.portlet.ResourceResponse;
088    import javax.portlet.WindowState;
089    
090    import javax.servlet.http.HttpServletResponse;
091    
092    import org.apache.struts.action.ActionForm;
093    import org.apache.struts.action.ActionForward;
094    import org.apache.struts.action.ActionMapping;
095    
096    /**
097     * @author Brian Wing Shun Chan
098     * @author Alexander Chow
099     * @author Sergio González
100     */
101    public class EditFileEntryAction extends PortletAction {
102    
103            @Override
104            public void processAction(
105                            ActionMapping mapping, ActionForm form, PortletConfig portletConfig,
106                            ActionRequest actionRequest, ActionResponse actionResponse)
107                    throws Exception {
108    
109                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
110    
111                    try {
112                            if (Validator.isNull(cmd)) {
113                                    UploadException uploadException =
114                                            (UploadException)actionRequest.getAttribute(
115                                                    WebKeys.UPLOAD_EXCEPTION);
116    
117                                    if (uploadException != null) {
118                                            if (uploadException.isExceededSizeLimit()) {
119                                                    throw new FileSizeException(uploadException.getCause());
120                                            }
121    
122                                            throw new PortalException(uploadException.getCause());
123                                    }
124                            }
125                            else if (cmd.equals(Constants.ADD) ||
126                                             cmd.equals(Constants.UPDATE) ||
127                                             cmd.equals(Constants.UPDATE_AND_CHECKIN)) {
128    
129                                    updateFileEntry(portletConfig, actionRequest, actionResponse);
130                            }
131                            else if (cmd.equals(Constants.ADD_MULTIPLE)) {
132                                    addMultipleFileEntries(actionRequest, actionResponse);
133                            }
134                            else if (cmd.equals(Constants.ADD_TEMP)) {
135                                    addTempFileEntry(actionRequest);
136                            }
137                            else if (cmd.equals(Constants.DELETE)) {
138                                    deleteFileEntry(actionRequest);
139                            }
140                            else if (cmd.equals(Constants.DELETE_TEMP)) {
141                                    deleteTempFileEntry(actionRequest, actionResponse);
142                            }
143                            else if (cmd.equals(Constants.CANCEL_CHECKOUT)) {
144                                    cancelFileEntriesCheckOut(actionRequest);
145                            }
146                            else if (cmd.equals(Constants.CHECKIN)) {
147                                    checkInFileEntries(actionRequest);
148                            }
149                            else if (cmd.equals(Constants.CHECKOUT)) {
150                                    checkOutFileEntries(actionRequest);
151                            }
152                            else if (cmd.equals(Constants.MOVE)) {
153                                    moveFileEntries(actionRequest);
154                            }
155                            else if (cmd.equals(Constants.REVERT)) {
156                                    revertFileEntry(actionRequest);
157                            }
158    
159                            WindowState windowState = actionRequest.getWindowState();
160    
161                            if (cmd.equals(Constants.ADD_TEMP) ||
162                                    cmd.equals(Constants.DELETE_TEMP)) {
163    
164                                    setForward(actionRequest, ActionConstants.COMMON_NULL);
165                            }
166                            else if (cmd.equals(Constants.PREVIEW)) {
167                            }
168                            else if (!windowState.equals(LiferayWindowState.POP_UP)) {
169                                    sendRedirect(actionRequest, actionResponse);
170                            }
171                            else {
172                                    String redirect = PortalUtil.escapeRedirect(
173                                            ParamUtil.getString(actionRequest, "redirect"));
174    
175                                    if (Validator.isNotNull(redirect)) {
176                                            actionResponse.sendRedirect(redirect);
177                                    }
178                            }
179                    }
180                    catch (Exception e) {
181                            if (e instanceof DuplicateLockException ||
182                                    e instanceof InvalidFileVersionException ||
183                                    e instanceof NoSuchFileEntryException ||
184                                    e instanceof PrincipalException) {
185    
186                                    if (e instanceof DuplicateLockException) {
187                                            DuplicateLockException dle = (DuplicateLockException)e;
188    
189                                            SessionErrors.add(
190                                                    actionRequest, dle.getClass(), dle.getLock());
191                                    }
192                                    else {
193                                            SessionErrors.add(actionRequest, e.getClass());
194                                    }
195    
196                                    setForward(actionRequest, "portlet.document_library.error");
197                            }
198                            else if (e instanceof DuplicateFileException ||
199                                             e instanceof DuplicateFolderNameException ||
200                                             e instanceof FileExtensionException ||
201                                             e instanceof FileMimeTypeException ||
202                                             e instanceof FileNameException ||
203                                             e instanceof FileSizeException ||
204                                             e instanceof NoSuchFolderException ||
205                                             e instanceof SourceFileNameException ||
206                                             e instanceof StorageFieldRequiredException) {
207    
208                                    if (!cmd.equals(Constants.ADD_MULTIPLE) &&
209                                            !cmd.equals(Constants.ADD_TEMP)) {
210    
211                                            SessionErrors.add(actionRequest, e.getClass());
212    
213                                            return;
214                                    }
215    
216                                    if (e instanceof DuplicateFileException) {
217                                            HttpServletResponse response =
218                                                    PortalUtil.getHttpServletResponse(actionResponse);
219    
220                                            response.setStatus(
221                                                    ServletResponseConstants.SC_DUPLICATE_FILE_EXCEPTION);
222                                    }
223                                    else if (e instanceof FileExtensionException) {
224                                            HttpServletResponse response =
225                                                    PortalUtil.getHttpServletResponse(actionResponse);
226    
227                                            response.setStatus(
228                                                    ServletResponseConstants.SC_FILE_EXTENSION_EXCEPTION);
229                                    }
230                                    else if (e instanceof FileNameException) {
231                                            HttpServletResponse response =
232                                                    PortalUtil.getHttpServletResponse(actionResponse);
233    
234                                            response.setStatus(
235                                                    ServletResponseConstants.SC_FILE_NAME_EXCEPTION);
236                                    }
237                                    else if (e instanceof FileSizeException) {
238                                            HttpServletResponse response =
239                                                    PortalUtil.getHttpServletResponse(actionResponse);
240    
241                                            response.setStatus(
242                                                    ServletResponseConstants.SC_FILE_SIZE_EXCEPTION);
243                                    }
244    
245                                    SessionErrors.add(actionRequest, e.getClass());
246                            }
247                            else if (e instanceof AssetCategoryException ||
248                                             e instanceof AssetTagException) {
249    
250                                    SessionErrors.add(actionRequest, e.getClass(), e);
251                            }
252                            else {
253                                    throw e;
254                            }
255                    }
256            }
257    
258            @Override
259            public ActionForward render(
260                            ActionMapping mapping, ActionForm form, PortletConfig portletConfig,
261                            RenderRequest renderRequest, RenderResponse renderResponse)
262                    throws Exception {
263    
264                    try {
265                            ActionUtil.getFileEntry(renderRequest);
266                    }
267                    catch (Exception e) {
268                            if (e instanceof NoSuchFileEntryException ||
269                                    e instanceof NoSuchFileVersionException ||
270                                    e instanceof PrincipalException) {
271    
272                                    SessionErrors.add(renderRequest, e.getClass());
273    
274                                    return mapping.findForward("portlet.document_library.error");
275                            }
276                            else {
277                                    throw e;
278                            }
279                    }
280    
281                    String forward = "portlet.document_library.edit_file_entry";
282    
283                    return mapping.findForward(getForward(renderRequest, forward));
284            }
285    
286            @Override
287            public void serveResource(
288                            ActionMapping mapping, ActionForm form, PortletConfig portletConfig,
289                            ResourceRequest resourceRequest, ResourceResponse resourceResponse)
290                    throws Exception {
291    
292                    PortletContext portletContext = portletConfig.getPortletContext();
293    
294                    PortletRequestDispatcher portletRequestDispatcher =
295                            portletContext.getRequestDispatcher(
296                                    "/html/portlet/document_library/" +
297                                            "upload_multiple_file_entries_resources.jsp");
298    
299                    portletRequestDispatcher.include(resourceRequest, resourceResponse);
300            }
301    
302            protected void addMultipleFileEntries(
303                            ActionRequest actionRequest, ActionResponse actionResponse)
304                    throws Exception {
305    
306                    List<String> validFileNames = new ArrayList<String>();
307                    List<KeyValuePair> invalidFileNameKVPs = new ArrayList<KeyValuePair>();
308    
309                    String[] selectedFileNames = ParamUtil.getParameterValues(
310                            actionRequest, "selectedFileName");
311    
312                    for (String selectedFileName : selectedFileNames) {
313                            addMultipleFileEntries(
314                                    actionRequest, actionResponse, selectedFileName, validFileNames,
315                                    invalidFileNameKVPs);
316                    }
317    
318                    JSONArray jsonArray = JSONFactoryUtil.createJSONArray();
319    
320                    for (String validFileName : validFileNames) {
321                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
322    
323                            jsonObject.put("added", Boolean.TRUE);
324                            jsonObject.put("fileName", validFileName);
325    
326                            jsonArray.put(jsonObject);
327                    }
328    
329                    for (KeyValuePair invalidFileNameKVP : invalidFileNameKVPs) {
330                            String fileName = invalidFileNameKVP.getKey();
331                            String errorMessage = invalidFileNameKVP.getValue();
332    
333                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
334    
335                            jsonObject.put("added", Boolean.FALSE);
336                            jsonObject.put("errorMessage", errorMessage);
337                            jsonObject.put("fileName", fileName);
338    
339                            jsonArray.put(jsonObject);
340                    }
341    
342                    writeJSON(actionRequest, actionResponse, jsonArray);
343            }
344    
345            protected void addMultipleFileEntries(
346                            ActionRequest actionRequest, ActionResponse actionResponse,
347                            String selectedFileName, List<String> validFileNames,
348                            List<KeyValuePair> invalidFileNameKVPs)
349                    throws Exception {
350    
351                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
352                            WebKeys.THEME_DISPLAY);
353    
354                    long repositoryId = ParamUtil.getLong(actionRequest, "repositoryId");
355                    long folderId = ParamUtil.getLong(actionRequest, "folderId");
356                    String contentType = MimeTypesUtil.getContentType(selectedFileName);
357                    String description = ParamUtil.getString(actionRequest, "description");
358                    String changeLog = ParamUtil.getString(actionRequest, "changeLog");
359    
360                    String tempFileName = TempFileUtil.getTempFileName(
361                            themeDisplay.getUserId(), selectedFileName, _TEMP_FOLDER_NAME);
362    
363                    try {
364                            InputStream inputStream = TempFileUtil.getTempFileAsStream(
365                                    tempFileName);
366                            long size = TempFileUtil.getTempFileSize(tempFileName);
367    
368                            ServiceContext serviceContext = ServiceContextFactory.getInstance(
369                                    DLFileEntry.class.getName(), actionRequest);
370    
371                            FileEntry fileEntry = DLAppServiceUtil.addFileEntry(
372                                    repositoryId, folderId, selectedFileName, contentType,
373                                    selectedFileName, description, changeLog, inputStream, size,
374                                    serviceContext);
375    
376                            AssetPublisherUtil.addAndStoreSelection(
377                                    actionRequest, DLFileEntry.class.getName(),
378                                    fileEntry.getFileEntryId(), -1);
379    
380                            AssetPublisherUtil.addRecentFolderId(
381                                    actionRequest, DLFileEntry.class.getName(), folderId);
382    
383                            validFileNames.add(selectedFileName);
384    
385                            return;
386                    }
387                    catch (Exception e) {
388                            String errorMessage = getAddMultipleFileEntriesErrorMessage(
389                                    themeDisplay, e);
390    
391                            invalidFileNameKVPs.add(
392                                    new KeyValuePair(selectedFileName, errorMessage));
393                    }
394                    finally {
395                            TempFileUtil.deleteTempFile(tempFileName);
396                    }
397            }
398    
399            protected void addTempFileEntry(ActionRequest actionRequest)
400                    throws Exception {
401    
402                    UploadPortletRequest uploadPortletRequest =
403                            PortalUtil.getUploadPortletRequest(actionRequest);
404    
405                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
406                            WebKeys.THEME_DISPLAY);
407    
408                    long folderId = ParamUtil.getLong(uploadPortletRequest, "folderId");
409                    String sourceFileName = uploadPortletRequest.getFileName("file");
410    
411                    InputStream inputStream = null;
412    
413                    try {
414                            inputStream = uploadPortletRequest.getFileAsStream("file");
415    
416                            DLAppServiceUtil.addTempFileEntry(
417                                    themeDisplay.getScopeGroupId(), folderId, sourceFileName,
418                                    _TEMP_FOLDER_NAME, inputStream);
419                    }
420                    finally {
421                            StreamUtil.cleanUp(inputStream);
422                    }
423            }
424    
425            protected void cancelFileEntriesCheckOut(ActionRequest actionRequest)
426                    throws Exception {
427    
428                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
429    
430                    if (fileEntryId > 0) {
431                            DLAppServiceUtil.cancelCheckOut(fileEntryId);
432                    }
433                    else {
434                            long[] fileEntryIds = StringUtil.split(
435                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
436    
437                            for (int i = 0; i < fileEntryIds.length; i++) {
438                                    DLAppServiceUtil.cancelCheckOut(fileEntryIds[i]);
439                            }
440                    }
441            }
442    
443            protected void checkInFileEntries(ActionRequest actionRequest)
444                    throws Exception {
445    
446                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
447    
448                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
449                            actionRequest);
450    
451                    if (fileEntryId > 0) {
452                            DLAppServiceUtil.checkInFileEntry(
453                                    fileEntryId, false, StringPool.BLANK, serviceContext);
454                    }
455                    else {
456                            long[] fileEntryIds = StringUtil.split(
457                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
458    
459                            for (int i = 0; i < fileEntryIds.length; i++) {
460                                    DLAppServiceUtil.checkInFileEntry(
461                                            fileEntryIds[i], false, StringPool.BLANK, serviceContext);
462                            }
463                    }
464            }
465    
466            protected void checkOutFileEntries(ActionRequest actionRequest)
467                    throws Exception {
468    
469                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
470    
471                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
472                            actionRequest);
473    
474                    if (fileEntryId > 0) {
475                            DLAppServiceUtil.checkOutFileEntry(fileEntryId, serviceContext);
476                    }
477                    else {
478                            long[] fileEntryIds = StringUtil.split(
479                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
480    
481                            for (int i = 0; i < fileEntryIds.length; i++) {
482                                    DLAppServiceUtil.checkOutFileEntry(
483                                            fileEntryIds[i], serviceContext);
484                            }
485                    }
486            }
487    
488            protected void deleteFileEntry(ActionRequest actionRequest)
489                    throws Exception {
490    
491                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
492                    String version = ParamUtil.getString(actionRequest, "version");
493    
494                    if (fileEntryId == 0) {
495                            return;
496                    }
497    
498                    if (Validator.isNotNull(version)) {
499                            DLAppServiceUtil.deleteFileVersion(fileEntryId, version);
500                    }
501                    else {
502                            DLAppServiceUtil.deleteFileEntry(fileEntryId);
503                    }
504            }
505    
506            protected void deleteTempFileEntry(
507                            ActionRequest actionRequest, ActionResponse actionResponse)
508                    throws Exception {
509    
510                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
511                            WebKeys.THEME_DISPLAY);
512    
513                    long folderId = ParamUtil.getLong(actionRequest, "folderId");
514                    String fileName = ParamUtil.getString(actionRequest, "fileName");
515    
516                    JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
517    
518                    try {
519                            DLAppServiceUtil.deleteTempFileEntry(
520                                    themeDisplay.getScopeGroupId(), folderId, fileName,
521                                    _TEMP_FOLDER_NAME);
522    
523                            jsonObject.put("deleted", Boolean.TRUE);
524                    }
525                    catch (Exception e) {
526                            String errorMessage = LanguageUtil.get(
527                                    themeDisplay.getLocale(),
528                                    "an-unexpected-error-occurred-while-deleting-the-file");
529    
530                            jsonObject.put("deleted", Boolean.FALSE);
531                            jsonObject.put("errorMessage", errorMessage);
532                    }
533    
534                    writeJSON(actionRequest, actionResponse, jsonObject);
535            }
536    
537            protected String getAddMultipleFileEntriesErrorMessage(
538                            ThemeDisplay themeDisplay, Exception e)
539                    throws Exception {
540    
541                    String errorMessage = null;
542    
543                    if (e instanceof AssetCategoryException) {
544                            AssetCategoryException ace = (AssetCategoryException)e;
545    
546                            AssetVocabulary assetVocabulary = ace.getVocabulary();
547    
548                            String vocabularyTitle = StringPool.BLANK;
549    
550                            if (assetVocabulary != null) {
551                                    vocabularyTitle = assetVocabulary.getTitle(
552                                            themeDisplay.getLocale());
553                            }
554    
555                            if (ace.getType() == AssetCategoryException.AT_LEAST_ONE_CATEGORY) {
556                                    errorMessage = LanguageUtil.format(
557                                            themeDisplay.getLocale(),
558                                            "please-select-at-least-one-category-for-x",
559                                            vocabularyTitle);
560                            }
561                            else if (ace.getType() ==
562                                                    AssetCategoryException.TOO_MANY_CATEGORIES) {
563    
564                                    errorMessage = LanguageUtil.format(
565                                            themeDisplay.getLocale(),
566                                            "you-cannot-select-more-than-one-category-for-x",
567                                            vocabularyTitle);
568                            }
569                    }
570                    else if (e instanceof DuplicateFileException) {
571                            errorMessage = LanguageUtil.get(
572                                    themeDisplay.getLocale(),
573                                    "the-folder-you-selected-already-has-an-entry-with-this-name." +
574                                            "-please-select-a-different-folder");
575                    }
576                    else if (e instanceof FileExtensionException) {
577                            errorMessage = LanguageUtil.format(
578                                    themeDisplay.getLocale(),
579                                    "please-enter-a-file-with-a-valid-extension-x",
580                                    StringUtil.merge(
581                                            PrefsPropsUtil.getStringArray(
582                                                    PropsKeys.DL_FILE_EXTENSIONS, StringPool.COMMA)));
583                    }
584                    else if (e instanceof FileNameException) {
585                            errorMessage = LanguageUtil.get(
586                                    themeDisplay.getLocale(),
587                                    "please-enter-a-file-with-a-valid-file-name");
588                    }
589                    else if (e instanceof FileSizeException) {
590                            long maxSizeMB = PrefsPropsUtil.getLong(
591                                    PropsKeys.DL_FILE_MAX_SIZE) / 1024 / 1024;
592    
593                            errorMessage = LanguageUtil.format(
594                                    themeDisplay.getLocale(),
595                                    "file-size-is-larger-than-x-megabytes", maxSizeMB);
596                    }
597                    else if (e instanceof InvalidFileEntryTypeException) {
598                            errorMessage = LanguageUtil.get(
599                                    themeDisplay.getLocale(),
600                                    "the-document-type-you-selected-is-not-valid-for-this-folder");
601                    }
602                    else {
603                            errorMessage = LanguageUtil.get(
604                                    themeDisplay.getLocale(),
605                                    "an-unexpected-error-occurred-while-saving-your-document");
606                    }
607    
608                    return errorMessage;
609            }
610    
611            protected void moveFileEntries(ActionRequest actionRequest)
612                    throws Exception {
613    
614                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
615                    long newFolderId = ParamUtil.getLong(actionRequest, "newFolderId");
616    
617                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
618                            DLFileEntry.class.getName(), actionRequest);
619    
620                    if (fileEntryId > 0) {
621                            DLAppServiceUtil.moveFileEntry(
622                                    fileEntryId, newFolderId, serviceContext);
623                    }
624                    else {
625                            long[] fileEntryIds = StringUtil.split(
626                                    ParamUtil.getString(actionRequest, "fileEntryIds"), 0L);
627    
628                            for (int i = 0; i < fileEntryIds.length; i++) {
629                                    DLAppServiceUtil.moveFileEntry(
630                                            fileEntryIds[i], newFolderId, serviceContext);
631                            }
632                    }
633            }
634    
635            protected void revertFileEntry(ActionRequest actionRequest)
636                    throws Exception {
637    
638                    long fileEntryId = ParamUtil.getLong(actionRequest, "fileEntryId");
639                    String version = ParamUtil.getString(actionRequest, "version");
640    
641                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
642                            DLFileEntry.class.getName(), actionRequest);
643    
644                    DLAppServiceUtil.revertFileEntry(fileEntryId, version, serviceContext);
645            }
646    
647            protected void updateFileEntry(
648                            PortletConfig portletConfig, ActionRequest actionRequest,
649                            ActionResponse actionResponse)
650                    throws Exception {
651    
652                    UploadPortletRequest uploadPortletRequest =
653                            PortalUtil.getUploadPortletRequest(actionRequest);
654    
655                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
656                            WebKeys.THEME_DISPLAY);
657    
658                    String cmd = ParamUtil.getString(uploadPortletRequest, Constants.CMD);
659    
660                    long fileEntryId = ParamUtil.getLong(
661                            uploadPortletRequest, "fileEntryId");
662    
663                    long repositoryId = ParamUtil.getLong(
664                            uploadPortletRequest, "repositoryId");
665                    long folderId = ParamUtil.getLong(uploadPortletRequest, "folderId");
666                    String sourceFileName = uploadPortletRequest.getFileName("file");
667                    String title = ParamUtil.getString(uploadPortletRequest, "title");
668                    String description = ParamUtil.getString(
669                            uploadPortletRequest, "description");
670                    String changeLog = ParamUtil.getString(
671                            uploadPortletRequest, "changeLog");
672                    boolean majorVersion = ParamUtil.getBoolean(
673                            uploadPortletRequest, "majorVersion");
674    
675                    if (folderId > 0) {
676                            Folder folder = DLAppServiceUtil.getFolder(folderId);
677    
678                            if (folder.getGroupId() != themeDisplay.getScopeGroupId()) {
679                                    throw new NoSuchFolderException();
680                            }
681                    }
682    
683                    InputStream inputStream = null;
684    
685                    try {
686                            String contentType = uploadPortletRequest.getContentType("file");
687    
688                            long size = uploadPortletRequest.getSize("file");
689    
690                            if (cmd.equals(Constants.ADD) && (size == 0)) {
691                                    contentType = MimeTypesUtil.getContentType(title);
692                            }
693    
694                            if (cmd.equals(Constants.ADD) || (size > 0)) {
695                                    String portletName = portletConfig.getPortletName();
696    
697                                    if (portletName.equals(PortletKeys.MEDIA_GALLERY_DISPLAY)) {
698                                            String portletResource = ParamUtil.getString(
699                                                    actionRequest, "portletResource");
700    
701                                            PortletPreferences portletPreferences = null;
702    
703                                            if (Validator.isNotNull(portletResource)) {
704                                                    PortletPreferencesFactoryUtil.getPortletSetup(
705                                                            actionRequest, portletResource);
706                                            }
707                                            else {
708                                                    portletPreferences = actionRequest.getPreferences();
709                                            }
710    
711                                            String[] mimeTypes = DLUtil.getMediaGalleryMimeTypes(
712                                                    portletPreferences, actionRequest);
713    
714                                            if (Arrays.binarySearch(mimeTypes, contentType) < 0) {
715                                                    throw new FileMimeTypeException(contentType);
716                                            }
717                                    }
718                            }
719    
720                            inputStream = uploadPortletRequest.getFileAsStream("file");
721    
722                            ServiceContext serviceContext = ServiceContextFactory.getInstance(
723                                    DLFileEntry.class.getName(), uploadPortletRequest);
724    
725                            FileEntry fileEntry = null;
726    
727                            if (cmd.equals(Constants.ADD)) {
728    
729                                    // Add file entry
730    
731                                    fileEntry = DLAppServiceUtil.addFileEntry(
732                                            repositoryId, folderId, sourceFileName, contentType, title,
733                                            description, changeLog, inputStream, size, serviceContext);
734    
735                                    AssetPublisherUtil.addAndStoreSelection(
736                                            actionRequest, DLFileEntry.class.getName(),
737                                            fileEntry.getFileEntryId(), -1);
738                            }
739                            else if (cmd.equals(Constants.UPDATE_AND_CHECKIN)) {
740    
741                                    // Update file entry and checkin
742    
743                                    fileEntry = DLAppServiceUtil.updateFileEntryAndCheckIn(
744                                            fileEntryId, sourceFileName, contentType, title,
745                                            description, changeLog, majorVersion, inputStream, size,
746                                            serviceContext);
747                            }
748                            else {
749    
750                                    // Update file entry
751    
752                                    fileEntry = DLAppServiceUtil.updateFileEntry(
753                                            fileEntryId, sourceFileName, contentType, title,
754                                            description, changeLog, majorVersion, inputStream, size,
755                                            serviceContext);
756                            }
757    
758                            AssetPublisherUtil.addRecentFolderId(
759                                    actionRequest, DLFileEntry.class.getName(), folderId);
760                    }
761                    finally {
762                            StreamUtil.cleanUp(inputStream);
763                    }
764            }
765    
766            private static final String _TEMP_FOLDER_NAME =
767                    EditFileEntryAction.class.getName();
768    
769    }