public void Execute(EditRoleDto request)
{
var role = _context.Roles.Include(r => r.RoleUseCases).Where(r => r.Id == request.Id).FirstOrDefault();
if (role == null)
{
throw new EntityNotFoundException(request.Id, typeof(Role));
}
if (role.CreatedBy != _actor.Id && _actor.RoleType != RoleType.Administrator && _actor.RoleType != RoleType.Moderator)
{
throw new NotAllowedException(UseCase.getUseCase(this.Id), _actor, $"You can only edit roles created by you.");
}
if (_actor.RoleType != RoleType.Administrator)
{
if (role.RoleType == RoleType.Administrator || role.RoleType == RoleType.Moderator)
{
throw new NotAllowedException(UseCase.getUseCase(this.Id), _actor, $"Only administrator can edit role with type {role.RoleType}.");
}
if (request.RoleType == RoleType.Administrator || request.RoleType == RoleType.Moderator)
{
throw new NotAllowedException(UseCase.getUseCase(this.Id), _actor, $"Only administrator can change role type to {request.RoleType}.");
}
}
_validator.ValidateAndThrow(request);
_mapper.Map <EditRoleDto, Role>(request, role);
_context.SaveChanges(_actor.Id);
}
public async Task <IActionResult> Edit([FromRoute] string id, [Bind("Id,EditedTime,Name,Description,NormalizedName,ConcurrencyStamp")][FromBody] EditRoleDto model)
{
if (ModelState.IsValid)
{
//var result = await roleManager.FindByIdAsync(model.Id);
//if (result == null)
//{
// return NotFound();
//}
//if (result.EditedTime != model.EditedTime || result.ConcurrencyStamp != model.ConcurrencyStamp)
//{
// return Json(ResponseResult.Failed("修改失败，数据已经被修改，请重新获取数据"));
//}
if (id != model.Id)
{
return(BadRequest());
}
var result = mapper.Map <IdentityRole>(model);
result.EditeUser = User.GetUserId();
var sult = await roleManager.UpdateAsync(result, nameof(IdentityRole.Description), nameof(IdentityRole.Name), nameof(IdentityRole.NormalizedName), nameof(IdentityRole.ConcurrencyStamp));
return(Json(sult));
}
ModelState.AddModelError("", "验证失败");
return(Failed());
}
public async Task <IActionResult> EditRoles(string userName, EditRoleDto editRoleDto)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(BadRequest("User not found"));
}
var userRoles = await _userManager.GetRolesAsync(user);
var selectedRoles = editRoleDto.RoleNames;
selectedRoles = selectedRoles ?? new string[] {};
var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to add roles"));
}
result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles));
if (!result.Succeeded)
{
return(BadRequest("Failed to remove roles"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public async Task <IActionResult> EditRoles(string userName, EditRoleDto editRoleDto)
{
var user = await userManager.FindByNameAsync(userName);
var userRoles = await userManager.GetRolesAsync(user);
var editRoles = editRoleDto.RoleNames;
editRoles = editRoles ?? new string[] { };
var result = await userManager.AddToRolesAsync(user, editRoles.Except(userRoles));
if (!result.Succeeded)
{
return(BadRequest("Edit roles add failure"));
}
result = await userManager.RemoveFromRolesAsync(user, userRoles.Except(editRoles));
if (!result.Succeeded)
{
return(BadRequest("Edit roles remove failure"));
}
return(Ok(await userManager.GetRolesAsync(user)));
}
public async Task <IActionResult> Put(int Id, [FromBody] EditRoleDto model)
{
IdentityResult result = await _roleService.EditRole(Id, model);
if (result.Succeeded)
{
return(Ok(result));
}
return(BadRequest(result.Errors.Select(x => x.Description)));
}
public JsonResult Save(EditRoleDto editRole)
{
CheckModelState();
bool status = false;
string msg = "";
if (editRole.Id > 0)
{
try
{
if (_roleAppService.Update(editRole).Result.Id > 0)
{
status = true;
msg = "保存成功";
}
else
{
status = false;
msg = "保存失败";
}
}
catch (Exception e)
{
status = false;
msg = "运行时出错:" + e.Message;
}
}
else
{
try
{
var newModel = _roleAppService.Create(editRole).Result;
if (newModel != null && newModel.Id > 0)
{
status = true;
msg = "添加成功";
}
else
{
status = false;
msg = "角色名称不能重复";
}
}
catch (Exception e)
{
status = false;
msg = "运行时出错:" + e.Message;
}
}
return(Json(new { success = status, message = msg }));
}
public async Task <ActionResult> RemoveRole(EditRoleDto editRoleDto)
{
var user = await _userManager.FindByIdAsync(editRoleDto.UserId);
if (user == null)
{
return(NotFound());
}
await _userManager.RemoveClaimAsync(user, new Claim(ClaimTypes.Role, editRoleDto.RoleName));
return(NoContent());
}
public async Task <IActionResult> RemoveRole(EditRoleDto editRoleDto)
{
IdentityUser user = await _userManager.FindByIdAsync(editRoleDto.UserId);
if (user == null)
{
return(NotFound());
}
await _userManager.RemoveClaimAsync(user : user, claim : new Claim(type: ClaimTypes.Role, value: editRoleDto.RoleName));
return(NoContent());
}
public async Task <IActionResult> AssignRole([FromBody] EditRoleDto editRoleDto)
{
IdentityUser user = await _userManager.FindByIdAsync(editRoleDto.UserId);
if (user == null)
{
return(NotFound());
}
await _userManager.AddClaimAsync(user : user, claim : new Claim(type: ClaimTypes.Role, value: editRoleDto.RoleName));
return(Ok(user));
}
public async Task <ActionResult> AssignRole(EditRoleDto editRoleDto)
{
var user = await _userManager.FindByIdAsync(editRoleDto.UserId);
if (user == null)
{
_logger.LogInformation("User not found in database.");
return(NotFound());
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, editRoleDto.RoleName));
_logger.LogInformation(" Role: {Role} assigned to User {ForUser}.", editRoleDto.RoleName, user.UserName);
return(NoContent());
}
public async Task <ActionResult> AssignRole(EditRoleDto editRoleDto)
{
var user = await _userManager.FindByIdAsync(editRoleDto.UserId);
if (user == null)
{
return(NotFound());
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, editRoleDto.RoleName));
//another way is to use
//await _userManager.AddToRoleAsync(user, editRoleDto.RoleName);
return(NoContent());
}
public async Task <ReturnResult> UpdateRole(EditRoleDto addRole)
{
try
{
var add = await mediator.Send(new UpdateRoleCommand(addRole.Name, addRole.Description, addRole.Id));
if (add.Success)
{
return(Ok());
}
return(BadRequest(add.ErrorMessage));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <ActionResult <UserDto> > AddRolesAsync(int id, [FromBody] EditRoleDto roleEditDto)
{
if (roleEditDto.RoleNames == null || roleEditDto.RoleNames.Length == 0)
{
return(BadRequest("At least one role must be specified."));
}
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.Any())
{
return(Ok(mapper.Map <UserDto>(user)));
}
user.UserRoles.AddRange(rolesToAdd.Select(role => new UserRole
{
Role = role
}));
var success = await userRepository.SaveAllAsync();
if (!success)
{
return(BadRequest("Failed to add roles."));
}
var userToReturn = mapper.Map <UserDto>(user);
return(Ok(userToReturn));
}
public async Task <IdentityResult> EditRole(int Id, EditRoleDto model)
{
Role role = await _roleManager.FindByIdAsync(model.Id.ToString());
if (role == null)
{
return(IdentityResult.Failed(new IdentityError[]
{
new IdentityError()
{
Code = "Role",
Description = "Not Found Role"
}
}));
}
role = _mapper.Map <Role>(model);
IdentityResult result = await _roleManager.UpdateAsync(role);
return(result);
}
public async Task <IActionResult> Edit(string id, EditRoleDto request)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
role.Name = request.Name;
await roleManager.UpdateAsync(role);
}
var viewModel = mapper.Map <EditRoleViewModel>(role);
await PopulateClaims(role, viewModel);
return(View(viewModel));
}
public async Task AddOrUpdate(EditRoleDto roleDto)
{
Role role = new Role();
if (roleDto.Id.HasValue)
{
role = await roleManager.GetRoleByIdAsync((int)roleDto.Id);
}
role.Name = roleDto.Name;
role.IsDefault = roleDto.IsDefault;
var grantedPermissions = permissionManager.GetAllPermissions().Where(p => ((JArray)roleDto.Permissions).ToObject <List <string> >().Contains(p.Name)).ToList();
await roleManager.SetGrantedPermissionsAsync(role, grantedPermissions);
if (roleDto.Id.HasValue)
{
await roleManager.UpdateAsync(role);
}
else
{
await roleManager.CreateAsync(role);
}
}
public IActionResult Put(int id, [FromBody] EditRoleDto request, [FromServices] IEditRoleCommand command)
{
request.Id = id;
_executor.ExecuteCommand(command, request);
return(StatusCode(StatusCodes.Status204NoContent));
}
