massUpdate.update("update groups set organization_uuid=?, updated_at=? where id=?");
massUpdate.rowPluralName("groups");
massUpdate.execute((row, update) -> {
- long groupId = row.getLong(1);
+ int groupId = row.getInt(1);
update.setString(1, organizationUuid);
update.setDate(2, new Date(system2.now()));
- update.setLong(3, groupId);
+ update.setInt(3, groupId);
return true;
});
}
massUpdate.update("update permission_templates set organization_uuid=?, updated_at=? where id=?");
massUpdate.rowPluralName("permission_templates");
massUpdate.execute((row, update) -> {
- long groupId = row.getLong(1);
+ int groupId = row.getInt(1);
update.setString(1, organizationUuid);
update.setDate(2, new Date(system2.now()));
- update.setLong(3, groupId);
+ update.setInt(3, groupId);
return true;
});
}
" user_id as \"userId\", resource_id as \"resourceId\", is_empty as \"isEmpty\", text_value as \"textValue\", clob_value as \"clobValue\", created_at as \"createdAt\"" +
" from properties2" +
" where prop_key='" + key + "'");
+ Long userId = (Long) row.get("userId");
return new Property2(
- (Long) row.get("userId"),
+ userId == null ? null : userId.intValue(),
(Long) row.get("resourceId"),
isEmpty(row),
(String) row.get("textValue"),
return this;
}
- public Property2Assert hasUserId(long expected) {
+ public Property2Assert hasUserId(int expected) {
isNotNull();
if (!Objects.equals(actual.getUserId(), expected)) {
}
private static final class Property2 {
- private final Long userId;
+ private final Integer userId;
private final Long resourceId;
private final Boolean empty;
private final String textValue;
private final String clobValue;
private final Long createdAt;
- private Property2(@Nullable Long userId, @Nullable Long resourceId,
+ private Property2(@Nullable Integer userId, @Nullable Long resourceId,
@Nullable Boolean empty, @Nullable String textValue, @Nullable String clobValue,
@Nullable Long createdAt) {
this.userId = userId;
this.createdAt = createdAt;
}
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
@Test
public void execute_sets_active_user_with_admin_role_has_root() throws SQLException {
- long userId = insertUser("foo", true);
+ int userId = insertUser("foo", true);
insertRole(userId, ROLE_ADMIN);
underTest.execute();
@Test
public void execute_sets_inactive_user_with_admin_role_has_not_root() throws SQLException {
- long userId = insertUser("bar", false);
+ int userId = insertUser("bar", false);
insertRole(userId, ROLE_ADMIN);
underTest.execute();
@Test
public void execute_sets_active_user_in_group_with_admin_role_has_root() throws SQLException {
- long userId = insertUser("doo", true);
- long groupId = insertGroup("admin group");
+ int userId = insertUser("doo", true);
+ int groupId = insertGroup("admin group");
insertGroupRole(groupId, ROLE_ADMIN);
addUserToGroup(userId, groupId);
@Test
public void execute_sets_inactive_user_in_group_with_admin_role_has_not_root() throws SQLException {
- long userId = insertUser("bar", false);
- long groupId = insertGroup("admin group");
+ int userId = insertUser("bar", false);
+ int groupId = insertGroup("admin group");
insertGroupRole(groupId, ROLE_ADMIN);
addUserToGroup(userId, groupId);
@Test
public void migration_is_reentrant() throws SQLException {
- long adminGroupId = insertGroup("admin group");
+ int adminGroupId = insertGroup("admin group");
insertGroupRole(adminGroupId, ROLE_ADMIN);
- long groupId = insertGroup("other group");
- long[] userIds = {
+ int groupId = insertGroup("other group");
+ int[] userIds = {
insertUser("inactive_direct_admin", false),
insertUser("active_direct_admin", true),
insertUser("inactive_group_admin", false),
verifyUser("no_perm_user", false);
}
- private void insertRole(long userId, String role) {
+ private void insertRole(int userId, String role) {
dbTester.executeInsert("user_roles", "user_id", userId, "role", role);
dbTester.commit();
}
- private long insertUser(String login, boolean active) {
+ private int insertUser(String login, boolean active) {
dbTester.executeInsert(USERS_TABLE, "login", login, "active", active);
dbTester.commit();
- return (Long) dbTester.selectFirst("select id as \"id\" from users where login = '" + login + "'").get("id");
+ Long userId = (Long) dbTester.selectFirst("select id as \"id\" from users where login = '" + login + "'").get("id");
+ return userId.intValue();
}
- private long insertGroup(String groupName) {
+ private int insertGroup(String groupName) {
dbTester.executeInsert("groups", "name", groupName);
dbTester.commit();
- return (Long) dbTester.selectFirst("select id as \"id\" from groups where name = '" + groupName + "'").get("id");
+ Long groupId = (Long) dbTester.selectFirst("select id as \"id\" from groups where name = '" + groupName + "'").get("id");
+ return groupId.intValue();
}
- private void insertGroupRole(long groupId, String role) {
+ private void insertGroupRole(int groupId, String role) {
dbTester.executeInsert("group_roles", "group_id", groupId, "role", role);
dbTester.commit();
}
- private void addUserToGroup(long userId, long groupId) {
+ private void addUserToGroup(int userId, int groupId) {
dbTester.executeInsert("groups_users", "user_id", userId, "group_id", groupId);
dbTester.commit();
}
* - Add component to favorite if the component has the 'Project Creators' permission
* - Index component if es indexes
*/
- public ComponentDto create(DbSession dbSession, NewComponent newComponent, @Nullable Long userId) {
+ public ComponentDto create(DbSession dbSession, NewComponent newComponent, @Nullable Integer userId) {
checkKeyFormat(newComponent.qualifier(), newComponent.key());
ComponentDto componentDto = createRootComponent(dbSession, newComponent);
removeDuplicatedProjects(dbSession, componentDto.getKey());
}
}
- private void handlePermissionTemplate(DbSession dbSession, ComponentDto componentDto, String organizationUuid, @Nullable Long userId) {
+ private void handlePermissionTemplate(DbSession dbSession, ComponentDto componentDto, String organizationUuid, @Nullable Integer userId) {
permissionTemplateService.applyDefault(dbSession, organizationUuid, componentDto, userId);
if (componentDto.qualifier().equals(PROJECT)
&& permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(dbSession, organizationUuid, componentDto)) {
// Used in GOV
/**
- * @deprecated Use {@link ComponentUpdater#create(DbSession, NewComponent, Long)} instead
+ * @deprecated Use {@link ComponentUpdater#create(DbSession, NewComponent, Integer)} instead
*/
@Deprecated
public Long createComponent(String key, String name, String qualifier) {
return componentUpdater.create(
dbSession,
newComponent,
- userSession.isLoggedIn() ? userSession.getUserId().longValue() : null).getId();
+ userSession.isLoggedIn() ? userSession.getUserId() : null).getId();
}
}
private ComponentDto createProject(DbSession dbSession, String organizationUuid, String projectKey, @Nullable String projectBranch, @Nullable String projectName) {
userSession.checkOrganizationPermission(organizationUuid, PROVISIONING);
Integer userId = userSession.getUserId();
- Long projectCreatorUserId = userId == null ? null : userId.longValue();
boolean wouldCurrentUserHaveScanPermission = permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(
- dbSession, organizationUuid, projectCreatorUserId, SCAN_EXECUTION, projectBranch, projectKey, Qualifiers.PROJECT);
+ dbSession, organizationUuid, userId, SCAN_EXECUTION, projectBranch, projectKey, Qualifiers.PROJECT);
if (!wouldCurrentUserHaveScanPermission) {
throw insufficientPrivilegesException();
}
.setBranch(projectBranch)
.setQualifier(Qualifiers.PROJECT)
.build();
- return componentUpdater.create(dbSession, newProject, projectCreatorUserId);
+ return componentUpdater.create(dbSession, newProject, userId);
}
private CeTask submitReport(DbSession dbSession, InputStream reportInput, ComponentDto project) {
/**
* Set favorite to the logged in user. If no user, no action is done
*/
- public void add(DbSession dbSession, ComponentDto componentDto, @Nullable Long userId) {
+ public void add(DbSession dbSession, ComponentDto componentDto, @Nullable Integer userId) {
if (userId == null) {
return;
}
List<PropertyDto> existingFavoriteOnComponent = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder()
.setKey(PROP_FAVORITE_KEY)
- .setUserId(userId.intValue())
+ .setUserId(userId)
.setComponentId(componentDto.getId())
.build(), dbSession);
checkRequest(existingFavoriteOnComponent.isEmpty(), "Component '%s' is already a favorite", componentDto.getKey());
* Remove a favorite to the user.
* @throws BadRequestException if the component is not a favorite
*/
- public void remove(DbSession dbSession, ComponentDto component, @Nullable Long userId) {
+ public void remove(DbSession dbSession, ComponentDto component, @Nullable Integer userId) {
if (userId == null) {
return;
}
userSession
.checkLoggedIn()
.checkComponentPermission(UserRole.USER, componentDto);
- favoriteUpdater.add(dbSession, componentDto, userSession.isLoggedIn() ? userSession.getUserId().longValue() : null);
+ favoriteUpdater.add(dbSession, componentDto, userSession.isLoggedIn() ? userSession.getUserId() : null);
dbSession.commit();
}
};
ComponentDto component = componentFinder.getByKey(dbSession, request.mandatoryParam(PARAM_COMPONENT));
userSession
.checkLoggedIn();
- favoriteUpdater.remove(dbSession, component, userSession.isLoggedIn() ? userSession.getUserId().longValue() : null);
+ favoriteUpdater.remove(dbSession, component, userSession.isLoggedIn() ? userSession.getUserId() : null);
dbSession.commit();
}
};
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto()
.setKey(key)
- .setUserId(Long.valueOf(userSession.getUserId()))
+ .setUserId(userSession.getUserId())
.setValue(PROP_NOTIFICATION_VALUE)
.setResourceId(projectId));
}
dbClient.propertiesDao().delete(dbSession, new PropertyDto()
.setKey(key)
- .setUserId(Long.valueOf(userSession.getUserId()))
+ .setUserId(userSession.getUserId())
.setValue(PROP_NOTIFICATION_VALUE)
.setResourceId(projectId));
}
* @throws KeyConflictException if an organization with the specified key already exists
* @throws IllegalArgumentException if any field of {@code newOrganization} is invalid according to {@link OrganizationValidation}
*/
- OrganizationDto create(DbSession dbSession, long createUserId, NewOrganization newOrganization) throws KeyConflictException;
+ OrganizationDto create(DbSession dbSession, int createUserId, NewOrganization newOrganization) throws KeyConflictException;
/**
* Create a new guarded organization which details are based on the login of the specified User.
}
@Override
- public OrganizationDto create(DbSession dbSession, long creatorUserId, NewOrganization newOrganization) throws KeyConflictException {
+ public OrganizationDto create(DbSession dbSession, int creatorUserId, NewOrganization newOrganization) throws KeyConflictException {
validate(newOrganization);
String key = newOrganization.getKey();
if (organizationKeyIsUsed(dbSession, key)) {
.setRole(permission));
}
- private void addCurrentUserToGroup(DbSession dbSession, GroupDto group, long createUserId) {
+ private void addCurrentUserToGroup(DbSession dbSession, GroupDto group, int createUserId) {
dbClient.userGroupDao().insert(
dbSession,
new UserGroupDto().setGroupId(group.getId()).setUserId(createUserId));
organizationFlags.checkEnabled(dbSession);
OrganizationDto organization = organizationCreation.create(
dbSession,
- userSession.getUserId().longValue(),
+ userSession.getUserId(),
newOrganizationBuilder()
.setName(name)
.setKey(key)
}
public boolean wouldUserHavePermissionWithDefaultTemplate(DbSession dbSession,
- String organizationUuid, @Nullable Long userId, String globalPermission, @Nullable String branch, String projectKey,
+ String organizationUuid, @Nullable Integer userId, String globalPermission, @Nullable String branch, String projectKey,
String qualifier) {
if (userSession.hasOrganizationPermission(organizationUuid, globalPermission)) {
return true;
* can be provisioned (so has no permissions yet).
* @param projectCreatorUserId id of the user who creates the project, only if project is provisioned. He will
*/
- public void applyDefault(DbSession dbSession, String organizationUuid, ComponentDto component, @Nullable Long projectCreatorUserId) {
+ public void applyDefault(DbSession dbSession, String organizationUuid, ComponentDto component, @Nullable Integer projectCreatorUserId) {
PermissionTemplateDto template = findTemplate(dbSession, organizationUuid, component);
checkArgument(template != null, "Cannot retrieve default permission template");
copyPermissions(dbSession, template, component, projectCreatorUserId);
permissionIndexer.indexProjectsByUuids(dbSession, projectOrViewUuids);
}
- private void copyPermissions(DbSession dbSession, PermissionTemplateDto template, ComponentDto project, @Nullable Long projectCreatorUserId) {
+ private void copyPermissions(DbSession dbSession, PermissionTemplateDto template, ComponentDto project, @Nullable Integer projectCreatorUserId) {
dbClient.resourceDao().updateAuthorizationDate(project.getId(), dbSession);
dbClient.groupPermissionDao().deleteByRootComponentId(dbSession, project.getId());
dbClient.userPermissionDao().deleteProjectPermissions(dbSession, project.getId());
@Immutable
public class UserId {
- private final long id;
+ private final int id;
private final String login;
- public UserId(long userId, String login) {
+ public UserId(int userId, String login) {
this.id = userId;
this.login = requireNonNull(login);
}
- public long getId() {
+ public int getId() {
return id;
}
private final String projectUuid;
private final long updatedAt;
private final String qualifier;
- private final List<Long> userIds = new ArrayList<>();
- private final List<Long> groupIds = new ArrayList<>();
+ private final List<Integer> userIds = new ArrayList<>();
+ private final List<Integer> groupIds = new ArrayList<>();
private boolean allowAnyone = false;
public Dto(String projectUuid, long updatedAt, String qualifier) {
return qualifier;
}
- public List<Long> getUserIds() {
+ public List<Integer> getUserIds() {
return userIds;
}
- public Dto addUserId(long l) {
+ public Dto addUserId(int l) {
userIds.add(l);
return this;
}
- public Dto addGroupId(long id) {
+ public Dto addGroupId(int id) {
groupIds.add(id);
return this;
}
- public List<Long> getGroupIds() {
+ public List<Integer> getGroupIds() {
return groupIds;
}
}
switch (rowKind) {
case USER:
- dto.addUserId(rs.getLong(3));
+ dto.addUserId(rs.getInt(3));
break;
case GROUP:
- dto.addGroupId(rs.getLong(4));
+ dto.addGroupId(rs.getInt(4));
break;
case ANYONE:
dto.allowAnyone();
}
private static WsGroupsResponse buildResponse(List<GroupDto> groups, List<GroupPermissionDto> groupPermissions, Paging paging) {
- Multimap<Long, String> permissionsByGroupId = TreeMultimap.create();
+ Multimap<Integer, String> permissionsByGroupId = TreeMultimap.create();
groupPermissions.forEach(groupPermission -> permissionsByGroupId.put(groupPermission.getGroupId(), groupPermission.getRole()));
WsGroupsResponse.Builder response = WsGroupsResponse.newBuilder();
groups.forEach(group -> {
Group.Builder wsGroup = response.addGroupsBuilder()
.setName(group.getName());
- if (group.getId() != 0L) {
+ if (group.getId() != 0) {
wsGroup.setId(String.valueOf(group.getId()));
}
setNullable(group.getDescription(), wsGroup::setDescription);
List<String> orderedNames = dbClient.groupPermissionDao().selectGroupNamesByQuery(dbSession, org.getUuid(), dbQuery);
List<GroupDto> groups = dbClient.groupDao().selectByNames(dbSession, org.getUuid(), orderedNames);
if (orderedNames.contains(DefaultGroups.ANYONE)) {
- groups.add(0, new GroupDto().setId(0L).setName(DefaultGroups.ANYONE).setOrganizationUuid(org.getUuid()));
+ groups.add(0, new GroupDto().setId(0).setName(DefaultGroups.ANYONE).setOrganizationUuid(org.getUuid()));
}
return Ordering.explicit(orderedNames).onResultOf(GroupDto::getName).immutableSortedCopy(groups);
}
if (groups.isEmpty()) {
return emptyList();
}
- List<Long> ids = groups.stream().map(GroupDto::getId).collect(Collectors.toList(groups.size()));
+ List<Integer> ids = groups.stream().map(GroupDto::getId).collect(Collectors.toList(groups.size()));
return dbClient.groupPermissionDao().selectByGroupIds(dbSession, org.getUuid(), ids, project.isPresent() ? project.get().getId() : null);
}
}
}
public GroupIdOrAnyone findGroup(DbSession dbSession, Request request) {
- Long groupId = request.paramAsLong(PARAM_GROUP_ID);
+ Integer groupId = request.paramAsInt(PARAM_GROUP_ID);
String orgKey = request.param(PARAM_ORGANIZATION);
String groupName = request.param(PARAM_GROUP_NAME);
GroupWsRef groupRef = GroupWsRef.create(groupId, orgKey, groupName);
}
private static UsersWsResponse buildResponse(List<UserDto> users, List<UserPermissionDto> userPermissions, Paging paging) {
- Multimap<Long, String> permissionsByUserId = TreeMultimap.create();
+ Multimap<Integer, String> permissionsByUserId = TreeMultimap.create();
userPermissions.forEach(userPermission -> permissionsByUserId.put(userPermission.getUserId(), userPermission.getPermission()));
UsersWsResponse.Builder response = UsersWsResponse.newBuilder();
}
private List<UserDto> findUsers(DbSession dbSession, OrganizationDto org, PermissionQuery query) {
- List<Long> orderedIds = dbClient.userPermissionDao().selectUserIds(dbSession, org.getUuid(), query);
+ List<Integer> orderedIds = dbClient.userPermissionDao().selectUserIds(dbSession, org.getUuid(), query);
return Ordering.explicit(orderedIds).onResultOf(UserDto::getId).immutableSortedCopy(dbClient.userDao().selectByIds(dbSession, orderedIds));
}
}
private static WsPermissions.WsGroupsResponse buildResponse(List<GroupDto> groups, List<PermissionTemplateGroupDto> groupPermissions, Paging paging) {
- Multimap<Long, String> permissionsByGroupId = TreeMultimap.create();
+ Multimap<Integer, String> permissionsByGroupId = TreeMultimap.create();
groupPermissions.forEach(groupPermission -> permissionsByGroupId.put(groupPermission.getGroupId(), groupPermission.getPermission()));
WsPermissions.WsGroupsResponse.Builder response = WsPermissions.WsGroupsResponse.newBuilder();
groups.forEach(group -> {
WsPermissions.Group.Builder wsGroup = response.addGroupsBuilder()
.setName(group.getName());
- if (group.getId() != 0L) {
+ if (group.getId() != 0) {
wsGroup.setId(String.valueOf(group.getId()));
}
setNullable(group.getDescription(), wsGroup::setDescription);
List<String> orderedNames = dbClient.permissionTemplateDao().selectGroupNamesByQueryAndTemplate(dbSession, dbQuery, template.getOrganizationUuid(), template.getId());
List<GroupDto> groups = dbClient.groupDao().selectByNames(dbSession, template.getOrganizationUuid(), orderedNames);
if (orderedNames.contains(DefaultGroups.ANYONE)) {
- groups.add(0, new GroupDto().setId(0L).setName(DefaultGroups.ANYONE));
+ groups.add(0, new GroupDto().setId(0).setName(DefaultGroups.ANYONE));
}
return Ordering.explicit(orderedNames).onResultOf(GroupDto::getName).immutableSortedCopy(groups);
}
}
private static WsPermissions.UsersWsResponse buildResponse(List<UserDto> users, List<PermissionTemplateUserDto> permissionTemplateUsers, Paging paging) {
- Multimap<Long, String> permissionsByUserId = TreeMultimap.create();
+ Multimap<Integer, String> permissionsByUserId = TreeMultimap.create();
permissionTemplateUsers.forEach(userPermission -> permissionsByUserId.put(userPermission.getUserId(), userPermission.getPermission()));
UsersWsResponse.Builder responseBuilder = UsersWsResponse.newBuilder();
.setBranch(request.getBranch())
.setQualifier(PROJECT)
.build(),
- userSession.isLoggedIn() ? userSession.getUserId().longValue() : null);
+ userSession.isLoggedIn() ? userSession.getUserId() : null);
return toCreateResponse(componentDto);
}
}
@VisibleForTesting
ProjectsResult searchProjects(DbSession dbSession, SearchMyProjectsRequest request) {
- long userId = requireNonNull(userSession.getUserId(), "Current user must be authenticated");
+ int userId = requireNonNull(userSession.getUserId(), "Current user must be authenticated");
List<Long> componentIds = dbClient.roleDao().selectComponentIdsByPermissionAndUserId(dbSession, UserRole.ADMIN, userId);
ComponentQuery dbQuery = ComponentQuery.builder()
@Immutable
public class GroupId {
- private final long id;
+ private final int id;
private final String organizationUuid;
- public GroupId(String organizationUuid, long id) {
+ public GroupId(String organizationUuid, int id) {
this.id = id;
this.organizationUuid = requireNonNull(organizationUuid);
}
- public long getId() {
+ public int getId() {
return id;
}
@Immutable
public class GroupIdOrAnyone {
- private final Long id;
+ private final Integer id;
private final String organizationUuid;
- public GroupIdOrAnyone(String organizationUuid, @Nullable Long id) {
+ public GroupIdOrAnyone(String organizationUuid, @Nullable Integer id) {
this.id = id;
this.organizationUuid = requireNonNull(organizationUuid);
}
}
@CheckForNull
- public Long getId() {
+ public Integer getId() {
return id;
}
private static final int NULL_ID = -1;
- private final long id;
+ private final int id;
private final String organizationKey;
private final String name;
- private GroupWsRef(long id, @Nullable String organizationKey, @Nullable String name) {
+ private GroupWsRef(int id, @Nullable String organizationKey, @Nullable String name) {
this.id = id;
this.organizationKey = organizationKey;
this.name = name;
* @return the group id
* @throws IllegalStateException if {@link #getId()} is {@code false}
*/
- public long getId() {
+ public int getId() {
checkState(hasId(), "Id is not present. Please see hasId().");
return id;
}
* Creates a reference to a group by its id. Virtual groups "Anyone" can't be returned
* as they can't be referenced by an id.
*/
- static GroupWsRef fromId(long id) {
+ static GroupWsRef fromId(int id) {
checkArgument(id > -1, "Group id must be positive: %s", id);
return new GroupWsRef(id, null, null);
}
return new GroupWsRef(NULL_ID, organizationKey, requireNonNull(name));
}
- public static GroupWsRef create(@Nullable Long id, @Nullable String organizationKey, @Nullable String name) {
+ public static GroupWsRef create(@Nullable Integer id, @Nullable String organizationKey, @Nullable String name) {
if (id != null) {
checkRequest(organizationKey == null && name == null, "Either group id or couple organization/group name must be set");
return fromId(id);
if (o == null || getClass() != o.getClass()) {
return false;
}
- GroupWsRef groupRef = (GroupWsRef) o;
- if (id != groupRef.id) {
+ GroupWsRef that = (GroupWsRef) o;
+ if (id != that.id) {
return false;
}
- if (organizationKey != null ? !organizationKey.equals(groupRef.organizationKey) : (groupRef.organizationKey != null)) {
+ if (organizationKey != null ? !organizationKey.equals(that.organizationKey) : (that.organizationKey != null)) {
return false;
}
- return name != null ? name.equals(groupRef.name) : (groupRef.name == null);
+ return name != null ? name.equals(that.name) : (that.name == null);
}
@Override
public int hashCode() {
- int result = (int) (id ^ (id >>> 32));
+ int result = id;
result = 31 * result + (organizationKey != null ? organizationKey.hashCode() : 0);
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
* or if the virtual group "Anyone" is requested.
*/
public GroupId findGroup(DbSession dbSession, Request request) {
- Long id = request.paramAsLong(PARAM_GROUP_ID);
+ Integer id = request.paramAsInt(PARAM_GROUP_ID);
String organizationKey = request.param(PARAM_ORGANIZATION_KEY);
String name = request.param(PARAM_GROUP_NAME);
return findGroup(dbSession, GroupWsRef.create(id, organizationKey, name));
int limit = dbClient.groupDao().countByQuery(dbSession, organization.getUuid(), query);
List<GroupDto> groups = dbClient.groupDao().selectByQuery(dbSession, organization.getUuid(), query, options.getOffset(), pageSize);
- List<Long> groupIds = groups.stream().map(GroupDto::getId).collect(Collectors.toList(groups.size()));
+ List<Integer> groupIds = groups.stream().map(GroupDto::getId).collect(Collectors.toList(groups.size()));
Map<String, Integer> userCountByGroup = dbClient.groupMembershipDao().countUsersByGroups(dbSession, groupIds);
JsonWriter json = response.newJsonWriter().beginObject();
@Override
public void handle(Request request, Response response) throws Exception {
try (DbSession dbSession = dbClient.openSession(false)) {
- long groupId = request.mandatoryParamAsLong(PARAM_GROUP_ID);
+ int groupId = request.mandatoryParamAsInt(PARAM_GROUP_ID);
GroupDto group = dbClient.groupDao().selectById(dbSession, groupId);
checkFound(group, "Could not find a user group with id '%s'.", groupId);
Optional<OrganizationDto> org = dbClient.organizationDao().selectByUuid(dbSession, group.getOrganizationUuid());
if (expectedGroups.length == 0) {
assertThat(db.users().selectGroupIdsOfUser(userDto)).isEmpty();
} else {
- assertThat(db.users().selectGroupIdsOfUser(userDto)).containsOnly(stream(expectedGroups).map(GroupDto::getId).collect(Collectors.toList()).toArray(new Long[] {}));
+ assertThat(db.users().selectGroupIdsOfUser(userDto)).containsOnly(stream(expectedGroups).map(GroupDto::getId).collect(Collectors.toList()).toArray(new Integer[] {}));
}
}
@Test
public void should_apply_default_permission_template() throws Exception {
- long userId = 42;
+ int userId = 42;
NewComponent project = NewComponent.newComponentBuilder()
.setKey(DEFAULT_PROJECT_KEY)
.setName(DEFAULT_PROJECT_NAME)
}
private void addFavourite(ComponentDto project) {
- dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey("favourite").setResourceId(project.getId()).setUserId(Long.valueOf(userSession.getUserId())));
+ dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey("favourite").setResourceId(project.getId()).setUserId(userSession.getUserId()));
}
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
mockSuccessfulPrepareSubmitCall();
ComponentDto createdProject = newProjectDto(organization, PROJECT_UUID).setKey(PROJECT_KEY);
when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(createdProject);
- when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(organization.getUuid()), anyLong(), eq(SCAN_EXECUTION), anyString(),
+ when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(organization.getUuid()), anyInt(), eq(SCAN_EXECUTION), anyString(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(DbSession.class), eq(organization.getUuid()), any(ComponentDto.class))).thenReturn(true);
mockSuccessfulPrepareSubmitCall();
ComponentDto createdProject = newProjectDto(db.getDefaultOrganization(), PROJECT_UUID).setKey(PROJECT_KEY);
when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(createdProject);
- when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyLong(), eq(SCAN_EXECUTION), anyString(),
+ when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyInt(), eq(SCAN_EXECUTION), anyString(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(DbSession.class), eq(defaultOrganizationUuid), any(ComponentDto.class))).thenReturn(false);
mockSuccessfulPrepareSubmitCall();
ComponentDto project = newProjectDto(db.getDefaultOrganization(), PROJECT_UUID).setKey(PROJECT_KEY);
when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(project);
- when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyLong(), eq(SCAN_EXECUTION), anyString(),
+ when(permissionTemplateService.wouldUserHavePermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyInt(), eq(SCAN_EXECUTION), anyString(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
private static final ComponentDto COMPONENT = newProjectDto(OrganizationTesting.newOrganizationDto())
.setId(COMPONENT_ID)
.setKey(COMPONENT_KEY);
- private static final long USER_ID = 42L;
+ private static final int USER_ID = 42;
@Rule
public ExpectedException expectedException = ExpectedException.none();
PropertyDto favorite = favorites.get(0);
assertThat(favorite)
.extracting(PropertyDto::getResourceId, PropertyDto::getUserId, PropertyDto::getKey)
- .containsOnly(project.getId(), (long) USER_ID, "favourite");
+ .containsOnly(project.getId(), USER_ID, "favourite");
}
@Test
PropertyDto favorite = favorites.get(0);
assertThat(favorite)
.extracting(PropertyDto::getResourceId, PropertyDto::getUserId, PropertyDto::getKey)
- .containsOnly(file.getId(), (long) USER_ID, "favourite");
+ .containsOnly(file.getId(), USER_ID, "favourite");
}
@Test
addComponent(newProjectDto(organizationDto).setKey("K1"));
ComponentDto otherUserFavorite = newProjectDto(organizationDto).setKey("K42");
db.components().insertComponent(otherUserFavorite);
- db.favorites().add(otherUserFavorite, 42L);
- dbClient.userPermissionDao().insert(dbSession, new UserPermissionDto(organizationDto.getUuid(), UserRole.USER, 42L, otherUserFavorite.getId()));
+ db.favorites().add(otherUserFavorite, 42);
+ dbClient.userPermissionDao().insert(dbSession, new UserPermissionDto(organizationDto.getUuid(), UserRole.USER, 42, otherUserFavorite.getId()));
db.commit();
SearchResponse result = call();
import static org.sonar.server.organization.OrganizationCreation.NewOrganization.newOrganizationBuilder;
public class OrganizationCreationImplTest {
- private static final long SOME_USER_ID = 1L;
+ private static final int SOME_USER_ID = 1;
private static final String SOME_UUID = "org-uuid";
private static final long SOME_DATE = 12893434L;
private static final String A_LOGIN = "a-login";
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(ownersGroup.getId(), UserRole.ADMIN), tuple(ownersGroup.getId(), UserRole.ISSUE_ADMIN),
- tuple(0L, UserRole.USER), tuple(0L, UserRole.CODEVIEWER));
+ tuple(0, UserRole.USER), tuple(0, UserRole.CODEVIEWER));
}
@Test
import org.sonar.api.config.Settings;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
-import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
import org.sonar.api.web.UserRole;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.util.UuidFactory;
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(ownersGroup.getId(), UserRole.ADMIN), tuple(ownersGroup.getId(), UserRole.ISSUE_ADMIN),
- tuple(0L, UserRole.USER), tuple(0L, UserRole.CODEVIEWER));
+ tuple(0, UserRole.USER), tuple(0, UserRole.CODEVIEWER));
}
@Test
checkWouldUserHavePermission(dbTester.getDefaultOrganization(), null, UserRole.ADMIN, false);
}
- private void checkWouldUserHavePermission(OrganizationDto organization, @Nullable Long userId, String permission, boolean expectedResult) {
+ private void checkWouldUserHavePermission(OrganizationDto organization, @Nullable Integer userId, String permission, boolean expectedResult) {
assertThat(underTest.wouldUserHavePermissionWithDefaultTemplate(session, organization.getUuid(), userId, permission, null, "PROJECT_KEY", Qualifiers.PROJECT))
.isEqualTo(expectedResult);
}
return db.getDbClient().groupPermissionDao().selectGroupNamesByQuery(db.getSession(), db.getDefaultOrganization().getUuid(), query);
}
- private List<Long> selectProjectPermissionUsers(ComponentDto project, String permission) {
+ private List<Integer> selectProjectPermissionUsers(ComponentDto project, String permission) {
PermissionQuery query = PermissionQuery.builder().setPermission(permission).setComponentUuid(project.uuid()).build();
return db.getDbClient().userPermissionDao().selectUserIds(db.getSession(), db.getDefaultOrganization().getUuid(), query);
}
return db.getDbClient().groupPermissionDao().selectGroupNamesByQuery(db.getSession(), project.getOrganizationUuid(), query);
}
- private List<Long> selectProjectPermissionUsers(ComponentDto project, String permission) {
+ private List<Integer> selectProjectPermissionUsers(ComponentDto project, String permission) {
PermissionQuery query = PermissionQuery.builder().setPermission(permission).setComponentUuid(project.uuid()).build();
return db.getDbClient().userPermissionDao().selectUserIds(db.getSession(), project.getOrganizationUuid(), query);
}
request.execute();
}
- private void addGroupToTemplate(PermissionTemplateDto template, @Nullable Long groupId, String permission) {
+ private void addGroupToTemplate(PermissionTemplateDto template, @Nullable Integer groupId, String permission) {
db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), template.getId(), groupId, permission);
db.commit();
}
return insert;
}
- private void addGroupToTemplate(long templateId, @Nullable Long groupId, String permission) {
+ private void addGroupToTemplate(long templateId, @Nullable Integer groupId, String permission) {
dbClient.permissionTemplateDao().insertGroupPermission(db.getSession(), templateId, groupId, permission);
db.getSession().commit();
}
- private void addUserToTemplate(long templateId, long userId, String permission) {
+ private void addUserToTemplate(long templateId, int userId, String permission) {
dbClient.permissionTemplateDao().insertUserPermission(db.getSession(), templateId, userId, permission);
db.getSession().commit();
}
db.getDbClient().permissionTemplateDao().insertGroupPermission(db.getSession(), permissionTemplateGroup);
}
- private static PermissionTemplateGroupDto newPermissionTemplateGroup(String permission, long templateId, @Nullable Long groupId) {
+ private static PermissionTemplateGroupDto newPermissionTemplateGroup(String permission, long templateId, @Nullable Integer groupId) {
return newPermissionTemplateGroupDto()
.setPermission(permission)
.setTemplateId(templateId)
import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@Test
public void fail_when_project_already_exists() throws Exception {
OrganizationDto organization = db.organizations().insert();
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), anyLong())).thenThrow(new BadRequestException("already exists"));
+ when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), anyInt())).thenThrow(new BadRequestException("already exists"));
userSession.addOrganizationPermission(organization, PROVISIONING);
expectedException.expect(BadRequestException.class);
private NewComponent verifyCallToComponentUpdater() {
ArgumentCaptor<NewComponent> argument = ArgumentCaptor.forClass(NewComponent.class);
- verify(componentUpdater).create(any(DbSession.class), argument.capture(), anyLong());
+ verify(componentUpdater).create(any(DbSession.class), argument.capture(), anyInt());
return argument.getValue();
}
private void expectSuccessfulCallToComponentUpdater() {
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), anyLong())).thenAnswer(invocation -> {
+ when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), anyInt())).thenAnswer(invocation -> {
NewComponent newC = invocation.getArgumentAt(1, NewComponent.class);
return new ComponentDto().setKey(newC.key()).setQualifier(newC.qualifier()).setName(newC.name());
});
@Test
public void user_setting_is_not_updated() {
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my user value").setUserId(42L));
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my user value").setUserId(42));
propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"));
callForGlobalSetting("my.key", "my new global value");
assertGlobalSetting("my.key", "my new global value");
- assertUserSetting("my.key", "my user value", 42L);
+ assertUserSetting("my.key", "my user value", 42);
}
@Test
.containsExactly(key, value, null);
}
- private void assertUserSetting(String key, String value, long userId) {
- List<PropertyDto> result = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder().setKey(key).setUserId((int) userId).build(), dbSession);
+ private void assertUserSetting(String key, String value, int userId) {
+ List<PropertyDto> result = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder().setKey(key).setUserId(userId).build(), dbSession);
assertThat(result).hasSize(1)
.extracting(PropertyDto::getKey, PropertyDto::getValue, PropertyDto::getUserId)
public void fail_if_id_does_not_exist() throws Exception {
addAdminToDefaultOrganization();
loginAsAdminOnDefaultOrganization();
- long groupId = defaultGroup.getId() + 123;
+ int groupId = defaultGroup.getId() + 123;
expectedException.expect(NotFoundException.class);
expectedException.expectMessage("No group with id '" + groupId + "'");
@Test
public void test_ref_by_id() {
- GroupWsRef ref = GroupWsRef.fromId(10L);
+ GroupWsRef ref = GroupWsRef.fromId(10);
assertThat(ref.hasId()).isTrue();
- assertThat(ref.getId()).isEqualTo(10L);
+ assertThat(ref.getId()).isEqualTo(10);
assertThat(ref.isAnyone()).isFalse();
}
@Test
public void test_equals_and_hashCode() {
- GroupWsRef refId1 = GroupWsRef.fromId(10L);
- GroupWsRef refId2 = GroupWsRef.fromId(11L);
+ GroupWsRef refId1 = GroupWsRef.fromId(10);
+ GroupWsRef refId2 = GroupWsRef.fromId(11);
assertThat(refId1.equals(refId1)).isTrue();
- assertThat(refId1.equals(GroupWsRef.fromId(10L))).isTrue();
- assertThat(refId1.hashCode()).isEqualTo(GroupWsRef.fromId(10L).hashCode());
+ assertThat(refId1.equals(GroupWsRef.fromId(10))).isTrue();
+ assertThat(refId1.hashCode()).isEqualTo(GroupWsRef.fromId(10).hashCode());
assertThat(refId1.equals(refId2)).isFalse();
GroupWsRef refName1 = fromName("ORG1", "the-group");
@Test
public void test_toString() {
- GroupWsRef refId = GroupWsRef.fromId(10L);
+ GroupWsRef refId = GroupWsRef.fromId(10);
assertThat(refId.toString()).isEqualTo("GroupWsRef{id=10, organizationKey='null', name='null'}");
}
*/
private boolean guarded = false;
/** If of the user for whom the organization was created, can be null. */
- private Long userId;
+ private Integer userId;
private long createdAt;
private long updatedAt;
}
@CheckForNull
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
- public OrganizationDto setUserId(@Nullable Long userId) {
+ public OrganizationDto setUserId(@Nullable Integer userId) {
this.userId = userId;
return this;
}
/**
* Loads all the permissions granted to logged-in user for the specified organization
*/
- public Set<String> selectOrganizationPermissions(DbSession dbSession, String organizationUuid, long userId) {
+ public Set<String> selectOrganizationPermissions(DbSession dbSession, String organizationUuid, int userId) {
return mapper(dbSession).selectOrganizationPermissions(organizationUuid, userId);
}
* is deleted. The anyone virtual group is not taken into account.
*/
public int countUsersWithGlobalPermissionExcludingGroup(DbSession dbSession, String organizationUuid,
- String permission, long excludedGroupId) {
+ String permission, int excludedGroupId) {
return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroup(organizationUuid, permission, excludedGroupId);
}
* is deleted. The anyone virtual group is not taken into account.
*/
public int countUsersWithGlobalPermissionExcludingUser(DbSession dbSession, String organizationUuid,
- String permission, long excludedUSerId) {
- return mapper(dbSession).countUsersWithGlobalPermissionExcludingUser(organizationUuid, permission, excludedUSerId);
+ String permission, int excludedUserId) {
+ return mapper(dbSession).countUsersWithGlobalPermissionExcludingUser(organizationUuid, permission, excludedUserId);
}
/**
* The number of users who will still have the permission if the user {@code userId}
* is removed from group {@code groupId}. The anyone virtual group is not taken into account.
- * Contrary to {@link #countUsersWithGlobalPermissionExcludingUser(DbSession, String, String, long)}, user
+ * Contrary to {@link #countUsersWithGlobalPermissionExcludingUser(DbSession, String, String, int)}, user
* still exists and may have the permission directly or through other groups.
*/
public int countUsersWithGlobalPermissionExcludingGroupMember(DbSession dbSession, String organizationUuid,
- String permission, long groupId, long userId) {
+ String permission, int groupId, int userId) {
return mapper(dbSession).countUsersWithGlobalPermissionExcludingGroupMember(organizationUuid, permission, groupId, userId);
}
/**
* The number of users who will still have the permission if the permission {@code permission}
* is removed from user {@code userId}. The anyone virtual group is not taken into account.
- * Contrary to {@link #countUsersWithGlobalPermissionExcludingUser(DbSession, String, String, long)}, user
+ * Contrary to {@link #countUsersWithGlobalPermissionExcludingUser(DbSession, String, String, int)}, user
* still exists and may have the permission through groups.
*/
public int countUsersWithGlobalPermissionExcludingUserPermission(DbSession dbSession, String organizationUuid,
- String permission, long userId) {
+ String permission, int userId) {
return mapper(dbSession).countUsersWithGlobalPermissionExcludingUserPermission(organizationUuid, permission, userId);
}
* <br/>
* Group membership is taken into account. Anonymous privileges are ignored.
*/
- public Set<String> selectOrganizationUuidsOfUserWithGlobalPermission(DbSession dbSession, long userId, String permission) {
+ public Set<String> selectOrganizationUuidsOfUserWithGlobalPermission(DbSession dbSession, int userId, String permission) {
return mapper(dbSession).selectOrganizationUuidsOfUserWithGlobalPermission(userId, permission);
}
* Keep only authorized user that have the given permission on a given project.
* Please Note that if the permission is 'Anyone' is NOT taking into account by thie method.
*/
- public Collection<Long> keepAuthorizedUsersForRoleAndProject(DbSession dbSession, Collection<Long> userIds, String role, long projectId) {
+ public Collection<Integer> keepAuthorizedUsersForRoleAndProject(DbSession dbSession, Collection<Integer> userIds, String role, long projectId) {
return executeLargeInputs(
userIds,
partitionOfIds -> mapper(dbSession).keepAuthorizedUsersForRoleAndProject(role, projectId, partitionOfIds));
*/
public interface AuthorizationMapper {
- Set<String> selectOrganizationPermissions(@Param("organizationUuid") String organizationUuid, @Param("userId") long userId);
+ Set<String> selectOrganizationPermissions(@Param("organizationUuid") String organizationUuid, @Param("userId") int userId);
Set<String> selectOrganizationPermissionsOfAnonymous(@Param("organizationUuid") String organizationUuid);
int countUsersWithGlobalPermissionExcludingGroup(@Param("organizationUuid") String organizationUuid,
- @Param("permission") String permission, @Param("excludedGroupId") long excludedGroupId);
+ @Param("permission") String permission, @Param("excludedGroupId") int excludedGroupId);
int countUsersWithGlobalPermissionExcludingUser(@Param("organizationUuid") String organizationUuid, @Param("permission") String permission,
- @Param("excludedUserId") long excludedUserId);
+ @Param("excludedUserId") int excludedUserId);
int countUsersWithGlobalPermissionExcludingGroupMember(@Param("organizationUuid") String organizationUuid,
- @Param("permission") String permission, @Param("groupId") long groupId, @Param("userId") long userId);
+ @Param("permission") String permission, @Param("groupId") int groupId, @Param("userId") int userId);
int countUsersWithGlobalPermissionExcludingUserPermission(@Param("organizationUuid") String organizationUuid,
- @Param("permission") String permission, @Param("userId") long userId);
+ @Param("permission") String permission, @Param("userId") int userId);
- Set<String> selectOrganizationUuidsOfUserWithGlobalPermission(@Param("userId") long userId, @Param("permission") String permission);
+ Set<String> selectOrganizationUuidsOfUserWithGlobalPermission(@Param("userId") int userId, @Param("permission") String permission);
Set<Long> keepAuthorizedProjectIdsForAnonymous(@Param("role") String role, @Param("componentIds") Collection<Long> componentIds);
- Set<Long> keepAuthorizedProjectIdsForUser(@Param("userId") long userId, @Param("role") String role, @Param("componentIds") Collection<Long> componentIds);
+ Set<Long> keepAuthorizedProjectIdsForUser(@Param("userId") int userId, @Param("role") String role, @Param("componentIds") Collection<Long> componentIds);
- List<Long> keepAuthorizedUsersForRoleAndProject(@Param("role") String role, @Param("componentId") long componentId, @Param("userIds") List<Long> userIds);
+ List<Integer> keepAuthorizedUsersForRoleAndProject(@Param("role") String role, @Param("componentId") long componentId, @Param("userIds") List<Integer> userIds);
}
* Select global or project permission of given groups and organization. Anyone virtual group is supported
* through the value "zero" (0L) in {@code groupIds}.
*/
- public List<GroupPermissionDto> selectByGroupIds(DbSession dbSession, String organizationUuid, List<Long> groupIds, @Nullable Long projectId) {
+ public List<GroupPermissionDto> selectByGroupIds(DbSession dbSession, String organizationUuid, List<Integer> groupIds, @Nullable Long projectId) {
return executeLargeInputs(groupIds, groups -> mapper(dbSession).selectByGroupIds(organizationUuid, groups, projectId));
}
* Selects the global permissions granted to group. An empty list is returned if the
* group does not exist.
*/
- public List<String> selectGlobalPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Long groupId) {
+ public List<String> selectGlobalPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Integer groupId) {
return mapper(session).selectGlobalPermissionsOfGroup(organizationUuid, groupId);
}
* Selects the permissions granted to group and project. An empty list is returned if the
* group or project do not exist.
*/
- public List<String> selectProjectPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Long groupId, long projectId) {
+ public List<String> selectProjectPermissionsOfGroup(DbSession session, String organizationUuid, @Nullable Integer groupId, long projectId) {
return mapper(session).selectProjectPermissionsOfGroup(organizationUuid, groupId, projectId);
}
* @param groupId if null, then anyone, else id of group
* @param rootComponentId if null, then global permission, else id of root component (project)
*/
- public void delete(DbSession dbSession, String permission, String organizationUuid, @Nullable Long groupId, @Nullable Long rootComponentId) {
+ public void delete(DbSession dbSession, String permission, String organizationUuid, @Nullable Integer groupId, @Nullable Long rootComponentId) {
mapper(dbSession).delete(permission, organizationUuid, groupId, rootComponentId);
}
public class GroupPermissionDto {
private String organizationUuid;
- private Long groupId;
+ private Integer groupId;
private Long resourceId;
private String role;
- public Long getGroupId() {
+ public Integer getGroupId() {
return groupId;
}
/**
* Null when Anyone
*/
- public GroupPermissionDto setGroupId(@Nullable Long groupId) {
+ public GroupPermissionDto setGroupId(@Nullable Integer groupId) {
this.groupId = groupId;
return this;
}
int countGroupsByQuery(@Param("organizationUuid") String organizationUuid, @Param("query") PermissionQuery query);
List<GroupPermissionDto> selectByGroupIds(@Param("organizationUuid") String organizationUuid,
- @Param("groupIds") List<Long> groupIds, @Nullable @Param("projectId") Long projectId);
+ @Param("groupIds") List<Integer> groupIds, @Nullable @Param("projectId") Long projectId);
void groupsCountByProjectIdAndPermission(Map<String, Object> parameters, ResultHandler resultHandler);
void deleteByRootComponentId(@Param("rootComponentId") long componentId);
void delete(@Param("permission") String permission, @Param("organizationUuid") String organizationUuid,
- @Nullable @Param("groupId") Long groupId, @Nullable @Param("rootComponentId") Long rootComponentId);
+ @Nullable @Param("groupId") Integer groupId, @Nullable @Param("rootComponentId") Long rootComponentId);
List<String> selectGlobalPermissionsOfGroup(@Param("organizationUuid") String organizationUuid,
- @Nullable @Param("groupId") Long groupId);
+ @Nullable @Param("groupId") Integer groupId);
List<String> selectProjectPermissionsOfGroup(@Param("organizationUuid") String organizationUuid,
- @Nullable @Param("groupId") Long groupId, @Param("projectId") long projectId);
+ @Nullable @Param("groupId") Integer groupId, @Param("projectId") long projectId);
void deleteByOrganization(@Param("organizationUuid") String organizationUuid);
* Shortcut over {@link #select(DbSession, String, PermissionQuery, Collection)} to return only distinct user
* ids, keeping the same order.
*/
- public List<Long> selectUserIds(DbSession dbSession, String organizationUuid, PermissionQuery query) {
+ public List<Integer> selectUserIds(DbSession dbSession, String organizationUuid, PermissionQuery query) {
List<UserPermissionDto> dtos = select(dbSession, organizationUuid, query, null);
return dtos.stream()
.map(UserPermissionDto::getUserId)
*
* @return the global permissions. An empty list is returned if user or organization do not exist.
*/
- public List<String> selectGlobalPermissionsOfUser(DbSession dbSession, long userId, String organizationUuid) {
+ public List<String> selectGlobalPermissionsOfUser(DbSession dbSession, int userId, String organizationUuid) {
return mapper(dbSession).selectGlobalPermissionsOfUser(userId, organizationUuid);
}
*
* @return the project permissions. An empty list is returned if project or user do not exist.
*/
- public List<String> selectProjectPermissionsOfUser(DbSession dbSession, long userId, long projectId) {
+ public List<String> selectProjectPermissionsOfUser(DbSession dbSession, int userId, long projectId) {
return mapper(dbSession).selectProjectPermissionsOfUser(userId, projectId);
}
/**
* Removes a single global permission from user
*/
- public void deleteGlobalPermission(DbSession dbSession, long userId, String permission, String organizationUuid) {
+ public void deleteGlobalPermission(DbSession dbSession, int userId, String permission, String organizationUuid) {
mapper(dbSession).deleteGlobalPermission(userId, permission, organizationUuid);
}
/**
* Removes a single project permission from user
*/
- public void deleteProjectPermission(DbSession dbSession, long userId, String permission, long projectId) {
+ public void deleteProjectPermission(DbSession dbSession, int userId, String permission, long projectId) {
mapper(dbSession).deleteProjectPermission(userId, permission, projectId);
}
private String organizationUuid;
private String permission;
- private long userId;
+ private int userId;
private Long componentId;
public UserPermissionDto() {
// used by MyBatis
}
- public UserPermissionDto(String organizationUuid, String permission, long userId, @Nullable Long componentId) {
+ public UserPermissionDto(String organizationUuid, String permission, int userId, @Nullable Long componentId) {
this.organizationUuid = organizationUuid;
this.permission = permission;
this.userId = userId;
return permission;
}
- public long getUserId() {
+ public int getUserId() {
return userId;
}
void insert(UserPermissionDto dto);
- void deleteGlobalPermission(@Param("userId") long userId, @Param("permission") String permission,
+ void deleteGlobalPermission(@Param("userId") int userId, @Param("permission") String permission,
@Param("organizationUuid") String organizationUuid);
- void deleteProjectPermission(@Param("userId") long userId, @Param("permission") String permission,
+ void deleteProjectPermission(@Param("userId") int userId, @Param("permission") String permission,
@Param("projectId") long projectId);
void deleteProjectPermissions(@Param("projectId") long projectId);
- List<String> selectGlobalPermissionsOfUser(@Param("userId") long userId, @Param("organizationUuid") String organizationUuid);
+ List<String> selectGlobalPermissionsOfUser(@Param("userId") int userId, @Param("organizationUuid") String organizationUuid);
- List<String> selectProjectPermissionsOfUser(@Param("userId") long userId, @Param("projectId") long projectId);
+ List<String> selectProjectPermissionsOfUser(@Param("userId") int userId, @Param("projectId") long projectId);
void deleteByOrganization(@Param("organizationUuid") String organizationUuid);
}
/**
* @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 Long groupId) {
+ public boolean hasGroupsWithPermission(DbSession dbSession, long templateId, String permission, @Nullable Integer groupId) {
return mapper(dbSession).countGroupsWithPermission(templateId, permission, groupId) > 0;
}
return permissionTemplate;
}
- public void insertUserPermission(DbSession session, Long templateId, Long userId, String permission) {
+ public void insertUserPermission(DbSession session, Long templateId, Integer userId, String permission) {
PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
.setTemplateId(templateId)
.setUserId(userId)
session.commit();
}
- public void deleteUserPermission(DbSession session, Long templateId, Long userId, String permission) {
+ public void deleteUserPermission(DbSession session, Long templateId, Integer userId, String permission) {
PermissionTemplateUserDto permissionTemplateUser = new PermissionTemplateUserDto()
.setTemplateId(templateId)
.setPermission(permission)
session.commit();
}
- public void insertGroupPermission(DbSession session, long templateId, @Nullable Long groupId, String permission) {
+ public void insertGroupPermission(DbSession session, long templateId, @Nullable Integer groupId, String permission) {
PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto()
.setTemplateId(templateId)
.setPermission(permission)
mapper(session).insertGroupPermission(permissionTemplateGroup);
}
- public void deleteGroupPermission(DbSession session, Long templateId, @Nullable Long groupId, String permission) {
+ public void deleteGroupPermission(DbSession session, Long templateId, @Nullable Integer groupId, String permission) {
PermissionTemplateGroupDto permissionTemplateGroup = new PermissionTemplateGroupDto()
.setTemplateId(templateId)
.setPermission(permission)
return mapper(dbSession).selectByName(organizationUuid, name.toUpperCase(Locale.ENGLISH));
}
- public List<String> selectPotentialPermissionsByUserIdAndTemplateId(DbSession dbSession, @Nullable Long currentUserId, long templateId) {
+ public List<String> selectPotentialPermissionsByUserIdAndTemplateId(DbSession dbSession, @Nullable Integer currentUserId, long templateId) {
return mapper(dbSession).selectPotentialPermissionsByUserIdAndTemplateId(currentUserId, templateId);
}
/**
* Remove a group from all templates (used when removing a group)
*/
- public void deleteByGroup(DbSession session, long groupId) {
+ public void deleteByGroup(DbSession session, int groupId) {
session.getMapper(PermissionTemplateMapper.class).deleteByGroupId(groupId);
}
public class PermissionTemplateGroupDto {
private Long id;
private Long templateId;
- private Long groupId;
+ private Integer groupId;
private String permission;
private String groupName;
private Date createdAt;
return this;
}
- public Long getGroupId() {
+ public Integer getGroupId() {
return groupId;
}
- public PermissionTemplateGroupDto setGroupId(@Nullable Long groupId) {
+ public PermissionTemplateGroupDto setGroupId(@Nullable Integer groupId) {
this.groupId = groupId;
return this;
}
void insertGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup);
- void deleteByGroupId(long groupId);
+ void deleteByGroupId(int groupId);
PermissionTemplateDto selectByName(@Param("organizationUuid") String organizationUuid, @Param("name") String name);
void groupsCountByTemplateIdAndPermission(Map<String, Object> parameters, ResultHandler resultHandler);
- List<String> selectPotentialPermissionsByUserIdAndTemplateId(@Param("userId") @Nullable Long currentUserId, @Param("templateId") long templateId);
+ List<String> selectPotentialPermissionsByUserIdAndTemplateId(@Param("userId") @Nullable Integer currentUserId, @Param("templateId") long templateId);
- int countGroupsWithPermission(@Param("templateId") long templateId, @Param("permission") String permission, @Nullable @Param("groupId") Long groupId);
+ int countGroupsWithPermission(@Param("templateId") long templateId, @Param("permission") String permission, @Nullable @Param("groupId") Integer groupId);
List<Long> selectTemplateIdsByOrganization(@Param("organizationUuid") String organizationUuid);
public class PermissionTemplateUserDto {
private Long id;
private Long templateId;
- private Long userId;
+ private Integer userId;
private String permission;
private String userName;
private String userLogin;
return this;
}
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
- public PermissionTemplateUserDto setUserId(Long userId) {
+ public PermissionTemplateUserDto setUserId(Integer userId) {
this.userId = userId;
return this;
}
}
private void save(PropertiesMapper mapper,
- String key, @Nullable Long userId, @Nullable Long componentId,
+ String key, @Nullable Integer userId, @Nullable Long componentId,
@Nullable String value) {
checkKey(key);
List<PropertyDto> selectDescendantModuleProperties(@Param("moduleUuid") String moduleUuid, @Param(value = "scope") String scope,
@Param(value = "excludeDisabled") boolean excludeDisabled);
- void insertAsEmpty(@Param("key") String key, @Nullable @Param("userId") Long userId, @Nullable @Param("componentId") Long componentId,
+ void insertAsEmpty(@Param("key") String key, @Nullable @Param("userId") Integer userId, @Nullable @Param("componentId") Long componentId,
@Param("now") long now);
- void insertAsText(@Param("key") String key, @Nullable @Param("userId") Long userId, @Nullable @Param("componentId") Long componentId,
+ void insertAsText(@Param("key") String key, @Nullable @Param("userId") Integer userId, @Nullable @Param("componentId") Long componentId,
@Param("value") String value, @Param("now") long now);
- void insertAsClob(@Param("key") String key, @Nullable @Param("userId") Long userId, @Nullable @Param("componentId") Long componentId,
+ void insertAsClob(@Param("key") String key, @Nullable @Param("userId") Integer userId, @Nullable @Param("componentId") Long componentId,
@Param("value") String value, @Param("now") long now);
- int delete(@Param("key") String key, @Nullable @Param("userId") Long userId, @Nullable @Param("componentId") Long componentId);
+ int delete(@Param("key") String key, @Nullable @Param("userId") Integer userId, @Nullable @Param("componentId") Long componentId);
int deleteById(long id);
private String key;
private String value;
private Long resourceId;
- private Long userId;
+ private Integer userId;
public String getKey() {
return key;
}
@CheckForNull
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
- public PropertyDto setUserId(@Nullable Long userId) {
+ public PropertyDto setUserId(@Nullable Integer userId) {
this.userId = userId;
return this;
}
return newPropertyDto(component.getId(), user.getId());
}
- private static PropertyDto newPropertyDto(@Nullable Long componentId, @Nullable Long userId) {
+ private static PropertyDto newPropertyDto(@Nullable Long componentId, @Nullable Integer userId) {
String key = String.valueOf(cursor);
cursor++;
String value = String.valueOf(cursor);
return newPropertyDto(key, value, componentId, userId);
}
- private static PropertyDto newPropertyDto(String key, String value, @Nullable Long componentId, @Nullable Long userId) {
+ private static PropertyDto newPropertyDto(String key, String value, @Nullable Long componentId, @Nullable Integer userId) {
PropertyDto propertyDto = new PropertyDto()
.setKey(key)
.setValue(value);
}
@CheckForNull
- public GroupDto selectById(DbSession dbSession, long groupId) {
+ public GroupDto selectById(DbSession dbSession, int groupId) {
return mapper(dbSession).selectById(groupId);
}
- public List<GroupDto> selectByIds(DbSession dbSession, List<Long> ids) {
+ public List<GroupDto> selectByIds(DbSession dbSession, List<Integer> ids) {
return executeLargeInputs(ids, mapper(dbSession)::selectByIds);
}
- public void deleteById(DbSession dbSession, long groupId) {
+ public void deleteById(DbSession dbSession, int groupId) {
mapper(dbSession).deleteById(groupId);
}
public class GroupDto {
- private Long id;
+ private Integer id;
private String name;
private String description;
private String organizationUuid;
private Date createdAt;
private Date updatedAt;
- public Long getId() {
+ public Integer getId() {
return id;
}
- public GroupDto setId(Long id) {
+ public GroupDto setId(Integer id) {
this.id = id;
return this;
}
public interface GroupMapper {
@CheckForNull
- GroupDto selectById(long groupId);
+ GroupDto selectById(int groupId);
List<GroupDto> selectByUserLogin(String userLogin);
*
* @return 1 or 0. Either because the organization uuid is not the one of the group or because the group does not exist
*/
- int countGroupByOrganizationAndId(@Param("organizationUuid") String organizationUuid, @Param("groupId") long groupId);
+ int countGroupByOrganizationAndId(@Param("organizationUuid") String organizationUuid, @Param("groupId") int groupId);
- void deleteById(long groupId);
+ void deleteById(int groupId);
void deleteByOrganization(@Param("organizationUuid") String organizationUuid);
List<GroupDto> selectByOrganizationUuid(@Param("organizationUuid") String organizationUuid);
- List<GroupDto> selectByIds(@Param("ids") List<Long> ids);
+ List<GroupDto> selectByIds(@Param("ids") List<Integer> ids);
}
public class GroupMembershipDao implements Dao {
- public List<GroupMembershipDto> selectGroups(DbSession session, GroupMembershipQuery query, Long userId, int offset, int limit) {
+ public List<GroupMembershipDto> selectGroups(DbSession session, GroupMembershipQuery query, Integer userId, int offset, int limit) {
Map<String, Object> params = ImmutableMap.of("query", query, "userId", userId);
return mapper(session).selectGroups(params, new RowBounds(offset, limit));
}
- public int countGroups(DbSession session, GroupMembershipQuery query, Long userId) {
+ public int countGroups(DbSession session, GroupMembershipQuery query, Integer userId) {
Map<String, Object> params = ImmutableMap.of("query", query, "userId", userId);
return mapper(session).countGroups(params);
}
return mapper(session).countMembers(params);
}
- public Map<String, Integer> countUsersByGroups(DbSession session, Collection<Long> groupIds) {
+ public Map<String, Integer> countUsersByGroups(DbSession session, Collection<Integer> groupIds) {
Map<String, Integer> result = Maps.newHashMap();
executeLargeInputs(
groupIds,
return result;
}
- public List<Long> selectGroupIdsByUserId(DbSession dbSession, long userId) {
+ public List<Integer> selectGroupIdsByUserId(DbSession dbSession, int userId) {
return mapper(dbSession).selectGroupIdsByUserId(userId);
}
private Long id;
private String name;
private String description;
- private Long userId;
+ private Integer userId;
public Long getId() {
return id;
}
@CheckForNull
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
- public GroupMembershipDto setUserId(@Nullable Long userId) {
+ public GroupMembershipDto setUserId(@Nullable Integer userId) {
this.userId = userId;
return this;
}
int countMembers(Map<String, Object> params);
- List<GroupUserCount> countUsersByGroup(@Param("groupIds") List<Long> groupIds);
+ List<GroupUserCount> countUsersByGroup(@Param("groupIds") List<Integer> groupIds);
List<LoginGroup> selectGroupsByLogins(@Param("logins") List<String> logins);
- List<Long> selectGroupIdsByUserId(@Param("userId") long userId);
+ List<Integer> selectGroupIdsByUserId(@Param("userId") int userId);
}
* All the projects on which the user has {@code permission}, directly or through
* groups.
*/
- public List<Long> selectComponentIdsByPermissionAndUserId(DbSession dbSession, String permission, long userId) {
+ public List<Long> selectComponentIdsByPermissionAndUserId(DbSession dbSession, String permission, int userId) {
return mapper(dbSession).selectComponentIdsByPermissionAndUserId(permission, userId);
}
- public void deleteGroupRolesByGroupId(DbSession session, long groupId) {
+ public void deleteGroupRolesByGroupId(DbSession session, int groupId) {
mapper(session).deleteGroupRolesByGroupId(groupId);
}
public interface RoleMapper {
- List<Long> selectComponentIdsByPermissionAndUserId(@Param("permission") String permission, @Param("userId") long userId);
+ List<Long> selectComponentIdsByPermissionAndUserId(@Param("permission") String permission, @Param("userId") int userId);
- void deleteGroupRolesByGroupId(long groupId);
+ void deleteGroupRolesByGroupId(int groupId);
}
this.system2 = system2;
}
- public UserDto selectUserById(long userId) {
+ public UserDto selectUserById(int userId) {
try (DbSession session = mybatis.openSession(false)) {
return selectUserById(session, userId);
}
}
- public UserDto selectUserById(DbSession session, long userId) {
+ public UserDto selectUserById(DbSession session, int userId) {
return mapper(session).selectUser(userId);
}
*
* Used by the Governance plugin
*/
- public List<UserDto> selectByIds(DbSession session, Collection<Long> ids) {
+ public List<UserDto> selectByIds(DbSession session, Collection<Integer> ids) {
return executeLargeInputs(ids, mapper(session)::selectByIds);
}
public class UserDto {
public static final char SCM_ACCOUNTS_SEPARATOR = '\n';
- private Long id;
+ private Integer id;
private String login;
private String name;
private String email;
private boolean local = true;
private boolean root = false;
- public Long getId() {
+ public Integer getId() {
return id;
}
- public UserDto setId(Long id) {
+ public UserDto setId(Integer id) {
this.id = id;
return this;
}
return dto;
}
- public void delete(DbSession session, long groupId, long userId) {
+ public void delete(DbSession session, int groupId, int userId) {
mapper(session).delete(groupId, userId);
}
- public void deleteByGroupId(DbSession session, long groupId) {
+ public void deleteByGroupId(DbSession session, int groupId) {
mapper(session).deleteByGroupId(groupId);
}
public class UserGroupDto {
- private Long userId;
- private Long groupId;
+ private int userId;
+ private int groupId;
- public Long getUserId() {
+ public int getUserId() {
return userId;
}
- public UserGroupDto setUserId(Long userId) {
+ public UserGroupDto setUserId(int userId) {
this.userId = userId;
return this;
}
- public Long getGroupId() {
+ public int getGroupId() {
return groupId;
}
- public UserGroupDto setGroupId(Long groupId) {
+ public UserGroupDto setGroupId(int groupId) {
this.groupId = groupId;
return this;
}
void insert(UserGroupDto dto);
- void delete(@Param("groupId") long groupId, @Param("userId") long userId);
+ void delete(@Param("groupId") int groupId, @Param("userId") int userId);
- void deleteByGroupId(@Param("groupId") long groupId);
+ void deleteByGroupId(@Param("groupId") int groupId);
}
List<UserDto> selectNullableByScmAccountOrLoginOrEmail(@Param("scmAccount") String scmAccountOrLoginOrEmail, @Param("likeScmAccount") String likeScmAccount);
@CheckForNull
- UserDto selectUser(long userId);
+ UserDto selectUser(int userId);
/**
* Select user by login. Note that disabled users are ignored.
List<UserDto> selectByLogins(List<String> logins);
- List<UserDto> selectByIds(@Param("ids") List<Long> ids);
+ List<UserDto> selectByIds(@Param("ids") List<Integer> ids);
long countByEmail(String email);
void setRoot(@Param("login") String login, @Param("root") boolean root, @Param("now") long now);
- void removeUserFromGroups(long userId);
+ void removeUserFromGroups(int userId);
- void deleteUserProperties(long userId);
+ void deleteUserProperties(int userId);
- void deleteUserRoles(long userId);
+ void deleteUserRoles(int userId);
void deletePropertiesMatchingLogin(@Param("propertyKeys") List<String> propertyKeys, @Param("login") String login);
- void deactivateUser(@Param("id") long userId, @Param("now") long now);
+ void deactivateUser(@Param("id") int userId, @Param("now") long now);
}
public class UserMembershipDto {
private Long id;
- private Long groupId;
+ private Integer groupId;
private String login;
private String name;
}
@CheckForNull
- public Long getGroupId() {
+ public Integer getGroupId() {
return groupId;
}
- public UserMembershipDto setGroupId(@Nullable Long groupId) {
+ public UserMembershipDto setGroupId(@Nullable Integer groupId) {
this.groupId = groupId;
return this;
}
public static final String OUT = "OUT";
public static final Set<String> AVAILABLE_MEMBERSHIPS = ImmutableSet.of(ANY, IN, OUT);
- private final long groupId;
+ private final int groupId;
private final String membership;
private final String memberSearch;
this.pageIndex = builder.pageIndex;
}
- public long groupId() {
+ public int groupId() {
return groupId;
}
}
public static class Builder {
- private Long groupId;
+ private Integer groupId;
private String membership;
private String memberSearch;
private Builder() {
}
- public Builder groupId(Long groupId) {
+ public Builder groupId(Integer groupId) {
this.groupId = groupId;
return this;
}
where
gr.organization_uuid=#{organizationUuid,jdbcType=VARCHAR} and
gr.resource_id is null and
- gu.user_id=#{userId,jdbcType=BIGINT}
+ gu.user_id=#{userId,jdbcType=INTEGER}
union
from user_roles ur
where
ur.organization_uuid=#{organizationUuid,jdbcType=VARCHAR} and
- ur.user_id=#{userId,jdbcType=BIGINT}
+ ur.user_id=#{userId,jdbcType=INTEGER}
and ur.resource_id is null
</select>
inner join groups_users gu on gr.group_id=gu.group_id
where
gr.resource_id=#{rootComponentId,jdbcType=BIGINT} and
- gu.user_id=#{userId,jdbcType=BIGINT}
+ gu.user_id=#{userId,jdbcType=INTEGER}
union
select gr.role
from user_roles ur
where
ur.resource_id=#{rootComponentId,jdbcType=BIGINT} and
- ur.user_id=#{userId,jdbcType=BIGINT}
+ ur.user_id=#{userId,jdbcType=INTEGER}
</select>
<select id="selectRootComponentPermissionsOfAnonymous" parameterType="map" resultType="string">
gr.role = #{permission,jdbcType=VARCHAR} and
gr.resource_id is null and
gr.group_id is not null and
- gr.group_id != #{excludedGroupId,jdbcType=BIGINT}
+ gr.group_id != #{excludedGroupId,jdbcType=INTEGER}
union
gr.role = #{permission,jdbcType=VARCHAR} and
gr.resource_id is null and
gr.group_id is not null and
- gu.user_id != #{excludedUserId,jdbcType=BIGINT}
+ gu.user_id != #{excludedUserId,jdbcType=INTEGER}
union
ur.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and
ur.resource_id is null and
ur.role = #{permission,jdbcType=VARCHAR} and
- ur.user_id != #{excludedUserId,jdbcType=BIGINT}
+ ur.user_id != #{excludedUserId,jdbcType=INTEGER}
) remaining
</select>
gr.role = #{permission,jdbcType=VARCHAR} and
gr.resource_id is null and
gr.group_id is not null and
- (gu.group_id != #{groupId,jdbcType=BIGINT} or gu.user_id != #{userId,jdbcType=BIGINT})
+ (gu.group_id != #{groupId,jdbcType=INTEGER} or gu.user_id != #{userId,jdbcType=INTEGER})
union
ur.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and
ur.resource_id is null and
ur.role = #{permission,jdbcType=VARCHAR} and
- ur.user_id != #{userId,jdbcType=BIGINT}
+ ur.user_id != #{userId,jdbcType=INTEGER}
) remaining
</select>
gr.role = #{permission,jdbcType=VARCHAR} and
gr.resource_id is null and
gr.group_id is not null and
- gu.user_id = #{userId,jdbcType=BIGINT}
+ gu.user_id = #{userId,jdbcType=INTEGER}
union
where
ur.resource_id is null and
ur.role = #{permission,jdbcType=VARCHAR} and
- ur.user_id = #{userId,jdbcType=BIGINT}
+ ur.user_id = #{userId,jdbcType=INTEGER}
</select>
<select id="keepAuthorizedProjectIdsForUser" parameterType="map" resultType="long">
INNER JOIN projects p on p.id = ur.resource_id
WHERE
ur.role=#{role,jdbcType=VARCHAR}
- and ur.user_id=#{userId,jdbcType=BIGINT} and
+ and ur.user_id=#{userId,jdbcType=INTEGER} and
<foreach collection="componentIds" open="(" close=")" item="element" index="index" separator=" or ">
p.id=#{element,jdbcType=BIGINT}
</foreach>
where
gr.role=#{role,jdbcType=VARCHAR}
and (gr.group_id is null or gr.group_id in (select gu.group_id from groups_users gu where
- gu.user_id=#{userId,jdbcType=BIGINT}))
+ gu.user_id=#{userId,jdbcType=INTEGER}))
UNION
SELECT p.uuid as root_project_uuid
FROM user_roles ur
INNER JOIN projects p on p.id = ur.resource_id AND p.module_uuid IS NULL
where
ur.role=#{role,jdbcType=VARCHAR}
- and ur.user_id = #{userId,jdbcType=BIGINT}
+ and ur.user_id = #{userId,jdbcType=INTEGER}
</when>
<otherwise>
SELECT p.uuid as root_project_uuid
</choose>
</select>
- <select id="keepAuthorizedUsersForRoleAndProject" parameterType="map" resultType="Long">
+ <select id="keepAuthorizedUsersForRoleAndProject" parameterType="map" resultType="int">
SELECT gu.user_id
FROM groups_users gu
INNER JOIN group_roles gr ON gr.group_id=gu.group_id
where
sub.groupId in
<foreach collection="groupIds" open="(" close=")" item="groupId" separator=",">
- #{groupId,jdbcType=BIGINT}
+ #{groupId,jdbcType=INTEGER}
</foreach>
<if test="projectId != null">
and sub.componentId=#{projectId,jdbcType=BIGINT}
gr.resource_id is null and
<choose>
<when test="groupId != null">
- gr.group_id = #{groupId,jdbcType=BIGINT}
+ gr.group_id = #{groupId,jdbcType=INTEGER}
</when>
<otherwise>
gr.group_id is null
gr.resource_id = #{projectId,jdbcType=BIGINT} and
<choose>
<when test="groupId != null">
- gr.group_id = #{groupId,jdbcType=BIGINT}
+ gr.group_id = #{groupId,jdbcType=INTEGER}
</when>
<otherwise>
gr.group_id is null
role
) values (
#{organizationUuid,jdbcType=VARCHAR},
- #{groupId,jdbcType=BIGINT},
+ #{groupId,jdbcType=INTEGER},
#{resourceId,jdbcType=BIGINT},
#{role,jdbcType=VARCHAR}
)
and
<choose>
<when test="groupId != null">
- group_id=#{groupId,jdbcType=BIGINT}
+ group_id=#{groupId,jdbcType=INTEGER}
</when>
<otherwise>
group_id is null
from user_roles ur
where
ur.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and
- ur.user_id = #{userId,jdbcType=BIGINT} and
+ ur.user_id = #{userId,jdbcType=INTEGER} and
ur.resource_id is null
</select>
select ur.role
from user_roles ur
where
- ur.user_id = #{userId,jdbcType=BIGINT} and
+ ur.user_id = #{userId,jdbcType=INTEGER} and
ur.resource_id = #{projectId,jdbcType=BIGINT}
</select>
role
) values (
#{organizationUuid,jdbcType=VARCHAR},
- #{userId,jdbcType=BIGINT},
+ #{userId,jdbcType=INTEGER},
#{componentId,jdbcType=BIGINT},
#{permission,jdbcType=VARCHAR}
)
delete from user_roles
where
role = #{permission,jdbcType=VARCHAR} and
- user_id = #{userId,jdbcType=BIGINT} and
+ user_id = #{userId,jdbcType=INTEGER} and
organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and
resource_id is null
</delete>
delete from user_roles
where
role = #{permission,jdbcType=VARCHAR} and
- user_id = #{userId,jdbcType=BIGINT} and
+ user_id = #{userId,jdbcType=INTEGER} and
resource_id = #{projectId,jdbcType=BIGINT}
</delete>
INSERT INTO perm_templates_groups (template_id, group_id, permission_reference, created_at, updated_at)
VALUES (
#{templateId,jdbcType=BIGINT},
- #{groupId,jdbcType=BIGINT},
+ #{groupId,jdbcType=INTEGER},
#{permission,jdbcType=VARCHAR},
#{createdAt,jdbcType=TIMESTAMP},
#{updatedAt,jdbcType=TIMESTAMP}
)
</insert>
- <delete id="deleteByGroupId" parameterType="long">
+ <delete id="deleteByGroupId" parameterType="int">
delete from perm_templates_groups
- where group_id = #{groupId,jdbcType=BIGINT}
+ where group_id = #{groupId,jdbcType=INTEGER}
</delete>
<select id="selectUserLoginsByQueryAndTemplate" parameterType="map" resultType="string">
and p.resource_id=#{query.componentId}
</if>
<if test="query.userId() != null">
- and p.user_id=#{query.userId}
+ and p.user_id=#{query.userId,jdbcType=INTEGER}
</if>
</where>
</select>
values (
#{key},
#{componentId},
- #{userId},
+ #{userId,jdbcType=INTEGER},
${_true},
#{now}
)
values (
#{key},
#{componentId},
- #{userId},
+ #{userId,jdbcType=INTEGER},
${_false},
#{value},
#{now}
values (
#{key},
#{componentId},
- #{userId},
+ #{userId,jdbcType=INTEGER},
${_false},
#{value},
#{now}
<choose>
<when test="componentId != null && userId != null">
and resource_id=#{componentId}
- and user_id=#{userId}
+ and user_id=#{userId,jdbcType=INTEGER}
</when>
<when test="componentId != null">
and resource_id=#{componentId}
</when>
<when test="userId != null">
and resource_id is null
- and user_id=#{userId}
+ and user_id=#{userId,jdbcType=INTEGER}
</when>
<otherwise>
and resource_id is null
and resource_id=#{query.componentId}
</if>
<if test="query.userId() != null">
- and user_id=#{query.userId}
+ and user_id=#{query.userId,jdbcType=INTEGER}
</if>
</where>
</delete>
where g.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} and g.name = #{name,jdbcType=VARCHAR}
</select>
- <select id="selectByIds" parameterType="long" resultType="Group">
+ <select id="selectByIds" parameterType="int" resultType="Group">
select
<include refid="groupColumns"/>
from groups g
</foreach>
</select>
- <select id="selectById" parameterType="long" resultType="Group">
+ <select id="selectById" parameterType="int" resultType="Group">
SELECT
<include refid="groupColumns"/>
FROM groups g
</where>
</select>
- <delete id="deleteById" parameterType="long">
+ <delete id="deleteById" parameterType="int">
DELETE FROM groups
<where>
id=#{id,jdbcType=BIGINT}
from groups g
where
g.organization_uuid = #{organizationUuid,jdbcType=VARCHAR}
- and g.id = #{groupId,jdbcType=BIGINT}
+ and g.id = #{groupId,jdbcType=INTEGER}
</select>
<select id="selectByOrganizationUuid" parameterType="map" resultType="Group">
<include refid="commonClauses"/>
</select>
- <select id="countUsersByGroup" parameterType="long" resultType="org.sonar.db.user.GroupUserCount">
+ <select id="countUsersByGroup" parameterType="int" resultType="org.sonar.db.user.GroupUserCount">
SELECT g.name as groupName, count(gu.user_id) as userCount
FROM groups g
LEFT JOIN groups_users gu ON gu.group_id=g.id
<include refid="userCommonClauses"/>
</select>
- <select id="selectGroupIdsByUserId" parameterType="map" resultType="long">
+ <select id="selectGroupIdsByUserId" parameterType="map" resultType="int">
select group_id
from groups_users
where user_id = #{userId}
select ur.resource_id
from user_roles ur
<where>
- and ur.user_id = #{userId}
- and ur.role = #{permission}
+ and ur.user_id = #{userId,jdbcType=INTEGER}
+ and ur.role = #{permission,jdbcType=VARCHAR}
and ur.resource_id IS NOT NULL
</where>
UNION
from group_roles gr
inner join groups_users gu on gr.group_id=gu.group_id
<where>
- and gr.role = #{permission}
+ and gr.role = #{permission,jdbcType=VARCHAR}
and gr.resource_id is not null
- and gu.user_id=#{userId}
+ and gu.user_id=#{userId,jdbcType=INTEGER}
</where>
ORDER by resource_id
</select>
- <delete id="deleteGroupRolesByGroupId" parameterType="long">
- delete from group_roles where group_id=#{id}
+ <delete id="deleteGroupRolesByGroupId" parameterType="int">
+ delete from group_roles where group_id=#{id,jdbcType=INTEGER}
</delete>
</mapper>
user_id,
group_id
) values (
- #{userId,jdbcType=BIGINT},
- #{groupId,jdbcType=BIGINT}
+ #{userId,jdbcType=INTEGER},
+ #{groupId,jdbcType=INTEGER}
)
</insert>
<delete id="delete" parameterType="map">
delete from groups_users
- where user_id = #{userId,jdbcType=BIGINT} and
- group_id = #{groupId,jdbcType=BIGINT}
+ where user_id = #{userId,jdbcType=INTEGER} and
+ group_id = #{groupId,jdbcType=INTEGER}
</delete>
- <delete id="deleteByGroupId" parameterType="long">
+ <delete id="deleteByGroupId" parameterType="int">
delete from groups_users
- where group_id = #{groupId,jdbcType=BIGINT}
+ where group_id = #{groupId,jdbcType=INTEGER}
</delete>
</mapper>
OR u.scm_accounts like #{likeScmAccount}
</select>
- <select id="selectUser" parameterType="long" resultType="User">
+ <select id="selectUser" parameterType="int" resultType="User">
SELECT
<include refid="userColumns"/>
FROM users u
and u.login <> #{login}
</select>
- <delete id="removeUserFromGroups" parameterType="long">
+ <delete id="removeUserFromGroups" parameterType="int">
DELETE FROM groups_users WHERE user_id=#{id}
</delete>
- <delete id="deleteUserRoles" parameterType="long">
- DELETE FROM user_roles WHERE user_id=#{id}
+ <delete id="deleteUserRoles" parameterType="int">
+ DELETE FROM user_roles WHERE user_id=#{id,jdbcType=INTEGER}
</delete>
- <delete id="deleteUserProperties" parameterType="long">
- DELETE FROM properties WHERE user_id=#{id}
+ <delete id="deleteUserProperties" parameterType="int">
+ DELETE FROM properties WHERE user_id=#{id,jdbcType=BIGINT}
</delete>
<delete id="deletePropertiesMatchingLogin" parameterType="String">
DELETE FROM properties
<where>
- text_value LIKE #{login}
+ text_value LIKE #{login,jdbcType=VARCHAR}
AND prop_key IN
<foreach item="property" index="index" collection="propertyKeys" open="(" separator="," close=")">
- #{property}
+ #{property,jdbcType=VARCHAR}
</foreach>
</where>
</delete>
- <update id="deactivateUser" parameterType="long">
+ <update id="deactivateUser" parameterType="map">
UPDATE users SET
active=${_false},
email=null,
crypted_password=null,
updated_at=#{now,jdbcType=BIGINT}
WHERE
- id=#{id}
+ id=#{id,jdbcType=INTEGER}
</update>
<update id="setRoot">
crypted_password=#{cryptedPassword,jdbcType=BIGINT},
updated_at=#{updatedAt,jdbcType=BIGINT}
WHERE
- login = #{login}
+ login = #{login,jdbcType=VARCHAR}
</insert>
</mapper>
this.dbSession = db.getSession();
}
- public void add(ComponentDto componentDto, long userId) {
+ public void add(ComponentDto componentDto, int userId) {
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto()
.setKey(PROP_FAVORITE_KEY)
.setUserId(userId)
dbSession.commit();
}
- public boolean hasFavorite(ComponentDto componentDto, long userId) {
+ public boolean hasFavorite(ComponentDto componentDto, int userId) {
List<PropertyDto> result = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder()
.setKey(PROP_FAVORITE_KEY)
.setComponentId(componentDto.getId())
this.dbSession = db.getSession();
}
- public void assertExists(String channel, String dispatcher, long userId, @Nullable ComponentDto component) {
+ public void assertExists(String channel, String dispatcher, int userId, @Nullable ComponentDto component) {
List<PropertyDto> result = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder()
.setKey(String.join(".", PROP_NOTIFICATION_PREFIX, dispatcher, channel))
.setComponentId(component == null ? null : component.getId())
assertThat(result.get(0).getValue()).isEqualTo("true");
}
- public void assertDoesNotExist(String channel, String dispatcher, long userId, @Nullable ComponentDto component) {
+ public void assertDoesNotExist(String channel, String dispatcher, int userId, @Nullable ComponentDto component) {
List<PropertyDto> result = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder()
.setKey(String.join(".", PROP_NOTIFICATION_PREFIX, dispatcher, channel))
.setComponentId(component == null ? null : component.getId())
.setUrl("the url 1")
.setAvatarUrl("the avatar url 1")
.setGuarded(false)
- .setUserId(1_000L);
+ .setUserId(1_000);
private static final OrganizationDto ORGANIZATION_DTO_2 = new OrganizationDto()
.setUuid("uuid 2")
.setKey("the_key 2")
.setUrl("the url 2")
.setAvatarUrl("the avatar url 2")
.setGuarded(true)
- .setUserId(2_000L);
+ .setUserId(2_000);
private static final String PERMISSION_1 = "foo";
private static final String PERMISSION_2 = "bar";
private static final int USER = 100;
private static final Long PROJECT_ID = 300L;
private static final Long PROJECT_ID_WITHOUT_SNAPSHOT = 400L;
- private static final long MISSING_ID = -1L;
+ private static final int MISSING_ID = -1;
private static final String A_PERMISSION = "a-permission";
private static final String DOES_NOT_EXIST = "does-not-exist";
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession,
// Only 100 and 101 has 'user' role on project
- newHashSet(100L, 101L, 102L), "user", PROJECT_ID)).containsOnly(100L, 101L);
+ newHashSet(100, 101, 102), "user", PROJECT_ID)).containsOnly(100, 101);
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession,
// Only 100 and 101 has 'user' role on project
- newHashSet(100L), "user", PROJECT_ID)).containsOnly(100L);
+ newHashSet(100), "user", PROJECT_ID)).containsOnly(100);
// user does not have the role "admin"
- assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, newHashSet(100L), "admin", PROJECT_ID)).isEmpty();
+ assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, newHashSet(100), "admin", PROJECT_ID)).isEmpty();
// Empty list
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, Collections.emptySet(), "user", PROJECT_ID)).isEmpty();
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession,
// Only 100 and 101 has 'user' role on project
- newHashSet(100L, 101L, 102L), "user", PROJECT_ID)).containsOnly(100L, 101L);
+ newHashSet(100, 101, 102), "user", PROJECT_ID)).containsOnly(100, 101);
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession,
- newHashSet(100L), "user", PROJECT_ID)).containsOnly(100L);
+ newHashSet(100), "user", PROJECT_ID)).containsOnly(100);
// user does not have the role "admin"
- assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, newHashSet(100L), "admin", PROJECT_ID)).isEmpty();
+ assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, newHashSet(100), "admin", PROJECT_ID)).isEmpty();
// Empty list
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession, Collections.emptySet(), "user", PROJECT_ID)).isEmpty();
assertThat(underTest.keepAuthorizedUsersForRoleAndProject(dbSession,
// Only 100 and 101 has 'user' role on project
- newHashSet(100L, 101L, 102L), "user", PROJECT_ID)).isEmpty();
+ newHashSet(100, 101, 102), "user", PROJECT_ID)).isEmpty();
}
@Test
public class GroupPermissionDaoTest {
- private static final long ANYONE_ID = 0L;
- private static final long MISSING_ID = -1L;
+ private static final int ANYONE_ID = 0;
+ private static final int MISSING_ID = -1;
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
assertThat(underTest.selectGroupNamesByQuery(dbSession,
defaultOrganizationUuid, PermissionQuery.builder().build()))
- .doesNotContain(ANYONE)
- .containsExactly(group.getName());
+ .doesNotContain(ANYONE)
+ .containsExactly(group.getName());
}
@Test
assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(ANYONE_ID), null))
.extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getResourceId)
.containsOnly(
- tuple(0L, SCAN_EXECUTION, null),
- tuple(0L, PROVISIONING, null));
+ tuple(0, SCAN_EXECUTION, null),
+ tuple(0, PROVISIONING, null));
assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(group1.getId(), group2.getId(), ANYONE_ID), null)).hasSize(3);
assertThat(underTest.selectByGroupIds(dbSession, organizationDto.getUuid(), asList(MISSING_ID), null)).isEmpty();
assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(ANYONE_ID), project.getId()))
.extracting(GroupPermissionDto::getGroupId, GroupPermissionDto::getRole, GroupPermissionDto::getResourceId)
- .containsOnly(tuple(0L, PROVISIONING, project.getId()));
+ .containsOnly(tuple(0, PROVISIONING, project.getId()));
assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), asList(group1.getId(), group2.getId(), ANYONE_ID), project.getId())).hasSize(2);
assertThat(underTest.selectByGroupIds(dbSession, org.getUuid(), singletonList(MISSING_ID), project.getId())).isEmpty();
.containsOnly(organizationUuids);
}
- private Long insertGroupWithPermissions(OrganizationDto organization1) {
+ private int insertGroupWithPermissions(OrganizationDto organization1) {
GroupDto group = db.users().insertGroup(organization1);
db.users().insertPermissionOnGroup(group, "foo");
db.users().insertPermissionOnGroup(group, "bar");
assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getId(), asList("Anyone")))
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
- tuple(0L, "Anyone", USER));
+ 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();
.extracting(PermissionTemplateGroupDto::getGroupId, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission)
.containsOnly(
tuple(group1.getId(), "Group-1", PROVISIONING),
- tuple(0L, "Anyone", USER));
+ tuple(0, "Anyone", USER));
assertThat(underTest.selectGroupPermissionsByTemplateId(session, 321L)).isEmpty();
}
public void should_add_user_permission_to_template() {
db.prepareDbUnit(getClass(), "addUserPermissionToTemplate.xml");
- underTest.insertUserPermission(dbSession, 1L, 1L, "new_permission");
+ underTest.insertUserPermission(dbSession, 1L, 1, "new_permission");
checkTemplateTables("addUserPermissionToTemplate-result.xml");
}
public void should_remove_user_permission_from_template() {
db.prepareDbUnit(getClass(), "removeUserPermissionFromTemplate.xml");
- underTest.deleteUserPermission(dbSession, 1L, 2L, "permission_to_remove");
+ underTest.deleteUserPermission(dbSession, 1L, 2, "permission_to_remove");
checkTemplateTables("removeUserPermissionFromTemplate-result.xml");
}
public void should_add_group_permission_to_template() {
db.prepareDbUnit(getClass(), "addGroupPermissionToTemplate.xml");
- underTest.insertGroupPermission(dbSession, 1L, 1L, "new_permission");
+ underTest.insertGroupPermission(dbSession, 1L, 1, "new_permission");
dbSession.commit();
checkTemplateTables("addGroupPermissionToTemplate-result.xml");
public void remove_by_group() {
db.prepareDbUnit(getClass(), "remove_by_group.xml");
- underTest.deleteByGroup(db.getSession(), 2L);
+ underTest.deleteByGroup(db.getSession(), 2);
db.getSession().commit();
db.assertDbUnitTable(getClass(), "remove_by_group-result.xml", "permission_templates", "id", "name", "kee", "description");
addGroupToTemplate(permissionTemplate.getId(), group.getId(), permission);
}
- public void addGroupToTemplate(long templateId, @Nullable Long groupId, String permission) {
+ public void addGroupToTemplate(long templateId, @Nullable Integer groupId, String permission) {
dbClient.permissionTemplateDao().insertGroupPermission(dbSession, templateId, groupId, permission);
db.commit();
}
addUserToTemplate(permissionTemplate.getId(), user.getId(), permission);
}
- public void addUserToTemplate(long templateId, long userId, String permission) {
+ public void addUserToTemplate(long templateId, int userId, String permission) {
dbClient.permissionTemplateDao().insertUserPermission(dbSession, templateId, userId, permission);
db.commit();
}
public void shouldFindUsersForNotification() throws SQLException {
ComponentDto project1 = insertProject("uuid_45");
ComponentDto project2 = insertProject("uuid_56");
- long userId1 = insertUser("user1");
- long userId2 = insertUser("user2");
- long userId3 = insertUser("user3");
+ int userId1 = insertUser("user1");
+ int userId2 = insertUser("user2");
+ int userId3 = insertUser("user3");
insertProperty("notification.NewViolations.Email", "true", project1.getId(), userId2);
insertProperty("notification.NewViolations.Twitter", "true", null, userId3);
insertProperty("notification.NewViolations.Twitter", "true", project2.getId(), userId1);
@Test
public void findNotificationSubscribers() throws SQLException {
- long userId1 = insertUser("user1");
- long userId2 = insertUser("user2");
+ int userId1 = insertUser("user1");
+ int userId2 = insertUser("user2");
ComponentDto projectDto = insertProject("PROJECT_A");
long projectId = projectDto.getId();
String projectKey = projectDto.key();
@Test
public void hasNotificationSubscribers() throws SQLException {
- long userId1 = insertUser("user1");
- long userId2 = insertUser("user2");
+ int userId1 = insertUser("user1");
+ int userId2 = insertUser("user2");
Long projectId = insertProject("PROJECT_A").getId();
// global subscription
insertProperty("notification.DispatcherWithGlobalSubscribers.Email", "true", null, userId2);
// project
insertProperty("project.one", "one", 10L, null);
// user
- insertProperty("user.one", "one", null, 100L);
+ insertProperty("user.one", "one", null, 100);
assertThatDto(underTest.selectGlobalProperty("global.one"))
.hasNoResourceId()
// commons
insertProperty("commonslang.one", "one", 11L, null);
// user
- insertProperty("user.one", "one", null, 100L);
- insertProperty("user.two", "two", 10L, 100L);
+ insertProperty("user.one", "one", null, 100);
+ insertProperty("user.two", "two", 10L, 100);
// other
insertProperty("other.one", "one", 12L, null);
@Test
public void select_global_properties_by_keys() throws Exception {
insertProject("A");
- long userId = insertUser("B");
+ int userId = insertUser("B");
String key = "key";
String anotherKey = "anotherKey";
public void saveProperty_inserts_user_properties_when_they_do_not_exist_in_db() {
when(system2.now()).thenReturn(DATE_1, DATE_2, DATE_3, DATE_4, DATE_5);
- long userId = 100;
+ int userId = 100;
underTest.saveProperty(new PropertyDto().setKey("user.null").setUserId(userId).setValue(null));
underTest.saveProperty(new PropertyDto().setKey("user.empty").setUserId(userId).setValue(""));
underTest.saveProperty(new PropertyDto().setKey("user.text").setUserId(userId).setValue("some text"));
@Test
@UseDataProvider("valueUpdatesDataProvider")
public void saveProperty_deletes_then_inserts_user_properties_when_they_exist_in_db(@Nullable String oldValue, @Nullable String newValue) throws SQLException {
- long userId = 90L;
+ int userId = 90;
long id = insertProperty("global", oldValue, null, userId, DATE_1);
when(system2.now()).thenReturn(DATE_4);
long id2 = insertProperty("global.two", "two", null, null);
long id3 = insertProperty("struts.one", "one", projectId1, null);
long id4 = insertProperty("commonslang.one", "one", projectId2, null);
- long id5 = insertProperty("user.one", "one", null, 100L);
- long id6 = insertProperty("user.two", "two", null, 100L);
+ long id5 = insertProperty("user.one", "one", null, 100);
+ long id6 = insertProperty("user.two", "two", null, 100);
long id7 = insertProperty("other.one", "one", projectId3, null);
underTest.deleteProjectProperty("struts.one", projectId1);
// project - do not delete this project property that has the same key
long id3 = insertProperty("to_be_deleted", "new_project", 10L, null);
// user
- long id4 = insertProperty("user.key", "new_user", null, 100L);
+ long id4 = insertProperty("user.key", "new_user", null, 100);
underTest.deleteGlobalProperty("to_be_deleted");
long id2 = insertProperty("old_name", "doc1", null, null, DATE_1);
long id3 = insertProperty("old_name", "doc2", 15L, null, DATE_1);
long id4 = insertProperty("old_name", "doc3", 16L, null, DATE_1);
- long id5 = insertProperty("old_name", "doc4", null, 100L, DATE_1);
- long id6 = insertProperty("old_name", "doc5", null, 101L, DATE_1);
+ long id5 = insertProperty("old_name", "doc4", null, 100, DATE_1);
+ long id6 = insertProperty("old_name", "doc5", null, 101, DATE_1);
underTest.renamePropertyKey("old_name", "new_name");
session.commit();
}
- private long insertProperty(String key, @Nullable String value, @Nullable Long resourceId, @Nullable Long userId, long createdAt) throws SQLException {
+ private long insertProperty(String key, @Nullable String value, @Nullable Long resourceId, @Nullable Integer userId, long createdAt) throws SQLException {
when(system2.now()).thenReturn(createdAt);
return insertProperty(key, value, resourceId, userId);
}
- private long insertProperty(String key, @Nullable String value, @Nullable Long resourceId, @Nullable Long userId) throws SQLException {
+ private long insertProperty(String key, @Nullable String value, @Nullable Long resourceId, @Nullable Integer userId) throws SQLException {
DbSession session = dbTester.getSession();
PropertyDto dto = new PropertyDto().setKey(key)
.setResourceId(resourceId == null ? null : resourceId.longValue())
return project;
}
- private long insertUser(String login) {
+ private int insertUser(String login) {
UserDto dto = new UserDto().setLogin(login);
DbSession session = dbTester.getSession();
dbClient.userDao().insert(session, dto);
final class PropertiesRow {
private final String key;
- private final Long userId;
+ private final Integer userId;
private final Long resourceId;
private final Boolean empty;
private final String textValue;
private final String clobValue;
private final Long createdAt;
- public PropertiesRow(String key, @Nullable Long userId, @Nullable Long resourceId,
+ public PropertiesRow(String key, @Nullable Integer userId, @Nullable Long resourceId,
@Nullable Boolean empty, @Nullable String textValue, @Nullable String clobValue,
@Nullable Long createdAt) {
this.key = key;
return key;
}
- public Long getUserId() {
+ public Integer getUserId() {
return userId;
}
return null;
} else {
Map<String, Object> row = rows.iterator().next();
+ Long userId = (Long) row.get("userId");
return new PropertiesRow(
(String) row.get("key"),
- (Long) row.get("userId"),
+ userId == null ? null : userId.intValue(),
(Long) row.get("resourceId"),
toBoolean(row.get("isEmpty")),
(String) row.get("textValue"),
return this;
}
- public PropertiesRowAssert hasUserId(long expected) {
+ public PropertiesRowAssert hasUserId(int expected) {
isNotNull();
if (!Objects.equals(actual.getUserId(), expected)) {
@Test
public void testToString() {
- assertThat(new PropertyDto().setKey("foo:bar").setValue("value").setResourceId(123L).setUserId(456L).toString()).isEqualTo("PropertyDto{foo:bar, value, 123, 456}");
+ assertThat(new PropertyDto().setKey("foo:bar").setValue("value").setResourceId(123L).setUserId(456).toString()).isEqualTo("PropertyDto{foo:bar, value, 123, 456}");
}
@Test
public class GroupDaoTest {
private static final long NOW = 1_500_000L;
- private static final long MISSING_ID = -1L;
+ private static final int MISSING_ID = -1;
private static final OrganizationDto AN_ORGANIZATION = new OrganizationDto()
.setKey("an-org")
.setName("An Org")
dbTester.prepareDbUnit(getClass(), "shared.xml");
// 200 is member of 3 groups
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200L)).isEqualTo(3);
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200L)).isZero();
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200)).isEqualTo(3);
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200)).isZero();
// 201 is member of 1 group on 3
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201L)).isEqualTo(1);
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201L)).isEqualTo(2);
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201)).isEqualTo(1);
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201)).isEqualTo(2);
// 999 is member of 0 group
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999L)).isZero();
- assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999L)).isEqualTo(3);
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999)).isZero();
+ assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999)).isEqualTo(3);
}
@Test
public void count_users_by_group() {
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
- assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100L, 101L, 102L, 103L))).containsOnly(
+ assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100, 101, 102, 103))).containsOnly(
entry("sonar-users", 2), entry("sonar-reviewers", 1), entry("sonar-administrators", 1), entry("sonar-nobody", 0));
- assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100L, 103L))).containsOnly(
+ assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100, 103))).containsOnly(
entry("sonar-administrators", 1), entry("sonar-nobody", 0));
}
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
// 100 has 1 member and 1 non member
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
// 101 has 2 members
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build())).isZero();
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.OUT).build())).isZero();
// 102 has 1 member and 1 non member
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
// 103 has no member
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build())).isZero();
- assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.IN).build())).isZero();
+ assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
}
@Test
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
// 100 has 1 member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
// 101 has 2 members
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
// 102 has 1 member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
// 103 has no member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty();
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty();
}
@Test
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
// 100 has 1 member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
// 101 has 2 members
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
// 102 has 1 member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
// 103 has no member
- assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2);
+ assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2);
}
@Test
public void search_by_user_name_or_login() {
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
- List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).memberSearch("admin").build(), 0, 10);
+ List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("admin").build(), 0, 10);
assertThat(result).hasSize(2);
assertThat(result.get(0).getName()).isEqualTo("Admin name");
assertThat(result.get(1).getName()).isEqualTo("Not Admin");
- result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).memberSearch("not").build(), 0, 10);
+ result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("not").build(), 0, 10);
assertThat(result).hasSize(1);
}
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
// search is case insensitive only on name
- List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).memberSearch("NaMe").build(), 0, 10);
+ List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("NaMe").build(), 0, 10);
assertThat(result).hasSize(1);
- result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).memberSearch("login").build(), 0, 10);
+ result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("login").build(), 0, 10);
assertThat(result).hasSize(1);
- result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).memberSearch("email").build(), 0, 10);
+ result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("email").build(), 0, 10);
assertThat(result).hasSize(1);
}
public void should_be_sorted_by_user_name() {
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
- List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).build(), 0, 10);
+ List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 0, 10);
assertThat(result).hasSize(2);
assertThat(result.get(0).getName()).isEqualTo("Admin name");
assertThat(result.get(1).getName()).isEqualTo("Not Admin");
public void members_should_be_paginated() {
dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
- List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).build(), 0, 2);
+ List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 0, 2);
assertThat(result).hasSize(2);
assertThat(result.get(0).getName()).isEqualTo("Admin name");
assertThat(result.get(1).getName()).isEqualTo("Not Admin");
- result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).build(), 1, 2);
+ result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 1, 2);
assertThat(result).hasSize(1);
assertThat(result.get(0).getName()).isEqualTo("Not Admin");
- result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100L).build(), 2, 1);
+ result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 2, 1);
assertThat(result).isEmpty();
}
}
import java.util.Date;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
+import static org.apache.commons.lang.math.RandomUtils.nextInt;
import static org.apache.commons.lang.math.RandomUtils.nextLong;
public class GroupTesting {
public static GroupDto newGroupDto() {
GroupDto group = new GroupDto()
- .setId(nextLong())
+ .setId(nextInt())
.setOrganizationUuid(randomAlphanumeric(40))
.setName(randomAlphanumeric(255))
.setDescription(randomAlphanumeric(200))
public void delete_all_group_permissions_by_group_id() {
db.prepareDbUnit(getClass(), "deleteGroupPermissionsByGroupId.xml");
- underTest.deleteGroupRolesByGroupId(db.getSession(), 100L);
+ underTest.deleteGroupRolesByGroupId(db.getSession(), 100);
db.getSession().commit();
db.assertDbUnit(getClass(), "deleteGroupPermissionsByGroupId-result.xml", "group_roles");
public void selectUsersIds() {
db.prepareDbUnit(getClass(), "selectUsersByIds.xml");
- Collection<UserDto> users = underTest.selectByIds(session, asList(100L, 101L, 987L));
+ Collection<UserDto> users = underTest.selectByIds(session, asList(100, 101, 987));
assertThat(users).hasSize(2);
assertThat(users).extracting("login").containsOnly("marius", "inactive_user");
- assertThat(underTest.selectByIds(session, Collections.<Long>emptyList())).isEmpty();
+ assertThat(underTest.selectByIds(session, Collections.emptyList())).isEmpty();
}
@Test
Long date = DateUtils.parseDate("2014-06-20").getTime();
UserDto userDto = new UserDto()
- .setId(1L)
+ .setId(1)
.setLogin("john")
.setName("John")
.setEmail("jo@hn.com")
db.getSession().commit();
UserDto userDto = new UserDto()
- .setId(1L)
+ .setId(1)
.setLogin("john")
.setName("John Doo")
.setEmail("jodoo@hn.com")
}
@CheckForNull
- public GroupDto selectGroupById(long groupId) {
+ public GroupDto selectGroupById(int groupId) {
return db.getDbClient().groupDao().selectById(db.getSession(), groupId);
}
db.commit();
}
- public List<Long> selectGroupIdsOfUser(UserDto user) {
+ public List<Integer> selectGroupIdsOfUser(UserDto user) {
return db.getDbClient().groupMembershipDao().selectGroupIdsByUserId(db.getSession(), user.getId());
}
@Test
public void insert() {
- UserGroupDto userGroupDto = new UserGroupDto().setUserId(1L).setGroupId(2L);
+ UserGroupDto userGroupDto = new UserGroupDto().setUserId(1).setGroupId(2);
underTest.insert(dbTester.getSession(), userGroupDto);
dbTester.getSession().commit();
@Test
public void delete_members_by_group_id() {
dbTester.prepareDbUnit(getClass(), "delete_members_by_group_id.xml");
- underTest.deleteByGroupId(dbTester.getSession(), 1L);
+ underTest.deleteByGroupId(dbTester.getSession(), 1);
dbTester.getSession().commit();
dbTester.assertDbUnit(getClass(), "delete_members_by_group_id-result.xml", "groups_users");
}
public static UserDto newUserDto(String login, String name, @Nullable String email) {
return new UserDto()
- .setId((long)nextInt())
+ .setId(nextInt())
.setActive(true)
.setLocal(true)
.setName(name)
public static UserDto newLocalUser(String login, String name, @Nullable String email) {
return new UserDto()
- .setId((long)nextInt())
+ .setId(nextInt())
.setActive(true)
.setLocal(true)
.setName(name)
public static UserDto newExternalUser(String login, String name, @Nullable String email) {
return new UserDto()
- .setId((long)nextInt())
+ .setId(nextInt())
.setActive(true)
.setLocal(false)
.setName(name)
public static UserDto newDisabledUser(String login) {
return new UserDto()
- .setId((long)nextInt())
+ .setId(nextInt())
.setLogin(login)
.setActive(false)
.setCreatedAt(nextLong())
projects / sonarqube.git / commitdiff