public async Task <IActionResult> EditRoles(string userId, RoleEditDto roleEditDto)
{
try
{
var user = await _userManager.FindByIdAsync(userId);
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove the roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside EditRoles endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByNameAsync(userName);
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
//selectedRoles = selectedRoles != null ? selectedRoles : new string [] {}
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
//Member ==> member + modetator
if (!result.Succeeded)
{
return(BadRequest("حدث خطا اثناء اضافه الصلاحيات "));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("حدث خطا اتناء حذف الصلاحيات"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task EditUserRoles(string userId, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
throw new EntityNotFoundException(typeof(User), userId);
}
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames ??= new string[] { };
var addingResult = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!addingResult.Succeeded)
{
throw new IdentityException(addingResult.Errors);
}
var removingResult = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!removingResult.Succeeded)
{
throw new IdentityException(removingResult.Errors);
}
}
public async Task <GetRoleForEditOutput> GetRoleForEdit(string roleKey)
{
var permissions = PermissionManager.GetAllPermissions();
var grantedPermissions = new Permission[0];
RoleEditDto roleEditDto;
if (string.IsNullOrEmpty(roleKey))
{
roleEditDto = new RoleEditDto();
}
else
{
var role = _roleManager.Roles.First(p => p.RoleKey == Guid.Parse(roleKey));
//var role = await _roleManager.GetRoleByIdAsync(input.Id);
grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
roleEditDto = ObjectMapper.Map <RoleEditDto>(role);
}
return(new GetRoleForEditOutput
{
Role = roleEditDto,
Permissions = ObjectMapper.Map <List <FlatPermissionDto> >(permissions).OrderBy(p => p.DisplayName).ToList(),
GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList()
});
}
public async Task UpdateRoleAsync(RoleEditDto input)
{
var info = await _roleManage.GetRoleByIdAsync(input.Id);
input.MapTo(info);
await _roleManage.UpdateRoleAsync(info);
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound());
}
var userRoles = await _userManager.GetRolesAsync(user);
//in case the end user deletes all of his roles, so it could be null
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove the roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task <GetRoleForEditOutput> GetRoleForEdit(NullableIdDto input)
{
var permissions = PermissionManager.GetAllPermissions();
var grantedPermissions = new Permission[0];
RoleEditDto roleEditDto;
if (input.Id.HasValue) //Editing existing role?
{
var role = await _roleManager.GetRoleByIdAsync(input.Id.Value);
grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
roleEditDto = ObjectMapper.Map <RoleEditDto>(role);
}
else
{
roleEditDto = new RoleEditDto();
}
return(new GetRoleForEditOutput
{
Role = roleEditDto,
Permissions = ObjectMapper.Map <List <FlatPermissionDto> >(permissions).OrderBy(p => p.DisplayName).ToList(),
GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList()
});
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByNameAsync(userName);
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove the roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByNameAsync(userName);
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles)); //Ajouter rôle sans repeter l'ancien
if (!result.Succeeded)
{
return(BadRequest("Erreur lors d'ajout de rôle"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));//Supprimer les rôles non séléctionner
if (!result.Succeeded)
{
return(BadRequest("Erreur lors de supprission de rôle"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roles)
{
var result = await _adminManager.EditRoles(userName, roles);
if (result == null)
{
return(BadRequest("Failed to Add/Remove roles"));
}
return(Ok(result));
}
public async Task <IActionResult> EditUsers(string userName, RoleEditDto roleDto)
{
var newAssignment = await AssingRole(userName, roleDto);
if (newAssignment.Succeeded)
{
return(NoContent());
}
return(BadRequest("Error al cambiar roles: " + newAssignment.Errors));
}
public async Task <ResultEntity> AddOrUpdateAsync(RoleEditDto editDto)
{
var result = await _roleManager.AddOrUpdateAsync(Mapper.Map <Role>(editDto));
if (result.Success)
{
await _unitOfWork.CommitAsync();
}
return(result);
}
public async Task <IActionResult> EditRolesAsync(string userName, RoleEditDto roleEditDto)
{
var roles = await userService.ChangeUserRolesAsync(userName, roleEditDto);
if (roles == null)
{
return(BadRequest("Failed to add or remove role for user"));
}
return(Ok(roles));
}
public async Task <IActionResult> EditRoles(string username, RoleEditDto roleEditDto)
{
var user = _repo.GetStudentByUsername(username);
var userRoles = _repo.GetUserRoles(user.Id);
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string [] {};
foreach (var role in selectedRoles)
{
if (role == "Instructor")
{
user.IsInstructor = true;
}
var r = _context.Roles.FirstOrDefault(x => x.Name == role);
var check = _context.StudentRoles.FirstOrDefault(x => x.StudentId == user.Id && x.RoleId == r.Id);
if (check == null)
{
var sr = new StudentRole {
Student = user, Role = r
};
_context.StudentRoles.AddAsync(sr).Wait();
await _context.SaveChangesAsync();
// return Ok(selectedRoles);
}
}
foreach (var role in userRoles)
{
var r = _context.Roles.FirstOrDefault(x => x.Name == role.Name);
var check = _context.StudentRoles.FirstOrDefault(x => x.StudentId == user.Id && x.RoleId == r.Id);
if (check != null && !selectedRoles.Contains(role.Name))
{
_context.StudentRoles.Remove(check);
_context.SaveChangesAsync().Wait();
// return Ok(selectedRoles);
}
}
return(Ok(selectedRoles));
//return BadRequest("User already has that roles.");
}
public async Task <IActionResult> ChangeRoles(string userId, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByIdAsync(userId);
var userRoles = await _userManager.GetRolesAsync(user);
if (userRoles.Any(p => p == roleEditDto.Value))
{
if (roleEditDto.Check)
{
return(NoContent());
}
else
{
var result = await _userManager
.RemoveFromRoleAsync(user, roleEditDto.Value);
if (!result.Succeeded)
{
return(BadRequest("خطا در پاک کردن نقش "));
}
else
{
return(NoContent());
}
}
}
else
{
if (!roleEditDto.Check)
{
return(NoContent());
}
else
{
var result = await _userManager
.AddToRoleAsync(user, roleEditDto.Value);
if (!result.Succeeded)
{
return(BadRequest("خطا در اضافه کردن نقش "));
}
else
{
return(NoContent());
}
}
}
}
public async Task <GetRoleForEditOutput> GetRoleForEdit(EntityDto input)
{
IReadOnlyList <Permission> permissions = PermissionManager.GetAllPermissions();
Role role = await _roleManager.GetRoleByIdAsync(input.Id);
Permission[] grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
RoleEditDto roleEditDto = ObjectMapper.Map <RoleEditDto>(role);
return(new GetRoleForEditOutput
{
Role = roleEditDto,
Permissions = ObjectMapper.Map <List <FlatPermissionDto> >(permissions).OrderBy(p => p.DisplayName).ToList(),
GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList()
});
}
/// <summary>
/// 添加
/// </summary>
/// <param name="input">信息</param>
/// <param name="permission">权限</param>
/// <returns>信息</returns>
public async Task <RoleListDto> AddAsync(RoleEditDto input, string permission)
{
if (await CurrentRepository.IsExistsAsync(u => u.Name == input.Name))
{
throw new UserFriendlyException("角色名已存在");
}
Role role = Mapper.Map <Role>(input);
role.Permissions = CreatePermissions(permission);
role = await CurrentRepository.AddAsync(role);
await CurrentContext.SaveChangesAsync();
return(_mapper.Map <RoleListDto>(role));
}
public async Task <GetRoleForEditOutput> GetRoleForEdit(NullableIdDto input)
{
var permissions = PermissionManager.GetAllPermissions().AsQueryable();
var grantedPermissions = new Permission[0];
RoleEditDto roleEditDto;
var user = await UserManager.GetUserByIdAsync(AbpSession.GetUserId());
var isAdmin = await UserManager.IsInRoleAsync(user, StaticRoleNames.Host.Admin);
if (!isAdmin)
{
permissions = permissions.Where(x => (x.Name != AppPermissions.Pages_DemoUiComponents) &&
(x.Name != AppPermissions.Pages_Administration_Languages) &&
(x.Name != AppPermissions.Pages_Administration_AuditLogs) &&
(x.Name != AppPermissions.Pages_Administration_OrganizationUnits) &&
(x.Name != AppPermissions.Pages_Administration_UiCustomization) &&
(x.Name != AppPermissions.Pages_Tenant_Dashboard) &&
(x.Name != AppPermissions.Pages_Administration_Tenant_Settings) &&
(x.Name != AppPermissions.Pages_Administration_Tenant_SubscriptionManagement) &&
(x.Name != AppPermissions.Pages_Editions) &&
(x.Name != AppPermissions.Pages_Tenants) &&
(x.Name != AppPermissions.Pages_Administration_Host_Settings) &&
(x.Name != AppPermissions.Pages_Administration_Host_Maintenance) &&
(x.Name != AppPermissions.Pages_Administration_HangfireDashboard) &&
(x.Name != AppPermissions.Pages_Administration_Host_Dashboard));
}
if (input.Id.HasValue) //Editing existing role?
{
var role = await _roleManager.GetRoleByIdAsync(input.Id.Value);
grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
roleEditDto = ObjectMapper.Map <RoleEditDto>(role);
}
else
{
roleEditDto = new RoleEditDto();
}
return(new GetRoleForEditOutput
{
Role = roleEditDto,
Permissions = ObjectMapper.Map <List <FlatPermissionDto> >(permissions).OrderBy(p => p.DisplayName).ToList(),
GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList()
});
}
public async Task <IActionResult> Edit(RoleEditDto role)
{
var result = new ResultEntity();
if (ModelState.IsValid)
{
role.SetCreateOrUpdateInfo(CurrentUser.UserId);
result = await _roleAppService.AddOrUpdateAsync(role);
return(Json(result));
}
result.Message = ModelState.Values
.FirstOrDefault(a => a.ValidationState == ModelValidationState.Invalid)?.Errors.FirstOrDefault()
?.ErrorMessage;
return(Json(result));
}
public async Task <RoleEditDto> GetRoleByIdAsync(NullableIdDto <long> input)
{
RoleEditDto edit;
if (input.Id.HasValue)
{
var entity = await _roleManage.GetRoleByIdAsync(input.Id.Value);
edit = entity.MapTo <RoleEditDto>();
}
else
{
edit = new RoleEditDto();
}
return(edit);
}
/// <summary>
/// 通过Id获取角色信息进行编辑或修改
/// Id为空时返回新对象
/// </summary>
public async Task <GetRoleForEditOutput> GetForEditAsync(NullableIdDto <int> input)
{
RoleEditDto roleEditDto;
if (input.Id.HasValue)
{
var entity = await _roleRepository.GetAsync(input.Id.Value);
roleEditDto = entity.MapTo <RoleEditDto>();
}
else
{
roleEditDto = new RoleEditDto();
}
return(new GetRoleForEditOutput {
RoleEditDto = roleEditDto
});
}
public async Task Update(RoleEditDto input)
{
var rs = await _repository.FirstOrDefaultAsync(x => x.Id == input.Id);
if (rs == null)
{
throw new UserFriendlyException(string.Format("There is no role with id : {0}", input.Id));
}
input.MapTo(rs);
var result = await _repository.FirstOrDefaultAsync(x => x.RoleCode == input.RoleCode);
if (result != null && result.Id != input.Id)
{
throw new UserFriendlyException(string.Format(L("DuplicateRoleCode"), input.RoleCode));
}
await _repository.UpdateAsync(rs);
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
// Формируем список доступных пользовательских ролей и ролей,
// установленных для конкретного пользователя. Это нужно для того,
// чтобы вывести полный список ролей в виде checkbox-ов и предоставить
// возможность выставлять пользователю любые роли
var user = await _userManager.FindByNameAsync(userName);
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
// Null coalescing operator: если selectedRoles будет равен null,
// то присвоим ему пустой массив строк. В противном случае, не будем
// делать ничего, присвоив ему его же самого
selectedRoles = selectedRoles ?? new string[] {};
// Довольно сложная схема добавления/удаления ролей нужна для того,
// чтобы уменьшить количество записей, которые должны быть модифицированы
// в базе данных Identity. Вместо того, чтобы сбрасывать все роли и
// и добавлять назначенные, мы удаляем только те, которые были назначены
// ранее помечены, но потом помечены, как необходимые к удалению, а также
// добавляем только те роли, которые не были назначены пользователю раньше.
// Ещё один довод в пользу подобного подхода - нет необходимости использовать
// транзакционный механизм, чтобы гарантировать, сохранение настроек
// пользователя в том случае, если какой-то из вызовов закончится неудачей
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove to roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task Update(RoleEditDto input)
{
var rs = await _repository.FirstOrDefaultAsync(x => x.Id == input.Id);
if (rs == null)
{
throw new UserFriendlyException(string.Format("There is no role with id : {0}", input.Id));
}
input.MapTo(rs);
var result = await _repository.FirstOrDefaultAsync(x => x.RoleCode == input.RoleCode);
if (result != null && result.Id != input.Id)
{
throw new UserFriendlyException(string.Format(L("DuplicateRoleCode"), input.RoleCode));
}
await _repository.UpdateAsync(rs);
}
public async Task <IActionResult> EditRoles(string userName, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByNameAsync(userName);
var userRoles = new List <string>();
if (User.Identity.Name.ToUpper() == "SYSTEMADMIN")
{
userRoles = (List <string>) await _userManager.GetRolesAsync(user);
}
else
{
var orgId = int.Parse(User.FindFirst("Organization").Value);
var roles = await _context.Roles.FromSql("SELECT * FROM AspNetRoles WHERE AspNetRoles.Id IN (SELECT AspNetUserRoles.RoleId FROM AspNetUserRoles WHERE AspNetUserRoles.UserId = {0}) AND AspNetRoles.OrganizationId = {1}", user.Id, orgId).ToListAsync();
foreach (var role in roles)
{
userRoles.Add(role.Name);
}
}
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove the role"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task <ActionResult <UserForReturnDto> > AddRolesAsync(int id, [FromBody] RoleEditDto roleEditDto)
{
if (roleEditDto.RoleNames == null || roleEditDto.RoleNames.Length == 0)
{
return(BadRequest(new ProblemDetailsWithErrors("At least one role must be specified.", 400, Request)));
}
var user = await userRepository.GetByIdAsync(id);
var roles = await userRepository.GetRolesAsync();
var userRoles = user.UserRoles.Select(ur => ur.Role.Name.ToUpper()).ToHashSet();
var selectedRoles = roleEditDto.RoleNames.Select(role => role.ToUpper()).ToHashSet();
var rolesToAdd = roles.Where(role =>
{
var upperName = role.Name.ToUpper();
return(selectedRoles.Contains(upperName) && !userRoles.Contains(upperName));
});
if (rolesToAdd.Count() == 0)
{
return(Ok(mapper.Map <UserForReturnDto>(user)));
}
user.UserRoles.AddRange(rolesToAdd.Select(role => new UserRole
{
Role = role
}));
var success = await userRepository.SaveAllAsync();
if (!success)
{
return(BadRequest(new ProblemDetailsWithErrors("Failed to add roles.", 400, Request)));
}
var userToReturn = mapper.Map <UserForReturnDto>(user);
return(Ok(userToReturn));
}
private async Task <IdentityResult> AssingRole(string userName, RoleEditDto roleDto)
{
var user = _userManager.FindByNameAsync(userName).Result;
var roles = await _userManager.GetRolesAsync(user);
//var role = _roleManager.FindByIdAsync(roleDto.RoleId).Result;
var selectedRoles = roleDto.RoleNames;
// selectedRoles = selectedRoles != null ? selectedRoles : new string[]{}
selectedRoles = selectedRoles ?? new string[] { };
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(roles));
result = await _userManager.RemoveFromRolesAsync(user, roles.Except(selectedRoles));
//var resp = await _userManager.AddToRoleAsync(user, role.Name);
return(result);
}
public async Task <IActionResult> EditRoles(string userName, [FromBody] RoleEditDto roleEditDto)
{
try
{
var user = await _userManager.FindByNameAsync(userName);
if (string.IsNullOrEmpty(user.Id.ToString()))
{
return(BadRequest());
}
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] { };
// disallow selectedRoles from excluding Admin role when the user is global admin - done at front end by including Admin role as readonly
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add to roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove the roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
catch (Exception ex)
{
ModelState.AddModelError("Error", "An error occured while performing this operation.");
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> EditUserRoles(string id, RoleEditDto roleEditDto)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound("User with that id doesn't exist"));
}
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = roleEditDto?.RoleNames;
// Checking if one of the roles is invalid
if (!IsRolesValid(selectedRoles))
{
return(BadRequest("Incorrect roles"));
}
// Add only the new roles
var results = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!results.Succeeded)
{
return(BadRequest("Failed To add to roles"));
}
// Removes all old roles, that was not selected.
results = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!results.Succeeded)
{
return(BadRequest("Failed To remove to roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
/// <summary>
/// 修改
/// </summary>
/// <param name="input">信息</param>
/// <param name="permission">权限</param>
/// <returns>信息</returns>
public async Task <RoleListDto> EditAsync(RoleEditDto input, string permission)
{
#region 角色
Role oldRole = await CurrentRepository
.FirstOrDefaultAsync(u => u.ID == input.ID.Value);
if (oldRole == null)
{
throw new UserFriendlyException("角色不存在");
}
Role role = _mapper.Map(input, oldRole);
CurrentRepository.Edit(role);
#endregion 角色
#region 权限
List <Permission> permissions = CreatePermissions(permission);
List <Permission> oldPermissions = await _permissionRepository
.LoadListAsync(p => p.Role.ID == role.ID);
List <Permission> newPermissions = permissions
.Except(oldPermissions, new PermissionComparer()).ToList();
List <Permission> lostPermissions = oldPermissions
.Except(permissions, new PermissionComparer()).ToList();
await _permissionRepository.SetPermissionsByRoleId(role, newPermissions,
lostPermissions);
#endregion 权限
if (await CurrentContext.SaveChangesAsync() <= 0)
{
throw new UserFriendlyException("修改失败");
}
return(_mapper.Map <RoleListDto>(role));
}
public async Task <GetRoleForEditOutput> GetRoleForEdit(NullableIdDto input)
{
var grantedPermissions = new Permission[0];
RoleEditDto roleEditDto;
if (input.Id.HasValue) //Editing existing role?
{
var role = await _roleManager.GetRoleByIdAsync(input.Id.Value);
grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
roleEditDto = ObjectMapper.Map <RoleEditDto>(role);
}
else
{
roleEditDto = new RoleEditDto();
}
return(new GetRoleForEditOutput
{
item = roleEditDto,
GrantedPermissionNames = grantedPermissions.Where(p => p.Children.Count == 0).Select(p => p.Name).ToList()//只选择叶节点，父节点自动选中
});
}
