예제 #1
0
  public void serialize(
      ResultSummary summary,
      List<DashBoardItem> workItems,
      String columnsDefinition,
      List<String> labels,
      String lang,
      Response response,
      HttpServletRequest req)
      throws ClientException {
    // TODO labels, lang

    SyndFeed atomFeed = new SyndFeedImpl();
    atomFeed.setFeedType(ATOM_TYPE);

    // XXX TODO : To be translated
    atomFeed.setTitle(summary.getTitle());

    atomFeed.setLink(summary.getLink());

    List<SyndEntry> entries = new ArrayList<SyndEntry>();
    for (DashBoardItem item : workItems) {
      entries.add(adaptDashBoardItem(item, req));
    }

    atomFeed.setEntries(entries);

    SyndFeedOutput output = new SyndFeedOutput();

    // Try to return feed
    try {
      response.setEntity(output.outputString(atomFeed), MediaType.TEXT_XML);
      response.getEntity().setCharacterSet(CharacterSet.UTF_8);
    } catch (FeedException fe) {
    }
  }
예제 #2
0
  @SuppressWarnings("unchecked")
  protected void removeRSSItem(String itemId, Node node, String description) throws Exception {
    RSS data = new RSS(node);
    SyndFeed feed = data.read();

    List<SyndEntry> entries = feed.getEntries();
    Node removeNode = getNodeById(itemId);

    if (removeNode.isNodeType("exo:topic")) {
      List<Node> listRemovePosts = getListRemove(removeNode, "exo:post");
      removeItem(entries, listRemovePosts);
    } else if (removeNode.isNodeType("exo:forum")) {
      List<Node> listRemoveForum = getListRemove(removeNode, "exo:topic");

      for (Node n : listRemoveForum) {
        List<Node> listRemovePosts = getListRemove(n, "exo:post");
        removeItem(entries, listRemovePosts);
      }
      removeItem(entries, listRemoveForum);
    }

    feed.setEntries(entries);
    String title = new PropertyReader(node).string("exo:name", "Root");
    feed.setTitle(title);
    feed.setDescription(description);
    data.saveFeed(feed, FORUM_RSS_TYPE);
  }
예제 #3
0
  private SyndFeed createFeed() {

    SyndFeed feed = new SyndFeedImpl();

    SyndPerson auteur = new SyndPersonImpl();
    auteur.setName("Gildas Cuisinier");
    auteur.setEmail("*****@*****.**");

    feed.setTitle("RSS Veille Techno");
    feed.setAuthors(Collections.singletonList(auteur));
    feed.setDescription("RSS d'exemple !");
    feed.setLink("http://svn.cyg.be/");
    feed.setPublishedDate(new Date());
    feed.setLanguage("fr");

    SyndEntry entry = new SyndEntryImpl();
    entry.setTitle("Ajout du projet Rome sur le SVN");
    entry.setLink("https://rome.dev.java.net/");

    SyndContent description = new SyndContentImpl();
    description.setValue("Ajout d'un projet Rome sur le SVN afin de voir comment creer un RSS");
    description.setType("text");
    entry.setDescription(description);
    entry.setAuthors(Collections.singletonList(auteur));

    feed.getEntries().add(entry);

    return feed;
  }
예제 #4
0
 /**
  * Remove one item from RSS feed based on id of object which is changed
  *
  * @param itemId id of object
  * @param node Node content RSS feed
  * @param feedDescription description about RSS feed
  * @throws Exception
  */
 protected void removeItemInFeed(String itemId, Node node, String feedDescription)
     throws Exception {
   RSS data = new RSS(node);
   SyndFeed feed = data.removeEntry(itemId);
   String title = new PropertyReader(node).string("exo:name", "Root");
   feed.setTitle(title);
   feed.setDescription(feedDescription);
   data.saveFeed(feed, FORUM_RSS_TYPE);
 }
예제 #5
0
파일: RSS.java 프로젝트: boueslati/forum
 /**
  * Create a new feed with some default content: link is the link to eXo web site and feed type is
  * <code>rss_2.0</code>
  *
  * @return
  */
 public static SyndFeed createNewFeed(String title, Date pubDate) {
   SyndFeed feed = new SyndFeedImpl();
   feed.setLink(DEFAULT_FEED_LINK);
   feed.setFeedType(RSS_2_0);
   feed.setTitle(title);
   feed.setPublishedDate(pubDate);
   feed.setDescription(" ");
   return feed;
 }
예제 #6
0
  @Override
  protected void createFeed(SyndFeed feed, Map model) {
    @SuppressWarnings("unchecked")
    List<PreparedUserEvent> list = (List<PreparedUserEvent>) model.get("topicsList");
    String s = "Ответы на комментарии пользователя " + model.get("nick");
    feed.setTitle(s);
    feed.setLink("http://www.linux.org.ru");
    feed.setUri("http://www.linux.org.ru");
    feed.setAuthor("");
    feed.setDescription(s);

    Date lastModified;
    if (!list.isEmpty()) {
      lastModified = list.get(0).getEvent().getEventDate();
    } else {
      lastModified = new Date();
    }
    feed.setPublishedDate(lastModified);

    List<SyndEntry> entries = new ArrayList<>();
    feed.setEntries(entries);
    for (PreparedUserEvent preparedUserEvent : list) {
      UserEvent item = preparedUserEvent.getEvent();

      SyndEntry feedEntry = new SyndEntryImpl();
      feedEntry.setPublishedDate(item.getEventDate());
      feedEntry.setTitle(StringEscapeUtils.unescapeHtml4(item.getSubj()));

      String link;

      if (item.getCid() != 0) {
        feedEntry.setAuthor(preparedUserEvent.getAuthor().getNick());

        link =
            String.format(
                "http://www.linux.org.ru/jump-message.jsp?msgid=%s&cid=%s",
                String.valueOf(item.getTopicId()), String.valueOf(item.getCid()));
      } else {
        link =
            String.format(
                "http://www.linux.org.ru/view-message.jsp?msgid=%s",
                String.valueOf(item.getTopicId()));
      }

      feedEntry.setLink(link);
      feedEntry.setUri(link);

      if (preparedUserEvent.getMessageText() != null) {
        SyndContent message = new SyndContentImpl();
        message.setValue(StringUtil.removeInvalidXmlChars(preparedUserEvent.getMessageText()));
        message.setType("text/html");
        feedEntry.setDescription(message);
      }
      entries.add(feedEntry);
    }
  }
예제 #7
0
 private void removePostFromParentFeeds(
     Node postNode, Node topicNode, Node forumNode, Node categoryNode) throws Exception {
   for (Node node : new Node[] {topicNode, forumNode, categoryNode}) {
     String description = new PropertyReader(node).string("exo:description", " ");
     RSS data = new RSS(node);
     SyndFeed feed = data.removeEntry(postNode.getName());
     String title = new PropertyReader(node).string("exo:name", "Root");
     feed.setTitle(title);
     feed.setDescription(description);
     data.saveFeed(feed, FORUM_RSS_TYPE);
   }
 }
예제 #8
0
  @Override
  public void execute(WebScriptRequest req, WebScriptResponse res) throws IOException {
    Writer writer = null;
    try {
      writer = res.getWriter();

      // Get the section placed in the request context by ApplicationDataInterceptor
      RequestContext requestContext = ThreadLocalRequestContext.getRequestContext();
      Section section = (Section) requestContext.getValue("section");
      WebSite webSite = (WebSite) requestContext.getValue("webSite");

      // Get the collection property from the page definition
      String collectionName = requestContext.getPage().getProperty("collection");
      if (collectionName == null)
        throw new WebScriptException("collectionName property must be supplied");

      // Fetch the named collection
      AssetCollection collection =
          (AssetCollection) collectionFactory.getCollection(section.getId(), collectionName);

      // Use ROME library to output the colleciton as a syndication feed
      SyndFeed feed = new SyndFeedImpl();
      feed.setFeedType(FEED_TYPE);

      feed.setTitle(section.getTitle());
      feed.setLink(urlUtils.getWebsiteDomain(webSite) + urlUtils.getUrl(section));
      feed.setDescription(section.getDescription());

      List<SyndEntry> entries = new ArrayList<SyndEntry>();
      for (Asset asset : collection.getAssets()) {
        SyndEntry entry = new SyndEntryImpl();
        entry.setTitle(asset.getTitle());
        entry.setLink(urlUtils.getWebsiteDomain(webSite) + urlUtils.getUrl(asset));
        entry.setUri(urlUtils.getWebsiteDomain(webSite) + urlUtils.getShortUrl(asset));
        entry.setPublishedDate((Date) asset.getProperties().get(Asset.PROPERTY_PUBLISHED_TIME));
        SyndContent description = new SyndContentImpl();
        description.setType("text/html");
        description.setValue(asset.getDescription());
        entry.setDescription(description);
        entries.add(entry);
      }
      feed.setEntries(entries);

      SyndFeedOutput output = new SyndFeedOutput();
      output.output(feed, writer);
      writer.flush();
    } catch (IOException e) {
      log.error("Unable to output rss", e);
    } catch (FeedException e) {
      log.error("Unable to output rss", e);
    }
  }
예제 #9
0
 public static SyndFeed create(
     List<Bookmark> bookmarks,
     String author,
     String title,
     String link,
     Date pubDate,
     String feedUri) {
   logger.debug("SyndFeedFactory create method called");
   logger.debug("bookmarks=" + bookmarks);
   logger.debug("author=" + author);
   logger.debug("title=" + title);
   logger.debug("link=" + link);
   logger.debug("pubDate=" + pubDate);
   logger.debug("feedUri=" + feedUri);
   SyndFeed syndFeed = new SyndFeedImpl();
   syndFeed.setAuthor(author);
   syndFeed.setTitle(title);
   syndFeed.setUri(feedUri);
   syndFeed.setLink(link);
   syndFeed.setPublishedDate(pubDate);
   List<SyndEntry> entries = new ArrayList<SyndEntry>();
   for (Bookmark bmark : bookmarks) {
     SyndEntry entry = new SyndEntryImpl();
     entry.setTitle(bmark.getTitle());
     entry.setAuthor(bmark.getUser().getUsername());
     entry.setLink(bmark.getLink().getUrl());
     entry.setUri("urn:bookmark:" + bmark.getId());
     entry.setUpdatedDate(bmark.getLastUpdated());
     List<String> tags = bmark.getTagList();
     List<SyndCategory> cats = new ArrayList<SyndCategory>();
     for (String aTag : tags) {
       SyndCategory aCat = new SyndCategoryImpl();
       aCat.setName(aTag);
       cats.add(aCat);
     }
     if (cats.isEmpty() == false) {
       entry.setCategories(cats);
     }
     SyndContent cnt = new SyndContentImpl();
     cnt.setType("text/html");
     cnt.setValue(bmark.getNotes());
     entry.setDescription(cnt);
     entries.add(entry);
   }
   syndFeed.setEntries(entries);
   syndFeed.setEncoding("UTF-8");
   logger.debug("done initializing syndFeed object");
   return syndFeed;
 }
  @Override
  public SyndFeed buildRssLabsNews(
      List<LabsNews> pLabsNews, String pPathBase, String pDefaultDescription)
      throws ClientException {
    String feedType = "rss_2.0";

    final SyndFeed feed = new SyndFeedImpl();
    feed.setFeedType(feedType);

    feed.setTitle(getTitle());
    feed.setLink(pPathBase);
    feed.setDescription(buildRssPageNewsDescription(pDefaultDescription));
    feed.setEntries(createRssEntries(pLabsNews, pPathBase));
    return feed;
  }
예제 #11
0
  @Path("/entriesAsFeed")
  @GET
  @ApiOperation(value = "Get category entries as feed", notes = "Get a feed of category entries")
  @Produces(MediaType.APPLICATION_XML)
  @SecurityCheck(value = Role.USER, apiKeyAllowed = true)
  public Response getCategoryEntriesAsFeed(
      @ApiParam(value = "id of the category, 'all' or 'starred'", required = true) @QueryParam("id")
          String id) {

    Preconditions.checkNotNull(id);

    ReadingMode readType = ReadingMode.all;
    ReadingOrder order = ReadingOrder.desc;
    int offset = 0;
    int limit = 20;

    Entries entries =
        (Entries)
            getCategoryEntries(id, readType, null, offset, limit, order, null, false).getEntity();

    SyndFeed feed = new SyndFeedImpl();
    feed.setFeedType("rss_2.0");
    feed.setTitle("CommaFeed - " + entries.getName());
    feed.setDescription("CommaFeed - " + entries.getName());
    String publicUrl = applicationSettingsService.get().getPublicUrl();
    feed.setLink(publicUrl);

    List<SyndEntry> children = Lists.newArrayList();
    for (Entry entry : entries.getEntries()) {
      children.add(entry.asRss());
    }
    feed.setEntries(children);

    SyndFeedOutput output = new SyndFeedOutput();
    StringWriter writer = new StringWriter();
    try {
      output.output(feed, writer);
    } catch (Exception e) {
      writer.write("Could not get feed information");
      log.error(e.getMessage(), e);
    }
    return Response.ok(writer.toString()).build();
  }
  public void copyInto(WireFeed feed, SyndFeed syndFeed) {
    syndFeed.setModules(ModuleUtils.cloneModules(feed.getModules()));
    if (((List) feed.getForeignMarkup()).size() > 0) {
      syndFeed.setForeignMarkup(feed.getForeignMarkup());
    }
    syndFeed.setEncoding(feed.getEncoding());
    Channel channel = (Channel) feed;
    syndFeed.setTitle(channel.getTitle());
    syndFeed.setLink(channel.getLink());
    syndFeed.setDescription(channel.getDescription());

    Image image = channel.getImage();
    if (image != null) {
      syndFeed.setImage(createSyndImage(image));
    }

    List items = channel.getItems();
    if (items != null) {
      syndFeed.setEntries(createSyndEntries(items));
    }
  }
예제 #13
0
 public static SyndFeed createFromBookmarkDoc(
     List<BookmarkDoc> bookmarks,
     String author,
     String title,
     String link,
     Date pubDate,
     String feedUri) {
   logger.debug("SyndFeedFactory create method called");
   logger.debug("bookmarks=" + bookmarks);
   logger.debug("author=" + author);
   logger.debug("title=" + title);
   logger.debug("link=" + link);
   logger.debug("pubDate=" + pubDate);
   logger.debug("feedUri=" + feedUri);
   SyndFeed syndFeed = new SyndFeedImpl();
   syndFeed.setAuthor(author);
   syndFeed.setTitle(title);
   syndFeed.setUri(feedUri);
   syndFeed.setLink(link);
   syndFeed.setPublishedDate(pubDate);
   List<SyndEntry> entries = new ArrayList<SyndEntry>();
   for (BookmarkDoc bmark : bookmarks) {
     SyndEntry entry = new SyndEntryImpl();
     entry.setTitle(bmark.getTitle());
     entry.setAuthor(bmark.getUsername());
     entry.setLink(bmark.getUrl());
     entry.setUri("urn-x:gnizr:bookmark:" + bmark.getBookmarkId());
     SyndContent cnt = new SyndContentImpl();
     cnt.setType("text/html");
     if (bmark.getNotes() != null) {
       cnt.setValue(bmark.getNotes());
       entry.setDescription(cnt);
     }
     entries.add(entry);
   }
   syndFeed.setEntries(entries);
   syndFeed.setEncoding("UTF-8");
   logger.debug("done initializing syndFeed object");
   return syndFeed;
 }
  protected String exportToRSS(
      long companyId,
      String name,
      String description,
      String type,
      double version,
      String displayStyle,
      String feedURL,
      String entryURL,
      List<WikiPage> pages,
      boolean diff,
      Locale locale)
      throws SystemException {

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setFeedType(RSSUtil.getFeedType(type, version));
    syndFeed.setTitle(name);
    syndFeed.setLink(feedURL);
    syndFeed.setDescription(description);

    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();

    syndFeed.setEntries(syndEntries);

    WikiPage latestPage = null;

    StringBundler link = new StringBundler(7);

    for (WikiPage page : pages) {
      String author = HtmlUtil.escape(PortalUtil.getUserName(page.getUserId(), page.getUserName()));

      String title = page.getTitle() + StringPool.SPACE + page.getVersion();

      if (page.isMinorEdit()) {
        title +=
            StringPool.SPACE
                + StringPool.OPEN_PARENTHESIS
                + LanguageUtil.get(locale, "minor-edit")
                + StringPool.CLOSE_PARENTHESIS;
      }

      link.setIndex(0);

      link.append(entryURL);
      link.append(StringPool.AMPERSAND);
      link.append(HttpUtil.encodeURL(page.getTitle()));

      SyndEntry syndEntry = new SyndEntryImpl();

      syndEntry.setAuthor(author);
      syndEntry.setTitle(title);
      syndEntry.setPublishedDate(page.getCreateDate());
      syndEntry.setUpdatedDate(page.getModifiedDate());

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);

      if (diff) {
        if (latestPage != null) {
          link.append(StringPool.QUESTION);
          link.append(PortalUtil.getPortletNamespace(PortletKeys.WIKI));
          link.append("version=");
          link.append(page.getVersion());

          String value = getPageDiff(companyId, latestPage, page, locale);

          syndContent.setValue(value);

          syndEntry.setDescription(syndContent);

          syndEntries.add(syndEntry);
        }
      } else {
        String value = null;

        if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_ABSTRACT)) {
          value =
              StringUtil.shorten(
                  HtmlUtil.extractText(page.getContent()),
                  PropsValues.WIKI_RSS_ABSTRACT_LENGTH,
                  StringPool.BLANK);
        } else if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
          value = StringPool.BLANK;
        } else {
          value = page.getContent();
        }

        syndContent.setValue(value);

        syndEntry.setDescription(syndContent);

        syndEntries.add(syndEntry);
      }

      syndEntry.setLink(link.toString());
      syndEntry.setUri(syndEntry.getLink());

      latestPage = page;
    }

    try {
      return RSSUtil.export(syndFeed);
    } catch (FeedException fe) {
      throw new SystemException(fe);
    }
  }
  protected String exportToRSS(
      String name,
      String description,
      String type,
      double version,
      String displayStyle,
      String feedURL,
      String entryURL,
      List<MBMessage> messages,
      ThemeDisplay themeDisplay)
      throws SystemException {

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setDescription(description);

    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();

    syndFeed.setEntries(syndEntries);

    for (MBMessage message : messages) {
      SyndEntry syndEntry = new SyndEntryImpl();

      if (!message.isAnonymous()) {
        String author = PortalUtil.getUserName(message);

        syndEntry.setAuthor(author);
      }

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);

      String value = null;

      if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_ABSTRACT)) {
        value =
            StringUtil.shorten(
                HtmlUtil.extractText(message.getBody()),
                PropsValues.MESSAGE_BOARDS_RSS_ABSTRACT_LENGTH,
                StringPool.BLANK);
      } else if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
        value = StringPool.BLANK;
      } else if (message.isFormatBBCode()) {
        value = BBCodeTranslatorUtil.getHTML(message.getBody());

        value = MBUtil.replaceMessageBodyPaths(themeDisplay, value);
      } else {
        value = message.getBody();
      }

      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      syndEntry.setLink(entryURL + "&messageId=" + message.getMessageId());
      syndEntry.setPublishedDate(message.getCreateDate());
      syndEntry.setTitle(message.getSubject());
      syndEntry.setUpdatedDate(message.getModifiedDate());
      syndEntry.setUri(syndEntry.getLink());

      syndEntries.add(syndEntry);
    }

    syndFeed.setFeedType(RSSUtil.getFeedType(type, version));

    List<SyndLink> syndLinks = new ArrayList<SyndLink>();

    syndFeed.setLinks(syndLinks);

    SyndLink selfSyndLink = new SyndLinkImpl();

    syndLinks.add(selfSyndLink);

    selfSyndLink.setHref(feedURL);
    selfSyndLink.setRel("self");

    syndFeed.setPublishedDate(new Date());
    syndFeed.setTitle(name);
    syndFeed.setUri(feedURL);

    try {
      return RSSUtil.export(syndFeed);
    } catch (FeedException fe) {
      throw new SystemException(fe);
    }
  }
예제 #16
0
  protected static String exportToRSS(
      PortletRequest portletRequest,
      PortletResponse portletResponse,
      String name,
      String description,
      String format,
      double version,
      String displayStyle,
      String linkBehavior,
      List<AssetEntry> assetEntries)
      throws Exception {

    ThemeDisplay themeDisplay = (ThemeDisplay) portletRequest.getAttribute(WebKeys.THEME_DISPLAY);

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setDescription(GetterUtil.getString(description, name));

    List<SyndEntry> syndEntries = new ArrayList<>();

    syndFeed.setEntries(syndEntries);

    for (AssetEntry assetEntry : assetEntries) {
      SyndEntry syndEntry = new SyndEntryImpl();

      String author = PortalUtil.getUserName(assetEntry);

      syndEntry.setAuthor(author);

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);

      String value = null;

      String languageId = LanguageUtil.getLanguageId(portletRequest);

      if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
        value = StringPool.BLANK;
      } else {
        value = assetEntry.getSummary(languageId, true);
      }

      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      String link = getEntryURL(portletRequest, portletResponse, linkBehavior, assetEntry);

      syndEntry.setLink(link);

      syndEntry.setPublishedDate(assetEntry.getPublishDate());
      syndEntry.setTitle(assetEntry.getTitle(languageId, true));
      syndEntry.setUpdatedDate(assetEntry.getModifiedDate());
      syndEntry.setUri(syndEntry.getLink());

      syndEntries.add(syndEntry);
    }

    syndFeed.setFeedType(RSSUtil.getFeedType(format, version));

    List<SyndLink> syndLinks = new ArrayList<>();

    syndFeed.setLinks(syndLinks);

    SyndLink selfSyndLink = new SyndLinkImpl();

    syndLinks.add(selfSyndLink);

    String feedURL = getFeedURL(portletRequest);

    selfSyndLink.setHref(feedURL);

    selfSyndLink.setRel("self");

    SyndLink alternateSyndLink = new SyndLinkImpl();

    syndLinks.add(alternateSyndLink);

    alternateSyndLink.setHref(PortalUtil.getLayoutFullURL(themeDisplay));
    alternateSyndLink.setRel("alternate");

    syndFeed.setPublishedDate(new Date());
    syndFeed.setTitle(name);
    syndFeed.setUri(feedURL);

    return RSSUtil.export(syndFeed);
  }
예제 #17
0
  /** Fills in the feed and entry-level metadata from DSpace objects. */
  public void populate(HttpServletRequest request, SummaryStatBean bean) {
    Locale locale = request.getLocale();
    ResourceBundle msgs = ResourceBundle.getBundle("Messages", locale);

    int type = bean.getType();
    int freq = bean.getFreq();

    // String logoURL = ConfigurationManager
    // .getProperty("webui.feed.stats.logo.url");
    String objectURL = bean.getObjectURL();

    feed.setTitle(
        MessageFormat.format(
            localize(msgs, MSG_FEED_TITLE, freq, type, null, null), bean.getObjectName()));
    feed.setDescription(
        MessageFormat.format(
            localize(msgs, MSG_FEED_DESCRIPTION, freq, type, null, null), bean.getObjectName()));
    feed.setLink(objectURL);
    feed.setPublishedDate(new Date());
    feed.setUri(objectURL);

    // // add logo if we found one:
    // if (logoURL != null)
    // {
    // // we use the path to the logo for this, the logo itself cannot
    // // be contained in the rdf. Not all RSS-viewers show this logo.
    // SyndImage image = new SyndImageImpl();
    // image.setLink(objectURL);
    // image.setTitle(localize(labels, MSG_LOGO_TITLE, freq, type));
    // image.setUrl(logoURL);
    // feed.setImage(image);
    // }

    // add entries for items
    if (bean.getData() != null) {
      List<SyndEntry> entries = new ArrayList<SyndEntry>();
      for (SummaryStatBean.StatDataBean dataBean : bean.getData()) {
        Date date = dataBean.getDate();

        SyndEntry entry = new SyndEntryImpl();
        entries.add(entry);

        // all the feed has the same url... details on the statistics
        // page
        entry.setLink(bean.getStatURL() + "&freq=" + bean.getFreq() + "&date=" + date.getTime());
        // entry.setUri();

        entry.setTitle(
            MessageFormat.format(
                localize(msgs, MSG_ENTRY_TITLE, freq, type, null, null),
                bean.getObjectName(),
                dataBean.getDate()));

        Calendar c1 = Calendar.getInstance();
        c1.setTime(date);
        if (bean.getFreq() != StatSubscription.FREQUENCY_MONTHLY) {
          c1.add(Calendar.DAY_OF_MONTH, 1);
        } else {
          c1.add(Calendar.MONTH, 1);
        }
        date = c1.getTime();
        entry.setPublishedDate(date);
        // date of last change to Item
        entry.setUpdatedDate(dataBean.getDate());

        SyndContent desc = new SyndContentImpl();
        desc.setType("text/html");

        String tmpMessage = "";

        tmpMessage +=
            MessageFormat.format(
                localize(
                    msgs,
                    MSG_ENTRY_DESCRIPTION,
                    freq,
                    type,
                    AStatComponentService._SELECTED_OBJECT,
                    "view"),
                dataBean.getPeriodSelectedView(),
                dataBean.getTotalSelectedView());

        if (dataBean.isShowSelectedObjectDownload()) {
          tmpMessage +=
              MessageFormat.format(
                  localize(
                      msgs,
                      MSG_ENTRY_DESCRIPTION,
                      freq,
                      type,
                      AStatComponentService._SELECTED_OBJECT,
                      "download"),
                  dataBean.getPeriodSelectedDownload(),
                  dataBean.getTotalSelectedDownload());
        }

        for (String key : dataBean.getPeriodAndTotalTopView().keySet()) {
          if (dataBean.getPeriodAndTotalTopView().get(key) != null) {
            if (dataBean.getPeriodAndTotalTopView().get(key).size() > 0) {
              tmpMessage +=
                  MessageFormat.format(
                      localize(msgs, MSG_ENTRY_DESCRIPTION, freq, type, key, "view"),
                      dataBean.getPeriodAndTotalTopView().get(key).get(0),
                      dataBean.getPeriodAndTotalTopView().get(key).get(1));
            }
            if (dataBean.getPeriodAndTotalTopDownload().get(key) != null) {
              if (dataBean.getPeriodAndTotalTopDownload().get(key).size() > 0) {
                tmpMessage +=
                    MessageFormat.format(
                        localize(msgs, MSG_ENTRY_DESCRIPTION, freq, type, key, "download"),
                        dataBean.getPeriodAndTotalTopDownload().get(key).get(0),
                        dataBean.getPeriodAndTotalTopDownload().get(key).get(1));
              }
            }
          }
        }

        String message =
            MessageFormat.format(
                localize(msgs, MSG_ENTRY_DESCRIPTION, freq, type, null, null),
                bean.getObjectName(),
                dataBean.getDate(),
                tmpMessage);

        desc.setValue(message);
        entry.setDescription(desc);

        entry.setAuthor(ConfigurationManager.getProperty("webui.feed.stats.authors"));
      }
      feed.setEntries(entries);
    }
  }
  @SuppressWarnings("unchecked")
  private void serializeToFeed(
      OutputStream outputStream,
      GeolocResultsDto geolocResultsDto,
      String feedVersion,
      int startPaginationIndex) {
    SyndFeed synFeed = new SyndFeedImpl();
    Writer oWriter = null;
    try {

      synFeed.setFeedType(feedVersion);

      synFeed.setTitle(Constants.FEED_TITLE);
      synFeed.setLink(Constants.FEED_LINK);
      synFeed.setDescription(Constants.FEED_DESCRIPTION);
      List<SyndEntry> entries = new ArrayList<SyndEntry>();

      for (GisFeatureDistance gisFeatureDistance : geolocResultsDto.getResult()) {

        SyndEntry entry = new SyndEntryImpl();
        GeoRSSModule geoRSSModuleGML = new GMLModuleImpl();
        OpenSearchModule openSearchModule = new OpenSearchModuleImpl();

        geoRSSModuleGML.setLatitude(gisFeatureDistance.getLat());
        geoRSSModuleGML.setLongitude(gisFeatureDistance.getLng());

        openSearchModule.setItemsPerPage(Pagination.DEFAULT_MAX_RESULTS);
        openSearchModule.setTotalResults(geolocResultsDto.getNumFound());
        openSearchModule.setStartIndex(startPaginationIndex);

        entry.getModules().add(openSearchModule);
        entry.getModules().add(geoRSSModuleGML);
        entry.setTitle(gisFeatureDistance.getName());
        entry.setAuthor(Constants.MAIL_ADDRESS);
        entry.setLink(Constants.GISFEATURE_BASE_URL + +gisFeatureDistance.getFeatureId());
        SyndContent description = new SyndContentImpl();
        description.setType(OutputFormat.ATOM.getContentType());
        description.setValue(gisFeatureDistance.getName());
        entry.setDescription(description);
        entries.add(entry);
      }

      synFeed.setEntries(entries);

      try {
        oWriter = new OutputStreamWriter(outputStream, Constants.CHARSET);
      } catch (UnsupportedEncodingException e) {
        throw new RuntimeException("unknow encoding " + Constants.CHARSET);
      }

      // Copy synfeed to output
      SyndFeedOutput output = new SyndFeedOutput();
      try {
        output.output(synFeed, oWriter);
        // Flush
        oWriter.flush();
      } catch (Exception e) {
        throw new RuntimeException(e);
      }

    } finally {
      if (oWriter != null)
        try {
          oWriter.close();
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      if (outputStream != null)
        try {
          outputStream.close();
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
    }
  }
예제 #19
0
  protected String exportToRSS(
      String name,
      String description,
      String type,
      double version,
      String displayStyle,
      String feedURL,
      String entryURL,
      List blogsEntries)
      throws SystemException {

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setFeedType(type + "_" + version);
    syndFeed.setTitle(name);
    syndFeed.setLink(feedURL);
    syndFeed.setDescription(GetterUtil.getString(description, name));

    List entries = new ArrayList();

    syndFeed.setEntries(entries);

    Iterator itr = blogsEntries.iterator();

    while (itr.hasNext()) {
      BlogsEntry entry = (BlogsEntry) itr.next();

      String author = PortalUtil.getUserName(entry.getUserId(), entry.getUserName());

      String link = entryURL;

      if (link.endsWith("/blogs/rss")) {
        link = link.substring(0, link.length() - 3) + entry.getUrlTitle();
      } else {
        if (!link.endsWith("?")) {
          link += "&";
        }

        link += "entryId=" + entry.getEntryId();
      }

      String value = null;

      if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_ABSTRACT)) {
        value =
            StringUtil.shorten(
                Html.stripHtml(entry.getContent()), _RSS_ABSTRACT_LENGTH, StringPool.BLANK);
      } else {
        value = entry.getContent();
      }

      SyndEntry syndEntry = new SyndEntryImpl();

      syndEntry.setAuthor(author);
      syndEntry.setTitle(entry.getTitle());
      syndEntry.setLink(link);
      syndEntry.setPublishedDate(entry.getCreateDate());

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType("html");
      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      entries.add(syndEntry);
    }

    try {
      return RSSUtil.export(syndFeed);
    } catch (FeedException fe) {
      throw new SystemException(fe);
    } catch (IOException ioe) {
      throw new SystemException(ioe);
    }
  }
예제 #20
0
  @Override
  protected void processModel(
      Map<String, Object> model, DecoratorRequest request, DecoratorResponse response)
      throws Exception {
    super.processModel(model, request, response);

    Map<String, Object> conf = new HashMap<String, Object>();

    String urls = request.getStringParameter(Parameter.URLS.getId());
    if (urls == null) {
      throw new DecoratorComponentException("Component parameter 'urls' is required");
    }

    String feedTitle = request.getStringParameter(Parameter.FEED_TITLE.getId());
    if (feedTitle != null) {
      conf.put("feedTitleValue", feedTitle.trim());
    }

    if (parameterHasValue(PARAMETER_ITEM_PICTURE, "true", request)) {
      conf.put("itemPicture", true);
    }

    if (!parameterHasValue(Parameter.DISPLAY_CHANNEL.getId(), "false", request)) {
      conf.put("displayChannel", true);
    }

    if (parameterHasValue(Parameter.ITEM_DESCRIPTION.getId(), "true", request)) {
      conf.put("itemDescription", true);
    }

    conf.put("maxMsgs", 10);
    String maxMsgsString = request.getStringParameter(Parameter.MAX_MESSAGES.getId());
    if (maxMsgsString != null) {
      try {
        int tmpInt = Integer.parseInt(maxMsgsString);
        if (tmpInt > 0) {
          conf.put("maxMsgs", tmpInt);
        }
      } catch (Exception e) {
      }
    }

    String publishedDateString = request.getStringParameter(Parameter.PUBLISHED_DATE.getId());
    if ("none".equals(publishedDateString)) {
      conf.put("publishedDate", null);
    } else if ("date".equals(publishedDateString)) {
      conf.put("publishedDate", "short");
    } else {
      conf.put("publishedDate", "long");
    }

    // Typical sort strings we handle:
    // asc
    // item-title
    // item-title desc
    // desc item-title
    // etc..
    String sortString = request.getStringParameter(Parameter.SORT.getId());
    // Indicates explicitly set sort direction
    boolean directionSpecified = false;
    if (sortString != null) {
      StringTokenizer tokenizer = new StringTokenizer(sortString);
      while (tokenizer.hasMoreTokens()) {
        String token = tokenizer.nextToken();
        if ("item-title".equals(token)) {
          conf.put("sortByTitle", true);
          if (!directionSpecified) {
            // Set to default for title, if not already specified.
            conf.put("sortAscending", true);
          }
        } else if ("asc".equalsIgnoreCase(token)) {
          conf.put("sortAscending", true);
          directionSpecified = true;
        } else if ("desc".equalsIgnoreCase(token)) {
          conf.remove("sortAscending");
          directionSpecified = true;
        }
      }
    }

    boolean includeIfEmpty = true;
    String includeIfEmptyParam = request.getStringParameter(Parameter.INCLUDE_IF_EMPTY.getId());
    if ("false".equalsIgnoreCase(includeIfEmptyParam)) {
      includeIfEmpty = false;
    }
    conf.put("includeIfEmpty", includeIfEmpty);

    String displayCategoriesParam =
        request.getStringParameter(Parameter.DISPLAY_CATEGORIES.getId());
    if (displayCategoriesParam != null && "true".equalsIgnoreCase(displayCategoriesParam)) {
      conf.put("displayCategories", true);
    }

    SyndFeed feed = new SyndFeedImpl();
    feed.setTitle("Aggregated Feed");
    feed.setDescription("Vortex Aggregated Feed");
    feed.setAuthor("Vortex");
    feed.setLink("http://www.uio.no");

    List<SyndEntry> entries = new ArrayList<SyndEntry>();
    feed.setEntries(entries);

    Map<SyndEntry, SyndFeed> feedMapping = new HashMap<SyndEntry, SyndFeed>();

    boolean displayChannel =
        conf.get("displayChannel") != null && (Boolean) conf.get("displayChannel");
    if (displayChannel) {
      model.put("feedMapping", new FeedMapping(feedMapping));
    }

    URL requestURL = RequestContext.getRequestContext().getRequestURL();

    String[] urlArray = urls.split(",");
    Map<String, String> imgMap = new HashMap<String, String>();
    Map<String, String> descriptionNoImage = new HashMap<String, String>();

    parseFeeds(request, entries, feedMapping, imgMap, descriptionNoImage, requestURL, urlArray);

    try {
      sort(entries);
    } catch (MissingPublishedDateException e) {
      SyndFeed f = feedMapping.get(e.getEntry());
      throw new MissingPublishedDateException(
          "Unable to sort feed '" + f.getUri() + "': does not contain published date");
    }

    List<String> elementOrder = getElementOrder(PARAMETER_FEED_ELEMENT_ORDER, request);
    model.put("elementOrder", elementOrder);

    model.put("descriptionNoImage", descriptionNoImage);
    model.put("imageMap", imgMap);

    String displayIfEmptyMessage = request.getStringParameter(PARAMETER_IF_EMPTY_MESSAGE);
    if (displayIfEmptyMessage != null && displayIfEmptyMessage.length() > 0) {
      model.put("displayIfEmptyMessage", displayIfEmptyMessage);
    }

    /* Temp fix for auth variable in ftl. */
    conf.put("auth", true);

    model.put("feed", feed);
    model.put("conf", conf);
  }
  protected String exportToRSS(
      ResourceRequest resourceRequest,
      ResourceResponse resourceResponse,
      String title,
      String description,
      String format,
      double version,
      String displayStyle,
      List<SocialActivity> socialActivities,
      ServiceContext serviceContext)
      throws Exception {

    ThemeDisplay themeDisplay = (ThemeDisplay) resourceRequest.getAttribute(WebKeys.THEME_DISPLAY);

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setDescription(GetterUtil.getString(description, title));

    List<SyndEntry> syndEntries = new ArrayList<>();

    syndFeed.setEntries(syndEntries);

    for (SocialActivity socialActivity : socialActivities) {
      SocialActivityFeedEntry socialActivityFeedEntry =
          _socialActivityInterpreterLocalService.interpret(
              StringPool.BLANK, socialActivity, serviceContext);

      if (socialActivityFeedEntry == null) {
        continue;
      }

      SyndEntry syndEntry = new SyndEntryImpl();

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);

      String value = null;

      if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
        value = StringPool.BLANK;
      } else {
        value = socialActivityFeedEntry.getBody();
      }

      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      if (Validator.isNotNull(socialActivityFeedEntry.getLink())) {
        syndEntry.setLink(socialActivityFeedEntry.getLink());
      }

      syndEntry.setPublishedDate(new Date(socialActivity.getCreateDate()));
      syndEntry.setTitle(HtmlUtil.extractText(socialActivityFeedEntry.getTitle()));
      syndEntry.setUri(syndEntry.getLink());

      syndEntries.add(syndEntry);
    }

    syndFeed.setFeedType(RSSUtil.getFeedType(format, version));

    List<SyndLink> syndLinks = new ArrayList<>();

    syndFeed.setLinks(syndLinks);

    SyndLink selfSyndLink = new SyndLinkImpl();

    syndLinks.add(selfSyndLink);

    LiferayPortletResponse liferayPortletResponse = (LiferayPortletResponse) resourceResponse;

    ResourceURL rssURL = liferayPortletResponse.createResourceURL();

    rssURL.setParameter("feedTitle", title);
    rssURL.setResourceID("rss");

    selfSyndLink.setHref(rssURL.toString());

    selfSyndLink.setRel("self");

    SyndLink alternateSyndLink = new SyndLinkImpl();

    syndLinks.add(alternateSyndLink);

    alternateSyndLink.setHref(PortalUtil.getLayoutFullURL(themeDisplay));
    alternateSyndLink.setRel("alternate");

    syndFeed.setPublishedDate(new Date());
    syndFeed.setTitle(title);
    syndFeed.setUri(rssURL.toString());

    return RSSUtil.export(syndFeed);
  }
예제 #22
0
  /**
   * Fills in the feed and entry-level metadata from DSpace objects.
   *
   * @param request request
   * @param context context
   * @param dso DSpaceObject
   * @param items array of objects
   * @param labels label map
   */
  public void populate(
      HttpServletRequest request,
      Context context,
      DSpaceObject dso,
      List<? extends DSpaceObject> items,
      Map<String, String> labels) {
    String logoURL = null;
    String objectURL = null;
    String defaultTitle = null;
    boolean podcastFeed = false;
    this.request = request;

    // dso is null for the whole site, or a search without scope
    if (dso == null) {
      defaultTitle = ConfigurationManager.getProperty("dspace.name");
      feed.setDescription(localize(labels, MSG_FEED_DESCRIPTION));
      objectURL = resolveURL(request, null);
      logoURL = ConfigurationManager.getProperty("webui.feed.logo.url");
    } else {
      Bitstream logo = null;
      if (dso.getType() == Constants.COLLECTION) {
        Collection col = (Collection) dso;
        defaultTitle = col.getName();
        feed.setDescription(collectionService.getMetadata(col, "short_description"));
        logo = col.getLogo();
        String cols = ConfigurationManager.getProperty("webui.feed.podcast.collections");
        if (cols != null && cols.length() > 1 && cols.contains(col.getHandle())) {
          podcastFeed = true;
        }
      } else if (dso.getType() == Constants.COMMUNITY) {
        Community comm = (Community) dso;
        defaultTitle = comm.getName();
        feed.setDescription(communityService.getMetadata(comm, "short_description"));
        logo = comm.getLogo();
        String comms = ConfigurationManager.getProperty("webui.feed.podcast.communities");
        if (comms != null && comms.length() > 1 && comms.contains(comm.getHandle())) {
          podcastFeed = true;
        }
      }
      objectURL = resolveURL(request, dso);
      if (logo != null) {
        logoURL = urlOfBitstream(request, logo);
      }
    }
    feed.setTitle(
        labels.containsKey(MSG_FEED_TITLE) ? localize(labels, MSG_FEED_TITLE) : defaultTitle);
    feed.setLink(objectURL);
    feed.setPublishedDate(new Date());
    feed.setUri(objectURL);

    // add logo if we found one:
    if (logoURL != null) {
      // we use the path to the logo for this, the logo itself cannot
      // be contained in the rdf. Not all RSS-viewers show this logo.
      SyndImage image = new SyndImageImpl();
      image.setLink(objectURL);
      if (StringUtils.isNotBlank(feed.getTitle())) {
        image.setTitle(feed.getTitle());
      } else {
        image.setTitle(localize(labels, MSG_LOGO_TITLE));
      }
      image.setUrl(logoURL);
      feed.setImage(image);
    }

    // add entries for items
    if (items != null) {
      List<SyndEntry> entries = new ArrayList<SyndEntry>();
      for (DSpaceObject itemDSO : items) {
        if (itemDSO.getType() != Constants.ITEM) {
          continue;
        }
        Item item = (Item) itemDSO;
        boolean hasDate = false;
        SyndEntry entry = new SyndEntryImpl();
        entries.add(entry);

        String entryURL = resolveURL(request, item);
        entry.setLink(entryURL);
        entry.setUri(entryURL);

        String title = getOneDC(item, titleField);
        entry.setTitle(title == null ? localize(labels, MSG_UNTITLED) : title);

        // "published" date -- should be dc.date.issued
        String pubDate = getOneDC(item, dateField);
        if (pubDate != null) {
          entry.setPublishedDate((new DCDate(pubDate)).toDate());
          hasDate = true;
        }
        // date of last change to Item
        entry.setUpdatedDate(item.getLastModified());

        StringBuffer db = new StringBuffer();
        for (String df : descriptionFields) {
          // Special Case: "(date)" in field name means render as date
          boolean isDate = df.indexOf("(date)") > 0;
          if (isDate) {
            df = df.replaceAll("\\(date\\)", "");
          }

          List<MetadataValue> dcv = itemService.getMetadataByMetadataString(item, df);
          if (dcv.size() > 0) {
            String fieldLabel = labels.get(MSG_METADATA + df);
            if (fieldLabel != null && fieldLabel.length() > 0) {
              db.append(fieldLabel).append(": ");
            }
            boolean first = true;
            for (MetadataValue v : dcv) {
              if (first) {
                first = false;
              } else {
                db.append("; ");
              }
              db.append(isDate ? new DCDate(v.getValue()).toString() : v.getValue());
            }
            db.append("\n");
          }
        }
        if (db.length() > 0) {
          SyndContent desc = new SyndContentImpl();
          desc.setType("text/plain");
          desc.setValue(db.toString());
          entry.setDescription(desc);
        }

        // This gets the authors into an ATOM feed
        List<MetadataValue> authors = itemService.getMetadataByMetadataString(item, authorField);
        if (authors.size() > 0) {
          List<SyndPerson> creators = new ArrayList<SyndPerson>();
          for (MetadataValue author : authors) {
            SyndPerson sp = new SyndPersonImpl();
            sp.setName(author.getValue());
            creators.add(sp);
          }
          entry.setAuthors(creators);
        }

        // only add DC module if any DC fields are configured
        if (dcCreatorField != null || dcDateField != null || dcDescriptionField != null) {
          DCModule dc = new DCModuleImpl();
          if (dcCreatorField != null) {
            List<MetadataValue> dcAuthors =
                itemService.getMetadataByMetadataString(item, dcCreatorField);
            if (dcAuthors.size() > 0) {
              List<String> creators = new ArrayList<String>();
              for (MetadataValue author : dcAuthors) {
                creators.add(author.getValue());
              }
              dc.setCreators(creators);
            }
          }
          if (dcDateField != null && !hasDate) {
            List<MetadataValue> v = itemService.getMetadataByMetadataString(item, dcDateField);
            if (v.size() > 0) {
              dc.setDate((new DCDate(v.get(0).getValue())).toDate());
            }
          }
          if (dcDescriptionField != null) {
            List<MetadataValue> v =
                itemService.getMetadataByMetadataString(item, dcDescriptionField);
            if (v.size() > 0) {
              StringBuffer descs = new StringBuffer();
              for (MetadataValue d : v) {
                if (descs.length() > 0) {
                  descs.append("\n\n");
                }
                descs.append(d.getValue());
              }
              dc.setDescription(descs.toString());
            }
          }
          entry.getModules().add(dc);
        }

        // iTunes Podcast Support - START
        if (podcastFeed) {
          // Add enclosure(s)
          List<SyndEnclosure> enclosures = new ArrayList();
          try {
            List<Bundle> bunds = itemService.getBundles(item, "ORIGINAL");
            if (bunds.get(0) != null) {
              List<Bitstream> bits = bunds.get(0).getBitstreams();
              for (Bitstream bit : bits) {
                String mime = bit.getFormat(context).getMIMEType();
                if (ArrayUtils.contains(podcastableMIMETypes, mime)) {
                  SyndEnclosure enc = new SyndEnclosureImpl();
                  enc.setType(bit.getFormat(context).getMIMEType());
                  enc.setLength(bit.getSize());
                  enc.setUrl(urlOfBitstream(request, bit));
                  enclosures.add(enc);
                } else {
                  continue;
                }
              }
            }
            // Also try to add an external value from dc.identifier.other
            // We are assuming that if this is set, then it is a media file
            List<MetadataValue> externalMedia =
                itemService.getMetadataByMetadataString(item, externalSourceField);
            if (externalMedia.size() > 0) {
              for (MetadataValue anExternalMedia : externalMedia) {
                SyndEnclosure enc = new SyndEnclosureImpl();
                enc.setType(
                    "audio/x-mpeg"); // We can't determine MIME of external file, so just picking
                                     // one.
                enc.setLength(1);
                enc.setUrl(anExternalMedia.getValue());
                enclosures.add(enc);
              }
            }

          } catch (Exception e) {
            System.out.println(e.getMessage());
          }
          entry.setEnclosures(enclosures);

          // Get iTunes specific fields: author, subtitle, summary, duration, keywords
          EntryInformation itunes = new EntryInformationImpl();

          String author = getOneDC(item, authorField);
          if (author != null && author.length() > 0) {
            itunes.setAuthor(author); // <itunes:author>
          }

          itunes.setSubtitle(
              title == null ? localize(labels, MSG_UNTITLED) : title); // <itunes:subtitle>

          if (db.length() > 0) {
            itunes.setSummary(db.toString()); // <itunes:summary>
          }

          String extent =
              getOneDC(
                  item,
                  "dc.format.extent"); // assumed that user will enter this field with length of
                                       // song in seconds
          if (extent != null && extent.length() > 0) {
            extent = extent.split(" ")[0];
            Integer duration = Integer.parseInt(extent);
            itunes.setDuration(new Duration(duration)); // <itunes:duration>
          }

          String subject = getOneDC(item, "dc.subject");
          if (subject != null && subject.length() > 0) {
            String[] subjects = new String[1];
            subjects[0] = subject;
            itunes.setKeywords(subjects); // <itunes:keywords>
          }

          entry.getModules().add(itunes);
        }
      }
      feed.setEntries(entries);
    }
  }
예제 #23
0
  protected String exportToRSS(
      PortletRequest portletRequest,
      PortletResponse portletResponse,
      String name,
      String description,
      String type,
      double version,
      String displayStyle,
      String linkBehavior,
      List<AssetEntry> assetEntries)
      throws Exception {

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setFeedType(RSSUtil.getFeedType(type, version));
    syndFeed.setTitle(name);
    syndFeed.setLink(getFeedURL(portletRequest));
    syndFeed.setDescription(GetterUtil.getString(description, name));

    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();

    syndFeed.setEntries(syndEntries);

    for (AssetEntry assetEntry : assetEntries) {
      String link = getEntryURL(portletRequest, portletResponse, linkBehavior, assetEntry);

      String author = PortalUtil.getUserName(assetEntry);

      String value = null;

      String languageId = LanguageUtil.getLanguageId(portletRequest);

      if (displayStyle.equals(RSSUtil.DISPLAY_STYLE_TITLE)) {
        value = StringPool.BLANK;
      } else {
        value = assetEntry.getSummary(languageId, true);
      }

      SyndEntry syndEntry = new SyndEntryImpl();

      syndEntry.setAuthor(author);

      syndEntry.setTitle(assetEntry.getTitle(languageId, true));

      syndEntry.setLink(link);
      syndEntry.setUri(syndEntry.getLink());
      syndEntry.setPublishedDate(assetEntry.getCreateDate());
      syndEntry.setUpdatedDate(assetEntry.getModifiedDate());

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);
      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      syndEntries.add(syndEntry);
    }

    return RSSUtil.export(syndFeed);
  }
예제 #24
0
  protected String exportToRSS(
      ResourceRequest resourceRequest,
      ResourceResponse resourceResponse,
      JournalFeed feed,
      String languageId,
      Layout layout,
      ThemeDisplay themeDisplay)
      throws Exception {

    SyndFeed syndFeed = new SyndFeedImpl();

    syndFeed.setDescription(feed.getDescription());

    List<SyndEntry> syndEntries = new ArrayList<SyndEntry>();

    syndFeed.setEntries(syndEntries);

    List<JournalArticle> articles = JournalRSSUtil.getArticles(feed);

    if (_log.isDebugEnabled()) {
      _log.debug("Syndicating " + articles.size() + " articles");
    }

    for (JournalArticle article : articles) {
      SyndEntry syndEntry = new SyndEntryImpl();

      String author = PortalUtil.getUserName(article);

      syndEntry.setAuthor(author);

      SyndContent syndContent = new SyndContentImpl();

      syndContent.setType(RSSUtil.ENTRY_TYPE_DEFAULT);

      String value = article.getDescription(languageId);

      try {
        value = processContent(feed, article, languageId, themeDisplay, syndEntry, syndContent);
      } catch (Exception e) {
        if (_log.isWarnEnabled()) {
          _log.warn(e, e);
        }
      }

      syndContent.setValue(value);

      syndEntry.setDescription(syndContent);

      String link = getEntryURL(resourceRequest, feed, article, layout, themeDisplay);

      syndEntry.setLink(link);

      syndEntry.setPublishedDate(article.getDisplayDate());
      syndEntry.setTitle(article.getTitle(languageId));
      syndEntry.setUpdatedDate(article.getModifiedDate());
      syndEntry.setUri(link);

      syndEntries.add(syndEntry);
    }

    syndFeed.setFeedType(feed.getFeedType() + "_" + feed.getFeedVersion());

    List<SyndLink> syndLinks = new ArrayList<SyndLink>();

    syndFeed.setLinks(syndLinks);

    SyndLink selfSyndLink = new SyndLinkImpl();

    syndLinks.add(selfSyndLink);

    ResourceURL feedURL = resourceResponse.createResourceURL();

    feedURL.setCacheability(ResourceURL.FULL);
    feedURL.setParameter("struts_action", "/journal/rss");
    feedURL.setParameter("groupId", String.valueOf(feed.getGroupId()));
    feedURL.setParameter("feedId", String.valueOf(feed.getFeedId()));

    String link = feedURL.toString();

    selfSyndLink.setHref(link);

    selfSyndLink.setRel("self");

    syndFeed.setTitle(feed.getName());
    syndFeed.setPublishedDate(new Date());
    syndFeed.setUri(feedURL.toString());

    try {
      return RSSUtil.export(syndFeed);
    } catch (FeedException fe) {
      throw new SystemException(fe);
    }
  }