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.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.language.LanguageUtil;
020    import com.liferay.portal.kernel.repository.model.FileEntry;
021    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
022    import com.liferay.portal.kernel.util.HtmlUtil;
023    import com.liferay.portal.kernel.util.HttpUtil;
024    import com.liferay.portal.kernel.util.ObjectValuePair;
025    import com.liferay.portal.kernel.util.OrderByComparator;
026    import com.liferay.portal.kernel.util.StringBundler;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.kernel.workflow.WorkflowConstants;
030    import com.liferay.portal.security.permission.ActionKeys;
031    import com.liferay.portal.service.ServiceContext;
032    import com.liferay.portal.util.PortalUtil;
033    import com.liferay.portal.util.PortletKeys;
034    import com.liferay.portal.util.PropsValues;
035    import com.liferay.portlet.wiki.NoSuchPageException;
036    import com.liferay.portlet.wiki.model.WikiNode;
037    import com.liferay.portlet.wiki.model.WikiPage;
038    import com.liferay.portlet.wiki.model.WikiPageConstants;
039    import com.liferay.portlet.wiki.service.base.WikiPageServiceBaseImpl;
040    import com.liferay.portlet.wiki.service.permission.WikiNodePermission;
041    import com.liferay.portlet.wiki.service.permission.WikiPagePermission;
042    import com.liferay.portlet.wiki.util.WikiUtil;
043    import com.liferay.portlet.wiki.util.comparator.PageCreateDateComparator;
044    import com.liferay.util.RSSUtil;
045    
046    import com.sun.syndication.feed.synd.SyndContent;
047    import com.sun.syndication.feed.synd.SyndContentImpl;
048    import com.sun.syndication.feed.synd.SyndEntry;
049    import com.sun.syndication.feed.synd.SyndEntryImpl;
050    import com.sun.syndication.feed.synd.SyndFeed;
051    import com.sun.syndication.feed.synd.SyndFeedImpl;
052    import com.sun.syndication.feed.synd.SyndLink;
053    import com.sun.syndication.feed.synd.SyndLinkImpl;
054    import com.sun.syndication.io.FeedException;
055    
056    import java.io.File;
057    import java.io.InputStream;
058    
059    import java.util.ArrayList;
060    import java.util.Calendar;
061    import java.util.Date;
062    import java.util.List;
063    import java.util.Locale;
064    
065    /**
066     * Provides the remote service for accessing, adding, deleting, moving,
067     * subscription handling of, trash handling of, and updating wiki pages and wiki
068     * page attachments. Its methods include permission checks.
069     *
070     * @author Brian Wing Shun Chan
071     * @author Jorge Ferrer
072     * @author Raymond Aug??
073     */
074    public class WikiPageServiceImpl extends WikiPageServiceBaseImpl {
075    
076            @Override
077            public WikiPage addPage(
078                            long nodeId, String title, String content, String summary,
079                            boolean minorEdit, ServiceContext serviceContext)
080                    throws PortalException {
081    
082                    WikiNodePermission.check(
083                            getPermissionChecker(), nodeId, ActionKeys.ADD_PAGE);
084    
085                    return wikiPageLocalService.addPage(
086                            getUserId(), nodeId, title, content, summary, minorEdit,
087                            serviceContext);
088            }
089    
090            @Override
091            public WikiPage addPage(
092                            long nodeId, String title, String content, String summary,
093                            boolean minorEdit, String format, String parentTitle,
094                            String redirectTitle, ServiceContext serviceContext)
095                    throws PortalException {
096    
097                    WikiNodePermission.check(
098                            getPermissionChecker(), nodeId, ActionKeys.ADD_PAGE);
099    
100                    return wikiPageLocalService.addPage(
101                            getUserId(), nodeId, title, WikiPageConstants.VERSION_DEFAULT,
102                            content, summary, minorEdit, format, true, parentTitle,
103                            redirectTitle, serviceContext);
104            }
105    
106            @Override
107            public void addPageAttachment(
108                            long nodeId, String title, String fileName, File file,
109                            String mimeType)
110                    throws PortalException {
111    
112                    WikiNodePermission.check(
113                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
114    
115                    wikiPageLocalService.addPageAttachment(
116                            getUserId(), nodeId, title, fileName, file, mimeType);
117            }
118    
119            @Override
120            public void addPageAttachment(
121                            long nodeId, String title, String fileName, InputStream inputStream,
122                            String mimeType)
123                    throws PortalException {
124    
125                    WikiNodePermission.check(
126                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
127    
128                    wikiPageLocalService.addPageAttachment(
129                            getUserId(), nodeId, title, fileName, inputStream, mimeType);
130            }
131    
132            @Override
133            public void addPageAttachments(
134                            long nodeId, String title,
135                            List<ObjectValuePair<String, InputStream>> inputStreamOVPs)
136                    throws PortalException {
137    
138                    WikiNodePermission.check(
139                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
140    
141                    wikiPageLocalService.addPageAttachments(
142                            getUserId(), nodeId, title, inputStreamOVPs);
143            }
144    
145            @Override
146            public void addTempFileEntry(
147                            long nodeId, String folderName, String fileName,
148                            InputStream inputStream, String mimeType)
149                    throws PortalException {
150    
151                    WikiNode node = wikiNodeLocalService.getNode(nodeId);
152    
153                    WikiNodePermission.check(
154                            getPermissionChecker(), node, ActionKeys.ADD_ATTACHMENT);
155    
156                    wikiPageLocalService.addTempFileEntry(
157                            node.getGroupId(), getUserId(), folderName, fileName, inputStream,
158                            mimeType);
159            }
160    
161            /**
162             * @deprecated As of 7.0.0 replaced by {@link #addTempFileEntry(long,
163             *             String, String, InputStream, String)}
164             */
165            @Deprecated
166            @Override
167            public void addTempPageAttachment(
168                            long nodeId, String fileName, String tempFolderName,
169                            InputStream inputStream, String mimeType)
170                    throws PortalException {
171    
172                    addTempFileEntry(
173                            nodeId, tempFolderName, fileName, inputStream, mimeType);
174            }
175    
176            @Override
177            public void changeNode(
178                            long nodeId, String title, long newNodeId,
179                            ServiceContext serviceContext)
180                    throws PortalException {
181    
182                    WikiPagePermission.check(
183                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
184    
185                    WikiNodePermission.check(
186                            getPermissionChecker(), newNodeId, ActionKeys.ADD_PAGE);
187    
188                    wikiPageLocalService.changeNode(
189                            getUserId(), nodeId, title, newNodeId, serviceContext);
190            }
191    
192            @Override
193            public void changeParent(
194                            long nodeId, String title, String newParentTitle,
195                            ServiceContext serviceContext)
196                    throws PortalException {
197    
198                    WikiPagePermission.check(
199                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
200    
201                    WikiNodePermission.check(
202                            getPermissionChecker(), nodeId, ActionKeys.ADD_PAGE);
203    
204                    wikiPageLocalService.changeParent(
205                            getUserId(), nodeId, title, newParentTitle, serviceContext);
206            }
207    
208            @Override
209            public void copyPageAttachments(
210                            long templateNodeId, String templateTitle, long nodeId,
211                            String title)
212                    throws PortalException {
213    
214                    WikiNodePermission.check(
215                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
216    
217                    wikiPageLocalService.copyPageAttachments(
218                            getUserId(), templateNodeId, templateTitle, nodeId, title);
219            }
220    
221            @Override
222            public void deletePage(long nodeId, String title) throws PortalException {
223                    WikiPagePermission.check(
224                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
225    
226                    wikiPageLocalService.deletePage(nodeId, title);
227            }
228    
229            /**
230             * @deprecated As of 6.2.0 replaced by {@link #discardDraft(long, String,
231             *             double)}
232             */
233            @Deprecated
234            @Override
235            public void deletePage(long nodeId, String title, double version)
236                    throws PortalException {
237    
238                    discardDraft(nodeId, title, version);
239            }
240    
241            @Override
242            public void deletePageAttachment(long nodeId, String title, String fileName)
243                    throws PortalException {
244    
245                    WikiPagePermission.check(
246                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
247    
248                    wikiPageLocalService.deletePageAttachment(nodeId, title, fileName);
249            }
250    
251            @Override
252            public void deletePageAttachments(long nodeId, String title)
253                    throws PortalException {
254    
255                    WikiPagePermission.check(
256                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
257    
258                    wikiPageLocalService.deletePageAttachments(nodeId, title);
259            }
260    
261            @Override
262            public void deleteTempFileEntry(
263                            long nodeId, String folderName, String fileName)
264                    throws PortalException {
265    
266                    WikiNode node = wikiNodeLocalService.getNode(nodeId);
267    
268                    WikiNodePermission.check(
269                            getPermissionChecker(), node, ActionKeys.ADD_ATTACHMENT);
270    
271                    wikiPageLocalService.deleteTempFileEntry(
272                            node.getGroupId(), getUserId(), folderName, fileName);
273            }
274    
275            @Override
276            public void deleteTrashPageAttachments(long nodeId, String title)
277                    throws PortalException {
278    
279                    WikiPagePermission.check(
280                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
281    
282                    wikiPageLocalService.deleteTrashPageAttachments(nodeId, title);
283            }
284    
285            @Override
286            public void discardDraft(long nodeId, String title, double version)
287                    throws PortalException {
288    
289                    WikiPagePermission.check(
290                            getPermissionChecker(), nodeId, title, version, ActionKeys.DELETE);
291    
292                    wikiPageLocalService.discardDraft(nodeId, title, version);
293            }
294    
295            @Override
296            public WikiPage fetchPage(long nodeId, String title, double version)
297                    throws PortalException {
298    
299                    WikiPagePermission.check(
300                            getPermissionChecker(), nodeId, title, version, ActionKeys.VIEW);
301    
302                    return wikiPageLocalService.fetchPage(nodeId, title, version);
303            }
304    
305            @Override
306            public List<WikiPage> getChildren(
307                            long groupId, long nodeId, boolean head, String parentTitle)
308                    throws PortalException {
309    
310                    WikiNodePermission.check(
311                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
312    
313                    return wikiPagePersistence.filterFindByG_N_H_P_S(
314                            groupId, nodeId, head, parentTitle,
315                            WorkflowConstants.STATUS_APPROVED);
316            }
317    
318            @Override
319            public WikiPage getDraftPage(long nodeId, String title)
320                    throws PortalException {
321    
322                    WikiPagePermission.check(
323                            getPermissionChecker(), nodeId, title, ActionKeys.VIEW);
324    
325                    return wikiPageLocalService.getDraftPage(nodeId, title);
326            }
327    
328            @Override
329            public List<WikiPage> getNodePages(long nodeId, int max)
330                    throws PortalException {
331    
332                    List<WikiPage> pages = new ArrayList<WikiPage>();
333    
334                    int lastIntervalStart = 0;
335                    boolean listNotExhausted = true;
336    
337                    while ((pages.size() < max) && listNotExhausted) {
338                            List<WikiPage> pageList = wikiPageLocalService.getPages(
339                                    nodeId, true, lastIntervalStart, lastIntervalStart + max);
340    
341                            lastIntervalStart += max;
342                            listNotExhausted = (pageList.size() == max);
343    
344                            for (WikiPage page : pageList) {
345                                    if (pages.size() >= max) {
346                                            break;
347                                    }
348    
349                                    if (WikiPagePermission.contains(
350                                                    getPermissionChecker(), page, ActionKeys.VIEW)) {
351    
352                                            pages.add(page);
353                                    }
354                            }
355                    }
356    
357                    return pages;
358            }
359    
360            /**
361             * @deprecated As of 6.2.0, replaced by {@link #getNodePagesRSS(long, int,
362             *             String, double, String, String, String, String)}
363             */
364            @Deprecated
365            @Override
366            public String getNodePagesRSS(
367                            long nodeId, int max, String type, double version,
368                            String displayStyle, String feedURL, String entryURL)
369                    throws PortalException {
370    
371                    return getNodePagesRSS(
372                            nodeId, max, type, version, displayStyle, feedURL, entryURL, null);
373            }
374    
375            @Override
376            public String getNodePagesRSS(
377                            long nodeId, int max, String type, double version,
378                            String displayStyle, String feedURL, String entryURL,
379                            String attachmentURLPrefix)
380                    throws PortalException {
381    
382                    WikiNodePermission.check(
383                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
384    
385                    WikiNode node = wikiNodePersistence.findByPrimaryKey(nodeId);
386    
387                    List<WikiPage> pages = getNodePages(nodeId, max);
388    
389                    return exportToRSS(
390                            node.getCompanyId(), node.getName(), node.getDescription(), type,
391                            version, displayStyle, feedURL, entryURL, attachmentURLPrefix,
392                            pages, false, null);
393            }
394    
395            @Override
396            public List<WikiPage> getOrphans(long groupId, long nodeId)
397                    throws PortalException {
398    
399                    WikiNodePermission.check(
400                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
401    
402                    List<WikiPage> pages = wikiPagePersistence.filterFindByG_N_H_S(
403                            groupId, nodeId, true, WorkflowConstants.STATUS_APPROVED);
404    
405                    return WikiUtil.filterOrphans(pages);
406            }
407    
408            @Override
409            public WikiPage getPage(long groupId, long nodeId, String title)
410                    throws PortalException {
411    
412                    List<WikiPage> pages = wikiPagePersistence.filterFindByG_N_T_H(
413                            groupId, nodeId, title, true, 0, 1);
414    
415                    if (!pages.isEmpty()) {
416                            return pages.get(0);
417                    }
418                    else {
419                            StringBundler sb = new StringBundler(5);
420    
421                            sb.append("{nodeId=");
422                            sb.append(nodeId);
423                            sb.append(", title=");
424                            sb.append(title);
425                            sb.append("}");
426    
427                            throw new NoSuchPageException(sb.toString());
428                    }
429            }
430    
431            @Override
432            public WikiPage getPage(long nodeId, String title) throws PortalException {
433                    WikiPagePermission.check(
434                            getPermissionChecker(), nodeId, title, ActionKeys.VIEW);
435    
436                    return wikiPageLocalService.getPage(nodeId, title);
437            }
438    
439            @Override
440            public WikiPage getPage(long nodeId, String title, Boolean head)
441                    throws PortalException {
442    
443                    WikiPagePermission.check(
444                            getPermissionChecker(), nodeId, title, ActionKeys.VIEW);
445    
446                    return wikiPageLocalService.getPage(nodeId, title, head);
447            }
448    
449            @Override
450            public WikiPage getPage(long nodeId, String title, double version)
451                    throws PortalException {
452    
453                    WikiPagePermission.check(
454                            getPermissionChecker(), nodeId, title, ActionKeys.VIEW);
455    
456                    return wikiPageLocalService.getPage(nodeId, title, version);
457            }
458    
459            @Override
460            public List<WikiPage> getPages(
461                            long groupId, long nodeId, boolean head, int status, int start,
462                            int end, OrderByComparator<WikiPage> obc)
463                    throws PortalException {
464    
465                    WikiNodePermission.check(
466                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
467    
468                    if (status == WorkflowConstants.STATUS_ANY) {
469                            return wikiPagePersistence.filterFindByG_N_H(
470                                    groupId, nodeId, head, start, end, obc);
471                    }
472                    else {
473                            return wikiPagePersistence.filterFindByG_N_H_S(
474                                    groupId, nodeId, head, status, start, end, obc);
475                    }
476            }
477    
478            @Override
479            public List<WikiPage> getPages(
480                            long groupId, long userId, long nodeId, int status, int start,
481                            int end)
482                    throws PortalException {
483    
484                    WikiNodePermission.check(
485                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
486    
487                    if (userId > 0) {
488                            return wikiPagePersistence.filterFindByG_U_N_S(
489                                    groupId, userId, nodeId, status, start, end,
490                                    new PageCreateDateComparator(false));
491                    }
492                    else {
493                            return wikiPagePersistence.filterFindByG_N_S(
494                                    groupId, nodeId, status, start, end,
495                                    new PageCreateDateComparator(false));
496                    }
497            }
498    
499            @Override
500            public int getPagesCount(long groupId, long nodeId, boolean head)
501                    throws PortalException {
502    
503                    WikiNodePermission.check(
504                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
505    
506                    return wikiPagePersistence.filterCountByG_N_H_S(
507                            groupId, nodeId, head, WorkflowConstants.STATUS_APPROVED);
508            }
509    
510            @Override
511            public int getPagesCount(long groupId, long userId, long nodeId, int status)
512                    throws PortalException {
513    
514                    WikiNodePermission.check(
515                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
516    
517                    if (userId > 0) {
518                            return wikiPagePersistence.filterCountByG_U_N_S(
519                                    groupId, userId, nodeId, status);
520                    }
521                    else {
522                            return wikiPagePersistence.filterCountByG_N_S(
523                                    groupId, nodeId, status);
524                    }
525            }
526    
527            /**
528             * @deprecated As of 6.2.0, replaced by {@link #getPagesRSS(long, long,
529             *             String, int, String, double, String, String, String, String,
530             *             java.util.Locale)}
531             */
532            @Deprecated
533            @Override
534            public String getPagesRSS(
535                            long companyId, long nodeId, String title, int max, String type,
536                            double version, String displayStyle, String feedURL,
537                            String entryURL, Locale locale)
538                    throws PortalException {
539    
540                    return getPagesRSS(
541                            companyId, nodeId, title, max, type, version, displayStyle, feedURL,
542                            entryURL, null, locale);
543            }
544    
545            @Override
546            public String getPagesRSS(
547                            long companyId, long nodeId, String title, int max, String type,
548                            double version, String displayStyle, String feedURL,
549                            String entryURL, String attachmentURLPrefix, Locale locale)
550                    throws PortalException {
551    
552                    WikiPagePermission.check(
553                            getPermissionChecker(), nodeId, title, ActionKeys.VIEW);
554    
555                    List<WikiPage> pages = wikiPageLocalService.getPages(
556                            nodeId, title, 0, max, new PageCreateDateComparator(true));
557    
558                    return exportToRSS(
559                            companyId, title, title, type, version, displayStyle, feedURL,
560                            entryURL, attachmentURLPrefix, pages, true, locale);
561            }
562    
563            @Override
564            public List<WikiPage> getRecentChanges(
565                            long groupId, long nodeId, int start, int end)
566                    throws PortalException {
567    
568                    WikiNodePermission.check(
569                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
570    
571                    Calendar calendar = CalendarFactoryUtil.getCalendar();
572    
573                    calendar.add(Calendar.WEEK_OF_YEAR, -1);
574    
575                    return wikiPageFinder.filterFindByCreateDate(
576                            groupId, nodeId, calendar.getTime(), false, start, end);
577            }
578    
579            @Override
580            public int getRecentChangesCount(long groupId, long nodeId)
581                    throws PortalException {
582    
583                    WikiNodePermission.check(
584                            getPermissionChecker(), nodeId, ActionKeys.VIEW);
585    
586                    Calendar calendar = CalendarFactoryUtil.getCalendar();
587    
588                    calendar.add(Calendar.WEEK_OF_YEAR, -1);
589    
590                    return wikiPageFinder.filterCountByCreateDate(
591                            groupId, nodeId, calendar.getTime(), false);
592            }
593    
594            @Override
595            public String[] getTempFileNames(long nodeId, String folderName)
596                    throws PortalException {
597    
598                    WikiNode node = wikiNodeLocalService.getNode(nodeId);
599    
600                    WikiNodePermission.check(
601                            getPermissionChecker(), node, ActionKeys.ADD_ATTACHMENT);
602    
603                    return wikiPageLocalService.getTempFileNames(
604                            node.getGroupId(), getUserId(), folderName);
605            }
606    
607            /**
608             * @deprecated As of 6.2.0, replaced by {@link #renamePage(long, String,
609             *             String, ServiceContext)}
610             **/
611            @Override
612            public void movePage(
613                            long nodeId, String title, String newTitle,
614                            ServiceContext serviceContext)
615                    throws PortalException {
616    
617                    renamePage(nodeId, title, newTitle, serviceContext);
618            }
619    
620            @Override
621            public FileEntry movePageAttachmentToTrash(
622                            long nodeId, String title, String fileName)
623                    throws PortalException {
624    
625                    WikiPagePermission.check(
626                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
627    
628                    return wikiPageLocalService.movePageAttachmentToTrash(
629                            getUserId(), nodeId, title, fileName);
630            }
631    
632            @Override
633            public WikiPage movePageToTrash(long nodeId, String title)
634                    throws PortalException {
635    
636                    WikiPagePermission.check(
637                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
638    
639                    return wikiPageLocalService.movePageToTrash(getUserId(), nodeId, title);
640            }
641    
642            @Override
643            public WikiPage movePageToTrash(long nodeId, String title, double version)
644                    throws PortalException {
645    
646                    WikiPagePermission.check(
647                            getPermissionChecker(), nodeId, title, version, ActionKeys.DELETE);
648    
649                    return wikiPageLocalService.movePageToTrash(
650                            getUserId(), nodeId, title, version);
651            }
652    
653            @Override
654            public void renamePage(
655                            long nodeId, String title, String newTitle,
656                            ServiceContext serviceContext)
657                    throws PortalException {
658    
659                    WikiPagePermission.check(
660                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
661    
662                    WikiNodePermission.check(
663                            getPermissionChecker(), nodeId, ActionKeys.ADD_PAGE);
664    
665                    wikiPageLocalService.renamePage(
666                            getUserId(), nodeId, title, newTitle, serviceContext);
667            }
668    
669            @Override
670            public void restorePageAttachmentFromTrash(
671                            long nodeId, String title, String fileName)
672                    throws PortalException {
673    
674                    WikiNodePermission.check(
675                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
676    
677                    wikiPageLocalService.restorePageAttachmentFromTrash(
678                            getUserId(), nodeId, title, fileName);
679            }
680    
681            @Override
682            public void restorePageFromTrash(long resourcePrimKey)
683                    throws PortalException {
684    
685                    WikiPage page = wikiPageLocalService.getPage(resourcePrimKey);
686    
687                    WikiPagePermission.check(
688                            getPermissionChecker(), page, ActionKeys.DELETE);
689    
690                    wikiPageLocalService.restorePageFromTrash(getUserId(), page);
691            }
692    
693            @Override
694            public WikiPage revertPage(
695                            long nodeId, String title, double version,
696                            ServiceContext serviceContext)
697                    throws PortalException {
698    
699                    WikiPagePermission.check(
700                            getPermissionChecker(), nodeId, title, ActionKeys.UPDATE);
701    
702                    return wikiPageLocalService.revertPage(
703                            getUserId(), nodeId, title, version, serviceContext);
704            }
705    
706            @Override
707            public void subscribePage(long nodeId, String title)
708                    throws PortalException {
709    
710                    WikiPagePermission.check(
711                            getPermissionChecker(), nodeId, title, ActionKeys.SUBSCRIBE);
712    
713                    wikiPageLocalService.subscribePage(getUserId(), nodeId, title);
714            }
715    
716            @Override
717            public void unsubscribePage(long nodeId, String title)
718                    throws PortalException {
719    
720                    WikiPagePermission.check(
721                            getPermissionChecker(), nodeId, title, ActionKeys.SUBSCRIBE);
722    
723                    wikiPageLocalService.unsubscribePage(getUserId(), nodeId, title);
724            }
725    
726            @Override
727            public WikiPage updatePage(
728                            long nodeId, String title, double version, String content,
729                            String summary, boolean minorEdit, String format,
730                            String parentTitle, String redirectTitle,
731                            ServiceContext serviceContext)
732                    throws PortalException {
733    
734                    WikiPagePermission.check(
735                            getPermissionChecker(), nodeId, title, ActionKeys.UPDATE);
736    
737                    return wikiPageLocalService.updatePage(
738                            getUserId(), nodeId, title, version, content, summary, minorEdit,
739                            format, parentTitle, redirectTitle, serviceContext);
740            }
741    
742            protected String exportToRSS(
743                            long companyId, String name, String description, String type,
744                            double version, String displayStyle, String feedURL,
745                            String entryURL, String attachmentURLPrefix, List<WikiPage> pages,
746                            boolean diff, Locale locale)
747                    throws PortalException {
748    
749                    SyndFeed syndFeed = new SyndFeedImpl();
750    
751                    syndFeed.setDescription(description);
752    
753                    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();
754    
755                    syndFeed.setEntries(syndEntries);
756    
757                    WikiPage latestPage = null;
758    
759                    StringBundler sb = new StringBundler(6);
760    
761                    for (WikiPage page : pages) {
762                            SyndEntry syndEntry = new SyndEntryImpl();
763    
764                            String author = PortalUtil.getUserName(page);
765    
766                            syndEntry.setAuthor(author);
767    
768                            SyndContent syndContent = new SyndContentImpl();
769    
770                            syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);
771    
772                            sb.setIndex(0);
773    
774                            sb.append(entryURL);
775    
776                            if (entryURL.endsWith(StringPool.SLASH)) {
777                                    sb.append(HttpUtil.encodeURL(page.getTitle()));
778                            }
779    
780                            if (diff) {
781                                    if ((latestPage != null) || (pages.size() == 1)) {
782                                            sb.append(StringPool.QUESTION);
783                                            sb.append(PortalUtil.getPortletNamespace(PortletKeys.WIKI));
784                                            sb.append("version=");
785                                            sb.append(page.getVersion());
786    
787                                            String value = null;
788    
789                                            if (latestPage == null) {
790                                                    value = WikiUtil.convert(
791                                                            page, null, null, attachmentURLPrefix);
792                                            }
793                                            else {
794                                                    try {
795                                                            value = WikiUtil.diffHtml(
796                                                                    latestPage, page, null, null,
797                                                                    attachmentURLPrefix);
798                                                    }
799                                                    catch (PortalException pe) {
800                                                            throw pe;
801                                                    }
802                                                    catch (SystemException se) {
803                                                            throw se;
804                                                    }
805                                                    catch (Exception e) {
806                                                            throw new SystemException(e);
807                                                    }
808                                            }
809    
810                                            syndContent.setValue(value);
811    
812                                            syndEntry.setDescription(syndContent);
813    
814                                            syndEntries.add(syndEntry);
815                                    }
816                            }
817                            else {
818                                    String value = null;
819    
820                                    if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_ABSTRACT)) {
821                                            value = StringUtil.shorten(
822                                                    HtmlUtil.extractText(page.getContent()),
823                                                    PropsValues.WIKI_RSS_ABSTRACT_LENGTH, StringPool.BLANK);
824                                    }
825                                    else if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
826                                            value = StringPool.BLANK;
827                                    }
828                                    else {
829                                            value = WikiUtil.convert(
830                                                    page, null, null, attachmentURLPrefix);
831                                    }
832    
833                                    syndContent.setValue(value);
834    
835                                    syndEntry.setDescription(syndContent);
836    
837                                    syndEntries.add(syndEntry);
838                            }
839    
840                            syndEntry.setLink(sb.toString());
841                            syndEntry.setPublishedDate(page.getCreateDate());
842    
843                            String title =
844                                    page.getTitle() + StringPool.SPACE + page.getVersion();
845    
846                            if (page.isMinorEdit()) {
847                                    title +=
848                                            StringPool.SPACE + StringPool.OPEN_PARENTHESIS +
849                                                    LanguageUtil.get(locale, "minor-edit") +
850                                                            StringPool.CLOSE_PARENTHESIS;
851                            }
852    
853                            syndEntry.setTitle(title);
854    
855                            syndEntry.setUpdatedDate(page.getModifiedDate());
856                            syndEntry.setUri(sb.toString());
857    
858                            latestPage = page;
859                    }
860    
861                    syndFeed.setFeedType(RSSUtil.getFeedType(type, version));
862    
863                    List<SyndLink> syndLinks = new ArrayList<SyndLink>();
864    
865                    syndFeed.setLinks(syndLinks);
866    
867                    SyndLink syndLinkSelf = new SyndLinkImpl();
868    
869                    syndLinks.add(syndLinkSelf);
870    
871                    syndLinkSelf.setHref(feedURL);
872                    syndLinkSelf.setRel("self");
873    
874                    syndFeed.setPublishedDate(new Date());
875                    syndFeed.setTitle(name);
876                    syndFeed.setUri(feedURL);
877    
878                    try {
879                            return RSSUtil.export(syndFeed);
880                    }
881                    catch (FeedException fe) {
882                            throw new SystemException(fe);
883                    }
884            }
885    
886    }