private ComponentDto getComponent(DbSession dbSession, DefaultIssue issue, @Nullable String componentUuid) { String issueKey = issue.key(); checkState(componentUuid != null, "Issue '%s' has no component", issueKey); ComponentDto component = dbClient.componentDao().selectByUuid(dbSession, componentUuid).orElse(null); checkState(component != null, "Component uuid '%s' for issue key '%s' cannot be found", componentUuid, issueKey); return component; }
private Optional<ComponentDto> getProjectByKeyOrId(DbSession dbSession, String component) { try { long componentId = Long.parseLong(component); return ofNullable(dbClient.componentDao().selectById(dbSession, componentId).orElse(null)); } catch (NumberFormatException e) { return ofNullable(dbClient.componentDao().selectByKey(dbSession, component).orElse(null)); } }
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; }
@CheckForNull private ComponentDto loadComponent(DbSession session, String componentKey, @Nullable String branch, @Nullable String pullRequest) { if (branch != null) { return componentDao.selectByKeyAndBranch(session, componentKey, branch).orElse(null); } else if (pullRequest != null) { return componentDao.selectByKeyAndPullRequest(session, componentKey, pullRequest).orElse(null); } else { return componentDao.selectByKey(session, componentKey).orElse(null); } }
/** * On MySQL, as PROJECTS.KEE is not unique, if the same project is provisioned multiple times, then it will be duplicated in the database. * So, after creating a project, we commit, and we search in the db if their are some duplications and we remove them. * * SONAR-6332 */ private void removeDuplicatedProjects(DbSession session, String projectKey) { List<ComponentDto> duplicated = dbClient.componentDao().selectComponentsHavingSameKeyOrderedById(session, projectKey); for (int i = 1; i < duplicated.size(); i++) { dbClient.componentDao().delete(session, duplicated.get(i).getId()); } }
ComponentDto file = ComponentTesting.newFileDto(project, directory, "DEFG").setPath("src/main/java/dir/Foo.java").setName("Foo.java") .setDbKey("PROJECT_KEY:src/main/java/dir/Foo.java"); dbClient.componentDao().insert(db.getSession(), directory, file); db.getSession().commit(); dbClient.componentDao().applyBChangesForRootComponentUuid(db.getSession(), project.uuid()); db.commit(); ComponentDto directoryReloaded = dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir").get(); assertThat(directoryReloaded).isNotNull(); assertThat(directoryReloaded.uuid()).isEqualTo(directory.uuid()); assertThat(directoryReloaded.getRootUuid()).isEqualTo(project.uuid()); ComponentDto fileReloaded = dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir/Foo.java").get(); assertThat(fileReloaded).isNotNull(); assertThat(fileReloaded.uuid()).isEqualTo(file.uuid());
private ComponentDto insertProject(ComponentDto project) { dbClient.componentDao().insert(dbSession, project); dbSession.commit(); return project; } }
@Test public void update_module_to_directory_change_scope() { ComponentDto project = prepareProject(); ComponentDto module = ComponentTesting.newModuleDto(project).setUuid("CDEF").setDbKey("MODULE_KEY").setPath("module"); dbClient.componentDao().insert(db.getSession(), module); db.getSession().commit(); assertThat(dbClient.componentDao().selectByUuid(db.getSession(), "CDEF").get().scope()).isEqualTo("PRJ"); treeRootHolder.setRoot( asTreeRoot(project) .addChildren( builder(DIRECTORY, 2).setUuid("CDEF").setKey(PROJECT_KEY + ":module") .setName("module") .addChildren( builder(FILE, 3).setUuid("HIJK").setKey(PROJECT_KEY + ":module/FooTest.java") .setName("module/FooTest.java") .setShortName("FooTest.java") .setFileAttributes(new FileAttributes(false, null, 1)) .build()) .build()) .build()); underTest.execute(new TestComputationStepContext()); // commit the functional transaction dbClient.componentDao().applyBChangesForRootComponentUuid(db.getSession(), project.uuid()); db.commit(); assertThat(dbClient.componentDao().selectByUuid(db.getSession(), "CDEF").get().scope()).isEqualTo("DIR"); }
private Optional<ComponentDto> loadBaseComponent(String rawComponentKey) { ComponentDto baseComponent = baseModulesByKey.get(rawComponentKey); if (baseComponent == null) { // Load component from key to be able to detect issue (try to analyze a module, etc.) return componentDao.selectByKey(session, rawComponentKey); } return Optional.of(baseComponent); } }
@CheckForNull private ComponentDto retrieveParentModuleIfNotCurrentComponent(ComponentDto componentDto, DbSession session) { final String moduleUuid = componentDto.moduleUuid(); if (moduleUuid == null || componentDto.uuid().equals(moduleUuid)) { return null; } return dbClient.componentDao().selectOrFailByUuid(session, moduleUuid); }
private List<ComponentDto> searchComponents(DbSession dbSession, ComponentTreeQuery componentTreeQuery) { Collection<String> qualifiers = componentTreeQuery.getQualifiers(); if (qualifiers != null && qualifiers.isEmpty()) { return Collections.emptyList(); } return dbClient.componentDao().selectDescendants(dbSession, componentTreeQuery); }
@Test public void delete() { ComponentDto project1 = db.components().insertPrivateProject(db.getDefaultOrganization(), (t) -> t.setDbKey("PROJECT_1")); db.components().insertPrivateProject(db.getDefaultOrganization(), (t) -> t.setDbKey("PROJECT_2")); underTest.delete(dbSession, project1.getId()); dbSession.commit(); assertThat(underTest.selectByKey(dbSession, "PROJECT_1")).isEmpty(); assertThat(underTest.selectByKey(dbSession, "PROJECT_2")).isPresent(); }
/** * Returns a mutable map of the components currently persisted in database for the project, including * disabled components. */ private Map<String, ComponentDto> indexExistingDtosByUuids(DbSession session) { return dbClient.componentDao().selectAllComponentsFromProjectKey(session, treeRootHolder.getRoot().getDbKey()) .stream() .collect(Collectors.toMap(ComponentDto::uuid, Function.identity())); }
@Test public void delete_doc_from_index_when_project_is_deleted() { ComponentDto project = db.components().insertPrivateProject(); indexProject(project, PROJECT_CREATION); assertThatIndexContainsOnly(project); db.getDbClient().componentDao().delete(db.getSession(), project.getId()); IndexingResult result = indexProject(project, PROJECT_DELETION); assertThat(es.countDocuments(INDEX_TYPE_PROJECT_MEASURES)).isEqualTo(0); assertThat(result.getTotal()).isEqualTo(1L); assertThat(result.getSuccess()).isEqualTo(1L); }
private Optional<ComponentDto> selectProjectById(DbSession dbSession, @Nullable String projectId) { if (projectId == null) { return Optional.empty(); } try { long dbId = Long.parseLong(projectId); return Optional.ofNullable(dbClient.componentDao().selectById(dbSession, dbId).orElse(null)); } catch (NumberFormatException e) { return Optional.empty(); } }
@Override public void execute(ComputationStep.Context context) { try (DbSession dbSession = dbClient.openSession(false)) { Component project = treeRootHolder.getRoot(); dbClient.snapshotDao().switchIsLastFlagAndSetProcessedStatus(dbSession, project.getUuid(), analysisMetadataHolder.getUuid()); dbClient.componentDao().applyBChangesForRootComponentUuid(dbSession, project.getUuid()); dbSession.commit(); } }
private void updateDb(ComponentDto component) { ComponentUpdateDto updateComponent = ComponentUpdateDto.copyFrom(component); updateComponent.setBChanged(true); dbClient.componentDao().update(dbSession, updateComponent); dbClient.componentDao().applyBChangesForRootComponentUuid(dbSession, component.getRootUuid()); dbSession.commit(); }
.setDbKey("PROJECT_KEY:src/main/java/dir/Foo.java") .setEnabled(false); dbClient.componentDao().insert(db.getSession(), removedDirectory, removedFile); db.getSession().commit(); assertThat(dbClient.componentDao().selectByKey(db.getSession(), project.getDbKey()).get().getId()).isEqualTo(project.getId()); assertThat(dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir").get().getId()).isEqualTo(removedDirectory.getId()); assertThat(dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir/Foo.java").get().getId()).isEqualTo(removedFile.getId()); assertExistButDisabled(removedDirectory.getDbKey(), removedFile.getDbKey()); dbClient.componentDao().applyBChangesForRootComponentUuid(db.getSession(), project.uuid()); ComponentDto projectReloaded = dbClient.componentDao().selectByKey(db.getSession(), project.getDbKey()).get(); assertThat(projectReloaded.getId()).isEqualTo(project.getId()); assertThat(projectReloaded.uuid()).isEqualTo(project.uuid()); assertThat(projectReloaded.isEnabled()).isTrue(); ComponentDto directoryReloaded = dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir").get(); assertThat(directoryReloaded.getId()).isEqualTo(removedDirectory.getId()); assertThat(directoryReloaded.uuid()).isEqualTo(removedDirectory.uuid()); assertThat(directoryReloaded.isEnabled()).isTrue(); ComponentDto fileReloaded = dbClient.componentDao().selectByKey(db.getSession(), "PROJECT_KEY:src/main/java/dir/Foo.java").get(); assertThat(fileReloaded.getId()).isEqualTo(fileReloaded.getId()); assertThat(fileReloaded.uuid()).isEqualTo(removedFile.uuid());
private ComponentDto insertComponent(ComponentDto component) { dbClient.componentDao().insert(session, component); session.commit(); return component; } }
public ComponentDto selectOrFailByKey(DbSession session, String key) { Optional<ComponentDto> component = selectByKey(session, key); if (!component.isPresent()) { throw new RowNotFoundException(String.format("Component key '%s' not found", key)); } return component.get(); }