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.wiki.action;
016    
017    import com.liferay.portal.kernel.servlet.SessionErrors;
018    import com.liferay.portal.kernel.util.Constants;
019    import com.liferay.portal.kernel.util.ParamUtil;
020    import com.liferay.portal.kernel.util.StringPool;
021    import com.liferay.portal.kernel.util.Validator;
022    import com.liferay.portal.kernel.workflow.WorkflowConstants;
023    import com.liferay.portal.model.Layout;
024    import com.liferay.portal.security.auth.PrincipalException;
025    import com.liferay.portal.service.ServiceContext;
026    import com.liferay.portal.service.ServiceContextFactory;
027    import com.liferay.portal.struts.PortletAction;
028    import com.liferay.portal.struts.StrutsActionPortletURL;
029    import com.liferay.portal.theme.ThemeDisplay;
030    import com.liferay.portal.util.WebKeys;
031    import com.liferay.portlet.PortletResponseImpl;
032    import com.liferay.portlet.PortletURLImpl;
033    import com.liferay.portlet.asset.AssetCategoryException;
034    import com.liferay.portlet.asset.AssetTagException;
035    import com.liferay.portlet.wiki.DuplicatePageException;
036    import com.liferay.portlet.wiki.NoSuchNodeException;
037    import com.liferay.portlet.wiki.NoSuchPageException;
038    import com.liferay.portlet.wiki.PageContentException;
039    import com.liferay.portlet.wiki.PageTitleException;
040    import com.liferay.portlet.wiki.PageVersionException;
041    import com.liferay.portlet.wiki.model.WikiNode;
042    import com.liferay.portlet.wiki.model.WikiPage;
043    import com.liferay.portlet.wiki.model.WikiPageConstants;
044    import com.liferay.portlet.wiki.service.WikiPageServiceUtil;
045    
046    import javax.portlet.ActionRequest;
047    import javax.portlet.ActionResponse;
048    import javax.portlet.PortletConfig;
049    import javax.portlet.PortletRequest;
050    import javax.portlet.RenderRequest;
051    import javax.portlet.RenderResponse;
052    
053    import org.apache.struts.action.ActionForm;
054    import org.apache.struts.action.ActionForward;
055    import org.apache.struts.action.ActionMapping;
056    
057    /**
058     * @author Brian Wing Shun Chan
059     * @author Jorge Ferrer
060     */
061    public class EditPageAction extends PortletAction {
062    
063            @Override
064            public void processAction(
065                            ActionMapping mapping, ActionForm form, PortletConfig portletConfig,
066                            ActionRequest actionRequest, ActionResponse actionResponse)
067                    throws Exception {
068    
069                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
070    
071                    WikiPage page = null;
072    
073                    try {
074                            if (cmd.equals(Constants.ADD) || cmd.equals(Constants.UPDATE)) {
075                                    page = updatePage(actionRequest);
076                            }
077                            else if (cmd.equals(Constants.DELETE)) {
078                                    deletePage(actionRequest);
079                            }
080                            else if (cmd.equals(Constants.REVERT)) {
081                                    revertPage(actionRequest);
082                            }
083                            else if (cmd.equals(Constants.SUBSCRIBE)) {
084                                    subscribePage(actionRequest);
085                            }
086                            else if (cmd.equals(Constants.UNSUBSCRIBE)) {
087                                    unsubscribePage(actionRequest);
088                            }
089    
090                            if (Validator.isNotNull(cmd)) {
091                                    String redirect = ParamUtil.getString(
092                                            actionRequest, "redirect");
093    
094                                    int workflowAction = ParamUtil.getInteger(
095                                            actionRequest, "workflowAction",
096                                            WorkflowConstants.ACTION_PUBLISH);
097    
098                                    if (page != null) {
099                                            if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
100                                                    redirect = getSaveAndContinueRedirect(
101                                                            actionRequest, actionResponse, page, redirect);
102                                            }
103                                            else if (redirect.endsWith("title=")) {
104                                                    redirect += page.getTitle();
105                                            }
106                                    }
107    
108                                    sendRedirect(actionRequest, actionResponse, redirect);
109                            }
110                    }
111                    catch (Exception e) {
112                            if (e instanceof NoSuchNodeException ||
113                                    e instanceof NoSuchPageException ||
114                                    e instanceof PrincipalException) {
115    
116                                    SessionErrors.add(actionRequest, e.getClass().getName());
117    
118                                    setForward(actionRequest, "portlet.wiki.error");
119                            }
120                            else if (e instanceof DuplicatePageException ||
121                                             e instanceof PageContentException ||
122                                             e instanceof PageVersionException ||
123                                             e instanceof PageTitleException) {
124    
125                                    SessionErrors.add(actionRequest, e.getClass().getName());
126                            }
127                            else if (e instanceof AssetCategoryException ||
128                                             e instanceof AssetTagException) {
129    
130                                    SessionErrors.add(actionRequest, e.getClass().getName(), e);
131                            }
132                            else {
133                                    throw e;
134                            }
135                    }
136            }
137    
138            @Override
139            public ActionForward render(
140                            ActionMapping mapping, ActionForm form, PortletConfig portletConfig,
141                            RenderRequest renderRequest, RenderResponse renderResponse)
142                    throws Exception {
143    
144                    try {
145                            ActionUtil.getNode(renderRequest);
146    
147                            if (!SessionErrors.contains(
148                                            renderRequest, DuplicatePageException.class.getName())) {
149    
150                                    getPage(renderRequest);
151                            }
152                    }
153                    catch (Exception e) {
154                            if (e instanceof NoSuchNodeException ||
155                                    e instanceof PageTitleException ||
156                                    e instanceof PrincipalException) {
157    
158                                    SessionErrors.add(renderRequest, e.getClass().getName());
159    
160                                    return mapping.findForward("portlet.wiki.error");
161                            }
162                            else if (e instanceof NoSuchPageException) {
163    
164                                    // Let edit_page.jsp handle this case
165    
166                            }
167                            else {
168                                    throw e;
169                            }
170                    }
171    
172                    return mapping.findForward(
173                            getForward(renderRequest, "portlet.wiki.edit_page"));
174            }
175    
176            protected void deletePage(ActionRequest actionRequest) throws Exception {
177                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
178                    String title = ParamUtil.getString(actionRequest, "title");
179                    double version = ParamUtil.getDouble(actionRequest, "version");
180    
181                    if (version > 0) {
182                            WikiPageServiceUtil.deletePage(nodeId, title, version);
183                    }
184                    else {
185                            WikiPageServiceUtil.deletePage(nodeId, title);
186                    }
187            }
188    
189            protected void getPage(RenderRequest renderRequest) throws Exception {
190                    long nodeId = ParamUtil.getLong(renderRequest, "nodeId");
191                    String title = ParamUtil.getString(renderRequest, "title");
192                    double version = ParamUtil.getDouble(renderRequest, "version");
193                    boolean removeRedirect = ParamUtil.getBoolean(
194                            renderRequest, "removeRedirect");
195    
196                    if (nodeId == 0) {
197                            WikiNode node = (WikiNode)renderRequest.getAttribute(
198                                    WebKeys.WIKI_NODE);
199    
200                            if (node != null) {
201                                    nodeId = node.getNodeId();
202                            }
203                    }
204    
205                    WikiPage page = null;
206    
207                    if (Validator.isNotNull(title)) {
208                            try {
209                                    if (version == 0) {
210                                            page = WikiPageServiceUtil.getPage(nodeId, title, null);
211                                    }
212                                    else {
213                                            page = WikiPageServiceUtil.getPage(nodeId, title, version);
214                                    }
215                            }
216                            catch (NoSuchPageException nspe1) {
217                                    try {
218                                            page = WikiPageServiceUtil.getPage(nodeId, title, false);
219                                    }
220                                    catch (NoSuchPageException nspe2) {
221                                            if ((title.equals(WikiPageConstants.FRONT_PAGE)) &&
222                                                    (version == 0)) {
223    
224                                                    ServiceContext serviceContext = new ServiceContext();
225    
226                                                    page = WikiPageServiceUtil.addPage(
227                                                            nodeId, title, null, WikiPageConstants.NEW, true,
228                                                            serviceContext);
229                                            }
230                                            else {
231                                                    throw nspe2;
232                                            }
233                                    }
234                            }
235    
236                            if (removeRedirect) {
237                                    page.setContent(StringPool.BLANK);
238                                    page.setRedirectTitle(StringPool.BLANK);
239                            }
240                    }
241    
242                    renderRequest.setAttribute(WebKeys.WIKI_PAGE, page);
243            }
244    
245            protected String getSaveAndContinueRedirect(
246                            ActionRequest actionRequest, ActionResponse actionResponse,
247                            WikiPage page, String redirect)
248                    throws Exception {
249    
250                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
251                            WebKeys.THEME_DISPLAY);
252    
253                    Layout layout = themeDisplay.getLayout();
254    
255                    String originalRedirect = ParamUtil.getString(
256                            actionRequest, "originalRedirect");
257    
258                    PortletURLImpl portletURL = new StrutsActionPortletURL(
259                            (PortletResponseImpl)actionResponse, themeDisplay.getPlid(),
260                            PortletRequest.RENDER_PHASE);
261    
262                    portletURL.setParameter("struts_action", "/wiki/edit_page");
263                    portletURL.setParameter(Constants.CMD, Constants.UPDATE, false);
264                    portletURL.setParameter("redirect", redirect, false);
265                    portletURL.setParameter("originalRedirect", originalRedirect, false);
266                    portletURL.setParameter(
267                            "groupId", String.valueOf(layout.getGroupId()), false);
268                    portletURL.setParameter(
269                            "nodeId", String.valueOf(page.getNodeId()), false);
270                    portletURL.setParameter("title", page.getTitle(), false);
271    
272                    return portletURL.toString();
273            }
274    
275            @Override
276            protected boolean isCheckMethodOnProcessAction() {
277                    return _CHECK_METHOD_ON_PROCESS_ACTION;
278            }
279    
280            protected void revertPage(ActionRequest actionRequest) throws Exception {
281                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
282                    String title = ParamUtil.getString(actionRequest, "title");
283                    double version = ParamUtil.getDouble(actionRequest, "version");
284    
285                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
286                            WikiPage.class.getName(), actionRequest);
287    
288                    WikiPageServiceUtil.revertPage(nodeId, title, version, serviceContext);
289            }
290    
291            protected void subscribePage(ActionRequest actionRequest) throws Exception {
292                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
293                    String title = ParamUtil.getString(actionRequest, "title");
294    
295                    WikiPageServiceUtil.subscribePage(nodeId, title);
296            }
297    
298            protected void unsubscribePage(ActionRequest actionRequest)
299                    throws Exception {
300    
301                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
302                    String title = ParamUtil.getString(actionRequest, "title");
303    
304                    WikiPageServiceUtil.unsubscribePage(nodeId, title);
305            }
306    
307            protected WikiPage updatePage(ActionRequest actionRequest)
308                    throws Exception {
309    
310                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
311    
312                    long nodeId = ParamUtil.getLong(actionRequest, "nodeId");
313                    String title = ParamUtil.getString(actionRequest, "title");
314                    double version = ParamUtil.getDouble(actionRequest, "version");
315    
316                    String content = ParamUtil.getString(actionRequest, "content");
317                    String summary = ParamUtil.getString(actionRequest, "summary");
318                    boolean minorEdit = ParamUtil.getBoolean(actionRequest, "minorEdit");
319                    String format = ParamUtil.getString(actionRequest, "format");
320                    String parentTitle = ParamUtil.getString(actionRequest, "parentTitle");
321                    String redirectTitle = null;
322    
323                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
324                            WikiPage.class.getName(), actionRequest);
325    
326                    WikiPage page = null;
327    
328                    if (cmd.equals(Constants.ADD)) {
329                            page = WikiPageServiceUtil.addPage(
330                                    nodeId, title, content, summary, minorEdit, format, parentTitle,
331                                    redirectTitle, serviceContext);
332                    }
333                    else {
334                            page = WikiPageServiceUtil.updatePage(
335                                    nodeId, title, version, content, summary, minorEdit, format,
336                                    parentTitle, redirectTitle, serviceContext);
337                    }
338    
339                    return page;
340            }
341    
342            private static final boolean _CHECK_METHOD_ON_PROCESS_ACTION = false;
343    
344    }