001    /**
002     * Copyright (c) 2000-present 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.trash;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.repository.model.FileEntry;
019    import com.liferay.portal.kernel.trash.TrashActionKeys;
020    import com.liferay.portal.kernel.trash.TrashHandler;
021    import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
022    import com.liferay.portal.kernel.trash.TrashRenderer;
023    import com.liferay.portal.kernel.util.HtmlUtil;
024    import com.liferay.portal.kernel.util.Validator;
025    import com.liferay.portal.kernel.workflow.WorkflowConstants;
026    import com.liferay.portal.model.ContainerModel;
027    import com.liferay.portal.model.LayoutConstants;
028    import com.liferay.portal.model.SystemEvent;
029    import com.liferay.portal.model.TrashedModel;
030    import com.liferay.portal.portletfilerepository.PortletFileRepositoryUtil;
031    import com.liferay.portal.security.permission.ActionKeys;
032    import com.liferay.portal.security.permission.PermissionChecker;
033    import com.liferay.portal.util.PortalUtil;
034    import com.liferay.portal.util.PortletKeys;
035    import com.liferay.portlet.PortletURLFactoryUtil;
036    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
037    import com.liferay.portlet.trash.RestoreEntryException;
038    import com.liferay.portlet.trash.TrashEntryConstants;
039    import com.liferay.portlet.trash.model.TrashEntry;
040    import com.liferay.portlet.trash.util.TrashUtil;
041    import com.liferay.portlet.wiki.asset.WikiPageAssetRenderer;
042    import com.liferay.portlet.wiki.model.WikiNode;
043    import com.liferay.portlet.wiki.model.WikiPage;
044    import com.liferay.portlet.wiki.model.WikiPageResource;
045    import com.liferay.portlet.wiki.service.WikiPageLocalServiceUtil;
046    import com.liferay.portlet.wiki.service.WikiPageResourceLocalServiceUtil;
047    import com.liferay.portlet.wiki.service.WikiPageServiceUtil;
048    import com.liferay.portlet.wiki.service.permission.WikiNodePermission;
049    import com.liferay.portlet.wiki.service.permission.WikiPagePermission;
050    import com.liferay.portlet.wiki.util.WikiPageAttachmentsUtil;
051    
052    import java.util.ArrayList;
053    import java.util.List;
054    
055    import javax.portlet.PortletRequest;
056    import javax.portlet.PortletURL;
057    
058    /**
059     * Implements trash handling for the wiki page entity.
060     *
061     * @author Eudaldo Alonso
062     * @author Roberto D??az
063     */
064    public class WikiPageTrashHandler extends BaseWikiTrashHandler {
065    
066            @Override
067            public SystemEvent addDeletionSystemEvent(
068                            long userId, long groupId, long classPK, String classUuid,
069                            String referrerClassName)
070                    throws PortalException {
071    
072                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
073                            classPK, WorkflowConstants.STATUS_ANY, false);
074    
075                    return super.addDeletionSystemEvent(
076                            userId, groupId, page.getPageId(), classUuid, referrerClassName);
077            }
078    
079            @Override
080            public void checkRestorableEntry(
081                            long classPK, long containerModelId, String newName)
082                    throws PortalException {
083    
084                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
085                            classPK, WorkflowConstants.STATUS_ANY, false);
086    
087                    checkRestorableEntry(
088                            classPK, 0, containerModelId, page.getTitle(), newName);
089            }
090    
091            @Override
092            public void checkRestorableEntry(
093                            TrashEntry trashEntry, long containerModelId, String newName)
094                    throws PortalException {
095    
096                    checkRestorableEntry(
097                            trashEntry.getClassPK(), trashEntry.getEntryId(), containerModelId,
098                            trashEntry.getTypeSettingsProperty("title"), newName);
099            }
100    
101            @Override
102            public void deleteTrashEntry(long classPK) throws PortalException {
103                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
104                            classPK, WorkflowConstants.STATUS_ANY, false);
105    
106                    WikiPageLocalServiceUtil.deletePage(page);
107            }
108    
109            @Override
110            public String getClassName() {
111                    return WikiPage.class.getName();
112            }
113    
114            @Override
115            public ContainerModel getParentContainerModel(long classPK)
116                    throws PortalException {
117    
118                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
119                            classPK, WorkflowConstants.STATUS_ANY, false);
120    
121                    return getParentContainerModel(page);
122            }
123    
124            @Override
125            public ContainerModel getParentContainerModel(TrashedModel trashedModel) {
126                    WikiPage page = (WikiPage)trashedModel;
127    
128                    if (Validator.isNotNull(page.getParentTitle())) {
129                            try {
130                                    WikiPage parentPage = page.getParentPage();
131    
132                                    while (parentPage.isInTrashImplicitly()) {
133                                            parentPage = parentPage.getParentPage();
134                                    }
135    
136                                    if (parentPage.isInTrashExplicitly()) {
137                                            return parentPage;
138                                    }
139                            }
140                            catch (Exception e) {
141                            }
142                    }
143    
144                    return page.getNode();
145            }
146    
147            @Override
148            public List<ContainerModel> getParentContainerModels(long classPK)
149                    throws PortalException {
150    
151                    List<ContainerModel> containerModels = new ArrayList<ContainerModel>();
152    
153                    containerModels.add(getParentContainerModel(classPK));
154    
155                    return containerModels;
156            }
157    
158            @Override
159            public String getRestoreContainedModelLink(
160                            PortletRequest portletRequest, long classPK)
161                    throws PortalException {
162    
163                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
164                            classPK, WorkflowConstants.STATUS_ANY, false);
165    
166                    WikiNode node = page.getNode();
167    
168                    PortletURL portletURL = getRestoreURL(portletRequest, classPK, false);
169    
170                    portletURL.setParameter("nodeName", node.getName());
171                    portletURL.setParameter("title", HtmlUtil.unescape(page.getTitle()));
172    
173                    return portletURL.toString();
174            }
175    
176            @Override
177            public String getRestoreContainerModelLink(
178                            PortletRequest portletRequest, long classPK)
179                    throws PortalException {
180    
181                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
182                            classPK, WorkflowConstants.STATUS_ANY, false);
183    
184                    WikiNode node = page.getNode();
185    
186                    PortletURL portletURL = getRestoreURL(portletRequest, classPK, true);
187    
188                    portletURL.setParameter("nodeId", String.valueOf(node.getNodeId()));
189    
190                    return portletURL.toString();
191            }
192    
193            @Override
194            public String getRestoreMessage(PortletRequest portletRequest, long classPK)
195                    throws PortalException {
196    
197                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
198                            classPK, WorkflowConstants.STATUS_ANY, false);
199    
200                    WikiNode node = page.getNode();
201    
202                    return node.getName();
203            }
204    
205            @Override
206            public String getTrashContainerModelName() {
207                    return "children-pages";
208            }
209    
210            @Override
211            public int getTrashContainerModelsCount(long classPK)
212                    throws PortalException {
213    
214                    WikiPage page = WikiPageLocalServiceUtil.getPage(classPK);
215    
216                    return WikiPageLocalServiceUtil.getChildrenCount(
217                            page.getNodeId(), true, page.getTitle(),
218                            WorkflowConstants.STATUS_IN_TRASH);
219            }
220    
221            @Override
222            public List<TrashRenderer> getTrashContainerModelTrashRenderers(
223                            long classPK, int start, int end)
224                    throws PortalException {
225    
226                    List<TrashRenderer> trashRenderers = new ArrayList<TrashRenderer>();
227    
228                    WikiPage page = WikiPageLocalServiceUtil.getPage(classPK);
229    
230                    List<WikiPage> pages = WikiPageLocalServiceUtil.getChildren(
231                            page.getNodeId(), true, page.getTitle(),
232                            WorkflowConstants.STATUS_IN_TRASH);
233    
234                    for (WikiPage curPage : pages) {
235                            TrashHandler trashHandler =
236                                    TrashHandlerRegistryUtil.getTrashHandler(
237                                            WikiPage.class.getName());
238    
239                            TrashRenderer trashRenderer = trashHandler.getTrashRenderer(
240                                    curPage.getResourcePrimKey());
241    
242                            trashRenderers.add(trashRenderer);
243                    }
244    
245                    return trashRenderers;
246            }
247    
248            @Override
249            public TrashEntry getTrashEntry(long classPK) throws PortalException {
250                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
251                            classPK, WorkflowConstants.STATUS_ANY, false);
252    
253                    return page.getTrashEntry();
254            }
255    
256            @Override
257            public TrashRenderer getTrashRenderer(long classPK) throws PortalException {
258                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
259                            classPK, WorkflowConstants.STATUS_ANY, false);
260    
261                    return new WikiPageAssetRenderer(page);
262            }
263    
264            @Override
265            public boolean hasTrashPermission(
266                            PermissionChecker permissionChecker, long groupId, long classPK,
267                            String trashActionId)
268                    throws PortalException {
269    
270                    if (trashActionId.equals(TrashActionKeys.MOVE)) {
271                            WikiPage page = WikiPageLocalServiceUtil.fetchLatestPage(
272                                    classPK, WorkflowConstants.STATUS_ANY, true);
273    
274                            if (page != null) {
275                                    WikiPagePermission.check(
276                                            permissionChecker, page.getNodeId(), page.getTitle(),
277                                            ActionKeys.DELETE);
278    
279                                    classPK = page.getNodeId();
280                            }
281    
282                            return WikiNodePermission.contains(
283                                    permissionChecker, classPK, ActionKeys.ADD_PAGE);
284                    }
285    
286                    return super.hasTrashPermission(
287                            permissionChecker, groupId, classPK, trashActionId);
288            }
289    
290            @Override
291            public boolean isContainerModel() {
292                    return true;
293            }
294    
295            @Override
296            public boolean isInTrash(long classPK) throws PortalException {
297                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
298                            classPK, WorkflowConstants.STATUS_ANY, false);
299    
300                    return page.isInTrash();
301            }
302    
303            @Override
304            public boolean isInTrashContainer(long classPK) throws PortalException {
305                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
306                            classPK, WorkflowConstants.STATUS_ANY, false);
307    
308                    return page.isInTrashContainer();
309            }
310    
311            @Override
312            public boolean isMovable() {
313                    return true;
314            }
315    
316            @Override
317            public boolean isRootContainerModelMovable() {
318                    return true;
319            }
320    
321            @Override
322            public void restoreRelatedTrashEntry(String className, long classPK)
323                    throws PortalException {
324    
325                    if (!className.equals(DLFileEntry.class.getName())) {
326                            return;
327                    }
328    
329                    FileEntry fileEntry = PortletFileRepositoryUtil.getPortletFileEntry(
330                            classPK);
331    
332                    WikiPage page = WikiPageAttachmentsUtil.getPage(classPK);
333    
334                    WikiPageServiceUtil.restorePageAttachmentFromTrash(
335                            page.getNodeId(), page.getTitle(), fileEntry.getTitle());
336            }
337    
338            @Override
339            public void restoreTrashEntry(long userId, long classPK)
340                    throws PortalException {
341    
342                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
343                            classPK, WorkflowConstants.STATUS_ANY, false);
344    
345                    WikiPageLocalServiceUtil.restorePageFromTrash(userId, page);
346            }
347    
348            @Override
349            public void updateTitle(long classPK, String name) throws PortalException {
350                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
351                            classPK, WorkflowConstants.STATUS_ANY, false);
352    
353                    page.setTitle(name);
354    
355                    WikiPageLocalServiceUtil.updateWikiPage(page);
356    
357                    WikiPageResource pageResource =
358                            WikiPageResourceLocalServiceUtil.getPageResource(
359                                    page.getResourcePrimKey());
360    
361                    pageResource.setTitle(name);
362    
363                    WikiPageResourceLocalServiceUtil.updateWikiPageResource(pageResource);
364            }
365    
366            protected void checkRestorableEntry(
367                            long classPK, long trashEntryId, long containerModelId,
368                            String originalTitle, String newName)
369                    throws PortalException {
370    
371                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
372                            classPK, WorkflowConstants.STATUS_ANY, false);
373    
374                    if (containerModelId == TrashEntryConstants.DEFAULT_CONTAINER_ID) {
375                            containerModelId = page.getNodeId();
376                    }
377    
378                    if (Validator.isNotNull(newName)) {
379                            originalTitle = newName;
380                    }
381    
382                    WikiPageResource duplicatePageResource =
383                            WikiPageResourceLocalServiceUtil.fetchPageResource(
384                                    containerModelId, originalTitle);
385    
386                    if (duplicatePageResource != null) {
387                            RestoreEntryException ree = new RestoreEntryException(
388                                    RestoreEntryException.DUPLICATE);
389    
390                            WikiPage duplicatePage = WikiPageLocalServiceUtil.getLatestPage(
391                                    duplicatePageResource.getResourcePrimKey(),
392                                    WorkflowConstants.STATUS_ANY, false);
393    
394                            ree.setDuplicateEntryId(duplicatePage.getResourcePrimKey());
395                            ree.setOldName(duplicatePage.getTitle());
396                            ree.setTrashEntryId(trashEntryId);
397    
398                            throw ree;
399                    }
400                    else {
401                            List<WikiPage> pages = WikiPageLocalServiceUtil.getDependentPages(
402                                    page.getNodeId(), true, page.getTitle(),
403                                    WorkflowConstants.STATUS_IN_TRASH);
404    
405                            for (WikiPage curPage : pages) {
406                                    checkRestorableEntry(
407                                            curPage.getResourcePrimKey(), 0, containerModelId,
408                                            curPage.getTitle(),
409                                            TrashUtil.getOriginalTitle(curPage.getTitle()));
410                            }
411                    }
412            }
413    
414            protected PortletURL getRestoreURL(
415                            PortletRequest portletRequest, long classPK,
416                            boolean isContainerModel)
417                    throws PortalException {
418    
419                    String portletId = PortletKeys.WIKI;
420    
421                    WikiPage page = WikiPageLocalServiceUtil.getLatestPage(
422                            classPK, WorkflowConstants.STATUS_ANY, false);
423    
424                    long plid = PortalUtil.getPlidFromPortletId(
425                            page.getGroupId(), PortletKeys.WIKI);
426    
427                    if (plid == LayoutConstants.DEFAULT_PLID) {
428                            portletId = PortletKeys.WIKI_ADMIN;
429    
430                            plid = PortalUtil.getControlPanelPlid(portletRequest);
431                    }
432    
433                    PortletURL portletURL = PortletURLFactoryUtil.create(
434                            portletRequest, portletId, plid, PortletRequest.RENDER_PHASE);
435    
436                    if (isContainerModel) {
437                            if (portletId.equals(PortletKeys.WIKI)) {
438                                    portletURL.setParameter(
439                                            "struts_action", "/wiki/view_all_pages");
440                            }
441                            else {
442                                    portletURL.setParameter(
443                                            "struts_action", "/wiki_admin/view_all_pages");
444                            }
445                    }
446                    else {
447                            if (portletId.equals(PortletKeys.WIKI)) {
448                                    portletURL.setParameter("struts_action", "/wiki/view");
449                            }
450                            else {
451                                    portletURL.setParameter("struts_action", "/wiki_admin/view");
452                            }
453                    }
454    
455                    return portletURL;
456            }
457    
458            @Override
459            protected boolean hasPermission(
460                            PermissionChecker permissionChecker, long classPK, String actionId)
461                    throws PortalException {
462    
463                    return WikiPagePermission.contains(
464                            permissionChecker, classPK, actionId);
465            }
466    
467    }