@@ -19,18 +19,19 @@ | |||
*/ | |||
package org.sonar.server.permission; | |||
import org.sonar.core.permission.GroupWithPermission; | |||
import java.util.List; | |||
import org.sonar.core.permission.GroupWithPermission; | |||
public class GroupWithPermissionQueryResult { | |||
private List<GroupWithPermission> groups; | |||
private boolean hasMoreResults; | |||
private final List<GroupWithPermission> groups; | |||
private final int total; | |||
private final boolean hasMoreResults; | |||
public GroupWithPermissionQueryResult(List<GroupWithPermission> groups, boolean hasMoreResults) { | |||
public GroupWithPermissionQueryResult(List<GroupWithPermission> groups, int total) { | |||
this.groups = groups; | |||
this.hasMoreResults = hasMoreResults; | |||
this.total = total; | |||
this.hasMoreResults = total > groups.size(); | |||
} | |||
public List<GroupWithPermission> groups() { | |||
@@ -41,4 +42,7 @@ public class GroupWithPermissionQueryResult { | |||
return hasMoreResults; | |||
} | |||
public int total() { | |||
return total; | |||
} | |||
} |
@@ -91,7 +91,12 @@ public class PermissionFinder { | |||
*/ | |||
public GroupWithPermissionQueryResult findGroupsWithPermission(PermissionQuery query) { | |||
Long componentId = componentId(query.component()); | |||
return toGroupQueryResult(permissionDao.selectGroups(query, componentId), query); | |||
DbSession dbSession = dbClient.openSession(false); | |||
try { | |||
return toGroupQueryResult(permissionDao.selectGroups(dbSession, query, componentId), query); | |||
} finally { | |||
dbClient.closeSession(dbSession); | |||
} | |||
} | |||
/** | |||
@@ -99,7 +104,12 @@ public class PermissionFinder { | |||
*/ | |||
public GroupWithPermissionQueryResult findGroupsWithPermissionTemplate(PermissionQuery query) { | |||
Long permissionTemplateId = templateId(query.template()); | |||
return toGroupQueryResult(permissionTemplateDao.selectGroups(query, permissionTemplateId), query); | |||
DbSession dbSession = dbClient.openSession(false); | |||
try { | |||
return toGroupQueryResult(permissionTemplateDao.selectGroups(dbSession, query, permissionTemplateId), query); | |||
} finally { | |||
dbClient.closeSession(dbSession); | |||
} | |||
} | |||
private static UserWithPermissionQueryResult toUserQueryResult(List<UserWithPermissionDto> dtos, int total) { | |||
@@ -133,7 +143,7 @@ public class PermissionFinder { | |||
Paging paging = Paging.create(query.pageSize(), query.pageIndex(), filteredDtos.size()); | |||
List<GroupWithPermission> pagedGroups = pagedGroups(filteredDtos, paging); | |||
return new GroupWithPermissionQueryResult(pagedGroups, paging.hasNextPage()); | |||
return new GroupWithPermissionQueryResult(pagedGroups, filteredDtos.size()); | |||
} | |||
private Long templateId(String templateKey) { |
@@ -0,0 +1,131 @@ | |||
/* | |||
* SonarQube, open source software quality management tool. | |||
* Copyright (C) 2008-2014 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* SonarQube is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* SonarQube is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public License | |||
* along with this program; if not, write to the Free Software Foundation, | |||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | |||
*/ | |||
package org.sonar.server.permission.ws; | |||
import com.google.common.io.Resources; | |||
import java.util.List; | |||
import org.sonar.api.server.ws.Request; | |||
import org.sonar.api.server.ws.Response; | |||
import org.sonar.api.server.ws.WebService; | |||
import org.sonar.api.utils.text.JsonWriter; | |||
import org.sonar.core.permission.GlobalPermissions; | |||
import org.sonar.core.permission.GroupWithPermission; | |||
import org.sonar.core.util.ProtobufJsonFormat; | |||
import org.sonar.db.permission.PermissionQuery; | |||
import org.sonar.server.permission.GroupWithPermissionQueryResult; | |||
import org.sonar.server.permission.PermissionFinder; | |||
import org.sonar.server.plugins.MimeTypes; | |||
import org.sonar.server.user.UserSession; | |||
import org.sonarqube.ws.Common; | |||
import org.sonarqube.ws.Permissions; | |||
import static com.google.common.base.Objects.firstNonNull; | |||
import static org.sonar.server.permission.PermissionQueryParser.toMembership; | |||
public class GroupsAction implements PermissionsWsAction { | |||
private final UserSession userSession; | |||
private final PermissionFinder permissionFinder; | |||
public GroupsAction(UserSession userSession, PermissionFinder permissionFinder) { | |||
this.userSession = userSession; | |||
this.permissionFinder = permissionFinder; | |||
} | |||
@Override | |||
public void define(WebService.NewController context) { | |||
WebService.NewAction action = context.createAction("groups") | |||
.setSince("5.2") | |||
.setInternal(true) | |||
.setDescription(String.format("List permission's groups.<br /> " + | |||
"If the query parameter '%s' is specified, the '%s' parameter is '%s'.", | |||
WebService.Param.TEXT_QUERY, WebService.Param.SELECTED, WebService.SelectionMode.ALL.value())) | |||
.addPagingParams(100) | |||
.addSearchQuery("sonar", "names") | |||
.addSelectionModeParam() | |||
.setResponseExample(Resources.getResource(getClass(), "groups-example.json")) | |||
.setHandler(this); | |||
action.createParam("permission") | |||
.setExampleValue("scan") | |||
.setRequired(true) | |||
.setPossibleValues(GlobalPermissions.ALL); | |||
} | |||
@Override | |||
public void handle(Request request, Response response) throws Exception { | |||
String permission = request.mandatoryParam("permission"); | |||
String selected = request.param(WebService.Param.SELECTED); | |||
int page = request.mandatoryParamAsInt(WebService.Param.PAGE); | |||
int pageSize = request.mandatoryParamAsInt(WebService.Param.PAGE_SIZE); | |||
String query = request.param(WebService.Param.TEXT_QUERY); | |||
if (query != null) { | |||
selected = WebService.SelectionMode.ALL.value(); | |||
} | |||
userSession | |||
.checkLoggedIn() | |||
.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN); | |||
PermissionQuery.Builder permissionQuery = PermissionQuery.builder() | |||
.permission(permission) | |||
.pageIndex(page) | |||
.pageSize(pageSize) | |||
.membership(toMembership(firstNonNull(selected, WebService.SelectionMode.SELECTED.value()))); | |||
if (query != null) { | |||
permissionQuery.search(query); | |||
} | |||
GroupWithPermissionQueryResult groupsResult = permissionFinder.findGroupsWithPermission(permissionQuery.build()); | |||
List<GroupWithPermission> groupsWithPermission = groupsResult.groups(); | |||
Permissions.GroupsResponse.Builder groupsResponse = Permissions.GroupsResponse.newBuilder(); | |||
Permissions.GroupsResponse.Group.Builder group = Permissions.GroupsResponse.Group.newBuilder(); | |||
Common.Paging.Builder paging = Common.Paging.newBuilder(); | |||
for (GroupWithPermission groupWithPermission : groupsWithPermission) { | |||
group | |||
.clear() | |||
.setName(groupWithPermission.name()) | |||
.setSelected(groupWithPermission.hasPermission()); | |||
// anyone group return with id = 0 | |||
if (groupWithPermission.id() != 0) { | |||
group.setId(String.valueOf(groupWithPermission.id())); | |||
} | |||
if (groupWithPermission.description() != null) { | |||
group.setDescription(groupWithPermission.description()); | |||
} | |||
groupsResponse.addGroups(group); | |||
} | |||
groupsResponse.setPaging( | |||
paging | |||
.setPageIndex(page) | |||
.setPageSize(pageSize) | |||
.setTotal(groupsResult.total()) | |||
); | |||
response.stream().setMediaType(MimeTypes.JSON); | |||
JsonWriter json = response.newJsonWriter(); | |||
ProtobufJsonFormat.write(groupsResponse.build(), json); | |||
json.close(); | |||
} | |||
} |
@@ -31,6 +31,7 @@ public class PermissionsWsModule extends Module { | |||
AddUserAction.class, | |||
RemoveGroupAction.class, | |||
RemoveUserAction.class, | |||
UsersAction.class); | |||
UsersAction.class, | |||
GroupsAction.class); | |||
} | |||
} |
@@ -112,7 +112,7 @@ public class UsersAction implements PermissionsWsAction { | |||
userResponse.setPaging( | |||
paging | |||
.clear() | |||
.setPages(page) | |||
.setPageIndex(page) | |||
.setPageSize(pageSize) | |||
.setTotal(usersResult.total()) | |||
); |
@@ -19,11 +19,9 @@ | |||
*/ | |||
package org.sonar.server.ws; | |||
import com.google.common.base.Strings; | |||
import org.sonar.api.resources.Language; | |||
import org.sonar.api.resources.Languages; | |||
import org.sonar.api.utils.Paging; | |||
import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.rule.RuleDto; | |||
import org.sonar.db.user.UserDto; | |||
import org.sonarqube.ws.Common; | |||
@@ -41,7 +39,6 @@ public class WsResponseCommonFormat { | |||
public Common.Paging.Builder formatPaging(Paging paging) { | |||
return Common.Paging.newBuilder() | |||
.setPageIndex(paging.pageIndex()) | |||
.setPages(paging.pages()) | |||
.setPageSize(paging.pageSize()) | |||
.setTotal(paging.total()); | |||
} |
@@ -0,0 +1,25 @@ | |||
{ | |||
"groups": [ | |||
{ | |||
"name": "Anyone", | |||
"selected": true | |||
}, | |||
{ | |||
"id": "1", | |||
"name": "sonar-administrators", | |||
"description": "System administrators", | |||
"selected": true | |||
}, | |||
{ | |||
"id": "2", | |||
"name": "sonar-users", | |||
"description": "Any new users created will automatically join this group", | |||
"selected": true | |||
} | |||
], | |||
"paging": { | |||
"pageIndex": 1, | |||
"pageSize": 100, | |||
"total": 3 | |||
} | |||
} |
@@ -14,7 +14,7 @@ | |||
"paging": { | |||
"pageSize": 100, | |||
"total": 2, | |||
"pages": 1 | |||
"pageIndex": 1 | |||
} | |||
} | |||
@@ -153,19 +153,20 @@ public class PermissionFinderTest { | |||
@Test | |||
public void find_groups() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("users").setPermission("user")) | |||
); | |||
GroupWithPermissionQueryResult result = underTest.findGroupsWithPermission( | |||
PermissionQuery.builder().permission("user").membership(PermissionQuery.IN).build()); | |||
assertThat(result.groups()).hasSize(1); | |||
assertThat(result.hasMoreResults()).isFalse(); | |||
} | |||
@Test | |||
public void find_groups_should_be_paginated() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn(newArrayList( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn(newArrayList( | |||
new GroupWithPermissionDto().setName("Anyone").setPermission("user"), | |||
new GroupWithPermissionDto().setName("Admin").setPermission("user"), | |||
new GroupWithPermissionDto().setName("Users").setPermission(null), | |||
@@ -191,12 +192,12 @@ public class PermissionFinderTest { | |||
.permission("user") | |||
.pageSize(2) | |||
.pageIndex(3) | |||
.build()).hasMoreResults()).isFalse(); | |||
.build()).hasMoreResults()).isTrue(); | |||
} | |||
@Test | |||
public void find_groups_should_filter_membership() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn(newArrayList( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn(newArrayList( | |||
new GroupWithPermissionDto().setName("Anyone").setPermission("user"), | |||
new GroupWithPermissionDto().setName("Admin").setPermission("user"), | |||
new GroupWithPermissionDto().setName("Users").setPermission(null), | |||
@@ -214,7 +215,7 @@ public class PermissionFinderTest { | |||
@Test | |||
public void find_groups_with_added_anyone_group() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("users").setPermission("user")) | |||
); | |||
@@ -228,7 +229,7 @@ public class PermissionFinderTest { | |||
@Test | |||
public void find_groups_without_adding_anyone_group_when_search_text_do_not_matched() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("users").setPermission("user")) | |||
); | |||
@@ -240,7 +241,7 @@ public class PermissionFinderTest { | |||
@Test | |||
public void find_groups_with_added_anyone_group_when_search_text_matched() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("MyAnyGroup").setPermission("user")) | |||
); | |||
@@ -251,7 +252,7 @@ public class PermissionFinderTest { | |||
@Test | |||
public void find_groups_without_adding_anyone_group_when_out_membership_selected() { | |||
when(permissionDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("users").setPermission("user")) | |||
); | |||
@@ -292,7 +293,7 @@ public class PermissionFinderTest { | |||
public void find_groups_from_permission_template() { | |||
when(permissionTemplateDao.selectTemplateByKey(anyString())).thenReturn(new PermissionTemplateDto().setId(1L).setKee("my_template")); | |||
when(permissionTemplateDao.selectGroups(any(PermissionQuery.class), anyLong())).thenReturn( | |||
when(permissionTemplateDao.selectGroups(any(DbSession.class), any(PermissionQuery.class), anyLong())).thenReturn( | |||
newArrayList(new GroupWithPermissionDto().setName("users").setPermission("user")) | |||
); | |||
@@ -0,0 +1,168 @@ | |||
/* | |||
* SonarQube, open source software quality management tool. | |||
* Copyright (C) 2008-2014 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* SonarQube is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* SonarQube is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public License | |||
* along with this program; if not, write to the Free Software Foundation, | |||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | |||
*/ | |||
package org.sonar.server.permission.ws; | |||
import com.google.common.io.Resources; | |||
import org.junit.Before; | |||
import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.junit.experimental.categories.Category; | |||
import org.junit.rules.ExpectedException; | |||
import org.sonar.api.security.DefaultGroups; | |||
import org.sonar.api.server.ws.WebService.Param; | |||
import org.sonar.api.server.ws.WebService.SelectionMode; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.core.permission.GlobalPermissions; | |||
import org.sonar.db.DbClient; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.user.GroupDto; | |||
import org.sonar.db.user.GroupRoleDto; | |||
import org.sonar.server.exceptions.ForbiddenException; | |||
import org.sonar.server.exceptions.UnauthorizedException; | |||
import org.sonar.server.permission.PermissionFinder; | |||
import org.sonar.server.tester.UserSessionRule; | |||
import org.sonar.server.ws.WsActionTester; | |||
import org.sonar.test.DbTests; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.sonar.test.JsonAssert.assertJson; | |||
@Category(DbTests.class) | |||
public class GroupsActionTest { | |||
@Rule | |||
public ExpectedException expectedException = ExpectedException.none(); | |||
@Rule | |||
public UserSessionRule userSession = UserSessionRule.standalone(); | |||
@Rule | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
DbClient dbClient; | |||
DbSession dbSession; | |||
WsActionTester ws; | |||
PermissionFinder permissionFinder; | |||
GroupsAction underTest; | |||
@Before | |||
public void setUp() { | |||
dbClient = db.getDbClient(); | |||
dbSession = db.getSession(); | |||
permissionFinder = new PermissionFinder(dbClient); | |||
userSession.login("login").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN); | |||
underTest = new GroupsAction(userSession, permissionFinder); | |||
ws = new WsActionTester(underTest); | |||
GroupDto group1 = dbClient.groupDao().insert(dbSession, new GroupDto() | |||
.setName("group-1-name") | |||
.setDescription("group-1-description")); | |||
GroupDto group2 = dbClient.groupDao().insert(dbSession, new GroupDto() | |||
.setName("group-2-name") | |||
.setDescription("group-2-description")); | |||
GroupDto group3 = dbClient.groupDao().insert(dbSession, new GroupDto() | |||
.setName("group-3-name") | |||
.setDescription("group-3-description")); | |||
dbClient.roleDao().insertGroupRole(dbSession, new GroupRoleDto() | |||
.setGroupId(group1.getId()) | |||
.setRole(GlobalPermissions.SCAN_EXECUTION)); | |||
dbClient.roleDao().insertGroupRole(dbSession, new GroupRoleDto() | |||
.setGroupId(group2.getId()) | |||
.setRole(GlobalPermissions.SCAN_EXECUTION)); | |||
dbClient.roleDao().insertGroupRole(dbSession, new GroupRoleDto() | |||
.setGroupId(group3.getId()) | |||
.setRole(GlobalPermissions.SYSTEM_ADMIN)); | |||
dbSession.commit(); | |||
} | |||
@Test | |||
public void search_for_groups_with_one_permission() { | |||
String result = ws.newRequest() | |||
.setParam("permission", "scan") | |||
.execute().getInput(); | |||
assertJson(result).isSimilarTo(Resources.getResource(getClass(), "GroupsActionTest/groups.json")); | |||
} | |||
@Test | |||
public void search_with_selection() { | |||
String result = ws.newRequest() | |||
.setParam("permission", "scan") | |||
.setParam("selected", SelectionMode.ALL.value()) | |||
.execute().getInput(); | |||
assertThat(result).containsSequence(DefaultGroups.ANYONE, "group-1", "group-2", "group-3"); | |||
} | |||
@Test | |||
public void search_groups_with_pagination() { | |||
String result = ws.newRequest() | |||
.setParam("permission", "scan") | |||
.setParam(Param.PAGE_SIZE, "1") | |||
.setParam(Param.PAGE, "2") | |||
.execute().getInput(); | |||
assertThat(result).contains("group-2") | |||
.doesNotContain("group-1") | |||
.doesNotContain("group-3"); | |||
} | |||
@Test | |||
public void search_groups_with_query() { | |||
String result = ws.newRequest() | |||
.setParam("permission", "scan") | |||
.setParam(Param.TEXT_QUERY, "group-") | |||
.execute().getInput(); | |||
assertThat(result) | |||
.contains("group-1", "group-2", "group-3") | |||
.doesNotContain(DefaultGroups.ANYONE); | |||
} | |||
@Test | |||
public void fail_if_not_logged_in() { | |||
expectedException.expect(UnauthorizedException.class); | |||
userSession.anonymous(); | |||
ws.newRequest() | |||
.setParam("permission", "scan") | |||
.execute(); | |||
} | |||
@Test | |||
public void fail_if_insufficient_privileges() { | |||
expectedException.expect(ForbiddenException.class); | |||
userSession.login("login"); | |||
ws.newRequest() | |||
.setParam("permission", "scan") | |||
.execute(); | |||
} | |||
@Test | |||
public void fail_if_permission_is_not_specified() { | |||
expectedException.expect(IllegalArgumentException.class); | |||
ws.newRequest() | |||
.execute(); | |||
} | |||
} |
@@ -30,6 +30,6 @@ public class PermissionsWsModuleTest { | |||
public void verify_count_of_added_components() { | |||
ComponentContainer container = new ComponentContainer(); | |||
new PermissionsWsModule().configure(container); | |||
assertThat(container.size()).isEqualTo(8); | |||
assertThat(container.size()).isEqualTo(9); | |||
} | |||
} |
@@ -5,7 +5,6 @@ | |||
"paging": { | |||
"pageIndex": 1, | |||
"pageSize": 100, | |||
"total": 0, | |||
"pages": 0 | |||
"total": 0 | |||
} | |||
} |
@@ -2,7 +2,6 @@ | |||
"paging": { | |||
"pageIndex": 2, | |||
"pageSize": 9, | |||
"total": 12, | |||
"pages": 2 | |||
"total": 12 | |||
} | |||
} |
@@ -5,8 +5,7 @@ | |||
"paging": { | |||
"pageIndex": 1, | |||
"pageSize": 100, | |||
"total": 0, | |||
"pages": 0 | |||
"total": 0 | |||
}, | |||
"issues": [] | |||
} |
@@ -0,0 +1,19 @@ | |||
{ | |||
"groups": [ | |||
{ | |||
"name": "group-1-name", | |||
"description": "group-1-description", | |||
"selected": true | |||
}, | |||
{ | |||
"name": "group-2-name", | |||
"description": "group-2-description", | |||
"selected": true | |||
} | |||
], | |||
"paging": { | |||
"pageIndex": 1, | |||
"pageSize": 100, | |||
"total": 2 | |||
} | |||
} |
@@ -14,6 +14,6 @@ | |||
"paging": { | |||
"pageSize": 100, | |||
"total": 2, | |||
"pages": 1 | |||
"pageIndex": 1 | |||
} | |||
} |
@@ -27,10 +27,20 @@ import org.apache.commons.lang.builder.ToStringStyle; | |||
public class GroupWithPermission { | |||
private long id; | |||
private String name; | |||
private String description; | |||
private boolean hasPermission; | |||
public long id() { | |||
return id; | |||
} | |||
public GroupWithPermission setId(Long id) { | |||
this.id = id; | |||
return this; | |||
} | |||
public String name() { | |||
return name; | |||
} |
@@ -26,10 +26,19 @@ import org.sonar.core.permission.GroupWithPermission; | |||
public class GroupWithPermissionDto { | |||
private long id; | |||
private String name; | |||
private String permission; | |||
private String description; | |||
public long getId() { | |||
return id; | |||
} | |||
public void setId(long id) { | |||
this.id = id; | |||
} | |||
public String getName() { | |||
return name; | |||
} | |||
@@ -61,6 +70,7 @@ public class GroupWithPermissionDto { | |||
public GroupWithPermission toGroupWithPermission() { | |||
return new GroupWithPermission() | |||
.setId(id) | |||
.setName(name) | |||
.setDescription(description) | |||
.hasPermission(permission != null); |
@@ -71,20 +71,33 @@ public class PermissionDao implements Dao { | |||
* | |||
* @return a non paginated list of groups. | |||
*/ | |||
public List<GroupWithPermissionDto> selectGroups(DbSession session, PermissionQuery query, @Nullable Long componentId) { | |||
Map<String, Object> params = groupsParameters(query, componentId); | |||
return mapper(session).selectGroups(params); | |||
} | |||
public List<GroupWithPermissionDto> selectGroups(PermissionQuery query, @Nullable Long componentId) { | |||
SqlSession session = myBatis.openSession(false); | |||
DbSession session = myBatis.openSession(false); | |||
try { | |||
Map<String, Object> params = newHashMap(); | |||
params.put(QUERY_PARAMETER, query); | |||
params.put(COMPONENT_ID_PARAMETER, componentId); | |||
params.put("anyoneGroup", DefaultGroups.ANYONE); | |||
return mapper(session).selectGroups(params); | |||
return selectGroups(session, query, componentId); | |||
} finally { | |||
MyBatis.closeQuietly(session); | |||
} | |||
} | |||
public int countGroups(DbSession session, PermissionQuery query, @Nullable Long componentId) { | |||
Map<String, Object> parameters = groupsParameters(query, componentId); | |||
return mapper(session).countGroups(parameters); | |||
} | |||
private static Map<String, Object> groupsParameters(PermissionQuery query, @Nullable Long componentId) { | |||
Map<String, Object> params = newHashMap(); | |||
params.put(QUERY_PARAMETER, query); | |||
params.put(COMPONENT_ID_PARAMETER, componentId); | |||
params.put("anyoneGroup", DefaultGroups.ANYONE); | |||
return params; | |||
} | |||
private PermissionMapper mapper(SqlSession session) { | |||
return session.getMapper(PermissionMapper.class); | |||
} |
@@ -28,7 +28,9 @@ public interface PermissionMapper { | |||
List<UserWithPermissionDto> selectUsers(Map<String, Object> parameters, RowBounds rowBounds); | |||
int countUsers(Map<String, Object> parameters); | |||
List<GroupWithPermissionDto> selectGroups(Map<String, Object> parameters); | |||
int countUsers(Map<String, Object> parameters); | |||
int countGroups(Map<String, Object> parameters); | |||
} |
@@ -89,19 +89,33 @@ public class PermissionTemplateDao implements Dao { | |||
* Membership parameter from query is not taking into account in order to deal more easily with the 'Anyone' group. | |||
* @return a non paginated list of groups. | |||
*/ | |||
public List<GroupWithPermissionDto> selectGroups(DbSession session, PermissionQuery query, Long templateId) { | |||
Map<String, Object> params = groupsParamaters(query, templateId); | |||
return mapper(session).selectGroups(params); | |||
} | |||
public List<GroupWithPermissionDto> selectGroups(PermissionQuery query, Long templateId) { | |||
SqlSession session = myBatis.openSession(false); | |||
DbSession session = myBatis.openSession(false); | |||
try { | |||
Map<String, Object> params = newHashMap(); | |||
params.put(QUERY_PARAMETER, query); | |||
params.put(TEMPLATE_ID_PARAMETER, templateId); | |||
params.put("anyoneGroup", DefaultGroups.ANYONE); | |||
return mapper(session).selectGroups(params); | |||
return selectGroups(session, query, templateId); | |||
} finally { | |||
MyBatis.closeQuietly(session); | |||
} | |||
} | |||
public int countGroups(DbSession session, PermissionQuery query, Long templateId) { | |||
Map<String, Object> parameters = groupsParamaters(query, templateId); | |||
return mapper(session).countGroups(parameters); | |||
} | |||
private Map<String, Object> groupsParamaters(PermissionQuery query, Long templateId) { | |||
Map<String, Object> params = newHashMap(); | |||
params.put(QUERY_PARAMETER, query); | |||
params.put(TEMPLATE_ID_PARAMETER, templateId); | |||
params.put("anyoneGroup", DefaultGroups.ANYONE); | |||
return params; | |||
} | |||
@CheckForNull | |||
public PermissionTemplateDto selectTemplateByKey(DbSession session, String templateKey) { | |||
return mapper(session).selectByKey(templateKey); |
@@ -60,4 +60,6 @@ public interface PermissionTemplateMapper { | |||
List<UserWithPermissionDto> selectUsers(Map<String, Object> params, RowBounds rowBounds); | |||
int countUsers(Map<String, Object> params); | |||
int countGroups(Map<String, Object> parameters); | |||
} |
@@ -41,8 +41,8 @@ | |||
</sql> | |||
<select id="selectGroups" parameterType="map" resultType="GroupWithPermission"> | |||
SELECT name, description, permission FROM | |||
(SELECT g.name as name, g.description as description, group_role.role as permission | |||
SELECT id, name, description, permission FROM | |||
(SELECT g.id as id, g.name as name, g.description as description, group_role.role as permission | |||
FROM groups g | |||
LEFT JOIN group_roles group_role ON group_role.group_id=g.id | |||
AND group_role.role=#{query.permission} | |||
@@ -54,7 +54,7 @@ | |||
</if> | |||
UNION | |||
-- Add Anyone group permission | |||
SELECT #{anyoneGroup} as name, NULL as description, group_role.role as permission | |||
SELECT 0 as id, #{anyoneGroup} as name, NULL as description, group_role.role as permission | |||
FROM group_roles group_role | |||
<where> | |||
AND group_role.role=#{query.permission} | |||
@@ -75,4 +75,37 @@ | |||
ORDER BY groups.name | |||
</select> | |||
<select id="countGroups" parameterType="map" resultType="int"> | |||
SELECT count(name) FROM | |||
(SELECT g.name as name | |||
FROM groups g | |||
LEFT JOIN group_roles group_role ON group_role.group_id=g.id | |||
AND group_role.role=#{query.permission} | |||
<if test="componentId != null"> | |||
AND group_role.resource_id=#{componentId} | |||
</if> | |||
<if test="componentId == null"> | |||
AND group_role.resource_id IS NULL | |||
</if> | |||
UNION | |||
-- Add Anyone group permission | |||
SELECT #{anyoneGroup} as name | |||
FROM group_roles group_role | |||
<where> | |||
AND group_role.role=#{query.permission} | |||
AND group_role.group_id IS NULL | |||
<if test="componentId != null"> | |||
AND group_role.resource_id=#{componentId} | |||
</if> | |||
<if test="componentId == null"> | |||
AND group_role.resource_id IS NULL | |||
</if> | |||
</where> | |||
) groups | |||
<where> | |||
<if test="query.search() != null"> | |||
AND (UPPER(groups.name) LIKE #{query.searchSql} ESCAPE '/') | |||
</if> | |||
</where> | |||
</select> | |||
</mapper> |
@@ -123,6 +123,30 @@ | |||
ORDER BY groups.name | |||
</select> | |||
<select id="countGroups" parameterType="map" resultType="int"> | |||
SELECT count(name) FROM | |||
(SELECT g.name as name, g.description as description, ptg.permission_reference as permission | |||
FROM groups g | |||
LEFT JOIN perm_templates_groups ptg ON ptg.group_id=g.id | |||
AND ptg.permission_reference=#{query.permission} | |||
AND ptg.template_id=#{templateId} | |||
UNION | |||
-- Add Anyone group permission | |||
SELECT #{anyoneGroup} as name, NULL as description, ptg.permission_reference as permission | |||
FROM perm_templates_groups ptg | |||
<where> | |||
AND ptg.permission_reference=#{query.permission} | |||
AND ptg.template_id=#{templateId} | |||
AND ptg.group_id IS NULL | |||
</where> | |||
) groups | |||
<where> | |||
<if test="query.search() != null"> | |||
AND (UPPER(groups.name) LIKE #{query.searchSql} ESCAPE '/') | |||
</if> | |||
</where> | |||
</select> | |||
<select id="selectByKey" parameterType="String" resultType="PermissionTemplate"> | |||
SELECT id, name, kee, description, key_pattern AS keyPattern, created_at AS createdAt, updated_at AS updatedAt | |||
FROM permission_templates |
@@ -25,6 +25,7 @@ import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.junit.experimental.categories.Category; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.test.DbTests; | |||
@@ -36,16 +37,17 @@ public class GroupWithPermissionDaoTest { | |||
private static final long COMPONENT_ID = 100L; | |||
@Rule | |||
public DbTester dbTester = DbTester.create(System2.INSTANCE); | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
DbSession session = db.getSession(); | |||
PermissionDao dao = dbTester.getDbClient().permissionDao(); | |||
PermissionDao underTest = db.getDbClient().permissionDao(); | |||
@Test | |||
public void select_groups_for_project_permission() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
db.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
PermissionQuery query = PermissionQuery.builder().permission("user").build(); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(query, COMPONENT_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, query, COMPONENT_ID); | |||
assertThat(result).hasSize(4); | |||
GroupWithPermissionDto anyone = result.get(0); | |||
@@ -71,11 +73,11 @@ public class GroupWithPermissionDaoTest { | |||
@Test | |||
public void anyone_group_is_not_returned_when_it_has_no_permission() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
db.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
// Anyone group has not the permission 'admin', so it's not returned | |||
PermissionQuery query = PermissionQuery.builder().permission("admin").build(); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(query, COMPONENT_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, query, COMPONENT_ID); | |||
assertThat(result).hasSize(3); | |||
GroupWithPermissionDto group1 = result.get(0); | |||
@@ -93,10 +95,10 @@ public class GroupWithPermissionDaoTest { | |||
@Test | |||
public void select_groups_for_global_permission() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
db.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
PermissionQuery query = PermissionQuery.builder().permission("admin").build(); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(query, null); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, query, null); | |||
assertThat(result).hasSize(3); | |||
GroupWithPermissionDto group1 = result.get(0); | |||
@@ -114,22 +116,25 @@ public class GroupWithPermissionDaoTest { | |||
@Test | |||
public void search_by_groups_name() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
db.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(PermissionQuery.builder().permission("user").search("aDMini").build(), COMPONENT_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").search("aDMini").build(), COMPONENT_ID); | |||
assertThat(result).hasSize(1); | |||
assertThat(result.get(0).getName()).isEqualTo("sonar-administrators"); | |||
result = dao.selectGroups(PermissionQuery.builder().permission("user").search("sonar").build(), COMPONENT_ID); | |||
result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").search("sonar").build(), COMPONENT_ID); | |||
assertThat(result).hasSize(3); | |||
} | |||
@Test | |||
public void search_groups_should_be_sorted_by_group_name() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions_should_be_sorted_by_group_name.xml"); | |||
db.prepareDbUnit(getClass(), "groups_with_permissions_should_be_sorted_by_group_name.xml"); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").build(), COMPONENT_ID); | |||
int count = underTest.countGroups(session, PermissionQuery.builder().permission("user").build(), COMPONENT_ID); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(PermissionQuery.builder().permission("user").build(), COMPONENT_ID); | |||
assertThat(result).hasSize(4); | |||
assertThat(count).isEqualTo(4); | |||
assertThat(result.get(0).getName()).isEqualTo("Anyone"); | |||
assertThat(result.get(1).getName()).isEqualTo("sonar-administrators"); | |||
assertThat(result.get(2).getName()).isEqualTo("sonar-reviewers"); |
@@ -25,6 +25,7 @@ import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.junit.experimental.categories.Category; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.test.DbTests; | |||
@@ -37,17 +38,20 @@ public class GroupWithPermissionTemplateDaoTest { | |||
@Rule | |||
public DbTester dbTester = DbTester.create(System2.INSTANCE); | |||
DbSession session = dbTester.getSession(); | |||
PermissionTemplateDao dao = dbTester.getDbClient().permissionTemplateDao(); | |||
PermissionTemplateDao underTest = dbTester.getDbClient().permissionTemplateDao(); | |||
@Test | |||
public void select_groups() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
PermissionQuery query = PermissionQuery.builder().permission("user").build(); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(query, TEMPLATE_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, query, TEMPLATE_ID); | |||
int count = underTest.countGroups(session, query, TEMPLATE_ID); | |||
assertThat(result).hasSize(4); | |||
assertThat(count).isEqualTo(4); | |||
GroupWithPermissionDto anyone = result.get(0); | |||
assertThat(anyone.getName()).isEqualTo("Anyone"); | |||
@@ -76,7 +80,7 @@ public class GroupWithPermissionTemplateDaoTest { | |||
// Anyone group has not the permission 'admin', so it's not returned | |||
PermissionQuery query = PermissionQuery.builder().permission("admin").build(); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(query, TEMPLATE_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, query, TEMPLATE_ID); | |||
assertThat(result).hasSize(3); | |||
GroupWithPermissionDto group1 = result.get(0); | |||
@@ -96,11 +100,11 @@ public class GroupWithPermissionTemplateDaoTest { | |||
public void search_by_groups_name() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions.xml"); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(PermissionQuery.builder().permission("user").search("aDMini").build(), TEMPLATE_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").search("aDMini").build(), TEMPLATE_ID); | |||
assertThat(result).hasSize(1); | |||
assertThat(result.get(0).getName()).isEqualTo("sonar-administrators"); | |||
result = dao.selectGroups(PermissionQuery.builder().permission("user").search("sonar").build(), TEMPLATE_ID); | |||
result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").search("sonar").build(), TEMPLATE_ID); | |||
assertThat(result).hasSize(3); | |||
} | |||
@@ -108,7 +112,7 @@ public class GroupWithPermissionTemplateDaoTest { | |||
public void search_groups_should_be_sorted_by_group_name() { | |||
dbTester.prepareDbUnit(getClass(), "groups_with_permissions_should_be_sorted_by_group_name.xml"); | |||
List<GroupWithPermissionDto> result = dao.selectGroups(PermissionQuery.builder().permission("user").build(), TEMPLATE_ID); | |||
List<GroupWithPermissionDto> result = underTest.selectGroups(session, PermissionQuery.builder().permission("user").build(), TEMPLATE_ID); | |||
assertThat(result).hasSize(4); | |||
assertThat(result.get(0).getName()).isEqualTo("Anyone"); | |||
assertThat(result.get(1).getName()).isEqualTo("sonar-administrators"); |
@@ -247,15 +247,6 @@ public final class Common { | |||
* <code>optional int32 total = 3;</code> | |||
*/ | |||
int getTotal(); | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
boolean hasPages(); | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
int getPages(); | |||
} | |||
/** | |||
* Protobuf type {@code sonarqube.ws.commons.Paging} | |||
@@ -324,11 +315,6 @@ public final class Common { | |||
total_ = input.readInt32(); | |||
break; | |||
} | |||
case 32: { | |||
bitField0_ |= 0x00000008; | |||
pages_ = input.readInt32(); | |||
break; | |||
} | |||
} | |||
} | |||
} catch (com.google.protobuf.InvalidProtocolBufferException e) { | |||
@@ -414,26 +400,10 @@ public final class Common { | |||
return total_; | |||
} | |||
public static final int PAGES_FIELD_NUMBER = 4; | |||
private int pages_; | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public boolean hasPages() { | |||
return ((bitField0_ & 0x00000008) == 0x00000008); | |||
} | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public int getPages() { | |||
return pages_; | |||
} | |||
private void initFields() { | |||
pageIndex_ = 0; | |||
pageSize_ = 0; | |||
total_ = 0; | |||
pages_ = 0; | |||
} | |||
private byte memoizedIsInitialized = -1; | |||
public final boolean isInitialized() { | |||
@@ -457,9 +427,6 @@ public final class Common { | |||
if (((bitField0_ & 0x00000004) == 0x00000004)) { | |||
output.writeInt32(3, total_); | |||
} | |||
if (((bitField0_ & 0x00000008) == 0x00000008)) { | |||
output.writeInt32(4, pages_); | |||
} | |||
getUnknownFields().writeTo(output); | |||
} | |||
@@ -481,10 +448,6 @@ public final class Common { | |||
size += com.google.protobuf.CodedOutputStream | |||
.computeInt32Size(3, total_); | |||
} | |||
if (((bitField0_ & 0x00000008) == 0x00000008)) { | |||
size += com.google.protobuf.CodedOutputStream | |||
.computeInt32Size(4, pages_); | |||
} | |||
size += getUnknownFields().getSerializedSize(); | |||
memoizedSerializedSize = size; | |||
return size; | |||
@@ -608,8 +571,6 @@ public final class Common { | |||
bitField0_ = (bitField0_ & ~0x00000002); | |||
total_ = 0; | |||
bitField0_ = (bitField0_ & ~0x00000004); | |||
pages_ = 0; | |||
bitField0_ = (bitField0_ & ~0x00000008); | |||
return this; | |||
} | |||
@@ -650,10 +611,6 @@ public final class Common { | |||
to_bitField0_ |= 0x00000004; | |||
} | |||
result.total_ = total_; | |||
if (((from_bitField0_ & 0x00000008) == 0x00000008)) { | |||
to_bitField0_ |= 0x00000008; | |||
} | |||
result.pages_ = pages_; | |||
result.bitField0_ = to_bitField0_; | |||
onBuilt(); | |||
return result; | |||
@@ -679,9 +636,6 @@ public final class Common { | |||
if (other.hasTotal()) { | |||
setTotal(other.getTotal()); | |||
} | |||
if (other.hasPages()) { | |||
setPages(other.getPages()); | |||
} | |||
this.mergeUnknownFields(other.getUnknownFields()); | |||
return this; | |||
} | |||
@@ -805,38 +759,6 @@ public final class Common { | |||
return this; | |||
} | |||
private int pages_ ; | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public boolean hasPages() { | |||
return ((bitField0_ & 0x00000008) == 0x00000008); | |||
} | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public int getPages() { | |||
return pages_; | |||
} | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public Builder setPages(int value) { | |||
bitField0_ |= 0x00000008; | |||
pages_ = value; | |||
onChanged(); | |||
return this; | |||
} | |||
/** | |||
* <code>optional int32 pages = 4;</code> | |||
*/ | |||
public Builder clearPages() { | |||
bitField0_ = (bitField0_ & ~0x00000008); | |||
pages_ = 0; | |||
onChanged(); | |||
return this; | |||
} | |||
// @@protoc_insertion_point(builder_scope:sonarqube.ws.commons.Paging) | |||
} | |||
@@ -4995,22 +4917,22 @@ public final class Common { | |||
static { | |||
java.lang.String[] descriptorData = { | |||
"\n\020ws-commons.proto\022\024sonarqube.ws.commons" + | |||
"\"K\n\006Paging\022\021\n\tpageIndex\030\001 \001(\005\022\020\n\010pageSiz" + | |||
"e\030\002 \001(\005\022\r\n\005total\030\003 \001(\005\022\r\n\005pages\030\004 \001(\005\"K\n" + | |||
"\005Facet\022\020\n\010property\030\001 \001(\t\0220\n\006values\030\002 \003(\013" + | |||
"2 .sonarqube.ws.commons.FacetValue\"(\n\nFa" + | |||
"cetValue\022\013\n\003val\030\001 \001(\t\022\r\n\005count\030\002 \001(\003\"s\n\004" + | |||
"Rule\022\013\n\003key\030\001 \001(\t\022\014\n\004name\030\002 \001(\t\022\014\n\004lang\030" + | |||
"\003 \001(\t\0220\n\006status\030\004 \001(\0162 .sonarqube.ws.com" + | |||
"mons.RuleStatus\022\020\n\010langName\030\005 \001(\t\"B\n\004Use" + | |||
"r\022\r\n\005login\030\001 \001(\t\022\014\n\004name\030\002 \001(\t\022\r\n\005email\030", | |||
"\003 \001(\t\022\016\n\006active\030\004 \001(\010\"W\n\tTextRange\022\021\n\tst" + | |||
"artLine\030\001 \001(\005\022\017\n\007endLine\030\002 \001(\005\022\023\n\013startO" + | |||
"ffset\030\003 \001(\005\022\021\n\tendOffset\030\004 \001(\005*E\n\010Severi" + | |||
"ty\022\010\n\004INFO\020\000\022\t\n\005MINOR\020\001\022\t\n\005MAJOR\020\002\022\014\n\010CR" + | |||
"ITICAL\020\003\022\013\n\007BLOCKER\020\004*>\n\nRuleStatus\022\010\n\004B" + | |||
"ETA\020\000\022\016\n\nDEPRECATED\020\001\022\t\n\005READY\020\002\022\013\n\007REMO" + | |||
"VED\020\003B\034\n\020org.sonarqube.wsB\006CommonH\001" | |||
"\"<\n\006Paging\022\021\n\tpageIndex\030\001 \001(\005\022\020\n\010pageSiz" + | |||
"e\030\002 \001(\005\022\r\n\005total\030\003 \001(\005\"K\n\005Facet\022\020\n\010prope" + | |||
"rty\030\001 \001(\t\0220\n\006values\030\002 \003(\0132 .sonarqube.ws" + | |||
".commons.FacetValue\"(\n\nFacetValue\022\013\n\003val" + | |||
"\030\001 \001(\t\022\r\n\005count\030\002 \001(\003\"s\n\004Rule\022\013\n\003key\030\001 \001" + | |||
"(\t\022\014\n\004name\030\002 \001(\t\022\014\n\004lang\030\003 \001(\t\0220\n\006status" + | |||
"\030\004 \001(\0162 .sonarqube.ws.commons.RuleStatus" + | |||
"\022\020\n\010langName\030\005 \001(\t\"B\n\004User\022\r\n\005login\030\001 \001(" + | |||
"\t\022\014\n\004name\030\002 \001(\t\022\r\n\005email\030\003 \001(\t\022\016\n\006active", | |||
"\030\004 \001(\010\"W\n\tTextRange\022\021\n\tstartLine\030\001 \001(\005\022\017" + | |||
"\n\007endLine\030\002 \001(\005\022\023\n\013startOffset\030\003 \001(\005\022\021\n\t" + | |||
"endOffset\030\004 \001(\005*E\n\010Severity\022\010\n\004INFO\020\000\022\t\n" + | |||
"\005MINOR\020\001\022\t\n\005MAJOR\020\002\022\014\n\010CRITICAL\020\003\022\013\n\007BLO" + | |||
"CKER\020\004*>\n\nRuleStatus\022\010\n\004BETA\020\000\022\016\n\nDEPREC" + | |||
"ATED\020\001\022\t\n\005READY\020\002\022\013\n\007REMOVED\020\003B\034\n\020org.so" + | |||
"narqube.wsB\006CommonH\001" | |||
}; | |||
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = | |||
new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { | |||
@@ -5029,7 +4951,7 @@ public final class Common { | |||
internal_static_sonarqube_ws_commons_Paging_fieldAccessorTable = new | |||
com.google.protobuf.GeneratedMessage.FieldAccessorTable( | |||
internal_static_sonarqube_ws_commons_Paging_descriptor, | |||
new java.lang.String[] { "PageIndex", "PageSize", "Total", "Pages", }); | |||
new java.lang.String[] { "PageIndex", "PageSize", "Total", }); | |||
internal_static_sonarqube_ws_commons_Facet_descriptor = | |||
getDescriptor().getMessageTypes().get(1); | |||
internal_static_sonarqube_ws_commons_Facet_fieldAccessorTable = new |
@@ -28,7 +28,6 @@ message Paging { | |||
optional int32 pageIndex = 1; | |||
optional int32 pageSize = 2; | |||
optional int32 total = 3; | |||
optional int32 pages = 4; | |||
} | |||
message Facet { |
@@ -32,9 +32,23 @@ message UsersResponse { | |||
message User { | |||
optional string login = 1; | |||
optional string name = 2; | |||
optional bool selected = 4; | |||
optional bool selected = 3; | |||
} | |||
repeated User users = 1; | |||
optional sonarqube.ws.commons.Paging paging = 2; | |||
} | |||
// WS api/permissions/groups for internal use only | |||
message GroupsResponse { | |||
message Group { | |||
optional string id = 1; | |||
optional string name = 2; | |||
optional string description = 3; | |||
optional bool selected = 4; | |||
} | |||
repeated Group groups = 1; | |||
optional sonarqube.ws.commons.Paging paging = 2; | |||
} |