private List<ComponentDto> getComponentsFromUuids(DbSession dbSession, Collection<String> componentUuids) { List<ComponentDto> componentDtos = dbClient.componentDao().selectByUuids(dbSession, componentUuids); if (!componentUuids.isEmpty() && componentDtos.isEmpty()) { return singletonList(UNKNOWN_COMPONENT); } return componentDtos; }
private List<ComponentDto> getComponents(DbSession dbSession, Collection<String> componentUuids) { return dbClient.componentDao().selectByUuids(dbSession, componentUuids); }
private Map<String, String> searchProjectsKeysByUuids(DbSession dbSession, List<ComponentDto> components) { Set<String> projectUuidsToSearch = components.stream() .map(ComponentDto::projectUuid) .collect(toHashSet()); List<ComponentDto> projects = dbClient.componentDao() .selectByUuids(dbSession, projectUuidsToSearch) .stream() .filter(c -> !c.qualifier().equals(Qualifiers.MODULE)) .collect(Collectors.toList()); return projects.stream().collect(toMap(ComponentDto::uuid, ComponentDto::getDbKey)); }
private Map<String, ComponentDto> searchReferenceComponentsByUuid(DbSession dbSession, List<ComponentDto> components) { List<String> referenceComponentIds = components.stream() .map(ComponentDto::getCopyResourceUuid) .filter(Objects::nonNull) .collect(toList()); if (referenceComponentIds.isEmpty()) { return emptyMap(); } return dbClient.componentDao().selectByUuids(dbSession, referenceComponentIds).stream() .collect(MoreCollectors.uniqueIndex(ComponentDto::uuid)); }
private Map<String, ComponentDto> searchReferenceComponentsById(DbSession dbSession, List<ComponentDto> components) { List<String> referenceComponentUUids = components.stream() .map(ComponentDto::getCopyResourceUuid) .filter(Objects::nonNull) .collect(MoreCollectors.toList(components.size())); if (referenceComponentUUids.isEmpty()) { return emptyMap(); } return FluentIterable.from(dbClient.componentDao().selectByUuids(dbSession, referenceComponentUUids)) .uniqueIndex(ComponentDto::uuid); }
private Map<String, ComponentDto> loadProjects(DbSession dbSession, Collection<ComponentDto> components) { Set<String> projectUuids = components.stream() .filter(c -> QUALIFIERS_FOR_WHICH_TO_RETURN_PROJECT.contains(c.qualifier())) .map(ComponentDto::projectUuid) .collect(MoreCollectors.toSet()); return dbClient.componentDao().selectByUuids(dbSession, projectUuids).stream() .collect(MoreCollectors.uniqueIndex(ComponentDto::uuid)); }
private List<ComponentDto> loadTreeOfComponents(DbSession dbSession, List<ComponentDto> touchedComponents) { Set<String> componentUuids = new HashSet<>(); for (ComponentDto component : touchedComponents) { componentUuids.add(component.uuid()); // ancestors, excluding self componentUuids.addAll(component.getUuidPathAsList()); } // Contrary to the formulas in Compute Engine, // measures do not aggregate values of descendant components. // As a consequence nodes do not need to be sorted. Formulas can be applied // on components in any order. return dbClient.componentDao().selectByUuids(dbSession, componentUuids); }
Map<String, ComponentDto> loadComponentDtos(DbSession dbSession, CeQueueDto taskDto) { Set<String> componentUuids = Stream.of(taskDto.getComponentUuid(), taskDto.getMainComponentUuid()) .filter(Objects::nonNull) .collect(MoreCollectors.toSet(2)); if (componentUuids.isEmpty()) { return emptyMap(); } return dbClient.componentDao().selectByUuids(dbSession, componentUuids) .stream() .collect(uniqueIndex(ComponentDto::uuid, 2)); }
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 loadProjects(Collector collector, DbSession dbSession, SearchResponseData result) { Collection<ComponentDto> loadedComponents = result.getComponents(); for (ComponentDto component : loadedComponents) { collector.addProjectUuid(component.projectUuid()); } Set<String> loadedProjectUuids = loadedComponents.stream().filter(cpt -> cpt.uuid().equals(cpt.projectUuid())).map(ComponentDto::uuid).collect(MoreCollectors.toSet()); Set<String> projectUuidsToLoad = copyOf(difference(collector.getProjectUuids(), loadedProjectUuids)); if (!projectUuidsToLoad.isEmpty()) { List<ComponentDto> projects = dbClient.componentDao().selectByUuids(dbSession, collector.getProjectUuids()); result.addComponents(projects); } }
/** * Return list of propertyDto by component uuid, sorted from project to lowest module */ private Multimap<String, PropertyDto> loadComponentSettings(DbSession dbSession, Optional<String> key, ComponentDto component) { List<String> componentUuids = DOT_SPLITTER.splitToList(component.moduleUuidPath()); List<ComponentDto> componentDtos = dbClient.componentDao().selectByUuids(dbSession, componentUuids); Set<Long> componentIds = componentDtos.stream().map(ComponentDto::getId).collect(Collectors.toSet()); Map<Long, String> uuidsById = componentDtos.stream().collect(Collectors.toMap(ComponentDto::getId, ComponentDto::uuid)); List<PropertyDto> properties = key.isPresent() ? dbClient.propertiesDao().selectPropertiesByKeysAndComponentIds(dbSession, Collections.singleton(key.get()), componentIds) : dbClient.propertiesDao().selectPropertiesByComponentIds(dbSession, componentIds); Multimap<String, PropertyDto> propertyDtosByUuid = TreeMultimap.create(Ordering.explicit(componentUuids), Ordering.arbitrary()); for (PropertyDto propertyDto : properties) { Long componentId = propertyDto.getResourceId(); String componentUuid = uuidsById.get(componentId); propertyDtosByUuid.put(componentUuid, propertyDto); } return propertyDtosByUuid; }
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 void loadComponents(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession, SearchResponseData result) { Collection<ComponentDto> preloadedComponents = preloadedResponseData.getComponents(); Set<String> preloadedComponentUuids = preloadedComponents.stream().map(ComponentDto::uuid).collect(MoreCollectors.toSet(preloadedComponents.size())); Set<String> componentUuidsToLoad = copyOf(difference(collector.getComponentUuids(), preloadedComponentUuids)); result.addComponents(preloadedComponents); if (!componentUuidsToLoad.isEmpty()) { result.addComponents(dbClient.componentDao().selectByUuids(dbSession, componentUuidsToLoad)); } // always load components and projects, because some issue fields still relate to component ids/keys. // They should be dropped but are kept for backward-compatibility (see SearchResponseFormat) result.addComponents(dbClient.componentDao().selectSubProjectsByComponentUuids(dbSession, collector.getComponentUuids())); loadProjects(collector, dbSession, result); }
/** * List of ancestors, ordered from root to parent. The list is empty * if the component is a tree root. Disabled components are excluded by design * as tree represents the more recent analysis. */ public List<ComponentDto> selectAncestors(DbSession dbSession, ComponentDto component) { if (component.isRoot()) { return Collections.emptyList(); } List<String> ancestorUuids = component.getUuidPathAsList(); List<ComponentDto> ancestors = selectByUuids(dbSession, ancestorUuids); return Ordering.explicit(ancestorUuids).onResultOf(ComponentDto::uuid).immutableSortedCopy(ancestors); }
/** * Return list of settings by component uuid, sorted from project to lowest module */ private Multimap<String, Setting> loadComponentSettings(DbSession dbSession, Set<String> keys, ComponentDto component) { List<String> componentUuids = DOT_SPLITTER.splitToList(component.moduleUuidPath()); List<ComponentDto> componentDtos = dbClient.componentDao().selectByUuids(dbSession, componentUuids); Set<Long> componentIds = componentDtos.stream().map(ComponentDto::getId).collect(Collectors.toSet()); Map<Long, String> uuidsById = componentDtos.stream().collect(Collectors.toMap(ComponentDto::getId, ComponentDto::uuid)); List<PropertyDto> properties = dbClient.propertiesDao().selectPropertiesByKeysAndComponentIds(dbSession, keys, componentIds); List<PropertyDto> propertySets = dbClient.propertiesDao().selectPropertiesByKeysAndComponentIds(dbSession, getPropertySetKeys(properties), componentIds); Multimap<String, Setting> settingsByUuid = TreeMultimap.create(Ordering.explicit(componentUuids), Ordering.arbitrary()); for (PropertyDto propertyDto : properties) { Long componentId = propertyDto.getResourceId(); String componentUuid = uuidsById.get(componentId); String propertyKey = propertyDto.getKey(); settingsByUuid.put(componentUuid, Setting.createFromDto(propertyDto, getPropertySets(propertyKey, propertySets, componentId), propertyDefinitions.get(propertyKey))); } return settingsByUuid; }
@Test public void get_by_uuids() { ComponentDto project1 = db.components().insertPrivateProject(); ComponentDto project2 = db.components().insertPrivateProject(); List<ComponentDto> results = underTest.selectByUuids(dbSession, asList(project1.uuid(), project2.uuid())); assertThat(results) .extracting(ComponentDto::uuid, ComponentDto::getDbKey) .containsExactlyInAnyOrder( tuple(project1.uuid(), project1.getDbKey()), tuple(project2.uuid(), project2.getDbKey())); assertThat(underTest.selectByUuids(dbSession, singletonList("unknown"))).isEmpty(); }
private SearchResults searchData(DbSession dbSession, SearchProjectsRequest request, @Nullable OrganizationDto organization) { Set<String> favoriteProjectUuids = loadFavoriteProjectUuids(dbSession); List<Criterion> criteria = FilterParser.parse(firstNonNull(request.getFilter(), "")); ProjectMeasuresQuery query = newProjectMeasuresQuery(criteria, hasFavoriteFilter(criteria) ? favoriteProjectUuids : null) .setSort(request.getSort()) .setAsc(request.getAsc()); Optional.ofNullable(organization) .map(OrganizationDto::getUuid) .ifPresent(query::setOrganizationUuid); ProjectMeasuresQueryValidator.validate(query); SearchIdResult<String> esResults = index.search(query, new SearchOptions() .addFacets(request.getFacets()) .setPage(request.getPage(), request.getPageSize())); List<String> projectUuids = esResults.getIds(); Ordering<ComponentDto> ordering = Ordering.explicit(projectUuids).onResultOf(ComponentDto::uuid); List<ComponentDto> projects = ordering.immutableSortedCopy(dbClient.componentDao().selectByUuids(dbSession, projectUuids)); Map<String, SnapshotDto> analysisByProjectUuid = getSnapshots(dbSession, request, projectUuids); return new SearchResults(projects, favoriteProjectUuids, esResults, analysisByProjectUuid, query); }
@Test public void get_by_uuids_on_removed_components() { ComponentDto project1 = db.components().insertPrivateProject(); ComponentDto project2 = db.components().insertPrivateProject(p -> p.setEnabled(false)); List<ComponentDto> results = underTest.selectByUuids(dbSession, asList(project1.uuid(), project2.uuid())); assertThat(results) .extracting(ComponentDto::getDbKey, ComponentDto::isEnabled) .containsExactlyInAnyOrder( tuple(project1.getDbKey(), true), tuple(project2.getDbKey(), false)); }
private SearchWsResponse doHandle(SearchRequest request) { try (DbSession dbSession = dbClient.openSession(false)) { OrganizationDto organization = getOrganization(dbSession, request); ComponentQuery esQuery = buildEsQuery(organization, request); SearchIdResult<String> results = componentIndex.search(esQuery, new SearchOptions().setPage(request.getPage(), request.getPageSize())); List<ComponentDto> components = dbClient.componentDao().selectByUuids(dbSession, results.getIds()); Map<String, String> projectKeysByUuids = searchProjectsKeysByUuids(dbSession, components); return buildResponse(components, organization, projectKeysByUuids, Paging.forPageIndex(request.getPage()).withPageSize(request.getPageSize()).andTotal((int) results.getTotal())); } }