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            @Deprecated
612            @Override
613            public void movePage(
614                            long nodeId, String title, String newTitle,
615                            ServiceContext serviceContext)
616                    throws PortalException {
617    
618                    renamePage(nodeId, title, newTitle, serviceContext);
619            }
620    
621            @Override
622            public FileEntry movePageAttachmentToTrash(
623                            long nodeId, String title, String fileName)
624                    throws PortalException {
625    
626                    WikiPagePermission.check(
627                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
628    
629                    return wikiPageLocalService.movePageAttachmentToTrash(
630                            getUserId(), nodeId, title, fileName);
631            }
632    
633            @Override
634            public WikiPage movePageToTrash(long nodeId, String title)
635                    throws PortalException {
636    
637                    WikiPagePermission.check(
638                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
639    
640                    return wikiPageLocalService.movePageToTrash(getUserId(), nodeId, title);
641            }
642    
643            @Override
644            public WikiPage movePageToTrash(long nodeId, String title, double version)
645                    throws PortalException {
646    
647                    WikiPagePermission.check(
648                            getPermissionChecker(), nodeId, title, version, ActionKeys.DELETE);
649    
650                    return wikiPageLocalService.movePageToTrash(
651                            getUserId(), nodeId, title, version);
652            }
653    
654            @Override
655            public void renamePage(
656                            long nodeId, String title, String newTitle,
657                            ServiceContext serviceContext)
658                    throws PortalException {
659    
660                    WikiPagePermission.check(
661                            getPermissionChecker(), nodeId, title, ActionKeys.DELETE);
662    
663                    WikiNodePermission.check(
664                            getPermissionChecker(), nodeId, ActionKeys.ADD_PAGE);
665    
666                    wikiPageLocalService.renamePage(
667                            getUserId(), nodeId, title, newTitle, serviceContext);
668            }
669    
670            @Override
671            public void restorePageAttachmentFromTrash(
672                            long nodeId, String title, String fileName)
673                    throws PortalException {
674    
675                    WikiNodePermission.check(
676                            getPermissionChecker(), nodeId, ActionKeys.ADD_ATTACHMENT);
677    
678                    wikiPageLocalService.restorePageAttachmentFromTrash(
679                            getUserId(), nodeId, title, fileName);
680            }
681    
682            @Override
683            public void restorePageFromTrash(long resourcePrimKey)
684                    throws PortalException {
685    
686                    WikiPage page = wikiPageLocalService.getPage(resourcePrimKey);
687    
688                    WikiPagePermission.check(
689                            getPermissionChecker(), page, ActionKeys.DELETE);
690    
691                    wikiPageLocalService.restorePageFromTrash(getUserId(), page);
692            }
693    
694            @Override
695            public WikiPage revertPage(
696                            long nodeId, String title, double version,
697                            ServiceContext serviceContext)
698                    throws PortalException {
699    
700                    WikiPagePermission.check(
701                            getPermissionChecker(), nodeId, title, ActionKeys.UPDATE);
702    
703                    return wikiPageLocalService.revertPage(
704                            getUserId(), nodeId, title, version, serviceContext);
705            }
706    
707            @Override
708            public void subscribePage(long nodeId, String title)
709                    throws PortalException {
710    
711                    WikiPagePermission.check(
712                            getPermissionChecker(), nodeId, title, ActionKeys.SUBSCRIBE);
713    
714                    wikiPageLocalService.subscribePage(getUserId(), nodeId, title);
715            }
716    
717            @Override
718            public void unsubscribePage(long nodeId, String title)
719                    throws PortalException {
720    
721                    WikiPagePermission.check(
722                            getPermissionChecker(), nodeId, title, ActionKeys.SUBSCRIBE);
723    
724                    wikiPageLocalService.unsubscribePage(getUserId(), nodeId, title);
725            }
726    
727            @Override
728            public WikiPage updatePage(
729                            long nodeId, String title, double version, String content,
730                            String summary, boolean minorEdit, String format,
731                            String parentTitle, String redirectTitle,
732                            ServiceContext serviceContext)
733                    throws PortalException {
734    
735                    WikiPagePermission.check(
736                            getPermissionChecker(), nodeId, title, ActionKeys.UPDATE);
737    
738                    return wikiPageLocalService.updatePage(
739                            getUserId(), nodeId, title, version, content, summary, minorEdit,
740                            format, parentTitle, redirectTitle, serviceContext);
741            }
742    
743            protected String exportToRSS(
744                            long companyId, String name, String description, String type,
745                            double version, String displayStyle, String feedURL,
746                            String entryURL, String attachmentURLPrefix, List<WikiPage> pages,
747                            boolean diff, Locale locale)
748                    throws PortalException {
749    
750                    SyndFeed syndFeed = new SyndFeedImpl();
751    
752                    syndFeed.setDescription(description);
753    
754                    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();
755    
756                    syndFeed.setEntries(syndEntries);
757    
758                    WikiPage latestPage = null;
759    
760                    StringBundler sb = new StringBundler(6);
761    
762                    for (WikiPage page : pages) {
763                            SyndEntry syndEntry = new SyndEntryImpl();
764    
765                            String author = PortalUtil.getUserName(page);
766    
767                            syndEntry.setAuthor(author);
768    
769                            SyndContent syndContent = new SyndContentImpl();
770    
771                            syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);
772    
773                            sb.setIndex(0);
774    
775                            sb.append(entryURL);
776    
777                            if (entryURL.endsWith(StringPool.SLASH)) {
778                                    sb.append(HttpUtil.encodeURL(page.getTitle()));
779                            }
780    
781                            if (diff) {
782                                    if ((latestPage != null) || (pages.size() == 1)) {
783                                            sb.append(StringPool.QUESTION);
784                                            sb.append(PortalUtil.getPortletNamespace(PortletKeys.WIKI));
785                                            sb.append("version=");
786                                            sb.append(page.getVersion());
787    
788                                            String value = null;
789    
790                                            if (latestPage == null) {
791                                                    value = WikiUtil.convert(
792                                                            page, null, null, attachmentURLPrefix);
793                                            }
794                                            else {
795                                                    try {
796                                                            value = WikiUtil.diffHtml(
797                                                                    latestPage, page, null, null,
798                                                                    attachmentURLPrefix);
799                                                    }
800                                                    catch (PortalException pe) {
801                                                            throw pe;
802                                                    }
803                                                    catch (SystemException se) {
804                                                            throw se;
805                                                    }
806                                                    catch (Exception e) {
807                                                            throw new SystemException(e);
808                                                    }
809                                            }
810    
811                                            syndContent.setValue(value);
812    
813                                            syndEntry.setDescription(syndContent);
814    
815                                            syndEntries.add(syndEntry);
816                                    }
817                            }
818                            else {
819                                    String value = null;
820    
821                                    if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_ABSTRACT)) {
822                                            value = StringUtil.shorten(
823                                                    HtmlUtil.extractText(page.getContent()),
824                                                    PropsValues.WIKI_RSS_ABSTRACT_LENGTH, StringPool.BLANK);
825                                    }
826                                    else if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
827                                            value = StringPool.BLANK;
828                                    }
829                                    else {
830                                            value = WikiUtil.convert(
831                                                    page, null, null, attachmentURLPrefix);
832                                    }
833    
834                                    syndContent.setValue(value);
835    
836                                    syndEntry.setDescription(syndContent);
837    
838                                    syndEntries.add(syndEntry);
839                            }
840    
841                            syndEntry.setLink(sb.toString());
842                            syndEntry.setPublishedDate(page.getCreateDate());
843    
844                            String title =
845                                    page.getTitle() + StringPool.SPACE + page.getVersion();
846    
847                            if (page.isMinorEdit()) {
848                                    title +=
849                                            StringPool.SPACE + StringPool.OPEN_PARENTHESIS +
850                                                    LanguageUtil.get(locale, "minor-edit") +
851                                                            StringPool.CLOSE_PARENTHESIS;
852                            }
853    
854                            syndEntry.setTitle(title);
855    
856                            syndEntry.setUpdatedDate(page.getModifiedDate());
857                            syndEntry.setUri(sb.toString());
858    
859                            latestPage = page;
860                    }
861    
862                    syndFeed.setFeedType(RSSUtil.getFeedType(type, version));
863    
864                    List<SyndLink> syndLinks = new ArrayList<SyndLink>();
865    
866                    syndFeed.setLinks(syndLinks);
867    
868                    SyndLink syndLinkSelf = new SyndLinkImpl();
869    
870                    syndLinks.add(syndLinkSelf);
871    
872                    syndLinkSelf.setHref(feedURL);
873                    syndLinkSelf.setRel("self");
874    
875                    syndFeed.setPublishedDate(new Date());
876                    syndFeed.setTitle(name);
877                    syndFeed.setUri(feedURL);
878    
879                    try {
880                            return RSSUtil.export(syndFeed);
881                    }
882                    catch (FeedException fe) {
883                            throw new SystemException(fe);
884                    }
885            }
886    
887    }