public Set<Issue> find(final ActivityRequest request) { Collection<Project> projects = ImmutableSet.copyOf(getProjects(request)); if (projects.isEmpty()) { // If there are no projects then that means the user doesn't have permission to browse the requested project return ImmutableSet.of(); } return ImmutableSet.copyOf(changeHistoryManager.findUserHistory( authenticationContext.getLoggedInUser(), getUsers(request), projects, request.getMaxResults())); }
/** * Creates a {@code Predicate} to determine if a project key matches the filters from the request. If the request * does not contain any project key filters, the returned {@code Predicate} will return {@code true} for every * project key. * * @param request request to generate the project key predicate from * @return {@code Predicate} to determine if a project key matches the filters from the request */ public static Predicate<String> inProjectKeys(ActivityRequest request) { return isAndNot(request.getStandardFilters().get(PROJECT_KEY)); }
/** * Converts an {@code Iterable} of {@code ActivityItem}s to an {@code Iterable} of {@code StreamsEntry}s, * while respecting a set of filters specified by a {@code ActivityRequest}. * * @param request the {@code ActivityRequest} containing the filters * @param activityItems {@code ActivityItem}s to convert * @return the filtered {@code Iterable} of {@code StreamsEntry}s */ private Iterable<StreamsEntry> toStreamsEntries(final ActivityRequest request, Iterable<ActivityItem> activityItems, Supplier<Boolean> cancelled) { // we use Iterables.size immediately after we return from here, so we might as well create a list now return ImmutableList.copyOf(take(request.getMaxResults(), catOptions(transform(activityItems, toStreamsEntry(request.getContextUri(), cancelled))))); }
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())))) isEmpty(getNotIssueKeys(request)) ? Predicates.<ChangesetDataFE>alwaysTrue() : commitComment(not(containsAnyIssueKey(getNotIssueKeys(request)))), hasCorrectBranch(request))); return memoize(take(request.getMaxResults(), catOptions(transform(filter(changesets, filters), toStreamsEntry(baseUri, repository)))));
private static boolean providerFilterExists(ActivityRequest request, String filterKey) { return filterExists(request.getProviderFilters(), filterKey); }
private Function2<RepositoryHandle, Iterable<Iterable<StreamsEntry>>, Iterable<Iterable<StreamsEntry>>> appendChangesets(final ActivityRequest request, final Supplier<Boolean> cancelled) { final URI baseUri = request.getContextUri(); return new Function2<RepositoryHandle, Iterable<Iterable<StreamsEntry>>, Iterable<Iterable<StreamsEntry>>>() { @Override public Iterable<Iterable<StreamsEntry>> apply(RepositoryHandle repository, Iterable<Iterable<StreamsEntry>> acc) { if (cancelled.get()) { throw new CancelledException(); } Iterable<StreamsEntry> changesets = finder.getChangesets(baseUri, repository, request, cancelled); return concat(acc, ImmutableList.of(changesets)); } }; } }
public boolean apply(final ChangesetDataFE changeset) { if (changeset == null) { return false; } return all(request.getProviderFilters().get(FishEyeFilterOptionProvider.BRANCH), new Predicate<Pair<Operator, Iterable<String>>>() { @Override public boolean apply(Pair<Operator, Iterable<String>> filter) { SetView<String> intersection = intersection(changeset.getBranches(), ImmutableSet.copyOf(filter.second())); if (Operator.IS.equals(filter.first())) { // we are looking for an intersection return !intersection.isEmpty(); } if (Operator.NOT.equals(filter.first())) { // we are looking for NO intersection return intersection.isEmpty(); } // the only operators we should really see are IS and NOT, but this is a // fail-safe return false; } }); } };
@Override public Option<StreamsEntry> apply(Pair<Pair<StreamsCrucibleActivityItem, ActivityVerb>, ActivityRequest> activityEntry) { // getting entry properties may be expensive, so check for interrupts here CancelledException.throwIfInterrupted(); return crucibleEntryFactory.getEntryFromActivityItem(activityEntry, activityRequest.getContextUri()); } })));
/** * 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)); }
@Override public StreamsFeed call() throws Exception { Iterable<StreamsEntry> entries = Lists.newArrayList(); if (!filter.getInProjectKeys().isEmpty() && filter.getInUsers().isEmpty()) { Iterable<Build> builds = buildService.getLatestBuildsByFilter(activityRequest.getMaxResults(), filter); if (cancelled.get()) { throw new CancelledException(); } LOGGER.debug("Found build entries for stream: " + builds); entries = transformEntries(builds, cancelled); } return new StreamsFeed(i18nResolver.getText("jenkins.streams.feed.title"), entries, Option.<String>none()); }
/** * Creates a {@code Predicate} to determine if an {@code ActivityObjectType}/{@code ActivityVerb} pair * matches the activity filters from the request. If the request does not contain any activity filters, the returned * {@code Predicate} will return {@code true} for every combination. * * @param request request to generate the activity predicate from * @return {@code Predicate} to determine if a activity matches the filters from the request */ public static Predicate<Option<Pair<ActivityObjectType, ActivityVerb>>> inOptionActivities(ActivityRequest request) { if (!providerFilterExists(request, ACTIVITY_KEY)) { return alwaysTrue(); } return new InOptionActivities(request.getProviderFilters().get(ACTIVITY_KEY)); }
public Option<StreamsEntry> build(AggregatedJiraActivityItem aggregatedItem, ActivityRequest request) { fetchMetadata(aggregatedItem); URI baseUri = request.getContextUri(); if (isTransitionVerb(aggregatedItem)) { JiraActivityItem item = aggregatedItem.getActivityItem(); return historyMetadataEntryBuilder.buildStatusChangeEntry(item, baseUri, find(getChangeItems(item), isStatusUpdate())); } return historyMetadataEntryBuilder.buildGeneralUpdateEntry(baseUri, aggregatedItem); }
/** * 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)); }
while (size(entries) < request.getMaxResults()) offset += request.getMaxResults(); searchables = search(request, offset, cancelled); if (isEmpty(searchables))
/** * Creates a {@code Predicate} to determine if a {@code StreamsEntry}'s object-type/verb matches the activity * filters from the request. If the request does not contain any activity filters, the returned {@code Predicate} * will return {@code true} for every activity combination. * * @param request request to generate the activity predicate from * @return {@code Predicate} to determine if a activity matches the filters from the request */ public static Predicate<StreamsEntry> entriesInActivities(ActivityRequest request) { if (!providerFilterExists(request, ACTIVITY_KEY)) { return alwaysTrue(); } return new EntriesInActivities(request.getProviderFilters().get(ACTIVITY_KEY)); }
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)); } }
/** * Creates a {@code Predicate} to determine if a date matches the filters from the request. If the request * does not contain any update date filters, the returned {@code Predicate} will return {@code true} for every date. * * @param request request to generate the updated date predicate from * @return {@code Predicate} to determine if a date matches the filters from the request */ public static Predicate<Date> inDateRange(ActivityRequest request) { Predicate<Date> alwaysTrue = Predicates.<Date>alwaysTrue(); return foldl(request.getStandardFilters().get(UPDATE_DATE.getKey()), alwaysTrue, ContainsDate.INSTANCE); }
public Set<Issue> search(final ActivityRequest request) { final Query searchQuery = createSearchQuery(request); final PagerFilter<Issue> pagerFilter = new PagerFilter<Issue>(Math.max(MIN_PAGING_RESULTS, request.getMaxResults())); try { final SearchResults<Issue> searchResults = searchService.search(authenticationContext.getLoggedInUser(), searchQuery, pagerFilter); return ImmutableSet.copyOf(searchResults.getResults()); } catch (final SearchException se) { throw new StreamsException("Error performing search", se); } }
static Clause filterByIssueType(final ActivityRequest request) { return filterBy(request.getProviderFilters().get(ISSUE_TYPE), toIssueTypeClause()); }