diff options
Diffstat (limited to 'server/sonar-db-dao/src')
60 files changed, 651 insertions, 641 deletions
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java index fb937c9f934..a6d45e63dca 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java @@ -109,15 +109,15 @@ public class OrganizationDao implements Dao { getMapper(dbSession).updateDefaultTemplates(uuid, defaultTemplates, now); } - public Optional<Integer> getDefaultGroupId(DbSession dbSession, String organizationUuid) { + public Optional<String> getDefaultGroupUuid(DbSession dbSession, String organizationUuid) { checkUuid(organizationUuid); - return Optional.ofNullable(getMapper(dbSession).selectDefaultGroupIdByUuid(organizationUuid)); + return Optional.ofNullable(getMapper(dbSession).selectDefaultGroupUuidByUuid(organizationUuid)); } - public void setDefaultGroupId(DbSession dbSession, String uuid, GroupDto defaultGroup) { + public void setDefaultGroupUuid(DbSession dbSession, String uuid, GroupDto defaultGroup) { checkUuid(uuid); - Integer defaultGroupId = requireNonNull(defaultGroup, "Default group cannot be null").getId(); - getMapper(dbSession).updateDefaultGroupId(uuid, requireNonNull(defaultGroupId, "Default group id cannot be null"), system2.now()); + String defaultGroupUuid = requireNonNull(defaultGroup, "Default group cannot be null").getUuid(); + getMapper(dbSession).updateDefaultGroupUuid(uuid, requireNonNull(defaultGroupUuid, "Default group uuid cannot be null"), system2.now()); } public void setDefaultQualityGate(DbSession dbSession, OrganizationDto organization, QGateWithOrgDto qualityGate) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDto.java index 4c482018b6c..9b9c10ad1a3 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDto.java @@ -73,7 +73,7 @@ public class OrganizationDto { private Subscription subscription; - private Integer defaultGroupId; + private String defaultGroupUuid; private String defaultQualityGateUuid; private long createdAt; private long updatedAt; @@ -136,12 +136,12 @@ public class OrganizationDto { } @CheckForNull - public Integer getDefaultGroupId() { - return defaultGroupId; + public String getDefaultGroupUuid() { + return defaultGroupUuid; } - public OrganizationDto setDefaultGroupId(@Nullable Integer defaultGroupId) { - this.defaultGroupId = defaultGroupId; + public OrganizationDto setDefaultGroupUuid(@Nullable String defaultGroupUuid) { + this.defaultGroupUuid = defaultGroupUuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java index 46276f62ac8..d5de60c4dda 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java @@ -51,7 +51,7 @@ public interface OrganizationMapper { DefaultTemplates selectDefaultTemplatesByUuid(@Param("uuid") String uuid); - Integer selectDefaultGroupIdByUuid(@Param("uuid") String uuid); + String selectDefaultGroupUuidByUuid(@Param("uuid") String uuid); boolean selectNewProjectPrivateByUuid(@Param("uuid") String uuid); @@ -67,8 +67,8 @@ public interface OrganizationMapper { void updateDefaultTemplates(@Param("organizationUuid") String organizationUuid, @Param("defaultTemplates") DefaultTemplates defaultTemplates, @Param("now") long now); - void updateDefaultGroupId(@Param("organizationUuid") String organizationUuid, - @Param("defaultGroupId") int defaultGroupId, @Param("now") long now); + void updateDefaultGroupUuid(@Param("organizationUuid") String organizationUuid, + @Param("defaultGroupUuid") String defaultGroupUuid, @Param("now") long now); void updateDefaultQualityGate(@Param("organizationUuid") String organizationUuid, @Param("defaultQualityGateUuid") String defaultQualityGateUuid, @Param("now") long now); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationDao.java index 13fcc11397f..5306fcb3c2f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationDao.java @@ -78,12 +78,12 @@ public class AuthorizationDao implements Dao { } /** - * The number of users who will still have the permission if the group {@code excludedGroupId} + * The number of users who will still have the permission if the group {@code excludedGroupUuid} * is deleted. The anyone virtual group is not taken into account. */ public int countUsersWithGlobalPermissionExcludingGroup(DbSession dbSession, String organizationUuid, - String permission, int excludedGroupId) { - return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroup(organizationUuid, permission, excludedGroupId); + String permission, String excludedGroupUuid) { + return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroup(organizationUuid, permission, excludedGroupUuid); } /** @@ -105,13 +105,13 @@ public class AuthorizationDao implements Dao { /** * The number of users who will still have the permission if the user {@code userId} - * is removed from group {@code groupId}. The anyone virtual group is not taken into account. + * is removed from group {@code groupUuid}. The anyone virtual group is not taken into account. * Contrary to {@link #countUsersWithGlobalPermissionExcludingUser(DbSession, String, String, int)}, user * still exists and may have the permission directly or through other groups. */ public int countUsersWithGlobalPermissionExcludingGroupMember(DbSession dbSession, String organizationUuid, - String permission, int groupId, int userId) { - return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroupMember(organizationUuid, permission, groupId, userId); + String permission, String groupUuid, int userId) { + return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroupMember(organizationUuid, permission, groupUuid, userId); } /** diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationMapper.java index 8712e4bb5f4..462c2fc4b78 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/AuthorizationMapper.java @@ -35,7 +35,7 @@ public interface AuthorizationMapper { Set<String> selectOrganizationPermissionsOfAnonymous(@Param("organizationUuid") String organizationUuid); int countUsersWithGlobalPermissionExcludingGroup(@Param("organizationUuid") String organizationUuid, - @Param("permission") String permission, @Param("excludedGroupId") int excludedGroupId); + @Param("permission") String permission, @Param("excludedGroupUuid") String excludedGroupUuid); int countUsersWithGlobalPermissionExcludingUser(@Param("organizationUuid") String organizationUuid, @Param("permission") String permission, @Param("excludedUserId") int excludedUserId); @@ -43,7 +43,7 @@ public interface AuthorizationMapper { List<Integer> selectUserIdsWithGlobalPermission(@Param("organizationUuid") String organizationUuid, @Param("permission") String permission); int countUsersWithGlobalPermissionExcludingGroupMember(@Param("organizationUuid") String organizationUuid, - @Param("permission") String permission, @Param("groupId") int groupId, @Param("userId") int userId); + @Param("permission") String permission, @Param("groupUuid") String groupUuid, @Param("userId") int userId); int countUsersWithGlobalPermissionExcludingUserPermission(@Param("organizationUuid") String organizationUuid, @Param("permission") String permission, @Param("userId") int userId); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java index 6d4ee373de6..06f360c16a3 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java @@ -59,18 +59,18 @@ public class GroupPermissionDao implements Dao { /** * Select global or project permission of given groups and organization. Anyone virtual group is supported - * through the value "zero" (0L) in {@code groupIds}. + * through the value "zero" (0L) in {@code groupUuids}. */ - public List<GroupPermissionDto> selectByGroupIds(DbSession dbSession, String organizationUuid, List<Integer> groupIds, @Nullable String projectUuid) { - return executeLargeInputs(groupIds, groups -> mapper(dbSession).selectByGroupIds(organizationUuid, groups, projectUuid)); + public List<GroupPermissionDto> selectByGroupUuids(DbSession dbSession, String organizationUuid, List<String> groupUuids, @Nullable String projectUuid) { + return executeLargeInputs(groupUuids, groups -> mapper(dbSession).selectByGroupUuids(organizationUuid, groups, projectUuid)); } /** * Select global and project permissions of a given group (Anyone group is NOT supported) * Each row returns a {@link GroupPermissionDto} */ - public void selectAllPermissionsByGroupId(DbSession dbSession, String organizationUuid, Integer groupId, ResultHandler resultHandler) { - mapper(dbSession).selectAllPermissionsByGroupId(organizationUuid, groupId, resultHandler); + public void selectAllPermissionsByGroupUuid(DbSession dbSession, String organizationUuid, String groupUuid, ResultHandler resultHandler) { + mapper(dbSession).selectAllPermissionsByGroupUuid(organizationUuid, groupUuid, resultHandler); } /** @@ -92,25 +92,25 @@ public class GroupPermissionDao implements Dao { * Selects the global permissions granted to group. An empty list is returned if the * group does not exist. */ - public List<String> selectGlobalPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Integer groupId) { - return mapper(session).selectGlobalPermissionsOfGroup(organizationUuid, groupId); + public List<String> selectGlobalPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable String groupUuid) { + return mapper(session).selectGlobalPermissionsOfGroup(organizationUuid, groupUuid); } /** * Selects the permissions granted to group and project. An empty list is returned if the * group or project do not exist. */ - public List<String> selectProjectPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Integer groupId, String projectUuid) { - return mapper(session).selectProjectPermissionsOfGroup(organizationUuid, groupId, projectUuid); + public List<String> selectProjectPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable String groupUuid, String projectUuid) { + return mapper(session).selectProjectPermissionsOfGroup(organizationUuid, groupUuid, projectUuid); } /** - * Lists id of groups with at least one permission on the specified root component but which do not have the specified + * Lists uuid of groups with at least one permission on the specified root component but which do not have the specified * permission, <strong>excluding group "AnyOne"</strong> (which implies the returned {@code Sett} can't contain * {@code null}). */ - public Set<Integer> selectGroupIdsWithPermissionOnProjectBut(DbSession session, String projectUuid, String permission) { - return mapper(session).selectGroupIdsWithPermissionOnProjectBut(projectUuid, permission); + public Set<String> selectGroupUuidsWithPermissionOnProjectBut(DbSession session, String projectUuid, String permission) { + return mapper(session).selectGroupUuidsWithPermissionOnProjectBut(projectUuid, permission); } public void insert(DbSession dbSession, GroupPermissionDto dto) { @@ -131,14 +131,14 @@ public class GroupPermissionDao implements Dao { } private static void ensureGroupPermissionConsistency(DbSession dbSession, GroupPermissionDto dto) { - if (dto.getGroupId() == null) { + if (dto.getGroupUuid() == null) { return; } GroupMapper groupMapper = dbSession.getMapper(GroupMapper.class); checkArgument( - groupMapper.countGroupByOrganizationAndId(dto.getOrganizationUuid(), dto.getGroupId()) == 1, + groupMapper.countGroupByOrganizationAndUuid(dto.getOrganizationUuid(), dto.getGroupUuid()) == 1, "Can't insert permission '%s' for group with id '%s' in organization with uuid '%s' because this group does not belong to organization with uuid '%s'", - dto.getRole(), dto.getGroupId(), dto.getOrganizationUuid(), dto.getOrganizationUuid()); + dto.getRole(), dto.getGroupUuid(), dto.getOrganizationUuid(), dto.getOrganizationUuid()); } /** @@ -149,11 +149,11 @@ public class GroupPermissionDao implements Dao { } /** - * Delete all permissions of the specified group (group "AnyOne" if {@code groupId} is {@code null}) for the specified + * Delete all permissions of the specified group (group "AnyOne" if {@code groupUuid} is {@code null}) for the specified * component. */ - public int deleteByRootComponentUuidAndGroupId(DbSession dbSession, String rootComponentUuid, @Nullable Integer groupId) { - return mapper(dbSession).deleteByRootComponentUuidAndGroupId(rootComponentUuid, groupId); + public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, String rootComponentUuid, @Nullable String groupUuid) { + return mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(rootComponentUuid, groupUuid); } /** @@ -173,12 +173,12 @@ public class GroupPermissionDao implements Dao { * </ul> * @param dbSession * @param permission the kind of permission - * @param organizationUuid UUID of organization, even if parameter {@code groupId} is not null - * @param groupId if null, then anyone, else id of group + * @param organizationUuid UUID of organization, even if parameter {@code groupUuid} is not null + * @param groupUuid if null, then anyone, else uuid of group * @param rootComponentUuid if null, then global permission, otherwise the uuid of root component (project) */ - public void delete(DbSession dbSession, String permission, String organizationUuid, @Nullable Integer groupId, @Nullable String rootComponentUuid) { - mapper(dbSession).delete(permission, organizationUuid, groupId, rootComponentUuid); + public void delete(DbSession dbSession, String permission, String organizationUuid, @Nullable String groupUuid, @Nullable String rootComponentUuid) { + mapper(dbSession).delete(permission, organizationUuid, groupUuid, rootComponentUuid); } public void deleteByOrganization(DbSession dbSession, String organizationUuid) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDto.java index eb7bf2f8e7f..687e01848c2 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDto.java @@ -24,7 +24,7 @@ import javax.annotation.Nullable; public class GroupPermissionDto { private String uuid; private String organizationUuid; - private Integer groupId; + private String groupUuid; private String componentUuid; private String role; @@ -37,8 +37,8 @@ public class GroupPermissionDto { return this; } - public Integer getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } public String getOrganizationUuid() { @@ -53,8 +53,8 @@ public class GroupPermissionDto { /** * Null when Anyone */ - public GroupPermissionDto setGroupId(@Nullable Integer groupId) { - this.groupId = groupId; + public GroupPermissionDto setGroupUuid(@Nullable String groupUuid) { + this.groupUuid = groupUuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java index 7d0c9122262..74e95b0d286 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java @@ -33,37 +33,37 @@ public interface GroupPermissionMapper { int countGroupsByQuery(@Param("query") PermissionQuery query); - List<GroupPermissionDto> selectByGroupIds(@Param("organizationUuid") String organizationUuid, - @Param("groupIds") List<Integer> groupIds, @Nullable @Param("projectUuid") String projectUuid); + List<GroupPermissionDto> selectByGroupUuids(@Param("organizationUuid") String organizationUuid, + @Param("groupUuids") List<String> groupUuids, @Nullable @Param("projectUuid") String projectUuid); void groupsCountByProjectUuidAndPermission(Map<String, Object> parameters, ResultHandler resultHandler); void insert(GroupPermissionDto dto); void delete(@Param("permission") String permission, @Param("organizationUuid") String organizationUuid, - @Nullable @Param("groupId") Integer groupId, @Nullable @Param("rootComponentUuid") String rootComponentUuid); + @Nullable @Param("groupUuid") String groupUuid, @Nullable @Param("rootComponentUuid") String rootComponentUuid); List<String> selectGlobalPermissionsOfGroup(@Param("organizationUuid") String organizationUuid, - @Nullable @Param("groupId") Integer groupId); + @Nullable @Param("groupUuid") String groupUuid); List<String> selectProjectPermissionsOfGroup(@Param("organizationUuid") String organizationUuid, - @Nullable @Param("groupId") Integer groupId, @Param("projectUuid") String projectUuid); + @Nullable @Param("groupUuid") String groupUuid, @Param("projectUuid") String projectUuid); - void selectAllPermissionsByGroupId(@Param("organizationUuid") String organizationUuid, - @Param("groupId") Integer groupId, ResultHandler resultHandler); + void selectAllPermissionsByGroupUuid(@Param("organizationUuid") String organizationUuid, + @Param("groupUuid") String groupUuid, ResultHandler resultHandler); /** - * Lists id of groups with at least one permission on the specified root component but which do not have the specified + * Lists uuid of groups with at least one permission on the specified root component but which do not have the specified * permission, <strong>excluding group "AnyOne"</strong> (which implies the returned {@code Set} can't contain * {@code null}). */ - Set<Integer> selectGroupIdsWithPermissionOnProjectBut(@Param("projectUuid") String projectUuid, @Param("role") String permission); + Set<String> selectGroupUuidsWithPermissionOnProjectBut(@Param("projectUuid") String projectUuid, @Param("role") String permission); void deleteByOrganization(@Param("organizationUuid") String organizationUuid); void deleteByRootComponentUuid(@Param("rootComponentUuid") String rootComponentUuid); - int deleteByRootComponentUuidAndGroupId(@Param("rootComponentUuid") String rootComponentUuid, @Nullable @Param("groupId") Integer groupId); + int deleteByRootComponentUuidAndGroupUuid(@Param("rootComponentUuid") String rootComponentUuid, @Nullable @Param("groupUuid") String groupUuid); int deleteByRootComponentUuidAndPermission(@Param("rootComponentUuid") String rootComponentUuid, @Param("permission") String permission); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java index e5c621d8493..48b0447f042 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java @@ -91,8 +91,8 @@ public class PermissionTemplateDao implements Dao { /** * @return {@code true} if template contains groups that are granted with {@code permission}, else {@code false} */ - public boolean hasGroupsWithPermission(DbSession dbSession, String templateUuid, String permission, @Nullable Integer groupId) { - return mapper(dbSession).countGroupsWithPermission(templateUuid, permission, groupId) > 0; + public boolean hasGroupsWithPermission(DbSession dbSession, String templateUuid, String permission, @Nullable String groupUuid) { + return mapper(dbSession).countGroupsWithPermission(templateUuid, permission, groupUuid) > 0; } @CheckForNull @@ -147,8 +147,8 @@ public class PermissionTemplateDao implements Dao { }); } - public List<PermissionTemplateGroupDto> selectAllGroupPermissionTemplatesByGroupId(DbSession dbSession, long groupId) { - return mapper(dbSession).selectAllGroupPermissionTemplatesByGroupId(groupId); + public List<PermissionTemplateGroupDto> selectAllGroupPermissionTemplatesByGroupUuid(DbSession dbSession, String groupUuid) { + return mapper(dbSession).selectAllGroupPermissionTemplatesByGroupUuid(groupUuid); } public void deleteByUuid(DbSession session, String templateUuid) { @@ -194,12 +194,12 @@ public class PermissionTemplateDao implements Dao { mapper(dbSession).deleteUserPermissionsByUserId(userId); } - public void insertGroupPermission(DbSession session, String templateUuid, @Nullable Integer groupId, String permission) { + public void insertGroupPermission(DbSession session, String templateUuid, @Nullable String groupUuid, String permission) { PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto() .setUuid(uuidFactory.create()) .setTemplateUuid(templateUuid) .setPermission(permission) - .setGroupId(groupId) + .setGroupUuid(groupUuid) .setCreatedAt(now()) .setUpdatedAt(now()); mapper(session).insertGroupPermission(permissionTemplateGroup); @@ -209,11 +209,11 @@ public class PermissionTemplateDao implements Dao { mapper(session).insertGroupPermission(permissionTemplateGroup); } - public void deleteGroupPermission(DbSession session, String templateUuid, @Nullable Integer groupId, String permission) { + public void deleteGroupPermission(DbSession session, String templateUuid, @Nullable String groupUuid, String permission) { PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto() .setTemplateUuid(templateUuid) .setPermission(permission) - .setGroupId(groupId); + .setGroupUuid(groupUuid); mapper(session).deleteGroupPermission(permissionTemplateGroup); session.commit(); } @@ -229,8 +229,8 @@ public class PermissionTemplateDao implements Dao { /** * Remove a group from all templates (used when removing a group) */ - public void deleteByGroup(DbSession session, int groupId) { - session.getMapper(PermissionTemplateMapper.class).deleteByGroupId(groupId); + public void deleteByGroup(DbSession session, String groupUuid) { + session.getMapper(PermissionTemplateMapper.class).deleteByGroupUuid(groupUuid); } private Date now() { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateGroupDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateGroupDto.java index 4c3e5acf6d0..6a9f3f86bbd 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateGroupDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateGroupDto.java @@ -25,7 +25,7 @@ import javax.annotation.Nullable; public class PermissionTemplateGroupDto { private String uuid; private String templateUuid; - private Integer groupId; + private String groupUuid; private String permission; private String groupName; private Date createdAt; @@ -49,12 +49,12 @@ public class PermissionTemplateGroupDto { return this; } - public Integer getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } - public PermissionTemplateGroupDto setGroupId(@Nullable Integer groupId) { - this.groupId = groupId; + public PermissionTemplateGroupDto setGroupUuid(@Nullable String groupUuid) { + this.groupUuid = groupUuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java index d5c6383890d..ce1d821b3fa 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java @@ -66,7 +66,7 @@ public interface PermissionTemplateMapper { void insertGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup); - void deleteByGroupId(int groupId); + void deleteByGroupUuid(String groupUuid); PermissionTemplateDto selectByName(@Param("organizationUuid") String organizationUuid, @Param("name") String name); @@ -86,10 +86,10 @@ public interface PermissionTemplateMapper { List<String> selectPotentialPermissionsByUserIdAndTemplateUuid(@Param("userId") @Nullable Integer currentUserId, @Param("templateUuid") String templateUuid); - int countGroupsWithPermission(@Param("templateUuid") String templateUuid, @Param("permission") String permission, @Nullable @Param("groupId") Integer groupId); + int countGroupsWithPermission(@Param("templateUuid") String templateUuid, @Param("permission") String permission, @Nullable @Param("groupUuid") String groupUuid); List<String> selectTemplateUuidsByOrganization(@Param("organizationUuid") String organizationUuid); - List<PermissionTemplateGroupDto> selectAllGroupPermissionTemplatesByGroupId(@Param("groupId") Long groupId); + List<PermissionTemplateGroupDto> selectAllGroupPermissionTemplatesByGroupUuid(@Param("groupUuid") String groupUuid); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/GroupMembershipDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/GroupMembershipDto.java index 63cb4f29c8d..21b6947ff24 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/GroupMembershipDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/GroupMembershipDto.java @@ -21,16 +21,16 @@ package org.sonar.db.qualityprofile; public class GroupMembershipDto { - private int groupId; + private String groupUuid; // Set by MyBatis private String uuid; - public int getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } - public GroupMembershipDto setGroupId(int groupId) { - this.groupId = groupId; + public GroupMembershipDto setGroupUuid(String groupUuid) { + this.groupUuid = groupUuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDao.java index 02f75e20479..1861da0c493 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDao.java @@ -47,7 +47,7 @@ public class QProfileEditGroupsDao implements Dao { } public boolean exists(DbSession dbSession, QProfileDto profile, Collection<GroupDto> groups) { - return !executeLargeInputs(groups.stream().map(GroupDto::getId).collect(toList()), partition -> mapper(dbSession).selectByQProfileAndGroups(profile.getKee(), partition)) + return !executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(toList()), partition -> mapper(dbSession).selectByQProfileAndGroups(profile.getKee(), partition)) .isEmpty(); } @@ -60,7 +60,7 @@ public class QProfileEditGroupsDao implements Dao { } public List<String> selectQProfileUuidsByOrganizationAndGroups(DbSession dbSession, OrganizationDto organization, Collection<GroupDto> groups) { - return DatabaseUtils.executeLargeInputs(groups.stream().map(GroupDto::getId).collect(toList()), + return DatabaseUtils.executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(toList()), g -> mapper(dbSession).selectQProfileUuidsByOrganizationAndGroups(organization.getUuid(), g)); } @@ -69,7 +69,7 @@ public class QProfileEditGroupsDao implements Dao { } public void deleteByQProfileAndGroup(DbSession dbSession, QProfileDto profile, GroupDto group) { - mapper(dbSession).delete(profile.getKee(), group.getId()); + mapper(dbSession).delete(profile.getKee(), group.getUuid()); } public void deleteByQProfiles(DbSession dbSession, List<QProfileDto> qProfiles) { @@ -77,7 +77,7 @@ public class QProfileEditGroupsDao implements Dao { } public void deleteByGroup(DbSession dbSession, GroupDto group) { - mapper(dbSession).deleteByGroup(group.getId()); + mapper(dbSession).deleteByGroup(group.getUuid()); } private static QProfileEditGroupsMapper mapper(DbSession dbSession) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDto.java index e0bd0f40f48..37672d86c26 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsDto.java @@ -22,7 +22,7 @@ package org.sonar.db.qualityprofile; public class QProfileEditGroupsDto { private String uuid; - private int groupId; + private String groupUuid; private String qProfileUuid; public String getUuid() { @@ -34,12 +34,12 @@ public class QProfileEditGroupsDto { return this; } - public int getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } - public QProfileEditGroupsDto setGroupId(int groupId) { - this.groupId = groupId; + public QProfileEditGroupsDto setGroupUuid(String groupUuid) { + this.groupUuid = groupUuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.java index b963c0f8210..fbc41a420ae 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.java @@ -26,20 +26,20 @@ import org.sonar.db.Pagination; public interface QProfileEditGroupsMapper { - List<QProfileEditGroupsDto> selectByQProfileAndGroups(@Param("qProfileUuid") String qProfileUuid, @Param("groupIds") List<Integer> groupIds); + List<QProfileEditGroupsDto> selectByQProfileAndGroups(@Param("qProfileUuid") String qProfileUuid, @Param("groupUuids") List<String> groupUuids); int countByQuery(@Param("query") SearchGroupsQuery query); List<GroupMembershipDto> selectByQuery(@Param("query") SearchGroupsQuery query, @Param("pagination") Pagination pagination); - List<String> selectQProfileUuidsByOrganizationAndGroups(@Param("organizationUuid") String organizationUuid, @Param("groupIds") List<Integer> groupIds); + List<String> selectQProfileUuidsByOrganizationAndGroups(@Param("organizationUuid") String organizationUuid, @Param("groupUuids") List<String> groupUuids); void insert(@Param("dto") QProfileEditGroupsDto dto, @Param("now") long now); - void delete(@Param("qProfileUuid") String qProfileUuid, @Param("groupId") int groupId); + void delete(@Param("qProfileUuid") String qProfileUuid, @Param("groupUuid") String groupUuid); void deleteByQProfiles(@Param("qProfileUuids") Collection<String> qProfileUuids); - void deleteByGroup(@Param("groupId") int groupId); + void deleteByGroup(@Param("groupUuid") String groupUuid); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java index 01f75de542e..5aa0a065ba8 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java @@ -59,16 +59,16 @@ public class GroupDao implements Dao { } @CheckForNull - public GroupDto selectById(DbSession dbSession, int groupId) { - return mapper(dbSession).selectById(groupId); + public GroupDto selectByUuid(DbSession dbSession, String groupUuid) { + return mapper(dbSession).selectByUuid(groupUuid); } - public List<GroupDto> selectByIds(DbSession dbSession, List<Integer> ids) { - return executeLargeInputs(ids, mapper(dbSession)::selectByIds); + public List<GroupDto> selectByUuids(DbSession dbSession, List<String> uuids) { + return executeLargeInputs(uuids, mapper(dbSession)::selectByUuids); } - public void deleteById(DbSession dbSession, int groupId) { - mapper(dbSession).deleteById(groupId); + public void deleteByUuid(DbSession dbSession, String groupUuid) { + mapper(dbSession).deleteByUuid(groupUuid); } public void deleteByOrganization(DbSession dbSession, String organizationUuid) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDto.java index 262d1994125..42dea6966af 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDto.java @@ -25,19 +25,19 @@ import javax.annotation.Nullable; public class GroupDto { - private Integer id; + private String uuid; private String name; private String description; private String organizationUuid; private Date createdAt; private Date updatedAt; - public Integer getId() { - return id; + public String getUuid() { + return uuid; } - public GroupDto setId(Integer id) { - this.id = id; + public GroupDto setUuid(String uuid) { + this.uuid = uuid; return this; } @@ -90,7 +90,7 @@ public class GroupDto { @Override public String toString() { StringBuilder sb = new StringBuilder("GroupDto{"); - sb.append("id=").append(id); + sb.append("id=").append(uuid); sb.append(", name='").append(name).append('\''); sb.append(", description='").append(description).append('\''); sb.append(", organizationUuid='").append(organizationUuid).append('\''); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java index 8de8574077a..34f4d792d41 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java @@ -28,7 +28,7 @@ import org.apache.ibatis.session.RowBounds; public interface GroupMapper { @CheckForNull - GroupDto selectById(int groupId); + GroupDto selectByUuid(String groupUuid); List<GroupDto> selectByUserLogin(String userLogin); @@ -47,9 +47,9 @@ public interface GroupMapper { * * @return 1 or 0. Either because the organization uuid is not the one of the group or because the group does not exist */ - int countGroupByOrganizationAndId(@Param("organizationUuid") String organizationUuid, @Param("groupId") int groupId); + int countGroupByOrganizationAndUuid(@Param("organizationUuid") String organizationUuid, @Param("groupUuid") String groupUuid); - void deleteById(int groupId); + void deleteByUuid(String groupUuid); void deleteByOrganization(@Param("organizationUuid") String organizationUuid); @@ -58,5 +58,5 @@ public interface GroupMapper { List<GroupDto> selectByOrganizationUuid(@Param("organizationUuid") String organizationUuid); - List<GroupDto> selectByIds(@Param("ids") List<Integer> ids); + List<GroupDto> selectByUuids(@Param("uuids") List<String> uuids); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDao.java index fd862ae048f..ea5b0597f2b 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDao.java @@ -46,19 +46,19 @@ public class GroupMembershipDao implements Dao { } public List<UserMembershipDto> selectMembers(DbSession session, UserMembershipQuery query, int offset, int limit) { - Map<String, Object> params = ImmutableMap.of("query", query, "groupId", query.groupId(), "organizationUuid", query.organizationUuid()); + Map<String, Object> params = ImmutableMap.of("query", query, "groupUuid", query.groupUuid(), "organizationUuid", query.organizationUuid()); return mapper(session).selectMembers(params, new RowBounds(offset, limit)); } public int countMembers(DbSession session, UserMembershipQuery query) { - Map<String, Object> params = ImmutableMap.of("query", query, "groupId", query.groupId(), "organizationUuid", query.organizationUuid()); + Map<String, Object> params = ImmutableMap.of("query", query, "groupUuid", query.groupUuid(), "organizationUuid", query.organizationUuid()); return mapper(session).countMembers(params); } - public Map<String, Integer> countUsersByGroups(DbSession session, Collection<Integer> groupIds) { + public Map<String, Integer> countUsersByGroups(DbSession session, Collection<String> groupUuids) { Map<String, Integer> result = new HashMap<>(); executeLargeInputs( - groupIds, + groupUuids, input -> { List<GroupUserCount> userCounts = mapper(session).countUsersByGroup(input); for (GroupUserCount count : userCounts) { @@ -70,8 +70,8 @@ public class GroupMembershipDao implements Dao { return result; } - public List<Integer> selectGroupIdsByUserId(DbSession dbSession, int userId) { - return mapper(dbSession).selectGroupIdsByUserId(userId); + public List<String> selectGroupUuidsByUserId(DbSession dbSession, int userId) { + return mapper(dbSession).selectGroupUuidsByUserId(userId); } public Multiset<String> countGroupByLoginsAndOrganization(DbSession dbSession, Collection<String> logins, String organizationUuid) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDto.java index 75934d1ceed..420c97989a9 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipDto.java @@ -27,17 +27,17 @@ import javax.annotation.Nullable; */ public class GroupMembershipDto { - private Long id; + private String uuid; private String name; private String description; private Integer userId; - public Long getId() { - return id; + public String getUuid() { + return uuid; } - public GroupMembershipDto setId(Long id) { - this.id = id; + public GroupMembershipDto setUuid(String uuid) { + this.uuid = uuid; return this; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipMapper.java index 4416392e231..e125cac211e 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMembershipMapper.java @@ -34,11 +34,11 @@ public interface GroupMembershipMapper { int countMembers(Map<String, Object> params); - List<GroupUserCount> countUsersByGroup(@Param("groupIds") List<Integer> groupIds); + List<GroupUserCount> countUsersByGroup(@Param("groupUuids") List<String> groupUuids); List<LoginGroup> selectGroupsByLogins(@Param("logins") List<String> logins); List<LoginGroup> selectGroupsByLoginsAndOrganization(@Param("logins") List<String> logins, @Param("organizationUuid") String organizationUuid); - List<Integer> selectGroupIdsByUserId(@Param("userId") int userId); + List<String> selectGroupUuidsByUserId(@Param("userId") int userId); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleDao.java index 4cc86238ccf..e36dc1b2f4f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleDao.java @@ -47,8 +47,8 @@ public class RoleDao implements Dao { return mapper(dbSession).selectComponentUuidsByPermissionAndUserId(permission, userId); } - public void deleteGroupRolesByGroupId(DbSession session, int groupId) { - mapper(session).deleteGroupRolesByGroupId(groupId); + public void deleteGroupRolesByGroupUuid(DbSession session, String groupUuid) { + mapper(session).deleteGroupRolesByGroupUuid(groupUuid); } private static RoleMapper mapper(DbSession session) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleMapper.java index 01dd4f2f6c2..0eab0fa9ba6 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/RoleMapper.java @@ -26,6 +26,6 @@ public interface RoleMapper { List<String> selectComponentUuidsByPermissionAndUserId(@Param("permission") String permission, @Param("userId") int userId); - void deleteGroupRolesByGroupId(int groupId); + void deleteGroupRolesByGroupUuid(String groupUuid); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java index 18a7c334830..2dc128b1fdc 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java @@ -29,12 +29,12 @@ public class UserGroupDao implements Dao { return dto; } - public void delete(DbSession session, int groupId, int userId) { - mapper(session).delete(groupId, userId); + public void delete(DbSession session, String groupUuid, int userId) { + mapper(session).delete(groupUuid, userId); } - public void deleteByGroupId(DbSession session, int groupId) { - mapper(session).deleteByGroupId(groupId); + public void deleteByGroupUuid(DbSession session, String groupUuid) { + mapper(session).deleteByGroupUuid(groupUuid); } public void deleteByOrganizationAndUser(DbSession dbSession, String organizationUuid, int userId) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDto.java index a2e5a9ccd89..4631d66a242 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDto.java @@ -22,7 +22,7 @@ package org.sonar.db.user; public class UserGroupDto { private int userId; - private int groupId; + private String groupUuid; public int getUserId() { return userId; @@ -33,12 +33,12 @@ public class UserGroupDto { return this; } - public int getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } - public UserGroupDto setGroupId(int groupId) { - this.groupId = groupId; + public UserGroupDto setGroupUuid(String groupUuid) { + this.groupUuid = groupUuid; return this; } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java index 76fd4b99338..072fd40466a 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java @@ -25,9 +25,9 @@ public interface UserGroupMapper { void insert(UserGroupDto dto); - void delete(@Param("groupId") int groupId, @Param("userId") int userId); + void delete(@Param("groupUuid") String groupUuid, @Param("userId") int userId); - void deleteByGroupId(@Param("groupId") int groupId); + void deleteByGroupUuid(@Param("groupUuid") String groupUuid); void deleteByOrganizationAndUser(@Param("organizationUuid") String organizationUuid, @Param("userId") int userId); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipDto.java index 3ea70da9825..ea421573722 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipDto.java @@ -25,7 +25,7 @@ import javax.annotation.Nullable; public class UserMembershipDto { private Long id; - private Integer groupId; + private String groupUuid; private String login; private String name; @@ -58,12 +58,12 @@ public class UserMembershipDto { } @CheckForNull - public Integer getGroupId() { - return groupId; + public String getGroupUuid() { + return groupUuid; } - public UserMembershipDto setGroupId(@Nullable Integer groupId) { - this.groupId = groupId; + public UserMembershipDto setGroupUuid(@Nullable String groupUuid) { + this.groupUuid = groupUuid; return this; } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipQuery.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipQuery.java index 4170fa12709..76e65ba0584 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipQuery.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserMembershipQuery.java @@ -42,7 +42,7 @@ public class UserMembershipQuery { public static final String OUT = "OUT"; public static final Set<String> AVAILABLE_MEMBERSHIPS = ImmutableSet.of(ANY, IN, OUT); - private final int groupId; + private final String groupUuid; private final String organizationUuid; private final String membership; @@ -59,7 +59,7 @@ public class UserMembershipQuery { private final int pageIndex; private UserMembershipQuery(Builder builder) { - this.groupId = builder.groupId; + this.groupUuid = builder.groupUuid; this.organizationUuid = builder.organizationUuid; this.membership = builder.membership; this.memberSearch = builder.memberSearch; @@ -69,8 +69,8 @@ public class UserMembershipQuery { this.pageIndex = builder.pageIndex; } - public int groupId() { - return groupId; + public String groupUuid() { + return groupUuid; } public String organizationUuid() { @@ -103,7 +103,7 @@ public class UserMembershipQuery { } public static class Builder { - private Integer groupId; + private String groupUuid; private String organizationUuid; private String membership; private String memberSearch; @@ -114,8 +114,8 @@ public class UserMembershipQuery { private Builder() { } - public Builder groupId(Integer groupId) { - this.groupId = groupId; + public Builder groupUuid(String groupUuid) { + this.groupUuid = groupUuid; return this; } @@ -160,7 +160,7 @@ public class UserMembershipQuery { } public UserMembershipQuery build() { - requireNonNull(groupId, "Group ID cant be null."); + requireNonNull(groupUuid, "Group ID cant be null."); requireNonNull(organizationUuid, "Organization UUID cannot be null"); initMembership(); initPageIndex(); diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml index e8bda0081ec..ad1342ad8d1 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml @@ -162,7 +162,7 @@ and g.component_uuid is null and g.role = #{permission,jdbcType=VARCHAR} inner join groups_users gu on - gu.group_id = g.group_id + gu.group_uuid = g.group_uuid and gu.user_id = #{userId,jdbcType=INTEGER} </select> @@ -170,8 +170,8 @@ select uuid from organizations </select> - <select id="selectDefaultGroupIdByUuid" resultType="Integer"> - select org.default_group_id + <select id="selectDefaultGroupUuidByUuid" resultType="string"> + select org.default_group_uuid from organizations org where org.uuid = #{uuid, jdbcType=VARCHAR} @@ -269,10 +269,10 @@ uuid = #{organizationUuid, jdbcType=VARCHAR} </update> - <update id="updateDefaultGroupId"> + <update id="updateDefaultGroupUuid"> update organizations set - default_group_id = #{defaultGroupId, jdbcType=INTEGER}, + default_group_uuid = #{defaultGroupUuid, jdbcType=VARCHAR}, updated_at = #{now, jdbcType=BIGINT} where uuid = #{organizationUuid, jdbcType=VARCHAR} diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/AuthorizationMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/AuthorizationMapper.xml index 32c918d3135..4e82b22be56 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/AuthorizationMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/AuthorizationMapper.xml @@ -6,7 +6,7 @@ <select id="selectOrganizationPermissions" parameterType="map" resultType="string"> select gr.role from group_roles gr - inner join groups_users gu on gr.group_id=gu.group_id + inner join groups_users gu on gr.group_uuid=gu.group_uuid where gr.organization_uuid=#{organizationUuid, jdbcType=VARCHAR} and gr.component_uuid is null and @@ -18,7 +18,7 @@ from group_roles gr where gr.organization_uuid=#{organizationUuid, jdbcType=VARCHAR} and - gr.group_id is null and + gr.group_uuid is null and gr.component_uuid is null union @@ -37,7 +37,7 @@ where gr.organization_uuid=#{organizationUuid, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is null + gr.group_uuid is null </select> <select id="countUsersWithGlobalPermissionExcludingGroup" parameterType="map" resultType="int"> @@ -45,13 +45,13 @@ ( select gu.user_id from groups_users gu - inner join group_roles gr on gr.group_id = gu.group_id + inner join group_roles gr on gr.group_uuid = gu.group_uuid where gr.organization_uuid = #{organizationUuid, jdbcType=VARCHAR} and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null and - gr.group_id != #{excludedGroupId, jdbcType=INTEGER} + gr.group_uuid is not null and + gr.group_uuid != #{excludedGroupUuid, jdbcType=VARCHAR} union @@ -69,12 +69,12 @@ ( select gu.user_id from groups_users gu - inner join group_roles gr on gr.group_id = gu.group_id + inner join group_roles gr on gr.group_uuid = gu.group_uuid where gr.organization_uuid = #{organizationUuid, jdbcType=VARCHAR} and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null and + gr.group_uuid is not null and gu.user_id != #{excludedUserId, jdbcType=INTEGER} union @@ -92,12 +92,12 @@ <select id="selectUserIdsWithGlobalPermission" parameterType="map" resultType="int"> select gu.user_id from groups_users gu - inner join group_roles gr on gr.group_id = gu.group_id + inner join group_roles gr on gr.group_uuid = gu.group_uuid where gr.organization_uuid = #{organizationUuid, jdbcType=VARCHAR} and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null + gr.group_uuid is not null union @@ -114,13 +114,13 @@ ( select gu.user_id from groups_users gu - inner join group_roles gr on gr.group_id = gu.group_id + inner join group_roles gr on gr.group_uuid = gu.group_uuid where gr.organization_uuid = #{organizationUuid, jdbcType=VARCHAR} and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null and - (gu.group_id != #{groupId, jdbcType=INTEGER} or gu.user_id != #{userId, jdbcType=INTEGER}) + gr.group_uuid is not null and + (gu.group_uuid != #{groupUuid, jdbcType=VARCHAR} or gu.user_id != #{userId, jdbcType=INTEGER}) union @@ -138,12 +138,12 @@ ( select gu.user_id from groups_users gu - inner join group_roles gr on gr.group_id = gu.group_id + inner join group_roles gr on gr.group_uuid = gu.group_uuid where gr.organization_uuid = #{organizationUuid, jdbcType=VARCHAR} and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null + gr.group_uuid is not null union @@ -160,11 +160,11 @@ <select id="selectOrganizationUuidsOfUserWithGlobalPermission" parameterType="map" resultType="String"> select gr.organization_uuid from group_roles gr - inner join groups_users gu on gr.group_id = gu.group_id + inner join groups_users gu on gr.group_uuid = gu.group_uuid where gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null and - gr.group_id is not null and + gr.group_uuid is not null and gu.user_id = #{userId, jdbcType=INTEGER} union @@ -185,7 +185,7 @@ where gr.role=#{role, jdbcType=VARCHAR} and ( - gr.group_id is null + gr.group_uuid is null or exists ( select 1 @@ -193,7 +193,7 @@ groups_users gu where gu.user_id = #{userId, jdbcType=INTEGER} - and gr.group_id = gu.group_id + and gr.group_uuid = gu.group_uuid ) ) and <foreach collection="projectUuids" open="(" close=")" item="element" index="index" separator=" or "> @@ -240,7 +240,7 @@ group_roles gr where gr.role=#{role, jdbcType=VARCHAR} - and gr.group_id is null + and gr.group_uuid is null and <foreach collection="projectUuids" open="(" close=")" item="element" index="index" separator=" or "> gr.component_uuid=#{element, jdbcType=VARCHAR} </foreach> @@ -256,7 +256,7 @@ from groups_users gu inner join group_roles gr on - gr.group_id=gu.group_id + gr.group_uuid=gu.group_uuid where gr.component_uuid=#{componentUuid, jdbcType=VARCHAR} and gr.role=#{role, jdbcType=VARCHAR} @@ -315,7 +315,7 @@ select gr.role from group_roles gr - inner join groups_users gu on gr.group_id = gu.group_id + inner join groups_users gu on gr.group_uuid = gu.group_uuid inner join components p on p.uuid = gr.component_uuid where p.uuid = #{projectUuid, jdbcType=VARCHAR} and @@ -341,7 +341,7 @@ where p.uuid = #{projectUuid, jdbcType=VARCHAR} and p.organization_uuid = gr.organization_uuid - and gr.group_id is null + and gr.group_uuid is null </sql> <select id="selectEmailSubscribersWithGlobalPermission" parameterType="map" resultType="org.sonar.db.EmailSubscriberDto"> @@ -368,7 +368,7 @@ inner join groups_users gu on u.id=gu.user_id inner join group_roles gr on - gr.group_id = gu.group_id + gr.group_uuid = gu.group_uuid and gr.role = #{permission, jdbcType=VARCHAR} and gr.component_uuid is null where @@ -394,7 +394,7 @@ select 1 from components p inner join group_roles gr on gr.component_uuid = p.uuid and gr.organization_uuid = p.organization_uuid - inner join groups_users gu on gu.group_id = gr.group_id + inner join groups_users gu on gu.group_uuid = gr.group_uuid where p.kee = #{projectKey, jdbcType=VARCHAR} and gu.user_id = u.id diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml index c74ed2c7133..a36f6b98883 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml @@ -17,7 +17,7 @@ FROM groups g INNER JOIN group_roles group_role ON - group_role.group_id=g.id + group_role.group_uuid=g.uuid UNION -- Add Anyone group permission SELECT @@ -27,7 +27,7 @@ FROM group_roles group_role where - group_role.group_id IS NULL + group_role.group_uuid IS NULL ) groups where groups.componentUuid in @@ -40,24 +40,24 @@ </select> <select id="selectGroupNamesByQuery" parameterType="map" resultType="string"> - select sub.name, lower(sub.name), sub.groupId + select sub.name, lower(sub.name), sub.groupUuid <include refid="groupsByQuery" /> - group by sub.name, lower(sub.name), sub.groupId - order by case when (count(sub.permission) > 0) then 1 else 2 end asc, lower(sub.name), sub.name, sub.groupId + group by sub.name, lower(sub.name), sub.groupUuid + order by case when (count(sub.permission) > 0) then 1 else 2 end asc, lower(sub.name), sub.name, sub.groupUuid </select> <select id="countGroupsByQuery" parameterType="map" resultType="int"> select count(1) from ( - select distinct sub.groupId + select distinct sub.groupUuid <include refid="groupsByQuery" />) g </select> <sql id="groupsByQuery"> from ( - select g.id as groupId, g.name as name, gr.role as permission, gr.component_uuid as componentUuid, gr.uuid as uuid + select g.uuid as groupUuid, g.name as name, gr.role as permission, gr.component_uuid as componentUuid, gr.uuid as uuid from groups g - left join group_roles gr on g.id = gr.group_id + left join group_roles gr on g.uuid = gr.group_uuid <if test="query.componentUuid == null"> and gr.component_uuid is null </if> @@ -69,7 +69,7 @@ union all - select 0 as groupId, 'Anyone' as name, gr.role as permission, gr.component_uuid as componentUuid, gr.uuid as uuid + select 'Anyone' as groupUuid, 'Anyone' as name, gr.role as permission, gr.component_uuid as componentUuid, gr.uuid as uuid from group_roles gr <where> <if test="query.componentUuid == null"> @@ -80,7 +80,7 @@ </if> <if test="query.withAtLeastOnePermission()"> and gr.organization_uuid = #{query.organizationUuid,jdbcType=VARCHAR} and - gr.group_id is null + gr.group_uuid is null </if> </where> @@ -106,28 +106,28 @@ </where> </sql> - <select id="selectByGroupIds" parameterType="map" resultType="GroupPermission"> - select sub.groupId as groupId, sub.componentUuid as componentUuid, sub.permission as role, sub.organizationUuid as organizationUuid + <select id="selectByGroupUuids" parameterType="map" resultType="GroupPermission"> + select sub.groupUuid as groupUuid, sub.componentUuid as componentUuid, sub.permission as role, sub.organizationUuid as organizationUuid from ( - select gr.group_id as groupId, gr.component_uuid as componentUuid, gr.role as permission, g.name as name, gr.organization_uuid as organizationUuid + select gr.group_uuid as groupUuid, gr.component_uuid as componentUuid, gr.role as permission, g.name as name, gr.organization_uuid as organizationUuid from group_roles gr - inner join groups g ON g.id = gr.group_id + inner join groups g ON g.uuid = gr.group_uuid where gr.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and - gr.group_id is not null + gr.group_uuid is not null union all - select 0 as groupId, gr.component_uuid as componentUuid, gr.role as permission, 'Anyone' as name, gr.organization_uuid as organizationUuid + select 'Anyone' as groupUuid, gr.component_uuid as componentUuid, gr.role as permission, 'Anyone' as name, gr.organization_uuid as organizationUuid from group_roles gr where - gr.group_id is null and + gr.group_uuid is null and gr.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} ) sub where - sub.groupId in - <foreach collection="groupIds" open="(" close=")" item="groupId" separator=","> - #{groupId,jdbcType=INTEGER} + sub.groupUuid in + <foreach collection="groupUuids" open="(" close=")" item="groupUuid" separator=","> + #{groupUuid,jdbcType=VARCHAR} </foreach> <if test="projectUuid != null"> and sub.componentUuid=#{projectUuid,jdbcType=VARCHAR} @@ -144,11 +144,11 @@ gr.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and gr.component_uuid is null and <choose> - <when test="groupId != null"> - gr.group_id = #{groupId,jdbcType=INTEGER} + <when test="groupUuid != null"> + gr.group_uuid = #{groupUuid,jdbcType=VARCHAR} </when> <otherwise> - gr.group_id is null + gr.group_uuid is null </otherwise> </choose> </select> @@ -160,30 +160,30 @@ gr.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and gr.component_uuid = #{projectUuid,jdbcType=VARCHAR} and <choose> - <when test="groupId != null"> - gr.group_id = #{groupId,jdbcType=INTEGER} + <when test="groupUuid != null"> + gr.group_uuid = #{groupUuid,jdbcType=VARCHAR} </when> <otherwise> - gr.group_id is null + gr.group_uuid is null </otherwise> </choose> </select> - <select id="selectAllPermissionsByGroupId" parameterType="map" resultType="GroupPermission"> - select gr.group_id as groupId, gr.component_uuid as componentUuid, gr.role as role, gr.organization_uuid as organizationUuid + <select id="selectAllPermissionsByGroupUuid" parameterType="map" resultType="GroupPermission"> + select gr.group_uuid as groupUuid, gr.component_uuid as componentUuid, gr.role as role, gr.organization_uuid as organizationUuid from group_roles gr where gr.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} - and gr.group_id = #{groupId,jdbcType=INTEGER} + and gr.group_uuid = #{groupUuid,jdbcType=VARCHAR} </select> - <select id="selectGroupIdsWithPermissionOnProjectBut" resultType="Integer"> + <select id="selectGroupUuidsWithPermissionOnProjectBut" resultType="string"> select - distinct gr1.group_id + distinct gr1.group_uuid from group_roles gr1 where gr1.component_uuid = #{projectUuid,jdbcType=VARCHAR} - and gr1.group_id is not null + and gr1.group_uuid is not null and not exists ( select 1 @@ -191,7 +191,7 @@ group_roles gr2 where gr2.component_uuid = gr1.component_uuid - and gr2.group_id = gr1.group_id + and gr2.group_uuid = gr1.group_uuid and gr2.role = #{role,jdbcType=VARCHAR} ) </select> @@ -200,13 +200,13 @@ insert into group_roles ( uuid, organization_uuid, - group_id, + group_uuid, component_uuid, role ) values ( #{uuid,jdbcType=VARCHAR}, #{organizationUuid,jdbcType=VARCHAR}, - #{groupId,jdbcType=INTEGER}, + #{groupUuid,jdbcType=VARCHAR}, #{componentUuid,jdbcType=BIGINT}, #{role,jdbcType=VARCHAR} ) @@ -217,17 +217,17 @@ where component_uuid=#{rootComponentUuid,jdbcType=VARCHAR} </delete> - <delete id="deleteByRootComponentUuidAndGroupId"> + <delete id="deleteByRootComponentUuidAndGroupUuid"> delete from group_roles where component_uuid=#{rootComponentUuid,jdbcType=VARCHAR} <choose> - <when test="groupId != null"> - and group_id = #{groupId,jdbcType=INTEGER} + <when test="groupUuid != null"> + and group_uuid = #{groupUuid,jdbcType=VARCHAR} </when> <otherwise> - and group_id is null + and group_uuid is null </otherwise> </choose> </delete> @@ -255,11 +255,11 @@ </choose> and <choose> - <when test="groupId != null"> - group_id=#{groupId,jdbcType=INTEGER} + <when test="groupUuid != null"> + group_uuid=#{groupUuid,jdbcType=VARCHAR} </when> <otherwise> - group_id is null + group_uuid is null </otherwise> </choose> </delete> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/template/PermissionTemplateMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/template/PermissionTemplateMapper.xml index 6c3707b102a..efaf0721354 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/template/PermissionTemplateMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/permission/template/PermissionTemplateMapper.xml @@ -93,11 +93,11 @@ AND permission_reference = #{permission} AND <choose> - <when test="groupId != null"> - group_id = #{groupId} + <when test="groupUuid != null"> + group_uuid = #{groupUuid} </when> <otherwise> - group_id IS NULL + group_uuid IS NULL </otherwise> </choose> </delete> @@ -108,20 +108,20 @@ </insert> <insert id="insertGroupPermission" parameterType="PermissionTemplateGroup"> - INSERT INTO perm_templates_groups (uuid, template_uuid, group_id, permission_reference, created_at, updated_at) + INSERT INTO perm_templates_groups (uuid, template_uuid, group_uuid, permission_reference, created_at, updated_at) VALUES ( #{uuid,jdbcType=VARCHAR}, #{templateUuid,jdbcType=VARCHAR}, - #{groupId,jdbcType=INTEGER}, + #{groupUuid,jdbcType=VARCHAR}, #{permission,jdbcType=VARCHAR}, #{createdAt,jdbcType=TIMESTAMP}, #{updatedAt,jdbcType=TIMESTAMP} ) </insert> - <delete id="deleteByGroupId" parameterType="int"> + <delete id="deleteByGroupUuid" parameterType="string"> delete from perm_templates_groups - where group_id = #{groupId,jdbcType=INTEGER} + where group_uuid = #{groupUuid,jdbcType=VARCHAR} </delete> <select id="selectUserLoginsByQueryAndTemplate" parameterType="map" resultType="string"> @@ -159,35 +159,35 @@ </sql> <select id="selectGroupNamesByQueryAndTemplate" parameterType="map" resultType="string"> - select groups.name, lower(groups.name), groups.group_id + select groups.name, lower(groups.name), groups.group_uuid <include refid="groupNamesByQueryAndTemplate" /> - group by groups.name, lower(groups.name), groups.group_id - order by case when (count(groups.permission) > 0) then 1 else 2 end asc, lower(groups.name), groups.name, groups.group_id + group by groups.name, lower(groups.name), groups.group_uuid + order by case when (count(groups.permission) > 0) then 1 else 2 end asc, lower(groups.name), groups.name, groups.group_uuid </select> <select id="countGroupNamesByQueryAndTemplate" parameterType="map" resultType="int"> SELECT COUNT(1) FROM ( - SELECT DISTINCT group_id + SELECT DISTINCT group_uuid <include refid="groupNamesByQueryAndTemplate" />) g </select> <sql id="groupNamesByQueryAndTemplate"> FROM (SELECT - g.id AS group_id, + g.uuid AS group_uuid, g.name AS name, ptg.permission_reference AS permission, ptg.template_uuid AS templateUuid FROM groups g LEFT JOIN perm_templates_groups ptg ON - ptg.group_id=g.id + ptg.group_uuid=g.uuid AND ptg.template_uuid=#{templateUuid} where g.organization_uuid=#{query.organizationUuid,jdbcType=VARCHAR} UNION ALL SELECT - 0 AS group_id, + 'Anyone' AS group_uuid, 'Anyone' AS name, ptg.permission_reference AS permission, ptg.template_uuid AS templateUuid @@ -197,7 +197,7 @@ <where> g.organization_uuid=#{query.organizationUuid,jdbcType=VARCHAR} <if test="query.withAtLeastOnePermission()"> - AND ptg.group_id IS NULL + AND ptg.group_uuid IS NULL </if> </where> ) groups @@ -278,7 +278,7 @@ sub.uuid, sub.templateUuid, sub.permission, - sub.groupId, + sub.groupUuid, sub.groupName, sub.createdAt, sub.updatedAt @@ -287,30 +287,30 @@ ptg.uuid, ptg.template_uuid as templateUuid, ptg.permission_reference AS permission, - ptg.group_id AS groupId, + ptg.group_uuid AS groupUuid, g.name AS groupName, ptg.created_at as createdAt, ptg.updated_at as updatedAt FROM perm_templates_groups ptg INNER JOIN groups g ON - g.id=ptg.group_id + g.uuid=ptg.group_uuid UNION ALL SELECT ptg.uuid, ptg.template_uuid as templateUuid, ptg.permission_reference AS permission, - 0 AS groupId, + 'Anyone' AS groupUuid, 'Anyone' AS groupName, ptg.created_at as createdAt, ptg.updated_at as updatedAt FROM perm_templates_groups ptg - WHERE ptg.group_id IS NULL + WHERE ptg.group_uuid IS NULL ) sub <where> sub.templateUuid=#{templateUuid} <if test="!groups.isEmpty()"> AND sub.groupName IN <foreach collection="groups" open="(" close=")" item="group" separator=","> - #{group} + #{group,jdbcType=VARCHAR} </foreach> </if> </where> @@ -329,7 +329,7 @@ -- from template groups except anyone group select ptg.permission_reference as permission_key from perm_templates_groups ptg - inner join groups_users gu on ptg.group_id = gu.group_id + inner join groups_users gu on ptg.group_uuid = gu.group_uuid <where> and gu.user_id=#{userId} and ptg.template_uuid=#{templateUuid} @@ -348,7 +348,7 @@ select ptg.permission_reference as permission_key from perm_templates_groups ptg where ptg.template_uuid=#{templateUuid} - and ptg.group_id IS NULL + and ptg.group_uuid IS NULL </select> <select id="usersCountByTemplateUuidAndPermission" parameterType="map" @@ -372,13 +372,13 @@ FROM (SELECT g.name as name, ptg.permission_reference as permission, ptg.template_uuid as templateUuid FROM groups g - INNER JOIN perm_templates_groups ptg ON ptg.group_id=g.id + INNER JOIN perm_templates_groups ptg ON ptg.group_uuid=g.uuid UNION -- Add Anyone group permission SELECT #{anyoneGroup} as name, ptg.permission_reference as permission, ptg.template_uuid as templateUuid FROM perm_templates_groups ptg <where> - AND ptg.group_id IS NULL + AND ptg.group_uuid IS NULL </where> ) groups <where> @@ -396,11 +396,11 @@ where ptg.template_uuid = #{templateUuid} and ptg.permission_reference = #{permission} and - <if test="groupId == null"> - ptg.group_id is null + <if test="groupUuid == null"> + ptg.group_uuid is null </if> - <if test="groupId != null"> - ptg.group_id = #{groupId} + <if test="groupUuid != null"> + ptg.group_uuid = #{groupUuid} </if> </select> @@ -413,19 +413,19 @@ organization_uuid = #{organizationUuid,jdbcType=VARCHAR} </select> - <select id="selectAllGroupPermissionTemplatesByGroupId" parameterType="Long" resultType="PermissionTemplateGroup"> + <select id="selectAllGroupPermissionTemplatesByGroupUuid" parameterType="string" resultType="PermissionTemplateGroup"> SELECT ptg.uuid, ptg.template_uuid as templateUuid, ptg.permission_reference AS permission, - ptg.group_id AS groupId, + ptg.group_uuid AS groupUuid, g.name AS groupName, ptg.created_at as createdAt, ptg.updated_at as updatedAt FROM perm_templates_groups ptg - INNER JOIN groups g ON g.id=ptg.group_id + INNER JOIN groups g ON g.uuid=ptg.group_uuid <where> - ptg.group_id=#{groupId,jdbcType=INTEGER} + ptg.group_uuid=#{groupUuid,jdbcType=VARCHAR} </where> </select> </mapper> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.xml index 9a023f45047..ccd81869b94 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/QProfileEditGroupsMapper.xml @@ -5,7 +5,7 @@ <sql id="sqlColumns"> qeg.uuid as "uuid", - qeg.group_id as "groupId", + qeg.group_uuid as "groupUuid", qeg.qprofile_uuid as "qProfileUuid" </sql> @@ -14,19 +14,19 @@ <include refid="sqlColumns"/> from qprofile_edit_groups qeg where - <foreach collection="groupIds" open="(" close=")" item="groupId" separator=" or "> - qeg.group_id = #{groupId, jdbcType=INTEGER} + <foreach collection="groupUuids" open="(" close=")" item="groupUuid" separator=" or "> + qeg.group_uuid = #{groupUuid, jdbcType=VARCHAR} </foreach> and qeg.qprofile_uuid = #{qProfileUuid, jdbcType=VARCHAR} </select> <select id="countByQuery" resultType="int"> - select count(g.id) + select count(g.uuid) <include refid="sqlSelectByQuery" /> </select> <select id="selectByQuery" parameterType="map" resultType="org.sonar.db.qualityprofile.GroupMembershipDto"> - SELECT g.id as groupId, g.name as name, qeg.uuid as uuid + SELECT g.uuid as groupUuid, g.name as name, qeg.uuid as uuid <include refid="sqlSelectByQuery"/> ORDER BY g.name ASC LIMIT #{pagination.pageSize,jdbcType=INTEGER} @@ -36,7 +36,7 @@ <select id="selectByQuery" parameterType="map" resultType="org.sonar.db.qualityprofile.GroupMembershipDto" databaseId="mssql"> select * from ( select row_number() over(order by g.name asc) as number, - g.id as groupId, g.name as name, qeg.uuid as uuid + g.uuid as groupUuid, g.name as name, qeg.uuid as uuid <include refid="sqlSelectByQuery" /> ) as query where @@ -47,7 +47,7 @@ <select id="selectByQuery" parameterType="map" resultType="org.sonar.db.qualityprofile.GroupMembershipDto" databaseId="oracle"> select * from ( select rownum as rn, t.* from ( - select g.id as groupId, g.name as name, qeg.uuid as uuid + select g.uuid as groupUuid, g.name as name, qeg.uuid as uuid <include refid="sqlSelectByQuery"/> order by g.name ASC ) t @@ -58,7 +58,7 @@ <sql id="sqlSelectByQuery"> FROM groups g - LEFT JOIN qprofile_edit_groups qeg ON qeg.group_id=g.id AND qeg.qprofile_uuid=#{query.qProfileUuid, jdbcType=VARCHAR} + LEFT JOIN qprofile_edit_groups qeg ON qeg.group_uuid=g.uuid AND qeg.qprofile_uuid=#{query.qProfileUuid, jdbcType=VARCHAR} <where> AND g.organization_uuid=#{query.organizationUuid,jdbcType=VARCHAR} <choose> @@ -80,19 +80,19 @@ from qprofile_edit_groups qeg inner join org_qprofiles oq on qeg.qprofile_uuid=oq.uuid and oq.organization_uuid=#{organizationUuid, jdbcType=VARCHAR} <where> - qeg.group_id in <foreach collection="groupIds" open="(" close=")" item="groupId" separator=",">#{groupId, jdbcType=INTEGER}</foreach> + qeg.group_uuid in <foreach collection="groupUuids" open="(" close=")" item="groupUuid" separator=",">#{groupUuid, jdbcType=VARCHAR}</foreach> </where> </select> <insert id="insert" useGeneratedKeys="false" parameterType="map"> insert into qprofile_edit_groups( uuid, - group_id, + group_uuid, qprofile_uuid, created_at ) values ( #{dto.uuid, jdbcType=VARCHAR}, - #{dto.groupId, jdbcType=INTEGER}, + #{dto.groupUuid, jdbcType=VARCHAR}, #{dto.qProfileUuid, jdbcType=VARCHAR}, #{now, jdbcType=BIGINT} ) @@ -101,7 +101,7 @@ <delete id="delete" parameterType="map"> delete from qprofile_edit_groups where qprofile_uuid = #{qProfileUuid, jdbcType=VARCHAR} - and group_id = #{groupId, jdbcType=INTEGER} + and group_uuid = #{groupUuid, jdbcType=VARCHAR} </delete> <delete id="deleteByQProfiles" parameterType="map"> @@ -111,7 +111,7 @@ <delete id="deleteByGroup" parameterType="map"> delete from qprofile_edit_groups - where group_id = #{groupId, jdbcType=INTEGER} + where group_uuid = #{groupUuid, jdbcType=VARCHAR} </delete> </mapper> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMapper.xml index d9d5850eb24..fe8ad8de0f2 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMapper.xml @@ -5,7 +5,7 @@ <mapper namespace="org.sonar.db.user.GroupMapper"> <sql id="groupColumns"> - g.id as id, + g.uuid as uuid, g.name as name, g.description as description, g.organization_uuid as organizationUuid, @@ -20,29 +20,29 @@ where g.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and g.name = #{name,jdbcType=VARCHAR} </select> - <select id="selectByIds" parameterType="int" resultType="Group"> + <select id="selectByUuids" parameterType="String" resultType="Group"> select <include refid="groupColumns"/> from groups g - where g.id in - <foreach item="id" index="index" collection="ids" open="(" separator="," close=")"> - #{id,jdbcType=BIGINT} + where g.uuid in + <foreach item="uuid" index="index" collection="uuids" open="(" separator="," close=")"> + #{uuid,jdbcType=VARCHAR} </foreach> </select> - <select id="selectById" parameterType="int" resultType="Group"> + <select id="selectByUuid" parameterType="String" resultType="Group"> SELECT <include refid="groupColumns"/> FROM groups g <where> - g.id=#{id,jdbcType=BIGINT} + g.uuid=#{uuid,jdbcType=VARCHAR} </where> </select> - <delete id="deleteById" parameterType="int"> + <delete id="deleteByUuid" parameterType="String"> DELETE FROM groups <where> - id=#{id,jdbcType=BIGINT} + uuid=#{uuid,jdbcType=VARCHAR} </where> </delete> @@ -57,7 +57,7 @@ select <include refid="groupColumns"/> from groups g - inner join groups_users gu on gu.group_id = g.id + inner join groups_users gu on gu.group_uuid = g.uuid inner join users u on u.id = gu.user_id where u.login=#{login,jdbcType=VARCHAR} </select> @@ -74,14 +74,16 @@ </foreach> </select> - <insert id="insert" parameterType="Group" keyColumn="id" useGeneratedKeys="true" keyProperty="id"> + <insert id="insert" parameterType="Group" useGeneratedKeys="false"> insert into groups ( + uuid, organization_uuid, name, description, created_at, updated_at ) values ( + #{uuid,jdbcType=VARCHAR}, #{organizationUuid,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, #{description,jdbcType=VARCHAR}, @@ -95,7 +97,7 @@ name=#{name,jdbcType=VARCHAR}, description=#{description,jdbcType=VARCHAR}, updated_at=#{updatedAt,jdbcType=TIMESTAMP} - WHERE id=#{id} + WHERE uuid=#{uuid} </update> <select id="selectByQuery" parameterType="map" resultType="Group"> @@ -120,13 +122,13 @@ </if> </select> - <select id="countGroupByOrganizationAndId" parameterType="map" resultType="int"> + <select id="countGroupByOrganizationAndUuid" parameterType="map" resultType="int"> select count(1) from groups g where g.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} - and g.id = #{groupId,jdbcType=INTEGER} + and g.uuid = #{groupUuid,jdbcType=VARCHAR} </select> <select id="selectByOrganizationUuid" parameterType="map" resultType="Group"> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMembershipMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMembershipMapper.xml index a16cbdf73d0..c22763782f3 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMembershipMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/GroupMembershipMapper.xml @@ -5,7 +5,7 @@ <sql id="commonClauses"> FROM groups g - LEFT JOIN groups_users gu ON gu.group_id=g.id AND gu.user_id=#{userId} + LEFT JOIN groups_users gu ON gu.group_uuid=g.uuid AND gu.user_id=#{userId} <where> AND g.organization_uuid=#{organizationUuid} <choose> @@ -23,24 +23,24 @@ </sql> <select id="selectGroups" parameterType="map" resultType="GroupMembership"> - SELECT g.id as id, g.name as name, g.description as description, gu.user_id as userId + SELECT g.uuid as uuid, g.name as name, g.description as description, gu.user_id as userId <include refid="commonClauses"/> ORDER BY g.name </select> <select id="countGroups" parameterType="map" resultType="int"> - SELECT COUNT(g.id) + SELECT COUNT(g.uuid) <include refid="commonClauses"/> </select> <select id="countUsersByGroup" parameterType="int" resultType="org.sonar.db.user.GroupUserCount"> SELECT g.name as groupName, count(gu.user_id) as userCount FROM groups g - LEFT JOIN groups_users gu ON gu.group_id=g.id + LEFT JOIN groups_users gu ON gu.group_uuid=g.uuid <where> - g.id in - <foreach collection="groupIds" open="(" close=")" item="id" separator=","> - #{id} + g.uuid in + <foreach collection="groupUuids" open="(" close=")" item="uuid" separator=","> + #{uuid} </foreach> </where> GROUP BY g.name @@ -50,7 +50,7 @@ SELECT u.login as login, g.name as groupName FROM users u LEFT JOIN groups_users gu ON gu.user_id=u.id - INNER JOIN groups g ON gu.group_id=g.id + INNER JOIN groups g ON gu.group_uuid=g.uuid <where> u.login in <foreach collection="logins" open="(" close=")" item="login" separator=","> @@ -64,7 +64,7 @@ SELECT u.login as login, g.name as groupName FROM users u LEFT JOIN groups_users gu ON gu.user_id=u.id - INNER JOIN groups g ON gu.group_id=g.id + INNER JOIN groups g ON gu.group_uuid=g.uuid <where> u.login in <foreach collection="logins" open="(" close=")" item="login" separator=","> @@ -77,15 +77,15 @@ <sql id="userCommonClauses"> FROM users u - LEFT JOIN groups_users gu ON gu.user_id=u.id AND gu.group_id=#{groupId} + LEFT JOIN groups_users gu ON gu.user_id=u.id AND gu.group_uuid=#{groupUuid} INNER JOIN organization_members om ON u.id=om.user_id AND om.organization_uuid=#{organizationUuid} <where> <choose> <when test="query.membership() == 'IN'"> - AND gu.group_id IS NOT NULL + AND gu.group_uuid IS NOT NULL </when> <when test="query.membership() == 'OUT'"> - AND gu.group_id IS NULL + AND gu.group_uuid IS NULL </when> </choose> <if test="query.memberSearch() != null"> @@ -99,7 +99,7 @@ </sql> <select id="selectMembers" parameterType="map" resultType="org.sonar.db.user.UserMembershipDto"> - SELECT u.id as id, u.login as login, u.name as name, gu.group_id as groupId + SELECT u.id as id, u.login as login, u.name as name, gu.group_uuid as groupUuid <include refid="userCommonClauses"/> ORDER BY u.name ASC </select> @@ -109,8 +109,8 @@ <include refid="userCommonClauses"/> </select> - <select id="selectGroupIdsByUserId" parameterType="map" resultType="int"> - select group_id + <select id="selectGroupUuidsByUserId" parameterType="map" resultType="string"> + select group_uuid from groups_users where user_id = #{userId} </select> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/RoleMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/RoleMapper.xml index abd64ce07f0..2350b9700db 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/RoleMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/RoleMapper.xml @@ -18,7 +18,7 @@ from group_roles gr inner join groups_users gu on - gr.group_id=gu.group_id + gr.group_uuid=gu.group_uuid where gr.role = #{permission,jdbcType=VARCHAR} and gr.component_uuid is not null @@ -27,10 +27,10 @@ component_uuid </select> - <delete id="deleteGroupRolesByGroupId" parameterType="int"> + <delete id="deleteGroupRolesByGroupUuid" parameterType="String"> delete from group_roles where - group_id=#{id,jdbcType=INTEGER} + group_uuid=#{uuid,jdbcType=VARCHAR} </delete> </mapper> diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/UserGroupMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/UserGroupMapper.xml index 1f7a7ac7d41..2cf7f6530f4 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/user/UserGroupMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/user/UserGroupMapper.xml @@ -6,28 +6,28 @@ <insert id="insert" parameterType="UserGroup" useGeneratedKeys="false"> insert into groups_users ( user_id, - group_id + group_uuid ) values ( #{userId,jdbcType=INTEGER}, - #{groupId,jdbcType=INTEGER} + #{groupUuid,jdbcType=VARCHAR} ) </insert> <delete id="delete" parameterType="map"> delete from groups_users where user_id = #{userId,jdbcType=INTEGER} and - group_id = #{groupId,jdbcType=INTEGER} + group_uuid = #{groupUuid,jdbcType=VARCHAR} </delete> - <delete id="deleteByGroupId" parameterType="int"> + <delete id="deleteByGroupUuid" parameterType="string"> delete from groups_users - where group_id = #{groupId,jdbcType=INTEGER} + where group_uuid = #{groupUuid,jdbcType=VARCHAR} </delete> <delete id="deleteByOrganizationAndUser" parameterType="map"> delete from groups_users where user_id = #{userId,jdbcType=INTEGER} and - group_id in (select id from groups where organization_uuid=#{organizationUuid,jdbcType=VARCHAR}) + group_uuid in (select uuid from groups where organization_uuid=#{organizationUuid,jdbcType=VARCHAR}) </delete> <delete id="deleteByUserId" parameterType="int"> diff --git a/server/sonar-db-dao/src/schema/schema-sq.ddl b/server/sonar-db-dao/src/schema/schema-sq.ddl index 9f21471b46c..2f90adf0194 100644 --- a/server/sonar-db-dao/src/schema/schema-sq.ddl +++ b/server/sonar-db-dao/src/schema/schema-sq.ddl @@ -313,32 +313,32 @@ CREATE INDEX "FILE_SOURCES_UPDATED_AT" ON "FILE_SOURCES"("UPDATED_AT"); CREATE TABLE "GROUP_ROLES"( "ORGANIZATION_UUID" VARCHAR(40) NOT NULL, - "GROUP_ID" INTEGER, "ROLE" VARCHAR(64) NOT NULL, "COMPONENT_UUID" VARCHAR(40), - "UUID" VARCHAR(40) NOT NULL + "UUID" VARCHAR(40) NOT NULL, + "GROUP_UUID" VARCHAR(40) ); ALTER TABLE "GROUP_ROLES" ADD CONSTRAINT "PK_GROUP_ROLES" PRIMARY KEY("UUID"); CREATE INDEX "GROUP_ROLES_COMPONENT_UUID" ON "GROUP_ROLES"("COMPONENT_UUID"); -CREATE UNIQUE INDEX "UNIQ_GROUP_ROLES" ON "GROUP_ROLES"("ORGANIZATION_UUID", "GROUP_ID", "COMPONENT_UUID", "ROLE"); +CREATE UNIQUE INDEX "UNIQ_GROUP_ROLES" ON "GROUP_ROLES"("ORGANIZATION_UUID", "GROUP_UUID", "COMPONENT_UUID", "ROLE"); CREATE TABLE "GROUPS"( - "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1), "ORGANIZATION_UUID" VARCHAR(40) NOT NULL, "NAME" VARCHAR(500), "DESCRIPTION" VARCHAR(200), "CREATED_AT" TIMESTAMP, - "UPDATED_AT" TIMESTAMP + "UPDATED_AT" TIMESTAMP, + "UUID" VARCHAR(40) NOT NULL ); -ALTER TABLE "GROUPS" ADD CONSTRAINT "PK_GROUPS" PRIMARY KEY("ID"); +ALTER TABLE "GROUPS" ADD CONSTRAINT "PK_GROUPS" PRIMARY KEY("UUID"); CREATE TABLE "GROUPS_USERS"( "USER_ID" BIGINT, - "GROUP_ID" BIGINT + "GROUP_UUID" VARCHAR(40) NOT NULL ); CREATE INDEX "INDEX_GROUPS_USERS_ON_USER_ID" ON "GROUPS_USERS"("USER_ID"); -CREATE INDEX "INDEX_GROUPS_USERS_ON_GROUP_ID" ON "GROUPS_USERS"("GROUP_ID"); -CREATE UNIQUE INDEX "GROUPS_USERS_UNIQUE" ON "GROUPS_USERS"("GROUP_ID", "USER_ID"); +CREATE INDEX "INDEX_GROUPS_USERS_GROUP_UUID" ON "GROUPS_USERS"("GROUP_UUID"); +CREATE UNIQUE INDEX "GROUPS_USERS_UNIQUE" ON "GROUPS_USERS"("GROUP_UUID", "USER_ID"); CREATE TABLE "INTERNAL_COMPONENT_PROPS"( "UUID" VARCHAR(40) NOT NULL, @@ -537,7 +537,6 @@ CREATE TABLE "ORGANIZATIONS"( "URL" VARCHAR(256), "AVATAR_URL" VARCHAR(256), "GUARDED" BOOLEAN, - "DEFAULT_GROUP_ID" INTEGER, "DEFAULT_QUALITY_GATE_UUID" VARCHAR(40) NOT NULL, "DEFAULT_PERM_TEMPLATE_PROJECT" VARCHAR(40), "DEFAULT_PERM_TEMPLATE_APP" VARCHAR(40), @@ -545,18 +544,27 @@ CREATE TABLE "ORGANIZATIONS"( "NEW_PROJECT_PRIVATE" BOOLEAN NOT NULL, "SUBSCRIPTION" VARCHAR(40) NOT NULL, "CREATED_AT" BIGINT NOT NULL, - "UPDATED_AT" BIGINT NOT NULL + "UPDATED_AT" BIGINT NOT NULL, + "DEFAULT_GROUP_UUID" VARCHAR(40) ); ALTER TABLE "ORGANIZATIONS" ADD CONSTRAINT "PK_ORGANIZATIONS" PRIMARY KEY("UUID"); CREATE UNIQUE INDEX "ORGANIZATION_KEY" ON "ORGANIZATIONS"("KEE"); CREATE TABLE "PERM_TEMPLATES_GROUPS"( +<<<<<<< HEAD "GROUP_ID" INTEGER, +======= + "TEMPLATE_ID" INTEGER NOT NULL, +>>>>>>> SONAR-13221 change PK of GROUPS and update FKs "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL, "CREATED_AT" TIMESTAMP, "UPDATED_AT" TIMESTAMP, "UUID" VARCHAR(40) NOT NULL, +<<<<<<< HEAD "TEMPLATE_UUID" VARCHAR(40) NOT NULL +======= + "GROUP_UUID" VARCHAR(40) +>>>>>>> SONAR-13221 change PK of GROUPS and update FKs ); ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID"); @@ -750,13 +758,13 @@ CREATE INDEX "QP_CHANGES_RULES_PROFILE_UUID" ON "QPROFILE_CHANGES"("RULES_PROFIL CREATE TABLE "QPROFILE_EDIT_GROUPS"( "UUID" VARCHAR(40) NOT NULL, - "GROUP_ID" INTEGER NOT NULL, "QPROFILE_UUID" VARCHAR(255) NOT NULL, - "CREATED_AT" BIGINT NOT NULL + "CREATED_AT" BIGINT NOT NULL, + "GROUP_UUID" VARCHAR(40) NOT NULL ); ALTER TABLE "QPROFILE_EDIT_GROUPS" ADD CONSTRAINT "PK_QPROFILE_EDIT_GROUPS" PRIMARY KEY("UUID"); CREATE INDEX "QPROFILE_EDIT_GROUPS_QPROFILE" ON "QPROFILE_EDIT_GROUPS"("QPROFILE_UUID"); -CREATE UNIQUE INDEX "QPROFILE_EDIT_GROUPS_UNIQUE" ON "QPROFILE_EDIT_GROUPS"("GROUP_ID", "QPROFILE_UUID"); +CREATE UNIQUE INDEX "QPROFILE_EDIT_GROUPS_UNIQUE" ON "QPROFILE_EDIT_GROUPS"("GROUP_UUID", "QPROFILE_UUID"); CREATE TABLE "QPROFILE_EDIT_USERS"( "UUID" VARCHAR(40) NOT NULL, diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java index d6fa90971d9..648fd9bfd32 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java @@ -679,46 +679,46 @@ public class OrganizationDaoTest { } @Test - public void getDefaultGroupId_returns_empty_when_default_group_id_is_null() { - insertOrganization(ORGANIZATION_DTO_1.setDefaultGroupId(null)); + public void getDefaultGroupUuid_returns_empty_when_default_group_uuid_is_null() { + insertOrganization(ORGANIZATION_DTO_1.setDefaultGroupUuid(null)); - assertThat(underTest.getDefaultGroupId(dbSession, ORGANIZATION_DTO_1.getUuid())).isEmpty(); + assertThat(underTest.getDefaultGroupUuid(dbSession, ORGANIZATION_DTO_1.getUuid())).isEmpty(); } @Test - public void getDefaultGroupId_returns_data_when_default_group_id_is_not_null() { + public void getDefaultGroupUuid_returns_data_when_default_group_uuid_is_not_null() { when(system2.now()).thenReturn(DATE_3); insertOrganization(ORGANIZATION_DTO_1); - underTest.setDefaultGroupId(dbSession, ORGANIZATION_DTO_1.getUuid(), GroupTesting.newGroupDto().setId(10)); + underTest.setDefaultGroupUuid(dbSession, ORGANIZATION_DTO_1.getUuid(), GroupTesting.newGroupDto().setUuid("10")); - Optional<Integer> optional = underTest.getDefaultGroupId(dbSession, ORGANIZATION_DTO_1.getUuid()); + Optional<String> optional = underTest.getDefaultGroupUuid(dbSession, ORGANIZATION_DTO_1.getUuid()); assertThat(optional).isNotEmpty(); - assertThat(optional.get()).isEqualTo(10); + assertThat(optional.get()).isEqualTo("10"); verifyOrganizationUpdatedAt(ORGANIZATION_DTO_1.getUuid(), DATE_3); } @Test - public void setDefaultGroupId_throws_NPE_when_uuid_is_null() { + public void setDefaultGroupUuid_throws_NPE_when_uuid_is_null() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("uuid can't be null"); - underTest.setDefaultGroupId(dbSession, null, GroupTesting.newGroupDto().setId(10)); + underTest.setDefaultGroupUuid(dbSession, null, GroupTesting.newGroupDto().setUuid("10")); } @Test - public void setDefaultGroupId_throws_NPE_when_default_group_is_null() { + public void setDefaultGroupUuid_throws_NPE_when_default_group_is_null() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("Default group cannot be null"); - underTest.setDefaultGroupId(dbSession, "uuid", null); + underTest.setDefaultGroupUuid(dbSession, "uuid", null); } @Test - public void setDefaultGroupId_throws_NPE_when_default_group_id_is_null() { + public void setDefaultGroupUuid_throws_NPE_when_default_group_uuid_is_null() { expectedException.expect(NullPointerException.class); - expectedException.expectMessage("Default group id cannot be null"); + expectedException.expectMessage("Default group uuid cannot be null"); - underTest.setDefaultGroupId(dbSession, "uuid", GroupTesting.newGroupDto().setId(null)); + underTest.setDefaultGroupUuid(dbSession, "uuid", GroupTesting.newGroupDto().setUuid(null)); } @Test @@ -801,7 +801,7 @@ public class OrganizationDaoTest { .setName("new_name") .setDescription("new_desc") .setAvatarUrl("new_avatar") - .setDefaultGroupId(11) + .setDefaultGroupUuid("11") .setSubscription(PAID) .setUrl("new_url") .setCreatedAt(2_000L) diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/AuthorizationDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/AuthorizationDaoTest.java index 00ca9b3c9ed..fde6aab7ac8 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/AuthorizationDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/AuthorizationDaoTest.java @@ -58,6 +58,7 @@ public class AuthorizationDaoTest { private static final String PROJECT_UUID = "uuid"; private static final int MISSING_ID = -1; + private static final String MISSING_UUID = "unkown"; private static final String A_PERMISSION = "a-permission"; private static final String DOES_NOT_EXIST = "does-not-exist"; @@ -174,19 +175,19 @@ public class AuthorizationDaoTest { // excluding group "g1" -> remain u1, u3 and u4 assertThat(underTest.countUsersWithGlobalPermissionExcludingGroup(db.getSession(), - organization.getUuid(), "perm1", group1.getId())).isEqualTo(3); + organization.getUuid(), "perm1", group1.getUuid())).isEqualTo(3); // excluding group "g2" -> remain u1, u2 and u4 assertThat(underTest.countUsersWithGlobalPermissionExcludingGroup(db.getSession(), - organization.getUuid(), "perm1", group2.getId())).isEqualTo(3); + organization.getUuid(), "perm1", group2.getUuid())).isEqualTo(3); // excluding group "g3" -> remain u1, u2, u3 and u4 assertThat(underTest.countUsersWithGlobalPermissionExcludingGroup(db.getSession(), - organization.getUuid(), "perm1", group3.getId())).isEqualTo(4); + organization.getUuid(), "perm1", group3.getUuid())).isEqualTo(4); // nobody has the permission assertThat(underTest.countUsersWithGlobalPermissionExcludingGroup(db.getSession(), - organization.getUuid(), "missingPermission", group1.getId())).isEqualTo(0); + organization.getUuid(), "missingPermission", group1.getUuid())).isEqualTo(0); } @Test @@ -224,7 +225,7 @@ public class AuthorizationDaoTest { // nobody has the permission assertThat(underTest.countUsersWithGlobalPermissionExcludingUser(db.getSession(), - organization.getUuid(), "missingPermission", group1.getId())).isEqualTo(0); + organization.getUuid(), "missingPermission", 123)).isEqualTo(0); } @Test @@ -726,21 +727,21 @@ public class AuthorizationDaoTest { db.users().insertMember(group1, u3); // excluding u2 membership --> remain u1 and u3 - int count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, group1.getId(), u2.getId()); + int count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, group1.getUuid(), u2.getId()); assertThat(count).isEqualTo(2); // excluding unknown memberships - count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, group1.getId(), MISSING_ID); + count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, group1.getUuid(), MISSING_ID); assertThat(count).isEqualTo(3); - count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, MISSING_ID, u2.getId()); + count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), A_PERMISSION, MISSING_UUID, u2.getId()); assertThat(count).isEqualTo(3); // another organization - count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, DOES_NOT_EXIST, A_PERMISSION, group1.getId(), u2.getId()); + count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, DOES_NOT_EXIST, A_PERMISSION, group1.getUuid(), u2.getId()); assertThat(count).isEqualTo(0); // another permission - count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), DOES_NOT_EXIST, group1.getId(), u2.getId()); + count = underTest.countUsersWithGlobalPermissionExcludingGroupMember(dbSession, organization.getUuid(), DOES_NOT_EXIST, group1.getUuid(), u2.getId()); assertThat(count).isEqualTo(0); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java index 443b3b7374c..2dbd6112ecc 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java @@ -55,8 +55,8 @@ import static org.sonar.db.permission.PermissionQuery.DEFAULT_PAGE_SIZE; public class GroupPermissionDaoTest { - private static final int ANYONE_ID = 0; - private static final int MISSING_ID = -1; + private static final String ANYONE_UUID = "Anyone"; + private static final String MISSING_UUID = "-1"; @Rule public DbTester db = DbTester.create(System2.INSTANCE); @@ -305,7 +305,7 @@ public class GroupPermissionDaoTest { } @Test - public void selectByGroupIds_on_global_permissions() { + public void selectByGroupUuids_on_global_permissions() { OrganizationDto organizationDto = db.organizations().insert(); GroupDto group1 = db.users().insertGroup(organizationDto, "Group-1"); @@ -322,29 +322,29 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnAnyone(organizationDto, SCAN); db.users().insertPermissionOnAnyone(organizationDto, PROVISION_PROJECTS); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(group1.getId()), null)) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group1.getId(), SCAN_EXECUTION, null)); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(group1.getUuid()), null)) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group1.getUuid(), SCAN_EXECUTION, null)); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(group2.getId()), null)).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(group2.getUuid()), null)).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(group3.getId()), null)) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group3.getId(), ADMINISTER.getKey(), null)); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(group3.getUuid()), null)) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group3.getUuid(), ADMINISTER.getKey(), null)); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(ANYONE_ID), null)) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(ANYONE_UUID), null)) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) .containsOnly( - tuple(0, SCAN.getKey(), null), - tuple(0, PROVISION_PROJECTS.getKey(), null)); + tuple(ANYONE_UUID, SCAN.getKey(), null), + tuple(ANYONE_UUID, PROVISION_PROJECTS.getKey(), null)); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(group1.getId(), group2.getId(), ANYONE_ID), null)).hasSize(3); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(MISSING_ID), null)).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), Collections.emptyList(), null)).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(group1.getUuid(), group2.getUuid(), ANYONE_UUID), null)).hasSize(3); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), asList(MISSING_UUID), null)).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, organizationDto.getUuid(), Collections.emptyList(), null)).isEmpty(); } @Test - public void selectByGroupIds_on_public_projects() { + public void selectByGroupUuids_on_public_projects() { OrganizationDto org = db.organizations().insert(); GroupDto group1 = db.users().insertGroup(org, "Group-1"); db.users().insertPermissionOnGroup(group1, "p1"); @@ -360,28 +360,28 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnAnyone(org, "p3"); db.users().insertProjectPermissionOnAnyone("p4", project); - assertThat(underTest.selectByGroupIds(dbSession, defaultOrganizationUuid, singletonList(group1.getId()), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, defaultOrganizationUuid, singletonList(group1.getUuid()), project.uuid())).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group2.getId()), project.uuid())) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group2.getId(), "p2", project.uuid())); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group2.getUuid()), project.uuid())) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group2.getUuid(), "p2", project.uuid())); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group3.getId()), project.uuid())) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group3.getId(), "p2", project.uuid())); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group3.getUuid()), project.uuid())) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group3.getUuid(), "p2", project.uuid())); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(ANYONE_ID), project.uuid())) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(0, "p4", project.uuid())); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(ANYONE_UUID), project.uuid())) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(ANYONE_UUID, "p4", project.uuid())); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), asList(group1.getId(), group2.getId(), ANYONE_ID), project.uuid())).hasSize(2); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(MISSING_ID), project.uuid())).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group1.getId()), "123")).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), Collections.emptyList(), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), asList(group1.getUuid(), group2.getUuid(), ANYONE_UUID), project.uuid())).hasSize(2); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(MISSING_UUID), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group1.getUuid()), "123")).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), Collections.emptyList(), project.uuid())).isEmpty(); } @Test - public void selectByGroupIds_on_private_projects() { + public void selectByGroupUuids_on_private_projects() { OrganizationDto org = db.organizations().insert(); GroupDto group1 = db.users().insertGroup(org, "Group-1"); db.users().insertPermissionOnGroup(group1, PROVISION_PROJECTS); @@ -396,23 +396,23 @@ public class GroupPermissionDaoTest { // Anyone group db.users().insertPermissionOnAnyone(org, SCAN); - assertThat(underTest.selectByGroupIds(dbSession, defaultOrganizationUuid, singletonList(group1.getId()), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, defaultOrganizationUuid, singletonList(group1.getUuid()), project.uuid())).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group2.getId()), project.uuid())) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group2.getId(), USER, project.uuid())); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group2.getUuid()), project.uuid())) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group2.getUuid(), USER, project.uuid())); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group3.getId()), project.uuid())) - .extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) - .containsOnly(tuple(group3.getId(), USER, project.uuid())); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group3.getUuid()), project.uuid())) + .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getComponentUuid) + .containsOnly(tuple(group3.getUuid(), USER, project.uuid())); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(ANYONE_ID), project.uuid())) + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(ANYONE_UUID), project.uuid())) .isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), asList(group1.getId(), group2.getId(), ANYONE_ID), project.uuid())).hasSize(1); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(MISSING_ID), project.uuid())).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(group1.getId()), "123")).isEmpty(); - assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), Collections.emptyList(), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), asList(group1.getUuid(), group2.getUuid(), ANYONE_UUID), project.uuid())).hasSize(1); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(MISSING_UUID), project.uuid())).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), singletonList(group1.getUuid()), "123")).isEmpty(); + assertThat(underTest.selectByGroupUuids(dbSession, org.getUuid(), Collections.emptyList(), project.uuid())).isEmpty(); } @Test @@ -430,12 +430,12 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm5", project); db.users().insertProjectPermissionOnAnyone("perm6", project); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org1.getUuid(), group1.getId())).containsOnly("perm2", "perm3"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org2.getUuid(), group2.getId())).containsOnly("perm4"); + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org1.getUuid(), group1.getUuid())).containsOnly("perm2", "perm3"); + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org2.getUuid(), group2.getUuid())).containsOnly("perm4"); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org1.getUuid(), null)).containsOnly("perm1"); // group1 is not in org2 - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org2.getUuid(), group1.getId())).isEmpty(); + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org2.getUuid(), group1.getUuid())).isEmpty(); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, org2.getUuid(), null)).isEmpty(); } @@ -453,9 +453,9 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm5", project2); db.users().insertProjectPermissionOnAnyone("perm6", project1); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getId(), project1.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getUuid(), project1.uuid())) .containsOnly("perm3", "perm4"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getId(), project2.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getUuid(), project2.uuid())) .containsOnly("perm5"); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), null, project1.uuid())) .containsOnly("perm6"); @@ -476,9 +476,9 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm4", project1); db.users().insertProjectPermissionOnGroup(group1, "perm5", project2); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getId(), project1.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getUuid(), project1.uuid())) .containsOnly("perm3", "perm4"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getId(), project2.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), group1.getUuid(), project2.uuid())) .containsOnly("perm5"); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, org1.getUuid(), null, project1.uuid())) .isEmpty(); @@ -487,7 +487,7 @@ public class GroupPermissionDaoTest { } @Test - public void selectAllPermissionsByGroupId_on_public_project() { + public void selectAllPermissionsByGroupUuid_on_public_project() { OrganizationDto org1 = db.organizations().insert(); GroupDto group1 = db.users().insertGroup(org1, "group1"); ComponentDto project1 = db.components().insertPublicProject(org1); @@ -500,14 +500,14 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnAnyone("perm6", project1); List<GroupPermissionDto> result = new ArrayList<>(); - underTest.selectAllPermissionsByGroupId(dbSession, org1.getUuid(), group1.getId(), context -> result.add((GroupPermissionDto) context.getResultObject())); + underTest.selectAllPermissionsByGroupUuid(dbSession, org1.getUuid(), group1.getUuid(), context -> result.add((GroupPermissionDto) context.getResultObject())); assertThat(result).extracting(GroupPermissionDto::getComponentUuid, GroupPermissionDto::getRole).containsOnly( tuple(null, "perm2"), tuple(project1.uuid(), "perm3"), tuple(project1.uuid(), "perm4"), tuple(project2.uuid(), "perm5")); } @Test - public void selectAllPermissionsByGroupId_on_private_project() { + public void selectAllPermissionsByGroupUuid_on_private_project() { OrganizationDto org1 = db.organizations().insert(); GroupDto group1 = db.users().insertGroup(org1, "group1"); ComponentDto project1 = db.components().insertPrivateProject(org1); @@ -519,25 +519,25 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm5", project2); List<GroupPermissionDto> result = new ArrayList<>(); - underTest.selectAllPermissionsByGroupId(dbSession, org1.getUuid(), group1.getId(), context -> result.add((GroupPermissionDto) context.getResultObject())); + underTest.selectAllPermissionsByGroupUuid(dbSession, org1.getUuid(), group1.getUuid(), context -> result.add((GroupPermissionDto) context.getResultObject())); assertThat(result).extracting(GroupPermissionDto::getComponentUuid, GroupPermissionDto::getRole).containsOnly( tuple(null, "perm2"), tuple(project1.uuid(), "perm3"), tuple(project1.uuid(), "perm4"), tuple(project2.uuid(), "perm5")); } @Test - public void selectGroupIdsWithPermissionOnProjectBut_returns_empty_if_project_does_not_exist() { + public void selectGroupUuidsWithPermissionOnProjectBut_returns_empty_if_project_does_not_exist() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); GroupDto group = db.users().insertGroup(organization); db.users().insertProjectPermissionOnGroup(group, "foo", project); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, "1234", UserRole.USER)) + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, "1234", UserRole.USER)) .isEmpty(); } @Test - public void selectGroupIdsWithPermissionOnProjectBut_returns_only_groups_of_project_which_do_not_have_permission() { + public void selectGroupUuidsWithPermissionOnProjectBut_returns_only_groups_of_project_which_do_not_have_permission() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); GroupDto group1 = db.users().insertGroup(organization); @@ -545,16 +545,16 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "p1", project); db.users().insertProjectPermissionOnGroup(group2, "p2", project); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) - .containsOnly(group1.getId()); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) - .containsOnly(group2.getId()); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p3")) - .containsOnly(group1.getId(), group2.getId()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) + .containsOnly(group1.getUuid()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) + .containsOnly(group2.getUuid()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p3")) + .containsOnly(group1.getUuid(), group2.getUuid()); } @Test - public void selectGroupIdsWithPermissionOnProjectBut_does_not_returns_group_AnyOne_of_project_when_it_does_not_have_permission() { + public void selectGroupUuidsWithPermissionOnProjectBut_does_not_returns_group_AnyOne_of_project_when_it_does_not_have_permission() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPublicProject(organization); GroupDto group1 = db.users().insertGroup(organization); @@ -563,14 +563,14 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group2, "p2", project); db.users().insertProjectPermissionOnAnyone("p2", project); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) - .containsOnly(group1.getId()); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) - .containsOnly(group2.getId()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) + .containsOnly(group1.getUuid()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) + .containsOnly(group2.getUuid()); } @Test - public void selectGroupIdsWithPermissionOnProjectBut_does_not_return_groups_which_have_no_permission_at_all_on_specified_project() { + public void selectGroupUuidsWithPermissionOnProjectBut_does_not_return_groups_which_have_no_permission_at_all_on_specified_project() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); GroupDto group1 = db.users().insertGroup(organization); @@ -579,10 +579,10 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "p1", project); db.users().insertProjectPermissionOnGroup(group2, "p2", project); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) - .containsOnly(group1.getId()); - assertThat(underTest.selectGroupIdsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) - .containsOnly(group2.getId()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p2")) + .containsOnly(group1.getUuid()); + assertThat(underTest.selectGroupUuidsWithPermissionOnProjectBut(dbSession, project.uuid(), "p1")) + .containsOnly(group2.getUuid()); } @Test @@ -633,7 +633,7 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm3", project1); db.users().insertProjectPermissionOnAnyone("perm4", project1); - underTest.delete(dbSession, "perm2", group1.getOrganizationUuid(), group1.getId(), null); + underTest.delete(dbSession, "perm2", group1.getOrganizationUuid(), group1.getUuid(), null); dbSession.commit(); assertThatNoPermission("perm2"); @@ -649,7 +649,7 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnGroup(group1, "perm2"); db.users().insertProjectPermissionOnGroup(group1, "perm3", project1); - underTest.delete(dbSession, "perm2", group1.getOrganizationUuid(), group1.getId(), null); + underTest.delete(dbSession, "perm2", group1.getOrganizationUuid(), group1.getUuid(), null); dbSession.commit(); assertThatNoPermission("perm2"); @@ -682,7 +682,7 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnGroup(group1, "perm2"); db.users().insertProjectPermissionOnGroup(group1, "perm3", project1); - underTest.delete(dbSession, "perm3", group1.getOrganizationUuid(), group1.getId(), project1.uuid()); + underTest.delete(dbSession, "perm3", group1.getOrganizationUuid(), group1.getUuid(), project1.uuid()); dbSession.commit(); assertThatNoPermission("perm3"); @@ -699,7 +699,7 @@ public class GroupPermissionDaoTest { db.users().insertProjectPermissionOnGroup(group1, "perm3", project1); db.users().insertProjectPermissionOnAnyone("perm4", project1); - underTest.delete(dbSession, "perm3", group1.getOrganizationUuid(), group1.getId(), project1.uuid()); + underTest.delete(dbSession, "perm3", group1.getOrganizationUuid(), group1.getUuid(), project1.uuid()); dbSession.commit(); assertThatNoPermission("perm3"); @@ -765,7 +765,7 @@ public class GroupPermissionDaoTest { } @Test - public void deleteByRootComponentUuidAndGroupId_deletes_all_permissions_of_group_AnyOne_of_specified_component_if_groupId_is_null() { + public void deleteByRootComponentUuidAndGroupUuid_deletes_all_permissions_of_group_AnyOne_of_specified_component_if_groupUuid_is_null() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPublicProject(organization); GroupDto group = db.users().insertGroup(organization); @@ -775,28 +775,28 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnGroup(group, "p4"); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .containsOnly("p1"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group.getUuid(), project.uuid())) .containsOnly("p2"); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), null)) .containsOnly("p3"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group.getUuid())) .containsOnly("p4"); - int deletedCount = underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), null); + int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null); assertThat(deletedCount).isEqualTo(1); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .isEmpty(); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group.getUuid(), project.uuid())) .containsOnly("p2"); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), null)) .containsOnly("p3"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group.getUuid())) .containsOnly("p4"); } @Test - public void deleteByRootComponentUuidAndGroupId_deletes_all_permissions_of_specified_group_of_specified_component_if_groupId_is_non_null() { + public void deleteByRootComponentUuidAndGroupUuid_deletes_all_permissions_of_specified_group_of_specified_component_if_groupUuid_is_non_null() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPublicProject(organization); GroupDto group1 = db.users().insertGroup(organization); @@ -810,101 +810,101 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnGroup(group2, "p7"); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .containsOnly("p1"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .containsOnly("p2"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid(), project.uuid())) .containsOnly("p3", "p4"); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), null)) .containsOnly("p5"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid())) .containsOnly("p6"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid())) .containsOnly("p7"); - int deletedCount = underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), group1.getId()); + int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group1.getUuid()); assertThat(deletedCount).isEqualTo(1); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .containsOnly("p1"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .isEmpty(); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid(), project.uuid())) .containsOnly("p3", "p4"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid())) .containsOnly("p6"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid())) .containsOnly("p7"); - deletedCount = underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), group2.getId()); + deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group2.getUuid()); assertThat(deletedCount).isEqualTo(2); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .containsOnly("p1"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .isEmpty(); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid(), project.uuid())) .isEmpty(); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid())) .containsOnly("p6"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid())) .containsOnly("p7"); } @Test - public void deleteByRootComponentUuidAndGroupId_has_no_effect_if_component_does_not_exist() { + public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_component_does_not_exist() { OrganizationDto organization = db.organizations().insert(); GroupDto group = db.users().insertGroup(organization); - assertThat(underTest.deleteByRootComponentUuidAndGroupId(dbSession, "1234", null)).isEqualTo(0); - assertThat(underTest.deleteByRootComponentUuidAndGroupId(dbSession, "1234", group.getId())).isEqualTo(0); + assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, "1234", null)).isEqualTo(0); + assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, "1234", group.getUuid())).isEqualTo(0); } @Test - public void deleteByRootComponentUuidAndGroupId_has_no_effect_if_component_has_no_group_permission_at_all() { + public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_component_has_no_group_permission_at_all() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); GroupDto group = db.users().insertGroup(organization); - assertThat(underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), null)).isEqualTo(0); - assertThat(underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), group.getId())).isEqualTo(0); + assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null)).isEqualTo(0); + assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group.getUuid())).isEqualTo(0); } @Test - public void deleteByRootComponentUuidAndGroupId_has_no_effect_if_group_does_not_exist() { + public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_group_does_not_exist() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); - assertThat(underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), 5678)).isEqualTo(0); + assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), "5678")).isEqualTo(0); } @Test - public void deleteByRootComponentUuidAndGroupId_has_no_effect_if_component_has_no_group_permission_for_group_AnyOne() { + public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_component_has_no_group_permission_for_group_AnyOne() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization); GroupDto group1 = db.users().insertGroup(organization); db.users().insertProjectPermissionOnGroup(group1, "p1", project); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .isEmpty(); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .containsOnly("p1"); db.users().insertPermissionOnAnyone(organization, "p2"); db.users().insertPermissionOnGroup(group1, "p3"); - int deletedCount = underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), null); + int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null); assertThat(deletedCount).isEqualTo(0); assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), null, project.uuid())) .isEmpty(); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .containsOnly("p1"); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), null)) .containsOnly("p2"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid())) .containsOnly("p3"); } @Test - public void deleteByRootComponentUuidAndGroupId_has_no_effect_if_component_has_no_group_permission_for_specified_group() { + public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_component_has_no_group_permission_for_specified_group() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization); GroupDto group1 = db.users().insertGroup(organization); @@ -913,16 +913,16 @@ public class GroupPermissionDaoTest { db.users().insertPermissionOnAnyone(organization, "p2"); db.users().insertPermissionOnGroup(group1, "p3"); - int deletedCount = underTest.deleteByRootComponentUuidAndGroupId(dbSession, project.uuid(), group2.getId()); + int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group2.getUuid()); assertThat(deletedCount).isEqualTo(0); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid(), project.uuid())) .containsOnly("p1"); - assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getId(), project.uuid())) + assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, organization.getUuid(), group2.getUuid(), project.uuid())) .isEmpty(); assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), null)) .containsOnly("p2"); - assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getId())) + assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, organization.getUuid(), group1.getUuid())) .containsOnly("p3"); } @@ -1005,22 +1005,22 @@ public class GroupPermissionDaoTest { } private Collection<String> getGlobalPermissionsForAnyone(OrganizationDto organization) { - return getPermissions("organization_uuid = '" + organization.getUuid() + "' and group_id is null and component_uuid is null"); + return getPermissions("organization_uuid = '" + organization.getUuid() + "' and group_uuid is null and component_uuid is null"); } private Collection<String> getGlobalPermissionsForGroup(GroupDto groupDto) { return getPermissions("organization_uuid = '" + groupDto.getOrganizationUuid() + - "' and group_id = " + groupDto.getId() + " and component_uuid is null"); + "' and group_uuid = '" + groupDto.getUuid() + "' and component_uuid is null"); } private Collection<String> getProjectPermissionsForAnyOne(ComponentDto project) { return getPermissions("organization_uuid = '" + project.getOrganizationUuid() + - "' and group_id is null and component_uuid = '" + project.uuid() + "'"); + "' and group_uuid is null and component_uuid = '" + project.uuid() + "'"); } private Collection<String> getProjectPermissionsForGroup(ComponentDto project, GroupDto group) { return getPermissions("organization_uuid = '" + project.getOrganizationUuid() + - "' and group_id = " + group.getId() + " and component_uuid = '" + project.uuid() + "'"); + "' and group_uuid = '" + group.getUuid() + "' and component_uuid = '" + project.uuid() + "'"); } private Collection<String> getPermissions(String whereClauses) { @@ -1046,12 +1046,12 @@ public class GroupPermissionDaoTest { .containsOnly(organizationUuids); } - private int insertGroupWithPermissions(OrganizationDto organization1) { + private String insertGroupWithPermissions(OrganizationDto organization1) { GroupDto group = db.users().insertGroup(organization1); db.users().insertPermissionOnGroup(group, "foo"); db.users().insertPermissionOnGroup(group, "bar"); db.users().insertPermissionOnGroup(group, "doh"); - return group.getId(); + return group.getUuid(); } private void assertThatNoPermission(String permission) { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java index 578abc4641d..77cf00ff9c1 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java @@ -496,7 +496,7 @@ public class UserPermissionDaoTest { } @Test - public void selectGroupIdsWithPermissionOnProjectBut_returns_empty_if_project_does_not_exist() { + public void selectGroupUuidsWithPermissionOnProjectBut_returns_empty_if_project_does_not_exist() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); UserDto user = insertUser(organization); @@ -507,7 +507,7 @@ public class UserPermissionDaoTest { } @Test - public void selectGroupIdsWithPermissionOnProjectBut_returns_only_users_of_projects_which_do_not_have_permission() { + public void selectGroupUuidsWithPermissionOnProjectBut_returns_only_users_of_projects_which_do_not_have_permission() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); UserDto user1 = insertUser(organization); @@ -524,7 +524,7 @@ public class UserPermissionDaoTest { } @Test - public void selectGroupIdsWithPermissionOnProjectBut_does_not_return_groups_which_have_no_permission_at_all_on_specified_project() { + public void selectGroupUuidsWithPermissionOnProjectBut_does_not_return_groups_which_have_no_permission_at_all_on_specified_project() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = randomPublicOrPrivateProject(organization); UserDto user1 = insertUser(organization); diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoTest.java index 1266bad5aa3..1563af9d5a0 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoTest.java @@ -59,13 +59,13 @@ public class GroupWithPermissionTemplateDaoTest { GroupDto group3 = db.users().insertGroup(organization, "Group-3"); PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(organization); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), USER); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), ADMIN); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getUuid(), PROVISIONING); PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(organization); permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER); - permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getUuid(), PROVISIONING); assertThat(selectGroupNamesByQueryAndTemplate(builder(), organization, template)) .containsOnly("Group-1", "Group-2", "Group-3", "Anyone"); @@ -159,7 +159,7 @@ public class GroupWithPermissionTemplateDaoTest { GroupDto group = db.users().insertGroup(organization, "Group"); PermissionTemplateDto otherTemplate = permissionTemplateDbTester.insertTemplate(organization); - permissionTemplateDbTester.addGroupToTemplate(otherTemplate.getUuid(), group.getId(), USER); + permissionTemplateDbTester.addGroupToTemplate(otherTemplate.getUuid(), group.getUuid(), USER); assertThat(selectGroupNamesByQueryAndTemplate(builder().setSearchQuery("nyo"), organization, template)) .containsExactly("Anyone"); @@ -173,13 +173,13 @@ public class GroupWithPermissionTemplateDaoTest { GroupDto group3 = db.users().insertGroup(organization, "Group-3"); PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(organization); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), USER); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), ADMIN); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getUuid(), PROVISIONING); PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(organization); permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER); - permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getUuid(), PROVISIONING); assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()), organization, template)) .isEqualTo(4); @@ -208,29 +208,29 @@ public class GroupWithPermissionTemplateDaoTest { GroupDto group3 = db.users().insertGroup(newGroupDto().setName("Group-3")); PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), USER); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), ADMIN); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getUuid(), PROVISIONING); PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(); permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER); - permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getUuid(), PROVISIONING); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Group-1"))) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getId(), "Group-1", USER), - tuple(group1.getId(), "Group-1", ADMIN)); + tuple(group1.getUuid(), "Group-1", USER), + tuple(group1.getUuid(), "Group-1", ADMIN)); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getUuid(), asList("Group-1"))) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getId(), "Group-1", PROVISIONING)); + tuple(group1.getUuid(), "Group-1", PROVISIONING)); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getUuid(), asList("Anyone"))) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(0, "Anyone", USER)); + tuple("Anyone", "Anyone", USER)); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Group-1", "Group-2", "Anyone"))).hasSize(3); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Unknown"))).isEmpty(); @@ -244,25 +244,25 @@ public class GroupWithPermissionTemplateDaoTest { GroupDto group3 = db.users().insertGroup(newGroupDto().setName("Group-3")); PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN); - permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), USER); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getUuid(), ADMIN); + permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getUuid(), PROVISIONING); PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(); permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER); - permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING); + permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getUuid(), PROVISIONING); assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, template.getUuid())) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getId(), "Group-1", USER), - tuple(group1.getId(), "Group-1", ADMIN), - tuple(group2.getId(), "Group-2", PROVISIONING)); + tuple(group1.getUuid(), "Group-1", USER), + tuple(group1.getUuid(), "Group-1", ADMIN), + tuple(group2.getUuid(), "Group-2", PROVISIONING)); assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, anotherTemplate.getUuid())) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getId(), "Group-1", PROVISIONING), - tuple(0, "Anyone", USER)); + tuple(group1.getUuid(), "Group-1", PROVISIONING), + tuple("Anyone", "Anyone", USER)); assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, "321")).isEmpty(); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java index 70677469e13..ae128046ab0 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java @@ -239,14 +239,14 @@ public class PermissionTemplateDaoTest { PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization()); GroupDto group = db.users().insertGroup(); - underTest.insertGroupPermission(dbSession, permissionTemplate.getUuid(), group.getId(), "user"); + underTest.insertGroupPermission(dbSession, permissionTemplate.getUuid(), group.getUuid(), "user"); dbSession.commit(); assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid())) - .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission, + .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getPermission, PermissionTemplateGroupDto::getCreatedAt, PermissionTemplateGroupDto::getUpdatedAt) - .containsOnly(tuple(permissionTemplate.getUuid(), group.getId(), "user", NOW, NOW)); + .containsOnly(tuple(permissionTemplate.getUuid(), group.getUuid(), "user", NOW, NOW)); } @Test @@ -258,12 +258,12 @@ public class PermissionTemplateDaoTest { templateDb.addGroupToTemplate(permissionTemplate, group1, "admin"); templateDb.addGroupToTemplate(permissionTemplate, group2, "user"); - underTest.deleteByGroup(db.getSession(), group1.getId()); + underTest.deleteByGroup(db.getSession(), group1.getUuid()); db.getSession().commit(); assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid())) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission) - .containsOnly(tuple(group2.getId(), "user")); + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getPermission) + .containsOnly(tuple(group2.getUuid(), "user")); } @Test @@ -274,9 +274,9 @@ public class PermissionTemplateDaoTest { dbSession.commit(); assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid())) - .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, + .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) - .containsOnly(tuple(permissionTemplate.getUuid(), 0, "Anyone", "user")); + .containsOnly(tuple(permissionTemplate.getUuid(), "Anyone", "Anyone", "user")); } @Test @@ -288,13 +288,13 @@ public class PermissionTemplateDaoTest { GroupDto group1 = db.users().insertGroup(newGroupDto()); GroupDto group2 = db.users().insertGroup(newGroupDto()); GroupDto group3 = db.users().insertGroup(newGroupDto()); - templateDb.addGroupToTemplate(template1.getUuid(), group1.getId(), CODEVIEWER); - templateDb.addGroupToTemplate(template1.getUuid(), group2.getId(), CODEVIEWER); - templateDb.addGroupToTemplate(template1.getUuid(), group3.getId(), CODEVIEWER); + templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), CODEVIEWER); + templateDb.addGroupToTemplate(template1.getUuid(), group2.getUuid(), CODEVIEWER); + templateDb.addGroupToTemplate(template1.getUuid(), group3.getUuid(), CODEVIEWER); templateDb.addGroupToTemplate(template1.getUuid(), null, CODEVIEWER); - templateDb.addGroupToTemplate(template1.getUuid(), group1.getId(), ADMIN); - templateDb.addGroupToTemplate(template2.getUuid(), group1.getId(), ADMIN); - templateDb.addGroupToTemplate(template4.getUuid(), group1.getId(), ISSUE_ADMIN); + templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), ADMIN); + templateDb.addGroupToTemplate(template2.getUuid(), group1.getUuid(), ADMIN); + templateDb.addGroupToTemplate(template4.getUuid(), group1.getUuid(), ISSUE_ADMIN); final List<CountByTemplateAndPermissionDto> result = new ArrayList<>(); underTest.groupsCountByTemplateUuidAndPermission(dbSession, asList(template1.getUuid(), template2.getUuid(), template3.getUuid()), @@ -360,8 +360,8 @@ public class PermissionTemplateDaoTest { templateDb.addProjectCreatorToTemplate(template.getUuid(), UserRole.ADMIN); templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER); templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.ADMIN); - templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.CODEVIEWER); - templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.ADMIN); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.CODEVIEWER); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.ADMIN); templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN); List<String> resultWithUser = underTest.selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, user.getId(), template.getUuid()); @@ -373,7 +373,7 @@ public class PermissionTemplateDaoTest { } @Test - public void selectAllGroupPermissionTemplatesByGroupId() { + public void selectAllGroupPermissionTemplatesByGroupUuid() { PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization()); GroupDto group1 = db.users().insertGroup(); GroupDto group2 = db.users().insertGroup(); @@ -381,9 +381,9 @@ public class PermissionTemplateDaoTest { templateDb.addGroupToTemplate(permissionTemplate, group1, "admin"); templateDb.addGroupToTemplate(permissionTemplate, group2, "user"); - assertThat(db.getDbClient().permissionTemplateDao().selectAllGroupPermissionTemplatesByGroupId(db.getSession(), group1.getId())) - .extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission) - .containsOnly(tuple(group1.getId(), "user"), tuple(group1.getId(), "admin")); + assertThat(db.getDbClient().permissionTemplateDao().selectAllGroupPermissionTemplatesByGroupUuid(db.getSession(), group1.getUuid())) + .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getPermission) + .containsOnly(tuple(group1.getUuid(), "user"), tuple(group1.getUuid(), "admin")); } @Test @@ -478,8 +478,8 @@ public class PermissionTemplateDaoTest { templateDb.addProjectCreatorToTemplate(template.getUuid(), UserRole.ADMIN); templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER); templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.ADMIN); - templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.CODEVIEWER); - templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.ADMIN); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.CODEVIEWER); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.ADMIN); templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN); return template; } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/QProfileEditGroupsDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/QProfileEditGroupsDaoTest.java index d3e0a00f77c..0ccd071dc06 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/QProfileEditGroupsDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/QProfileEditGroupsDaoTest.java @@ -111,27 +111,27 @@ public class QProfileEditGroupsDaoTest { .setOrganization(organization) .setProfile(profile) .setMembership(ANY).build(), Pagination.all())) - .extracting(GroupMembershipDto::getGroupId, GroupMembershipDto::isSelected) + .extracting(GroupMembershipDto::getGroupUuid, GroupMembershipDto::isSelected) .containsExactlyInAnyOrder( - tuple(group1.getId(), true), - tuple(group2.getId(), true), - tuple(group3.getId(), false)); + tuple(group1.getUuid(), true), + tuple(group2.getUuid(), true), + tuple(group3.getUuid(), false)); assertThat(underTest.selectByQuery(db.getSession(), builder() .setOrganization(organization) .setProfile(profile) .setMembership(IN).build(), Pagination.all())) - .extracting(GroupMembershipDto::getGroupId, GroupMembershipDto::isSelected) - .containsExactlyInAnyOrder(tuple(group1.getId(), true), tuple(group2.getId(), true)); + .extracting(GroupMembershipDto::getGroupUuid, GroupMembershipDto::isSelected) + .containsExactlyInAnyOrder(tuple(group1.getUuid(), true), tuple(group2.getUuid(), true)); assertThat(underTest.selectByQuery(db.getSession(), builder() .setOrganization(organization) .setProfile(profile) .setMembership(OUT).build(), Pagination.all())) - .extracting(GroupMembershipDto::getGroupId, GroupMembershipDto::isSelected) - .containsExactlyInAnyOrder(tuple(group3.getId(), false)); + .extracting(GroupMembershipDto::getGroupUuid, GroupMembershipDto::isSelected) + .containsExactlyInAnyOrder(tuple(group3.getUuid(), false)); } @Test @@ -151,8 +151,8 @@ public class QProfileEditGroupsDaoTest { .setMembership(IN) .setQuery("project").build(), Pagination.all())) - .extracting(GroupMembershipDto::getGroupId) - .containsExactlyInAnyOrder(group1.getId()); + .extracting(GroupMembershipDto::getGroupUuid) + .containsExactlyInAnyOrder(group1.getUuid()); assertThat(underTest.selectByQuery(db.getSession(), builder() .setOrganization(organization) @@ -160,8 +160,8 @@ public class QProfileEditGroupsDaoTest { .setMembership(IN) .setQuery("UserS").build(), Pagination.all())) - .extracting(GroupMembershipDto::getGroupId) - .containsExactlyInAnyOrder(group1.getId(), group2.getId()); + .extracting(GroupMembershipDto::getGroupUuid) + .containsExactlyInAnyOrder(group1.getUuid(), group2.getUuid()); } @Test @@ -180,8 +180,8 @@ public class QProfileEditGroupsDaoTest { .setMembership(ANY) .build(), Pagination.forPage(1).andSize(1))) - .extracting(GroupMembershipDto::getGroupId) - .containsExactly(group1.getId()); + .extracting(GroupMembershipDto::getGroupUuid) + .containsExactly(group1.getUuid()); assertThat(underTest.selectByQuery(db.getSession(), builder() .setOrganization(organization) @@ -189,8 +189,8 @@ public class QProfileEditGroupsDaoTest { .setMembership(ANY) .build(), Pagination.forPage(3).andSize(1))) - .extracting(GroupMembershipDto::getGroupId) - .containsExactly(group3.getId()); + .extracting(GroupMembershipDto::getGroupUuid) + .containsExactly(group3.getUuid()); assertThat(underTest.selectByQuery(db.getSession(), builder() .setOrganization(organization) @@ -198,8 +198,8 @@ public class QProfileEditGroupsDaoTest { .setMembership(ANY) .build(), Pagination.forPage(1).andSize(10))) - .extracting(GroupMembershipDto::getGroupId) - .containsExactly(group1.getId(), group2.getId(), group3.getId()); + .extracting(GroupMembershipDto::getGroupUuid) + .containsExactly(group1.getUuid(), group2.getUuid(), group3.getUuid()); } @Test @@ -230,13 +230,13 @@ public class QProfileEditGroupsDaoTest { public void insert() { underTest.insert(db.getSession(), new QProfileEditGroupsDto() .setUuid("ABCD") - .setGroupId(100) + .setGroupUuid("100") .setQProfileUuid("QPROFILE") ); - assertThat(db.selectFirst(db.getSession(), "select uuid as \"uuid\", group_id as \"groupId\", qprofile_uuid as \"qProfileUuid\", created_at as \"createdAt\" from qprofile_edit_groups")).contains( + assertThat(db.selectFirst(db.getSession(), "select uuid as \"uuid\", group_uuid as \"groupUuid\", qprofile_uuid as \"qProfileUuid\", created_at as \"createdAt\" from qprofile_edit_groups")).contains( entry("uuid", "ABCD"), - entry("groupId", 100L), + entry("groupUuid", "100"), entry("qProfileUuid", "QPROFILE"), entry("createdAt", NOW)); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoTest.java index ca5428cf9ce..a6fd8238075 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoTest.java @@ -41,7 +41,7 @@ import static org.sonar.db.user.GroupTesting.newGroupDto; public class GroupDaoTest { private static final long NOW = 1_500_000L; - private static final int MISSING_ID = -1; + private static final String MISSING_UUID = "unknown"; private static final OrganizationDto AN_ORGANIZATION = new OrganizationDto() .setKey("an-org") .setName("An Org") @@ -56,8 +56,9 @@ public class GroupDaoTest { private DbSession dbSession = db.getSession(); private GroupDao underTest = db.getDbClient().groupDao(); - // not static as group id is changed in each test + // not static as group uuid is changed in each test private final GroupDto aGroup = new GroupDto() + .setUuid("uuid") .setName("the-name") .setDescription("the description") .setOrganizationUuid(AN_ORGANIZATION.getUuid()); @@ -74,7 +75,7 @@ public class GroupDaoTest { GroupDto group = underTest.selectByName(dbSession, AN_ORGANIZATION.getUuid(), aGroup.getName()).get(); - assertThat(group.getId()).isNotNull(); + assertThat(group.getUuid()).isNotNull(); assertThat(group.getOrganizationUuid()).isEqualTo(aGroup.getOrganizationUuid()); assertThat(group.getName()).isEqualTo(aGroup.getName()); assertThat(group.getDescription()).isEqualTo(aGroup.getDescription()); @@ -110,33 +111,33 @@ public class GroupDaoTest { 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", asList("group1", "group2", "group3", "missingGroup"))).extracting(GroupDto::getUuid) + .containsOnly(group1InOrg1.getUuid(), group2InOrg1.getUuid()); assertThat(underTest.selectByNames(dbSession, "org1", Collections.emptyList())).isEmpty(); assertThat(underTest.selectByNames(dbSession, "missingOrg", asList("group1"))).isEmpty(); } @Test - public void selectByIds() { + public void selectByUuids() { GroupDto group1 = db.users().insertGroup(); GroupDto group2 = db.users().insertGroup(); GroupDto group3 = db.users().insertGroup(); - assertThat(underTest.selectByIds(dbSession, asList(group1.getId(), group2.getId()))) - .extracting(GroupDto::getId).containsOnly(group1.getId(), group2.getId()); + assertThat(underTest.selectByUuids(dbSession, asList(group1.getUuid(), group2.getUuid()))) + .extracting(GroupDto::getUuid).containsOnly(group1.getUuid(), group2.getUuid()); - assertThat(underTest.selectByIds(dbSession, asList(group1.getId(), MISSING_ID))) - .extracting(GroupDto::getId).containsOnly(group1.getId()); + assertThat(underTest.selectByUuids(dbSession, asList(group1.getUuid(), MISSING_UUID))) + .extracting(GroupDto::getUuid).containsOnly(group1.getUuid()); - assertThat(underTest.selectByIds(dbSession, Collections.emptyList())).isEmpty(); + assertThat(underTest.selectByUuids(dbSession, Collections.emptyList())).isEmpty(); } @Test public void update() { db.getDbClient().groupDao().insert(dbSession, aGroup); GroupDto dto = new GroupDto() - .setId(aGroup.getId()) + .setUuid(aGroup.getUuid()) .setName("new-name") .setDescription("New description") .setOrganizationUuid("another-org") @@ -144,7 +145,7 @@ public class GroupDaoTest { underTest.update(dbSession, dto); - GroupDto reloaded = underTest.selectById(dbSession, aGroup.getId()); + GroupDto reloaded = underTest.selectByUuid(dbSession, aGroup.getUuid()); // verify mutable fields assertThat(reloaded.getName()).isEqualTo("new-name"); @@ -234,10 +235,10 @@ public class GroupDaoTest { } @Test - public void deleteById() { + public void deleteByUuid() { db.getDbClient().groupDao().insert(dbSession, aGroup); - underTest.deleteById(dbSession, aGroup.getId()); + underTest.deleteByUuid(dbSession, aGroup.getUuid()); assertThat(db.countRowsOfTable(dbSession, "groups")).isEqualTo(0); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java index 6a7a7d2af5e..35c8b69b737 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java @@ -133,9 +133,9 @@ public class GroupMembershipDaoTest { db.users().insertMember(group3, user1); db.users().insertMember(group2, user2); - assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getId(), group2.getId(), group3.getId(), emptyGroup.getId()))) + assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getUuid(), group2.getUuid(), group3.getUuid(), emptyGroup.getUuid()))) .containsOnly(entry(group1.getName(), 1), entry(group2.getName(), 2), entry(group3.getName(), 1), entry(emptyGroup.getName(), 0)); - assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getId(), emptyGroup.getId()))) + assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getUuid(), emptyGroup.getUuid()))) .containsOnly(entry(group1.getName(), 1), entry(emptyGroup.getName(), 0)); } @@ -162,17 +162,17 @@ public class GroupMembershipDaoTest { db.users().insertMember(group2, user2); // 100 has 1 member and 1 non member - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group1.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(1); - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group1.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).membership(UserMembershipQuery.IN).build())).isEqualTo(1); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1); // 101 has 2 members - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group2.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(2); - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group2.getId()).membership(UserMembershipQuery.OUT).build())).isZero(); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group2.getUuid()).membership(UserMembershipQuery.IN).build())).isEqualTo(2); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group2.getUuid()).membership(UserMembershipQuery.OUT).build())).isZero(); // 102 has 1 member and 1 non member - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group3.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(1); - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(group3.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group3.getUuid()).membership(UserMembershipQuery.IN).build())).isEqualTo(1); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(group3.getUuid()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1); // 103 has no member - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(emptyGroup.getId()).membership(UserMembershipQuery.IN).build())).isZero(); - assertThat(underTest.countMembers(db.getSession(), newQuery().groupId(emptyGroup.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(2); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(emptyGroup.getUuid()).membership(UserMembershipQuery.IN).build())).isZero(); + assertThat(underTest.countMembers(db.getSession(), newQuery().groupUuid(emptyGroup.getUuid()).membership(UserMembershipQuery.OUT).build())).isEqualTo(2); } @Test @@ -184,13 +184,13 @@ public class GroupMembershipDaoTest { db.users().insertMember(group2, user2); // 100 has 1 member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1); // 101 has 2 members - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group2.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group2.getUuid()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2); // 102 has 1 member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group3.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group3.getUuid()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1); // 103 has no member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(emptyGroup.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty(); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(emptyGroup.getUuid()).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty(); } @Test @@ -202,13 +202,13 @@ public class GroupMembershipDaoTest { db.users().insertMember(group2, user2); // 100 has 1 member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1); // 101 has 2 members - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group2.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty(); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group2.getUuid()).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty(); // 102 has 1 member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(group3.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(group3.getUuid()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1); // 103 has no member - assertThat(underTest.selectMembers(db.getSession(), newQuery().groupId(emptyGroup.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2); + assertThat(underTest.selectMembers(db.getSession(), newQuery().groupUuid(emptyGroup.getUuid()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2); } @Test @@ -218,13 +218,13 @@ public class GroupMembershipDaoTest { db.users().insertMember(group3, user1); db.users().insertMember(group2, user2); - List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).memberSearch("admin").build(), 0, 10); + List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).memberSearch("admin").build(), 0, 10); assertThat(result).hasSize(2); assertThat(result.get(0).getName()).isEqualTo("Admin name"); assertThat(result.get(1).getName()).isEqualTo("Not Admin"); - result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).memberSearch("not").build(), 0, 10); + result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).memberSearch("not").build(), 0, 10); assertThat(result).hasSize(1); } @@ -236,13 +236,13 @@ public class GroupMembershipDaoTest { db.users().insertMember(group2, user2); // search is case insensitive only on name - List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).memberSearch("NaMe").build(), 0, 10); + List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).memberSearch("NaMe").build(), 0, 10); assertThat(result).hasSize(1); - result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).memberSearch("login").build(), 0, 10); + result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).memberSearch("login").build(), 0, 10); assertThat(result).hasSize(1); - result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).memberSearch("email").build(), 0, 10); + result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).memberSearch("email").build(), 0, 10); assertThat(result).hasSize(1); } @@ -253,7 +253,7 @@ public class GroupMembershipDaoTest { db.users().insertMember(group3, user1); db.users().insertMember(group2, user2); - List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).build(), 0, 10); + List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).build(), 0, 10); assertThat(result).hasSize(2); assertThat(result.get(0).getName()).isEqualTo("Admin name"); assertThat(result.get(1).getName()).isEqualTo("Not Admin"); @@ -266,16 +266,16 @@ public class GroupMembershipDaoTest { db.users().insertMember(group3, user1); db.users().insertMember(group2, user2); - List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupId(group1.getId()).build(), 0, 2); + List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), newQuery().groupUuid(group1.getUuid()).build(), 0, 2); assertThat(result).hasSize(2); assertThat(result.get(0).getName()).isEqualTo("Admin name"); assertThat(result.get(1).getName()).isEqualTo("Not Admin"); - result = underTest.selectMembers(db.getSession(), newQuery().groupId(100).build(), 1, 2); + result = underTest.selectMembers(db.getSession(), newQuery().groupUuid("100").build(), 1, 2); assertThat(result).hasSize(1); assertThat(result.get(0).getName()).isEqualTo("Not Admin"); - result = underTest.selectMembers(db.getSession(), newQuery().groupId(100).build(), 2, 1); + result = underTest.selectMembers(db.getSession(), newQuery().groupUuid("100").build(), 2, 1); assertThat(result).isEmpty(); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/RoleDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/RoleDaoTest.java index 94913bb0c5a..94fe7b9ddf5 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/RoleDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/RoleDaoTest.java @@ -114,7 +114,7 @@ public class RoleDaoTest { } @Test - public void delete_all_group_permissions_by_group_id() { + public void delete_all_group_permissions_by_group_uuid() { GroupDto group1 = db.users().insertGroup(); GroupDto group2 = db.users().insertGroup(); ComponentDto project = db.components().insertPrivateProject(); @@ -126,13 +126,13 @@ public class RoleDaoTest { db.users().insertPermissionOnAnyone(db.getDefaultOrganization(), "scan"); db.users().insertPermissionOnAnyone(db.getDefaultOrganization(), "provisioning"); - underTest.deleteGroupRolesByGroupId(db.getSession(), group1.getId()); + underTest.deleteGroupRolesByGroupUuid(db.getSession(), group1.getUuid()); db.getSession().commit(); - assertThat(db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group1.getId())).isEmpty(); - assertThat(db.getDbClient().groupPermissionDao().selectProjectPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group1.getId(), project.uuid())).isEmpty(); - assertThat(db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group2.getId())).containsOnly("gateadmin"); - assertThat(db.getDbClient().groupPermissionDao().selectProjectPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group2.getId(), project.uuid())).containsOnly("admin"); + assertThat(db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group1.getUuid())).isEmpty(); + assertThat(db.getDbClient().groupPermissionDao().selectProjectPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group1.getUuid(), project.uuid())).isEmpty(); + assertThat(db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group2.getUuid())).containsOnly("gateadmin"); + assertThat(db.getDbClient().groupPermissionDao().selectProjectPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), group2.getUuid(), project.uuid())).containsOnly("admin"); assertThat(db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), db.getDefaultOrganization().getUuid(), null)).containsOnly("scan", "provisioning"); } } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserDaoTest.java index 4dd8cbd122c..5936ec55676 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserDaoTest.java @@ -34,7 +34,6 @@ import org.sonar.db.DatabaseUtils; import org.sonar.db.DbClient; import org.sonar.db.DbSession; import org.sonar.db.DbTester; -import org.sonar.db.component.ComponentDto; import org.sonar.db.organization.OrganizationDto; import org.sonar.db.project.ProjectDto; @@ -760,7 +759,7 @@ public class UserDaoTest { GroupDto group = newGroupDto().setName(randomAlphanumeric(30)); dbClient.groupDao().insert(session, group); - UserGroupDto dto = new UserGroupDto().setUserId(user.getId()).setGroupId(group.getId()); + UserGroupDto dto = new UserGroupDto().setUserId(user.getId()).setGroupUuid(group.getUuid()); dbClient.userGroupDao().insert(session, dto); return dto; } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoTest.java index 7dfcb565005..f226aba8362 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoTest.java @@ -42,16 +42,16 @@ public class UserGroupDaoTest { public void insert() { UserDto user = dbTester.users().insertUser(); GroupDto group = dbTester.users().insertGroup(); - UserGroupDto userGroupDto = new UserGroupDto().setUserId(user.getId()).setGroupId(group.getId()); + UserGroupDto userGroupDto = new UserGroupDto().setUserId(user.getId()).setGroupUuid(group.getUuid()); underTest.insert(dbTester.getSession(), userGroupDto); dbTester.getSession().commit(); - assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupIdsByUserId(dbTester.getSession(), user.getId())).containsOnly(group.getId()); + assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(dbTester.getSession(), user.getId())).containsOnly(group.getUuid()); } @Test - public void delete_members_by_group_id() { + public void delete_members_by_group_uuid() { UserDto user1 = dbTester.users().insertUser(); UserDto user2 = dbTester.users().insertUser(); GroupDto group1 = dbTester.users().insertGroup(); @@ -61,11 +61,11 @@ public class UserGroupDaoTest { dbTester.users().insertMember(group2, user1); dbTester.users().insertMember(group2, user2); - underTest.deleteByGroupId(dbTester.getSession(), group1.getId()); + underTest.deleteByGroupUuid(dbTester.getSession(), group1.getUuid()); dbTester.getSession().commit(); - assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupIdsByUserId(dbTester.getSession(), user1.getId())).containsOnly(group2.getId()); - assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupIdsByUserId(dbTester.getSession(), user2.getId())).containsOnly(group2.getId()); + assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(dbTester.getSession(), user1.getId())).containsOnly(group2.getUuid()); + assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(dbTester.getSession(), user2.getId())).containsOnly(group2.getUuid()); } @Test @@ -81,10 +81,10 @@ public class UserGroupDaoTest { underTest.deleteByOrganizationAndUser(dbSession, organization.getUuid(), user.getId()); - assertThat(dbClient.groupMembershipDao().selectGroupIdsByUserId(dbSession, user.getId())) - .containsOnly(anotherGroup.getId()); - assertThat(dbClient.groupMembershipDao().selectGroupIdsByUserId(dbSession, anotherUser.getId())) - .containsOnly(group.getId(), anotherGroup.getId()); + assertThat(dbClient.groupMembershipDao().selectGroupUuidsByUserId(dbSession, user.getId())) + .containsOnly(anotherGroup.getUuid()); + assertThat(dbClient.groupMembershipDao().selectGroupUuidsByUserId(dbSession, anotherUser.getId())) + .containsOnly(group.getUuid(), anotherGroup.getUuid()); } @Test @@ -101,7 +101,7 @@ public class UserGroupDaoTest { underTest.deleteByUserId(dbTester.getSession(), user1.getId()); dbTester.getSession().commit(); - assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupIdsByUserId(dbTester.getSession(), user1.getId())).isEmpty(); - assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupIdsByUserId(dbTester.getSession(), user2.getId())).containsOnly(group1.getId(), group2.getId()); + assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(dbTester.getSession(), user1.getId())).isEmpty(); + assertThat(dbTester.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(dbTester.getSession(), user2.getId())).containsOnly(group1.getUuid(), group2.getUuid()); } } diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueDaoTest/shared.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueDaoTest/shared.xml index 7ecb9987931..32a278ac094 100644 --- a/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueDaoTest/shared.xml +++ b/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueDaoTest/shared.xml @@ -1,7 +1,7 @@ <dataset> <group_roles id="1" - group_id="[null]" + group_uuid="[null]" resource_id="399" role="user" organization_uuid="org1"/> diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueStatsDaoTest/should_select_assignees.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueStatsDaoTest/should_select_assignees.xml index 80787f7a14b..8b14a83d2a9 100644 --- a/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueStatsDaoTest/should_select_assignees.xml +++ b/server/sonar-db-dao/src/test/resources/org/sonar/db/issue/IssueStatsDaoTest/should_select_assignees.xml @@ -1,7 +1,7 @@ <dataset> <group_roles id="1" - group_id="[null]" + group_uuid="[null]" resource_id="399" role="user" organization_uuid="org1"/> diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_anonymous.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_anonymous.xml index 5b4a68f376e..811a4ec4fe3 100644 --- a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_anonymous.xml +++ b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_anonymous.xml @@ -6,9 +6,9 @@ role="user" organization_uuid="org1"/> <groups_users user_id="100" - group_id="200"/> + group_uuid="200"/> <group_roles id="1" - group_id="[null]" + group_uuid="[null]" resource_id="300" role="user" organization_uuid="org1"/> diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_group.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_group.xml index 4c3775cc298..92784c88940 100644 --- a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_group.xml +++ b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_group.xml @@ -8,9 +8,9 @@ role="user" organization_uuid="org1"/> <groups_users user_id="100" - group_id="200"/> + group_uuid="200"/> <group_roles id="1" - group_id="200" + group_uuid="200" resource_id="300" role="user" organization_uuid="org1"/> diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_user.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_user.xml index a4e80e5265a..58270a7655b 100644 --- a/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_user.xml +++ b/server/sonar-db-dao/src/test/resources/org/sonar/db/permission/AuthorizationDaoTest/should_return_root_project_keys_for_user.xml @@ -7,9 +7,9 @@ role="user" organization_uuid="org1"/> <groups_users user_id="100" - group_id="200"/> + group_uuid="200"/> <group_roles id="1" - group_id="200" + group_uuid="200" resource_id="999" role="user" organization_uuid="org1"/> diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/organization/OrganizationDbTester.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/organization/OrganizationDbTester.java index e2bd1f5f9e1..9c5906f6b60 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/organization/OrganizationDbTester.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/organization/OrganizationDbTester.java @@ -117,14 +117,14 @@ public class OrganizationDbTester { public void assertUserIsMemberOfOrganization(OrganizationDto organization, UserDto user) { assertThat(db.getDbClient().organizationMemberDao().select(db.getSession(), organization.getUuid(), user.getId())).as("User is not member of the organization").isPresent(); - Integer defaultGroupId = db.getDbClient().organizationDao().getDefaultGroupId(db.getSession(), organization.getUuid()).get(); + String defaultGroupUuid = db.getDbClient().organizationDao().getDefaultGroupUuid(db.getSession(), organization.getUuid()).get(); assertThat(db.getDbClient().groupMembershipDao().selectGroups( db.getSession(), GroupMembershipQuery.builder().membership(IN).organizationUuid(organization.getUuid()).build(), user.getId(), 0, 10)) - .extracting(GroupMembershipDto::getId) + .extracting(GroupMembershipDto::getUuid) .as("User is not member of the default group of the organization") - .containsOnly(defaultGroupId.longValue()); + .containsOnly(defaultGroupUuid); } public void assertUserIsNotMemberOfOrganization(OrganizationDto organization, UserDto user) { diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/permission/template/PermissionTemplateDbTester.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/permission/template/PermissionTemplateDbTester.java index f7c44f61a61..97ee6e56f74 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/permission/template/PermissionTemplateDbTester.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/permission/template/PermissionTemplateDbTester.java @@ -57,11 +57,11 @@ public class PermissionTemplateDbTester { } public void addGroupToTemplate(PermissionTemplateDto permissionTemplate, GroupDto group, String permission) { - addGroupToTemplate(permissionTemplate.getUuid(), group.getId(), permission); + addGroupToTemplate(permissionTemplate.getUuid(), group.getUuid(), permission); } - public void addGroupToTemplate(String templateUuid, @Nullable Integer groupId, String permission) { - dbClient.permissionTemplateDao().insertGroupPermission(dbSession, templateUuid, groupId, permission); + public void addGroupToTemplate(String templateUuid, @Nullable String groupUuid, String permission) { + dbClient.permissionTemplateDao().insertGroupPermission(dbSession, templateUuid, groupUuid, permission); db.commit(); } diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/qualityprofile/QualityProfileDbTester.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/qualityprofile/QualityProfileDbTester.java index e50bba618d7..349b319e7da 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/qualityprofile/QualityProfileDbTester.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/qualityprofile/QualityProfileDbTester.java @@ -127,7 +127,7 @@ public class QualityProfileDbTester { checkArgument(!profile.isBuiltIn(), "Built-In profile cannot be used"); dbClient.qProfileEditGroupsDao().insert(dbSession, new QProfileEditGroupsDto() .setUuid(Uuids.createFast()) - .setGroupId(group.getId()) + .setGroupUuid(group.getUuid()) .setQProfileUuid(profile.getKee()) ); dbSession.commit(); diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/GroupTesting.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/GroupTesting.java index 2bbdbef5142..2f904eadc74 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/GroupTesting.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/GroupTesting.java @@ -22,7 +22,6 @@ package org.sonar.db.user; import java.util.Date; import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric; -import static org.apache.commons.lang.math.RandomUtils.nextInt; import static org.apache.commons.lang.math.RandomUtils.nextLong; public class GroupTesting { @@ -33,7 +32,7 @@ public class GroupTesting { public static GroupDto newGroupDto() { return new GroupDto() - .setId(nextInt()) + .setUuid(randomAlphanumeric(40)) .setOrganizationUuid(randomAlphanumeric(40)) .setName(randomAlphanumeric(255)) .setDescription(randomAlphanumeric(200)) diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/UserDbTester.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/UserDbTester.java index 3aec11d801f..5d8cb40ac21 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/UserDbTester.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/user/UserDbTester.java @@ -167,12 +167,12 @@ public class UserDbTester { public GroupDto insertDefaultGroup(GroupDto dto) { String organizationUuid = dto.getOrganizationUuid(); - db.getDbClient().organizationDao().getDefaultGroupId(db.getSession(), organizationUuid) - .ifPresent(groupId -> { + db.getDbClient().organizationDao().getDefaultGroupUuid(db.getSession(), organizationUuid) + .ifPresent(groupUuid -> { throw new IllegalArgumentException(format("Organization '%s' has already a default group", organizationUuid)); }); db.getDbClient().groupDao().insert(db.getSession(), dto); - db.getDbClient().organizationDao().setDefaultGroupId(db.getSession(), organizationUuid, dto); + db.getDbClient().organizationDao().setDefaultGroupUuid(db.getSession(), organizationUuid, dto); db.commit(); return dto; } @@ -186,8 +186,8 @@ public class UserDbTester { } @CheckForNull - public GroupDto selectGroupById(int groupId) { - return db.getDbClient().groupDao().selectById(db.getSession(), groupId); + public GroupDto selectGroupByUuid(String groupUuid) { + return db.getDbClient().groupDao().selectByUuid(db.getSession(), groupUuid); } public Optional<GroupDto> selectGroup(OrganizationDto org, String name) { @@ -201,7 +201,7 @@ public class UserDbTester { // GROUP MEMBERSHIP public UserGroupDto insertMember(GroupDto group, UserDto user) { - UserGroupDto dto = new UserGroupDto().setGroupId(group.getId()).setUserId(user.getId()); + UserGroupDto dto = new UserGroupDto().setGroupUuid(group.getUuid()).setUserId(user.getId()); db.getDbClient().userGroupDao().insert(db.getSession(), dto); db.commit(); return dto; @@ -209,14 +209,14 @@ public class UserDbTester { public void insertMembers(GroupDto group, UserDto... users) { Arrays.stream(users).forEach(user -> { - UserGroupDto dto = new UserGroupDto().setGroupId(group.getId()).setUserId(user.getId()); + UserGroupDto dto = new UserGroupDto().setGroupUuid(group.getUuid()).setUserId(user.getId()); db.getDbClient().userGroupDao().insert(db.getSession(), dto); }); db.commit(); } - public List<Integer> selectGroupIdsOfUser(UserDto user) { - return db.getDbClient().groupMembershipDao().selectGroupIdsByUserId(db.getSession(), user.getId()); + public List<String> selectGroupUuidsOfUser(UserDto user) { + return db.getDbClient().groupMembershipDao().selectGroupUuidsByUserId(db.getSession(), user.getId()); } // GROUP PERMISSIONS @@ -225,7 +225,7 @@ public class UserDbTester { GroupPermissionDto dto = new GroupPermissionDto() .setUuid(Uuids.createFast()) .setOrganizationUuid(org.getUuid()) - .setGroupId(null) + .setGroupUuid(null) .setRole(permission); db.getDbClient().groupPermissionDao().insert(db.getSession(), dto); db.commit(); @@ -240,7 +240,7 @@ public class UserDbTester { GroupPermissionDto dto = new GroupPermissionDto() .setUuid(Uuids.createFast()) .setOrganizationUuid(group.getOrganizationUuid()) - .setGroupId(group.getId()) + .setGroupUuid(group.getUuid()) .setRole(permission); db.getDbClient().groupPermissionDao().insert(db.getSession(), dto); db.commit(); @@ -252,7 +252,7 @@ public class UserDbTester { } public void deletePermissionFromGroup(GroupDto group, String permission) { - db.getDbClient().groupPermissionDao().delete(db.getSession(), permission, group.getOrganizationUuid(), group.getId(), null); + db.getDbClient().groupPermissionDao().delete(db.getSession(), permission, group.getOrganizationUuid(), group.getUuid(), null); db.commit(); } @@ -264,7 +264,7 @@ public class UserDbTester { GroupPermissionDto dto = new GroupPermissionDto() .setUuid(Uuids.createFast()) .setOrganizationUuid(project.getOrganizationUuid()) - .setGroupId(null) + .setGroupUuid(null) .setRole(permission) .setComponentUuid(project.uuid()); db.getDbClient().groupPermissionDao().insert(db.getSession(), dto); @@ -285,7 +285,7 @@ public class UserDbTester { GroupPermissionDto dto = new GroupPermissionDto() .setUuid(Uuids.createFast()) .setOrganizationUuid(group.getOrganizationUuid()) - .setGroupId(group.getId()) + .setGroupUuid(group.getUuid()) .setRole(permission) .setComponentUuid(project.uuid()); db.getDbClient().groupPermissionDao().insert(db.getSession(), dto); @@ -296,10 +296,10 @@ public class UserDbTester { public List<String> selectGroupPermissions(GroupDto group, @Nullable ComponentDto project) { if (project == null) { return db.getDbClient().groupPermissionDao().selectGlobalPermissionsOfGroup(db.getSession(), - group.getOrganizationUuid(), group.getId()); + group.getOrganizationUuid(), group.getUuid()); } return db.getDbClient().groupPermissionDao().selectProjectPermissionsOfGroup(db.getSession(), - group.getOrganizationUuid(), group.getId(), project.uuid()); + group.getOrganizationUuid(), group.getUuid(), project.uuid()); } public List<String> selectAnyonePermissions(OrganizationDto org, @Nullable ComponentDto project) { |