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