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)); }
/** * @throws IllegalArgumentException if specified {@link ComponentDto} is not a project. */ private static void checkScopeAndQualifier(ComponentDto projectDto) { String scope = projectDto.scope(); String qualifier = projectDto.qualifier(); checkArgument( scope.equals(Scopes.PROJECT) && qualifier.equals(Qualifiers.PROJECT), "Component %s must be a project (scope=%s, qualifier=%s)", projectDto.uuid(), scope, qualifier); }
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)); }
static ComponentDto checkProject(ComponentDto component) { checkRequest(component.scope().equals(Scopes.PROJECT) && component.qualifier().equals(Qualifiers.PROJECT), format("Component '%s' must be a project.", component.getKey())); return component; }
private ComponentDto getProjectOrApplication(DbSession dbSession, SnapshotDto analysis) { ComponentDto project = dbClient.componentDao().selectByUuid(dbSession, analysis.getComponentUuid()).orElse(null); checkState(project != null, "Project of analysis '%s' is not found", analysis.getUuid()); checkArgument(ALLOWED_QUALIFIERS.contains(project.qualifier()) && Scopes.PROJECT.equals(project.scope()), "An event must be created on a project or an application"); return project; }
private ComponentDto checkIsProject(ComponentDto component) { Set<String> rootQualifiers = getRootQualifiers(resourceTypes); checkRequest(component.scope().equals(Scopes.PROJECT) && rootQualifiers.contains(component.qualifier()), format( "Component '%s' (id: %s) must be a project%s.", component.getDbKey(), component.uuid(), rootQualifiers.contains(Qualifiers.VIEW) ? " or a view" : "")); return component; }
private Optional<ComponentDto> searchProject(DbSession dbSession, RemoveRequest request) { Optional<ComponentDto> project = request.getProject() == null ? empty() : Optional.of(componentFinder.getByKey(dbSession, request.getProject())); project.ifPresent(p -> checkRequest(Qualifiers.PROJECT.equals(p.qualifier()) && Scopes.PROJECT.equals(p.scope()), "Component '%s' must be a project", request.getProject())); return project; }
private Optional<ComponentDto> searchProject(DbSession dbSession, AddRequest request) { Optional<ComponentDto> project = request.getProject() == null ? empty() : Optional.of(componentFinder.getByKey(dbSession, request.getProject())); project.ifPresent(p -> checkRequest(Qualifiers.PROJECT.equals(p.qualifier()) && Scopes.PROJECT.equals(p.scope()), "Component '%s' must be a project", request.getProject())); project.ifPresent(p -> userSession.checkComponentPermission(UserRole.USER, p)); return project; }
private void checkComponentType(DbSession dbSession, ComponentDto project) { Optional<BranchDto> branch = dbClient.branchDao().selectByUuid(dbSession, project.uuid()); if (project.isPrivate()) { throw generateInvalidProjectExcpetion(); } if (branch.isPresent() && !branch.get().getBranchType().equals(LONG)) { throw generateInvalidProjectExcpetion(); } if (!project.qualifier().equals(PROJECT) && !project.qualifier().equals(APP)) { throw generateInvalidProjectExcpetion(); } }
private static Ce.Task.Builder setComponent(Ce.Task.Builder builder, @Nullable String componentUuid, DtoCache componentDtoCache) { ComponentDto componentDto = componentDtoCache.getComponent(componentUuid); if (componentDto == null) { return builder; } builder.setComponentKey(componentDto.getKey()); builder.setComponentName(componentDto.name()); builder.setComponentQualifier(componentDto.qualifier()); return builder; }
@Test public void return_public_project_with_only_AllowAnyone_true_when_no_permission_in_DB() { List<IndexPermissions> dtos = underTest.selectByUuids(dbClient, dbSession, singletonList(publicProject.uuid())); Assertions.assertThat(dtos).hasSize(1); IndexPermissions dto = dtos.get(0); assertThat(dto.getGroupIds()).isEmpty(); assertThat(dto.getUserIds()).isEmpty(); assertThat(dto.isAllowAnyone()).isTrue(); assertThat(dto.getProjectUuid()).isEqualTo(publicProject.uuid()); assertThat(dto.getQualifier()).isEqualTo(publicProject.qualifier()); }
@Test public void return_private_project_without_any_permission_when_no_permission_in_DB() { List<IndexPermissions> dtos = underTest.selectByUuids(dbClient, dbSession, singletonList(privateProject1.uuid())); // no permissions Assertions.assertThat(dtos).hasSize(1); IndexPermissions dto = dtos.get(0); assertThat(dto.getGroupIds()).isEmpty(); assertThat(dto.getUserIds()).isEmpty(); assertThat(dto.isAllowAnyone()).isFalse(); assertThat(dto.getProjectUuid()).isEqualTo(privateProject1.uuid()); assertThat(dto.getQualifier()).isEqualTo(privateProject1.qualifier()); }
private void writeConfiguration(JsonWriter json, ComponentDto component, OrganizationDto organization) { boolean isProjectAdmin = userSession.hasComponentPermission(ADMIN, component); json.name("configuration").beginObject(); writeConfigPageAccess(json, isProjectAdmin, component, organization); if (isProjectAdmin) { json.name("extensions").beginArray(); List<Page> configPages = pageRepository.getComponentPages(true, component.qualifier()); configPages.forEach(page -> writePage(json, page)); json.endArray(); } json.endObject(); }
private void failForPropertyWithoutDefinitionOnUnsupportedComponent(ComponentDto root, ComponentDto component) { i18n.put("qualifier." + component.qualifier(), "QualifierLabel"); logInAsProjectAdmin(root); expectedException.expect(BadRequestException.class); expectedException.expectMessage("Setting 'foo' cannot be set on a QualifierLabel"); executeRequestOnComponentSetting("foo", component); }
public PermissionIndexerTester allowOnlyUser(ComponentDto project, UserDto user) { IndexPermissions dto = new IndexPermissions(project.uuid(), project.qualifier()) .addUserId(user.getId()); return allow(dto); }
public PermissionIndexerTester allowOnlyGroup(ComponentDto project, GroupDto group) { IndexPermissions dto = new IndexPermissions(project.uuid(), project.qualifier()) .addGroupId(group.getId()); return allow(dto); }
private static void addProject(JsonWriter json, ComponentDto project) { json.beginObject() .prop("id", project.getId()) .prop("k", project.getDbKey()) .prop("nm", project.name()) .prop("sc", project.scope()) .prop("qu", project.qualifier()) .endObject(); }
private void failForPropertyWithoutDefinitionOnUnsupportedComponent(ComponentDto root, ComponentDto component) { i18n.put("qualifier." + component.qualifier(), "QualifierLabel"); logInAsProjectAdministrator(root); expectedException.expect(BadRequestException.class); expectedException.expectMessage("Setting 'my.key' cannot be set on a QualifierLabel"); callForProjectSettingByKey("my.key", "My Value", component.getDbKey()); }
private IssueMetricFormula newQualifierBasedIntFormula() { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); return new IssueMetricFormula(metric, false, (ctx, issues) -> { ctx.setValue(ORDERED_BOTTOM_UP.indexOf(ctx.getComponent().qualifier())); }); }
private IssueMetricFormula newQualifierBasedIntLeakFormula() { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); return new IssueMetricFormula(metric, true, (ctx, issues) -> { ctx.setLeakValue(ORDERED_BOTTOM_UP.indexOf(ctx.getComponent().qualifier())); }); }