/** * Determines the project keys based on the {@code ActivityRequest}. * * @param request the {@code ActivityRequest} containing the filter information * @return the project keys to be searched */ public static Iterable<String> getProjectKeys(ActivityRequest request) { return getIsValues(request.getStandardFilters().get(PROJECT_KEY)); }
public Iterable<Pair<ActivityObjectType, ActivityVerb>> apply(ActivityRequest activityRequest) { return filter(supported, inActivities(activityRequest)); } };
public NotInUsers(ActivityRequest request) { nottedUsers = getAllValues(NOT, request.getStandardFilters().get(USER.getKey())); }
public Iterable<RepositoryHandle> getRepositories(ActivityRequest request) { Iterable<String> projectKeys = getIsValues(request.getStandardFilters().get(PROJECT_KEY)); Iterable<RepositoryHandle> repoHandles; if (!isEmpty(projectKeys)) { repoHandles = filter(transform(projectKeys, toRepositoryHandles()), notNull()); } else { repoHandles = repositoryManager.getHandles(); } // Filter out any repository handles that match the NOT project_key filter option return filter(repoHandles, repoName(inProjectKeys(request))); }
GetActivityItems(ActivityRequest request, Iterable<ActivityItem> baseItems) { this.activityItems = new BoundedActivityItemTreeSet(evictor, request.getMaxResults(), activityItemSorter); addAll(activityItems, baseItems); // calculate a few request filter properties that we'll refer to frequently shouldIncludeAttachments = any(ImmutableList.of(pair(file(), post()), pair(file(), update())), inActivities(request)); hasSpaceFilter = !isEmpty(getIsValues(request.getStandardFilters().get(PROJECT_KEY))); requestMinDate = Filters.getMinDate(request); // Calculate the predicates beforehand inActivities = inActivities(request); inProjectKeys = inProjectKeys(request); anyUsers = anyInUsers(request); notInUsers = notInUsers(request); followedUsers = getFollowedUsersPredicate(request, userManager.getRemoteUsername()); inDateRange = inDateRange(request); baseUri = request.getContextUri(); }
Set<String> users = getIsValues(request.getStandardFilters().get(USER.getKey())); if (!isEmpty(users)) if (!isEmpty(getAllValues(NOT, request.getStandardFilters().get(USER.getKey())))) changesets = filter(changesets, committedBy(inUsers(request))); commitDate(inDateRange(request)), isEmpty(getIssueKeys(request)) ? Predicates.<ChangesetDataFE>alwaysTrue() : commitComment(containsAnyIssueKey(getIssueKeys(request))), isEmpty(getNotIssueKeys(request)) ? Predicates.<ChangesetDataFE>alwaysTrue() : commitComment(not(containsAnyIssueKey(getNotIssueKeys(request)))), hasCorrectBranch(request))); return memoize(take(request.getMaxResults(), catOptions(transform(filter(changesets, filters),
private Iterable<CrucibleActivityItemParameter> activityItemParameters(ActivityRequest request, Option<Set<Review>> reviews) { ImmutableList.Builder<CrucibleActivityItemParameter> builder = new ImmutableList.Builder<CrucibleActivityItemParameter>(); builder.add(builder(PROJECT_KEY, IN).values(getIsValues(request.getStandardFilters().get(StandardStreamsFilterOption.PROJECT_KEY))).build()); builder.add(builder(USERNAME, IN).values(getIsValues(request.getStandardFilters().get(USER.getKey()))).build()); builder.add(builder(REVIEW_ID, IN).values(transform(reviews.getOrElse(ImmutableSet.<Review>of()), toReviewId())).build()); builder.add(builder(LOG_ACTION, IN).values(SUPPORTED_ACTIONS).build()); for (Date date : getMinDate(request)) { builder.add(builder(CREATE_DATE, GT).value(date).build()); } for (Date date : getMaxDate(request)) { builder.add(builder(CREATE_DATE, LT).value(date).build()); } builder.add(builder(PROJECT_KEY, NOT_IN).values(getAllValues(NOT, request.getStandardFilters().get(StandardStreamsFilterOption.PROJECT_KEY))).build()); builder.add(builder(USERNAME, NOT_IN).values(getAllValues(NOT, request.getStandardFilters().get(USER.getKey()))).build()); return builder.build(); }
/** * Creates a {@code Predicate} to apply the filter by network of "followed users". * * @param request request to generate the predicate from * @param username the user requesting the Activity Stream, as returned by {@link UserManager#getRemoteUsername()} * @return {@code Predicate} to determine if a user matches the filter of the request */ public Predicate<String> getFollowedUsersPredicate(ActivityRequest request, String username) { Collection<Pair<StreamsFilterType.Operator, Iterable<String>>> networkFilters = request.getProviderFilters().get(ConfluenceFilterOptionProvider.NETWORK_FILTER); if (networkFilters.isEmpty()) { return alwaysTrue(); } User user = userAccessor.getUser(username); List<String> followedUsers = followManager.getFollowing(user); if (!getIsValues(networkFilters).isEmpty()) { // Return a predicate on followed users return in(followedUsers); } if (!getNotValues(networkFilters).isEmpty()) { // Return a predicate on followed users return not(in(followedUsers)); } return alwaysTrue(); }
/** * Extracts activity from the given list of issues */ private List<JiraActivityItem> extractActivity(final Iterable<Issue> issues, final ActivityRequest request, Supplier<Boolean> cancelled) { final ApplicationUser user = authenticationContext.getUser(); Predicate<String> inUsers = inUsers(request); Predicate<Date> containsDate = inDateRange(request); Predicate<Option<Pair<ActivityObjectType, ActivityVerb>>> hasActivity = isDefined(); Predicate<Pair<ActivityObjectType, ActivityVerb>> inJiraActivities = inActivities(request); ImmutableList.Builder<JiraActivityItem> builder = ImmutableList.builder(); // map the change histories by issue so we can look them up from inside the loop ChangeHistoryQuery changeHistories = new ChangeHistoryQuery(issueHistoryReader, issues, user); IssueActivityExtractor issueActivityExtractor = new IssueActivityExtractor(user, commentManager, helper, builder, changeHistories, inUsers, containsDate, inJiraActivities); for (final Issue issue : issues) { // Check for cancellation each time through this loop, since we may be pulling // quite a bit of change history for each issue if (cancelled.get()) { throw new CancelledException(); } issueActivityExtractor.extract(issue); } return builder.build(); }
Set<String> authors = ImmutableSet.copyOf(getAuthors(request)); Iterable<String> searchTerms = getSearchTerms(request); Iterable<String> excludedSearchTerms = getExcludedSearchTerms(request); Iterable<ActivityObjectType> activityObjectTypes = getRequestedActivityObjectTypes(request, activities); .inSpace(getProjectKeys(request)) .searchFor(searchTerms) .excludeTerms(excludedSearchTerms) .activityObjects(activityObjectTypes) .minDate(getMinDate(request)) .maxDate(getMaxDate(request)); final SearchSort sort = ModifiedSort.DESCENDING; // latest modified content first SearchFilter searchFilter = new BooleanSearchFilter(
/** * Determines the project keys to exclude based on the {@code ActivityRequest}. * * @param request the {@code ActivityRequest} containing the filter information * @return the project keys to be excluded */ public static Iterable<String> getNotProjectKeys(ActivityRequest request) { return getNotValues(request.getStandardFilters().get(PROJECT_KEY)); }
notPhantomReview(), inCrucibleActivities(request), activityItemReview(nameOrDescription(containsIssueKeys(getIssueKeys(request)).getOrElse(Predicates.<String>alwaysTrue()))), activityItemReview(not(nameOrDescription(containsIssueKeys(getNotIssueKeys(request)).getOrElse(Predicates.<String>alwaysFalse())))), userVisible )))),
public AnyInUsers(ActivityRequest request) { inUsers = inUsers(request); }
public static Set<String> getNotValues(Iterable<Pair<Operator, Iterable<String>>> filters) { Pair<Set<String>, Set<String>> isAndNotValues = getIsAndNotValues(filters); return isAndNotValues.second(); }
private Builder getQueryParametersBuilder(ActivityRequest request) { Iterable<String> issueKeys = getIssueKeys(request); final Builder queryBuilder = recentChangesetsService.getQueryBuilder(); if (!isEmpty(issueKeys)) { queryBuilder.comment(Joiner.on(" ").join(issueKeys)); } return queryBuilder; }
@Override public CancellableTask<StreamsFeed> getActivityFeed(final ActivityRequest activityRequest) { final BuildIssueFilter filter = new BuildIssueFilter(); filter.setInProjectKeys(getInProjectsByPermission(Filters.getIsValues(activityRequest.getStandardFilters().get (StandardStreamsFilterOption.PROJECT_KEY)))); filter.setNotInProjectKeys(Filters.getNotValues(activityRequest.getStandardFilters().get (StandardStreamsFilterOption.PROJECT_KEY))); filter.setInIssueKeys(Filters.getIsValues(activityRequest.getStandardFilters().get(StandardStreamsFilterOption .ISSUE_KEY.getKey()))); filter.setNotInIssueKeys(Filters.getNotValues(activityRequest.getStandardFilters().get (StandardStreamsFilterOption.ISSUE_KEY.getKey()))); filter.setInUsers(Filters.getIsValues(activityRequest.getStandardFilters().get(StandardStreamsFilterOption.USER .getKey()))); filter.setNotInUsers(Filters.getNotValues(activityRequest.getStandardFilters().get(StandardStreamsFilterOption .USER.getKey())));
/** * Determines the search terms (i.e. issue keys) to exclude based on the {@code ActivityRequest}. * * @param request the {@code ActivityRequest} containing the filter information * @return the search terms to be excluded */ public static Iterable<String> getExcludedSearchTerms(ActivityRequest request) { return getNotValues(request.getStandardFilters().get(ISSUE_KEY.getKey())); }
/** * Extracts the set of values to include from the request. It does this by getting the set of values that should be * included - those with the "is" operator - and the set of values that should not be included - those with the * "is not" operator - and taking the difference. * * Useful only when you want to know the set of values to include. The result of this method does not tell you * anything about which values *not* to include. */ public static Set<String> getIsValues(Iterable<Pair<Operator, Iterable<String>>> filters) { Pair<Set<String>, Set<String>> isAndNotValues = getIsAndNotValues(filters); return difference(isAndNotValues.first(), isAndNotValues.second()); }
private Option<Set<Review>> getReviews(ActivityRequest request) { Iterable<String> issueKeys = getIssueKeys(request); final Option<Set<Review>> reviews; if (!isEmpty(issueKeys)) { reviews = some(searchForReviewsContaining(issueKeys)); } else { reviews = none(); } // The IS operators were filtered above, but we still have to take care of any NOT operators. // Here we filter out any reviews that match the NOT issue-key filter options. return reviews.map(filterReviews(request)); }
private Iterable<Project> getProjects(ActivityRequest request) { Iterable<String> projectKeys = getIsValues(request.getStandardFilters().get(PROJECT_KEY)); if (!isEmpty(projectKeys)) { return filter(transform(projectKeys, toProject), and(notNull(), hasPermission)); } else { return permissionManager.getProjects(ProjectPermissions.BROWSE_PROJECTS, authenticationContext.getLoggedInUser()); } }