private Map<String, UserDto> loadUserDtoByUuid(NewIssuesStatistics statistics) { List<Map.Entry<String, NewIssuesStatistics.Stats>> entriesWithIssuesOnLeak = statistics.getAssigneesStatistics().entrySet() .stream().filter(e -> e.getValue().hasIssuesOnLeak()).collect(toList()); List<String> assigneeUuids = entriesWithIssuesOnLeak.stream().map(Map.Entry::getKey).collect(toList()); try (DbSession dbSession = dbClient.openSession(false)) { return dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); } }
Map<String, UserDto> getUsersByUuid(DbSession dbSession, List<RuleDto> rules) { Set<String> userUuids = rules.stream().map(RuleDto::getNoteUserUuid).filter(Objects::nonNull).collect(toSet()); return dbClient.userDao().selectByUuids(dbSession, userUuids).stream().collect(uniqueIndex(UserDto::getUuid)); }
private Map<String, UserDto> getUsersByUserUuid(DbSession dbSession, List<Change> changes) { Set<String> userUuids = changes.stream() .map(Change::getUserUuid) .filter(Objects::nonNull) .collect(toSet()); return dbClient.userDao() .selectByUuids(dbSession, userUuids) .stream() .collect(uniqueIndex(UserDto::getUuid)); }
private Map<String, UserDto> usersByUuid(DbSession dbSession, List<CustomMeasureDto> customMeasures) { Set<String> userUuids = customMeasures.stream().map(CustomMeasureDto::getUserUuid).collect(MoreCollectors.toSet()); List<UserDto> users = dbClient.userDao().selectByUuids(dbSession, userUuids); return users.stream().collect(MoreCollectors.uniqueIndex(UserDto::getUuid)); }
private void setAssigneesStatistics(DbSession dbSession, NewIssuesStatistics.Stats stats) { Metric metric = Metric.ASSIGNEE; List<Map.Entry<String, MetricStatsInt>> entries = fiveBiggest(stats.getDistributedMetricStats(metric), MetricStatsInt::getOnLeak); Set<String> assigneeUuids = entries.stream().map(Map.Entry::getKey).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> userDtoByUuid = dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); int i = 1; for (Map.Entry<String, MetricStatsInt> assigneeStats : entries) { String assigneeUuid = assigneeStats.getKey(); UserDto user = userDtoByUuid.get(assigneeUuid); String name = user == null ? assigneeUuid : user.getName(); setFieldValue(metric + DOT + i + LABEL, name); setFieldValue(metric + DOT + i + COUNT, String.valueOf(assigneeStats.getValue().getOnLeak())); i++; } }
static DtoCache forQueueDtos(DbClient dbClient, DbSession dbSession, Collection<CeQueueDto> ceQueueDtos) { Map<String, ComponentDto> componentsByUuid = dbClient.componentDao().selectByUuids(dbSession, componentUuidsOfCeQueues(ceQueueDtos)) .stream() .collect(uniqueIndex(ComponentDto::uuid)); Multimap<String, CeTaskCharacteristicDto> characteristicsByTaskUuid = dbClient.ceTaskCharacteristicsDao() .selectByTaskUuids(dbSession, ceQueueDtos.stream().map(CeQueueDto::getUuid).collect(Collectors.toList())) .stream().collect(MoreCollectors.index(CeTaskCharacteristicDto::getTaskUuid)); Set<String> submitterUuids = ceQueueDtos.stream().map(CeQueueDto::getSubmitterUuid).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> usersByUuid = dbClient.userDao().selectByUuids(dbSession, submitterUuids).stream().collect(uniqueIndex(UserDto::getUuid)); return new DtoCache(componentsByUuid, buildOrganizationsByUuid(dbClient, dbSession, componentsByUuid), characteristicsByTaskUuid, usersByUuid); }
static DtoCache forActivityDtos(DbClient dbClient, DbSession dbSession, Collection<CeActivityDto> ceActivityDtos) { Map<String, ComponentDto> componentsByUuid = dbClient.componentDao().selectByUuids( dbSession, getComponentUuidsOfCeActivities(ceActivityDtos)) .stream() .collect(uniqueIndex(ComponentDto::uuid)); Multimap<String, CeTaskCharacteristicDto> characteristicsByTaskUuid = dbClient.ceTaskCharacteristicsDao() .selectByTaskUuids(dbSession, ceActivityDtos.stream().map(CeActivityDto::getUuid).collect(Collectors.toList())) .stream().collect(MoreCollectors.index(CeTaskCharacteristicDto::getTaskUuid)); Set<String> submitterUuids = ceActivityDtos.stream().map(CeActivityDto::getSubmitterUuid).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> usersByUuid = dbClient.userDao().selectByUuids(dbSession, submitterUuids).stream().collect(uniqueIndex(UserDto::getUuid)); return new DtoCache(componentsByUuid, buildOrganizationsByUuid(dbClient, dbSession, componentsByUuid), characteristicsByTaskUuid, usersByUuid); }
private void loadUsers(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession, SearchResponseData result) { Set<String> usersUuidToLoad = collector.getUserUuids(); List<UserDto> preloadedUsers = firstNonNull(preloadedResponseData.getUsers(), emptyList()); result.addUsers(preloadedUsers); preloadedUsers.forEach(userDto -> usersUuidToLoad.remove(userDto.getUuid())); result.addUsers(dbClient.userDao().selectByUuids(dbSession, usersUuidToLoad)); }
ChangeLogResults(DbSession dbSession, String issueKey) { IssueDto issue = issueFinder.getByKey(dbSession, issueKey); if (isMember(dbSession, issue)) { this.changes = dbClient.issueChangeDao().selectChangelogByIssue(dbSession, issue.getKey()); List<String> userUuids = changes.stream().filter(change -> change.userUuid() != null).map(FieldDiffs::userUuid).collect(MoreCollectors.toList()); this.users = dbClient.userDao().selectByUuids(dbSession, userUuids).stream().collect(MoreCollectors.uniqueIndex(UserDto::getUuid)); this.files = dbClient.componentDao().selectByUuids(dbSession, getFileUuids(changes)).stream().collect(MoreCollectors.uniqueIndex(ComponentDto::uuid, Function.identity())); } else { changes = ImmutableList.of(); users = ImmutableMap.of(); files = ImmutableMap.of(); } }
private BulkChangeResult executeBulkChange(DbSession dbSession, Request request) { BulkChangeData bulkChangeData = new BulkChangeData(dbSession, request); BulkChangeResult result = new BulkChangeResult(bulkChangeData.issues.size()); IssueChangeContext issueChangeContext = IssueChangeContext.createUser(new Date(system2.now()), userSession.getUuid()); List<DefaultIssue> items = bulkChangeData.issues.stream() .filter(bulkChange(issueChangeContext, bulkChangeData, result)) .collect(MoreCollectors.toList()); issueStorage.save(dbSession, items); refreshLiveMeasures(dbSession, bulkChangeData, result); Set<String> assigneeUuids = items.stream().map(DefaultIssue::assignee).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> userDtoByUuid = dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); String authorUuid = requireNonNull(userSession.getUuid(), "User uuid cannot be null"); UserDto author = dbClient.userDao().selectByUuid(dbSession, authorUuid); checkState(author != null, "User with uuid '%s' does not exist"); items.forEach(sendNotification(bulkChangeData, userDtoByUuid, author)); return result; }
private void doExecute(NotificationStatistics notificationStatistics, Component project) { long analysisDate = analysisMetadataHolder.getAnalysisDate(); Predicate<DefaultIssue> isOnLeakPredicate = i -> i.isNew() && i.creationDate().getTime() >= truncateToSeconds(analysisDate); NewIssuesStatistics newIssuesStats = new NewIssuesStatistics(isOnLeakPredicate); Map<String, UserDto> usersDtoByUuids; try (DbSession dbSession = dbClient.openSession(false)) { Iterable<DefaultIssue> iterable = issueCache::traverse; List<String> assigneeUuids = stream(iterable.spliterator(), false).map(DefaultIssue::assignee).filter(Objects::nonNull).collect(toList()); usersDtoByUuids = dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, dto -> dto)); } try (CloseableIterator<DefaultIssue> issues = issueCache.traverse()) { processIssues(newIssuesStats, issues, project, usersDtoByUuids, notificationStatistics); } if (newIssuesStats.hasIssuesOnLeak()) { sendNewIssuesNotification(newIssuesStats, project, analysisDate, notificationStatistics); sendMyNewIssuesNotification(newIssuesStats, project, analysisDate, notificationStatistics); } }
.collect(toList()); Map<String, String> userLoginsByUserUuids = dbClient.userDao().selectByUuids(dbSession, usersUuids) .stream().collect(toMap(UserDto::getUuid, UserDto::getLogin));
@Test public void selectUsersByUuids() { UserDto user1 = db.users().insertUser(); UserDto user2 = db.users().insertUser(); UserDto user3 = db.users().insertUser(user -> user.setActive(false)); assertThat((Collection<UserDto>) underTest.selectByUuids(session, asList(user1.getUuid(), user2.getUuid(), user3.getUuid()))).hasSize(3); assertThat((Collection<UserDto>) underTest.selectByUuids(session, asList(user1.getUuid(), "unknown"))).hasSize(1); assertThat((Collection<UserDto>) underTest.selectByUuids(session, Collections.emptyList())).isEmpty(); }
private void deleteOrganization(DbSession dbSession, OrganizationDto organization) { Collection<String> uuids = dbClient.organizationMemberDao().selectUserUuidsByOrganizationUuid(dbSession, organization.getUuid()); dbClient.organizationMemberDao().deleteByOrganizationUuid(dbSession, organization.getUuid()); dbClient.organizationDao().deleteByUuid(dbSession, organization.getUuid()); dbClient.userDao().cleanHomepage(dbSession, organization); dbClient.webhookDao().selectByOrganizationUuid(dbSession, organization.getUuid()) .forEach(wh -> dbClient.webhookDeliveryDao().deleteByWebhook(dbSession, wh)); dbClient.webhookDao().deleteByOrganization(dbSession, organization); List<UserDto> users = dbClient.userDao().selectByUuids(dbSession, uuids); userIndexer.commitAndIndex(dbSession, users); }
private Map<String, UserDto> loadUserDtoByUuid(NewIssuesStatistics statistics) { List<Map.Entry<String, NewIssuesStatistics.Stats>> entriesWithIssuesOnLeak = statistics.getAssigneesStatistics().entrySet() .stream().filter(e -> e.getValue().hasIssuesOnLeak()).collect(toList()); List<String> assigneeUuids = entriesWithIssuesOnLeak.stream().map(Map.Entry::getKey).collect(toList()); try (DbSession dbSession = dbClient.openSession(false)) { return dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); } }
private Map<String, UserDto> getUsersByUserUuid(DbSession dbSession, List<Change> changes) { Set<String> userUuids = changes.stream() .map(Change::getUserUuid) .filter(Objects::nonNull) .collect(toSet()); return dbClient.userDao() .selectByUuids(dbSession, userUuids) .stream() .collect(uniqueIndex(UserDto::getUuid)); }
private Map<String, UserDto> usersByUuid(DbSession dbSession, List<CustomMeasureDto> customMeasures) { Set<String> userUuids = customMeasures.stream().map(CustomMeasureDto::getUserUuid).collect(MoreCollectors.toSet()); List<UserDto> users = dbClient.userDao().selectByUuids(dbSession, userUuids); return users.stream().collect(MoreCollectors.uniqueIndex(UserDto::getUuid)); }
static DtoCache forQueueDtos(DbClient dbClient, DbSession dbSession, Collection<CeQueueDto> ceQueueDtos) { Map<String, ComponentDto> componentsByUuid = dbClient.componentDao().selectByUuids(dbSession, componentUuidsOfCeQueues(ceQueueDtos)) .stream() .collect(uniqueIndex(ComponentDto::uuid)); Multimap<String, CeTaskCharacteristicDto> characteristicsByTaskUuid = dbClient.ceTaskCharacteristicsDao() .selectByTaskUuids(dbSession, ceQueueDtos.stream().map(CeQueueDto::getUuid).collect(Collectors.toList())) .stream().collect(MoreCollectors.index(CeTaskCharacteristicDto::getTaskUuid)); Set<String> submitterUuids = ceQueueDtos.stream().map(CeQueueDto::getSubmitterUuid).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> usersByUuid = dbClient.userDao().selectByUuids(dbSession, submitterUuids).stream().collect(uniqueIndex(UserDto::getUuid)); return new DtoCache(componentsByUuid, buildOrganizationsByUuid(dbClient, dbSession, componentsByUuid), characteristicsByTaskUuid, usersByUuid); }
ChangeLogResults(DbSession dbSession, String issueKey) { IssueDto dbIssue = issueFinder.getByKey(dbSession, issueKey); this.changes = dbClient.issueChangeDao().selectChangelogByIssue(dbSession, dbIssue.getKey()); List<String> userUuids = changes.stream().filter(change -> change.userUuid() != null).map(FieldDiffs::userUuid).collect(MoreCollectors.toList()); this.users = dbClient.userDao().selectByUuids(dbSession, userUuids).stream().collect(MoreCollectors.uniqueIndex(UserDto::getUuid)); this.files = dbClient.componentDao().selectByUuids(dbSession, getFileUuids(changes)).stream().collect(MoreCollectors.uniqueIndex(ComponentDto::uuid, Function.identity())); }
private void deleteOrganization(DbSession dbSession, OrganizationDto organization) { Collection<String> uuids = dbClient.organizationMemberDao().selectUserUuidsByOrganizationUuid(dbSession, organization.getUuid()); dbClient.organizationMemberDao().deleteByOrganizationUuid(dbSession, organization.getUuid()); dbClient.organizationDao().deleteByUuid(dbSession, organization.getUuid()); dbClient.userDao().cleanHomepage(dbSession, organization); dbClient.webhookDao().selectByOrganizationUuid(dbSession, organization.getUuid()) .forEach(wh -> dbClient.webhookDeliveryDao().deleteByWebhook(dbSession, wh)); dbClient.webhookDao().deleteByOrganization(dbSession, organization); List<UserDto> users = dbClient.userDao().selectByUuids(dbSession, uuids); userIndexer.commitAndIndex(dbSession, users); }