public Map<ShortBranchIssue, DefaultIssue> loadDefaultIssuesWithChanges(Collection<ShortBranchIssue> lightIssues) { if (lightIssues.isEmpty()) { return Collections.emptyMap(); } Map<String, ShortBranchIssue> issuesByKey = lightIssues.stream().collect(Collectors.toMap(ShortBranchIssue::getKey, i -> i)); try (DbSession session = dbClient.openSession(false)) { List<DefaultIssue> issues = dbClient.issueDao().selectByKeys(session, issuesByKey.keySet()) .stream() .map(IssueDto::toDefaultIssue) .collect(toList(issuesByKey.size())); componentIssuesLoader.loadChanges(session, issues); return issues.stream() .collect(uniqueIndex(i -> issuesByKey.get(i.key()), i -> i, issues.size())); } }
private List<IssueDto> loadIssues(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession) { List<IssueDto> preloadedIssues = preloadedResponseData.getIssues(); Set<String> preloadedIssueKeys = preloadedIssues.stream().map(IssueDto::getKey).collect(MoreCollectors.toSet(preloadedIssues.size())); ImmutableSet<String> issueKeys = ImmutableSet.copyOf(collector.getIssueKeys()); Set<String> issueKeysToLoad = copyOf(difference(issueKeys, preloadedIssueKeys)); if (issueKeysToLoad.isEmpty()) { return issueKeys.stream() .map(new KeyToIssueFunction(preloadedIssues)::apply).filter(Objects::nonNull) .collect(Collectors.toList()); } List<IssueDto> loadedIssues = dbClient.issueDao().selectByKeys(dbSession, issueKeysToLoad); List<IssueDto> unorderedIssues = concat(preloadedIssues.stream(), loadedIssues.stream()) .collect(toList(preloadedIssues.size() + loadedIssues.size())); return issueKeys.stream() .map(new KeyToIssueFunction(unorderedIssues)::apply).filter(Objects::nonNull) .collect(Collectors.toList()); }
BulkChangeData(DbSession dbSession, Request request) { this.sendNotification = request.mandatoryParamAsBoolean(PARAM_SEND_NOTIFICATIONS); this.propertiesByActions = toPropertiesByActions(request); List<String> issueKeys = request.mandatoryParamAsStrings(PARAM_ISSUES); checkArgument(issueKeys.size() <= MAX_LIMIT, "Number of issues is limited to %s", MAX_LIMIT); List<IssueDto> allIssues = dbClient.issueDao().selectByKeys(dbSession, issueKeys); List<ComponentDto> allProjects = getComponents(dbSession, allIssues.stream().map(IssueDto::getProjectUuid).collect(MoreCollectors.toSet())); this.projectsByUuid = getAuthorizedProjects(allProjects).stream().collect(uniqueIndex(ComponentDto::uuid, identity())); this.issues = getAuthorizedIssues(allIssues); this.componentsByUuid = getComponents(dbSession, issues.stream().map(DefaultIssue::componentUuid).collect(MoreCollectors.toSet())).stream() .collect(uniqueIndex(ComponentDto::uuid, identity())); this.rulesByKey = dbClient.ruleDao().selectDefinitionByKeys(dbSession, issues.stream().map(DefaultIssue::ruleKey).collect(MoreCollectors.toSet())).stream() .collect(uniqueIndex(RuleDefinitionDto::getKey, identity())); this.availableActions = actions.stream() .filter(action -> propertiesByActions.containsKey(action.key())) .filter(action -> action.verify(getProperties(action.key()), issues, userSession)) .collect(MoreCollectors.toList()); }
private void assertThatDbHasOnly(IssueDto... expectedIssues) { try (DbSession otherSession = db.getDbClient().openSession(false)) { List<String> keys = Arrays.stream(expectedIssues).map(IssueDto::getKey).collect(Collectors.toList()); assertThat(db.getDbClient().issueDao().selectByKeys(otherSession, keys)).hasSize(expectedIssues.length); } }
private List<IssueDto> getIssueByKeys(String... issueKeys) { return db.getDbClient().issueDao().selectByKeys(db.getSession(), asList(issueKeys)); }
@Test public void selectByKeys() { // contains I1 and I2 prepareTables(); List<IssueDto> issues = underTest.selectByKeys(db.getSession(), asList("I1", "I2", "I3")); // results are not ordered, so do not use "containsExactly" assertThat(issues).extracting("key").containsOnly("I1", "I2"); }
/** * Gets a list issues by their keys. The result does NOT contain {@code null} values for issues not found, so * the size of result may be less than the number of keys. A single issue is returned * if input keys contain multiple occurrences of a key. * <p>Contrary to {@link #selectByKeys(DbSession, List)}, results are in the same order as input keys.</p> */ public List<IssueDto> selectByOrderedKeys(DbSession session, List<String> keys) { List<IssueDto> unordered = selectByKeys(session, keys); return from(keys).transform(new KeyToIssue(unordered)).filter(Predicates.notNull()).toList(); }
public Map<ShortBranchIssue, DefaultIssue> loadDefaultIssuesWithChanges(Collection<ShortBranchIssue> lightIssues) { if (lightIssues.isEmpty()) { return Collections.emptyMap(); } Map<String, ShortBranchIssue> issuesByKey = lightIssues.stream().collect(Collectors.toMap(ShortBranchIssue::getKey, i -> i)); try (DbSession session = dbClient.openSession(false)) { Map<String, List<IssueChangeDto>> changeDtoByIssueKey = dbClient.issueChangeDao() .selectByIssueKeys(session, issuesByKey.keySet()).stream().collect(groupingBy(IssueChangeDto::getIssueKey)); return dbClient.issueDao().selectByKeys(session, issuesByKey.keySet()) .stream() .map(IssueDto::toDefaultIssue) .peek(i -> ComponentIssuesLoader.setChanges(changeDtoByIssueKey, i)) .collect(toMap(i -> issuesByKey.get(i.key()), i -> i)); } }
private List<IssueDto> loadIssues(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession) { List<IssueDto> preloadedIssues = preloadedResponseData.getIssues(); Set<String> preloadedIssueKeys = preloadedIssues.stream().map(IssueDto::getKey).collect(MoreCollectors.toSet(preloadedIssues.size())); ImmutableSet<String> issueKeys = ImmutableSet.copyOf(collector.getIssueKeys()); Set<String> issueKeysToLoad = copyOf(difference(issueKeys, preloadedIssueKeys)); if (issueKeysToLoad.isEmpty()) { return issueKeys.stream() .map(new KeyToIssueFunction(preloadedIssues)::apply).filter(Objects::nonNull) .collect(Collectors.toList()); } List<IssueDto> loadedIssues = dbClient.issueDao().selectByKeys(dbSession, issueKeysToLoad); List<IssueDto> unorderedIssues = concat(preloadedIssues.stream(), loadedIssues.stream()) .collect(toList(preloadedIssues.size() + loadedIssues.size())); return issueKeys.stream() .map(new KeyToIssueFunction(unorderedIssues)::apply).filter(Objects::nonNull) .collect(Collectors.toList()); }
BulkChangeData(DbSession dbSession, Request request) { this.sendNotification = request.mandatoryParamAsBoolean(PARAM_SEND_NOTIFICATIONS); this.propertiesByActions = toPropertiesByActions(request); List<String> issueKeys = request.mandatoryParamAsStrings(PARAM_ISSUES); checkArgument(issueKeys.size() <= MAX_LIMIT, "Number of issues is limited to %s", MAX_LIMIT); List<IssueDto> allIssues = dbClient.issueDao().selectByKeys(dbSession, issueKeys); List<ComponentDto> allProjects = getComponents(dbSession, allIssues.stream().map(IssueDto::getProjectUuid).collect(MoreCollectors.toSet())); this.projectsByUuid = getAuthorizedProjects(allProjects).stream().collect(uniqueIndex(ComponentDto::uuid, identity())); this.issues = getAuthorizedIssues(allIssues); this.componentsByUuid = getComponents(dbSession, issues.stream().map(DefaultIssue::componentUuid).collect(MoreCollectors.toSet())).stream() .collect(uniqueIndex(ComponentDto::uuid, identity())); this.rulesByKey = dbClient.ruleDao().selectDefinitionByKeys(dbSession, issues.stream().map(DefaultIssue::ruleKey).collect(MoreCollectors.toSet())).stream() .collect(uniqueIndex(RuleDefinitionDto::getKey, identity())); this.availableActions = actions.stream() .filter(action -> propertiesByActions.containsKey(action.key())) .filter(action -> action.verify(getProperties(action.key()), issues, userSession)) .collect(MoreCollectors.toList()); }