/// <summary>
/// 获取所有角色分页列表
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public PagingList<RoleDto> GetRoles(GetRolesInput input)
{
var query = _roleRepository.Table;
var source = query.OrderBy(n => n.Id)
.Skip((input.PageIndex - 1) * input.PageSize)
.Take(input.PageSize)
.MapTo<List<RoleDto>>();
var result = new PagingList<RoleDto>(source, input.PageIndex, input.PageSize, query.LongCount());
return result;
}
public async Task <ListResultDto <RoleListDto> > GetRolesAsync(GetRolesInput input)
{
var roles = await _roleManager
.Roles
.WhereIf(
!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted)
)
.ToListAsync();
return(new ListResultDto <RoleListDto>(ObjectMapper.Map <List <RoleListDto> >(roles)));
}
public async Task <ListResultDto <RoleListDto> > GetRoles(GetRolesInput input)
{
var roles = await _roleManager
.Roles
.WhereIf(
!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted)
)
.WhereIf(!input.Filter.IsNullOrWhiteSpace(), r => r.DisplayName.Contains(input.Filter))
.ToListAsync();
return(new ListResultDto <RoleListDto>(roles.MapTo <List <RoleListDto> >()));
}
public async Task <GetRolesOutput> GetRoles(GetRolesInput input)
{
var roles = _roleManager.GetRoles().Where(e => (string.IsNullOrEmpty(input.SearchKey) || e.Name.Contains(input.SearchKey)));
int num = roles.Count();
var queryResults = roles.Skip((input.PageIndex - 1) * input.PageSize).Take(input.PageSize).ToList();
return(new GetRolesOutput()
{
Roles = _objectMapper.Map <List <RoleDto> >(queryResults), ResourceNum = num, PageIndex = input.PageIndex
});
}
public async Task GetRolesByPermissionInTenant_Test()
{
CreateTenantDto createTenantDto = new CreateTenantDto()
{
TenancyName = "TestTenant",
Name = "TestTenant",
AdminPhoneNumber = "13851400000",
IsActive = true
};
var tenantDto = await _tenantAppService.CreateAsync(createTenantDto);
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto1);
var createRoleDto2 = new CreateRoleDto()
{
Name = "Role2",
DisplayName = "Test role2",
Description = "Role2 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Users
}
};
var role2Dto = await _omRoleAppService.CreateRoleInTenantAsync(tenantDto.Id, createRoleDto2);
GetRolesInput input1 = new GetRolesInput()
{
Permission = string.Empty
};
var roles1 = await _omRoleAppService.GetRolesByPermissionInTenantAsync(tenantDto.Id, input1);
roles1.Items.Count.ShouldBe(3);
GetRolesInput input2 = new GetRolesInput()
{
Permission = PermissionNames.Pages_Users
};
var roles2 = await _omRoleAppService.GetRolesByPermissionInTenantAsync(tenantDto.Id, input2);
roles2.Items.Count.ShouldBe(2);
}
public async Task <PagedResultOutput <RoleListDto> > GetRoles(GetRolesInput input)
{
var roles = await _roleManager
.Roles
.WhereIf(
!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted)
).WhereIf(!input.RoleName.IsNullOrWhiteSpace(), rn => rn.DisplayName.Contains(input.RoleName))
.ToListAsync();
var total = roles.Count();
return(new PagedResultOutput <RoleListDto>(total, roles.MapTo <List <RoleListDto> >()));
}
public async Task Execute(GetRolesInput input)
{
var currentUserId = currentUser.UserId;
if (!await identityService.CheckRole(currentUserId, Roles.Admin))
{
outputPort.WriteError("You role is not Administrator");
return;
}
var roles = await context.Roles
.ProjectTo <RoleDto>(mapper.ConfigurationProvider)
.ToListAsync();
outputPort.Standart(new GetRolesOutput(roles));
// return new RolesVm() { Roles = roles };
}
public async Task <PagedResultDto <RoleListDto> > GetPagedRoleAsync(GetRolesInput input)
{
Expression <Func <Role, bool> > whereif = w => w.Name == input.FilterText;
var predicate = new PredicateGroup <Role>();
predicate.AddPredicate(!string.IsNullOrEmpty(input.FilterText), whereif);
var tuple = await _roleManage.GetPagedRoleAsync(predicate.Predicates, input);
var roleListDtos = tuple.Item1.MapTo <List <RoleListDto> >();
return(new PagedResultDto <RoleListDto>(
tuple.Item2,
roleListDtos
));
}
/// <summary>
/// 分页获取角色列表
/// </summary>
public async Task <PagedResultDto <RoleListDto> > GetRolesAsync(GetRolesInput input)
{
var query = RoleManager.Roles
.WhereIf(!input.Filter.IsNullOrWhiteSpace(), w => w.DisplayName.Contains(input.Filter))
.WhereIf(
!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted)
);
var roleCount = await query.CountAsync();
var roles = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
return(new PagedResultDto <RoleListDto>(roleCount, roles.MapTo <List <RoleListDto> >()));
}
public async Task <PagedResultDto <RoleListDto> > GetPagedAsync(GetRolesInput input)
{
var query = GetRolesFilteredQuery(input);
var userCount = await query.CountAsync();
var users = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var userListDtos = _mapper.Map <List <RoleListDto> >(users);
return(new PagedResultDto <RoleListDto>(
userCount,
userListDtos
));
}
public async Task <ListResultOutput <RoleListDto> > GetRoles(GetRolesInput input)
{
var isFilterPermissionGrantedByDefault = false;
if (!input.Permission.IsNullOrWhiteSpace())
{
isFilterPermissionGrantedByDefault = PermissionManager.GetPermission(input.Permission).IsGrantedByDefault;
}
var roles = await _roleManager.Roles
.WhereIf(!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted) ||
(r.Permissions.All(rp => rp.Name != input.Permission) && isFilterPermissionGrantedByDefault)
)
.ToListAsync();
return(new ListResultOutput <RoleListDto>(roles.MapTo <List <RoleListDto> >()));
}
public async Task GetRolesByPermission_Test()
{
var createRoleDto1 = new CreateRoleDto()
{
Name = "Role1",
DisplayName = "Test role1",
Description = "Role1 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Roles
}
};
var role1Dto = await _roleAppService.CreateAsync(createRoleDto1);
var createRoleDto2 = new CreateRoleDto()
{
Name = "Role2",
DisplayName = "Test role2",
Description = "Role2 for test",
GrantedPermissions = new List <string>()
{
PermissionNames.Pages_Users
}
};
var role2Dto = await _roleAppService.CreateAsync(createRoleDto2);
GetRolesInput input1 = new GetRolesInput()
{
Permission = string.Empty
};
var roles1 = await _roleAppService.GetRolesByPermissionAsync(input1);
roles1.Items.Count.ShouldBe(3); // + Admin Role
GetRolesInput input2 = new GetRolesInput()
{
Permission = PermissionNames.Pages_Users
};
var roles2 = await _roleAppService.GetRolesByPermissionAsync(input2);
roles2.Items.Count.ShouldBe(2); // Admin & Role2
}
/// <summary>
/// 获取所有角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultDto <RoleListDto> > GetRoles([FromQuery] GetRolesInput input)
{
var query = _roleManager
.Roles
.WhereIf(!input.DisplayName.IsNullOrWhiteSpace(), r => r.DisplayName.Contains(input.DisplayName))
.WhereIf(!input.Permission.IsNullOrWhiteSpace(), r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted));
var roleCount = await query.CountAsync();
var roles = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var roleListDtos = ObjectMapper.Map <List <RoleListDto> >(roles);
return(new PagedResultDto <RoleListDto>(
roleCount,
roleListDtos));
}
public void GetRolesAsync_StateUnderTest_ExpectedBehavior()
{
LoginAsHost("85261107946");
// Arrange
var service = this.CreateService();
service.ObjectMapper = LocalIocManager.Resolve <Abp.ObjectMapping.IObjectMapper>();
service.UnitOfWorkManager = Resolve <IUnitOfWorkManager>();
service.UnitOfWorkManager.Begin();
GetRolesInput input1 = new GetRolesInput {
Permission = ""
};
GetRolesInput input2 = new GetRolesInput {
Permission = "role3"
};
GetRolesInput input3 = new GetRolesInput {
Permission = "nodata"
};
GetRolesInput input4 = new GetRolesInput {
Permission = null
};
// Act
var result1 = service.GetRolesAsync(
input1);
var result2 = service.GetRolesAsync(
input2);
var result3 = service.GetRolesAsync(
input3);
var result4 = service.GetRolesAsync(
input4);
// Assert
Assert.True(result1.Status == TaskStatus.RanToCompletion && result1.Result.Items.Count > 0);
Assert.True(result2.Status == TaskStatus.RanToCompletion && result2.Result.Items.Count > 0);
Assert.True(result3.Status == TaskStatus.RanToCompletion && result3.Result.Items.Count == 0);
Assert.True(result4.Status == TaskStatus.RanToCompletion && result4.Result.Items.Count > 0);
}
public async Task <ListResultDto <RoleListDto> > GetRoles(GetRolesInput input)
{
var query = _roleManager.Roles;
if (!string.IsNullOrEmpty(input.Permission))
{
var staticRoleNames = _roleManagementConfig.StaticRoles.Where(
r => r.GrantAllPermissionsByDefault &&
r.Side == AbpSession.MultiTenancySide
).Select(r => r.RoleName).ToList();
query = query.Where(r =>
r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted) ||
staticRoleNames.Contains(r.Name)
);
}
var roles = await query.ToListAsync();
return(new ListResultDto <RoleListDto>(ObjectMapper.Map <List <RoleListDto> >(roles)));
}
public PagedResultOutput <RoleDto> GetRoles(GetRolesInput input)
{
if (input.MaxResultCount <= 0)
{
input.MaxResultCount = SettingManager.GetSettingValue <int>(MySettingProvider.RolesDefaultPageSize);
}
var RoleCount = _RoleRepository.Count();
var Roles =
_RoleRepository
.GetAll()
.Include(q => q.CreatorUser)
.OrderBy(input.Sorting)
.PageBy(input)
.ToList();
return(new PagedResultOutput <RoleDto>
{
TotalCount = RoleCount,
Items = Roles.MapTo <List <RoleDto> >()
});
}
public async Task <ListResultDto <RoleListDto> > GetRoles(GetRolesInput input)
{
var query = _roleManager.Roles;
var user = await UserManager.GetUserByIdAsync(AbpSession.GetUserId());
var isAdmin = await UserManager.IsInRoleAsync(user, StaticRoleNames.Host.Admin);
if (!isAdmin)
{
query = query.Where(x => x.Name != StaticRoleNames.Host.Admin);
}
if (input.Permissions != null && input.Permissions.Any(p => !string.IsNullOrEmpty(p)))
{
input.Permissions = input.Permissions.Where(p => !string.IsNullOrEmpty(p)).ToList();
var staticRoleNames = _roleManagementConfig.StaticRoles.Where(
r => r.GrantAllPermissionsByDefault &&
r.Side == AbpSession.MultiTenancySide
).Select(r => r.RoleName).ToList();
foreach (var permission in input.Permissions)
{
query = query.Where(r =>
r.Permissions.Any(rp => rp.Name == permission)
? r.Permissions.Any(rp => rp.Name == permission && rp.IsGranted)
: staticRoleNames.Contains(r.Name)
);
}
}
var roles = await query.ToListAsync();
return(new ListResultDto <RoleListDto>(ObjectMapper.Map <List <RoleListDto> >(roles)));
}
public async Task <PagedResultDto <RoleListDto> > GetPagedRoleAsync(GetRolesInput input)
{
return(await _roleAppService.GetPagedRoleAsync(input));
}
public async Task <JsonResult> Load(GetRolesInput input)
{
var roles = await _roleAppService.GetPagedAsync(input);
return(Json(roles));
}
/// <summary>
/// 角色管理
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">每页数据数</param>
/// <returns></returns>
public virtual ActionResult ManageRoles(int pageIndex = 1, int pageSize = 5)
{
var input = new GetRolesInput
{
PageIndex = pageIndex,
PageSize = pageSize
};
var roles = _roleService.GetRoles(input);
return View(roles);
}
public async Task <ListResultDto <RoleListDto> > GetAllRolesInTenantAsync(int tenantId, GetRolesInput input)
{
using (CurrentUnitOfWork.SetTenantId(tenantId))
{
var roles = await _roleManager
.Roles
.WhereIf(
!input.Permission.IsNullOrWhiteSpace(),
r => r.Permissions.Any(rp => rp.Name == input.Permission && rp.IsGranted)
)
.ToListAsync();
return(new ListResultDto <RoleListDto>(ObjectMapper.Map <List <RoleListDto> >(roles)));
}
}
