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.wiki.action;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.json.JSONFactoryUtil;
019    import com.liferay.portal.kernel.json.JSONObject;
020    import com.liferay.portal.kernel.repository.model.FileEntry;
021    import com.liferay.portal.kernel.servlet.SessionErrors;
022    import com.liferay.portal.kernel.servlet.SessionMessages;
023    import com.liferay.portal.kernel.upload.UploadException;
024    import com.liferay.portal.kernel.upload.UploadPortletRequest;
025    import com.liferay.portal.kernel.util.Constants;
026    import com.liferay.portal.kernel.util.KeyValuePair;
027    import com.liferay.portal.kernel.util.ObjectValuePair;
028    import com.liferay.portal.kernel.util.ParamUtil;
029    import com.liferay.portal.kernel.util.StreamUtil;
030    import com.liferay.portal.kernel.util.StringUtil;
031    import com.liferay.portal.kernel.util.TempFileUtil;
032    import com.liferay.portal.kernel.util.Validator;
033    import com.liferay.portal.portletfilerepository.PortletFileRepositoryUtil;
034    import com.liferay.portal.security.auth.PrincipalException;
035    import com.liferay.portal.struts.ActionConstants;
036    import com.liferay.portal.theme.ThemeDisplay;
037    import com.liferay.portal.util.PortalUtil;
038    import com.liferay.portal.util.WebKeys;
039    import com.liferay.portlet.documentlibrary.FileSizeException;
040    import com.liferay.portlet.documentlibrary.action.EditFileEntryAction;
041    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
042    import com.liferay.portlet.trash.util.TrashUtil;
043    import com.liferay.portlet.wiki.NoSuchNodeException;
044    import com.liferay.portlet.wiki.NoSuchPageException;
045    import com.liferay.portlet.wiki.model.WikiPage;
046    import com.liferay.portlet.wiki.service.WikiPageServiceUtil;
047    import com.liferay.portlet.wiki.util.WikiPageAttachmentsUtil;
048    
049    import java.io.InputStream;
050    
051    import java.util.ArrayList;
052    import java.util.HashMap;
053    import java.util.List;
054    import java.util.Map;
055    
056    import javax.portlet.ActionRequest;
057    import javax.portlet.ActionResponse;
058    import javax.portlet.PortletConfig;
059    import javax.portlet.RenderRequest;
060    import javax.portlet.RenderResponse;
061    
062    import org.apache.struts.action.ActionForm;
063    import org.apache.struts.action.ActionForward;
064    import org.apache.struts.action.ActionMapping;
065    
066    /**
067     * @author Jorge Ferrer
068     */
069    public class EditPageAttachmentsAction extends EditFileEntryAction {
070    
071            @Override
072            public void processAction(
073                            ActionMapping actionMapping, ActionForm actionForm,
074                            PortletConfig portletConfig, ActionRequest actionRequest,
075                            ActionResponse actionResponse)
076                    throws Exception {
077    
078                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
079    
080                    try {
081                            if (Validator.isNull(cmd)) {
082                                    UploadException uploadException =
083                                            (UploadException)actionRequest.getAttribute(
084                                                    WebKeys.UPLOAD_EXCEPTION);
085    
086                                    if (uploadException != null) {
087                                            if (uploadException.isExceededSizeLimit()) {
088                                                    throw new FileSizeException(uploadException.getCause());
089                                            }
090    
091                                            throw new PortalException(uploadException.getCause());
092                                    }
093                            }
094                            else if (cmd.equals(Constants.ADD)) {
095                                    addAttachment(actionRequest);
096                            }
097                            else if (cmd.equals(Constants.ADD_MULTIPLE)) {
098                                    addMultipleFileEntries(
099                                            portletConfig, actionRequest, actionResponse);
100                            }
101                            else if (cmd.equals(Constants.ADD_TEMP)) {
102                                    addTempAttachment(actionRequest);
103                            }
104                            else if (cmd.equals(Constants.DELETE)) {
105                                    deleteAttachment(actionRequest, false);
106                            }
107                            else if (cmd.equals(Constants.DELETE_TEMP)) {
108                                    deleteTempAttachment(actionRequest, actionResponse);
109                            }
110                            else if (cmd.equals(Constants.EMPTY_TRASH)) {
111                                    emptyTrash(actionRequest);
112                            }
113                            else if (cmd.equals(Constants.MOVE_FROM_TRASH)) {
114                                    restoreAttachmentFromTrash(actionRequest, actionResponse);
115                            }
116                            else if (cmd.equals(Constants.MOVE_TO_TRASH)) {
117                                    deleteAttachment(actionRequest, true);
118                            }
119                            else if (cmd.equals(Constants.RESTORE)) {
120                                    restoreAttachment(actionRequest);
121                            }
122    
123                            if (cmd.equals(Constants.ADD_TEMP) ||
124                                    cmd.equals(Constants.DELETE_TEMP)) {
125    
126                                    setForward(actionRequest, ActionConstants.COMMON_NULL);
127                            }
128                            else {
129                                    sendRedirect(actionRequest, actionResponse);
130                            }
131                    }
132                    catch (Exception e) {
133                            if (e instanceof NoSuchNodeException ||
134                                    e instanceof NoSuchPageException ||
135                                    e instanceof PrincipalException) {
136    
137                                    SessionErrors.add(actionRequest, e.getClass());
138    
139                                    setForward(actionRequest, "portlet.wiki.error");
140                            }
141                            else {
142                                    handleUploadException(
143                                            portletConfig, actionRequest, actionResponse, cmd, e);
144                            }
145                    }
146            }
147    
148            @Override
149            public ActionForward render(
150                            ActionMapping actionMapping, ActionForm actionForm,
151                            PortletConfig portletConfig, RenderRequest renderRequest,
152                            RenderResponse renderResponse)
153                    throws Exception {
154    
155                    try {
156                            ActionUtil.getNode(renderRequest);
157                            ActionUtil.getPage(renderRequest);
158                    }
159                    catch (Exception e) {
160                            if (e instanceof NoSuchNodeException ||
161                                    e instanceof NoSuchPageException ||
162                                    e instanceof PrincipalException) {
163    
164                                    SessionErrors.add(renderRequest, e.getClass());
165    
166                                    return actionMapping.findForward("portlet.wiki.error");
167                            }
168                            else {
169                                    throw e;
170                            }
171                    }
172    
173                    return actionMapping.findForward(
174                            getForward(renderRequest, "portlet.wiki.edit_page_attachment"));
175            }
176    
177            protected void addAttachment(ActionRequest actionRequest) throws Exception {
178                    UploadPortletRequest uploadPortletRequest =
179                            PortalUtil.getUploadPortletRequest(actionRequest);
180    
181                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
182                    String title = ParamUtil.getString(actionRequest, "title");
183    
184                    int numOfFiles = ParamUtil.getInteger(actionRequest, "numOfFiles");
185    
186                    List<ObjectValuePair<String, InputStream>> inputStreamOVPs =
187                            new ArrayList<ObjectValuePair<String, InputStream>>();
188    
189                    try {
190                            if (numOfFiles == 0) {
191                                    String fileName = uploadPortletRequest.getFileName("file");
192                                    InputStream inputStream = uploadPortletRequest.getFileAsStream(
193                                            "file");
194    
195                                    if (inputStream != null) {
196                                            ObjectValuePair<String, InputStream> inputStreamOVP =
197                                                    new ObjectValuePair<String, InputStream>(
198                                                            fileName, inputStream);
199    
200                                            inputStreamOVPs.add(inputStreamOVP);
201                                    }
202                            }
203                            else {
204                                    for (int i = 1; i <= numOfFiles; i++) {
205                                            String fileName = uploadPortletRequest.getFileName(
206                                                    "file" + i);
207                                            InputStream inputStream =
208                                                    uploadPortletRequest.getFileAsStream("file" + i);
209    
210                                            if (inputStream == null) {
211                                                    continue;
212                                            }
213    
214                                            ObjectValuePair<String, InputStream> inputStreamOVP =
215                                                    new ObjectValuePair<String, InputStream>(
216                                                            fileName, inputStream);
217    
218                                            inputStreamOVPs.add(inputStreamOVP);
219                                    }
220                            }
221    
222                            WikiPageServiceUtil.addPageAttachments(
223                                    nodeId, title, inputStreamOVPs);
224                    }
225                    finally {
226                            for (ObjectValuePair<String, InputStream> inputStreamOVP :
227                                            inputStreamOVPs) {
228    
229                                    InputStream inputStream = inputStreamOVP.getValue();
230    
231                                    StreamUtil.cleanUp(inputStream);
232                            }
233                    }
234            }
235    
236            @Override
237            protected void addMultipleFileEntries(
238                            PortletConfig portletConfig, ActionRequest actionRequest,
239                            ActionResponse actionResponse, String selectedFileName,
240                            List<String> validFileNames, List<KeyValuePair> invalidFileNameKVPs)
241                    throws Exception {
242    
243                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
244                            WebKeys.THEME_DISPLAY);
245    
246                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
247                    String title = ParamUtil.getString(actionRequest, "title");
248    
249                    FileEntry tempFileEntry = null;
250    
251                    try {
252                            tempFileEntry = TempFileUtil.getTempFile(
253                                    themeDisplay.getScopeGroupId(), themeDisplay.getUserId(),
254                                    selectedFileName, _TEMP_FOLDER_NAME);
255    
256                            InputStream inputStream = tempFileEntry.getContentStream();
257                            String mimeType = tempFileEntry.getMimeType();
258    
259                            WikiPageServiceUtil.addPageAttachment(
260                                    nodeId, title, selectedFileName, inputStream, mimeType);
261    
262                            validFileNames.add(selectedFileName);
263                    }
264                    catch (Exception e) {
265                            String errorMessage = getAddMultipleFileEntriesErrorMessage(
266                                    portletConfig, actionRequest, actionResponse, e);
267    
268                            KeyValuePair invalidFileNameKVP = new KeyValuePair(
269                                    selectedFileName, errorMessage);
270    
271                            invalidFileNameKVPs.add(invalidFileNameKVP);
272                    }
273                    finally {
274                            if (tempFileEntry != null) {
275                                    TempFileUtil.deleteTempFile(tempFileEntry.getFileEntryId());
276                            }
277                    }
278            }
279    
280            protected void addTempAttachment(ActionRequest actionRequest)
281                    throws Exception {
282    
283                    UploadPortletRequest uploadPortletRequest =
284                            PortalUtil.getUploadPortletRequest(actionRequest);
285    
286                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
287                    String sourceFileName = uploadPortletRequest.getFileName("file");
288    
289                    InputStream inputStream = null;
290    
291                    try {
292                            inputStream = uploadPortletRequest.getFileAsStream("file");
293    
294                            String mimeType = uploadPortletRequest.getContentType("file");
295    
296                            WikiPageServiceUtil.addTempPageAttachment(
297                                    nodeId, sourceFileName, _TEMP_FOLDER_NAME, inputStream,
298                                    mimeType);
299                    }
300                    finally {
301                            StreamUtil.cleanUp(inputStream);
302                    }
303            }
304    
305            protected void deleteAttachment(
306                            ActionRequest actionRequest, boolean moveToTrash)
307                    throws Exception {
308    
309                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
310                    String title = ParamUtil.getString(actionRequest, "title");
311                    String attachment = ParamUtil.getString(actionRequest, "fileName");
312    
313                    FileEntry fileEntry = null;
314    
315                    if (moveToTrash) {
316                            fileEntry = WikiPageServiceUtil.movePageAttachmentToTrash(
317                                    nodeId, title, attachment);
318                    }
319                    else {
320                            WikiPageServiceUtil.deletePageAttachment(nodeId, title, attachment);
321                    }
322    
323                    if (moveToTrash && (fileEntry != null)) {
324                            Map<String, String[]> data = new HashMap<String, String[]>();
325    
326                            data.put(Constants.CMD, new String[] {Constants.REMOVE});
327    
328                            data.put(
329                                    "deleteEntryClassName",
330                                    new String[] {DLFileEntry.class.getName()});
331    
332                            if (Validator.isNotNull(fileEntry.getTitle())) {
333                                    data.put(
334                                            "deleteEntryTitle",
335                                            new String[] {
336                                                    TrashUtil.getOriginalTitle(fileEntry.getTitle())});
337                            }
338    
339                            data.put(
340                                    "restoreEntryIds",
341                                    new String[] {String.valueOf(fileEntry.getFileEntryId())});
342    
343                            SessionMessages.add(
344                                    actionRequest,
345                                    PortalUtil.getPortletId(actionRequest) +
346                                            SessionMessages.KEY_SUFFIX_DELETE_SUCCESS_DATA, data);
347    
348                            hideDefaultSuccessMessage(actionRequest);
349                    }
350            }
351    
352            protected void deleteTempAttachment(
353                            ActionRequest actionRequest, ActionResponse actionResponse)
354                    throws Exception {
355    
356                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
357                            WebKeys.THEME_DISPLAY);
358    
359                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
360                    String fileName = ParamUtil.getString(actionRequest, "fileName");
361    
362                    JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
363    
364                    try {
365                            WikiPageServiceUtil.deleteTempPageAttachment(
366                                    nodeId, fileName, _TEMP_FOLDER_NAME);
367    
368                            jsonObject.put("deleted", Boolean.TRUE);
369                    }
370                    catch (Exception e) {
371                            String errorMessage = themeDisplay.translate(
372                                    "an-unexpected-error-occurred-while-deleting-the-file");
373    
374                            jsonObject.put("deleted", Boolean.FALSE);
375                            jsonObject.put("errorMessage", errorMessage);
376                    }
377    
378                    writeJSON(actionRequest, actionResponse, jsonObject);
379            }
380    
381            protected void emptyTrash(ActionRequest actionRequest) throws Exception {
382                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
383                    String title = ParamUtil.getString(actionRequest, "title");
384    
385                    WikiPageServiceUtil.deleteTrashPageAttachments(nodeId, title);
386            }
387    
388            protected void restoreAttachment(ActionRequest actionRequest)
389                    throws Exception {
390    
391                    long[] restoreEntryIds = StringUtil.split(
392                            ParamUtil.getString(actionRequest, "restoreEntryIds"), 0L);
393    
394                    for (long restoreEntryId : restoreEntryIds) {
395                            FileEntry fileEntry = PortletFileRepositoryUtil.getPortletFileEntry(
396                                    restoreEntryId);
397    
398                            WikiPage page = WikiPageAttachmentsUtil.getPage(
399                                    fileEntry.getFileEntryId());
400    
401                            WikiPageServiceUtil.restorePageAttachmentFromTrash(
402                                    page.getNodeId(), page.getTitle(), fileEntry.getTitle());
403                    }
404            }
405    
406            protected void restoreAttachmentFromTrash(
407                            ActionRequest actionRequest, ActionResponse actionResponse)
408                    throws Exception {
409    
410                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
411                    String title = ParamUtil.getString(actionRequest, "title");
412                    String fileName = ParamUtil.getString(actionRequest, "fileName");
413    
414                    JSONObject jsonObject =
415                            com.liferay.portlet.trash.action.ActionUtil.checkEntry(
416                                    actionRequest);
417    
418                    writeJSON(actionRequest, actionResponse, jsonObject);
419    
420                    WikiPageServiceUtil.restorePageAttachmentFromTrash(
421                            nodeId, title, fileName);
422            }
423    
424            private static final String _TEMP_FOLDER_NAME =
425                    EditPageAttachmentsAction.class.getName();
426    
427    }