global_permissions.dryRunScan=Execute Local Analysis (Dry Run)
global_permissions.dryRunScan.desc=Ability to execute local (dry run) analyses without pushing the results to the server, and to get all settings required to perform a local analysis. This permission does not include the ability to access secured settings such as the scm account password, the jira account password, and so on.<br/>\
This permission is <em>required</em> to execute a local analysis in Eclipse or via the Issues Report plugin.
-global_permissions.error.need_at_lest_one_admin=At least one admin must be defined.
#------------------------------------------------------------------------------
#
MyBatis.closeQuietly(session);
}
}
-
- public int countUserWithPermission(String permission) {
- SqlSession session = mybatis.openSession();
- try {
- RoleMapper mapper = session.getMapper(RoleMapper.class);
- return mapper.countUserWithPermission(permission);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
}
import org.apache.ibatis.annotations.Param;
+import javax.annotation.Nullable;
import java.util.List;
/**
int countUserRoles(Long resourceId);
- int countUserWithPermission(@Param("permission") String permission);
-
+ List<Long> countSystemAdministrators(@Nullable @Param("groupName") String groupName);
}
SELECT count(id)
FROM group_roles WHERE resource_id=#{id}
</select>
-
- <select id="countUserWithPermission" parameterType="map" resultType="int">
- SELECT COUNT(DISTINCT tmp.id)
- FROM (
- SELECT u.id as id
- FROM users u
- INNER JOIN user_roles ur ON ur.user_id = u.id
- <where>
- AND (ur.role=#{permission} AND ur.resource_id IS NULL)
- AND u.active=${_true}
- </where>
- UNION
- select u.id as id
- FROM users u
- INNER JOIN groups_users gu ON gu.user_id = u.id
- INNER JOIN group_roles gr ON gr.group_id = gu.group_id
- INNER JOIN groups g ON g.id = gu.group_id
- <where>
- AND (gr.role=#{permission} AND gr.resource_id IS NULL)
- AND u.active=${_true}
- </where>
- ) tmp
- </select>
-
</mapper>
checkTable("groupPermissions", "group_roles", "group_id", "role");
}
- @Test
- public void should_count_user_with_permission() {
- setupData("should_count_user_with_permission");
-
- RoleDao dao = new RoleDao(getMyBatis());
-
- // 1 user have role 'admin', 1 user owns to the 'admin' group
- assertThat(dao.countUserWithPermission("admin")).isEqualTo(2);
- // 1 user have role 'profileadmin'
- assertThat(dao.countUserWithPermission("profileadmin")).isEqualTo(1);
- // 1 user owns to the 'user' group
- assertThat(dao.countUserWithPermission("user")).isEqualTo(1);
- assertThat(dao.countUserWithPermission("unknown")).isEqualTo(0);
- }
-
}
+++ /dev/null
-<dataset>
-
- <!-- users having role -->
-
- <users id="200" login="admin_user" name="admin_user" active="[true]"/>
- <users id="201" login="profile_admin_user" name="profile_admin_user" active="[true]"/>
-
- <user_roles id="1" user_id="200" role="admin"/>
- <user_roles id="2" user_id="201" role="profileadmin"/>
-
- <!-- users having group -->
-
- <users id="202" login="admin_group" name="admin_group" active="[true]"/>
- <users id="203" login="user_group" name="user_group" active="[true]"/>
-
- <groups id="100" name="sonar-administrators"/>
- <groups id="101" name="sonar-users"/>
-
- <group_roles id="1" group_id="100" role="admin"/>
- <group_roles id="2" group_id="101" role="user"/>
-
- <groups_users user_id="202" group_id="100"/>
- <groups_users user_id="203" group_id="101"/>
-
-</dataset>
*/
package org.sonar.api.utils;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Collection;
-import java.util.Collections;
-
-import static com.google.common.collect.Lists.newArrayList;
-
/**
* Runtime exception for "functional" errors. It aims to be displayed to end-users, without any technical information
* like stack traces.
*/
public class MessageException extends RuntimeException {
- private String l10nKey;
- private Collection<Object> l10nParams;
-
public MessageException(String s) {
super(s);
}
- public MessageException(@Nullable String message, @Nullable String l10nKey, @Nullable Object[] l10nParams) {
- super(message);
- this.l10nKey = l10nKey;
- this.l10nParams = l10nParams == null ? Collections.emptyList() : Collections.unmodifiableCollection(newArrayList(l10nParams));
- }
-
/**
* Does not fill in the stack trace
*
return getMessage();
}
- @CheckForNull
- public String l10nKey() {
- return l10nKey;
- }
-
- @CheckForNull
- public Collection<Object> l10nParams() {
- return l10nParams;
- }
}
assertThat(writer.toString()).isEqualTo(message + System.getProperty("line.separator"));
}
}
-
- @Test
- public void should_create_exception_with_status_and_l10n_message_with_param(){
- MessageException exception = new MessageException(null, "key", new String[]{"value"});
- assertThat(exception.l10nKey()).isEqualTo("key");
- assertThat(exception.l10nParams()).containsOnly("value");
- }
-
- @Test
- public void should_create_exception_with_status_and_l10n_message_without_param(){
- MessageException exception = new MessageException(null, "key", null);
- assertThat(exception.l10nKey()).isEqualTo("key");
- assertThat(exception.l10nParams()).isEmpty();
- }
}
import org.slf4j.LoggerFactory;
import org.sonar.api.ServerComponent;
import org.sonar.api.security.DefaultGroups;
-import org.sonar.api.utils.MessageException;
import org.sonar.core.permission.ComponentPermissionFacade;
import org.sonar.core.permission.Permission;
import org.sonar.core.user.*;
}
}
- public void checkAtLeatOneSysAdminExists(){
- if (roleDao.countUserWithPermission(Permission.SYSTEM_ADMIN.key()) == 0){
- throw new MessageException(null, "global_permissions.error.need_at_lest_one_admin", null);
- }
- }
-
private void applyPermissionTemplate(String templateKey, String componentId) {
permissionFacade.applyPermissionTemplate(templateKey, Long.parseLong(componentId));
}
before_filter :admin_required
def index
- @groups = Group.all(:order => 'name')
+ @groups = Group.find(:all, :order => 'name')
if params[:id]
@group = Group.find(params[:id])
else
end
def to_index(errors, id)
- unless errors.empty?
+ if !errors.empty?
flash[:error] = errors.full_messages.join("<br/>\n")
end
end
def destroy
- begin
- user = User.find(params[:id])
- Api.users.deactivate(user.login)
+ @user = User.find(params[:id])
+
+ if current_user.id==@user.id
+ flash[:error] = 'Please log in with another user in order to delete yourself.'
+
+ else
+ Api.users.deactivate(@user.login)
flash[:notice] = 'User is deleted.'
- rescue Java::OrgSonarServerExceptions::HttpException => exception
- error = exception.cause
- flash[:error] = (error.getMessage ? error.getMessage : Api::Utils.message(error.l10nKey, :params => error.l10nParams.to_a))
end
- redirect_to(:action => 'index', :id => nil)
+ to_index(@user.errors, nil)
end
def select_group
end
def to_index(errors, id)
- unless errors.empty?
+ if !errors.empty?
flash[:error] = errors.full_messages.join("<br/>\n")
end
$j('input[type=submit]', obj).removeAttr('disabled');
errorElt.show();
errorElt.html(xhr.responseText);
- } else {
// otherwise replace modal window by the returned text
+ } else {
$j("#modal").html(xhr.responseText);
}
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.security.DefaultGroups;
-import org.sonar.api.utils.MessageException;
import org.sonar.core.permission.ComponentPermissionFacade;
import org.sonar.core.permission.Permission;
import org.sonar.core.user.*;
import java.util.Map;
-import static org.fest.assertions.Assertions.assertThat;
-import static org.fest.assertions.Fail.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.*;
verify(permissionFacade).applyPermissionTemplate("my_template_key", 3L);
}
- @Test
- public void should_check_at_least_one_sys_admin_exists() throws Exception {
- // One admin exists -> all is ok
- when(roleDao.countUserWithPermission(anyString())).thenReturn(1);
- service.checkAtLeatOneSysAdminExists();
-
- // No admin -> fail
- try {
- when(roleDao.countUserWithPermission(anyString())).thenReturn(0);
- service.checkAtLeatOneSysAdminExists();
- fail();
- } catch (Exception e){
- assertThat(e).isInstanceOf(MessageException.class);
- }
- }
-
protected static class MatchesUserRole extends BaseMatcher<UserRoleDto> {
private final UserRoleDto referenceDto;
projects / sonarqube.git / commitdiff