/** * 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; }
public IssueDto setComponent(ComponentDto component) { this.componentKey = component.getDbKey(); this.componentUuid = component.uuid(); this.moduleUuid = component.moduleUuid(); this.moduleUuidPath = component.moduleUuidPath(); this.filePath = component.path(); return this; }
public List<IssueDto> selectNonClosedByModuleOrProjectExcludingExternalsAndSecurityHotspots(DbSession dbSession, ComponentDto module) { String likeModuleUuidPath = buildLikeValue(module.moduleUuidPath(), WildcardPosition.AFTER); return mapper(dbSession).selectNonClosedByModuleOrProject(module.projectUuid(), likeModuleUuidPath); }
/** * 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; }
private static Optional<ComponentUpdateDto> compareForUpdate(ComponentDto existing, ComponentDto target) { boolean hasDifferences = !StringUtils.equals(existing.getCopyResourceUuid(), target.getCopyResourceUuid()) || !StringUtils.equals(existing.description(), target.description()) || !StringUtils.equals(existing.getDbKey(), target.getDbKey()) || !existing.isEnabled() || !StringUtils.equals(existing.getUuidPath(), target.getUuidPath()) || !StringUtils.equals(existing.language(), target.language()) || !StringUtils.equals(existing.longName(), target.longName()) || !StringUtils.equals(existing.moduleUuid(), target.moduleUuid()) || !StringUtils.equals(existing.moduleUuidPath(), target.moduleUuidPath()) || !StringUtils.equals(existing.name(), target.name()) || !StringUtils.equals(existing.path(), target.path()) || !StringUtils.equals(existing.scope(), target.scope()) || !StringUtils.equals(existing.qualifier(), target.qualifier()); ComponentUpdateDto update = null; if (hasDifferences) { update = ComponentUpdateDto .copyFrom(target) .setBChanged(true); } return ofNullable(update); }
private void assertDtoIsProjectView1(ComponentDto pv1Dto, ComponentDto viewDto, ComponentDto parentViewDto, ComponentDto project) { assertThat(pv1Dto.getOrganizationUuid()).isEqualTo(ORGANIZATION_UUID); assertThat(pv1Dto.name()).isEqualTo(PROJECT_VIEW_1_NAME); assertThat(pv1Dto.longName()).isEqualTo(PROJECT_VIEW_1_NAME); assertThat(pv1Dto.description()).isNull(); assertThat(pv1Dto.path()).isNull(); assertThat(pv1Dto.uuid()).isEqualTo(PROJECT_VIEW_1_UUID); assertThat(pv1Dto.projectUuid()).isEqualTo(viewDto.uuid()); assertThat(pv1Dto.getRootUuid()).isEqualTo(viewDto.uuid()); assertThat(pv1Dto.moduleUuid()).isEqualTo(parentViewDto.uuid()); assertThat(pv1Dto.moduleUuidPath()).isEqualTo(parentViewDto.moduleUuidPath() + pv1Dto.uuid() + "."); assertThat(pv1Dto.qualifier()).isEqualTo(Qualifiers.PROJECT); assertThat(pv1Dto.scope()).isEqualTo(Scopes.FILE); assertThat(pv1Dto.getCopyResourceUuid()).isEqualTo(project.uuid()); assertThat(pv1Dto.getCreatedAt()).isEqualTo(now); }
/** * Assertions to verify the DTO created from {@link #createViewBuilder(ViewAttributes.Type)} ()} */ private void assertDtoIsView(ComponentDto dto) { assertThat(dto.getOrganizationUuid()).isEqualTo(ORGANIZATION_UUID); assertThat(dto.name()).isEqualTo(VIEW_NAME); assertThat(dto.longName()).isEqualTo(VIEW_NAME); assertThat(dto.description()).isEqualTo(VIEW_DESCRIPTION); assertThat(dto.path()).isNull(); assertThat(dto.uuid()).isEqualTo(VIEW_UUID); assertThat(dto.projectUuid()).isEqualTo(VIEW_UUID); assertThat(dto.getRootUuid()).isEqualTo(VIEW_UUID); assertThat(dto.moduleUuid()).isNull(); assertThat(dto.moduleUuidPath()).isEqualTo("." + dto.uuid() + "."); assertThat(dto.qualifier()).isEqualTo(Qualifiers.VIEW); assertThat(dto.scope()).isEqualTo(Scopes.PROJECT); assertThat(dto.getCopyResourceUuid()).isNull(); assertThat(dto.getCreatedAt()).isEqualTo(now); }
/** * Assertions to verify the DTO created from {@link #createProjectView1Builder(ComponentDto, Long)} */ private void assertDtoIsSubView1(ComponentDto viewDto, ComponentDto sv1Dto) { assertThat(sv1Dto.getOrganizationUuid()).isEqualTo(ORGANIZATION_UUID); assertThat(sv1Dto.name()).isEqualTo(SUBVIEW_1_NAME); assertThat(sv1Dto.longName()).isEqualTo(SUBVIEW_1_NAME); assertThat(sv1Dto.description()).isEqualTo(SUBVIEW_1_DESCRIPTION); assertThat(sv1Dto.path()).isNull(); assertThat(sv1Dto.uuid()).isEqualTo(SUBVIEW_1_UUID); assertThat(sv1Dto.projectUuid()).isEqualTo(viewDto.uuid()); assertThat(sv1Dto.getRootUuid()).isEqualTo(viewDto.uuid()); assertThat(sv1Dto.moduleUuid()).isEqualTo(viewDto.uuid()); assertThat(sv1Dto.moduleUuidPath()).isEqualTo(viewDto.moduleUuidPath() + sv1Dto.uuid() + "."); assertThat(sv1Dto.qualifier()).isEqualTo(Qualifiers.SUBVIEW); assertThat(sv1Dto.scope()).isEqualTo(Scopes.PROJECT); assertThat(sv1Dto.getCopyResourceUuid()).isNull(); assertThat(sv1Dto.getCreatedAt()).isEqualTo(now); }
/** * Assertions to verify the DTO created from {@link #createViewBuilder(ViewAttributes.Type)} ()} */ private void assertDtoIsApplication(ComponentDto dto) { assertThat(dto.getOrganizationUuid()).isEqualTo(ORGANIZATION_UUID); assertThat(dto.name()).isEqualTo(VIEW_NAME); assertThat(dto.longName()).isEqualTo(VIEW_NAME); assertThat(dto.description()).isEqualTo(VIEW_DESCRIPTION); assertThat(dto.path()).isNull(); assertThat(dto.uuid()).isEqualTo(VIEW_UUID); assertThat(dto.projectUuid()).isEqualTo(VIEW_UUID); assertThat(dto.getRootUuid()).isEqualTo(VIEW_UUID); assertThat(dto.moduleUuid()).isNull(); assertThat(dto.moduleUuidPath()).isEqualTo("." + dto.uuid() + "."); assertThat(dto.qualifier()).isEqualTo(Qualifiers.APP); assertThat(dto.scope()).isEqualTo(Scopes.PROJECT); assertThat(dto.getCopyResourceUuid()).isNull(); assertThat(dto.getCreatedAt()).isEqualTo(now); }
/** * Applies to a node of type either DIRECTORY or FILE */ private static void setParentModuleProperties(ComponentDto componentDto, PathAwareVisitor.Path<ComponentDtoHolder> path) { componentDto.setProjectUuid(path.root().getDto().uuid()); ComponentDto parentModule = from(path.getCurrentPath()) .filter(ParentModulePathElement.INSTANCE) .first() .get() .getElement().getDto(); componentDto.setUuidPath(formatUuidPathFromParent(path.parent().getDto())); componentDto.setRootUuid(parentModule.uuid()); componentDto.setModuleUuid(parentModule.uuid()); componentDto.setModuleUuidPath(parentModule.moduleUuidPath()); }
@Test public void get_by_uuid() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization, p -> p .setDbKey("org.struts:struts") .setName("Struts") .setLongName("Apache Struts")); ComponentDto anotherProject = db.components().insertPrivateProject(organization); ComponentDto result = underTest.selectByUuid(dbSession, project.uuid()).get(); assertThat(result).isNotNull(); assertThat(result.getOrganizationUuid()).isEqualTo(organization.getUuid()); assertThat(result.uuid()).isEqualTo(project.uuid()); assertThat(result.getUuidPath()).isEqualTo("."); assertThat(result.moduleUuid()).isNull(); assertThat(result.moduleUuidPath()).isEqualTo("." + project.uuid() + "."); assertThat(result.projectUuid()).isEqualTo(project.uuid()); assertThat(result.getDbKey()).isEqualTo("org.struts:struts"); assertThat(result.path()).isNull(); assertThat(result.name()).isEqualTo("Struts"); assertThat(result.longName()).isEqualTo("Apache Struts"); assertThat(result.qualifier()).isEqualTo("TRK"); assertThat(result.scope()).isEqualTo("PRJ"); assertThat(result.language()).isNull(); assertThat(result.getCopyResourceUuid()).isNull(); assertThat(result.isPrivate()).isTrue(); assertThat(underTest.selectByUuid(dbSession, "UNKNOWN")).isEmpty(); }
@Test public void get_by_uuid_on_technical_project_copy() { ComponentDto view = db.components().insertView(); ComponentDto project = db.components().insertPublicProject(p -> p .setDbKey("org.struts:struts") .setName("Struts") .setLongName("Apache Struts")); ComponentDto projectCopy = db.components().insertComponent(newProjectCopy(project, view)); ComponentDto anotherProject = db.components().insertPrivateProject(); ComponentDto anotherProjectCopy = db.components().insertComponent(newProjectCopy(anotherProject, view)); ComponentDto result = underTest.selectByUuid(dbSession, projectCopy.uuid()).get(); assertThat(result.uuid()).isEqualTo(projectCopy.uuid()); assertThat(result.moduleUuid()).isEqualTo(view.uuid()); assertThat(result.moduleUuidPath()).isEqualTo("." + view.uuid() + "."); assertThat(result.projectUuid()).isEqualTo(view.uuid()); assertThat(result.getDbKey()).isEqualTo(view.getDbKey() + project.getDbKey()); assertThat(result.path()).isNull(); assertThat(result.name()).isEqualTo("Struts"); assertThat(result.longName()).isEqualTo("Apache Struts"); assertThat(result.qualifier()).isEqualTo("TRK"); assertThat(result.scope()).isEqualTo("FIL"); assertThat(result.language()).isNull(); assertThat(result.getCopyResourceUuid()).isEqualTo(project.uuid()); assertThat(result.isPrivate()).isFalse(); }
assertThat(loaded.projectUuid()).isEqualTo(loaded.uuid()); assertThat(loaded.moduleUuid()).isNull(); assertThat(loaded.moduleUuidPath()).isEqualTo("." + loaded.uuid() + "."); assertThat(loaded.isPrivate()).isEqualTo(project.isPrivate()); assertThat(loaded.getCreatedAt()).isNotNull();
/** * Applies to a node of type either MODULE, SUBVIEW, PROJECT_VIEW */ private void setRootAndParentModule(ComponentDto res, PathAwareVisitor.Path<ComponentDtoHolder> path) { ComponentDto rootDto = path.root().getDto(); res.setRootUuid(rootDto.uuid()); res.setProjectUuid(rootDto.uuid()); ComponentDto parentModule = path.parent().getDto(); res.setUuidPath(formatUuidPathFromParent(parentModule)); res.setModuleUuid(parentModule.uuid()); res.setModuleUuidPath(parentModule.moduleUuidPath() + res.uuid() + UUID_PATH_SEPARATOR); } }
@Test public void migrate_project_with_modules() { ComponentDto project = db.components().insertPrivateProject(dto -> dto.setDbKey("project")); ComponentDto module1 = db.components().insertComponent(ComponentTesting.newModuleDto(project) .setDbKey("project:module1")); ComponentDto module2 = db.components().insertComponent(ComponentTesting.newModuleDto(module1) .setDbKey("project:module1:module2")); ComponentDto file1 = db.components().insertComponent(ComponentTesting.newFileDto(project) .setDbKey("project:file1") .setPath("file1_path")); ComponentDto file2 = db.components().insertComponent(ComponentTesting.newFileDto(module2) .setDbKey("project:module1:module2:file2") .setPath("file2_path")); assertThat(file2.moduleUuidPath()).isEqualTo("." + project.uuid() + "." + module1.uuid() + "." + module2.uuid() + "."); Map<String, String> modulesRelativePaths = new HashMap<>(); modulesRelativePaths.put("project:module1", "module1_path"); modulesRelativePaths.put("project:module1:module2", "module1_path/module2_path"); ComponentUuidFactoryWithMigration underTest = new ComponentUuidFactoryWithMigration(db.getDbClient(), db.getSession(), project.getDbKey(), pathToKey, modulesRelativePaths); // migrated files assertThat(underTest.getOrCreateForKey("project:file1_path")).isEqualTo(file1.uuid()); assertThat(underTest.getOrCreateForKey("project:module1_path/module2_path/file2_path")).isEqualTo(file2.uuid()); // project remains the same assertThat(underTest.getOrCreateForKey(project.getDbKey())).isEqualTo(project.uuid()); }
@Test public void migrate_branch_with_modules() { pathToKey = path -> path != null ? "project:" + path + ":BRANCH:branch1" : "project:BRANCH:branch1"; ComponentDto project = db.components().insertPrivateProject(dto -> dto.setDbKey("project:BRANCH:branch1")); ComponentDto module1 = db.components().insertComponent(ComponentTesting.newModuleDto(project) .setDbKey("project:module1:BRANCH:branch1")); ComponentDto module2 = db.components().insertComponent(ComponentTesting.newModuleDto(module1) .setDbKey("project:module1:module2:BRANCH:branch1")); ComponentDto file1 = db.components().insertComponent(ComponentTesting.newFileDto(project) .setDbKey("project:file1:BRANCH:branch1") .setPath("file1_path")); ComponentDto file2 = db.components().insertComponent(ComponentTesting.newFileDto(module2) .setDbKey("project:module1:module2:file2:BRANCH:branch1") .setPath("file2_path")); assertThat(file2.moduleUuidPath()).isEqualTo("." + project.uuid() + "." + module1.uuid() + "." + module2.uuid() + "."); Map<String, String> modulesRelativePaths = new HashMap<>(); modulesRelativePaths.put("project:module1", "module1_path"); modulesRelativePaths.put("project:module1:module2", "module1_path/module2_path"); ComponentUuidFactoryWithMigration underTest = new ComponentUuidFactoryWithMigration(db.getDbClient(), db.getSession(), project.getDbKey(), pathToKey, modulesRelativePaths); // migrated files assertThat(underTest.getOrCreateForKey("project:file1_path:BRANCH:branch1")).isEqualTo(file1.uuid()); assertThat(underTest.getOrCreateForKey("project:module1_path/module2_path/file2_path:BRANCH:branch1")).isEqualTo(file2.uuid()); // project remains the same assertThat(underTest.getOrCreateForKey(project.getDbKey())).isEqualTo(project.uuid()); }
public static ComponentDto newModuleDto(String uuid, ComponentDto parentModuleOrProject) { return newChildComponent(uuid, parentModuleOrProject, parentModuleOrProject) .setModuleUuidPath(parentModuleOrProject.moduleUuidPath() + uuid + UUID_PATH_SEPARATOR) .setDbKey(generateKey("MODULE_KEY_" + uuid, parentModuleOrProject)) .setName("NAME_" + uuid) .setLongName("LONG_NAME_" + uuid) .setPath("module") .setScope(Scopes.PROJECT) .setQualifier(Qualifiers.MODULE) .setLanguage(null); }
public static IssueDoc newDoc(String key, ComponentDto componentDto) { String mainBranchProjectUuid = componentDto.getMainBranchProjectUuid(); return newDoc() .setKey(key) .setBranchUuid(componentDto.projectUuid()) .setComponentUuid(componentDto.uuid()) .setModuleUuid(!componentDto.scope().equals(Scopes.PROJECT) ? componentDto.moduleUuid() : componentDto.uuid()) .setModuleUuidPath(componentDto.moduleUuidPath()) .setProjectUuid(mainBranchProjectUuid == null ? componentDto.projectUuid() : mainBranchProjectUuid) .setOrganizationUuid(componentDto.getOrganizationUuid()) // File path make no sens on modules and projects .setFilePath(!componentDto.scope().equals(Scopes.PROJECT) ? componentDto.path() : null) .setIsMainBranch(mainBranchProjectUuid == null); }
public static ComponentDto newChildComponent(String uuid, ComponentDto moduleOrProject, ComponentDto parent) { checkArgument(moduleOrProject.isPrivate() == parent.isPrivate(), "private flag inconsistent between moduleOrProject (%s) and parent (%s)", moduleOrProject.isPrivate(), parent.isPrivate()); return new ComponentDto() .setOrganizationUuid(parent.getOrganizationUuid()) .setUuid(uuid) .setUuidPath(formatUuidPathFromParent(parent)) .setProjectUuid(moduleOrProject.projectUuid()) .setRootUuid(moduleOrProject.uuid()) .setModuleUuid(moduleOrProject.uuid()) .setModuleUuidPath(moduleOrProject.moduleUuidPath()) .setMainBranchProjectUuid(moduleOrProject.getMainBranchProjectUuid()) .setCreatedAt(new Date()) .setEnabled(true) .setPrivate(moduleOrProject.isPrivate()); }
/** * Copy the A-fields to B-fields. The field bChanged is kept to false. */ public static ComponentUpdateDto copyFrom(ComponentDto from) { return new ComponentUpdateDto() .setUuid(from.uuid()) .setBChanged(false) .setBKey(from.getDbKey()) .setBCopyComponentUuid(from.getCopyResourceUuid()) .setBDescription(from.description()) .setBEnabled(from.isEnabled()) .setBUuidPath(from.getUuidPath()) .setBLanguage(from.language()) .setBLongName(from.longName()) .setBModuleUuid(from.moduleUuid()) .setBModuleUuidPath(from.moduleUuidPath()) .setBName(from.name()) .setBPath(from.path()) // We don't have a b_scope. The applyBChangesForRootComponentUuid query is using a case ... when to infer scope from the qualifier .setBQualifier(from.qualifier()); } }