001
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
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
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
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
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
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
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 }