/** * Determines the requested activity object types based on the {@code ActivityRequest}. * * @param request the {@code ActivityRequest} containing the filter information * @param activities the set of possible activities * @return the {@link ActivityObjectType}s to be searched */ public static Iterable<ActivityObjectType> getRequestedActivityObjectTypes(ActivityRequest request, Iterable<Pair<ActivityObjectType, ActivityVerb>> activities) { return firsts(filter(activities, inActivities(request))); }
private Predicate<Pair<StreamsCrucibleActivityItem, Option<Pair<ActivityObjectType, ActivityVerb>>>> notPhantomReview() { return withFirst(notPhantomReview); }
private Predicate<Pair<StreamsCrucibleActivityItem, Option<Pair<ActivityObjectType, ActivityVerb>>>> inCrucibleActivities(ActivityRequest request) { return withSecond(inOptionActivities(request)); }
/** * Given a collection of date filters, extract the first date range. * * @param filters the date filters * @return the first date range found */ private static Option<Pair<Date, Date>> getDateRange(Collection<Pair<Operator, Iterable<String>>> filters) { Pair<Operator, Iterable<String>> firstFilter = get(filters, 0); Iterable<Date> dates = transform(firstFilter.second(), toDate()); if (size(dates) < 2) { //no range exists return none(); } Iterable<Pair<Date, Date>> ranges = mkPairs(dates); return some(get(ranges, 0)); }
public boolean apply(StreamsEntry entry) { return any( transform( ActivityObjectTypes.getActivityObjectTypes(entry.getActivityObjects()), Pairs.<ActivityObjectType, ActivityVerb>pairWith(entry.getVerb())), inActivities); } }
/** * Determines the maximum date filter based on the {@code ActivityRequest}. Returns null if none is specified. * * @param request the {@code ActivityRequest} containing the filter information * @return the maximum date */ public static Option<Date> getMaxDate(ActivityRequest request) { Collection<Pair<Operator, Iterable<String>>> filters = request.getStandardFilters().get(UPDATE_DATE.getKey()); //first try with BEFORE operator Option<Long> maxDate = parseLongSafely(getFirstValue(BEFORE, filters)); if (!maxDate.isDefined() && size(filters) > 0) { return getDateRange(filters).map(Pairs.<Date, Date>second()); } return maxDate.map(toDate); }
/** * Determines the minimum date filter based on the {@code ActivityRequest}. Returns null if none is specified. * * @param request the {@code ActivityRequest} containing the filter information * @return the minimum date */ public static Option<Date> getMinDate(ActivityRequest request) { Collection<Pair<Operator, Iterable<String>>> filters = request.getStandardFilters().get(UPDATE_DATE.getKey()); //first try with BEFORE operator Option<Long> minDate = parseLongSafely(getFirstValue(AFTER, filters)); if (!minDate.isDefined() && size(filters) > 0) { return getDateRange(filters).map(Pairs.<Date, Date>first()); } return minDate.map(toDate); }
public Predicate<Date> apply(Pair<Operator, Iterable<String>> filter, Predicate<Date> predicate) { Iterable<Date> dates = transform(filter.second(), toDate()); switch (filter.first()) { case BEFORE: return and(predicate, or(transform(dates, ToBeforePredicate.INSTANCE))); case AFTER: return and(predicate, or(transform(dates, ToAfterPredicate.INSTANCE))); case BETWEEN: Iterable<Pair<Date, Date>> ranges = mkPairs(dates); return and(predicate, or(transform(ranges, ToBetweenPredicate.INSTANCE))); default: return predicate; } } }
private Iterable<Pair<ActivityObjectType, ActivityVerb>> getActivities(ActivityItem activityItem) { return transform( getActivityObjectTypes(activityItem.getActivityObjects()), Pairs.pairWith(activityItem.getVerb())); }
public Clause apply(Pair<Operator, Iterable<String>> dateFilter) { JqlClauseBuilder builder = newClauseBuilder().sub(); ImmutableList<Date> dates = ImmutableList.copyOf(transform(dateFilter.second(), toDate())); switch (dateFilter.first()) { case BEFORE: builder.addClause(or(before(created(), dates))).or().addClause(or(before(updated(), dates))); break; case AFTER: builder.addClause(or(after(created(), dates))).or().addClause(or(after(updated(), dates))); break; case BETWEEN: Iterable<Pair<Date, Date>> ranges = mkPairs(dates); builder.addClause(or(between(created(), ranges))).or().addClause(or(between(updated(), ranges))); break; } return builder.endsub().buildClause(); } }
private Predicate<Pair<StreamsCrucibleActivityItem, Option<Pair<ActivityObjectType, ActivityVerb>>>> activityItemReview(final Predicate<Review> p) { return withFirst(new Predicate<StreamsCrucibleActivityItem>() { public boolean apply(StreamsCrucibleActivityItem item) { return p.apply(item.getReview()); } @Override public String toString() { return String.format("activityItemReview(%s)", p); } }); }