private async Task UpdateAllTenantPermission(CreateOrUpdateRoleInput input)
{
List <int> tenantId = new List <int>();
if (input.Role.DisplayName == StaticRoleNames.Host.Cruise)
{
tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Cruise).Select(x => x.Id).ToList();
}
else if (input.Role.DisplayName == StaticRoleNames.Host.Cruise)
{
tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Ship).Select(x => x.Id).ToList();
}
else if (input.Role.DisplayName == StaticRoleNames.Host.Cruise)
{
tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Travel).Select(x => x.Id).ToList();
}
foreach (var item in tenantId)
{
using (UnitOfWorkManager.Current.SetTenantId(item))
{
var rolesAdmin = _roleManager.Roles.ToList();
foreach (var item2 in rolesAdmin)
{
var grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(item2)).Where(x => x.MultiTenancySides != Abp.MultiTenancy.MultiTenancySides.Host).ToArray();
var d = grantedPermissions.Where(x => input.GrantedPermissionNames.Any(z => z == x.Name)).Select(x => x.Name).ToList();
await UpdateGrantedPermissionsAsync(item2, d);
}
}
}
CurrentUnitOfWork.SaveChanges();
}
public async Task Should_Update_Role()
{
var testRole = await CreateAndGetTestRoleAsync();
var input = new CreateOrUpdateRoleInput
{
Role = new RoleDto
{
Id = testRole.Id,
Name = "TestRoleName_Edited_" + Guid.NewGuid()
},
GrantedPermissionIds = new List <Guid> {
DefaultPermissions.MemberAccess.Id
}
};
var requestMessage = new HttpRequestMessage(HttpMethod.Put, "/api/roles");
requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _token);
requestMessage.Content = input.ToStringContent(Encoding.UTF8, "application/json");
var responseAddRole = await TestServer.CreateClient().SendAsync(requestMessage);
Assert.Equal(HttpStatusCode.OK, responseAddRole.StatusCode);
var dbContextFromAnotherScope = GetNewScopeServiceProvider().GetService <NucleusDbContext>();
var editedTestRole = await dbContextFromAnotherScope.Roles.FindAsync(testRole.Id);
Assert.Contains(editedTestRole.RolePermissions, rp => rp.PermissionId == DefaultPermissions.MemberAccess.Id);
}
public async Task Should_Create_Role()
{
var input = new CreateOrUpdateRoleInput
{
Role = new RoleDto
{
Name = "TestRoleName_" + Guid.NewGuid()
},
GrantedPermissionIds = new List <Guid> {
DefaultPermissions.MemberAccess.Id
}
};
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/api/roles");
requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _token);
requestMessage.Content = input.ToStringContent(Encoding.UTF8, "application/json");
var responseAddRole = await TestServer.CreateClient().SendAsync(requestMessage);
Assert.Equal(HttpStatusCode.Created, responseAddRole.StatusCode);
var insertedRole = await DbContext.Roles.FirstAsync(r => r.Name == input.Role.Name);
Assert.NotNull(insertedRole);
}
protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input)
{
var entity = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value);
ObjectMapper.Map(input.Role, entity);
CurrentUnitOfWork.SaveChanges();
await UpdateGrantedPermissionsAsync(entity, input.GrantedPermissionNames);
}
private async Task UpdateRoleAsync(CreateOrUpdateRoleInput input)
{
Debug.Assert(input.Role.Id != null, "input.Role.Id should be set.");
var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value);
role.DisplayName = input.Role.DisplayName;
role.IsDefault = input.Role.IsDefault;
await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames);
}
public virtual async Task Update(CreateOrUpdateRoleInput input)
{
if (!input.EntityDto.Id.HasValue)
{
return;
}
await _roleManager.UpdateAsync(input.EntityDto.Id, input.EntityDto.DisplayName, input.EntityDto.Description, input.Permissions?.ToArray());
}
public virtual async Task Create(CreateOrUpdateRoleInput input)
{
await _roleManager.CreateAsync(
input.EntityDto.Name,
input.EntityDto.DisplayName,
input.EntityDto.Description,
permissions : input.Permissions?.ToArray()
);
}
/// <summary>
/// 新增角色
/// </summary>
public async Task <RoleEditDto> CreateAsync(CreateOrUpdateRoleInput input)
{
//TODO: 新增前的逻辑判断，是否允许新增
var entity = input.RoleEditDto.MapTo <Role>();
entity = await _roleRepository.InsertAsync(entity);
return(entity.MapTo <RoleEditDto>());
}
protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input)
{
RoleManager roleManager = this._roleManager;
int? id = input.Role.Id;
Role roleByIdAsync = await roleManager.GetRoleByIdAsync(id.Value);
roleByIdAsync.DisplayName = input.Role.DisplayName;
roleByIdAsync.IsDefault = input.Role.IsDefault;
await this.UpdateGrantedPermissionsAsync(roleByIdAsync, input.GrantedPermissionNames);
}
/// <summary>
/// 更新角色
/// </summary>
public async Task UpdateAsync(CreateOrUpdateRoleInput input)
{
//TODO: 更新前的逻辑判断，是否允许更新
var entity = await _roleRepository.GetAsync(input.RoleEditDto.Id.Value);
input.RoleEditDto.MapTo(entity);
await _roleRepository.UpdateAsync(entity);
}
public async Task CreateOrUpdateRole(CreateOrUpdateRoleInput input)
{
if (input.Role.Id.HasValue)
{
await UpdateRoleAsync(input);
}
else
{
await CreateRoleAsync(input);
}
}
/// <summary>
/// 新增或编辑角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <EntityDto> CreateOrUpdateRole(CreateOrUpdateRoleInput input)
{
if (input.Item.Id.HasValue)
{
return(await UpdateRoleAsync(input));
}
else
{
return(await CreateRoleAsync(input));
}
}
public async Task <int> CreateOrUpdateRole(CreateOrUpdateRoleInput input)
{
if (input.Role.Id.HasValue)
{
return(await UpdateRoleAsync(input));
}
else
{
return(await CreateRoleAsync(input));
}
}
public async Task <ActionResult> PutRoles([FromBody] CreateOrUpdateRoleInput input)
{
var identityResult = await _roleAppService.EditRoleAsync(input);
if (identityResult.Succeeded)
{
return(Ok());
}
return(BadRequest(identityResult.Errors.Select(e => new NameValueDto(e.Code, e.Description))));
}
protected virtual async Task CreateRoleAsync(CreateOrUpdateRoleInput input)
{
var role = new Role(AbpSession.TenantId, input.Role.DisplayName)
{
IsDefault = input.Role.IsDefault
};
CheckErrors(await _roleManager.CreateAsync(role));
await CurrentUnitOfWork.SaveChangesAsync(); //It's done to get Id of the role.
await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames);
}
protected virtual async Task <EntityDto> UpdateRoleAsync(CreateOrUpdateRoleInput input)
{
//Debug.Assert(input.Role.Id != null, "input.Role.Id should be set.");
var role = await _roleManager.GetRoleByIdAsync(input.Item.Id.Value);
role.DisplayName = input.Item.DisplayName;
role.IsDefault = input.Item.IsDefault;
await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames);
return(new EntityDto(role.Id));
}
/// <summary>
///
/// </summary>
protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input)
{
Debug.Assert(input.Role.Id != null, "角色id不可为null");
var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value);
role.DisplayName = input.Role.DisplayName;
role.IsDefault = input.Role.IsDefault;
role.IsActive = input.Role.IsActive;
role.Description = input.Role.Description;
await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames);
}
public async Task <ActionResult> CreateOrUpdateRole([FromBody] CreateOrUpdateRoleInput input)
{
if (input.Role.Id == Guid.Empty)
{
await _roleAppService.AddRoleAsync(input);
}
else
{
await _roleAppService.EditRoleAsync(input);
}
return(Ok(new { success = true }));
}
public async Task EditRoleAsync(CreateOrUpdateRoleInput input)
{
var role = await _roleManager.FindByIdAsync(input.Role.Id.ToString());
role.Name = input.Role.Name;
role.RolePermissions.Clear();
var updateRoleResult = await _roleManager.UpdateAsync(role);
if (updateRoleResult.Succeeded)
{
GrantPermissionsToRole(input.GrantedPermissionIds, role);
}
}
protected virtual async Task CreateRoleAsync(CreateOrUpdateRoleInput input)
{
Role role = new Role(this.AbpSession.TenantId, input.Role.DisplayName)
{
IsDefault = input.Role.IsDefault
};
Role role1 = role;
this.CheckErrors(await this._roleManager.CreateAsync(role1));
await this.CurrentUnitOfWork.SaveChangesAsync();
await this.UpdateGrantedPermissionsAsync(role1, input.GrantedPermissionNames);
}
public async Task AddRoleAsync(CreateOrUpdateRoleInput input)
{
var role = new Role
{
Id = input.Role.Id,
Name = input.Role.Name
};
var createRoleResult = await _roleManager.CreateAsync(role);
if (createRoleResult.Succeeded)
{
GrantPermissionsToRole(input.GrantedPermissionIds, role);
}
}
protected virtual async Task UpdateAsync(CreateOrUpdateRoleInput input)
{
Debug.Assert(input.Role.Id != null, "input.Role.Id != null");
var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value);
_mapper.Map(input.Role, role);
CheckErrors(await _roleManager.UpdateAsync(role));
var grantedPermissions = PermissionManager
.GetAllPermissions()
.Where(p => input.GrantedPermissions.Contains(p.Name))
.ToList();
await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions);
}
public async Task <RoleDto> Create(CreateOrUpdateRoleInput input)
{
CheckCreatePermission();
var role = ObjectMapper.Map <Role>(input.Role);
CheckErrors(await _roleManager.CreateAsync(role));
var grantedPermissions = PermissionManager
.GetAllPermissions()
.Where(p => input.GrantedPermissionNames.Contains(p.Name))
.ToList();
await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions);
return(MapToEntityDto(role));
}
protected virtual async Task CreateAsync(CreateOrUpdateRoleInput input)
{
var role = _mapper.Map <Role>(input.Role);
role.SetNormalizedName();
CheckErrors(await _roleManager.CreateAsync(role));
if (input.GrantedPermissions.Any())
{
var grantedPermissions = PermissionManager
.GetAllPermissions()
.Where(p => input.GrantedPermissions.Contains(p.Name))
.ToList();
await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions);
}
}
public async Task <ActionResult> CreateOrUpdateRole([FromBody] CreateOrUpdateRoleInput input)
{
IdentityResult identityResult;
if (input.Role.Id == Guid.Empty)
{
identityResult = await _roleAppService.AddRoleAsync(input);
}
else
{
identityResult = await _roleAppService.EditRoleAsync(input);
}
if (identityResult.Succeeded)
{
return(Ok());
}
return(BadRequest(identityResult.Errors.Select(e => new NameValueDto(e.Code, e.Description))));
}
public async Task UpdateUserPermissionsUnit(UserPermissionsInput input)
{
await _userRoleRepository.DeleteAsync(p => p.UserId == input.UserId);
CreateOrUpdateRoleInput request = new CreateOrUpdateRoleInput();
request.Role = input.Role;
request.GrantedPermissionNames = input.GrantedPermissionNames;
int roleId = await _roleAppService.CreateRoleForUserAsync(request);
UserRole userrole = new UserRole
{
RoleId = roleId,
UserId = input.UserId.Value
};
await _userRoleRepository.InsertAsync(userrole);
await _unitOfWorkManager.Current.SaveChangesAsync();
}
public async void Should_Edit_Role()
{
var testRole = await CreateAndGetTestRoleAsync();
var input = new CreateOrUpdateRoleInput
{
Role = new RoleDto
{
Id = testRole.Id,
Name = "TestRoleName_Edited_" + Guid.NewGuid()
},
GrantedPermissionIds = new List <Guid> {
DefaultPermissions.MemberAccess.Id
}
};
await _roleAppService.EditRoleAsync(input);
var editedTestRole = await _dbContext.Roles.FindAsync(testRole.Id);
Assert.Contains("TestRoleName_Edited_", editedTestRole.Name);
Assert.Contains(editedTestRole.RolePermissions, rp => rp.PermissionId == DefaultPermissions.MemberAccess.Id);
}
public async Task <IdentityResult> EditRoleAsync(CreateOrUpdateRoleInput input)
{
if (await _roleManager.RoleExistsAsync(input.Role.Name))
{
return(IdentityResult.Failed(new IdentityError()
{
Code = "RoleNameAlreadyExist",
Description = "Role name '" + input.Role.Name + "' is already taken!"
}));
}
var role = await _roleManager.FindByIdAsync(input.Role.Id.ToString());
role.Name = input.Role.Name;
role.RolePermissions.Clear();
var updateRoleResult = await _roleManager.UpdateAsync(role);
if (updateRoleResult.Succeeded)
{
GrantPermissionsToRole(input.GrantedPermissionIds, role);
}
return(updateRoleResult);
}
public async void Should_Add_Role()
{
var input = new CreateOrUpdateRoleInput
{
Role = new RoleDto
{
Id = Guid.NewGuid(),
Name = "TestRoleName_" + Guid.NewGuid()
},
GrantedPermissionIds = new List <Guid> {
DefaultPermissions.MemberAccess.Id
}
};
await _roleAppService.AddRoleAsync(input);
await _dbContext.SaveChangesAsync();
var dbContextFromAnotherScope = TestServer.Host.Services.GetRequiredService <NucleusDbContext>();
var insertedTestRole = await dbContextFromAnotherScope.Roles.FindAsync(input.Role.Id);
Assert.NotNull(insertedTestRole);
Assert.Equal(1, insertedTestRole.RolePermissions.Count);
}
/// <summary>
/// 更新角色记录
/// </summary>
public async Task UpdateInfRole(CreateOrUpdateRoleInput input)
{
await UpdateRoleAsync(input);
}
