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