private static Group toWsGroup(GroupDto group, Integer memberCount, Set<String> fields, boolean isDefault) { Group.Builder groupBuilder = Group.newBuilder() .setId(group.getId()) .setDefault(isDefault); if (fields.contains(FIELD_NAME)) { groupBuilder.setName(group.getName()); } if (fields.contains(FIELD_DESCRIPTION)) { ofNullable(group.getDescription()).ifPresent(groupBuilder::setDescription); } if (fields.contains(FIELD_MEMBERS_COUNT)) { groupBuilder.setMembersCount(memberCount); } return groupBuilder.build(); }
@Override public void handle(Request request, Response response) throws Exception { try (DbSession dbSession = dbClient.openSession(false)) { OrganizationDto organization = support.findOrganizationByKey(dbSession, request.param(PARAM_ORGANIZATION_KEY)); userSession.checkPermission(ADMINISTER, organization); GroupDto group = new GroupDto() .setOrganizationUuid(organization.getUuid()) .setName(request.mandatoryParam(PARAM_GROUP_NAME)) .setDescription(request.param(PARAM_GROUP_DESCRIPTION)); // validations UserGroupValidation.validateGroupName(group.getName()); support.checkNameDoesNotExist(dbSession, group.getOrganizationUuid(), group.getName()); dbClient.groupDao().insert(dbSession, group); dbSession.commit(); writeResponse(request, response, organization, group); } }
public static GroupDto newGroupDto() { GroupDto group = new GroupDto() .setId(nextInt()) .setOrganizationUuid(randomAlphanumeric(40)) .setName(randomAlphanumeric(255)) .setDescription(randomAlphanumeric(200)) .setCreatedAt(new Date(nextLong())) .setUpdatedAt(new Date(nextLong())); return group; } }
void checkGroupIsNotDefault(DbSession dbSession, GroupDto groupDto) { GroupDto defaultGroup = defaultGroupFinder.findDefaultGroup(dbSession, groupDto.getOrganizationUuid()); checkArgument(!defaultGroup.getId().equals(groupDto.getId()), "Default group '%s' cannot be used to perform this action", groupDto.getName()); }
public static GroupId from(GroupDto dto) { return new GroupId(dto.getOrganizationUuid(), dto.getId()); } }
public GroupDto insert(DbSession session, GroupDto item) { Date createdAt = new Date(system.now()); item.setCreatedAt(createdAt) .setUpdatedAt(createdAt); mapper(session).insert(item); return item; }
/** * Owners group has an hard coded name, a description based on the organization's name and has all global permissions. */ private GroupDto insertOwnersGroup(DbSession dbSession, OrganizationDto organization) { GroupDto group = dbClient.groupDao().insert(dbSession, new GroupDto() .setOrganizationUuid(organization.getUuid()) .setName(OWNERS_GROUP_NAME) .setDescription(format(OWNERS_GROUP_DESCRIPTION_PATTERN, organization.getName()))); permissionService.getAllOrganizationPermissions().forEach(p -> addPermissionToGroup(dbSession, group, p)); return group; }
private static GroupDto newGroup(OrganizationDto org, String name, String description) { return GroupTesting.newGroupDto().setName(name).setDescription(description).setOrganizationUuid(org.getUuid()); } }
private void verifyMembersGroup(UserDto user, String organizationKey) { OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, organizationKey).get(); Optional<GroupDto> groupOpt = dbClient.groupDao().selectByName(dbSession, organization.getUuid(), "Members"); assertThat(groupOpt).isPresent(); GroupDto groupDto = groupOpt.get(); assertThat(groupDto.getDescription()).isEqualTo("All members of the organization"); assertThat(dbClient.groupPermissionDao().selectGlobalPermissionsOfGroup(dbSession, groupDto.getOrganizationUuid(), groupDto.getId())).isEmpty(); List<UserMembershipDto> members = dbClient.groupMembershipDao().selectMembers( dbSession, UserMembershipQuery.builder() .organizationUuid(organization.getUuid()) .groupId(groupDto.getId()) .membership(UserMembershipQuery.IN).build(), 0, Integer.MAX_VALUE); assertThat(members) .extracting(UserMembershipDto::getLogin) .containsOnly(user.getLogin()); }
private List<GroupDto> findGroups(DbSession dbSession, OrganizationDto org, PermissionQuery dbQuery) { List<String> orderedNames = dbClient.groupPermissionDao().selectGroupNamesByQuery(dbSession, dbQuery); List<GroupDto> groups = dbClient.groupDao().selectByNames(dbSession, org.getUuid(), orderedNames); if (orderedNames.contains(DefaultGroups.ANYONE)) { groups.add(0, new GroupDto().setId(0).setName(DefaultGroups.ANYONE).setOrganizationUuid(org.getUuid())); } return Ordering.explicit(orderedNames).onResultOf(GroupDto::getName).immutableSortedCopy(groups); }
@Test public void return_groups_from_given_organization() { UserDto user = insertUser(); OrganizationDto organizationDto = db.organizations().insert(); OrganizationDto otherOrganizationDto = db.organizations().insert(); GroupDto group = db.users().insertDefaultGroup(newGroupDto().setName("group1").setOrganizationUuid(organizationDto.getUuid())); GroupDto otherGroup = db.users().insertDefaultGroup(newGroupDto().setName("group2").setOrganizationUuid(otherOrganizationDto.getUuid())); addUserToGroup(user, group); addUserToGroup(user, otherGroup); GroupsWsResponse response = call(ws.newRequest() .setParam("login", USER_LOGIN) .setParam("organization", organizationDto.getKey()) .setParam(Param.SELECTED, ALL.value())); assertThat(response.getGroupsList()) .extracting(GroupsWsResponse.Group::getId, GroupsWsResponse.Group::getName, GroupsWsResponse.Group::getDescription, GroupsWsResponse.Group::getSelected, GroupsWsResponse.Group::getDefault) .containsOnly(tuple(group.getId().longValue(), group.getName(), group.getDescription(), true, true)); }
@Test public void selectByName() { db.getDbClient().groupDao().insert(dbSession, aGroup); GroupDto group = underTest.selectByName(dbSession, AN_ORGANIZATION.getUuid(), aGroup.getName()).get(); assertThat(group.getId()).isNotNull(); assertThat(group.getOrganizationUuid()).isEqualTo(aGroup.getOrganizationUuid()); assertThat(group.getName()).isEqualTo(aGroup.getName()); assertThat(group.getDescription()).isEqualTo(aGroup.getDescription()); assertThat(group.getCreatedAt()).isEqualTo(new Date(NOW)); assertThat(group.getUpdatedAt()).isEqualTo(new Date(NOW)); }
private List<GroupDto> findGroups(DbSession dbSession, PermissionQuery dbQuery, PermissionTemplateDto template) { List<String> orderedNames = dbClient.permissionTemplateDao().selectGroupNamesByQueryAndTemplate(dbSession, dbQuery, template.getId()); List<GroupDto> groups = dbClient.groupDao().selectByNames(dbSession, template.getOrganizationUuid(), orderedNames); if (orderedNames.contains(DefaultGroups.ANYONE)) { groups.add(0, new GroupDto().setId(0).setName(DefaultGroups.ANYONE)); } return Ordering.explicit(orderedNames).onResultOf(GroupDto::getName).immutableSortedCopy(groups); }
private static Qualityprofiles.SearchGroupsResponse.Group toGroup(GroupDto group, boolean isSelected) { Qualityprofiles.SearchGroupsResponse.Group.Builder builder = Qualityprofiles.SearchGroupsResponse.Group.newBuilder() .setName(group.getName()) .setSelected(isSelected); ofNullable(group.getDescription()).ifPresent(builder::setDescription); return builder.build(); }
private void copySonarUsersGroupPermissionTemplatesToMembersGroup(DbSession dbSession, GroupDto sonarUsersGroup, GroupDto membersGroup) { List<PermissionTemplateGroupDto> sonarUsersPermissionTemplates = dbClient.permissionTemplateDao().selectAllGroupPermissionTemplatesByGroupId(dbSession, sonarUsersGroup.getId()); sonarUsersPermissionTemplates.forEach(permissionTemplateGroup -> dbClient.permissionTemplateDao().insertGroupPermission(dbSession, permissionTemplateGroup.getTemplateId(), membersGroup.getId(), permissionTemplateGroup.getPermission())); }
@Test public void selectByNames() { GroupDto group1InOrg1 = underTest.insert(dbSession, newGroupDto().setName("group1").setOrganizationUuid("org1")); GroupDto group2InOrg1 = underTest.insert(dbSession, newGroupDto().setName("group2").setOrganizationUuid("org1")); GroupDto group1InOrg2 = underTest.insert(dbSession, newGroupDto().setName("group1").setOrganizationUuid("org2")); GroupDto group3InOrg2 = underTest.insert(dbSession, newGroupDto().setName("group3").setOrganizationUuid("org2")); dbSession.commit(); assertThat(underTest.selectByNames(dbSession, "org1", asList("group1", "group2", "group3", "missingGroup"))).extracting(GroupDto::getId) .containsOnly(group1InOrg1.getId(), group2InOrg1.getId()); assertThat(underTest.selectByNames(dbSession, "org1", Collections.emptyList())).isEmpty(); assertThat(underTest.selectByNames(dbSession, "missingOrg", asList("group1"))).isEmpty(); }
private void assertTemplate1AppliedToProject() { assertThat(selectProjectPermissionGroups(project, UserRole.ADMIN)).containsExactly(group1.getName()); assertThat(selectProjectPermissionGroups(project, UserRole.USER)).containsExactly(group2.getName()); assertThat(selectProjectPermissionUsers(project, UserRole.ADMIN)).isEmpty(); assertThat(selectProjectPermissionUsers(project, UserRole.CODEVIEWER)).containsExactly(user1.getId()); assertThat(selectProjectPermissionUsers(project, UserRole.ISSUE_ADMIN)).containsExactly(user2.getId()); }
@Test public void select_by_query_with_special_characters() { String groupNameWithSpecialCharacters = "group%_%/name"; underTest.insert(dbSession, newGroupDto().setName(groupNameWithSpecialCharacters).setOrganizationUuid("org1")); db.commit(); List<GroupDto> result = underTest.selectByQuery(dbSession, "org1", "roup%_%/nam", 0, 10); int resultCount = underTest.countByQuery(dbSession, "org1", "roup%_%/nam"); assertThat(result).hasSize(1); assertThat(result.get(0).getName()).isEqualTo(groupNameWithSpecialCharacters); assertThat(resultCount).isEqualTo(1); }
@Override public void handle(Request request, Response response) throws Exception { try (DbSession dbSession = dbClient.openSession(false)) { int groupId = request.mandatoryParamAsInt(PARAM_GROUP_ID); GroupDto group = dbClient.groupDao().selectById(dbSession, groupId); checkFound(group, "Could not find a user group with id '%s'.", groupId); Optional<OrganizationDto> org = dbClient.organizationDao().selectByUuid(dbSession, group.getOrganizationUuid()); checkFoundWithOptional(org, "Could not find organization with id '%s'.", group.getOrganizationUuid()); userSession.checkPermission(ADMINISTER, org.get()); support.checkGroupIsNotDefault(dbSession, group); boolean changed = false; String newName = request.param(PARAM_GROUP_NAME); if (newName != null) { changed = true; UserGroupValidation.validateGroupName(newName); support.checkNameDoesNotExist(dbSession, group.getOrganizationUuid(), newName); group.setName(newName); } String description = request.param(PARAM_GROUP_DESCRIPTION); if (description != null) { changed = true; group.setDescription(description); } if (changed) { dbClient.groupDao().update(dbSession, group); dbSession.commit(); } writeResponse(dbSession, request, response, org.get(), group); } }
@Test public void select_group_names_by_query_and_template_returns_anyone() { OrganizationDto organization = db.organizations().insert(); PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(organization); GroupDto group = db.users().insertGroup(newGroupDto().setName("Group")); PermissionTemplateDto otherTemplate = permissionTemplateDbTester.insertTemplate(organization); permissionTemplateDbTester.addGroupToTemplate(otherTemplate.getId(), group.getId(), USER); assertThat(selectGroupNamesByQueryAndTemplate(builder().setSearchQuery("nyo"), organization, template)) .containsExactly("Anyone"); }