SONAR-13221 change PERM_TEMPLATES_USERS user_id FK to user_uuid

server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java

@@ -164,11 +164,11 @@ public class PermissionTemplateDao implements Dao {
     return permissionTemplate;
   }
 
-  public void insertUserPermission(DbSession session, String templateUuid, Integer userId, String permission) {
+  public void insertUserPermission(DbSession session, String templateUuid, String userUuid, String permission) {
     PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
       .setUuid(uuidFactory.create())
       .setTemplateUuid(templateUuid)
-      .setUserId(userId)
+      .setUserUuid(userUuid)
       .setPermission(permission)
       .setCreatedAt(now())
       .setUpdatedAt(now());
@@ -177,21 +177,21 @@ public class PermissionTemplateDao implements Dao {
     session.commit();
   }
 
-  public void deleteUserPermission(DbSession session, String templateUuid, Integer userId, String permission) {
+  public void deleteUserPermission(DbSession session, String templateUuid, String userUuid, String permission) {
     PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
       .setTemplateUuid(templateUuid)
       .setPermission(permission)
-      .setUserId(userId);
+      .setUserUuid(userUuid);
     mapper(session).deleteUserPermission(permissionTemplateUser);
     session.commit();
   }
 
-  public void deleteUserPermissionsByOrganization(DbSession dbSession, String organizationUuid, int userId) {
-    mapper(dbSession).deleteUserPermissionsByOrganization(organizationUuid, userId);
+  public void deleteUserPermissionsByOrganization(DbSession dbSession, String organizationUuid, String userUuid) {
+    mapper(dbSession).deleteUserPermissionsByOrganization(organizationUuid, userUuid);
   }
 
-  public void deleteUserPermissionsByUserId(DbSession dbSession, int userId) {
-    mapper(dbSession).deleteUserPermissionsByUserId(userId);
+  public void deleteUserPermissionsByUserUuid(DbSession dbSession, String userUuid) {
+    mapper(dbSession).deleteUserPermissionsByUserUuid(userUuid);
   }
 
   public void insertGroupPermission(DbSession session, String templateUuid, @Nullable String groupUuid, String permission) {

server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java

@@ -44,9 +44,9 @@ public interface PermissionTemplateMapper {
 
   void deleteUserPermissionsByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
 
-  void deleteUserPermissionsByOrganization(@Param("organizationUuid") String organizationUuid, @Param("userId") int userId);
+  void deleteUserPermissionsByOrganization(@Param("organizationUuid") String organizationUuid, @Param("userUuid") String userUuid);
 
-  void deleteUserPermissionsByUserId(@Param("userId") int userId);
+  void deleteUserPermissionsByUserUuid(@Param("userUuid") String userUuid);
 
   void deleteUserPermission(PermissionTemplateUserDto permissionTemplateUser);
 

server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateUserDto.java

@@ -24,7 +24,7 @@ import java.util.Date;
 public class PermissionTemplateUserDto {
   private String uuid;
   private String templateUuid;
-  private Integer userId;
+  private String userUuid;
   private String permission;
   private String userName;
   private String userLogin;
@@ -49,12 +49,12 @@ public class PermissionTemplateUserDto {
     return this;
   }
 
-  public Integer getUserId() {
-    return userId;
+  public String getUserUuid() {
+    return userUuid;
   }
 
-  public PermissionTemplateUserDto setUserId(Integer userId) {
-    this.userId = userId;
+  public PermissionTemplateUserDto setUserUuid(String userUuid) {
+    this.userUuid = userUuid;
     return this;
   }
 

server/sonar-db-dao/src/main/resources/org/sonar/db/permission/template/PermissionTemplateMapper.xml

@@ -54,21 +54,21 @@
   <delete id="deleteUserPermission" parameterType="PermissionTemplateUser">
     DELETE FROM perm_templates_users
     WHERE template_uuid = #{templateUuid}
-    AND user_id = #{userId}
+    AND user_uuid = #{userUuid}
     AND permission_reference = #{permission}
   </delete>
 
   <delete id="deleteUserPermissionsByOrganization" parameterType="map">
     delete from perm_templates_users
     where
-    user_id = #{userId,jdbcType=INTEGER}
+    user_uuid = #{userUuid,jdbcType=VARCHAR}
     and template_uuid in (select uuid from permission_templates where organization_uuid=#{organizationUuid,jdbcType=VARCHAR})
   </delete>
 
-  <delete id="deleteUserPermissionsByUserId" parameterType="integer">
+  <delete id="deleteUserPermissionsByUserUuid" parameterType="String">
     delete from perm_templates_users
     where
-    user_id = #{userId,jdbcType=INTEGER}
+    user_uuid = #{userUuid,jdbcType=VARCHAR}
   </delete>
 
   <delete id="deleteGroupPermissionsByTemplateUuid" parameterType="String">
@@ -103,8 +103,8 @@
   </delete>
 
   <insert id="insertUserPermission" parameterType="PermissionTemplateUser">
-    INSERT INTO perm_templates_users (uuid, template_uuid, user_id, permission_reference, created_at, updated_at)
-    VALUES (#{uuid}, #{templateUuid}, #{userId}, #{permission}, #{createdAt}, #{updatedAt})
+    INSERT INTO perm_templates_users (uuid, template_uuid, user_uuid, permission_reference, created_at, updated_at)
+    VALUES (#{uuid}, #{templateUuid}, #{userUuid}, #{permission}, #{createdAt}, #{updatedAt})
   </insert>
 
   <insert id="insertGroupPermission" parameterType="PermissionTemplateGroup">
@@ -140,7 +140,7 @@
 
   <sql id="userLoginsByQueryAndTemplate">
     FROM users u
-    LEFT JOIN perm_templates_users ptu ON ptu.user_id=u.id
+    LEFT JOIN perm_templates_users ptu ON ptu.user_uuid=u.uuid
       AND ptu.template_uuid=#{templateUuid}
     INNER JOIN organization_members om ON u.uuid=om.user_uuid
       AND om.organization_uuid=#{query.organizationUuid}
@@ -251,7 +251,7 @@
     ptu.uuid,
     ptu.template_uuid as templateUuid,
     ptu.permission_reference AS permission,
-    ptu.user_id AS userId,
+    ptu.user_uuid AS userUuid,
     u.name AS userName,
     u.login AS userLogin,
     ptu.created_at AS createdAt,
@@ -262,7 +262,7 @@
     SELECT
     <include refid="permissionTemplateUserColumns"/>
     FROM perm_templates_users ptu
-    INNER JOIN users u ON u.id = ptu.user_id AND u.active = ${_true}
+    INNER JOIN users u ON u.uuid = ptu.user_uuid AND u.active = ${_true}
     <where>
       AND ptu.template_uuid = #{templateUuid}
       <if test="!logins.isEmpty()">
@@ -321,9 +321,8 @@
       -- from template users
       select ptu.permission_reference as permission_key
       from perm_templates_users ptu
-      inner join users u on u.id = ptu.user_id
       <where>
-        and u.uuid=#{userUuid}
+        and ptu.user_uuid=#{userUuid}
         and ptu.template_uuid=#{templateUuid}
       </where>
       UNION
@@ -356,7 +355,7 @@
           resultType="org.sonar.db.permission.template.CountByTemplateAndPermissionDto">
     SELECT ptu.template_uuid as templateUuid, ptu.permission_reference as permission, count(u.login) as count
     FROM users u
-    INNER JOIN perm_templates_users ptu ON ptu.user_id=u.id
+    INNER JOIN perm_templates_users ptu ON ptu.user_uuid=u.uuid
     AND ptu.template_uuid in
     <foreach collection="templateUuids" open="(" close=")" item="id" separator=",">
       #{id}

server/sonar-db-dao/src/schema/schema-sq.ddl

@@ -561,12 +561,12 @@ CREATE TABLE "PERM_TEMPLATES_GROUPS"(
 ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
 
 CREATE TABLE "PERM_TEMPLATES_USERS"(
-    "USER_ID" INTEGER NOT NULL,
     "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
     "CREATED_AT" TIMESTAMP,
     "UPDATED_AT" TIMESTAMP,
     "UUID" VARCHAR(40) NOT NULL,
-    "TEMPLATE_UUID" VARCHAR(40) NOT NULL
+    "TEMPLATE_UUID" VARCHAR(40) NOT NULL,
+    "USER_UUID" VARCHAR(40) NOT NULL
 );
 ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
 

server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java

@@ -209,13 +209,13 @@ public class PermissionTemplateDaoTest {
     PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization());
     UserDto user = db.users().insertUser();
 
-    underTest.insertUserPermission(dbSession, permissionTemplate.getUuid(), user.getId(), "user");
+    underTest.insertUserPermission(dbSession, permissionTemplate.getUuid(), user.getUuid(), "user");
 
     assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getUuid()))
-      .extracting(PermissionTemplateUserDto::getTemplateUuid, PermissionTemplateUserDto::getUserId, PermissionTemplateUserDto::getPermission,
+      .extracting(PermissionTemplateUserDto::getTemplateUuid, PermissionTemplateUserDto::getUserUuid, PermissionTemplateUserDto::getPermission,
         PermissionTemplateUserDto::getCreatedAt,
         PermissionTemplateUserDto::getUpdatedAt)
-      .containsOnly(tuple(permissionTemplate.getUuid(), user.getId(), "user", NOW, NOW));
+      .containsOnly(tuple(permissionTemplate.getUuid(), user.getUuid(), "user", NOW, NOW));
   }
 
   @Test
@@ -227,11 +227,11 @@ public class PermissionTemplateDaoTest {
     templateDb.addUserToTemplate(permissionTemplate, user1, "admin");
     templateDb.addUserToTemplate(permissionTemplate, user2, "user");
 
-    underTest.deleteUserPermission(dbSession, permissionTemplate.getUuid(), user1.getId(), "user");
+    underTest.deleteUserPermission(dbSession, permissionTemplate.getUuid(), user1.getUuid(), "user");
 
     assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getUuid()))
-      .extracting(PermissionTemplateUserDto::getUserId, PermissionTemplateUserDto::getPermission)
-      .containsOnly(tuple(user1.getId(), "admin"), tuple(user2.getId(), "user"));
+      .extracting(PermissionTemplateUserDto::getUserUuid, PermissionTemplateUserDto::getPermission)
+      .containsOnly(tuple(user1.getUuid(), "admin"), tuple(user2.getUuid(), "user"));
   }
 
   @Test
@@ -315,12 +315,12 @@ public class PermissionTemplateDaoTest {
     UserDto user2 = db.users().insertUser();
     UserDto user3 = db.users().insertUser();
 
-    templateDb.addUserToTemplate(template1.getUuid(), user1.getId(), ADMIN);
-    templateDb.addUserToTemplate(template1.getUuid(), user2.getId(), ADMIN);
-    templateDb.addUserToTemplate(template1.getUuid(), user3.getId(), ADMIN);
-    templateDb.addUserToTemplate(template1.getUuid(), user1.getId(), USER);
-    templateDb.addUserToTemplate(template2.getUuid(), user1.getId(), USER);
-    templateDb.addUserToTemplate(anotherTemplate.getUuid(), user1.getId(), ISSUE_ADMIN);
+    templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), ADMIN);
+    templateDb.addUserToTemplate(template1.getUuid(), user2.getUuid(), ADMIN);
+    templateDb.addUserToTemplate(template1.getUuid(), user3.getUuid(), ADMIN);
+    templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), USER);
+    templateDb.addUserToTemplate(template2.getUuid(), user1.getUuid(), USER);
+    templateDb.addUserToTemplate(anotherTemplate.getUuid(), user1.getUuid(), ISSUE_ADMIN);
 
     final List<CountByTemplateAndPermissionDto> result = new ArrayList<>();
     underTest.usersCountByTemplateUuidAndPermission(dbSession, asList(template1.getUuid(), template2.getUuid(), template3.getUuid()),
@@ -358,8 +358,8 @@ public class PermissionTemplateDaoTest {
     PermissionTemplateDto template = templateDb.insertTemplate();
     templateDb.addProjectCreatorToTemplate(template.getUuid(), SCAN_EXECUTION);
     templateDb.addProjectCreatorToTemplate(template.getUuid(), UserRole.ADMIN);
-    templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER);
-    templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.ADMIN);
+    templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), UserRole.USER);
+    templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), 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);
@@ -438,18 +438,18 @@ public class PermissionTemplateDaoTest {
     PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
     PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
     String permission = "PERMISSION";
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getId(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getUuid(), permission);
 
-    underTest.deleteUserPermissionsByOrganization(dbSession, organization.getUuid(), user.getId());
+    underTest.deleteUserPermissionsByOrganization(dbSession, organization.getUuid(), user.getUuid());
 
-    assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(anotherUser.getId());
-    assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(user.getId());
+    assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid).containsOnly(anotherUser.getUuid());
+    assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid).containsOnly(user.getUuid());
   }
 
   @Test
-  public void delete_user_permissions_by_user_id() {
+  public void delete_user_permissions_by_user_uuid() {
     OrganizationDto organization = db.organizations().insert();
     OrganizationDto anotherOrganization = db.organizations().insert();
     UserDto user = db.users().insertUser();
@@ -457,16 +457,16 @@ public class PermissionTemplateDaoTest {
     PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
     PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
     String permission = "PERMISSION";
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getId(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getUuid(), permission);
 
-    underTest.deleteUserPermissionsByUserId(dbSession, user.getId());
+    underTest.deleteUserPermissionsByUserUuid(dbSession, user.getUuid());
     db.commit();
 
-    assertThat(db.select("select template_uuid as \"templateUuid\", user_id as \"userId\", permission_reference as \"permission\" from perm_templates_users"))
-      .extracting((row) -> row.get("templateUuid"), (row) -> row.get("userId"), (row) -> row.get("permission"))
-      .containsOnly(tuple(template.getUuid(), anotherUser.getId().longValue(), permission));
+    assertThat(db.select("select template_uuid as \"templateUuid\", user_uuid as \"userUuid\", permission_reference as \"permission\" from perm_templates_users"))
+      .extracting((row) -> row.get("templateUuid"), (row) -> row.get("userUuid"), (row) -> row.get("permission"))
+      .containsOnly(tuple(template.getUuid(), anotherUser.getUuid(), permission));
   }
 
   private PermissionTemplateDto createTemplate(OrganizationDto organization) {
@@ -476,8 +476,8 @@ public class PermissionTemplateDaoTest {
     PermissionTemplateDto template = templateDb.insertTemplate(organization);
     templateDb.addProjectCreatorToTemplate(template.getUuid(), SCAN_EXECUTION);
     templateDb.addProjectCreatorToTemplate(template.getUuid(), UserRole.ADMIN);
-    templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER);
-    templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.ADMIN);
+    templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), UserRole.USER);
+    templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), 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);

server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/UserWithPermissionTemplateDaoTest.java

@@ -154,7 +154,7 @@ public class UserWithPermissionTemplateDaoTest {
     UserDto user2 = db.users().insertUser(u -> u.setName("B"));
     UserDto user3 = db.users().insertUser(u -> u.setName("C"));
     db.organizations().addMember(organization, user1, user2, user3);
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), user3.getId(), UserRole.USER);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), user3.getUuid(), UserRole.USER);
 
     PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
     assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getUuid()))

server/sonar-db-dao/src/testFixtures/java/org/sonar/db/permission/template/PermissionTemplateDbTester.java

@@ -70,11 +70,11 @@ public class PermissionTemplateDbTester {
   }
 
   public void addUserToTemplate(PermissionTemplateDto permissionTemplate, UserDto user, String permission) {
-    addUserToTemplate(permissionTemplate.getUuid(), user.getId(), permission);
+    addUserToTemplate(permissionTemplate.getUuid(), user.getUuid(), permission);
   }
 
-  public void addUserToTemplate(String templateUuid, int userId, String permission) {
-    dbClient.permissionTemplateDao().insertUserPermission(dbSession, templateUuid, userId, permission);
+  public void addUserToTemplate(String templateUuid, String userUuid, String permission) {
+    dbClient.permissionTemplateDao().insertUserPermission(dbSession, templateUuid, userUuid, permission);
     db.commit();
   }
 

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/DbVersion83.java

@@ -275,6 +275,10 @@ import org.sonar.server.platform.db.migration.version.v83.users.fk.organizationm
 import org.sonar.server.platform.db.migration.version.v83.users.fk.organizationmembers.DropUserIdColumnOfOrganizationMembersTable;
 import org.sonar.server.platform.db.migration.version.v83.users.fk.organizationmembers.MakeOrganizationMembersUserUuidColumnNotNullable;
 import org.sonar.server.platform.db.migration.version.v83.users.fk.organizationmembers.PopulateOrganizationMembersUserUuid;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers.AddUserUuidColumnToPermTemplatesUsers;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers.DropUserIdColumnOfPermTemplatesUsersTable;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers.MakePermTemplatesUsersUserUuidColumnNotNullable;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers.PopulatePermTemplatesUsersUserUuid;
 import org.sonar.server.platform.db.migration.version.v83.usertokens.AddPrimaryKeyOnUuidColumnOfUserTokensTable;
 import org.sonar.server.platform.db.migration.version.v83.usertokens.AddUuidColumnToUserTokens;
 import org.sonar.server.platform.db.migration.version.v83.usertokens.DropIdColumnOfUserTokensTable;
@@ -662,6 +666,14 @@ public class DbVersion83 implements DbVersion {
       .add(3647, "Add index on 'user_uuid' column of 'ORGANIZATION_MEMBERS' table", AddIndexOnUserUuidOfOrganizationMembersTable.class)
       .add(3648, "Drop index on 'user_id', 'group_id' columns of 'ORGANIZATION_MEMBERS' table", DropPrimaryKeyOnUserIdAndOrganizationUuidOfOrganizationMembersTable.class)
       .add(3649, "Add PK on 'user_uuid', 'organization_uuid' columns of 'ORGANIZATION_MEMBERS' table", AddPrimaryKeyOnUserUuidAndOrganizationUuidColumnsOfUserRolesTable.class)
-      .add(3650, "Drop column on 'user_id' column of 'ORGANIZATION_MEMBERS' table", DropUserIdColumnOfOrganizationMembersTable.class);
+      .add(3650, "Drop column on 'user_id' column of 'ORGANIZATION_MEMBERS' table", DropUserIdColumnOfOrganizationMembersTable.class)
+
+      // Migration of FK in PERM_TEMPLATES_USERS to USERS
+      .add(3651, "Add 'user_uuid' column on 'PERM_TEMPLATES_USERS' table", AddUserUuidColumnToPermTemplatesUsers.class)
+      .add(3652, "Populate 'user_uuid' for 'PERM_TEMPLATES_USERS'", PopulatePermTemplatesUsersUserUuid.class)
+      .add(3653, "Make 'user_uuid' not-null for 'PERM_TEMPLATES_USERS'", MakePermTemplatesUsersUserUuidColumnNotNullable.class)
+      .add(3654, "Drop column on 'user_id' column of 'PERM_TEMPLATES_USERS' table", DropUserIdColumnOfPermTemplatesUsersTable.class)
+
+    ;
   }
 }

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/groupsusers/AddUserUuidColumnToGroupsUsers.java

@@ -19,32 +19,11 @@
  */
 package org.sonar.server.platform.db.migration.version.v83.users.fk.groupsusers;
 
-import java.sql.SQLException;
 import org.sonar.db.Database;
-import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
-import org.sonar.server.platform.db.migration.sql.AddColumnsBuilder;
-import org.sonar.server.platform.db.migration.step.DdlChange;
-
-import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
-
-public class AddUserUuidColumnToGroupsUsers extends DdlChange {
-  private static final String TABLE = "groups_users";
-
-  private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
-    .setColumnName("user_uuid")
-    .setIsNullable(true)
-    .setDefaultValue(null)
-    .setLimit(VarcharColumnDef.UUID_SIZE)
-    .build();
+import org.sonar.server.platform.db.migration.version.v83.users.fk.util.AddUserUuidColumnToTable;
 
+public class AddUserUuidColumnToGroupsUsers extends AddUserUuidColumnToTable {
   public AddUserUuidColumnToGroupsUsers(Database db) {
-    super(db);
-  }
-
-  @Override
-  public void execute(Context context) throws SQLException {
-    context.execute(new AddColumnsBuilder(getDialect(), TABLE)
-      .addColumn(uuidColumnDefinition)
-      .build());
+    super(db, "groups_users");
   }
 }

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/organizationmembers/AddUserUuidColumnToOrganizationMembers.java

@@ -19,32 +19,11 @@
  */
 package org.sonar.server.platform.db.migration.version.v83.users.fk.organizationmembers;
 
-import java.sql.SQLException;
 import org.sonar.db.Database;
-import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
-import org.sonar.server.platform.db.migration.sql.AddColumnsBuilder;
-import org.sonar.server.platform.db.migration.step.DdlChange;
-
-import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
-
-public class AddUserUuidColumnToOrganizationMembers extends DdlChange {
-  private static final String TABLE = "organization_members";
-
-  private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
-    .setColumnName("user_uuid")
-    .setIsNullable(true)
-    .setDefaultValue(null)
-    .setLimit(VarcharColumnDef.UUID_SIZE)
-    .build();
+import org.sonar.server.platform.db.migration.version.v83.users.fk.util.AddUserUuidColumnToTable;
 
+public class AddUserUuidColumnToOrganizationMembers extends AddUserUuidColumnToTable {
   public AddUserUuidColumnToOrganizationMembers(Database db) {
-    super(db);
-  }
-
-  @Override
-  public void execute(Context context) throws SQLException {
-    context.execute(new AddColumnsBuilder(getDialect(), TABLE)
-      .addColumn(uuidColumnDefinition)
-      .build());
+    super(db, "organization_members");
   }
 }

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/organizationmembers/MakeOrganizationMembersUserUuidColumnNotNullable.java

@@ -19,31 +19,13 @@
  */
 package org.sonar.server.platform.db.migration.version.v83.users.fk.organizationmembers;
 
-import java.sql.SQLException;
 import org.sonar.db.Database;
-import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
-import org.sonar.server.platform.db.migration.sql.AlterColumnsBuilder;
-import org.sonar.server.platform.db.migration.step.DdlChange;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.util.MakeUserUuidColumnNotNullable;
 
-import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
-
-public class MakeOrganizationMembersUserUuidColumnNotNullable extends DdlChange {
+public class MakeOrganizationMembersUserUuidColumnNotNullable extends MakeUserUuidColumnNotNullable {
   private static final String TABLE_NAME = "organization_members";
-  private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
-    .setColumnName("user_uuid")
-    .setIsNullable(false)
-    .setDefaultValue(null)
-    .setLimit(VarcharColumnDef.UUID_SIZE)
-    .build();
 
   public MakeOrganizationMembersUserUuidColumnNotNullable(Database db) {
-    super(db);
-  }
-
-  @Override
-  public void execute(Context context) throws SQLException {
-    context.execute(new AlterColumnsBuilder(getDialect(), TABLE_NAME)
-      .updateColumn(uuidColumnDefinition)
-      .build());
+    super(db, TABLE_NAME);
   }
 }

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/AddUserUuidColumnToPermTemplatesUsers.java

@@ -0,0 +1,30 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.util.AddUserUuidColumnToTable;
+
+public class AddUserUuidColumnToPermTemplatesUsers extends AddUserUuidColumnToTable {
+
+  public AddUserUuidColumnToPermTemplatesUsers(Database db) {
+    super(db, "perm_templates_users");
+  }
+}

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/DropUserIdColumnOfPermTemplatesUsersTable.java

@@ -0,0 +1,36 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.sql.DropColumnsBuilder;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+public class DropUserIdColumnOfPermTemplatesUsersTable extends DdlChange {
+  public DropUserIdColumnOfPermTemplatesUsersTable(Database db) {
+    super(db);
+  }
+
+  @Override
+  public void execute(Context context) throws SQLException {
+    context.execute(new DropColumnsBuilder(getDialect(), "perm_templates_users", "user_id").build());
+  }
+}

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/MakePermTemplatesUsersUserUuidColumnNotNullable.java

@@ -0,0 +1,31 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.users.fk.util.MakeUserUuidColumnNotNullable;
+
+public class MakePermTemplatesUsersUserUuidColumnNotNullable extends MakeUserUuidColumnNotNullable {
+  private static final String TABLE_NAME = "perm_templates_users";
+
+  public MakePermTemplatesUsersUserUuidColumnNotNullable(Database db) {
+    super(db, TABLE_NAME);
+  }
+}

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/PopulatePermTemplatesUsersUserUuid.java

@@ -0,0 +1,52 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DataChange;
+import org.sonar.server.platform.db.migration.step.MassUpdate;
+
+public class PopulatePermTemplatesUsersUserUuid extends DataChange {
+
+  public PopulatePermTemplatesUsersUserUuid(Database db) {
+    super(db);
+  }
+
+  @Override
+  protected void execute(Context context) throws SQLException {
+    MassUpdate massUpdate = context.prepareMassUpdate();
+
+    massUpdate.select("select ptu.uuid, u.uuid " +
+      "from perm_templates_users ptu " +
+      "join users u on ptu.user_id = u.id where ptu.user_uuid is null");
+
+    massUpdate.update("update perm_templates_users set user_uuid = ? where uuid = ?");
+
+    massUpdate.execute((row, update, index) -> {
+      String permTemplatesUuid = row.getString(1);
+      String userUuid = row.getString(2);
+
+      update.setString(1, userUuid);
+      update.setString(2, permTemplatesUuid);
+      return true;
+    });
+  }
+}

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/util/AddUserUuidColumnToTable.java

@@ -0,0 +1,51 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.util;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
+import org.sonar.server.platform.db.migration.sql.AddColumnsBuilder;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
+
+public class AddUserUuidColumnToTable extends DdlChange {
+  private final String tableName;
+
+  private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+    .setColumnName("user_uuid")
+    .setIsNullable(true)
+    .setDefaultValue(null)
+    .setLimit(VarcharColumnDef.UUID_SIZE)
+    .build();
+
+  public AddUserUuidColumnToTable(Database db, String tableName) {
+    super(db);
+    this.tableName = tableName;
+  }
+
+  @Override
+  public void execute(Context context) throws SQLException {
+    context.execute(new AddColumnsBuilder(getDialect(), tableName)
+      .addColumn(uuidColumnDefinition)
+      .build());
+  }
+}

server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/version/v83/users/fk/util/MakeUserUuidColumnNotNullable.java

@@ -0,0 +1,51 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.util;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
+import org.sonar.server.platform.db.migration.sql.AlterColumnsBuilder;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
+
+public class MakeUserUuidColumnNotNullable extends DdlChange {
+  private final String tableName;
+
+  private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+    .setColumnName("user_uuid")
+    .setIsNullable(false)
+    .setDefaultValue(null)
+    .setLimit(VarcharColumnDef.UUID_SIZE)
+    .build();
+
+  public MakeUserUuidColumnNotNullable(Database db, String tableName) {
+    super(db);
+    this.tableName = tableName;
+  }
+
+  @Override
+  public void execute(Context context) throws SQLException {
+    context.execute(new AlterColumnsBuilder(getDialect(), tableName)
+      .updateColumn(uuidColumnDefinition)
+      .build());
+  }
+}

server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/AddUserUuidColumnToPermTemplatesUsersTest.java

@@ -0,0 +1,65 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import java.sql.Types;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.Uuids;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AddUserUuidColumnToPermTemplatesUsersTest {
+
+  @Rule
+  public CoreDbTester db = CoreDbTester.createForSchema(AddUserUuidColumnToPermTemplatesUsersTest.class, "schema.sql");
+
+  private DdlChange underTest = new AddUserUuidColumnToPermTemplatesUsers(db.database());
+
+  @Before
+  public void setup() {
+    insertPermTemplatesUser(Uuids.createFast(), 1L);
+    insertPermTemplatesUser(Uuids.createFast(), 2L);
+    insertPermTemplatesUser(Uuids.createFast(), 3L);
+  }
+
+  @Test
+  public void add_uuid_column() throws SQLException {
+    underTest.execute();
+
+    db.assertColumnDefinition("perm_templates_users", "user_uuid", Types.VARCHAR, 40, true);
+
+    assertThat(db.countSql("select count(*) from perm_templates_users"))
+      .isEqualTo(3);
+  }
+
+  private void insertPermTemplatesUser(String uuid, long userId) {
+    db.executeInsert("perm_templates_users",
+      "uuid", uuid,
+      "user_id", userId,
+      "template_id", userId + 100,
+      "permission_reference", Uuids.createFast());
+  }
+
+}

server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/DropUserIdColumnOfPermTemplatesUsersTableTest.java

@@ -0,0 +1,51 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropUserIdColumnOfPermTemplatesUsersTableTest {
+
+  @Rule
+  public CoreDbTester db = CoreDbTester.createForSchema(DropUserIdColumnOfPermTemplatesUsersTableTest.class, "schema.sql");
+
+  private DdlChange underTest = new DropUserIdColumnOfPermTemplatesUsersTable(db.database());
+
+  @Test
+  public void execute() throws SQLException {
+    underTest.execute();
+
+    db.assertColumnDoesNotExist("perm_templates_users", "user_id");
+  }
+
+  @Test
+  public void migration_is_not_re_entrant() throws SQLException {
+    underTest.execute();
+
+    assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+  }
+
+}

server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/MakePermTemplatesUsersUserUuidColumnNotNullableTest.java

@@ -0,0 +1,43 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.MigrationStep;
+
+import static java.sql.Types.VARCHAR;
+import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.UUID_SIZE;
+
+public class MakePermTemplatesUsersUserUuidColumnNotNullableTest {
+  @Rule
+  public CoreDbTester db = CoreDbTester.createForSchema(MakePermTemplatesUsersUserUuidColumnNotNullableTest.class, "schema.sql");
+
+  private MigrationStep underTest = new MakePermTemplatesUsersUserUuidColumnNotNullable(db.database());
+
+  @Test
+  public void uuid_column_is_not_null() throws SQLException {
+    underTest.execute();
+
+    db.assertColumnDefinition("perm_templates_users", "user_uuid", VARCHAR, UUID_SIZE, false);
+  }
+}

server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/PopulatePermTemplatesUsersUserUuidTest.java

@@ -0,0 +1,145 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2020 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.version.v83.users.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.Uuids;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DataChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PopulatePermTemplatesUsersUserUuidTest {
+
+  @Rule
+  public CoreDbTester db = CoreDbTester.createForSchema(PopulatePermTemplatesUsersUserUuidTest.class, "schema.sql");
+
+  private DataChange underTest = new PopulatePermTemplatesUsersUserUuid(db.database());
+
+  @Test
+  public void populate_uuids() throws SQLException {
+    long userId_1 = 1L;
+    String userUuid_1 = "uuid-1";
+    insertUser(userId_1, userUuid_1);
+
+    long userId_2 = 2L;
+    String userUuid_2 = "uuid-2";
+    insertUser(userId_2, userUuid_2);
+
+    long userId_3 = 3L;
+    String userUuid_3 = "uuid-3";
+    insertUser(userId_3, userUuid_3);
+
+    long userId_4 = 4L;
+    String userUuid_4 = "uuid-4";
+    insertUser(userId_4, userUuid_4);
+
+    String permTemplatesUserUuid_1 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_1, userId_1);
+    String permTemplatesUserUuid_2 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_2, userId_2);
+    String permTemplatesUserUuid_3 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_3, userId_3);
+    String permTemplatesUserUuid_4 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_4, userId_4);
+    String permTemplatesUserUuid_5 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_5, userId_1);
+
+    underTest.execute();
+
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_1, userUuid_1);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_2, userUuid_2);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_3, userUuid_3);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_4, userUuid_4);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_5, userUuid_1);
+  }
+
+  @Test
+  public void migration_is_reentrant() throws SQLException {
+    long userId_1 = 1L;
+    String userUuid_1 = "uuid-1";
+    insertUser(userId_1, userUuid_1);
+
+    long userId_2 = 2L;
+    String userUuid_2 = "uuid-2";
+    insertUser(userId_2, userUuid_2);
+
+    long userId_3 = 3L;
+    String userUuid_3 = "uuid-3";
+    insertUser(userId_3, userUuid_3);
+
+    long userId_4 = 4L;
+    String userUuid_4 = "uuid-4";
+    insertUser(userId_4, userUuid_4);
+
+    String permTemplatesUserUuid_1 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_1, userId_1);
+    String permTemplatesUserUuid_2 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_2, userId_2);
+    String permTemplatesUserUuid_3 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_3, userId_3);
+
+    underTest.execute();
+
+    String permTemplatesUserUuid_4 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_4, userId_4);
+    String permTemplatesUserUuid_5 = Uuids.createFast();
+    insertPermTemplatesUser(permTemplatesUserUuid_5, userId_1);
+
+    // re-entrant
+    underTest.execute();
+
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_1, userUuid_1);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_2, userUuid_2);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_3, userUuid_3);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_4, userUuid_4);
+    assertThatPermTemplatesUsersUserUuidIsEqualTo(permTemplatesUserUuid_5, userUuid_1);
+  }
+
+  private void assertThatPermTemplatesUsersUserUuidIsEqualTo(String permTemplatesUserUuid, String expectedUuid) {
+    assertThat(db.select(String.format("select user_uuid from perm_templates_users where uuid = '%s'", permTemplatesUserUuid))
+      .stream()
+      .map(row -> row.get("USER_UUID"))
+      .findFirst())
+        .hasValue(expectedUuid);
+  }
+
+  private void insertPermTemplatesUser(String uuid, long userId) {
+    db.executeInsert("perm_templates_users",
+      "uuid", uuid,
+      "user_id", userId,
+      "template_id", userId + 100,
+      "permission_reference", Uuids.createFast());
+  }
+
+  private void insertUser(Long id, String uuid) {
+    db.executeInsert("users",
+      "id", id,
+      "uuid", uuid,
+      "login", "login" + id,
+      "external_login", "ex-login" + id,
+      "external_identity_provider", "ex-provider" + id,
+      "external_id", id + 1,
+      "is_root", false,
+      "onboarded", false);
+  }
+}

server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/AddUserUuidColumnToPermTemplatesUsersTest/schema.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+    "USER_ID" INTEGER NOT NULL,
+    "TEMPLATE_ID" INTEGER NOT NULL,
+    "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+    "CREATED_AT" TIMESTAMP,
+    "UPDATED_AT" TIMESTAMP,
+    "UUID" VARCHAR(40) NOT NULL
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");

server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/DropUserIdColumnOfPermTemplatesUsersTableTest/schema.sql

@@ -0,0 +1,11 @@
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+    "USER_ID" INTEGER NOT NULL,
+    "TEMPLATE_ID" INTEGER NOT NULL,
+    "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+    "CREATED_AT" TIMESTAMP,
+    "UPDATED_AT" TIMESTAMP,
+    "UUID" VARCHAR(40) NOT NULL,
+    "USER_UUID" VARCHAR(40) NOT NULL
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
+

server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/MakePermTemplatesUsersUserUuidColumnNotNullableTest/schema.sql

@@ -0,0 +1,11 @@
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+    "USER_ID" INTEGER NOT NULL,
+    "TEMPLATE_ID" INTEGER NOT NULL,
+    "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+    "CREATED_AT" TIMESTAMP,
+    "UPDATED_AT" TIMESTAMP,
+    "UUID" VARCHAR(40) NOT NULL,
+    "USER_UUID" VARCHAR(40)
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
+

server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/version/v83/users/fk/permtemplatesusers/PopulatePermTemplatesUsersUserUuidTest/schema.sql

@@ -0,0 +1,42 @@
+CREATE TABLE "USERS"(
+    "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+    "UUID" VARCHAR(255) NOT NULL,
+    "LOGIN" VARCHAR(255) NOT NULL,
+    "ORGANIZATION_UUID" VARCHAR(40),
+    "NAME" VARCHAR(200),
+    "EMAIL" VARCHAR(100),
+    "CRYPTED_PASSWORD" VARCHAR(100),
+    "SALT" VARCHAR(40),
+    "HASH_METHOD" VARCHAR(10),
+    "ACTIVE" BOOLEAN DEFAULT TRUE,
+    "SCM_ACCOUNTS" VARCHAR(4000),
+    "EXTERNAL_LOGIN" VARCHAR(255) NOT NULL,
+    "EXTERNAL_IDENTITY_PROVIDER" VARCHAR(100) NOT NULL,
+    "EXTERNAL_ID" VARCHAR(255) NOT NULL,
+    "IS_ROOT" BOOLEAN NOT NULL,
+    "USER_LOCAL" BOOLEAN,
+    "ONBOARDED" BOOLEAN NOT NULL,
+    "HOMEPAGE_TYPE" VARCHAR(40),
+    "HOMEPAGE_PARAMETER" VARCHAR(40),
+    "LAST_CONNECTION_DATE" BIGINT,
+    "CREATED_AT" BIGINT,
+    "UPDATED_AT" BIGINT
+);
+ALTER TABLE "USERS" ADD CONSTRAINT "PK_USERS" PRIMARY KEY("ID");
+CREATE UNIQUE INDEX "USERS_LOGIN" ON "USERS"("LOGIN");
+CREATE INDEX "USERS_UPDATED_AT" ON "USERS"("UPDATED_AT");
+CREATE UNIQUE INDEX "USERS_UUID" ON "USERS"("UUID");
+CREATE UNIQUE INDEX "UNIQ_EXTERNAL_ID" ON "USERS"("EXTERNAL_IDENTITY_PROVIDER", "EXTERNAL_ID");
+CREATE UNIQUE INDEX "UNIQ_EXTERNAL_LOGIN" ON "USERS"("EXTERNAL_IDENTITY_PROVIDER", "EXTERNAL_LOGIN");
+
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+    "USER_ID" INTEGER NOT NULL,
+    "TEMPLATE_ID" INTEGER NOT NULL,
+    "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+    "CREATED_AT" TIMESTAMP,
+    "UPDATED_AT" TIMESTAMP,
+    "UUID" VARCHAR(40) NOT NULL,
+    "USER_UUID" VARCHAR(40)
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
+

server/sonar-webserver-auth/src/main/java/org/sonar/server/organization/MemberUpdater.java

@@ -137,7 +137,7 @@ public class MemberUpdater {
     String userUuid = user.getUuid();
     String organizationUuid = organization.getUuid();
     dbClient.userPermissionDao().deleteOrganizationMemberPermissions(dbSession, organizationUuid, userId);
-    dbClient.permissionTemplateDao().deleteUserPermissionsByOrganization(dbSession, organizationUuid, userId);
+    dbClient.permissionTemplateDao().deleteUserPermissionsByOrganization(dbSession, organizationUuid, userUuid);
     dbClient.qProfileEditUsersDao().deleteByOrganizationAndUser(dbSession, organization, user);
     dbClient.userGroupDao().deleteByOrganizationAndUser(dbSession, organizationUuid, user.getUuid());
     dbClient.propertiesDao().deleteByOrganizationAndUser(dbSession, organizationUuid, userId);

server/sonar-webserver-auth/src/test/java/org/sonar/server/organization/MemberUpdaterTest.java

@@ -248,16 +248,16 @@ public class MemberUpdaterTest {
     PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
     PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
     String permission = "browse";
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getId(), permission);
-    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getId(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), anotherUser.getUuid(), permission);
+    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getUuid(), permission);
 
     underTest.removeMember(db.getSession(), organization, user);
 
-    assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), template.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
-      .containsOnly(anotherUser.getId());
-    assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
-      .containsOnly(user.getId());
+    assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), template.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid)
+      .containsOnly(anotherUser.getUuid());
+    assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid)
+      .containsOnly(user.getUuid());
   }
 
   @Test

server/sonar-webserver-webapi/src/main/java/org/sonar/server/permission/PermissionTemplateService.java

@@ -24,7 +24,9 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.apache.commons.lang.StringUtils;
@@ -41,6 +43,7 @@ import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
 import org.sonar.db.permission.template.PermissionTemplateDto;
 import org.sonar.db.permission.template.PermissionTemplateGroupDto;
 import org.sonar.db.permission.template.PermissionTemplateUserDto;
+import org.sonar.db.user.UserDto;
 import org.sonar.server.es.ProjectIndexer;
 import org.sonar.server.es.ProjectIndexers;
 import org.sonar.server.permission.DefaultTemplatesResolver.ResolvedDefaultTemplates;
@@ -129,11 +132,13 @@ public class PermissionTemplateService {
 
     List<PermissionTemplateUserDto> usersPermissions = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid());
     String organizationUuid = template.getOrganizationUuid();
+    Map<String, Integer> userDtoMap = dbClient.userDao().selectByUuids(dbSession, usersPermissions.stream().map(PermissionTemplateUserDto::getUserUuid).collect(Collectors.toSet()))
+      .stream().collect(Collectors.toMap(UserDto::getUuid, UserDto::getId));
     usersPermissions
       .stream()
       .filter(up -> permissionValidForProject(project, up.getPermission()))
       .forEach(up -> {
-        UserPermissionDto dto = new UserPermissionDto(uuidFactory.create(), organizationUuid, up.getPermission(), up.getUserId(), project.uuid());
+        UserPermissionDto dto = new UserPermissionDto(uuidFactory.create(), organizationUuid, up.getPermission(), userDtoMap.get(up.getUserUuid()), project.uuid());
         dbClient.userPermissionDao().insert(dbSession, dto);
       });
 
@@ -155,7 +160,7 @@ public class PermissionTemplateService {
     List<PermissionTemplateCharacteristicDto> characteristics = dbClient.permissionTemplateCharacteristicDao().selectByTemplateUuids(dbSession, singletonList(template.getUuid()));
     if (projectCreatorUserId != null) {
       Set<String> permissionsForCurrentUserAlreadyInDb = usersPermissions.stream()
-        .filter(userPermission -> projectCreatorUserId.equals(userPermission.getUserId()))
+        .filter(userPermission -> projectCreatorUserId.equals(userPermission.getUserUuid()))
         .map(PermissionTemplateUserDto::getPermission)
         .collect(java.util.stream.Collectors.toSet());
       characteristics.stream()

server/sonar-webserver-webapi/src/main/java/org/sonar/server/permission/ws/template/AddUserToTemplateAction.java

@@ -103,7 +103,7 @@ public class AddUserToTemplateAction implements PermissionsWsAction {
       wsSupport.checkMembership(dbSession, organizationDto, user);
 
       if (!isUserAlreadyAdded(dbSession, organizationDto, template.getUuid(), userLogin, permission)) {
-        dbClient.permissionTemplateDao().insertUserPermission(dbSession, template.getUuid(), user.getId(), permission);
+        dbClient.permissionTemplateDao().insertUserPermission(dbSession, template.getUuid(), user.getUuid(), permission);
         dbSession.commit();
       }
     }

server/sonar-webserver-webapi/src/main/java/org/sonar/server/permission/ws/template/RemoveUserFromTemplateAction.java

@@ -101,7 +101,7 @@ public class RemoveUserFromTemplateAction implements PermissionsWsAction {
 
       UserId user = wsSupport.findUser(dbSession, userLogin);
 
-      dbClient.permissionTemplateDao().deleteUserPermission(dbSession, template.getUuid(), user.getId(), permission);
+      dbClient.permissionTemplateDao().deleteUserPermission(dbSession, template.getUuid(), user.getUuid(), permission);
       dbSession.commit();
     }
   }

server/sonar-webserver-webapi/src/main/java/org/sonar/server/permission/ws/template/TemplateUsersAction.java

@@ -129,14 +129,14 @@ public class TemplateUsersAction implements PermissionsWsAction {
   }
 
   private Permissions.UsersWsResponse buildResponse(List<UserDto> users, List<PermissionTemplateUserDto> permissionTemplateUsers, Paging paging) {
-    Multimap<Integer, String> permissionsByUserId = TreeMultimap.create();
-    permissionTemplateUsers.forEach(userPermission -> permissionsByUserId.put(userPermission.getUserId(), userPermission.getPermission()));
+    Multimap<String, String> permissionsByUserUuid = TreeMultimap.create();
+    permissionTemplateUsers.forEach(userPermission -> permissionsByUserUuid.put(userPermission.getUserUuid(), userPermission.getPermission()));
 
     UsersWsResponse.Builder responseBuilder = UsersWsResponse.newBuilder();
     users.forEach(user -> {
       Permissions.User.Builder userResponse = responseBuilder.addUsersBuilder()
         .setLogin(user.getLogin())
-        .addAllPermissions(permissionsByUserId.get(user.getId()));
+        .addAllPermissions(permissionsByUserUuid.get(user.getUuid()));
       ofNullable(user.getEmail()).ifPresent(userResponse::setEmail);
       ofNullable(user.getName()).ifPresent(userResponse::setName);
       ofNullable(emptyToNull(user.getEmail())).ifPresent(u -> userResponse.setAvatar(avatarResolver.create(user)));

server/sonar-webserver-webapi/src/main/java/org/sonar/server/user/ws/DeactivateAction.java

@@ -98,14 +98,15 @@ public class DeactivateAction implements UsersWsAction {
       ensureNotLastAdministrator(dbSession, user);
 
       Integer userId = user.getId();
+      String userUuid = user.getUuid();
       dbClient.userTokenDao().deleteByUser(dbSession, user);
       dbClient.propertiesDao().deleteByKeyAndValue(dbSession, DEFAULT_ISSUE_ASSIGNEE, user.getLogin());
       dbClient.propertiesDao().deleteByQuery(dbSession, PropertyQuery.builder().setUserId(userId).build());
-      dbClient.userGroupDao().deleteByUserUuid(dbSession, user.getUuid());
+      dbClient.userGroupDao().deleteByUserUuid(dbSession, userUuid);
       dbClient.userPermissionDao().deleteByUserId(dbSession, userId);
-      dbClient.permissionTemplateDao().deleteUserPermissionsByUserId(dbSession, userId);
+      dbClient.permissionTemplateDao().deleteUserPermissionsByUserUuid(dbSession, userUuid);
       dbClient.qProfileEditUsersDao().deleteByUser(dbSession, user);
-      dbClient.organizationMemberDao().deleteByUserUuid(dbSession, user.getUuid());
+      dbClient.organizationMemberDao().deleteByUserUuid(dbSession, userUuid);
       dbClient.userPropertiesDao().deleteByUser(dbSession, user);
       dbClient.almPatDao().deleteByUser(dbSession, user);
       deactivateUser(dbSession, user);

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/PermissionTemplateServiceTest.java

@@ -454,7 +454,7 @@ public class PermissionTemplateServiceTest {
     PermissionTemplateDto template = templateDb.insertTemplate(organization);
     dbTester.organizations().setDefaultTemplates(template, null, null);
     templateDb.addProjectCreatorToTemplate(template.getUuid(), SCAN.getKey());
-    templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER);
+    templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), UserRole.USER);
     templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.CODEVIEWER);
     templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN);
 

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/ApplyTemplateActionTest.java

@@ -207,7 +207,7 @@ public class ApplyTemplateActionTest extends BasePermissionWsTest<ApplyTemplateA
   }
 
   private void addUserToTemplate(UserDto user, PermissionTemplateDto permissionTemplate, String permission) {
-    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getId(), permission);
+    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getUuid(), permission);
     db.commit();
   }
 

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/BulkApplyTemplateActionTest.java

@@ -345,7 +345,7 @@ public class BulkApplyTemplateActionTest extends BasePermissionWsTest<BulkApplyT
   }
 
   private void addUserToTemplate(UserDto user, PermissionTemplateDto permissionTemplate, String permission) {
-    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getId(), permission);
+    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getUuid(), permission);
     db.commit();
   }
 

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/DeleteTemplateActionTest.java

@@ -421,7 +421,7 @@ public class DeleteTemplateActionTest {
     PermissionTemplateDto dto = db.permissionTemplates().insertTemplate(organization);
     UserDto user = db.getDbClient().userDao().insert(db.getSession(), UserTesting.newUserDto().setActive(true));
     GroupDto group = db.getDbClient().groupDao().insert(db.getSession(), GroupTesting.newGroupDto());
-    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getUuid(), user.getId(), UserRole.ADMIN);
+    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getUuid(), user.getUuid(), UserRole.ADMIN);
     db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), dto.getUuid(), group.getUuid(), UserRole.CODEVIEWER);
     db.commit();
     return dto;

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/RemoveUserFromTemplateActionTest.java

@@ -221,7 +221,7 @@ public class RemoveUserFromTemplateActionTest extends BasePermissionWsTest<Remov
   }
 
   private void addUserToTemplate(UserDto user, PermissionTemplateDto template, String permission) {
-    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), template.getUuid(), user.getId(), permission);
+    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), template.getUuid(), user.getUuid(), permission);
     db.commit();
   }
 

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/SearchTemplatesActionTest.java

@@ -93,10 +93,10 @@ public class SearchTemplatesActionTest extends BasePermissionWsTest<SearchTempla
     GroupDto group2 = db.users().insertGroup(organization);
     GroupDto group3 = db.users().insertGroup(organization);
 
-    addUserToTemplate(projectTemplate.getUuid(), user1.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user2.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user3.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user1.getId(), UserRole.CODEVIEWER);
+    addUserToTemplate(projectTemplate.getUuid(), user1.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user2.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user3.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user1.getUuid(), UserRole.CODEVIEWER);
     addGroupToTemplate(projectTemplate.getUuid(), group1.getUuid(), UserRole.ADMIN);
     addPermissionTemplateWithProjectCreator(projectTemplate.getUuid(), UserRole.ADMIN);
 
@@ -124,15 +124,15 @@ public class SearchTemplatesActionTest extends BasePermissionWsTest<SearchTempla
     GroupDto group2 = db.users().insertGroup(organization);
     GroupDto group3 = db.users().insertGroup(organization);
 
-    addUserToTemplate(projectTemplate.getUuid(), user1.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user2.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user3.getId(), UserRole.ISSUE_ADMIN);
-    addUserToTemplate(projectTemplate.getUuid(), user1.getId(), UserRole.CODEVIEWER);
+    addUserToTemplate(projectTemplate.getUuid(), user1.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user2.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user3.getUuid(), UserRole.ISSUE_ADMIN);
+    addUserToTemplate(projectTemplate.getUuid(), user1.getUuid(), UserRole.CODEVIEWER);
     addGroupToTemplate(projectTemplate.getUuid(), group1.getUuid(), UserRole.ADMIN);
     addPermissionTemplateWithProjectCreator(projectTemplate.getUuid(), UserRole.ADMIN);
 
-    addUserToTemplate(portfoliosTemplate.getUuid(), user1.getId(), UserRole.USER);
-    addUserToTemplate(portfoliosTemplate.getUuid(), user2.getId(), UserRole.USER);
+    addUserToTemplate(portfoliosTemplate.getUuid(), user1.getUuid(), UserRole.USER);
+    addUserToTemplate(portfoliosTemplate.getUuid(), user2.getUuid(), UserRole.USER);
     addGroupToTemplate(portfoliosTemplate.getUuid(), group1.getUuid(), UserRole.ISSUE_ADMIN);
     addGroupToTemplate(portfoliosTemplate.getUuid(), group2.getUuid(), UserRole.ISSUE_ADMIN);
     addGroupToTemplate(portfoliosTemplate.getUuid(), group3.getUuid(), UserRole.ISSUE_ADMIN);
@@ -382,7 +382,7 @@ public class SearchTemplatesActionTest extends BasePermissionWsTest<SearchTempla
     db.getSession().commit();
   }
 
-  private void addUserToTemplate(String templateUuid, int userId, String permission) {
+  private void addUserToTemplate(String templateUuid, String userId, String permission) {
     dbClient.permissionTemplateDao().insertUserPermission(db.getSession(), templateUuid, userId, permission);
     db.getSession().commit();
   }

server/sonar-webserver-webapi/src/test/java/org/sonar/server/permission/ws/template/TemplateUsersActionTest.java

@@ -313,7 +313,7 @@ public class TemplateUsersActionTest extends BasePermissionWsTest<TemplateUsersA
   }
 
   private void addUserToTemplate(PermissionTemplateUserDto dto) {
-    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getTemplateUuid(), dto.getUserId(), dto.getPermission());
+    db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getTemplateUuid(), dto.getUserUuid(), dto.getPermission());
     db.commit();
   }
 
@@ -321,7 +321,7 @@ public class TemplateUsersActionTest extends BasePermissionWsTest<TemplateUsersA
     return newPermissionTemplateUserDto()
       .setPermission(permission)
       .setTemplateUuid(template.getUuid())
-      .setUserId(user.getId());
+      .setUserUuid(user.getUuid());
   }
 
   private TestRequest newRequest(@Nullable String permission, @Nullable String templateUuid) {

server/sonar-webserver-webapi/src/test/java/org/sonar/server/user/ws/DeactivateActionTest.java

@@ -173,14 +173,14 @@ public class DeactivateActionTest {
     UserDto user = db.users().insertUser();
     PermissionTemplateDto template = db.permissionTemplates().insertTemplate();
     PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate();
-    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getId(), USER);
-    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getId(), CODEVIEWER);
+    db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getUuid(), USER);
+    db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getUuid(), CODEVIEWER);
 
     deactivate(user.getLogin());
 
-    assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
+    assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid)
       .isEmpty();
-    assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
+    assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserUuid)
       .isEmpty();
   }