How to use

StreamsEntry$Parameters

in

com.atlassian.streams.api

.id(buildUrl)
.postedDate(new DateTime(build.getTimestamp()))
.authors(ImmutableNonEmptyList.of(first, others))
.addActivityObject(activityObject)
.verb(ActivityVerbs.post())
.alternateLinkUri(buildUrl)
.renderer(renderer)
.applicationType("com.marvelution.jenkins"), i18nResolver);

public StreamsEntry buildStreamsEntry(final URI baseUri, final ActivityItem activityItem)
{
  URI url = URI.create(baseUri.toASCIIString() + activityItem.getUrlPath());
  return new StreamsEntry(StreamsEntry.params()
      .id(url)
      .postedDate(new DateTime(activityItem.getModified()))
      .applicationType(CONFLUENCE_APPLICATION_TYPE)
      .alternateLinkUri(url)
      .inReplyTo(buildReplyTo(activityItem))
      .addLink(buildReplyTo(activityItem), REPLY_TO_LINK_REL, none(String.class))
      .addLink(buildIconUrl(activityItem), ICON_LINK_REL, some(i18nResolver.getText("streams.item.confluence.tooltip." + activityItem.getContentType())))
      .addLinks(getWatchLink(activityItem))
      .addLinks(transform(uriProvider.getContentCssUris(), toLink(CSS_LINK_REL)))
      .addLinks(transform(uriProvider.getPanelCssUris(), toLink(CSS_LINK_REL)))
      .addLinks(transform(uriProvider.getIconCssUris(), toLink(CSS_LINK_REL)))
      .categories(buildCategory(activityItem))
      .addActivityObjects(activityItem.getActivityObjects())
      .verb(activityItem.getVerb())
      .target(activityItem.getTarget())
      .renderer(activityItem.getRenderer())
      .baseUri(baseUri)
      .authors(ImmutableNonEmptyList.of(userProfileAccessor.getUserProfile(baseUri, activityItem.getChangedBy()))), i18nResolver);
}

authors(helper.getUserProfiles(baseUri, item)).
categories(ImmutableList.of(statusName)).
verb(transition()).
addActivityObject(helper.buildActivityObject(item.getIssue(), baseUri,
    item.getDisplaySummary())).
renderer(rendererFactory.newCustomTransitionRenderer(item, baseUri,
    statusName)), i18nResolver));

.id(uriBuilder.getUri())
.postedDate(new DateTime(changeTimestamp))
.applicationType(CRUCIBLE_APPLICATION_TYPE)
.alternateLinkUri(uri)
.inReplyTo(some(inReplyToUriBuilder.getUri()))
.authors(ImmutableNonEmptyList.of(userProfileAccessor.getUserProfile(baseUri, changeUsername)))
.categories(ImmutableList.of("commented"))
.addLink(buildReplyTo(comment), REPLY_TO_LINK_REL, none(String.class))
.addLink(uriProvider.getReviewIconUri(baseUri), ICON_LINK_REL, some(i18nResolver.getText("streams.item.crucible.tooltip")))
.addActivityObject(buildCommentObject(uriBuilder.getUri(), comment, baseUri))
.verb(verb)
.target(some(buildReviewObject(baseUri, comment.getReview())))
.baseUri(baseUri)
.renderer(reviewRendererFactory.newCommentRenderer(comment.getMessage(), comment.getDefectRaised())), i18nResolver));

params = params.addLink(uriProvider.getRestReviewServiceUri(baseUri, review), REVIEW_SUMMARIZE_AND_CLOSE_REL, none(String.class));
params = params.addLink(uriProvider.getRestReviewServiceUri(baseUri, review), REVIEW_CLOSE_REL, none(String.class));
          .id(uriBuilder.getUri())
          .postedDate(new DateTime(changeTimestamp))
          .applicationType(CRUCIBLE_APPLICATION_TYPE)
          .alternateLinkUri(uri)
          .authors(ImmutableNonEmptyList.of(
              userProfileAccessor.getUserProfile(baseUri, changeUsername)))
          .categories(ImmutableList.of(action))
          .addLink(uriProvider.getReviewIconUri(baseUri), ICON_LINK_REL, some(i18nResolver.getText("streams.item.crucible.tooltip")))
          .addActivityObject(buildReviewObject(uriBuilder.getUri(), review, baseUri))
          .verb(verb)
          .renderer(reviewRendererFactory.newRenderer(verb, review, baseUri))
          .baseUri(baseUri), i18nResolver));

private Option<StreamsEntry> buildSingleActivityItem(URI baseUri, JiraActivityItem item)
{
  Iterable<GenericValue> changeItems = filter(getChangeItems(item), helper.validAttachment());
  if (isEmpty(changeItems))
  {
    return none();
  }
  if (pair(file(), post()).equals(item.getActivity()))
  {
    return buildAttachments(item, baseUri, changeItems);
  }
  else if (pair(issue(), remoteLink()).equals(item.getActivity()))
  {
    return buildRemoteLink(item, baseUri, changeItems);
  }
  else
  {
    return some(new StreamsEntry((item.getComment().isDefined()
          ? helper.newCommentBuilder(baseUri, item) : helper.newBuilder(item, baseUri)).
      authors(helper.getUserProfiles(baseUri, item)).
      addActivityObject(helper.buildActivityObject(item.getIssue(), baseUri, item.getDisplaySummary())).
      verb(update()).
      renderer(issueUpdateRendererFactory.newRenderer(item, baseUri, changeItems)),
        i18nResolver));
  }
}

public StreamsEntry getEntry(final URI baseUri,
               final ChangesetDataFE changeSet,
               final RepositoryHandle repositoryHandle)
{
  final StreamsUriBuilder streamsUriBuilder = new StreamsUriBuilder();
  final URI uri = uriProvider.getChangeSetUri(baseUri, changeSet, repositoryHandle);
  streamsUriBuilder.setUrl(uri.toASCIIString());
  StreamsEntry.Parameters params = StreamsEntry.params();
  if (permissionAccessor.isCreateReviewAllowed())
  {
    params = params.addLink(uriProvider.getChangesetReviewUri(baseUri, changeSet.getCsid(), repositoryHandle.getName()), CHANGESET_REVIEW_REL, none(String.class));
  }
  return new StreamsEntry(params
      .id(streamsUriBuilder.getUri())
      .postedDate(new DateTime(changeSet.getDate()))
      .applicationType(FISHEYE_APPLICATION_TYPE)
      .categories(ImmutableList.of(COMMIT_CATEGORY))
      .authors(ImmutableNonEmptyList.of(userProfileAccessor.getUserProfile(baseUri, getUserName(changeSet))))
      .addLink(uriProvider.getCommitIconUri(baseUri), ICON_LINK_REL, some(i18nResolver.getText("streams.item.fisheye.tooltip.changeset")))
      .alternateLinkUri(uri)
      .addActivityObject(buildActivityObject(baseUri, changeSet, repositoryHandle))
      .verb(push())
      .target(some(buildActivityObject(baseUri, repositoryHandle)))
      .baseUri(baseUri)
      .renderer(rendererFactory.newRenderer(changeSet, repositoryHandle, baseUri)), i18nResolver);
}

  @Override
  public StreamsEntry apply(final StreamsEntry original)
  {
    if (maybeMetadata.isDefined())
    {
      final HistoryMetadata historyMetadata = maybeMetadata.get();
      final String descriptionKey = historyMetadata.getActivityDescriptionKey();
      if (!Strings.isNullOrEmpty(descriptionKey) && (!i18nResolver.getRawText(descriptionKey).equals(descriptionKey)))
      {
        return new StreamsEntry(StreamsEntry.params(original)
            .renderer(historyMetadataRendererFactory.newCustomKeyRenderer(original, historyMetadata)), i18nResolver);
      }
      else if (!Strings.isNullOrEmpty(historyMetadata.getActivityDescription()))
      {
        return new StreamsEntry(StreamsEntry.params(original)
            .renderer(historyMetadataRendererFactory.newSuffixRenderer(original, historyMetadata.getActivityDescription())), i18nResolver);
      }
    }
    return original;
  }
}

private Option<StreamsEntry> buildAttachments(JiraActivityItem item, URI baseUri, Iterable<GenericValue> changeItems)
{
  Iterable<Attachment> attachments = helper.extractAttachments(changeItems);
  if (!isEmpty(attachments))
  {
    return some(new StreamsEntry(helper.newBuilder(item, baseUri).
        authors(helper.getUserProfiles(baseUri, item)).
        verb(post()).
        addActivityObjects(helper.buildActivityObjects(baseUri, attachments)).
        target(some(helper.buildActivityObject(item.getIssue(), baseUri, item.getDisplaySummary()))).
        renderer(attachmentRendererFactory.newAttachmentsEntryRenderer(item, baseUri, attachments)),
          i18nResolver));
  }
  else
  {
    // If attachment has been deleted, we shouldn't display any streams entry (STRM-913)
    return none();
  }
}

  public Option<StreamsEntry> build(JiraActivityItem item, ActivityRequest request)
  {
    for (Comment comment : item.getComment())
    {
      final URI baseUri = request.getContextUri();
      return some(new StreamsEntry(helper.newCommentBuilder(baseUri, item).
        authors(ImmutableNonEmptyList.of(helper.getUserProfile(baseUri)
            .apply(getNameFor(comment.getAuthorApplicationUser())))).
            categories(ImmutableList.of(COMMENT_CATEGORY)).
            inReplyTo(some(new StreamsUriBuilder().setUrl(helper.getIssueUri(baseUri, item).toASCIIString())
                .getUri())).
            verb(post()).
            addActivityObject(helper.buildActivityObject(baseUri, comment)).
            target(some(helper.buildActivityObject(comment.getIssue(), baseUri,
                item.getDisplaySummary()))).
            renderer(rendererFactory.newInstance(item, comment)), i18nResolver));
    }
    return none();
  }
}

  private Option<StreamsEntry> buildRemoteLink(JiraActivityItem item, URI baseUri, Iterable<GenericValue> changeItems)
  {
    final Option<RemoteIssueLink> remoteLink = helper.extractRemoteIssueLink(changeItems);

    if (remoteLink.isDefined())
    {
      return some(new StreamsEntry(helper.newBuilder(item, baseUri).
        authors(helper.getUserProfiles(baseUri, item)).
        addActivityObject(helper.buildActivityObject(item.getIssue(), baseUri, item.getDisplaySummary())).
        verb(update()).
        renderer(issueUpdateRendererFactory.newRemoteIssueLinkEntryRenderer(baseUri, item, remoteLink.get())), i18nResolver));
    }
    else
    {
      // If remote link has been deleted, we shouldn't display any streams entry (STRM-913)
      return none();
    }
  }
}

private StreamsEntry.Parameters<HasId, HasPostedDate, HasAlternateLinkUri, HasApplicationType, NeedsRenderer, NeedsVerb, NeedsAuthors>
newParams(JiraActivityItem item, URI itemUri, URI baseUri, boolean issueLinked)
{
  final StreamsUriBuilder uriBuilder = new StreamsUriBuilder().setUrl(itemUri.toASCIIString());
  if (item.getChangeHistory().isDefined() || item.getComment().isDefined())
  {
    uriBuilder.setTimestamp(item.getDate());
  }
  // The following things are constant across all types of activity
  return StreamsEntry.params()
      .id(uriBuilder.getUri())
      .postedDate(new DateTime(item.getDate()))
      .applicationType(JIRA_APPLICATION_TYPE)
      .alternateLinkUri(itemUri)
      .baseUri(baseUri)
      .addLinks(buildLinks(item, issueLinked));
}

  private Option<StreamsEntry> newEntryForStatus(JiraActivityItem item, URI baseUri, String status, ActivityVerb verb)
  {
    Renderer renderer = resolve().equals(verb) ?
      rendererFactory.newResolvedRenderer(item, baseUri) :
        rendererFactory.newSystemTransitionRenderer(item, baseUri, verb);

    return some(new StreamsEntry(helper.newBuilder(item, baseUri).
      authors(helper.getUserProfiles(baseUri, item)).
      categories(ImmutableList.of(status)).
      verb(verb).
      addActivityObject(helper.buildActivityObject(item.getIssue(), baseUri,
          item.getDisplaySummary())).
      renderer(renderer), i18nResolver));
  }
}

private Option<StreamsEntry> buildMultipleActivityItem(URI baseUri, AggregatedJiraActivityItem aggregatedItem)
{
  if (pair(issue(), link()).equals(aggregatedItem.getActivity()))
  {
    JiraActivityItem mainItem = aggregatedItem.getActivityItem();
    return some(new StreamsEntry(helper.newLinkedIssueBuilder(baseUri, mainItem).
      authors(helper.getUserProfiles(baseUri, mainItem)).
      addActivityObject(helper.buildActivityObject(mainItem.getIssue(), baseUri, mainItem.getDisplaySummary())).
      verb(update()).
      renderer(issueUpdateRendererFactory.newIssueLinkEntryRenderer(baseUri, aggregatedItem)),
        i18nResolver));
  }
  return none();
}

@Override
public Html renderTitleAsHtml(final StreamsEntry entry)
{
  String descriptionKey = historyMetadata.getActivityDescriptionKey();
  Html generatorDisplayName = participantRenderer.apply(historyMetadata.getGenerator());
  Html causeDisplayName = participantRenderer.apply(historyMetadata.getCause());
  final NonEmptyIterable<UserProfile> emptyAuthor = NonEmptyIterables.from(Collections.singleton(new UserProfile.Builder("").build())).get();
  return new Html(i18nResolver.getText(descriptionKey,
      originalEntry.renderTitleAsHtml(),
      streamsEntryRendererFactory.newAuthorsRenderer().apply(originalEntry.getAuthors()),
      new StreamsEntry(StreamsEntry.params(originalEntry).authors(emptyAuthor), i18nResolver).renderTitleAsHtml(),
      generatorDisplayName, causeDisplayName));
}

  public Option<StreamsEntry> build(JiraActivityItem item, ActivityRequest request)
  {
    Issue issue = item.getIssue();
    URI baseUri = request.getContextUri();
    return some(new StreamsEntry(helper.newBuilder(item, baseUri).
      authors(ImmutableNonEmptyList.of(helper.getUserProfile(baseUri)
          .apply(getNameFor(issue.getCreator())))).
      categories(ImmutableList.of(CREATED_CATEGORY)).
      addActivityObject(helper.buildActivityObject(issue, baseUri, item.getDisplaySummary())).
      verb(post()).
      renderer(rendererFactory.newInstance(item.getIssue(), baseUri, item.getInitialDescription())), i18nResolver));
  }
}