* change template_id to template_uuid for PERM_TEMPLATES_GROUPS, PERM_TEMPLATES_USERS, PERM_TPL_CHARACTERISTICS
package org.sonar.db.permission.template;
public class CountByTemplateAndPermissionDto {
- private long templateId;
+ private String templateUuid;
private String permission;
private int count;
- public long getTemplateId() {
- return templateId;
+ public String getTemplateUuid() {
+ return templateUuid;
}
- public void setTemplateId(long templateId) {
- this.templateId = templateId;
+ public void setTemplateUuid(String templateUuid) {
+ this.templateUuid = templateUuid;
}
public String getPermission() {
public class PermissionTemplateCharacteristicDao implements Dao {
- public List<PermissionTemplateCharacteristicDto> selectByTemplateIds(DbSession dbSession, List<Long> templateIds) {
- return executeLargeInputs(templateIds, partitionOfTemplateIds -> mapper(dbSession).selectByTemplateIds(partitionOfTemplateIds));
+ public List<PermissionTemplateCharacteristicDto> selectByTemplateUuids(DbSession dbSession, List<String> templateUuids) {
+ return executeLargeInputs(templateUuids, partitionOfTemplateUuids -> mapper(dbSession).selectByTemplateUuids(partitionOfTemplateUuids));
}
- public Optional<PermissionTemplateCharacteristicDto> selectByPermissionAndTemplateId(DbSession dbSession, String permission, long templateId) {
- PermissionTemplateCharacteristicDto dto = mapper(dbSession).selectByPermissionAndTemplateId(permission, templateId);
+ public Optional<PermissionTemplateCharacteristicDto> selectByPermissionAndTemplateId(DbSession dbSession, String permission, String templateUuid) {
+ PermissionTemplateCharacteristicDto dto = mapper(dbSession).selectByPermissionAndTemplateUuid(permission, templateUuid);
return Optional.ofNullable(dto);
}
private static final int MAX_PERMISSION_KEY_LENGTH = 64;
private String uuid;
- private long templateId;
+ private String templateUuid;
private String permission;
private boolean withProjectCreator;
private long createdAt;
return this;
}
- public long getTemplateId() {
- return templateId;
+ public String getTemplateUuid() {
+ return templateUuid;
}
- public PermissionTemplateCharacteristicDto setTemplateId(long templateId) {
- this.templateId = templateId;
+ public PermissionTemplateCharacteristicDto setTemplateUuid(String templateUuid) {
+ this.templateUuid = templateUuid;
return this;
}
PermissionTemplateCharacteristicDto selectByUuid(@Param("uuid") String uuid);
- List<PermissionTemplateCharacteristicDto> selectByTemplateIds(@Param("templateIds") List<Long> templateId);
+ List<PermissionTemplateCharacteristicDto> selectByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
- PermissionTemplateCharacteristicDto selectByPermissionAndTemplateId(@Param("permission") String permission, @Param("templateId") long templateId);
+ PermissionTemplateCharacteristicDto selectByPermissionAndTemplateUuid(@Param("permission") String permission, @Param("templateUuid") String templateUuid);
void insert(PermissionTemplateCharacteristicDto templatePermissionDto);
void update(PermissionTemplateCharacteristicDto templatePermissionDto);
- void deleteByTemplateId(long id);
+ void deleteByTemplateUuid(String uuid);
- void deleteByTemplateIds(@Param("templateIds") List<Long> subList);
+ void deleteByTemplateUuids(@Param("templateUuids") List<String> subList);
}
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.sonar.api.utils.System2;
-import org.sonar.core.util.Uuids;
+import org.sonar.core.util.UuidFactory;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
import org.sonar.db.permission.CountPerProjectPermission;
private static final String ANYONE_GROUP_PARAMETER = "anyoneGroup";
private final System2 system;
+ private final UuidFactory uuidFactory;
- public PermissionTemplateDao(System2 system) {
+ public PermissionTemplateDao(UuidFactory uuidFactory, System2 system) {
+ this.uuidFactory = uuidFactory;
this.system = system;
}
/**
* @return a paginated list of user logins.
*/
- public List<String> selectUserLoginsByQueryAndTemplate(DbSession session, PermissionQuery query, long templateId) {
- return mapper(session).selectUserLoginsByQueryAndTemplate(query, templateId, new RowBounds(query.getPageOffset(), query.getPageSize()));
+ public List<String> selectUserLoginsByQueryAndTemplate(DbSession session, PermissionQuery query, String templateUuid) {
+ return mapper(session).selectUserLoginsByQueryAndTemplate(query, templateUuid, new RowBounds(query.getPageOffset(), query.getPageSize()));
}
- public int countUserLoginsByQueryAndTemplate(DbSession session, PermissionQuery query, long templateId) {
- return mapper(session).countUserLoginsByQueryAndTemplate(query, templateId);
+ public int countUserLoginsByQueryAndTemplate(DbSession session, PermissionQuery query, String templateUuid) {
+ return mapper(session).countUserLoginsByQueryAndTemplate(query, templateUuid);
}
- public List<PermissionTemplateUserDto> selectUserPermissionsByTemplateIdAndUserLogins(DbSession dbSession, long templateId, List<String> logins) {
- return executeLargeInputs(logins, l -> mapper(dbSession).selectUserPermissionsByTemplateIdAndUserLogins(templateId, l));
+ public List<PermissionTemplateUserDto> selectUserPermissionsByTemplateIdAndUserLogins(DbSession dbSession, String templateUuid, List<String> logins) {
+ return executeLargeInputs(logins, l -> mapper(dbSession).selectUserPermissionsByTemplateUuidAndUserLogins(templateUuid, l));
}
- public List<PermissionTemplateUserDto> selectUserPermissionsByTemplateId(DbSession dbSession, long templateId) {
- return mapper(dbSession).selectUserPermissionsByTemplateIdAndUserLogins(templateId, Collections.emptyList());
+ public List<PermissionTemplateUserDto> selectUserPermissionsByTemplateId(DbSession dbSession, String templateUuid) {
+ return mapper(dbSession).selectUserPermissionsByTemplateUuidAndUserLogins(templateUuid, Collections.emptyList());
}
- public List<String> selectGroupNamesByQueryAndTemplate(DbSession session, PermissionQuery query, long templateId) {
- return mapper(session).selectGroupNamesByQueryAndTemplate(templateId, query, new RowBounds(query.getPageOffset(), query.getPageSize()));
+ public List<String> selectGroupNamesByQueryAndTemplate(DbSession session, PermissionQuery query, String templateUuid) {
+ return mapper(session).selectGroupNamesByQueryAndTemplate(templateUuid, query, new RowBounds(query.getPageOffset(), query.getPageSize()));
}
- public int countGroupNamesByQueryAndTemplate(DbSession session, PermissionQuery query, String organizationUuid, long templateId) {
- return mapper(session).countGroupNamesByQueryAndTemplate(organizationUuid, query, templateId);
+ public int countGroupNamesByQueryAndTemplate(DbSession session, PermissionQuery query, String organizationUuid, String templateUuid) {
+ return mapper(session).countGroupNamesByQueryAndTemplate(organizationUuid, query, templateUuid);
}
- public List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateIdAndGroupNames(DbSession dbSession, long templateId, List<String> groups) {
- return executeLargeInputs(groups, g -> mapper(dbSession).selectGroupPermissionsByTemplateIdAndGroupNames(templateId, g));
+ public List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateIdAndGroupNames(DbSession dbSession, String templateUuid, List<String> groups) {
+ return executeLargeInputs(groups, g -> mapper(dbSession).selectGroupPermissionsByTemplateUuidAndGroupNames(templateUuid, g));
}
- public List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateId(DbSession dbSession, long templateId) {
- return mapper(dbSession).selectGroupPermissionsByTemplateIdAndGroupNames(templateId, Collections.emptyList());
+ public List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateUuid(DbSession dbSession, String templateUuid) {
+ return mapper(dbSession).selectGroupPermissionsByTemplateUuidAndGroupNames(templateUuid, Collections.emptyList());
}
/**
* @return {@code true} if template contains groups that are granted with {@code permission}, else {@code false}
*/
- public boolean hasGroupsWithPermission(DbSession dbSession, long templateId, String permission, @Nullable Integer groupId) {
- return mapper(dbSession).countGroupsWithPermission(templateId, permission, groupId) > 0;
+ public boolean hasGroupsWithPermission(DbSession dbSession, String templateUuid, String permission, @Nullable Integer groupId) {
+ return mapper(dbSession).countGroupsWithPermission(templateUuid, permission, groupId) > 0;
}
@CheckForNull
}
public PermissionTemplateDto insert(DbSession session, PermissionTemplateDto dto) {
+ if (dto.getUuid() == null) {
+ dto.setUuid(uuidFactory.create());
+ }
mapper(session).insert(dto);
return dto;
}
/**
* Each row returns a #{@link CountPerProjectPermission}
*/
- public void usersCountByTemplateIdAndPermission(DbSession dbSession, List<Long> templateIds, ResultHandler<CountByTemplateAndPermissionDto> resultHandler) {
+ public void usersCountByTemplateUuidAndPermission(DbSession dbSession, List<String> templateUuids, ResultHandler<CountByTemplateAndPermissionDto> resultHandler) {
Map<String, Object> parameters = new HashMap<>(1);
executeLargeInputsWithoutOutput(
- templateIds,
- partitionedTemplateIds -> {
- parameters.put("templateIds", partitionedTemplateIds);
- mapper(dbSession).usersCountByTemplateIdAndPermission(parameters, resultHandler);
+ templateUuids,
+ partitionedTemplateUuids -> {
+ parameters.put("templateUuids", partitionedTemplateUuids);
+ mapper(dbSession).usersCountByTemplateUuidAndPermission(parameters, resultHandler);
});
}
/**
* Each row returns a #{@link CountPerProjectPermission}
*/
- public void groupsCountByTemplateIdAndPermission(DbSession dbSession, List<Long> templateIds, ResultHandler<CountByTemplateAndPermissionDto> resultHandler) {
+ public void groupsCountByTemplateUuidAndPermission(DbSession dbSession, List<String> templateUuids, ResultHandler<CountByTemplateAndPermissionDto> resultHandler) {
Map<String, Object> parameters = new HashMap<>(2);
parameters.put(ANYONE_GROUP_PARAMETER, ANYONE);
executeLargeInputsWithoutOutput(
- templateIds,
- partitionedTemplateIds -> {
- parameters.put("templateIds", partitionedTemplateIds);
- mapper(dbSession).groupsCountByTemplateIdAndPermission(parameters, resultHandler);
+ templateUuids,
+ partitionedTemplateUuids -> {
+ parameters.put("templateUuids", partitionedTemplateUuids);
+ mapper(dbSession).groupsCountByTemplateUuidAndPermission(parameters, resultHandler);
});
}
return mapper(dbSession).selectAllGroupPermissionTemplatesByGroupId(groupId);
}
- public void deleteById(DbSession session, long templateId) {
+ public void deleteByUuid(DbSession session, String templateUuid) {
PermissionTemplateMapper mapper = mapper(session);
- mapper.deleteUserPermissionsByTemplateId(templateId);
- mapper.deleteGroupPermissionsByTemplateId(templateId);
- session.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateId(templateId);
- mapper.deleteById(templateId);
+ mapper.deleteUserPermissionsByTemplateUuid(templateUuid);
+ mapper.deleteGroupPermissionsByTemplateUuid(templateUuid);
+ session.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateUuid(templateUuid);
+ mapper.deleteByUuid(templateUuid);
}
public PermissionTemplateDto update(DbSession session, PermissionTemplateDto permissionTemplate) {
return permissionTemplate;
}
- public void insertUserPermission(DbSession session, Long templateId, Integer userId, String permission) {
+ public void insertUserPermission(DbSession session, String templateUuid, Integer userId, String permission) {
PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
- .setUuid(Uuids.create())
- .setTemplateId(templateId)
+ .setUuid(uuidFactory.create())
+ .setTemplateUuid(templateUuid)
.setUserId(userId)
.setPermission(permission)
.setCreatedAt(now())
session.commit();
}
- public void deleteUserPermission(DbSession session, Long templateId, Integer userId, String permission) {
+ public void deleteUserPermission(DbSession session, String templateUuid, Integer userId, String permission) {
PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
- .setTemplateId(templateId)
+ .setTemplateUuid(templateUuid)
.setPermission(permission)
.setUserId(userId);
mapper(session).deleteUserPermission(permissionTemplateUser);
mapper(dbSession).deleteUserPermissionsByUserId(userId);
}
- public void insertGroupPermission(DbSession session, long templateId, @Nullable Integer groupId, String permission) {
+ public void insertGroupPermission(DbSession session, String templateUuid, @Nullable Integer groupId, String permission) {
PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto()
- .setUuid(Uuids.create())
- .setTemplateId(templateId)
+ .setUuid(uuidFactory.create())
+ .setTemplateUuid(templateUuid)
.setPermission(permission)
.setGroupId(groupId)
.setCreatedAt(now())
mapper(session).insertGroupPermission(permissionTemplateGroup);
}
- public void deleteGroupPermission(DbSession session, Long templateId, @Nullable Integer groupId, String permission) {
+ public void deleteGroupPermission(DbSession session, String templateUuid, @Nullable Integer groupId, String permission) {
PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto()
- .setTemplateId(templateId)
+ .setTemplateUuid(templateUuid)
.setPermission(permission)
.setGroupId(groupId);
mapper(session).deleteGroupPermission(permissionTemplateGroup);
return mapper(dbSession).selectByName(organizationUuid, name.toUpperCase(Locale.ENGLISH));
}
- public List<String> selectPotentialPermissionsByUserIdAndTemplateId(DbSession dbSession, @Nullable Integer currentUserId, long templateId) {
- return mapper(dbSession).selectPotentialPermissionsByUserIdAndTemplateId(currentUserId, templateId);
+ public List<String> selectPotentialPermissionsByUserIdAndTemplateUuid(DbSession dbSession, @Nullable Integer currentUserId, String templateUuid) {
+ return mapper(dbSession).selectPotentialPermissionsByUserIdAndTemplateUuid(currentUserId, templateUuid);
}
/**
public void deleteByOrganization(DbSession dbSession, String organizationUuid) {
PermissionTemplateMapper templateMapper = mapper(dbSession);
PermissionTemplateCharacteristicMapper templateCharacteristicMapper = dbSession.getMapper(PermissionTemplateCharacteristicMapper.class);
- List<Long> templateIds = templateMapper.selectTemplateIdsByOrganization(organizationUuid);
- executeLargeInputsWithoutOutput(templateIds, subList -> {
- templateCharacteristicMapper.deleteByTemplateIds(subList);
- templateMapper.deleteGroupPermissionsByTemplateIds(subList);
- templateMapper.deleteUserPermissionsByTemplateIds(subList);
- templateMapper.deleteByIds(subList);
+ List<String> templateUuids = templateMapper.selectTemplateUuidsByOrganization(organizationUuid);
+ executeLargeInputsWithoutOutput(templateUuids, subList -> {
+ templateCharacteristicMapper.deleteByTemplateUuids(subList);
+ templateMapper.deleteGroupPermissionsByTemplateUuids(subList);
+ templateMapper.deleteUserPermissionsByTemplateUuids(subList);
+ templateMapper.deleteByUuids(subList);
});
}
}
public class PermissionTemplateDto {
- private Long id;
private String name;
private String organizationUuid;
private String uuid;
private Date createdAt;
private Date updatedAt;
- public Long getId() {
- return id;
- }
-
- public PermissionTemplateDto setId(Long id) {
- this.id = id;
- return this;
- }
-
public String getOrganizationUuid() {
return organizationUuid;
}
return this;
}
- /**
- * @deprecated since 5.2 use {@link #getUuid()}
- */
- @Deprecated
- public String getKee() {
- return uuid;
- }
-
- /**
- * @deprecated since 5.2 use {@link #setUuid(String)}
- */
- @Deprecated
- public PermissionTemplateDto setKee(String kee) {
- this.uuid = kee;
- return this;
- }
-
/**
* @since 5.2 the kee column is a proper uuid. Before that it was build on the name + timestamp
*/
public class PermissionTemplateGroupDto {
private String uuid;
- private Long templateId;
+ private String templateUuid;
private Integer groupId;
private String permission;
private String groupName;
return this;
}
- public Long getTemplateId() {
- return templateId;
+ public String getTemplateUuid() {
+ return templateUuid;
}
- public PermissionTemplateGroupDto setTemplateId(Long templateId) {
- this.templateId = templateId;
+ public PermissionTemplateGroupDto setTemplateUuid(String templateUuid) {
+ this.templateUuid = templateUuid;
return this;
}
void update(PermissionTemplateDto permissionTemplate);
- void deleteById(long templateId);
+ void deleteByUuid(String templateUuid);
- void deleteByIds(@Param("templateIds") List<Long> templateIds);
+ void deleteByUuids(@Param("templateUuids") List<String> templateUuids);
- void deleteUserPermissionsByTemplateId(long templateId);
+ void deleteUserPermissionsByTemplateUuid(String templateUuid);
- void deleteUserPermissionsByTemplateIds(@Param("templateIds") List<Long> templateIds);
+ void deleteUserPermissionsByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
void deleteUserPermissionsByOrganization(@Param("organizationUuid") String organizationUuid, @Param("userId") int userId);
void deleteUserPermission(PermissionTemplateUserDto permissionTemplateUser);
- void deleteGroupPermissionsByTemplateId(long templateId);
+ void deleteGroupPermissionsByTemplateUuid(String templateUuid);
- void deleteGroupPermissionsByTemplateIds(@Param("templateIds") List<Long> templateIds);
+ void deleteGroupPermissionsByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
void deleteGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup);
PermissionTemplateDto selectByUuid(String templateUuid);
- List<PermissionTemplateUserDto> selectUserPermissionsByTemplateIdAndUserLogins(@Param("templateId") long templateId, @Param("logins") List<String> logins);
+ List<PermissionTemplateUserDto> selectUserPermissionsByTemplateUuidAndUserLogins(@Param("templateUuid") String templateUuid, @Param("logins") List<String> logins);
- List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateIdAndGroupNames(@Param("templateId") long templateId, @Param("groups") List<String> groups);
+ List<PermissionTemplateGroupDto> selectGroupPermissionsByTemplateUuidAndGroupNames(@Param("templateUuid") String templateUuid, @Param("groups") List<String> groups);
void insertUserPermission(PermissionTemplateUserDto permissionTemplateUser);
PermissionTemplateDto selectByName(@Param("organizationUuid") String organizationUuid, @Param("name") String name);
- List<String> selectUserLoginsByQueryAndTemplate(@Param("query") PermissionQuery query, @Param("templateId") long templateId, RowBounds rowBounds);
+ List<String> selectUserLoginsByQueryAndTemplate(@Param("query") PermissionQuery query, @Param("templateUuid") String templateUuid, RowBounds rowBounds);
- int countUserLoginsByQueryAndTemplate(@Param("query") PermissionQuery query, @Param("templateId") long templateId);
+ int countUserLoginsByQueryAndTemplate(@Param("query") PermissionQuery query, @Param("templateUuid") String templateUuid);
- List<String> selectGroupNamesByQueryAndTemplate(@Param("templateId") long templateId, @Param("query") PermissionQuery query, RowBounds rowBounds);
+ List<String> selectGroupNamesByQueryAndTemplate(@Param("templateUuid") String templateUuid, @Param("query") PermissionQuery query, RowBounds rowBounds);
- int countGroupNamesByQueryAndTemplate(@Param("organizationUuid") String organizationUuid, @Param("query") PermissionQuery query, @Param("templateId") long templateId);
+ int countGroupNamesByQueryAndTemplate(@Param("organizationUuid") String organizationUuid, @Param("query") PermissionQuery query, @Param("templateUuid") String templateUuid);
List<PermissionTemplateDto> selectAll(@Param("organizationUuid") String organizationUuid, @Nullable @Param("upperCaseNameLikeSql") String upperCaseNameLikeSql);
- void usersCountByTemplateIdAndPermission(Map<String, Object> parameters, ResultHandler<CountByTemplateAndPermissionDto> resultHandler);
+ void usersCountByTemplateUuidAndPermission(Map<String, Object> parameters, ResultHandler<CountByTemplateAndPermissionDto> resultHandler);
- void groupsCountByTemplateIdAndPermission(Map<String, Object> parameters, ResultHandler<CountByTemplateAndPermissionDto> resultHandler);
+ void groupsCountByTemplateUuidAndPermission(Map<String, Object> parameters, ResultHandler<CountByTemplateAndPermissionDto> resultHandler);
- List<String> selectPotentialPermissionsByUserIdAndTemplateId(@Param("userId") @Nullable Integer currentUserId, @Param("templateId") long templateId);
+ List<String> selectPotentialPermissionsByUserIdAndTemplateUuid(@Param("userId") @Nullable Integer currentUserId, @Param("templateUuid") String templateUuid);
- int countGroupsWithPermission(@Param("templateId") long templateId, @Param("permission") String permission, @Nullable @Param("groupId") Integer groupId);
+ int countGroupsWithPermission(@Param("templateUuid") String templateUuid, @Param("permission") String permission, @Nullable @Param("groupId") Integer groupId);
- List<Long> selectTemplateIdsByOrganization(@Param("organizationUuid") String organizationUuid);
+ List<String> selectTemplateUuidsByOrganization(@Param("organizationUuid") String organizationUuid);
List<PermissionTemplateGroupDto> selectAllGroupPermissionTemplatesByGroupId(@Param("groupId") Long groupId);
public class PermissionTemplateUserDto {
private String uuid;
- private Long templateId;
+ private String templateUuid;
private Integer userId;
private String permission;
private String userName;
return this;
}
- public Long getTemplateId() {
- return templateId;
+ public String getTemplateUuid() {
+ return templateUuid;
}
- public PermissionTemplateUserDto setTemplateId(Long templateId) {
- this.templateId = templateId;
+ public PermissionTemplateUserDto setTemplateUuid(String templateUuid) {
+ this.templateUuid = templateUuid;
return this;
}
<mapper namespace="org.sonar.db.permission.template.PermissionTemplateCharacteristicMapper">
<sql id="columns">
ptc.uuid,
- ptc.template_id as templateId,
+ ptc.template_uuid as templateUuid,
ptc.permission_key as permission,
ptc.with_project_creator as withProjectCreator,
ptc.created_at as createdAt,
where ptc.uuid=#{uuid,jdbcType=VARCHAR}
</select>
- <select id="selectByTemplateIds" parameterType="long" resultType="PermissionTemplateCharacteristic">
+ <select id="selectByTemplateUuids" parameterType="String" resultType="PermissionTemplateCharacteristic">
select
<include refid="columns" />
from perm_tpl_characteristics ptc
where
- ptc.template_id in
- <foreach collection="templateIds" open="(" close=")" item="templateId" separator=",">
- #{templateId}
+ ptc.template_uuid in
+ <foreach collection="templateUuids" open="(" close=")" item="templateUuid" separator=",">
+ #{templateUuid}
</foreach>
order by ptc.created_at
</select>
- <select id="selectByPermissionAndTemplateId" parameterType="map" resultType="PermissionTemplateCharacteristic">
+ <select id="selectByPermissionAndTemplateUuid" parameterType="map" resultType="PermissionTemplateCharacteristic">
select
<include refid="columns" />
from perm_tpl_characteristics ptc
- where ptc.template_id=#{templateId}
+ where ptc.template_uuid=#{templateUuid}
and ptc.permission_key=#{permission}
order by ptc.created_at
</select>
<insert id="insert" parameterType="PermissionTemplateCharacteristic">
- insert into perm_tpl_characteristics(uuid, template_id, permission_key, with_project_creator, created_at, updated_at)
- values(#{uuid, jdbcType=VARCHAR}, #{templateId, jdbcType=BIGINT}, #{permission, jdbcType=VARCHAR},
+ insert into perm_tpl_characteristics(uuid, template_uuid, permission_key, with_project_creator, created_at, updated_at)
+ values(#{uuid, jdbcType=VARCHAR}, #{templateUuid, jdbcType=VARCHAR}, #{permission, jdbcType=VARCHAR},
#{withProjectCreator, jdbcType=BOOLEAN}, #{createdAt, jdbcType=BIGINT}, #{updatedAt, jdbcType=BIGINT})
</insert>
where uuid=#{uuid}
</update>
- <delete id="deleteByTemplateId" parameterType="long">
+ <delete id="deleteByTemplateUuid" parameterType="String">
DELETE FROM perm_tpl_characteristics
- WHERE template_id = #{permissionTemplateId}
+ WHERE template_uuid = #{permissionTemplateId}
</delete>
- <delete id="deleteByTemplateIds" parameterType="long">
+ <delete id="deleteByTemplateUuids" parameterType="String">
delete from
perm_tpl_characteristics
where
- template_id in
- <foreach collection="templateIds" open="(" close=")" item="templateId" separator=",">
- #{templateId}
+ template_uuid in
+ <foreach collection="templateUuids" open="(" close=")" item="templateUuid" separator=",">
+ #{templateUuid}
</foreach>
</delete>
</mapper>
<mapper namespace="org.sonar.db.permission.template.PermissionTemplateMapper">
- <insert id="insert" parameterType="PermissionTemplate" keyColumn="id" useGeneratedKeys="true" keyProperty="id">
- INSERT INTO permission_templates (organization_uuid, name, kee, description, key_pattern, created_at, updated_at)
+ <insert id="insert" parameterType="PermissionTemplate" useGeneratedKeys="false">
+ INSERT INTO permission_templates (organization_uuid, name, uuid, description, key_pattern, created_at, updated_at)
VALUES (
#{organizationUuid,jdbcType=VARCHAR},
#{name,jdbcType=VARCHAR},
- #{kee,jdbcType=VARCHAR},
+ #{uuid,jdbcType=VARCHAR},
#{description,jdbcType=VARCHAR},
#{keyPattern,jdbcType=VARCHAR},
#{createdAt},
<update id="update" parameterType="PermissionTemplate">
UPDATE permission_templates
SET name = #{name}, description = #{description}, key_pattern = #{keyPattern}, updated_at = #{updatedAt}
- WHERE id = #{id}
+ WHERE uuid = #{uuid}
</update>
- <delete id="deleteById" parameterType="long">
+ <delete id="deleteByUuid" parameterType="String">
DELETE FROM permission_templates
- WHERE id = #{templateId}
+ WHERE uuid = #{uuid}
</delete>
- <delete id="deleteByIds" parameterType="long">
+ <delete id="deleteByUuids" parameterType="String">
delete from
permission_templates
where
- id in <foreach collection="templateIds" open="(" close=")" item="templateId" separator=",">
- #{templateId,jdbcType=BIGINT}
+ uuid in <foreach collection="templateUuids" open="(" close=")" item="uuid" separator=",">
+ #{uuid,jdbcType=BIGINT}
</foreach>
</delete>
- <delete id="deleteUserPermissionsByTemplateId" parameterType="long">
+ <delete id="deleteUserPermissionsByTemplateUuid" parameterType="string">
delete from
perm_templates_users
where
- template_id = #{templateId,jdbcType=BIGINT}
+ template_uuid = #{templateUuid,jdbcType=VARCHAR}
</delete>
- <delete id="deleteUserPermissionsByTemplateIds">
+ <delete id="deleteUserPermissionsByTemplateUuids">
delete from
perm_templates_users
where
- template_id in <foreach collection="templateIds" open="(" close=")" item="templateId" separator=",">
- #{templateId,jdbcType=BIGINT}
+ template_uuid in <foreach collection="templateUuids" open="(" close=")" item="templateUuid" separator=",">
+ #{templateUuid,jdbcType=BIGINT}
</foreach>
</delete>
<delete id="deleteUserPermission" parameterType="PermissionTemplateUser">
DELETE FROM perm_templates_users
- WHERE template_id = #{templateId}
+ WHERE template_uuid = #{templateUuid}
AND user_id = #{userId}
AND permission_reference = #{permission}
</delete>
delete from perm_templates_users
where
user_id = #{userId,jdbcType=INTEGER}
- and template_id in (select id from permission_templates where organization_uuid=#{organizationUuid,jdbcType=VARCHAR})
+ and template_uuid in (select uuid from permission_templates where organization_uuid=#{organizationUuid,jdbcType=VARCHAR})
</delete>
<delete id="deleteUserPermissionsByUserId" parameterType="integer">
user_id = #{userId,jdbcType=INTEGER}
</delete>
- <delete id="deleteGroupPermissionsByTemplateId" parameterType="long">
+ <delete id="deleteGroupPermissionsByTemplateUuid" parameterType="String">
delete from
perm_templates_groups
where
- template_id = #{templateId,jdbcType=BIGINT}
+ template_uuid = #{templateUuid,jdbcType=VARCHAR}
</delete>
- <delete id="deleteGroupPermissionsByTemplateIds">
+ <delete id="deleteGroupPermissionsByTemplateUuids">
delete from
perm_templates_groups
where
- template_id in <foreach collection="templateIds" open="(" close=")" item="templateId" separator=",">
- #{templateId,jdbcType=BIGINT}
+ template_uuid in <foreach collection="templateUuids" open="(" close=")" item="templateUuid" separator=",">
+ #{templateUuid,jdbcType=VARCHAR}
</foreach>
</delete>
<delete id="deleteGroupPermission" parameterType="PermissionTemplateGroup">
DELETE FROM perm_templates_groups
- WHERE template_id = #{templateId}
+ WHERE template_uuid = #{templateUuid}
AND permission_reference = #{permission}
AND
<choose>
</delete>
<insert id="insertUserPermission" parameterType="PermissionTemplateUser">
- INSERT INTO perm_templates_users (uuid, template_id, user_id, permission_reference, created_at, updated_at)
- VALUES (#{uuid}, #{templateId}, #{userId}, #{permission}, #{createdAt}, #{updatedAt})
+ INSERT INTO perm_templates_users (uuid, template_uuid, user_id, permission_reference, created_at, updated_at)
+ VALUES (#{uuid}, #{templateUuid}, #{userId}, #{permission}, #{createdAt}, #{updatedAt})
</insert>
<insert id="insertGroupPermission" parameterType="PermissionTemplateGroup">
- INSERT INTO perm_templates_groups (uuid, template_id, group_id, permission_reference, created_at, updated_at)
+ INSERT INTO perm_templates_groups (uuid, template_uuid, group_id, permission_reference, created_at, updated_at)
VALUES (
#{uuid,jdbcType=VARCHAR},
- #{templateId,jdbcType=BIGINT},
+ #{templateUuid,jdbcType=VARCHAR},
#{groupId,jdbcType=INTEGER},
#{permission,jdbcType=VARCHAR},
#{createdAt,jdbcType=TIMESTAMP},
<sql id="userLoginsByQueryAndTemplate">
FROM users u
LEFT JOIN perm_templates_users ptu ON ptu.user_id=u.id
- AND ptu.template_id=#{templateId}
+ AND ptu.template_uuid=#{templateUuid}
INNER JOIN organization_members om ON u.id=om.user_id
AND om.organization_uuid=#{query.organizationUuid}
<where>
g.id AS group_id,
g.name AS name,
ptg.permission_reference AS permission,
- ptg.template_id AS templateId
+ ptg.template_uuid AS templateUuid
FROM groups g
LEFT JOIN perm_templates_groups ptg ON
ptg.group_id=g.id
- AND ptg.template_id=#{templateId}
+ AND ptg.template_uuid=#{templateUuid}
where
g.organization_uuid=#{query.organizationUuid,jdbcType=VARCHAR}
UNION ALL
0 AS group_id,
'Anyone' AS name,
ptg.permission_reference AS permission,
- ptg.template_id AS templateId
+ ptg.template_uuid AS templateUuid
FROM groups g
LEFT JOIN perm_templates_groups ptg ON
- ptg.template_id=#{templateId}
+ ptg.template_uuid=#{templateUuid}
<where>
g.organization_uuid=#{query.organizationUuid,jdbcType=VARCHAR}
<if test="query.withAtLeastOnePermission()">
</if>
<if test="query.withAtLeastOnePermission()">
AND groups.permission IS NOT NULL
- AND groups.templateId=#{templateId}
+ AND groups.templateUuid=#{templateUuid}
<if test="query.permission != null">
AND groups.permission=#{query.permission}
</if>
</sql>
<sql id="templateColumns">
- id, organization_uuid as organizationUuid, name, kee, description, key_pattern AS keyPattern, created_at AS createdAt, updated_at AS updatedAt
+ organization_uuid as organizationUuid, name, uuid, description, key_pattern AS keyPattern, created_at AS createdAt, updated_at AS updatedAt
</sql>
<select id="selectByUuid" parameterType="String" resultType="PermissionTemplate">
SELECT
<include refid="templateColumns"/>
FROM permission_templates
- WHERE kee=#{uuid}
+ WHERE uuid=#{uuid}
</select>
<select id="selectAll" parameterType="map" resultType="PermissionTemplate">
<sql id="permissionTemplateUserColumns">
ptu.uuid,
- ptu.template_id as templateId,
+ ptu.template_uuid as templateUuid,
ptu.permission_reference AS permission,
ptu.user_id AS userId,
u.name AS userName,
ptu.updated_at AS updatedAt
</sql>
- <select id="selectUserPermissionsByTemplateIdAndUserLogins" parameterType="Long" resultType="PermissionTemplateUser">
+ <select id="selectUserPermissionsByTemplateUuidAndUserLogins" parameterType="String" resultType="PermissionTemplateUser">
SELECT
<include refid="permissionTemplateUserColumns"/>
FROM perm_templates_users ptu
INNER JOIN users u ON u.id = ptu.user_id AND u.active = ${_true}
<where>
- AND ptu.template_id = #{templateId}
+ AND ptu.template_uuid = #{templateUuid}
<if test="!logins.isEmpty()">
AND u.login IN <foreach collection="logins" open="(" close=")" item="login" separator=",">
#{login}
</where>
</select>
- <select id="selectGroupPermissionsByTemplateIdAndGroupNames" parameterType="Long" resultType="PermissionTemplateGroup">
+ <select id="selectGroupPermissionsByTemplateUuidAndGroupNames" parameterType="String" resultType="PermissionTemplateGroup">
SELECT
sub.uuid,
- sub.templateId,
+ sub.templateUuid,
sub.permission,
sub.groupId,
sub.groupName,
FROM (
SELECT
ptg.uuid,
- ptg.template_id as templateId,
+ ptg.template_uuid as templateUuid,
ptg.permission_reference AS permission,
ptg.group_id AS groupId,
g.name AS groupName,
UNION ALL
SELECT
ptg.uuid,
- ptg.template_id as templateId,
+ ptg.template_uuid as templateUuid,
ptg.permission_reference AS permission,
0 AS groupId,
'Anyone' AS groupName,
WHERE ptg.group_id IS NULL
) sub
<where>
- sub.templateId=#{templateId}
+ sub.templateUuid=#{templateUuid}
<if test="!groups.isEmpty()">
AND sub.groupName IN <foreach collection="groups" open="(" close=")" item="group" separator=",">
#{group}
</where>
</select>
- <select id="selectPotentialPermissionsByUserIdAndTemplateId" parameterType="map" resultType="String">
+ <select id="selectPotentialPermissionsByUserIdAndTemplateUuid" parameterType="map" resultType="String">
<if test="userId!=null">
-- from template users
select ptu.permission_reference as permission_key
from perm_templates_users ptu
<where>
and ptu.user_id=#{userId}
- and ptu.template_id=#{templateId}
+ and ptu.template_uuid=#{templateUuid}
</where>
UNION
-- from template groups except anyone group
inner join groups_users gu on ptg.group_id = gu.group_id
<where>
and gu.user_id=#{userId}
- and ptg.template_id=#{templateId}
+ and ptg.template_uuid=#{templateUuid}
</where>
UNION
-- from template characteristics
from perm_tpl_characteristics ptc
<where>
and with_project_creator = ${_true}
- and ptc.template_id = #{templateId}
+ and ptc.template_uuid = #{templateUuid}
</where>
UNION
</if>
-- from anyone group
select ptg.permission_reference as permission_key
from perm_templates_groups ptg
- where ptg.template_id=#{templateId}
+ where ptg.template_uuid=#{templateUuid}
and ptg.group_id IS NULL
</select>
- <select id="usersCountByTemplateIdAndPermission" parameterType="map"
+ <select id="usersCountByTemplateUuidAndPermission" parameterType="map"
resultType="org.sonar.db.permission.template.CountByTemplateAndPermissionDto">
- SELECT ptu.template_id as templateId, ptu.permission_reference as permission, count(u.login) as count
+ 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
- AND ptu.template_id in
- <foreach collection="templateIds" open="(" close=")" item="id" separator=",">
+ AND ptu.template_uuid in
+ <foreach collection="templateUuids" open="(" close=")" item="id" separator=",">
#{id}
</foreach>
<where>
AND u.active = ${_true}
</where>
- GROUP BY ptu.template_id, ptu.permission_reference
+ GROUP BY ptu.template_uuid, ptu.permission_reference
</select>
- <select id="groupsCountByTemplateIdAndPermission" parameterType="map"
+ <select id="groupsCountByTemplateUuidAndPermission" parameterType="map"
resultType="org.sonar.db.permission.template.CountByTemplateAndPermissionDto">
- SELECT count(1) as count, permission, templateId
+ SELECT count(1) as count, permission, templateUuid
FROM
- (SELECT g.name as name, ptg.permission_reference as permission, ptg.template_id as templateId
+ (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
UNION
-- Add Anyone group permission
- SELECT #{anyoneGroup} as name, ptg.permission_reference as permission, ptg.template_id as templateId
+ 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
</where>
) groups
<where>
- AND groups.templateId in
- <foreach collection="templateIds" open="(" close=")" item="id" separator=",">
+ AND groups.templateUuid in
+ <foreach collection="templateUuids" open="(" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
- GROUP BY groups.permission, groups.templateId
+ GROUP BY groups.permission, groups.templateUuid
</select>
<select id="countGroupsWithPermission" resultType="int" parameterType="map">
select count(1)
from perm_templates_groups ptg
- where ptg.template_id = #{templateId}
+ where ptg.template_uuid = #{templateUuid}
and ptg.permission_reference = #{permission}
and
<if test="groupId == null">
</if>
</select>
- <select id="selectTemplateIdsByOrganization" resultType="Long">
+ <select id="selectTemplateUuidsByOrganization" resultType="String">
select
- id
+ uuid
from
permission_templates
where
<select id="selectAllGroupPermissionTemplatesByGroupId" parameterType="Long" resultType="PermissionTemplateGroup">
SELECT
ptg.uuid,
- ptg.template_id as templateId,
+ ptg.template_uuid as templateUuid,
ptg.permission_reference AS permission,
ptg.group_id AS groupId,
g.name AS groupName,
CREATE TABLE "PERM_TEMPLATES_GROUPS"(
"GROUP_ID" INTEGER,
- "TEMPLATE_ID" INTEGER NOT NULL,
"PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
"CREATED_AT" TIMESTAMP,
"UPDATED_AT" TIMESTAMP,
- "UUID" VARCHAR(40) NOT NULL
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL
);
ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
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
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL
);
ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
- "TEMPLATE_ID" INTEGER NOT NULL,
"PERMISSION_KEY" VARCHAR(64) NOT NULL,
"WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
"CREATED_AT" BIGINT NOT NULL,
"UPDATED_AT" BIGINT NOT NULL,
- "UUID" VARCHAR(40) NOT NULL
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL
);
ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
-CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_UUID", "PERMISSION_KEY");
CREATE TABLE "PERMISSION_TEMPLATES"(
- "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
"ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
"NAME" VARCHAR(100) NOT NULL,
- "KEE" VARCHAR(100) NOT NULL,
"DESCRIPTION" VARCHAR(4000),
"CREATED_AT" TIMESTAMP,
"UPDATED_AT" TIMESTAMP,
- "KEY_PATTERN" VARCHAR(500)
+ "KEY_PATTERN" VARCHAR(500),
+ "UUID" VARCHAR(40) NOT NULL
);
-ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("UUID");
CREATE TABLE "PLUGINS"(
"UUID" VARCHAR(40) NOT NULL,
GroupDto group3 = db.users().insertGroup(organization, "Group-3");
PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(organization);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), USER);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), ADMIN);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group2.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING);
PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(organization);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), null, USER);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), group1.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING);
assertThat(selectGroupNamesByQueryAndTemplate(builder(), organization, template))
.containsOnly("Group-1", "Group-2", "Group-3", "Anyone");
assertThat(selectGroupNamesByQueryAndTemplate(builder().setSearchQuery("p-2"), organization, template))
.containsOnly("Group-2");
- assertThat(selectGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().build(), organization, 123L))
+ assertThat(selectGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().build(), organization, "123"))
.isEmpty();
assertThat(selectGroupNamesByQueryAndTemplate(builder().setSearchQuery("unknown"), organization, template))
.isEmpty();
permissionTemplateDbTester.addGroupToTemplate(template, group3, UserRole.USER);
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
- assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getId()))
+ assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid()))
.containsExactly("Anyone", group3.getName(), group1.getName(), group2.getName());
}
permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(organization, lastGroupName).get(), UserRole.USER);
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
- assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getId()))
+ assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid()))
.hasSize(DEFAULT_PAGE_SIZE)
.startsWith("Anyone", lastGroupName, "Group-1");
}
permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(organization, lastGroupName).get(), UserRole.USER);
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
- assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getId()))
+ assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid()))
.hasSize(DEFAULT_PAGE_SIZE)
.startsWith("Anyone", lastGroupName, "Group-1");
}
GroupDto group = db.users().insertGroup(organization, "Group");
PermissionTemplateDto otherTemplate = permissionTemplateDbTester.insertTemplate(organization);
- permissionTemplateDbTester.addGroupToTemplate(otherTemplate.getId(), group.getId(), USER);
+ permissionTemplateDbTester.addGroupToTemplate(otherTemplate.getUuid(), group.getId(), USER);
assertThat(selectGroupNamesByQueryAndTemplate(builder().setSearchQuery("nyo"), organization, template))
.containsExactly("Anyone");
GroupDto group3 = db.users().insertGroup(organization, "Group-3");
PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate(organization);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), USER);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), ADMIN);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group2.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING);
PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate(organization);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), null, USER);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), group1.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING);
assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()), organization, template))
.isEqualTo(4);
assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).setSearchQuery("p-2"), organization, template))
.isEqualTo(1);
- assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().build(), organization, 123L))
+ assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().build(), organization, "123"))
.isZero();
assertThat(countGroupNamesByQueryAndTemplate(builder().setOrganizationUuid(organization.getUuid()).setSearchQuery("unknown"), organization, template))
.isZero();
GroupDto group3 = db.users().insertGroup(newGroupDto().setName("Group-3"));
PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate();
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), USER);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), ADMIN);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group2.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING);
PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate();
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), null, USER);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), group1.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING);
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getId(), asList("Group-1")))
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Group-1")))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(group1.getId(), "Group-1", USER),
tuple(group1.getId(), "Group-1", ADMIN));
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getId(), asList("Group-1")))
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getUuid(), asList("Group-1")))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(group1.getId(), "Group-1", PROVISIONING));
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getId(), asList("Anyone")))
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getUuid(), asList("Anyone")))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(0, "Anyone", USER));
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getId(), asList("Group-1", "Group-2", "Anyone"))).hasSize(3);
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getId(), asList("Unknown"))).isEmpty();
- assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getId(), Collections.emptyList())).isEmpty();
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Group-1", "Group-2", "Anyone"))).hasSize(3);
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Unknown"))).isEmpty();
+ assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), Collections.emptyList())).isEmpty();
}
@Test
GroupDto group3 = db.users().insertGroup(newGroupDto().setName("Group-3"));
PermissionTemplateDto template = permissionTemplateDbTester.insertTemplate();
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), USER);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group1.getId(), ADMIN);
- permissionTemplateDbTester.addGroupToTemplate(template.getId(), group2.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), USER);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group1.getId(), ADMIN);
+ permissionTemplateDbTester.addGroupToTemplate(template.getUuid(), group2.getId(), PROVISIONING);
PermissionTemplateDto anotherTemplate = permissionTemplateDbTester.insertTemplate();
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), null, USER);
- permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getId(), group1.getId(), PROVISIONING);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), null, USER);
+ permissionTemplateDbTester.addGroupToTemplate(anotherTemplate.getUuid(), group1.getId(), PROVISIONING);
- assertThat(underTest.selectGroupPermissionsByTemplateId(session, template.getId()))
+ assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, template.getUuid()))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(group1.getId(), "Group-1", USER),
tuple(group1.getId(), "Group-1", ADMIN),
tuple(group2.getId(), "Group-2", PROVISIONING));
- assertThat(underTest.selectGroupPermissionsByTemplateId(session, anotherTemplate.getId()))
+ assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, anotherTemplate.getUuid()))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(group1.getId(), "Group-1", PROVISIONING),
tuple(0, "Anyone", USER));
- assertThat(underTest.selectGroupPermissionsByTemplateId(session, 321L)).isEmpty();
+ assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, "321")).isEmpty();
}
private List<String> selectGroupNamesByQueryAndTemplate(PermissionQuery.Builder queryBuilder, OrganizationDto organization, PermissionTemplateDto permissionTemplateDto) {
- return selectGroupNamesByQueryAndTemplate(queryBuilder.setOrganizationUuid(organization.getUuid()).build(), organization, permissionTemplateDto.getId());
+ return selectGroupNamesByQueryAndTemplate(queryBuilder.setOrganizationUuid(organization.getUuid()).build(), organization, permissionTemplateDto.getUuid());
}
- private List<String> selectGroupNamesByQueryAndTemplate(PermissionQuery query, OrganizationDto organization, long templateId) {
- return underTest.selectGroupNamesByQueryAndTemplate(session, query, templateId);
+ private List<String> selectGroupNamesByQueryAndTemplate(PermissionQuery query, OrganizationDto organization, String templateUuid) {
+ return underTest.selectGroupNamesByQueryAndTemplate(session, query, templateUuid);
}
private int countGroupNamesByQueryAndTemplate(PermissionQuery.Builder queryBuilder, OrganizationDto organization, PermissionTemplateDto permissionTemplateDto) {
- return countGroupNamesByQueryAndTemplate(queryBuilder.build(), organization, permissionTemplateDto.getId());
+ return countGroupNamesByQueryAndTemplate(queryBuilder.build(), organization, permissionTemplateDto.getUuid());
}
- private int countGroupNamesByQueryAndTemplate(PermissionQuery query, OrganizationDto organization, long templateId) {
- return underTest.countGroupNamesByQueryAndTemplate(session, query, organization.getUuid(), templateId);
+ private int countGroupNamesByQueryAndTemplate(PermissionQuery query, OrganizationDto organization, String templateUuid) {
+ return underTest.countGroupNamesByQueryAndTemplate(session, query, organization.getUuid(), templateUuid);
}
}
import org.sonar.db.DbTester;
import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.primitives.Longs.asList;
+import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
private PermissionTemplateCharacteristicDao underTest = new PermissionTemplateCharacteristicDao();
@Test
- public void selectByTemplateId_filter_by_template_id() {
+ public void selectByTemplateId_filter_by_template_uuid() {
PermissionTemplateCharacteristicDto templatePermission1 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid1")
.setPermission(UserRole.ADMIN)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
PermissionTemplateCharacteristicDto templatePermission2 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid2")
.setPermission(UserRole.USER)
- .setTemplateId(2L)
+ .setTemplateUuid("2")
.setWithProjectCreator(false)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
PermissionTemplateCharacteristicDto templatePermission3 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid3")
.setPermission(UserRole.USER)
- .setTemplateId(3L)
+ .setTemplateUuid("3")
.setWithProjectCreator(false)
.setCreatedAt(1_000_000_001L)
.setUpdatedAt(2_000_000_000L));
PermissionTemplateCharacteristicDto templatePermissionForAnotherTemplate = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid4")
.setPermission(UserRole.ADMIN)
- .setTemplateId(42L)
+ .setTemplateUuid("42")
.setWithProjectCreator(true)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
- List<PermissionTemplateCharacteristicDto> result = underTest.selectByTemplateIds(dbSession, newArrayList(1L, 2L, 3L));
+ List<PermissionTemplateCharacteristicDto> result = underTest.selectByTemplateUuids(dbSession, newArrayList("1", "2", "3"));
assertThat(result)
.hasSize(3)
.extracting("uuid")
}
@Test
- public void selectByTemplateId_for_empty_list_of_template_id() {
- List<PermissionTemplateCharacteristicDto> result = underTest.selectByTemplateIds(dbSession, emptyList());
+ public void selectByTemplateId_for_empty_list_of_template_uuid() {
+ List<PermissionTemplateCharacteristicDto> result = underTest.selectByTemplateUuids(dbSession, emptyList());
assertThat(result).isEmpty();
}
PermissionTemplateCharacteristicDto templatePermission1 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid1")
.setPermission(UserRole.ADMIN)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid2")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(false)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid3")
.setPermission(UserRole.ADMIN)
- .setTemplateId(42L)
+ .setTemplateUuid("42")
.setWithProjectCreator(true)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
- Optional<PermissionTemplateCharacteristicDto> result = underTest.selectByPermissionAndTemplateId(dbSession, UserRole.ADMIN, 1L);
+ Optional<PermissionTemplateCharacteristicDto> result = underTest.selectByPermissionAndTemplateId(dbSession, UserRole.ADMIN, "1");
assertThat(result).isPresent();
assertThat(result.get()).isEqualToComparingFieldByField(templatePermission1);
PermissionTemplateCharacteristicDto expectedResult = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(123_456_789L)
.setUpdatedAt(2_000_000_000L));
PermissionTemplateCharacteristicDto insertedDto = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(123_456_789L)
.setUpdatedAt(2_000_000_000L));
underTest.update(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid")
.setPermission("PERMISSION_ARE_NOT_UPDATABLE")
- .setTemplateId(42L)
+ .setTemplateUuid("42")
.setCreatedAt(42L)
.setWithProjectCreator(false)
.setUpdatedAt(3_000_000_000L));
- PermissionTemplateCharacteristicDto result = underTest.selectByPermissionAndTemplateId(dbSession, insertedDto.getPermission(), insertedDto.getTemplateId()).get();
- assertThat(result).extracting("uuid", "permission", "templateId", "createdAt")
- .containsExactly(insertedDto.getUuid(), insertedDto.getPermission(), insertedDto.getTemplateId(), insertedDto.getCreatedAt());
+ PermissionTemplateCharacteristicDto result = underTest.selectByPermissionAndTemplateId(dbSession, insertedDto.getPermission(), insertedDto.getTemplateUuid()).get();
+ assertThat(result).extracting("uuid", "permission", "templateUuid", "createdAt")
+ .containsExactly(insertedDto.getUuid(), insertedDto.getPermission(), insertedDto.getTemplateUuid(), insertedDto.getCreatedAt());
assertThat(result).extracting("withProjectCreator", "updatedAt")
.containsExactly(false, 3_000_000_000L);
}
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setUpdatedAt(2_000_000_000L));
}
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(2_000_000_000L));
}
underTest.update(dbSession, new PermissionTemplateCharacteristicDto()
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(123_456_789L)
.setUpdatedAt(2_000_000_000L));
}
@Test
- public void delete_by_permission_template_id() {
+ public void delete_by_permission_template_uuid() {
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid1")
.setPermission(UserRole.USER)
- .setTemplateId(1L)
+ .setTemplateUuid("1")
.setWithProjectCreator(true)
.setCreatedAt(123_456_789L)
.setUpdatedAt(2_000_000_000L));
underTest.insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid("uuid2")
.setPermission(UserRole.USER)
- .setTemplateId(2L)
+ .setTemplateUuid("2")
.setWithProjectCreator(true)
.setCreatedAt(123_456_789L)
.setUpdatedAt(2_000_000_000L));
- assertThat(underTest.selectByTemplateIds(dbSession, asList(1L))).hasSize(1);
- assertThat(underTest.selectByTemplateIds(dbSession, asList(1L, 2L))).hasSize(2);
+ assertThat(underTest.selectByTemplateUuids(dbSession, asList("1"))).hasSize(1);
+ assertThat(underTest.selectByTemplateUuids(dbSession, asList("1", "2"))).hasSize(2);
- dbSession.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateId(1L);
+ dbSession.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateUuid("1");
- assertThat(underTest.selectByTemplateIds(dbSession, asList(1L))).hasSize(0);
- assertThat(underTest.selectByTemplateIds(dbSession, asList(1L, 2L))).hasSize(1);
+ assertThat(underTest.selectByTemplateUuids(dbSession, asList("1"))).hasSize(0);
+ assertThat(underTest.selectByTemplateUuids(dbSession, asList("1", "2"))).hasSize(1);
}
}
import org.junit.rules.ExpectedException;
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.UserDto;
-import static com.google.common.primitives.Longs.asList;
+import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
private System2 system2 = mock(System2.class);
private DbSession dbSession = db.getSession();
private PermissionTemplateDbTester templateDb = db.permissionTemplates();
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
- private PermissionTemplateDao underTest = new PermissionTemplateDao(system2);
+ private PermissionTemplateDao underTest = new PermissionTemplateDao(uuidFactory, system2);
@Before
public void setUp() {
PermissionTemplateDto t3InOrg1 = templateDb.insertTemplate(newPermissionTemplateDto().setName("hijkl").setOrganizationUuid("org2"));
PermissionTemplateDto t4InOrg2 = templateDb.insertTemplate(newPermissionTemplateDto().setName("cdefgh").setOrganizationUuid("org2"));
- assertThat(underTest.selectAll(dbSession, "org1", "def")).extracting(PermissionTemplateDto::getId).containsExactly(t1InOrg1.getId(), t2InOrg1.getId());
+ assertThat(underTest.selectAll(dbSession, "org1", "def")).extracting(PermissionTemplateDto::getUuid).containsExactly(t1InOrg1.getUuid(), t2InOrg1.getUuid());
assertThat(underTest.selectAll(dbSession, "org1", "missing")).isEmpty();
}
.setKeyPattern("new_regexp")
.setUpdatedAt(NOW)
// Invariant fields, should not be updated
- .setUuid("new UUID")
+ .setUuid("ABCD")
.setOrganizationUuid("new org")
.setCreatedAt(NOW));
db.commit();
templateDb.addGroupToTemplate(permissionTemplate1, group2, "user");
templateDb.addAnyoneToTemplate(permissionTemplate1, "admin");
templateDb.addAnyoneToTemplate(permissionTemplate2, "admin");
- templateDb.addProjectCreatorToTemplate(permissionTemplate1.getId(), "user");
- templateDb.addProjectCreatorToTemplate(permissionTemplate2.getId(), "user");
+ templateDb.addProjectCreatorToTemplate(permissionTemplate1.getUuid(), "user");
+ templateDb.addProjectCreatorToTemplate(permissionTemplate2.getUuid(), "user");
- underTest.deleteById(dbSession, permissionTemplate1.getId());
+ underTest.deleteByUuid(dbSession, permissionTemplate1.getUuid());
dbSession.commit();
assertThat(underTest.selectAll(db.getSession(), db.getDefaultOrganization().getUuid(), null))
.extracting(PermissionTemplateDto::getUuid)
.containsOnly(permissionTemplate2.getUuid());
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate1.getId())).isEmpty();
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate2.getId())).hasSize(1);
- assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), permissionTemplate1.getId())).isEmpty();
- assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), permissionTemplate2.getId())).hasSize(1);
- assertThat(db.getDbClient().permissionTemplateCharacteristicDao().selectByTemplateIds(db.getSession(), asList(permissionTemplate1.getId(), permissionTemplate2.getId())))
- .extracting(PermissionTemplateCharacteristicDto::getTemplateId)
- .containsOnly(permissionTemplate2.getId());
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate1.getUuid())).isEmpty();
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate2.getUuid())).hasSize(1);
+ assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate1.getUuid())).isEmpty();
+ assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate2.getUuid())).hasSize(1);
+ assertThat(db.getDbClient().permissionTemplateCharacteristicDao().selectByTemplateUuids(db.getSession(), asList(permissionTemplate1.getUuid(), permissionTemplate2.getUuid())))
+ .extracting(PermissionTemplateCharacteristicDto::getTemplateUuid)
+ .containsOnly(permissionTemplate2.getUuid());
}
@Test
PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization());
UserDto user = db.users().insertUser();
- underTest.insertUserPermission(dbSession, permissionTemplate.getId(), user.getId(), "user");
+ underTest.insertUserPermission(dbSession, permissionTemplate.getUuid(), user.getId(), "user");
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getId()))
- .extracting(PermissionTemplateUserDto::getTemplateId, PermissionTemplateUserDto::getUserId, PermissionTemplateUserDto::getPermission, PermissionTemplateUserDto::getCreatedAt,
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getUuid()))
+ .extracting(PermissionTemplateUserDto::getTemplateUuid, PermissionTemplateUserDto::getUserId, PermissionTemplateUserDto::getPermission,
+ PermissionTemplateUserDto::getCreatedAt,
PermissionTemplateUserDto::getUpdatedAt)
- .containsOnly(tuple(permissionTemplate.getId(), user.getId(), "user", NOW, NOW));
+ .containsOnly(tuple(permissionTemplate.getUuid(), user.getId(), "user", NOW, NOW));
}
@Test
templateDb.addUserToTemplate(permissionTemplate, user1, "admin");
templateDb.addUserToTemplate(permissionTemplate, user2, "user");
- underTest.deleteUserPermission(dbSession, permissionTemplate.getId(), user1.getId(), "user");
+ underTest.deleteUserPermission(dbSession, permissionTemplate.getUuid(), user1.getId(), "user");
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getId()))
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), permissionTemplate.getUuid()))
.extracting(PermissionTemplateUserDto::getUserId, PermissionTemplateUserDto::getPermission)
.containsOnly(tuple(user1.getId(), "admin"), tuple(user2.getId(), "user"));
}
PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization());
GroupDto group = db.users().insertGroup();
- underTest.insertGroupPermission(dbSession, permissionTemplate.getId(), group.getId(), "user");
+ underTest.insertGroupPermission(dbSession, permissionTemplate.getUuid(), group.getId(), "user");
dbSession.commit();
- assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), permissionTemplate.getId()))
- .extracting(PermissionTemplateGroupDto::getTemplateId, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission,
+ assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid()))
+ .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission,
PermissionTemplateGroupDto::getCreatedAt,
PermissionTemplateGroupDto::getUpdatedAt)
- .containsOnly(tuple(permissionTemplate.getId(), group.getId(), "user", NOW, NOW));
+ .containsOnly(tuple(permissionTemplate.getUuid(), group.getId(), "user", NOW, NOW));
}
@Test
underTest.deleteByGroup(db.getSession(), group1.getId());
db.getSession().commit();
- assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), permissionTemplate.getId()))
+ assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid()))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission)
.containsOnly(tuple(group2.getId(), "user"));
}
public void add_group_permission_to_anyone() {
PermissionTemplateDto permissionTemplate = templateDb.insertTemplate(db.getDefaultOrganization());
- underTest.insertGroupPermission(dbSession, permissionTemplate.getId(), null, "user");
+ underTest.insertGroupPermission(dbSession, permissionTemplate.getUuid(), null, "user");
dbSession.commit();
- assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), permissionTemplate.getId()))
- .extracting(PermissionTemplateGroupDto::getTemplateId, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName,
+ assertThat(db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), permissionTemplate.getUuid()))
+ .extracting(PermissionTemplateGroupDto::getTemplateUuid, PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName,
PermissionTemplateGroupDto::getPermission)
- .containsOnly(tuple(permissionTemplate.getId(), 0, "Anyone", "user"));
+ .containsOnly(tuple(permissionTemplate.getUuid(), 0, "Anyone", "user"));
}
@Test
GroupDto group1 = db.users().insertGroup(newGroupDto());
GroupDto group2 = db.users().insertGroup(newGroupDto());
GroupDto group3 = db.users().insertGroup(newGroupDto());
- templateDb.addGroupToTemplate(template1.getId(), group1.getId(), CODEVIEWER);
- templateDb.addGroupToTemplate(template1.getId(), group2.getId(), CODEVIEWER);
- templateDb.addGroupToTemplate(template1.getId(), group3.getId(), CODEVIEWER);
- templateDb.addGroupToTemplate(template1.getId(), null, CODEVIEWER);
- templateDb.addGroupToTemplate(template1.getId(), group1.getId(), ADMIN);
- templateDb.addGroupToTemplate(template2.getId(), group1.getId(), ADMIN);
- templateDb.addGroupToTemplate(template4.getId(), group1.getId(), ISSUE_ADMIN);
+ 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(), null, CODEVIEWER);
+ templateDb.addGroupToTemplate(template1.getUuid(), group1.getId(), ADMIN);
+ templateDb.addGroupToTemplate(template2.getUuid(), group1.getId(), ADMIN);
+ templateDb.addGroupToTemplate(template4.getUuid(), group1.getId(), ISSUE_ADMIN);
final List<CountByTemplateAndPermissionDto> result = new ArrayList<>();
- underTest.groupsCountByTemplateIdAndPermission(dbSession, asList(template1.getId(), template2.getId(), template3.getId()),
+ underTest.groupsCountByTemplateUuidAndPermission(dbSession, asList(template1.getUuid(), template2.getUuid(), template3.getUuid()),
context -> result.add(context.getResultObject()));
- assertThat(result).extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateId, CountByTemplateAndPermissionDto::getCount)
- .containsOnly(tuple(ADMIN, template1.getId(), 1), tuple(CODEVIEWER, template1.getId(), 4), tuple(ADMIN, template2.getId(), 1));
+ assertThat(result).extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateUuid, CountByTemplateAndPermissionDto::getCount)
+ .containsOnly(tuple(ADMIN, template1.getUuid(), 1), tuple(CODEVIEWER, template1.getUuid(), 4), tuple(ADMIN, template2.getUuid(), 1));
}
@Test
UserDto user2 = db.users().insertUser();
UserDto user3 = db.users().insertUser();
- templateDb.addUserToTemplate(template1.getId(), user1.getId(), ADMIN);
- templateDb.addUserToTemplate(template1.getId(), user2.getId(), ADMIN);
- templateDb.addUserToTemplate(template1.getId(), user3.getId(), ADMIN);
- templateDb.addUserToTemplate(template1.getId(), user1.getId(), USER);
- templateDb.addUserToTemplate(template2.getId(), user1.getId(), USER);
- templateDb.addUserToTemplate(anotherTemplate.getId(), user1.getId(), ISSUE_ADMIN);
+ 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);
final List<CountByTemplateAndPermissionDto> result = new ArrayList<>();
- underTest.usersCountByTemplateIdAndPermission(dbSession, asList(template1.getId(), template2.getId(), template3.getId()),
+ underTest.usersCountByTemplateUuidAndPermission(dbSession, asList(template1.getUuid(), template2.getUuid(), template3.getUuid()),
context -> result.add(context.getResultObject()));
assertThat(result)
- .extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateId, CountByTemplateAndPermissionDto::getCount)
+ .extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateUuid, CountByTemplateAndPermissionDto::getCount)
.containsExactlyInAnyOrder(
- tuple(ADMIN, template1.getId(), 3),
- tuple(USER, template1.getId(), 1),
- tuple(USER, template2.getId(), 1));
+ tuple(ADMIN, template1.getUuid(), 3),
+ tuple(USER, template1.getUuid(), 1),
+ tuple(USER, template2.getUuid(), 1));
}
@Test
public void selectPotentialPermissions_with_unknown_template_and_no_user() {
- List<String> result = underTest.selectPotentialPermissionsByUserIdAndTemplateId(dbSession, null, 42L);
+ List<String> result = underTest.selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, null, "42");
assertThat(result).isEmpty();
}
UserDto user = db.users().insertUser();
PermissionTemplateDto template = templateDb.insertTemplate();
- List<String> result = underTest.selectPotentialPermissionsByUserIdAndTemplateId(dbSession, user.getId(), template.getId());
+ List<String> result = underTest.selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, user.getId(), template.getUuid());
assertThat(result).isEmpty();
}
GroupDto group = db.users().insertGroup(newGroupDto());
db.users().insertMember(group, user);
PermissionTemplateDto template = templateDb.insertTemplate();
- templateDb.addProjectCreatorToTemplate(template.getId(), SCAN_EXECUTION);
- templateDb.addProjectCreatorToTemplate(template.getId(), UserRole.ADMIN);
- templateDb.addUserToTemplate(template.getId(), user.getId(), UserRole.USER);
- templateDb.addUserToTemplate(template.getId(), user.getId(), UserRole.ADMIN);
- templateDb.addGroupToTemplate(template.getId(), group.getId(), UserRole.CODEVIEWER);
- templateDb.addGroupToTemplate(template.getId(), group.getId(), UserRole.ADMIN);
- templateDb.addGroupToTemplate(template.getId(), null, UserRole.ISSUE_ADMIN);
+ 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.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.CODEVIEWER);
+ templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.ADMIN);
+ templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN);
- List<String> resultWithUser = underTest.selectPotentialPermissionsByUserIdAndTemplateId(dbSession, user.getId(), template.getId());
- List<String> resultWithoutUser = underTest.selectPotentialPermissionsByUserIdAndTemplateId(dbSession, null, template.getId());
+ List<String> resultWithUser = underTest.selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, user.getId(), template.getUuid());
+ List<String> resultWithoutUser = underTest.selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, null, template.getUuid());
assertThat(resultWithUser).containsOnlyOnce(SCAN_EXECUTION, UserRole.ADMIN, UserRole.USER, UserRole.CODEVIEWER, UserRole.ISSUE_ADMIN);
// only permission from anyone group
createTemplate(organization2)
};
- verifyTemplateIdsInDb(templates[0].getId(), templates[1].getId(), templates[2].getId(), templates[3].getId(), templates[4].getId());
+ verifyTemplateUuidsInDb(templates[0].getUuid(), templates[1].getUuid(), templates[2].getUuid(), templates[3].getUuid(), templates[4].getUuid());
underTest.deleteByOrganization(dbSession, organization2.getUuid());
dbSession.commit();
- verifyTemplateIdsInDb(templates[0].getId(), templates[2].getId(), templates[3].getId());
+ verifyTemplateUuidsInDb(templates[0].getUuid(), templates[2].getUuid(), templates[3].getUuid());
underTest.deleteByOrganization(dbSession, organization3.getUuid());
dbSession.commit();
- verifyTemplateIdsInDb(templates[0].getId(), templates[3].getId());
+ verifyTemplateUuidsInDb(templates[0].getUuid(), templates[3].getUuid());
underTest.deleteByOrganization(dbSession, organization1.getUuid());
dbSession.commit();
- verifyTemplateIdsInDb();
+ verifyTemplateUuidsInDb();
}
@Test
PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
String permission = "PERMISSION";
- db.permissionTemplates().addUserToTemplate(template.getId(), user.getId(), permission);
- db.permissionTemplates().addUserToTemplate(template.getId(), anotherUser.getId(), permission);
- db.permissionTemplates().addUserToTemplate(anotherTemplate.getId(), user.getId(), 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);
underTest.deleteUserPermissionsByOrganization(dbSession, organization.getUuid(), user.getId());
- assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, template.getId())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(anotherUser.getId());
- assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getId())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(user.getId());
+ assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(anotherUser.getId());
+ assertThat(underTest.selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId).containsOnly(user.getId());
}
@Test
PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
String permission = "PERMISSION";
- db.permissionTemplates().addUserToTemplate(template.getId(), user.getId(), permission);
- db.permissionTemplates().addUserToTemplate(template.getId(), anotherUser.getId(), permission);
- db.permissionTemplates().addUserToTemplate(anotherTemplate.getId(), user.getId(), 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);
underTest.deleteUserPermissionsByUserId(dbSession, user.getId());
db.commit();
- assertThat(db.select("select template_id as \"templateId\", user_id as \"userId\", permission_reference as \"permission\" from perm_templates_users"))
- .extracting((row) -> row.get("templateId"), (row) -> row.get("userId"), (row) -> row.get("permission"))
- .containsOnly(tuple(template.getId(), anotherUser.getId().longValue(), permission));
+ 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));
}
private PermissionTemplateDto createTemplate(OrganizationDto organization) {
GroupDto group = db.users().insertGroup();
db.users().insertMember(group, user);
PermissionTemplateDto template = templateDb.insertTemplate(organization);
- templateDb.addProjectCreatorToTemplate(template.getId(), SCAN_EXECUTION);
- templateDb.addProjectCreatorToTemplate(template.getId(), UserRole.ADMIN);
- templateDb.addUserToTemplate(template.getId(), user.getId(), UserRole.USER);
- templateDb.addUserToTemplate(template.getId(), user.getId(), UserRole.ADMIN);
- templateDb.addGroupToTemplate(template.getId(), group.getId(), UserRole.CODEVIEWER);
- templateDb.addGroupToTemplate(template.getId(), group.getId(), UserRole.ADMIN);
- templateDb.addGroupToTemplate(template.getId(), null, UserRole.ISSUE_ADMIN);
+ 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.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.CODEVIEWER);
+ templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.ADMIN);
+ templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN);
return template;
}
- private void verifyTemplateIdsInDb(Long... expectedTemplateIds) {
- assertThat(db.select("select distinct template_id as \"templateId\" from perm_templates_groups"))
- .extracting((row) -> (Long) row.get("templateId"))
- .containsOnly(expectedTemplateIds);
- assertThat(db.select("select distinct template_id as \"templateId\" from perm_templates_users"))
- .extracting((row) -> (Long) row.get("templateId"))
- .containsOnly(expectedTemplateIds);
- assertThat(db.select("select distinct template_id as \"templateId\" from perm_tpl_characteristics"))
- .extracting((row) -> (Long) row.get("templateId"))
- .containsOnly(expectedTemplateIds);
- assertThat(db.select("select distinct id as \"templateId\" from permission_templates"))
- .extracting((row) -> (Long) row.get("templateId"))
- .containsOnly(expectedTemplateIds);
+ private void verifyTemplateUuidsInDb(String... expectedTemplateUuids) {
+ assertThat(db.select("select distinct template_uuid as \"templateUuid\" from perm_templates_groups"))
+ .extracting((row) -> (String) row.get("templateUuid"))
+ .containsOnly(expectedTemplateUuids);
+ assertThat(db.select("select distinct template_uuid as \"templateUuid\" from perm_templates_users"))
+ .extracting((row) -> (String) row.get("templateUuid"))
+ .containsOnly(expectedTemplateUuids);
+ assertThat(db.select("select distinct template_uuid as \"templateUuid\" from perm_tpl_characteristics"))
+ .extracting((row) -> (String) row.get("templateUuid"))
+ .containsOnly(expectedTemplateUuids);
+ assertThat(db.select("select distinct uuid as \"templateUuid\" from permission_templates"))
+ .extracting((row) -> (String) row.get("templateUuid"))
+ .containsOnly(expectedTemplateUuids);
}
}
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
builder().setOrganizationUuid(organization.getUuid()).build(),
- permissionTemplate.getId()))
+ permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin(), user2.getLogin(), user3.getLogin());
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().setPermission(USER).build(),
- permissionTemplate.getId()))
+ permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin(), user2.getLogin());
}
db.permissionTemplates().addUserToTemplate(permissionTemplate, user, USER);
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).setPermission(USER).withAtLeastOnePermission().build(), 999L))
+ builder().setOrganizationUuid(organization.getUuid()).setPermission(USER).withAtLeastOnePermission().build(), "999"))
.isEmpty();
}
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
builder().setOrganizationUuid(organization.getUuid()).setPermission(USER).withAtLeastOnePermission().build(),
- permissionTemplate.getId()))
+ permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin(), user2.getLogin());
}
db.permissionTemplates().addUserToTemplate(permissionTemplate, disabledUser, USER);
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).setPermission(USER).build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).setPermission(USER).build(), permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user.getLogin());
}
assertThat(underTest.selectUserLoginsByQueryAndTemplate(
dbSession, builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().setPermission(USER).setSearchQuery("SEr1").build(),
- permissionTemplate.getId()))
+ permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin());
assertThat(underTest.selectUserLoginsByQueryAndTemplate(
dbSession, builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().setPermission(USER).setSearchQuery("user").build(),
- permissionTemplate.getId()))
+ permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin(), user2.getLogin());
}
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.getId(), user3.getId(), UserRole.USER);
+ db.permissionTemplates().addUserToTemplate(template.getUuid(), user3.getId(), UserRole.USER);
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
- assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getId()))
+ assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getUuid()))
.containsExactly(user3.getLogin(), user1.getLogin(), user2.getLogin());
}
db.permissionTemplates().addUserToTemplate(template, db.users().selectUserByLogin(lastLogin).get(), UserRole.USER);
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(organization.getUuid()).build();
- assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getId()))
+ assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getUuid()))
.hasSize(DEFAULT_PAGE_SIZE)
.startsWith(lastLogin);
}
db.permissionTemplates().addUserToTemplate(permissionTemplate, user2, USER);
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).setPageIndex(1).setPageSize(2).build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).setPageIndex(1).setPageSize(2).build(), permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user1.getLogin(), user2.getLogin());
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).setPageIndex(2).setPageSize(2).build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).setPageIndex(2).setPageSize(2).build(), permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user3.getLogin());
assertThat(underTest.selectUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).setPageIndex(3).setPageSize(1).build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).setPageIndex(3).setPageSize(1).build(), permissionTemplate.getUuid()))
.containsExactlyInAnyOrder(user3.getLogin());
}
db.permissionTemplates().addUserToTemplate(permissionTemplate, user2, USER);
assertThat(underTest.countUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).build(), permissionTemplate.getUuid()))
.isEqualTo(3);
assertThat(underTest.countUserLoginsByQueryAndTemplate(dbSession,
- builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().setPermission("user").build(), permissionTemplate.getId()))
+ builder().setOrganizationUuid(organization.getUuid()).withAtLeastOnePermission().setPermission("user").build(), permissionTemplate.getUuid()))
.isEqualTo(2);
}
PermissionTemplateDto anotherPermissionTemplate = db.permissionTemplates().insertTemplate();
db.permissionTemplates().addUserToTemplate(anotherPermissionTemplate, user1, USER);
- assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getId(), singletonList(user1.getLogin())))
+ assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), singletonList(user1.getLogin())))
.extracting(PermissionTemplateUserDto::getUserLogin, PermissionTemplateUserDto::getPermission)
.containsExactlyInAnyOrder(
tuple(user1.getLogin(), USER),
tuple(user1.getLogin(), ADMIN),
tuple(user1.getLogin(), CODEVIEWER));
- assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getId(), asList(user1.getLogin(), user2.getLogin(), user2.getLogin())))
+ assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), asList(user1.getLogin(), user2.getLogin(), user2.getLogin())))
.extracting(PermissionTemplateUserDto::getUserLogin, PermissionTemplateUserDto::getPermission)
.containsExactlyInAnyOrder(
tuple(user1.getLogin(), USER),
tuple(user1.getLogin(), CODEVIEWER),
tuple(user2.getLogin(), USER));
- assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getId(), singletonList("unknown"))).isEmpty();
- assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getId(), Collections.emptyList())).isEmpty();
- assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, 123L, singletonList(user1.getLogin()))).isEmpty();
+ assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), singletonList("unknown"))).isEmpty();
+ assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), Collections.emptyList())).isEmpty();
+ assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, "123", singletonList(user1.getLogin()))).isEmpty();
}
}
}
public void addGroupToTemplate(PermissionTemplateDto permissionTemplate, GroupDto group, String permission) {
- addGroupToTemplate(permissionTemplate.getId(), group.getId(), permission);
+ addGroupToTemplate(permissionTemplate.getUuid(), group.getId(), permission);
}
- public void addGroupToTemplate(long templateId, @Nullable Integer groupId, String permission) {
- dbClient.permissionTemplateDao().insertGroupPermission(dbSession, templateId, groupId, permission);
+ public void addGroupToTemplate(String templateUuid, @Nullable Integer groupId, String permission) {
+ dbClient.permissionTemplateDao().insertGroupPermission(dbSession, templateUuid, groupId, permission);
db.commit();
}
public void addAnyoneToTemplate(PermissionTemplateDto permissionTemplate, String permission) {
- addGroupToTemplate(permissionTemplate.getId(), null, permission);
+ addGroupToTemplate(permissionTemplate.getUuid(), null, permission);
}
public void addUserToTemplate(PermissionTemplateDto permissionTemplate, UserDto user, String permission) {
- addUserToTemplate(permissionTemplate.getId(), user.getId(), permission);
+ addUserToTemplate(permissionTemplate.getUuid(), user.getId(), permission);
}
- public void addUserToTemplate(long templateId, int userId, String permission) {
- dbClient.permissionTemplateDao().insertUserPermission(dbSession, templateId, userId, permission);
+ public void addUserToTemplate(String templateUuid, int userId, String permission) {
+ dbClient.permissionTemplateDao().insertUserPermission(dbSession, templateUuid, userId, permission);
db.commit();
}
public void addProjectCreatorToTemplate(PermissionTemplateDto permissionTemplate, String permission) {
- addProjectCreatorToTemplate(permissionTemplate.getId(), permission);
+ addProjectCreatorToTemplate(permissionTemplate.getUuid(), permission);
}
- public void addProjectCreatorToTemplate(long templateId, String permission) {
+ public void addProjectCreatorToTemplate(String templateUuid, String permission) {
dbClient.permissionTemplateCharacteristicDao().insert(dbSession, newPermissionTemplateCharacteristicDto()
.setWithProjectCreator(true)
- .setTemplateId(templateId)
+ .setTemplateUuid(templateUuid)
.setPermission(permission));
db.commit();
}
import org.sonar.server.platform.db.migration.version.v83.permtplcharacteristics.DropPrimaryKeyOnIdColumnOfPermTplCharacteristicsTable;
import org.sonar.server.platform.db.migration.version.v83.permtplcharacteristics.MakePermTplCharacteristicsUuidColumnNotNullable;
import org.sonar.server.platform.db.migration.version.v83.permtplcharacteristics.PopulatePermTplCharacteristicsUuid;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.AddUuidColumnToPermissionTemplates;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropIdColumnOfPermissionTemplatesTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropKeeColumnOfPermissionTemplatesTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropPrimaryKeyOnIdColumnOfPermissionTemplatesTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.MakePermissionTemplateUuidColumnNotNullable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.PopulatePermissionTemplatesUuid;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesgroups.AddTemplateUuidColumnToPermTemplatesGroups;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesgroups.DropTemplateIdColumnOfPermTemplatesGroupsTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesgroups.MakePermTemplatesGroupsTemplateUuidColumnNotNullable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesgroups.PopulatePermTemplatesGroupsTemplateUuidColumn;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesusers.AddTemplateUuidColumnToPermTemplatesUsers;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesusers.DropTemplateIdColumnOfPermTemplatesUsersTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesusers.MakePermTemplatesUsersTemplateUuidColumnNotNullable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtemplatesusers.PopulatePermTemplatesUsersTemplateUuidColumn;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.AddTemplateUuidColumnToPermTplCharacteristics;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.DropTemplateIdColumnOfPermTplCharacteristicsTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.MakePermTplCharacteristicsTemplateUuidColumnNotNullable;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.fk.permtplcharacteristics.PopulatePermTplCharacteristicsTemplateUuidColumn;
import org.sonar.server.platform.db.migration.version.v83.projectmeasures.AddPrimaryKeyOnUuidColumnOfProjectMeasuresTable;
import org.sonar.server.platform.db.migration.version.v83.projectmeasures.AddUuidColumnToProjectMeasures;
import org.sonar.server.platform.db.migration.version.v83.projectmeasures.DropIdColumnOfProjectMeasuresTable;
.add(3552, "Drop column 'METRIC_ID' of 'MANUAL_MEASURES' table", DropMetricIdColumnOfManualMeasuresTable.class)
.add(3553, "Drop column 'ID' of 'METRICS' table", DropIdColumnOfMetricsTable.class)
+ // Migration of PERMISSION_TEMPLATES table
+ .add(3554, "Add 'UUID' column on 'PERMISSION_TEMPLATES' table", AddUuidColumnToPermissionTemplates.class)
+ .add(3555, "Populate 'uuid' for 'PERMISSION_TEMPLATES'", PopulatePermissionTemplatesUuid.class)
+ .add(3556, "Make 'uuid' column not nullable for user_tokens", MakePermissionTemplateUuidColumnNotNullable.class)
+
+ // Migration of PERM_TEMPLATES_GROUPS FK to PERMISSION_TEMPLATES, switch from templateId to templateUuid
+ .add(3557, "Add 'template_uuid' column for 'PERM_TEMPLATES_GROUPS' table", AddTemplateUuidColumnToPermTemplatesGroups.class)
+ .add(3558, "Populate 'template_uuid' column for 'PERM_TEMPLATES_GROUPS' table", PopulatePermTemplatesGroupsTemplateUuidColumn.class)
+ .add(3559, "Make 'template_uuid' column not nullable for 'PERM_TEMPLATES_GROUPS' table", MakePermTemplatesGroupsTemplateUuidColumnNotNullable.class)
+ .add(3560, "Drop column 'template_id' of 'PERM_TEMPLATES_GROUPS' table", DropTemplateIdColumnOfPermTemplatesGroupsTable.class)
+
+ // Migration of PERM_TEMPLATES_USERS FK to PERMISSION_TEMPLATES, switch from templateId to templateUuid
+ .add(3561, "Add 'template_uuid' column for 'PERM_TEMPLATES_USERS' table", AddTemplateUuidColumnToPermTemplatesUsers.class)
+ .add(3562, "Populate 'template_uuid' column for 'PERM_TEMPLATES_USERS' table", PopulatePermTemplatesUsersTemplateUuidColumn.class)
+ .add(3563, "Make 'template_uuid' column not nullable for 'PERM_TEMPLATES_USERS' table", MakePermTemplatesUsersTemplateUuidColumnNotNullable.class)
+ .add(3564, "Drop column 'template_id' of 'PERM_TEMPLATES_USERS' table", DropTemplateIdColumnOfPermTemplatesUsersTable.class)
+
+ // Migration of PERM_TPL_CHARACTERISTICS FK to PERMISSION_TEMPLATES, switch from templateId to templateUuid
+ .add(3565, "Add 'template_uuid' column for 'PERM_TPL_CHARACTERISTICS' table", AddTemplateUuidColumnToPermTplCharacteristics.class)
+ .add(3566, "Populate 'template_uuid' column for 'PERM_TPL_CHARACTERISTICS' table", PopulatePermTplCharacteristicsTemplateUuidColumn.class)
+ .add(3567, "Make 'template_uuid' column not nullable for 'PERM_TPL_CHARACTERISTICS' table", MakePermTplCharacteristicsTemplateUuidColumnNotNullable.class)
+ .add(3568, "Drop unique constraint on 'template_id', 'permission_key' columns 'PERM_TPL_CHARACTERISTICS' table",
+ DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTable.class)
+ .add(3569, "Add unique constraint on 'template_uuid', 'permission_key' columns 'PERM_TPL_CHARACTERISTICS' table",
+ AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTable.class)
+
+ .add(3570, "Drop column 'template_id' of 'PERM_TPL_CHARACTERISTICS' table", DropTemplateIdColumnOfPermTplCharacteristicsTable.class)
+
+ .add(3571, "Drop primary key on 'ID' column of 'PERMISSION_TEMPLATES' table", DropPrimaryKeyOnIdColumnOfPermissionTemplatesTable.class)
+ .add(3572, "Add primary key on 'UUID' column of 'PERMISSION_TEMPLATES' table", AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTable.class)
+
+ .add(3573, "Drop column 'ID' of 'PERMISSION_TEMPLATES' table", DropIdColumnOfPermissionTemplatesTable.class)
+ .add(3574, "Drop column 'KEE' of 'PERMISSION_TEMPLATES' table", DropKeeColumnOfPermissionTemplatesTable.class)
+
;
}
}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+import org.sonar.server.platform.db.migration.version.v83.util.AddPrimaryKeyBuilder;
+
+public class AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTable extends DdlChange {
+
+ public AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AddPrimaryKeyBuilder("permission_templates", "uuid").build());
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.common.AddUuidColumnToTable;
+
+public class AddUuidColumnToPermissionTemplates extends AddUuidColumnToTable {
+ private static final String TABLE_NAME = "permission_templates";
+
+ public AddUuidColumnToPermissionTemplates(Database db) {
+ super(db, TABLE_NAME);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.common.DropIdColumn;
+
+public class DropIdColumnOfPermissionTemplatesTable extends DropIdColumn {
+ private static final String TABLE_NAME = "permission_templates";
+
+ public DropIdColumnOfPermissionTemplatesTable(Database db) {
+ super(db, TABLE_NAME);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 DropKeeColumnOfPermissionTemplatesTable extends DdlChange {
+
+ public DropKeeColumnOfPermissionTemplatesTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new DropColumnsBuilder(getDialect(), "permission_templates", "kee").build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.common.DropPrimaryKeyOnIdColumn;
+import org.sonar.server.platform.db.migration.version.v83.util.DropPrimaryKeySqlGenerator;
+
+public class DropPrimaryKeyOnIdColumnOfPermissionTemplatesTable extends DropPrimaryKeyOnIdColumn {
+ private static final String TABLE_NAME = "permission_templates";
+
+ public DropPrimaryKeyOnIdColumnOfPermissionTemplatesTable(Database db, DropPrimaryKeySqlGenerator dropPrimaryKeySqlGenerator) {
+ super(db, dropPrimaryKeySqlGenerator, TABLE_NAME);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.version.v83.common.MakeUuidColumnNotNullable;
+
+public class MakePermissionTemplateUuidColumnNotNullable extends MakeUuidColumnNotNullable {
+ private static final String TABLE_NAME = "permission_templates";
+
+ public MakePermissionTemplateUuidColumnNotNullable(Database db) {
+ super(db, TABLE_NAME);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import java.sql.SQLException;
+import org.sonar.core.util.UuidFactory;
+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 PopulatePermissionTemplatesUuid extends DataChange {
+
+ private UuidFactory uuidFactory;
+
+ public PopulatePermissionTemplatesUuid(Database db, UuidFactory uuidFactory) {
+ super(db);
+ this.uuidFactory = uuidFactory;
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate();
+
+ massUpdate.select("select kee from permission_templates where uuid is null");
+ massUpdate.update("update permission_templates set uuid = ? where kee = ?");
+
+ massUpdate.execute((row, update) -> {
+ String kee = row.getString(1);
+ String uuid = kee;
+
+ //kee column was declared with 100 char length, so we regenerate if it happened
+ if (kee.length() > 40) {
+ uuid = uuidFactory.create();
+ }
+
+ update.setString(1, uuid);
+ update.setString(2, kee);
+ return true;
+ });
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 AddTemplateUuidColumnToPermTemplatesGroups extends DdlChange {
+ private static final String TABLE = "perm_templates_groups";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(true)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public AddTemplateUuidColumnToPermTemplatesGroups(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AddColumnsBuilder(getDialect(), TABLE)
+ .addColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 DropTemplateIdColumnOfPermTemplatesGroupsTable extends DdlChange {
+
+ public DropTemplateIdColumnOfPermTemplatesGroupsTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new DropColumnsBuilder(getDialect(), "perm_templates_groups", "template_id").build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 MakePermTemplatesGroupsTemplateUuidColumnNotNullable extends DdlChange {
+ private static final String TABLE = "perm_templates_groups";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(false)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public MakePermTemplatesGroupsTemplateUuidColumnNotNullable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AlterColumnsBuilder(getDialect(), TABLE)
+ .updateColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 PopulatePermTemplatesGroupsTemplateUuidColumn extends DataChange {
+
+ public PopulatePermTemplatesGroupsTemplateUuidColumn(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate();
+
+ massUpdate.select("select ptg.uuid, pt.uuid " +
+ "from perm_templates_groups ptg " +
+ "join permission_templates pt on ptg.template_id = pt.id " +
+ "where ptg.template_uuid is null");
+ massUpdate.update("update perm_templates_groups set template_uuid = ? where uuid = ?");
+
+ massUpdate.execute((row, update) -> {
+ update.setString(1, row.getString(2));
+ update.setString(2, row.getString(1));
+ return true;
+ });
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesusers;
+
+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 AddTemplateUuidColumnToPermTemplatesUsers extends DdlChange {
+ private static final String TABLE = "perm_templates_users";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(true)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public AddTemplateUuidColumnToPermTemplatesUsers(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AddColumnsBuilder(getDialect(), TABLE)
+ .addColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.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 DropTemplateIdColumnOfPermTemplatesUsersTable extends DdlChange {
+
+ public DropTemplateIdColumnOfPermTemplatesUsersTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new DropColumnsBuilder(getDialect(), "perm_templates_users", "template_id").build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesusers;
+
+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 MakePermTemplatesUsersTemplateUuidColumnNotNullable extends DdlChange {
+ private static final String TABLE = "perm_templates_users";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(false)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public MakePermTemplatesUsersTemplateUuidColumnNotNullable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AlterColumnsBuilder(getDialect(), TABLE)
+ .updateColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.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 PopulatePermTemplatesUsersTemplateUuidColumn extends DataChange {
+
+ public PopulatePermTemplatesUsersTemplateUuidColumn(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate();
+
+ massUpdate.select("select ptu.uuid, pt.uuid " +
+ "from perm_templates_users ptu " +
+ "join permission_templates pt on ptu.template_id = pt.id " +
+ "where ptu.template_uuid is null");
+ massUpdate.update("update perm_templates_users set template_uuid = ? where uuid = ?");
+
+ massUpdate.execute((row, update) -> {
+ update.setString(1, row.getString(2));
+ update.setString(2, row.getString(1));
+ return true;
+ });
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 AddTemplateUuidColumnToPermTplCharacteristics extends DdlChange {
+ private static final String TABLE = "perm_tpl_characteristics";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(true)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public AddTemplateUuidColumnToPermTplCharacteristics(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AddColumnsBuilder(getDialect(), TABLE)
+ .addColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.db.DatabaseUtils;
+import org.sonar.server.platform.db.migration.def.VarcharColumnDef;
+import org.sonar.server.platform.db.migration.sql.CreateIndexBuilder;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.newVarcharColumnDefBuilder;
+
+public class AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTable extends DdlChange {
+ private static final String TABLE_NAME = "perm_tpl_characteristics";
+ private static final String INDEX_NAME = "uniq_perm_tpl_charac";
+
+ public AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ if (!indexExists()) {
+ context.execute(new CreateIndexBuilder()
+ .setUnique(true)
+ .setTable(TABLE_NAME)
+ .setName(INDEX_NAME)
+ .addColumn(newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(false)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build())
+ .addColumn(newVarcharColumnDefBuilder()
+ .setColumnName("permission_key")
+ .setIsNullable(false)
+ .setLimit(64)
+ .build())
+ .build());
+ }
+
+ }
+
+ private boolean indexExists() throws SQLException {
+ try (Connection connection = getDatabase().getDataSource().getConnection()) {
+ return DatabaseUtils.indexExists(TABLE_NAME, INDEX_NAME, connection);
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 DropTemplateIdColumnOfPermTplCharacteristicsTable extends DdlChange {
+
+ public DropTemplateIdColumnOfPermTplCharacteristicsTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new DropColumnsBuilder(getDialect(), "perm_tpl_characteristics", "template_id").build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.db.DatabaseUtils;
+import org.sonar.server.platform.db.migration.sql.DropIndexBuilder;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+public class DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTable extends DdlChange {
+ private static final String TABLE_NAME = "perm_tpl_characteristics";
+ private static final String INDEX_NAME = "uniq_perm_tpl_charac";
+
+ public DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ if (indexExists()) {
+ context.execute(new DropIndexBuilder(getDialect())
+ .setTable(TABLE_NAME)
+ .setName(INDEX_NAME)
+ .build());
+ }
+ }
+
+ private boolean indexExists() throws SQLException {
+ try (Connection connection = getDatabase().getDataSource().getConnection()) {
+ return DatabaseUtils.indexExists(TABLE_NAME, INDEX_NAME, connection);
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 MakePermTplCharacteristicsTemplateUuidColumnNotNullable extends DdlChange {
+ private static final String TABLE = "perm_tpl_characteristics";
+
+ private static final VarcharColumnDef uuidColumnDefinition = newVarcharColumnDefBuilder()
+ .setColumnName("template_uuid")
+ .setIsNullable(false)
+ .setDefaultValue(null)
+ .setLimit(VarcharColumnDef.UUID_SIZE)
+ .build();
+
+ public MakePermTplCharacteristicsTemplateUuidColumnNotNullable(Database db) {
+ super(db);
+ }
+
+ @Override
+ public void execute(Context context) throws SQLException {
+ context.execute(new AlterColumnsBuilder(getDialect(), TABLE)
+ .updateColumn(uuidColumnDefinition)
+ .build());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 PopulatePermTplCharacteristicsTemplateUuidColumn extends DataChange {
+
+ public PopulatePermTplCharacteristicsTemplateUuidColumn(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate();
+
+ massUpdate.select("select ptc.uuid, pt.uuid " +
+ "from perm_tpl_characteristics ptc " +
+ "join permission_templates pt on ptc.template_id = pt.id " +
+ "where ptc.template_uuid is null");
+ massUpdate.update("update perm_tpl_characteristics set template_uuid = ? where uuid = ?");
+
+ massUpdate.execute((row, update) -> {
+ update.setString(1, row.getString(2));
+ update.setString(2, row.getString(1));
+ return true;
+ });
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 org.sonar.server.platform.db.migration.version.v83.projectmeasures.AddPrimaryKeyOnUuidColumnOfProjectMeasuresTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new AddPrimaryKeyOnUuidColumnOfPermissionTemplatesTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertPrimaryKey("permission_templates", "pk_permission_templates", "uuid");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+import org.sonar.server.platform.db.migration.version.v83.projectmeasures.AddUuidColumnToProjectMeasures;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AddUuidColumnToPermissionTemplatesTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(AddUuidColumnToPermissionTemplatesTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+
+ private DdlChange underTest = new AddUuidColumnToPermissionTemplates(db.database());
+
+ @Before
+ public void setup() {
+ insertPermissionTemplate(1L);
+ insertPermissionTemplate(2L);
+ insertPermissionTemplate(3L);
+ }
+
+ @Test
+ public void add_uuid_column_to_permission_templates() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("permission_templates", "uuid", Types.VARCHAR, 40, true);
+
+ assertThat(db.countSql("select count(id) from permission_templates"))
+ .isEqualTo(3);
+ }
+
+ private void insertPermissionTemplate(Long id) {
+ db.executeInsert("permission_templates",
+ "id", id,
+ "organization_uuid", id + 100,
+ "name", uuidFactory.create(),
+ "kee", uuidFactory.create());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 org.sonar.server.platform.db.migration.version.v83.projectmeasures.DropIdColumnOfProjectMeasuresTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropIdColumnOfPermissionTemplatesTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropIdColumnOfPermissionTemplatesTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropIdColumnOfPermissionTemplatesTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDoesNotExist("permission_templates", "id");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 org.sonar.server.platform.db.migration.version.v83.projectmeasures.DropIdColumnOfProjectMeasuresTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropKeeColumnOfPermissionTemplatesTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropKeeColumnOfPermissionTemplatesTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropKeeColumnOfPermissionTemplatesTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDoesNotExist("permission_templates", "kee");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 org.sonar.server.platform.db.migration.version.v83.util.DropPrimaryKeySqlGenerator;
+import org.sonar.server.platform.db.migration.version.v83.util.SqlHelper;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropPrimaryKeyOnIdColumnOfPermissionTemplatesTableTest {
+
+ private static final String TABLE_NAME = "permission_templates";
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropPrimaryKeyOnIdColumnOfPermissionTemplatesTableTest.class, "schema.sql");
+
+ private DropPrimaryKeySqlGenerator dropPrimaryKeySqlGenerator = new DropPrimaryKeySqlGenerator(db.database(), new SqlHelper(db.database()));
+
+ private MigrationStep underTest = new DropPrimaryKeyOnIdColumnOfPermissionTemplatesTable(db.database(), dropPrimaryKeySqlGenerator);
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertNoPrimaryKey(TABLE_NAME);
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+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 org.sonar.server.platform.db.migration.version.v83.projectmeasures.MakeProjectMeasuresUuidColumnNotNullable;
+
+import static java.sql.Types.VARCHAR;
+
+public class MakePermissionTemplateUuidColumnNotNullableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(MakePermissionTemplateUuidColumnNotNullableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new MakePermissionTemplateUuidColumnNotNullable(db.database());
+
+ @Test
+ public void uuid_column_is_not_null() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("permission_templates", "uuid", VARCHAR, null, false);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates;
+
+import java.sql.SQLException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DataChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PopulatePermissionTemplatesUuidTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(PopulatePermissionTemplatesUuidTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+ private DataChange underTest = new PopulatePermissionTemplatesUuid(db.database(), uuidFactory);
+
+ @Test
+ public void populate_uuids() throws SQLException {
+ insertPermissionTemplate(1L);
+ insertPermissionTemplate(2L);
+ insertPermissionTemplate(3L);
+ insertPermissionTemplate(4L, "very_very_very_very_very_very_very_very_very_very_very_long_kee");
+
+ underTest.execute();
+
+ verifyUuidsAreNotNull();
+ }
+
+ @Test
+ public void migration_is_reentrant() throws SQLException {
+ insertPermissionTemplate(1L);
+ insertPermissionTemplate(2L);
+ insertPermissionTemplate(3L);
+
+ underTest.execute();
+ // re-entrant
+ underTest.execute();
+
+ verifyUuidsAreNotNull();
+ }
+
+ private void verifyUuidsAreNotNull() {
+ assertThat(db.select("select uuid from permission_templates")
+ .stream()
+ .map(row -> row.get("UUID"))
+ .filter(Objects::isNull)
+ .collect(Collectors.toList())).isEmpty();
+ }
+
+ private void insertPermissionTemplate(Long id) {
+ insertPermissionTemplate(id, uuidFactory.create());
+ }
+
+ private void insertPermissionTemplate(Long id, String kee) {
+ db.executeInsert("permission_templates",
+ "id", id,
+ "organization_uuid", id + 100,
+ "name", uuidFactory.create(),
+ "kee", kee);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AddTemplateUuidColumnToPermTemplatesGroupsTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(AddTemplateUuidColumnToPermTemplatesGroupsTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+
+ private DdlChange underTest = new AddTemplateUuidColumnToPermTemplatesGroups(db.database());
+
+ @Before
+ public void setup() {
+ insertPermissionTemplateGroup("1", 4L);
+ insertPermissionTemplateGroup("2", 5L);
+ insertPermissionTemplateGroup("3", 6L);
+ }
+
+ @Test
+ public void add_uuid_column_to_permission_templates() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_templates_groups", "template_uuid", Types.VARCHAR, 40, true);
+
+ assertThat(db.countRowsOfTable("perm_templates_groups"))
+ .isEqualTo(3);
+ }
+
+ private void insertPermissionTemplateGroup(String uuid, Long templateId) {
+ db.executeInsert("perm_templates_groups",
+ "uuid", uuid,
+ "template_id", templateId,
+ "permission_reference", uuidFactory.create());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropIdColumnOfPermissionTemplatesTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropTemplateIdColumnOfPermTemplatesGroupsTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropTemplateIdColumnOfPermTemplatesGroupsTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropTemplateIdColumnOfPermTemplatesGroupsTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDoesNotExist("perm_templates_groups", "template_id");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.MakePermissionTemplateUuidColumnNotNullable;
+
+import static java.sql.Types.VARCHAR;
+
+public class MakePermTemplatesGroupsTemplateUuidColumnNotNullableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(MakePermTemplatesGroupsTemplateUuidColumnNotNullableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new MakePermTemplatesGroupsTemplateUuidColumnNotNullable(db.database());
+
+ @Test
+ public void uuid_column_is_not_null() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_templates_groups", "template_uuid", VARCHAR, null, false);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesgroups;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DataChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PopulatePermTemplatesGroupsTemplateUuidColumnTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(PopulatePermTemplatesGroupsTemplateUuidColumnTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+ private DataChange underTest = new PopulatePermTemplatesGroupsTemplateUuidColumn(db.database());
+
+ @Test
+ public void populate_uuids() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermissionTemplateGroup("4", permissionTemplateId_1);
+ insertPermissionTemplateGroup("5", permissionTemplateId_2);
+ insertPermissionTemplateGroup("6", permissionTemplateId_3);
+
+ underTest.execute();
+
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ @Test
+ public void migration_is_reentrant() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermissionTemplateGroup("4", permissionTemplateId_1);
+ insertPermissionTemplateGroup("5", permissionTemplateId_2);
+ insertPermissionTemplateGroup("6", permissionTemplateId_3);
+
+ underTest.execute();
+ // re-entrant
+ underTest.execute();
+
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermissionTemplateGroupTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ private void assertThatPermissionTemplateGroupTemplateUuidIsEqualTo(String permissionTemplateGroupUuid, String expectedUuid) {
+ assertThat(db.select("select template_uuid from perm_templates_groups where uuid = '" + permissionTemplateGroupUuid + "'")
+ .stream()
+ .map(row -> row.get("TEMPLATE_UUID"))
+ .findFirst())
+ .hasValue(expectedUuid);
+ }
+
+ private void insertPermissionTemplateGroup(String uuid, Long templateId) {
+ db.executeInsert("perm_templates_groups",
+ "uuid", uuid,
+ "template_id", templateId,
+ "permission_reference", uuidFactory.create());
+ }
+
+ private void insertPermissionTemplate(Long id, String uuid) {
+ db.executeInsert("permission_templates",
+ "id", id,
+ "uuid", uuid,
+ "organization_uuid", id + 100,
+ "name", uuidFactory.create(),
+ "kee", uuidFactory.create());
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.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.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+import org.sonar.server.platform.db.migration.version.v83.permissiontemplates.AddUuidColumnToPermissionTemplates;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AddTemplateUuidColumnToPermTemplatesUsersTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(AddTemplateUuidColumnToPermTemplatesUsersTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+
+ private DdlChange underTest = new AddTemplateUuidColumnToPermTemplatesUsers(db.database());
+
+ @Before
+ public void setup() {
+ insertPermTemplatesUsers("1");
+ insertPermTemplatesUsers("2");
+ insertPermTemplatesUsers("3");
+ }
+
+ @Test
+ public void add_uuid_column_to_permission_templates() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_templates_users", "template_uuid", Types.VARCHAR, 40, true);
+
+ assertThat(db.countRowsOfTable("perm_templates_users"))
+ .isEqualTo(3);
+ }
+
+ private void insertPermTemplatesUsers(String uuid) {
+ db.executeInsert("perm_templates_users",
+ "uuid", uuid,
+ "user_id", 100,
+ "template_id", 200,
+ "permission_reference", uuidFactory.create());
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropIdColumnOfPermissionTemplatesTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropTemplateIdColumnOfPermTemplatesUsersTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropTemplateIdColumnOfPermTemplatesUsersTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropTemplateIdColumnOfPermTemplatesUsersTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDoesNotExist("perm_templates_users", "template_id");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.MakePermissionTemplateUuidColumnNotNullable;
+
+import static java.sql.Types.VARCHAR;
+
+public class MakePermTemplatesUsersTemplateUuidColumnNotNullableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(MakePermTemplatesUsersTemplateUuidColumnNotNullableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new MakePermTemplatesUsersTemplateUuidColumnNotNullable(db.database());
+
+ @Test
+ public void uuid_column_is_not_null() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_templates_users", "template_uuid", VARCHAR, null, false);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtemplatesusers;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DataChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PopulatePermTemplatesUsersTemplateUuidColumnTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(PopulatePermTemplatesUsersTemplateUuidColumnTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+ private DataChange underTest = new PopulatePermTemplatesUsersTemplateUuidColumn(db.database());
+
+ @Test
+ public void populate_uuids() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermTemplatesUsers("4", permissionTemplateId_1);
+ insertPermTemplatesUsers("5", permissionTemplateId_2);
+ insertPermTemplatesUsers("6", permissionTemplateId_3);
+
+ underTest.execute();
+
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ @Test
+ public void migration_is_reentrant() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermTemplatesUsers("4", permissionTemplateId_1);
+ insertPermTemplatesUsers("5", permissionTemplateId_2);
+ insertPermTemplatesUsers("6", permissionTemplateId_3);
+
+ underTest.execute();
+ // re-entrant
+ underTest.execute();
+
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermTemplatesUsersTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ private void assertThatPermTemplatesUsersTemplateUuidIsEqualTo(String permTemplatesUsersUuid, String expectedUuid) {
+ assertThat(db.select("select template_uuid from perm_templates_users where uuid = '" + permTemplatesUsersUuid + "'")
+ .stream()
+ .map(row -> row.get("TEMPLATE_UUID"))
+ .findFirst())
+ .hasValue(expectedUuid);
+ }
+
+ private void insertPermTemplatesUsers(String uuid, Long templateId) {
+ db.executeInsert("perm_templates_users",
+ "uuid", uuid,
+ "user_id", 100,
+ "template_id", templateId,
+ "permission_reference", uuidFactory.create());
+ }
+
+ private void insertPermissionTemplate(Long id, String uuid) {
+ db.executeInsert("permission_templates",
+ "id", id,
+ "uuid", uuid,
+ "organization_uuid", id + 100,
+ "name", uuidFactory.create(),
+ "kee", uuidFactory.create());
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DdlChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AddTemplateUuidColumnToPermTplCharacteristicsTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(AddTemplateUuidColumnToPermTplCharacteristicsTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+
+ private DdlChange underTest = new AddTemplateUuidColumnToPermTplCharacteristics(db.database());
+
+ @Before
+ public void setup() {
+ insertPermTplCharacteristics("1");
+ insertPermTplCharacteristics("2");
+ insertPermTplCharacteristics("3");
+ }
+
+ @Test
+ public void add_uuid_column_to_perm_tpl_characteristics() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_tpl_characteristics", "template_uuid", Types.VARCHAR, 40, true);
+
+ assertThat(db.countRowsOfTable("perm_tpl_characteristics"))
+ .isEqualTo(3);
+ }
+
+ private void insertPermTplCharacteristics(String uuid) {
+ db.executeInsert("perm_tpl_characteristics",
+ "uuid", uuid,
+ "template_id", 100,
+ "permission_key", uuidFactory.create(),
+ "with_project_creator", false,
+ "created_at", System.currentTimeMillis(),
+ "updated_at", System.currentTimeMillis());
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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;
+
+public class AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropTemplateIdColumnOfPermTplCharacteristicsTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new AddUniqueIndexOnTemplateUuidAndPermissionKeyColumnsOfPermTplCharacteristicsTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertUniqueIndex("perm_tpl_characteristics", "uniq_perm_tpl_charac", "template_uuid", "permission_key");
+ }
+
+ @Test
+ public void migration_is_re_entrant() throws SQLException {
+ underTest.execute();
+
+ // re-entrant
+ underTest.execute();
+
+ db.assertUniqueIndex("perm_tpl_characteristics", "uniq_perm_tpl_charac", "template_uuid", "permission_key");
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.DropIdColumnOfPermissionTemplatesTable;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class DropTemplateIdColumnOfPermTplCharacteristicsTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropTemplateIdColumnOfPermTplCharacteristicsTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropTemplateIdColumnOfPermTplCharacteristicsTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDoesNotExist("perm_tpl_characteristics", "template_id");
+ }
+
+ @Test
+ public void migration_is_not_re_entrant() throws SQLException {
+ underTest.execute();
+
+ assertThatThrownBy(() -> underTest.execute()).isInstanceOf(IllegalStateException.class);
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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;
+
+public class DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DropTemplateIdColumnOfPermTplCharacteristicsTableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new DropUniqueIndexOnTemplateIdAndPermissionKeyColumnsOfPermTplCharacteristicsTable(db.database());
+
+ @Test
+ public void execute() throws SQLException {
+ underTest.execute();
+
+ db.assertIndexDoesNotExist("perm_tpl_characteristics", "uniq_perm_tpl_charac");
+ }
+
+ @Test
+ public void migration_is_re_entrant() throws SQLException {
+ underTest.execute();
+
+ // re-entrant
+ underTest.execute();
+
+ db.assertIndexDoesNotExist("perm_tpl_characteristics", "uniq_perm_tpl_charac");
+ }
+
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+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 org.sonar.server.platform.db.migration.version.v83.permissiontemplates.MakePermissionTemplateUuidColumnNotNullable;
+
+import static java.sql.Types.VARCHAR;
+
+public class MakePermTplCharacteristicsTemplateUuidColumnNotNullableTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(MakePermTplCharacteristicsTemplateUuidColumnNotNullableTest.class, "schema.sql");
+
+ private MigrationStep underTest = new MakePermTplCharacteristicsTemplateUuidColumnNotNullable(db.database());
+
+ @Test
+ public void uuid_column_is_not_null() throws SQLException {
+ underTest.execute();
+
+ db.assertColumnDefinition("perm_tpl_characteristics", "template_uuid", VARCHAR, null, false);
+ }
+}
--- /dev/null
+/*
+ * 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.permissiontemplates.fk.permtplcharacteristics;
+
+import java.sql.SQLException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.CoreDbTester;
+import org.sonar.server.platform.db.migration.step.DataChange;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PopulatePermTplCharacteristicsTemplateUuidColumnTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(PopulatePermTplCharacteristicsTemplateUuidColumnTest.class, "schema.sql");
+
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+ private DataChange underTest = new PopulatePermTplCharacteristicsTemplateUuidColumn(db.database());
+
+ @Test
+ public void populate_uuids() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermTplCharacteristics("4", permissionTemplateId_1);
+ insertPermTplCharacteristics("5", permissionTemplateId_2);
+ insertPermTplCharacteristics("6", permissionTemplateId_3);
+
+ underTest.execute();
+
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ @Test
+ public void migration_is_reentrant() throws SQLException {
+ long permissionTemplateId_1 = 1L;
+ String permissionTemplateUuid_1 = "uuid-1";
+ insertPermissionTemplate(permissionTemplateId_1, permissionTemplateUuid_1);
+
+ long permissionTemplateId_2 = 2L;
+ String permissionTemplateUuid_2 = "uuid-2";
+ insertPermissionTemplate(permissionTemplateId_2, permissionTemplateUuid_2);
+
+ long permissionTemplateId_3 = 3L;
+ String permissionTemplateUuid_3 = "uuid-3";
+ insertPermissionTemplate(permissionTemplateId_3, permissionTemplateUuid_3);
+
+ insertPermTplCharacteristics("4", permissionTemplateId_1);
+ insertPermTplCharacteristics("5", permissionTemplateId_2);
+ insertPermTplCharacteristics("6", permissionTemplateId_3);
+
+ underTest.execute();
+ // re-entrant
+ underTest.execute();
+
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("4", permissionTemplateUuid_1);
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("5", permissionTemplateUuid_2);
+ assertThatPermTplCharacteristicsTemplateUuidIsEqualTo("6", permissionTemplateUuid_3);
+ }
+
+ private void assertThatPermTplCharacteristicsTemplateUuidIsEqualTo(String permTplCharacteristicsUuid, String expectedUuid) {
+ assertThat(db.select("select template_uuid from perm_tpl_characteristics where uuid = '" + permTplCharacteristicsUuid + "'")
+ .stream()
+ .map(row -> row.get("TEMPLATE_UUID"))
+ .findFirst())
+ .hasValue(expectedUuid);
+ }
+
+ private void insertPermTplCharacteristics(String uuid, long templateId) {
+ db.executeInsert("perm_tpl_characteristics",
+ "uuid", uuid,
+ "template_id", templateId,
+ "permission_key", uuidFactory.create(),
+ "with_project_creator", false,
+ "created_at", System.currentTimeMillis(),
+ "updated_at", System.currentTimeMillis());
+ }
+
+ private void insertPermissionTemplate(Long id, String uuid) {
+ db.executeInsert("permission_templates",
+ "id", id,
+ "uuid", uuid,
+ "organization_uuid", id + 100,
+ "name", uuidFactory.create(),
+ "kee", uuidFactory.create());
+ }
+}
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40),
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40),
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_GROUPS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "GROUP_ID" INTEGER,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_GROUPS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "GROUP_ID" INTEGER,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_GROUPS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "GROUP_ID" INTEGER,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_GROUPS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "GROUP_ID" INTEGER,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_GROUPS" ADD CONSTRAINT "PK_PERM_TEMPLATES_GROUPS" PRIMARY KEY("UUID");
+
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "USER_ID" INTEGER NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "USER_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "USER_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
+
+CREATE TABLE "PERM_TEMPLATES_USERS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "USER_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_REFERENCE" VARCHAR(64) NOT NULL,
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP
+);
+ALTER TABLE "PERM_TEMPLATES_USERS" ADD CONSTRAINT "PK_PERM_TEMPLATES_USERS" PRIMARY KEY("UUID");
--- /dev/null
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
--- /dev/null
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL,
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
--- /dev/null
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_UUID", "PERMISSION_KEY");
--- /dev/null
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_UUID" INTEGER NOT NULL,
+ "TEMPLATE_ID" VARCHAR(40) NOT NULL,
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
--- /dev/null
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
--- /dev/null
+CREATE TABLE "PERMISSION_TEMPLATES"(
+ "ID" INTEGER NOT NULL AUTO_INCREMENT (1,1),
+ "UUID" VARCHAR(40) NOT NULL,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "NAME" VARCHAR(100) NOT NULL,
+ "KEE" VARCHAR(100) NOT NULL,
+ "DESCRIPTION" VARCHAR(4000),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "KEY_PATTERN" VARCHAR(500)
+);
+ALTER TABLE "PERMISSION_TEMPLATES" ADD CONSTRAINT "PK_PERMISSION_TEMPLATES" PRIMARY KEY("ID");
+
+CREATE TABLE "PERM_TPL_CHARACTERISTICS"(
+ "UUID" VARCHAR(40) NOT NULL,
+ "TEMPLATE_ID" INTEGER NOT NULL,
+ "TEMPLATE_UUID" VARCHAR(40),
+ "PERMISSION_KEY" VARCHAR(64) NOT NULL,
+ "WITH_PROJECT_CREATOR" BOOLEAN DEFAULT FALSE NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "PERM_TPL_CHARACTERISTICS" ADD CONSTRAINT "PK_PERM_TPL_CHARACTERISTICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PERM_TPL_CHARAC" ON "PERM_TPL_CHARACTERISTICS"("TEMPLATE_ID", "PERMISSION_KEY");
List<PermissionTemplateGroupDto> sonarUsersPermissionTemplates = dbClient.permissionTemplateDao().selectAllGroupPermissionTemplatesByGroupId(dbSession,
sonarUsersGroup.getId());
sonarUsersPermissionTemplates.forEach(permissionTemplateGroup -> dbClient.permissionTemplateDao().insertGroupPermission(dbSession,
- permissionTemplateGroup.getTemplateId(), membersGroup.getId(), permissionTemplateGroup.getPermission()));
+ permissionTemplateGroup.getTemplateUuid(), membersGroup.getId(), permissionTemplateGroup.getPermission()));
}
private List<Integer> disableTemplateRulesAndCustomRules(DbSession dbSession) {
}
private void insertGroupPermission(DbSession dbSession, PermissionTemplateDto template, String permission, @Nullable GroupDto group) {
- dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getId(), group == null ? null : group.getId(), permission);
+ dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getUuid(), group == null ? null : group.getId(), permission);
}
private void insertQualityProfiles(DbSession dbSession, DbSession batchDbSession, OrganizationDto organization) {
PermissionTemplateDto template = db.permissionTemplates().insertTemplate(organization);
PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate(anotherOrganization);
String permission = "browse";
- db.permissionTemplates().addUserToTemplate(template.getId(), user.getId(), permission);
- db.permissionTemplates().addUserToTemplate(template.getId(), anotherUser.getId(), permission);
- db.permissionTemplates().addUserToTemplate(anotherTemplate.getId(), user.getId(), 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);
underTest.removeMember(db.getSession(), organization, user);
- assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), template.getId())).extracting(PermissionTemplateUserDto::getUserId)
+ assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), template.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
.containsOnly(anotherUser.getId());
- assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), anotherTemplate.getId())).extracting(PermissionTemplateUserDto::getUserId)
+ assertThat(dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(db.getSession(), anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
.containsOnly(user.getId());
}
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.impl.utils.TestSystem2;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.ResourceTypes;
import org.sonar.api.utils.System2;
-import org.sonar.api.impl.utils.TestSystem2;
import org.sonar.api.web.UserRole;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.util.SequenceUuidFactory;
DefaultTemplates defaultTemplates = dbClient.organizationDao().getDefaultTemplates(dbSession, organization.getUuid()).get();
assertThat(defaultTemplates.getProjectUuid()).isEqualTo(defaultTemplate.getUuid());
assertThat(defaultTemplates.getApplicationsUuid()).isNull();
- assertThat(dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateId(dbSession, defaultTemplate.getId()))
+ assertThat(dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateUuid(dbSession, defaultTemplate.getUuid()))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(ownersGroup.getId(), UserRole.ADMIN),
*/
package org.sonar.server.startup;
+import java.util.Date;
+import java.util.Optional;
import org.picocontainer.Startable;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.utils.log.Logger;
import org.sonar.db.user.GroupDto;
import org.sonar.server.organization.DefaultOrganizationProvider;
-import java.util.Date;
-import java.util.Optional;
-
import static java.lang.String.format;
public class RegisterPermissionTemplates implements Startable {
}
private void insertGroupPermission(DbSession dbSession, PermissionTemplateDto template, String permission, GroupDto group) {
- dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getId(), group.getId(), permission);
+ dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getUuid(), group.getId(), permission);
}
}
}
private List<PermissionTemplateGroupDto> selectGroupPermissions(PermissionTemplateDto template) {
- return db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateId(db.getSession(), template.getId());
+ return db.getDbClient().permissionTemplateDao().selectGroupPermissionsByTemplateUuid(db.getSession(), template.getUuid());
}
private void expectGroupPermission(List<PermissionTemplateGroupDto> groupPermissions, String expectedPermission,
import org.sonar.db.permission.template.PermissionTemplateUserDto;
import org.sonar.server.es.ProjectIndexer;
import org.sonar.server.es.ProjectIndexers;
+import org.sonar.server.permission.DefaultTemplatesResolver.ResolvedDefaultTemplates;
import org.sonar.server.user.UserSession;
import static com.google.common.base.Preconditions.checkArgument;
return false;
}
- List<String> potentialPermissions = dbClient.permissionTemplateDao().selectPotentialPermissionsByUserIdAndTemplateId(dbSession, userId, template.getId());
+ List<String> potentialPermissions = dbClient.permissionTemplateDao().selectPotentialPermissionsByUserIdAndTemplateUuid(dbSession, userId, template.getUuid());
return potentialPermissions.contains(SCAN.getKey());
}
}
private boolean hasProjectCreatorPermission(DbSession dbSession, @Nullable PermissionTemplateDto template) {
- return template != null && dbClient.permissionTemplateCharacteristicDao().selectByTemplateIds(dbSession, singletonList(template.getId())).stream()
+ return template != null && dbClient.permissionTemplateCharacteristicDao().selectByTemplateUuids(dbSession, singletonList(template.getUuid())).stream()
.anyMatch(PermissionTemplateCharacteristicDto::getWithProjectCreator);
}
dbClient.groupPermissionDao().deleteByRootComponentUuid(dbSession, project.uuid());
dbClient.userPermissionDao().deleteProjectPermissions(dbSession, project.uuid());
- List<PermissionTemplateUserDto> usersPermissions = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getId());
+ List<PermissionTemplateUserDto> usersPermissions = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid());
String organizationUuid = template.getOrganizationUuid();
usersPermissions
.stream()
dbClient.userPermissionDao().insert(dbSession, dto);
});
- List<PermissionTemplateGroupDto> groupsPermissions = dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateId(dbSession, template.getId());
+ List<PermissionTemplateGroupDto> groupsPermissions = dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateUuid(dbSession, template.getUuid());
groupsPermissions
.stream()
.filter(gp -> groupNameValidForProject(project, gp.getGroupName()))
dbClient.groupPermissionDao().insert(dbSession, dto);
});
- List<PermissionTemplateCharacteristicDto> characteristics = dbClient.permissionTemplateCharacteristicDao().selectByTemplateIds(dbSession, singletonList(template.getId()));
+ List<PermissionTemplateCharacteristicDto> characteristics = dbClient.permissionTemplateCharacteristicDao().selectByTemplateUuids(dbSession, singletonList(template.getUuid()));
if (projectCreatorUserId != null) {
Set<String> permissionsForCurrentUserAlreadyInDb = usersPermissions.stream()
.filter(userPermission -> projectCreatorUserId.equals(userPermission.getUserId()))
format("No Default templates defined for organization with uuid '%s'", organizationUuid)));
String qualifier = component.qualifier();
- DefaultTemplatesResolverImpl.ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
+ ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
switch (qualifier) {
case Qualifiers.PROJECT:
return dbClient.permissionTemplateDao().selectByUuid(dbSession, resolvedDefaultTemplates.getProject());
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.server.permission.GroupIdOrAnyone;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
-import org.sonar.server.permission.GroupIdOrAnyone;
import static java.lang.String.format;
import static org.sonar.core.permission.GlobalPermissions.SYSTEM_ADMIN;
+import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
import static org.sonar.server.permission.ws.WsParameters.createGroupIdParameter;
import static org.sonar.server.permission.ws.WsParameters.createGroupNameParameter;
import static org.sonar.server.permission.ws.WsParameters.createTemplateParameters;
import static org.sonar.server.permission.ws.template.WsTemplateRef.fromRequest;
-import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_PERMISSION;
public class AddGroupToTemplateAction implements PermissionsWsAction {
PermissionTemplateDto template = support.findTemplate(dbSession, fromRequest(request));
checkGlobalAdmin(userSession, template.getOrganizationUuid());
- if (!groupAlreadyAdded(dbSession, template.getId(), permission, groupId)) {
- dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getId(), groupId.getId(), permission);
+ if (!groupAlreadyAdded(dbSession, template.getUuid(), permission, groupId)) {
+ dbClient.permissionTemplateDao().insertGroupPermission(dbSession, template.getUuid(), groupId.getId(), permission);
dbSession.commit();
}
}
response.noContent();
}
- private boolean groupAlreadyAdded(DbSession dbSession, long templateId, String permission, GroupIdOrAnyone group) {
- return dbClient.permissionTemplateDao().hasGroupsWithPermission(dbSession, templateId, permission, group.getId());
+ private boolean groupAlreadyAdded(DbSession dbSession, String templateUuid, String permission, GroupIdOrAnyone group) {
+ return dbClient.permissionTemplateDao().hasGroupsWithPermission(dbSession, templateUuid, permission, group.getId());
}
}
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
-import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
checkGlobalAdmin(userSession, template.getOrganizationUuid());
Optional<PermissionTemplateCharacteristicDto> templatePermission = dbClient.permissionTemplateCharacteristicDao()
- .selectByPermissionAndTemplateId(dbSession, request.getPermission(), template.getId());
+ .selectByPermissionAndTemplateId(dbSession, request.getPermission(), template.getUuid());
if (templatePermission.isPresent()) {
updateTemplatePermission(dbSession, templatePermission.get());
} else {
dbClient.permissionTemplateCharacteristicDao().insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid(Uuids.create())
.setPermission(request.getPermission())
- .setTemplateId(template.getId())
+ .setTemplateUuid(template.getUuid())
.setWithProjectCreator(true)
.setCreatedAt(now)
.setUpdatedAt(now));
UserId user = wsSupport.findUser(dbSession, userLogin);
wsSupport.checkMembership(dbSession, organizationDto, user);
- if (!isUserAlreadyAdded(dbSession, organizationDto, template.getId(), userLogin, permission)) {
- dbClient.permissionTemplateDao().insertUserPermission(dbSession, template.getId(), user.getId(), permission);
+ if (!isUserAlreadyAdded(dbSession, organizationDto, template.getUuid(), userLogin, permission)) {
+ dbClient.permissionTemplateDao().insertUserPermission(dbSession, template.getUuid(), user.getId(), permission);
dbSession.commit();
}
}
}
- private boolean isUserAlreadyAdded(DbSession dbSession, OrganizationDto organizationDto, long templateId, String userLogin, String permission) {
+ private boolean isUserAlreadyAdded(DbSession dbSession, OrganizationDto organizationDto, String templateUuid, String userLogin, String permission) {
PermissionQuery permissionQuery = PermissionQuery.builder().setOrganizationUuid(organizationDto.getUuid()).setPermission(permission).build();
- List<String> usersWithPermission = dbClient.permissionTemplateDao().selectUserLoginsByQueryAndTemplate(dbSession, permissionQuery, templateId);
+ List<String> usersWithPermission = dbClient.permissionTemplateDao().selectUserLoginsByQueryAndTemplate(dbSession, permissionQuery, templateUuid);
return usersWithPermission.stream().anyMatch(s -> s.equals(userLogin));
}
import org.sonar.db.organization.DefaultTemplates;
import org.sonar.db.permission.template.PermissionTemplateDto;
import org.sonar.server.permission.DefaultTemplatesResolver;
+import org.sonar.server.permission.DefaultTemplatesResolver.ResolvedDefaultTemplates;
import org.sonar.server.permission.DefaultTemplatesResolverImpl;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
+import static org.sonar.server.exceptions.BadRequestException.checkRequest;
+import static org.sonar.server.exceptions.NotFoundException.checkFoundWithOptional;
import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
import static org.sonar.server.permission.ws.template.WsTemplateRef.newTemplateRef;
-import static org.sonar.server.exceptions.NotFoundException.checkFoundWithOptional;
-import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_ORGANIZATION;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_TEMPLATE_ID;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_TEMPLATE_NAME;
DefaultTemplates defaultTemplates = retrieveDefaultTemplates(dbSession, template);
checkTemplateUuidIsNotDefault(template, defaultTemplates);
- dbClient.permissionTemplateDao().deleteById(dbSession, template.getId());
+ dbClient.permissionTemplateDao().deleteByUuid(dbSession, template.getUuid());
updateViewDefaultTemplateWhenGovernanceIsNotInstalled(dbSession, template, defaultTemplates);
dbSession.commit();
}
private void checkTemplateUuidIsNotDefault(PermissionTemplateDto template, DefaultTemplates defaultTemplates) {
- DefaultTemplatesResolverImpl.ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
+ ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
checkRequest(!resolvedDefaultTemplates.getProject().equals(template.getUuid()),
"It is not possible to delete the default permission template for projects");
resolvedDefaultTemplates.getApplication()
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.server.permission.GroupIdOrAnyone;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
-import org.sonar.server.permission.GroupIdOrAnyone;
import static com.google.common.base.Preconditions.checkArgument;
import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
GroupIdOrAnyone groupId = wsSupport.findGroup(dbSession, request);
checkArgument(groupId.getOrganizationUuid().equals(template.getOrganizationUuid()), "Group and template are on different organizations");
- dbClient.permissionTemplateDao().deleteGroupPermission(dbSession, template.getId(), groupId.getId(), permission);
+ dbClient.permissionTemplateDao().deleteGroupPermission(dbSession, template.getUuid(), groupId.getId(), permission);
dbSession.commit();
}
response.noContent();
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDao;
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
-import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
checkGlobalAdmin(userSession, template.getOrganizationUuid());
PermissionTemplateCharacteristicDao dao = dbClient.permissionTemplateCharacteristicDao();
- dao.selectByPermissionAndTemplateId(dbSession, request.getPermission(), template.getId())
+ dao.selectByPermissionAndTemplateId(dbSession, request.getPermission(), template.getUuid())
.ifPresent(permissionTemplateCharacteristicDto -> updateTemplateCharacteristic(dbSession, permissionTemplateCharacteristicDto));
}
}
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.UserId;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
-import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
UserId user = wsSupport.findUser(dbSession, userLogin);
- dbClient.permissionTemplateDao().deleteUserPermission(dbSession, template.getId(), user.getId(), permission);
+ dbClient.permissionTemplateDao().deleteUserPermission(dbSession, template.getUuid(), user.getId(), permission);
dbSession.commit();
}
}
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
import org.sonar.db.permission.template.PermissionTemplateDto;
import org.sonar.server.permission.DefaultTemplatesResolver;
+import org.sonar.server.permission.DefaultTemplatesResolver.ResolvedDefaultTemplates;
import org.sonar.server.permission.DefaultTemplatesResolverImpl;
import org.sonar.server.permission.PermissionService;
import org.sonar.server.permission.ws.PermissionWsSupport;
import static java.util.Optional.ofNullable;
import static org.sonar.api.utils.DateUtils.formatDateTime;
+import static org.sonar.server.exceptions.NotFoundException.checkFoundWithOptional;
import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
import static org.sonar.server.permission.ws.template.SearchTemplatesData.builder;
-import static org.sonar.server.exceptions.NotFoundException.checkFoundWithOptional;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_ORGANIZATION;
private static void buildDefaultTemplatesResponse(SearchTemplatesWsResponse.Builder response, SearchTemplatesData data) {
TemplateIdQualifier.Builder templateUuidQualifierBuilder = TemplateIdQualifier.newBuilder();
- DefaultTemplatesResolverImpl.ResolvedDefaultTemplates resolvedDefaultTemplates = data.defaultTemplates();
+ ResolvedDefaultTemplates resolvedDefaultTemplates = data.defaultTemplates();
response.addDefaultTemplates(templateUuidQualifierBuilder
.setQualifier(Qualifiers.PROJECT)
.setTemplateId(resolvedDefaultTemplates.getProject()));
permissionResponse
.clear()
.setKey(permission)
- .setUsersCount(data.userCount(templateDto.getId(), permission))
- .setGroupsCount(data.groupCount(templateDto.getId(), permission))
- .setWithProjectCreator(data.withProjectCreator(templateDto.getId(), permission)));
+ .setUsersCount(data.userCount(templateDto.getUuid(), permission))
+ .setGroupsCount(data.groupCount(templateDto.getUuid(), permission))
+ .setWithProjectCreator(data.withProjectCreator(templateDto.getUuid(), permission)));
}
response.addPermissionTemplates(templateBuilder);
}
private SearchTemplatesData load(DbSession dbSession, SearchTemplatesRequest request) {
SearchTemplatesData.Builder data = builder();
List<PermissionTemplateDto> templates = searchTemplates(dbSession, request);
- List<Long> templateIds = Lists.transform(templates, PermissionTemplateDto::getId);
+ List<String> templateUuids = Lists.transform(templates, PermissionTemplateDto::getUuid);
DefaultTemplates defaultTemplates = checkFoundWithOptional(
- dbClient.organizationDao().getDefaultTemplates(dbSession, request.getOrganizationUuid()),
- "No Default templates for organization with uuid '%s'", request.getOrganizationUuid());
- DefaultTemplatesResolver.ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
+ dbClient.organizationDao().getDefaultTemplates(dbSession, request.getOrganizationUuid()),
+ "No Default templates for organization with uuid '%s'", request.getOrganizationUuid());
+ ResolvedDefaultTemplates resolvedDefaultTemplates = defaultTemplatesResolver.resolve(defaultTemplates);
data.templates(templates)
- .defaultTemplates(resolvedDefaultTemplates)
- .userCountByTemplateIdAndPermission(userCountByTemplateIdAndPermission(dbSession, templateIds))
- .groupCountByTemplateIdAndPermission(groupCountByTemplateIdAndPermission(dbSession, templateIds))
- .withProjectCreatorByTemplateIdAndPermission(withProjectCreatorsByTemplateIdAndPermission(dbSession, templateIds));
+ .defaultTemplates(resolvedDefaultTemplates)
+ .userCountByTemplateUuidAndPermission(userCountByTemplateUuidAndPermission(dbSession, templateUuids))
+ .groupCountByTemplateUuidAndPermission(groupCountByTemplateUuidAndPermission(dbSession, templateUuids))
+ .withProjectCreatorByTemplateUuidAndPermission(withProjectCreatorsByTemplateUuidAndPermission(dbSession, templateUuids));
return data.build();
}
return dbClient.permissionTemplateDao().selectAll(dbSession, request.getOrganizationUuid(), request.getQuery());
}
- private Table<Long, String, Integer> userCountByTemplateIdAndPermission(DbSession dbSession, List<Long> templateIds) {
- final Table<Long, String, Integer> userCountByTemplateIdAndPermission = TreeBasedTable.create();
+ private Table<String, String, Integer> userCountByTemplateUuidAndPermission(DbSession dbSession, List<String> templateUuids) {
+ final Table<String, String, Integer> userCountByTemplateUuidAndPermission = TreeBasedTable.create();
- dbClient.permissionTemplateDao().usersCountByTemplateIdAndPermission(dbSession, templateIds, context -> {
+ dbClient.permissionTemplateDao().usersCountByTemplateUuidAndPermission(dbSession, templateUuids, context -> {
CountByTemplateAndPermissionDto row = context.getResultObject();
- userCountByTemplateIdAndPermission.put(row.getTemplateId(), row.getPermission(), row.getCount());
+ userCountByTemplateUuidAndPermission.put(row.getTemplateUuid(), row.getPermission(), row.getCount());
});
- return userCountByTemplateIdAndPermission;
+ return userCountByTemplateUuidAndPermission;
}
- private Table<Long, String, Integer> groupCountByTemplateIdAndPermission(DbSession dbSession, List<Long> templateIds) {
- final Table<Long, String, Integer> userCountByTemplateIdAndPermission = TreeBasedTable.create();
+ private Table<String, String, Integer> groupCountByTemplateUuidAndPermission(DbSession dbSession, List<String> templateUuids) {
+ final Table<String, String, Integer> userCountByTemplateUuidAndPermission = TreeBasedTable.create();
- dbClient.permissionTemplateDao().groupsCountByTemplateIdAndPermission(dbSession, templateIds, context -> {
+ dbClient.permissionTemplateDao().groupsCountByTemplateUuidAndPermission(dbSession, templateUuids, context -> {
CountByTemplateAndPermissionDto row = context.getResultObject();
- userCountByTemplateIdAndPermission.put(row.getTemplateId(), row.getPermission(), row.getCount());
+ userCountByTemplateUuidAndPermission.put(row.getTemplateUuid(), row.getPermission(), row.getCount());
});
- return userCountByTemplateIdAndPermission;
+ return userCountByTemplateUuidAndPermission;
}
- private Table<Long, String, Boolean> withProjectCreatorsByTemplateIdAndPermission(DbSession dbSession, List<Long> templateIds) {
- final Table<Long, String, Boolean> templatePermissionsByTemplateIdAndPermission = TreeBasedTable.create();
+ private Table<String, String, Boolean> withProjectCreatorsByTemplateUuidAndPermission(DbSession dbSession, List<String> templateUuids) {
+ final Table<String, String, Boolean> templatePermissionsByTemplateUuidAndPermission = TreeBasedTable.create();
- List<PermissionTemplateCharacteristicDto> templatePermissions = dbClient.permissionTemplateCharacteristicDao().selectByTemplateIds(dbSession, templateIds);
+ List<PermissionTemplateCharacteristicDto> templatePermissions = dbClient.permissionTemplateCharacteristicDao().selectByTemplateUuids(dbSession, templateUuids);
templatePermissions.stream()
- .forEach(templatePermission -> templatePermissionsByTemplateIdAndPermission.put(templatePermission.getTemplateId(), templatePermission.getPermission(),
- templatePermission.getWithProjectCreator()));
+ .forEach(templatePermission -> templatePermissionsByTemplateUuidAndPermission.put(templatePermission.getTemplateUuid(), templatePermission.getPermission(),
+ templatePermission.getWithProjectCreator()));
- return templatePermissionsByTemplateIdAndPermission;
+ return templatePermissionsByTemplateUuidAndPermission;
}
private static class SearchTemplatesRequest {
class SearchTemplatesData {
private final List<PermissionTemplateDto> templates;
private final ResolvedDefaultTemplates defaultTemplates;
- private final Table<Long, String, Integer> userCountByTemplateIdAndPermission;
- private final Table<Long, String, Integer> groupCountByTemplateIdAndPermission;
- private final Table<Long, String, Boolean> withProjectCreatorByTemplateIdAndPermission;
+ private final Table<String, String, Integer> userCountByTemplateUuidAndPermission;
+ private final Table<String, String, Integer> groupCountByTemplateUuidAndPermission;
+ private final Table<String, String, Boolean> withProjectCreatorByTemplateUuidAndPermission;
private SearchTemplatesData(Builder builder) {
this.templates = copyOf(builder.templates);
this.defaultTemplates = builder.defaultTemplates;
- this.userCountByTemplateIdAndPermission = copyOf(builder.userCountByTemplateIdAndPermission);
- this.groupCountByTemplateIdAndPermission = copyOf(builder.groupCountByTemplateIdAndPermission);
- this.withProjectCreatorByTemplateIdAndPermission = copyOf(builder.withProjectCreatorByTemplateIdAndPermission);
+ this.userCountByTemplateUuidAndPermission = copyOf(builder.userCountByTemplateUuidAndPermission);
+ this.groupCountByTemplateUuidAndPermission = copyOf(builder.groupCountByTemplateUuidAndPermission);
+ this.withProjectCreatorByTemplateUuidAndPermission = copyOf(builder.withProjectCreatorByTemplateUuidAndPermission);
}
public static Builder builder() {
return defaultTemplates;
}
- public int userCount(long templateId, String permission) {
- return firstNonNull(userCountByTemplateIdAndPermission.get(templateId, permission), 0);
+ public int userCount(String templateUuid, String permission) {
+ return firstNonNull(userCountByTemplateUuidAndPermission.get(templateUuid, permission), 0);
}
- public int groupCount(long templateId, String permission) {
- return firstNonNull(groupCountByTemplateIdAndPermission.get(templateId, permission), 0);
+ public int groupCount(String templateUuid, String permission) {
+ return firstNonNull(groupCountByTemplateUuidAndPermission.get(templateUuid, permission), 0);
}
- public boolean withProjectCreator(long templateId, String permission) {
- return firstNonNull(withProjectCreatorByTemplateIdAndPermission.get(templateId, permission), false);
+ public boolean withProjectCreator(String templateUuid, String permission) {
+ return firstNonNull(withProjectCreatorByTemplateUuidAndPermission.get(templateUuid, permission), false);
}
public static class Builder {
private List<PermissionTemplateDto> templates;
private ResolvedDefaultTemplates defaultTemplates;
- private Table<Long, String, Integer> userCountByTemplateIdAndPermission;
- private Table<Long, String, Integer> groupCountByTemplateIdAndPermission;
- private Table<Long, String, Boolean> withProjectCreatorByTemplateIdAndPermission;
+ private Table<String, String, Integer> userCountByTemplateUuidAndPermission;
+ private Table<String, String, Integer> groupCountByTemplateUuidAndPermission;
+ private Table<String, String, Boolean> withProjectCreatorByTemplateUuidAndPermission;
private Builder() {
// prevents instantiation outside main class
public SearchTemplatesData build() {
checkState(templates != null);
checkState(defaultTemplates != null);
- checkState(userCountByTemplateIdAndPermission != null);
- checkState(groupCountByTemplateIdAndPermission != null);
- checkState(withProjectCreatorByTemplateIdAndPermission != null);
+ checkState(userCountByTemplateUuidAndPermission != null);
+ checkState(groupCountByTemplateUuidAndPermission != null);
+ checkState(withProjectCreatorByTemplateUuidAndPermission != null);
return new SearchTemplatesData(this);
}
return this;
}
- public Builder userCountByTemplateIdAndPermission(Table<Long, String, Integer> userCountByTemplateIdAndPermission) {
- this.userCountByTemplateIdAndPermission = userCountByTemplateIdAndPermission;
+ public Builder userCountByTemplateUuidAndPermission(Table<String, String, Integer> userCountByTemplateUuidAndPermission) {
+ this.userCountByTemplateUuidAndPermission = userCountByTemplateUuidAndPermission;
return this;
}
- public Builder groupCountByTemplateIdAndPermission(Table<Long, String, Integer> groupCountByTemplateIdAndPermission) {
- this.groupCountByTemplateIdAndPermission = groupCountByTemplateIdAndPermission;
+ public Builder groupCountByTemplateUuidAndPermission(Table<String, String, Integer> groupCountByTemplateUuidAndPermission) {
+ this.groupCountByTemplateUuidAndPermission = groupCountByTemplateUuidAndPermission;
return this;
}
- public Builder withProjectCreatorByTemplateIdAndPermission(Table<Long, String, Boolean> withProjectCreatorByTemplateIdAndPermission) {
- this.withProjectCreatorByTemplateIdAndPermission = withProjectCreatorByTemplateIdAndPermission;
+ public Builder withProjectCreatorByTemplateUuidAndPermission(Table<String, String, Boolean> withProjectCreatorByTemplateUuidAndPermission) {
+ this.withProjectCreatorByTemplateUuidAndPermission = withProjectCreatorByTemplateUuidAndPermission;
return this;
}
}
import org.sonar.db.permission.template.PermissionTemplateDto;
import org.sonar.db.permission.template.PermissionTemplateGroupDto;
import org.sonar.db.user.GroupDto;
+import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
-import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
import org.sonarqube.ws.Permissions;
checkGlobalAdmin(userSession, template.getOrganizationUuid());
PermissionQuery query = buildPermissionQuery(wsRequest, template);
- int total = dbClient.permissionTemplateDao().countGroupNamesByQueryAndTemplate(dbSession, query, template.getOrganizationUuid(), template.getId());
+ int total = dbClient.permissionTemplateDao().countGroupNamesByQueryAndTemplate(dbSession, query, template.getOrganizationUuid(), template.getUuid());
Paging paging = Paging.forPageIndex(wsRequest.mandatoryParamAsInt(PAGE)).withPageSize(wsRequest.mandatoryParamAsInt(PAGE_SIZE)).andTotal(total);
List<GroupDto> groups = findGroups(dbSession, query, template);
List<PermissionTemplateGroupDto> groupPermissions = findGroupPermissions(dbSession, groups, template);
}
private List<GroupDto> findGroups(DbSession dbSession, PermissionQuery dbQuery, PermissionTemplateDto template) {
- List<String> orderedNames = dbClient.permissionTemplateDao().selectGroupNamesByQueryAndTemplate(dbSession, dbQuery, template.getId());
+ List<String> orderedNames = dbClient.permissionTemplateDao().selectGroupNamesByQueryAndTemplate(dbSession, dbQuery, template.getUuid());
List<GroupDto> groups = dbClient.groupDao().selectByNames(dbSession, template.getOrganizationUuid(), orderedNames);
if (orderedNames.contains(DefaultGroups.ANYONE)) {
groups.add(0, new GroupDto().setId(0).setName(DefaultGroups.ANYONE));
private List<PermissionTemplateGroupDto> findGroupPermissions(DbSession dbSession, List<GroupDto> groups, PermissionTemplateDto template) {
List<String> names = groups.stream().map(GroupDto::getName).collect(Collectors.toList());
- return dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateIdAndGroupNames(dbSession, template.getId(), names);
+ return dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateIdAndGroupNames(dbSession, template.getUuid(), names);
}
}
checkGlobalAdmin(userSession, template.getOrganizationUuid());
PermissionQuery query = buildQuery(wsRequest, template);
- int total = dbClient.permissionTemplateDao().countUserLoginsByQueryAndTemplate(dbSession, query, template.getId());
+ int total = dbClient.permissionTemplateDao().countUserLoginsByQueryAndTemplate(dbSession, query, template.getUuid());
Paging paging = Paging.forPageIndex(wsRequest.mandatoryParamAsInt(PAGE)).withPageSize(wsRequest.mandatoryParamAsInt(PAGE_SIZE)).andTotal(total);
List<UserDto> users = findUsers(dbSession, query, template);
- List<PermissionTemplateUserDto> permissionTemplateUsers = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateIdAndUserLogins(dbSession, template.getId(),
+ List<PermissionTemplateUserDto> permissionTemplateUsers = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateIdAndUserLogins(dbSession, template.getUuid(),
users.stream().map(UserDto::getLogin).collect(Collectors.toList()));
Permissions.UsersWsResponse templateUsersResponse = buildResponse(users, permissionTemplateUsers, paging);
writeProtobuf(templateUsersResponse, wsRequest, wsResponse);
}
private List<UserDto> findUsers(DbSession dbSession, PermissionQuery query, PermissionTemplateDto template) {
- List<String> orderedLogins = dbClient.permissionTemplateDao().selectUserLoginsByQueryAndTemplate(dbSession, query, template.getId());
+ List<String> orderedLogins = dbClient.permissionTemplateDao().selectUserLoginsByQueryAndTemplate(dbSession, query, template.getUuid());
return Ordering.explicit(orderedLogins).onResultOf(UserDto::getLogin).immutableSortedCopy(dbClient.userDao().selectByLogins(dbSession, orderedLogins));
}
package org.sonar.server.permission.ws.template;
import java.util.Date;
+import java.util.Objects;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.server.ws.Request;
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateDto;
import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.PermissionWsSupport;
import org.sonar.server.permission.ws.PermissionsWsAction;
-import org.sonar.server.permission.RequestValidator;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.user.UserSession;
import org.sonarqube.ws.Permissions.PermissionTemplate;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;
import static org.apache.commons.lang.StringUtils.isBlank;
+import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
import static org.sonar.server.permission.RequestValidator.MSG_TEMPLATE_WITH_SAME_NAME;
import static org.sonar.server.permission.ws.template.PermissionTemplateDtoToPermissionTemplateResponse.toPermissionTemplateResponse;
-import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_DESCRIPTION;
import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_ID;
}
private void validateTemplate(DbSession dbSession, PermissionTemplateDto templateToUpdate) {
- validateTemplateNameForUpdate(dbSession, templateToUpdate.getOrganizationUuid(), templateToUpdate.getName(), templateToUpdate.getId());
+ validateTemplateNameForUpdate(dbSession, templateToUpdate.getOrganizationUuid(), templateToUpdate.getName(), templateToUpdate.getUuid());
RequestValidator.validateProjectPattern(templateToUpdate.getKeyPattern());
}
return dbClient.permissionTemplateDao().update(dbSession, templateToUpdate);
}
- private void validateTemplateNameForUpdate(DbSession dbSession, String organizationUuid, String name, long id) {
+ private void validateTemplateNameForUpdate(DbSession dbSession, String organizationUuid, String name, String uuid) {
BadRequestException.checkRequest(!isBlank(name), "The template name must not be blank");
PermissionTemplateDto permissionTemplateWithSameName = dbClient.permissionTemplateDao().selectByName(dbSession, organizationUuid, name);
- checkRequest(permissionTemplateWithSameName == null || permissionTemplateWithSameName.getId() == id,
+ checkRequest(permissionTemplateWithSameName == null || Objects.equals(permissionTemplateWithSameName.getUuid(), uuid),
format(MSG_TEMPLATE_WITH_SAME_NAME, name));
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.config.internal.MapSettings;
+import org.sonar.api.impl.utils.TestSystem2;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.ResourceTypes;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
-import org.sonar.api.impl.utils.TestSystem2;
import org.sonar.api.web.UserRole;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.util.UuidFactoryFast;
DefaultTemplates defaultTemplates = dbClient.organizationDao().getDefaultTemplates(dbSession, organization.getUuid()).get();
assertThat(defaultTemplates.getProjectUuid()).isEqualTo(defaultTemplate.getUuid());
assertThat(defaultTemplates.getApplicationsUuid()).isNull();
- assertThat(dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateId(dbSession, defaultTemplate.getId()))
+ assertThat(dbClient.permissionTemplateDao().selectGroupPermissionsByTemplateUuid(dbSession, defaultTemplate.getUuid()))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(ownersGroup.getId(), UserRole.ADMIN),
dbTester.users().insertMember(group, user);
PermissionTemplateDto template = templateDb.insertTemplate(organization);
dbTester.organizations().setDefaultTemplates(template, null, null);
- templateDb.addProjectCreatorToTemplate(template.getId(), SCAN.getKey());
- templateDb.addUserToTemplate(template.getId(), user.getId(), UserRole.USER);
- templateDb.addGroupToTemplate(template.getId(), group.getId(), UserRole.CODEVIEWER);
- templateDb.addGroupToTemplate(template.getId(), null, UserRole.ISSUE_ADMIN);
+ templateDb.addProjectCreatorToTemplate(template.getUuid(), SCAN.getKey());
+ templateDb.addUserToTemplate(template.getUuid(), user.getId(), UserRole.USER);
+ templateDb.addGroupToTemplate(template.getUuid(), group.getId(), UserRole.CODEVIEWER);
+ templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN);
// authenticated user
checkWouldUserHaveScanPermission(organization, user.getId(), true);
private List<String> getGroupNamesInTemplateAndPermission(PermissionTemplateDto template, String permission) {
PermissionQuery query = PermissionQuery.builder().setOrganizationUuid(template.getOrganizationUuid()).setPermission(permission).build();
return db.getDbClient().permissionTemplateDao()
- .selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getId());
+ .selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid());
}
}
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.permission.PermissionService;
import org.sonar.server.permission.PermissionServiceImpl;
-import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.RequestValidator;
+import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.ws.WsParameters;
import static org.assertj.core.api.Assertions.assertThat;
.setParam(PARAM_TEMPLATE_ID, template.getUuid())
.execute();
- assertThatProjectCreatorIsPresentFor(UserRole.ADMIN, template.getId());
+ assertThatProjectCreatorIsPresentFor(UserRole.ADMIN, template.getUuid());
}
@Test
PermissionTemplateCharacteristicDto characteristic = db.getDbClient().permissionTemplateCharacteristicDao().insert(db.getSession(),
new PermissionTemplateCharacteristicDto()
.setUuid(Uuids.createFast())
- .setTemplateId(template.getId())
+ .setTemplateUuid(template.getUuid())
.setPermission(UserRole.USER)
.setWithProjectCreator(false)
.setCreatedAt(1_000_000_000L)
.setParam(PARAM_TEMPLATE_NAME, template.getName())
.execute();
- assertThatProjectCreatorIsPresentFor(UserRole.USER, template.getId());
+ assertThatProjectCreatorIsPresentFor(UserRole.USER, template.getUuid());
PermissionTemplateCharacteristicDto reloaded = reload(characteristic);
assertThat(reloaded.getCreatedAt()).isEqualTo(1_000_000_000L);
assertThat(reloaded.getUpdatedAt()).isEqualTo(3_000_000_000L);
.execute();
}
- private void assertThatProjectCreatorIsPresentFor(String permission, long templateId) {
+ private void assertThatProjectCreatorIsPresentFor(String permission, String templateUuid) {
Optional<PermissionTemplateCharacteristicDto> templatePermission = db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(),
permission,
- templateId);
+ templateUuid);
assertThat(templatePermission).isPresent();
assertThat(templatePermission.get().getWithProjectCreator()).isTrue();
}
private PermissionTemplateCharacteristicDto reload(PermissionTemplateCharacteristicDto characteristic) {
- return db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(), characteristic.getPermission(), characteristic.getTemplateId()).get();
+ return db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(), characteristic.getPermission(), characteristic.getTemplateUuid())
+ .get();
}
}
private List<String> getLoginsInTemplateAndPermission(PermissionTemplateDto template, String permission) {
PermissionQuery permissionQuery = PermissionQuery.builder().setOrganizationUuid(template.getOrganizationUuid()).setPermission(permission).build();
return db.getDbClient().permissionTemplateDao()
- .selectUserLoginsByQueryAndTemplate(db.getSession(), permissionQuery, template.getId());
+ .selectUserLoginsByQueryAndTemplate(db.getSession(), permissionQuery, template.getUuid());
}
private void addUserAsMemberOfOrganization(OrganizationDto organization) {
}
private void addUserToTemplate(UserDto user, PermissionTemplateDto permissionTemplate, String permission) {
- db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getId(), user.getId(), permission);
+ db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getId(), permission);
db.commit();
}
private void addGroupToTemplate(GroupDto group, PermissionTemplateDto permissionTemplate, String permission) {
- db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), permissionTemplate.getId(), group.getId(), permission);
+ db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), permissionTemplate.getUuid(), group.getId(), permission);
db.commit();
}
}
private void addUserToTemplate(UserDto user, PermissionTemplateDto permissionTemplate, String permission) {
- db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getId(), user.getId(), permission);
+ db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), permissionTemplate.getUuid(), user.getId(), permission);
db.commit();
}
private void addGroupToTemplate(GroupDto group, PermissionTemplateDto permissionTemplate, String permission) {
- db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), permissionTemplate.getId(), group.getId(), permission);
+ db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), permissionTemplate.getUuid(), group.getId(), permission);
db.commit();
}
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.getId(), user.getId(), UserRole.ADMIN);
- db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), dto.getId(), group.getId(), UserRole.CODEVIEWER);
+ db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getUuid(), user.getId(), UserRole.ADMIN);
+ db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), dto.getUuid(), group.getId(), UserRole.CODEVIEWER);
db.commit();
return dto;
}
}
private void addGroupToTemplate(PermissionTemplateDto template, @Nullable Integer groupId, String permission) {
- db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), template.getId(), groupId, permission);
+ db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), template.getUuid(), groupId, permission);
db.commit();
}
private List<String> getGroupNamesInTemplateAndPermission(PermissionTemplateDto template, String permission) {
PermissionQuery permissionQuery = PermissionQuery.builder().setOrganizationUuid(template.getOrganizationUuid()).setPermission(permission).build();
return db.getDbClient().permissionTemplateDao()
- .selectGroupNamesByQueryAndTemplate(db.getSession(), permissionQuery, template.getId());
+ .selectGroupNamesByQueryAndTemplate(db.getSession(), permissionQuery, template.getUuid());
}
}
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.permission.PermissionService;
import org.sonar.server.permission.PermissionServiceImpl;
-import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.RequestValidator;
+import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.ws.WsParameters;
import static org.assertj.core.api.Assertions.assertThat;
PermissionTemplateCharacteristicDto characteristic = db.getDbClient().permissionTemplateCharacteristicDao().insert(db.getSession(),
new PermissionTemplateCharacteristicDto()
.setUuid(Uuids.createFast())
- .setTemplateId(template.getId())
+ .setTemplateUuid(template.getUuid())
.setPermission(UserRole.USER)
.setWithProjectCreator(false)
.setCreatedAt(1_000_000_000L)
private void assertWithoutProjectCreatorFor(String permission) {
Optional<PermissionTemplateCharacteristicDto> templatePermission = db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(),
- permission, template.getId());
+ permission, template.getUuid());
assertThat(templatePermission).isPresent();
assertThat(templatePermission.get().getWithProjectCreator()).isFalse();
}
private void assertNoTemplatePermissionFor(String permission) {
Optional<PermissionTemplateCharacteristicDto> templatePermission = db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(),
- permission, template.getId());
+ permission, template.getUuid());
assertThat(templatePermission).isNotPresent();
}
private PermissionTemplateCharacteristicDto reload(PermissionTemplateCharacteristicDto characteristic) {
- return db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(), characteristic.getPermission(), characteristic.getTemplateId())
+ return db.getDbClient().permissionTemplateCharacteristicDao().selectByPermissionAndTemplateId(db.getSession(), characteristic.getPermission(), characteristic.getTemplateUuid())
.get();
}
}
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.permission.PermissionService;
import org.sonar.server.permission.PermissionServiceImpl;
-import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.RequestValidator;
+import org.sonar.server.permission.ws.BasePermissionWsTest;
import org.sonar.server.permission.ws.WsParameters;
import org.sonar.server.ws.TestRequest;
private List<String> getLoginsInTemplateAndPermission(PermissionTemplateDto template, String permission) {
PermissionQuery permissionQuery = PermissionQuery.builder().setOrganizationUuid(template.getOrganizationUuid()).setPermission(permission).build();
return db.getDbClient().permissionTemplateDao()
- .selectUserLoginsByQueryAndTemplate(db.getSession(), permissionQuery, template.getId());
+ .selectUserLoginsByQueryAndTemplate(db.getSession(), permissionQuery, template.getUuid());
}
private void addUserToTemplate(UserDto user, PermissionTemplateDto template, String permission) {
- db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), template.getId(), user.getId(), permission);
+ db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), template.getUuid(), user.getId(), permission);
db.commit();
}
@Before
public void setUp() {
DefaultTemplatesResolver defaultTemplatesResolverWithViews = new DefaultTemplatesResolverImpl(resourceTypesWithoutViews);
- underTestWithoutViews = new WsActionTester(new SearchTemplatesAction(dbClient, userSession, i18n, newPermissionWsSupport(), defaultTemplatesResolverWithViews, permissionServiceWithoutViews));
+ underTestWithoutViews = new WsActionTester(
+ new SearchTemplatesAction(dbClient, userSession, i18n, newPermissionWsSupport(), defaultTemplatesResolverWithViews, permissionServiceWithoutViews));
i18n.setProjectPermissions();
userSession.logIn().addPermission(ADMINISTER, db.getDefaultOrganization());
}
GroupDto group2 = db.users().insertGroup(organization);
GroupDto group3 = db.users().insertGroup(organization);
- addUserToTemplate(projectTemplate.getId(), user1.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user2.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user3.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user1.getId(), UserRole.CODEVIEWER);
- addGroupToTemplate(projectTemplate.getId(), group1.getId(), UserRole.ADMIN);
- addPermissionTemplateWithProjectCreator(projectTemplate.getId(), UserRole.ADMIN);
+ 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);
+ addGroupToTemplate(projectTemplate.getUuid(), group1.getId(), UserRole.ADMIN);
+ addPermissionTemplateWithProjectCreator(projectTemplate.getUuid(), UserRole.ADMIN);
db.organizations().setDefaultTemplates(projectTemplate, null, null);
GroupDto group2 = db.users().insertGroup(organization);
GroupDto group3 = db.users().insertGroup(organization);
- addUserToTemplate(projectTemplate.getId(), user1.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user2.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user3.getId(), UserRole.ISSUE_ADMIN);
- addUserToTemplate(projectTemplate.getId(), user1.getId(), UserRole.CODEVIEWER);
- addGroupToTemplate(projectTemplate.getId(), group1.getId(), UserRole.ADMIN);
- addPermissionTemplateWithProjectCreator(projectTemplate.getId(), UserRole.ADMIN);
+ 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);
+ addGroupToTemplate(projectTemplate.getUuid(), group1.getId(), UserRole.ADMIN);
+ addPermissionTemplateWithProjectCreator(projectTemplate.getUuid(), UserRole.ADMIN);
- addUserToTemplate(portfoliosTemplate.getId(), user1.getId(), UserRole.USER);
- addUserToTemplate(portfoliosTemplate.getId(), user2.getId(), UserRole.USER);
- addGroupToTemplate(portfoliosTemplate.getId(), group1.getId(), UserRole.ISSUE_ADMIN);
- addGroupToTemplate(portfoliosTemplate.getId(), group2.getId(), UserRole.ISSUE_ADMIN);
- addGroupToTemplate(portfoliosTemplate.getId(), group3.getId(), UserRole.ISSUE_ADMIN);
+ addUserToTemplate(portfoliosTemplate.getUuid(), user1.getId(), UserRole.USER);
+ addUserToTemplate(portfoliosTemplate.getUuid(), user2.getId(), UserRole.USER);
+ addGroupToTemplate(portfoliosTemplate.getUuid(), group1.getId(), UserRole.ISSUE_ADMIN);
+ addGroupToTemplate(portfoliosTemplate.getUuid(), group2.getId(), UserRole.ISSUE_ADMIN);
+ addGroupToTemplate(portfoliosTemplate.getUuid(), group3.getId(), UserRole.ISSUE_ADMIN);
db.organizations().setDefaultTemplates(projectTemplate, applicationsTemplate, portfoliosTemplate);
PermissionTemplateDto projectDefaultTemplate = db.permissionTemplates().insertTemplate(org);
db.organizations().setDefaultTemplates(projectDefaultTemplate, null, null);
PermissionTemplateDto templateInOrg = insertProjectTemplate(org);
- insertProjectTemplate(db.getDefaultOrganization());
+ insertProjectTemplate("uuid-1", db.getDefaultOrganization());
db.commit();
userSession.addPermission(ADMINISTER, org);
" {" +
" \"key\": \"securityhotspotadmin\"," +
" \"name\": \"Administer Security Hotspots\"," +
- " \"description\": \"Detect a Vulnerability from a \\\"Security Hotspot\\\". Reject, clear, accept, reopen a \\\"Security Hotspot\\\" (users also need \\\"Browse\\\" permissions).\"" +
+ " \"description\": \"Detect a Vulnerability from a \\\"Security Hotspot\\\". Reject, clear, accept, reopen a \\\"Security Hotspot\\\" (users also need \\\"Browse\\\" permissions).\""
+ +
" }," +
" {" +
" \"key\": \"scan\"," +
" }" +
" ]" +
"}");
- }
+ }
@Test
public void display_all_project_permissions_with_views() {
" {" +
" \"key\": \"securityhotspotadmin\"," +
" \"name\": \"Administer Security Hotspots\"," +
- " \"description\": \"Detect a Vulnerability from a \\\"Security Hotspot\\\". Reject, clear, accept, reopen a \\\"Security Hotspot\\\" (users also need \\\"Browse\\\" permissions).\"" +
+ " \"description\": \"Detect a Vulnerability from a \\\"Security Hotspot\\\". Reject, clear, accept, reopen a \\\"Security Hotspot\\\" (users also need \\\"Browse\\\" permissions).\""
+ +
" }," +
" {" +
" \"key\": \"scan\"," +
}
private PermissionTemplateDto insertProjectTemplate(OrganizationDto org) {
+ return insertProjectTemplate(UUID_EXAMPLE_01, org);
+ }
+
+ private PermissionTemplateDto insertProjectTemplate(String uuid, OrganizationDto org) {
return insertTemplate(newPermissionTemplateDto()
.setOrganizationUuid(org.getUuid())
- .setUuid(UUID_EXAMPLE_01)
+ .setUuid(uuid)
.setName("Default template for Projects")
.setDescription("Template for new projects")
.setKeyPattern(null)
return insert;
}
- private void addGroupToTemplate(long templateId, @Nullable Integer groupId, String permission) {
- dbClient.permissionTemplateDao().insertGroupPermission(db.getSession(), templateId, groupId, permission);
+ private void addGroupToTemplate(String templateUuid, @Nullable Integer groupId, String permission) {
+ dbClient.permissionTemplateDao().insertGroupPermission(db.getSession(), templateUuid, groupId, permission);
db.getSession().commit();
}
- private void addUserToTemplate(long templateId, int userId, String permission) {
- dbClient.permissionTemplateDao().insertUserPermission(db.getSession(), templateId, userId, permission);
+ private void addUserToTemplate(String templateUuid, int userId, String permission) {
+ dbClient.permissionTemplateDao().insertUserPermission(db.getSession(), templateUuid, userId, permission);
db.getSession().commit();
}
- private void addPermissionTemplateWithProjectCreator(long templateId, String permission) {
+ private void addPermissionTemplateWithProjectCreator(String templateUuid, String permission) {
dbClient.permissionTemplateCharacteristicDao().insert(dbSession, new PermissionTemplateCharacteristicDto()
.setUuid(Uuids.createFast())
.setWithProjectCreator(true)
- .setTemplateId(templateId)
+ .setTemplateUuid(templateUuid)
.setPermission(permission)
.setCreatedAt(1_000_000_000L)
.setUpdatedAt(2_000_000_000L));
SearchTemplatesData.Builder underTest = SearchTemplatesData.builder()
.defaultTemplates(new DefaultTemplatesResolverImpl.ResolvedDefaultTemplates("template_uuid", null, null))
.templates(singletonList(newPermissionTemplateDto()))
- .userCountByTemplateIdAndPermission(HashBasedTable.create())
- .groupCountByTemplateIdAndPermission(HashBasedTable.create())
- .withProjectCreatorByTemplateIdAndPermission(HashBasedTable.create());
+ .userCountByTemplateUuidAndPermission(HashBasedTable.create())
+ .groupCountByTemplateUuidAndPermission(HashBasedTable.create())
+ .withProjectCreatorByTemplateUuidAndPermission(HashBasedTable.create());
@Test
public void fail_if_templates_is_null() {
@Test
public void fail_if_user_count_is_null() {
expectedException.expect(IllegalStateException.class);
- underTest.userCountByTemplateIdAndPermission(null);
+ underTest.userCountByTemplateUuidAndPermission(null);
underTest.build();
}
@Test
public void fail_if_group_count_is_null() {
expectedException.expect(IllegalStateException.class);
- underTest.groupCountByTemplateIdAndPermission(null);
+ underTest.groupCountByTemplateUuidAndPermission(null);
underTest.build();
}
@Test
public void fail_if_with_project_creators_is_null() {
expectedException.expect(IllegalStateException.class);
- underTest.withProjectCreatorByTemplateIdAndPermission(null);
+ underTest.withProjectCreatorByTemplateUuidAndPermission(null);
underTest.build();
}
GroupDto userGroup = insertGroupOnDefaultOrganization("sonar-users", "Any new users created will automatically join this group");
PermissionTemplateDto template = addTemplateToDefaultOrganization();
- addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getId(), adminGroup.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getId(), userGroup.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getUuid(), adminGroup.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getUuid(), userGroup.getId()));
// Anyone group
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), null));
- addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getId(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getUuid(), null));
loginAsAdmin(db.getDefaultOrganization());
String response = newRequest()
String groupName = "group-name";
GroupDto group1 = db.users().insertGroup(db.getDefaultOrganization(), groupName);
- addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getId(), group1.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getUuid(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getUuid(), group1.getId()));
OrganizationDto otherOrganization = db.organizations().insert();
db.users().insertGroup(otherOrganization, groupName);
PermissionTemplateDto template = addTemplateToDefaultOrganization();
GroupDto group1 = db.users().insertGroup(db.getDefaultOrganization(), "group-1-name");
- addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getId(), group1.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getUuid(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getUuid(), group1.getId()));
GroupDto group2 = db.users().insertGroup(db.getDefaultOrganization(), "group-2-name");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group2.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getId(), group2.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group2.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getUuid(), group2.getId()));
GroupDto group3 = db.users().insertGroup(db.getDefaultOrganization(), "group-3-name");
// Anyone
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), null));
- addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getId(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(ISSUE_ADMIN, template.getUuid(), null));
PermissionTemplateDto anotherTemplate = addTemplateToDefaultOrganization();
GroupDto group4 = db.users().insertGroup(db.getDefaultOrganization(), "group-4-name");
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getId(), group3.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getId(), group4.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getUuid(), group3.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getUuid(), group4.getId()));
loginAsAdmin(db.getDefaultOrganization());
WsGroupsResponse response = newRequest()
PermissionTemplateDto template = addTemplateToDefaultOrganization();
GroupDto group1 = db.users().insertGroup(db.getDefaultOrganization(), "group-1-name");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group1.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(CODEVIEWER, template.getUuid(), group1.getId()));
GroupDto group2 = db.users().insertGroup(db.getDefaultOrganization(), "group-2-name");
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getId(), group2.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getUuid(), group2.getId()));
GroupDto group3 = db.users().insertGroup(db.getDefaultOrganization(), "group-3-name");
// Anyone
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), null));
PermissionTemplateDto anotherTemplate = addTemplateToDefaultOrganization();
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getId(), group3.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, anotherTemplate.getUuid(), group3.getId()));
loginAsAdmin(db.getDefaultOrganization());
WsGroupsResponse response = newRequest()
GroupDto group3 = db.users().insertGroup(defaultOrg, "group-3-name");
PermissionTemplateDto template = addTemplateToDefaultOrganization();
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group1.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getId(), group2.getId()));
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), null));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(ADMIN, template.getUuid(), group2.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), null));
PermissionTemplateDto anotherTemplate = addTemplateToDefaultOrganization();
- addGroupToTemplate(newPermissionTemplateGroup(USER, anotherTemplate.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, anotherTemplate.getUuid(), group1.getId()));
loginAsAdmin(db.getDefaultOrganization());
WsGroupsResponse response = newRequest()
OrganizationDto defaultOrg = db.getDefaultOrganization();
PermissionTemplateDto template = addTemplateToDefaultOrganization();
GroupDto group1 = db.users().insertGroup(defaultOrg, "group-1-name");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group1.getId()));
GroupDto group2 = db.users().insertGroup(defaultOrg, "group-2-name");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group2.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group2.getId()));
loginAsAdmin(db.getDefaultOrganization());
WsGroupsResponse response = newRequest()
OrganizationDto defaultOrg = db.getDefaultOrganization();
PermissionTemplateDto template = addTemplateToDefaultOrganization();
GroupDto group1 = db.users().insertGroup(defaultOrg, "group-1-name");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group1.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group1.getId()));
GroupDto group2 = db.users().insertGroup(defaultOrg, "group-2-name");
GroupDto group3 = db.users().insertGroup(defaultOrg, "group-3");
loginAsAdmin(db.getDefaultOrganization());
public void search_with_text_query_return_anyone_group_even_when_no_permission_set() {
PermissionTemplateDto template = addTemplateToDefaultOrganization();
GroupDto group = db.users().insertGroup(db.getDefaultOrganization(), "group");
- addGroupToTemplate(newPermissionTemplateGroup(USER, template.getId(), group.getId()));
+ addGroupToTemplate(newPermissionTemplateGroup(USER, template.getUuid(), group.getId()));
loginAsAdmin(db.getDefaultOrganization());
WsGroupsResponse response = newRequest()
db.commit();
}
- private static PermissionTemplateGroupDto newPermissionTemplateGroup(String permission, long templateId, @Nullable Integer groupId) {
+ private static PermissionTemplateGroupDto newPermissionTemplateGroup(String permission, String templateUuid, @Nullable Integer groupId) {
return newPermissionTemplateGroupDto()
.setPermission(permission)
- .setTemplateId(templateId)
+ .setTemplateUuid(templateUuid)
.setGroupId(groupId);
}
}
private void addUserToTemplate(PermissionTemplateUserDto dto) {
- db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getTemplateId(), dto.getUserId(), dto.getPermission());
+ db.getDbClient().permissionTemplateDao().insertUserPermission(db.getSession(), dto.getTemplateUuid(), dto.getUserId(), dto.getPermission());
db.commit();
}
private static PermissionTemplateUserDto newPermissionTemplateUser(String permission, PermissionTemplateDto template, UserDto user) {
return newPermissionTemplateUserDto()
.setPermission(permission)
- .setTemplateId(template.getId())
+ .setTemplateUuid(template.getUuid())
.setUserId(user.getId());
}
UserDto user = db.users().insertUser();
PermissionTemplateDto template = db.permissionTemplates().insertTemplate();
PermissionTemplateDto anotherTemplate = db.permissionTemplates().insertTemplate();
- db.permissionTemplates().addUserToTemplate(template.getId(), user.getId(), USER);
- db.permissionTemplates().addUserToTemplate(anotherTemplate.getId(), user.getId(), CODEVIEWER);
+ db.permissionTemplates().addUserToTemplate(template.getUuid(), user.getId(), USER);
+ db.permissionTemplates().addUserToTemplate(anotherTemplate.getUuid(), user.getId(), CODEVIEWER);
deactivate(user.getLogin());
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getId())).extracting(PermissionTemplateUserDto::getUserId).isEmpty();
- assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getId())).extracting(PermissionTemplateUserDto::getUserId)
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
+ .isEmpty();
+ assertThat(db.getDbClient().permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, anotherTemplate.getUuid())).extracting(PermissionTemplateUserDto::getUserId)
.isEmpty();
}
insertDefaultGroupOnDefaultOrganization();
GroupDto group = db.users().insertGroup();
PermissionTemplateDto template = db.getDbClient().permissionTemplateDao().insert(db.getSession(), PermissionTemplateTesting.newPermissionTemplateDto());
- db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), template.getId(), group.getId(), "perm");
+ db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), template.getUuid(), group.getId(), "perm");
db.commit();
loginAsAdminOnDefaultOrganization();
assertThat(db.countRowsOfTable("perm_templates_groups")).isEqualTo(1);
projects / sonarqube.git / commitdiff