private void ValidateUpdateRequest(UpdateRoleRequest request)
{
if (request.Id == null || request.Id == Guid.Empty)
{
throw new ValidationException("security.addOrUpdateRole.validation.idIsInvalid");
}
IRoleRepository roleRepository = IoC.Container.Resolve <IRoleRepository>();
if (roleRepository.GetById(request.Id.ToString()) == null)
{
throw new ValidationException("security.addOrUpdateRole.validation.roleNotExist");
}
if (string.IsNullOrWhiteSpace(request.Name))
{
throw new ValidationException("security.addOrUpdateRole.validation.nameIsRequired");
}
string key = App.Common.Helpers.UtilHelper.ToKey(request.Name);
Role roleByKey = roleRepository.GetByKey(key);
if (roleByKey != null && roleByKey.Id != request.Id)
{
throw new ValidationException("security.addOrUpdateRole.validation.keyAlreadyExisted");
}
}
public async Task<IActionResult> UpdateRole(
int id,
[FromBody] UpdateRoleRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
if (id != request.Id)
{
return BadRequest(ControllerMessages.IdIncorrectMessage);
}
var result = await rolesService.UpdateRole(id, request);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return Ok(result);
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return NotFound(result);
}
}
else
{
return BadRequest(ControllerMessages.InvalidLicenseRequestMessage);
}
}
public async Task UpdateRoleAsync_Should_Return_OkObjectResult_With_GetRoleResponse()
{
var rowVersion = new byte[] { 1, 2, 4, 8, 16, 32 };
var roleId = Guid.NewGuid();
var updateRoleRequest = new UpdateRoleRequest
{
Id = roleId,
Name = DefaultRoleEnumeration.Administrator.DisplayName
};
var updateRoleCommand = new UpdateRoleCommand(updateRoleRequest.Id, rowVersion, updateRoleRequest.Name);
var roleOutputQuery = new RoleOutputQuery(updateRoleRequest.Id, new byte[] { 1, 2, 4, 8, 16, 64 }, updateRoleRequest.Name);
var getRoleResponse = new GetRoleResponse(roleOutputQuery.Id, roleOutputQuery.RowVersion, roleOutputQuery.Name);
_mapperMock.Setup(x => x.Map <UpdateRoleRequest, UpdateRoleCommand>(It.IsAny <UpdateRoleRequest>())).Returns(updateRoleCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <UpdateRoleCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getRoleQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetRoleInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(roleOutputQuery);
_mapperMock.Setup(x => x.Map <RoleOutputQuery, GetRoleResponse>(It.IsAny <RoleOutputQuery>())).Returns(getRoleResponse);
var result = await _controller.UpdateRoleAsync(roleId, updateRoleRequest, rowVersion);
var okObjectResult = result.As <OkObjectResult>();
okObjectResult.Value.Should().BeEquivalentTo(getRoleResponse);
}
/// <summary> Creates a new role. </summary>
public async Task <Role> CreateRole(string name, ServerPermissions?permissions = null, Color color = null, bool isHoisted = false, bool isMentionable = false)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var createRequest = new CreateRoleRequest(Id);
var createResponse = await Client.ClientAPI.Send(createRequest).ConfigureAwait(false);
var role = AddRole(createResponse.Id);
role.Update(createResponse, false);
var editRequest = new UpdateRoleRequest(role.Server.Id, role.Id)
{
Name = name,
Permissions = (permissions ?? role.Permissions).RawValue,
Color = (color ?? Color.Default).RawValue,
IsHoisted = isHoisted,
IsMentionable = isMentionable
};
var editResponse = await Client.ClientAPI.Send(editRequest).ConfigureAwait(false);
role.Update(editResponse, true);
return(role);
}
public async override Task <Task> Handle(UpdateRoleCommand command, CancellationToken cancellationToken = default)
{
using var client = _awsClientFactory.Create <AmazonIdentityManagementServiceClient>(command.AssumeProfile);
var request = new UpdateRoleRequest()
{
RoleName = command.RoleName
};
if (!string.IsNullOrEmpty(command.Description))
{
request.Description = command.Description;
}
try
{
await client.UpdateRoleAsync(request, cancellationToken);
}
catch (AmazonServiceException e)
{
throw new Exception(e.Message, e);
}
return(Task.CompletedTask);
}
public async Task <IActionResult> UpdateRole([FromBody] UpdateRoleRequest model)
{
if (!ModelState.IsValid)
{
return(Ok(ModelState));
}
bool isExist = !String.IsNullOrEmpty(model.RoleName);
IdentityResult roleResult;
if (ModelState.IsValid)
{
ApplicationRole applicationRole = await _roleservice.FindByNameAsync(model.RoleName);
applicationRole.Name = model.RoleName;
applicationRole.CreatedDate = DateTime.UtcNow;
applicationRole.Description = model.Description;
applicationRole.IpAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
roleResult = await _roleservice.UpdateAsync(applicationRole);
if (roleResult.Succeeded)
{
if (isExist)
{
return(Ok("Role SuccessFully Updated...."));
}
}
}
return(Ok("UnExpected Error"));
}
public UserDTO UpdateRole(UpdateRoleRequest request)
{
var user = dbContext.Users.Where(u => u.Username == request.Username).FirstOrDefault();
if (user == null)
{
throw new CustomException(HttpStatusCode.NotFound, "user not found");
}
var userRolesToDelete = dbContext.UserRole.Where(ur => ur.UserId == user.Id).ToList();
if (userRolesToDelete != null)
{
dbContext.RemoveRange(userRolesToDelete);
}
var roles = dbContext.Roles.Where(r => request.RoleIds.Contains(r.Id)).ToList();
foreach (var role in roles)
{
UserRole userRole = new UserRole()
{
User = user,
Role = role,
};
dbContext.Add(userRole);
}
dbContext.SaveChanges();
return(new UserDTO(user));
}
/// <summary>
/// 修改
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ApiResult <string> > UpdateAsync(UpdateRoleRequest request)
{
return(await ExecuteResultAsync(async query =>
{
var rsp = new ApiResult <string>();
var entity = await query.FirstOrDefaultAsync(p => p.Id == request.Id);
if (entity == null)
{
rsp.Message = "找不到要修改的信息.";
return rsp;
}
entity.Name = request.Name;
entity.Remarks = request.Remarks;
entity.Status = request.Status;
// 修改
RegisterDirty(entity);
// 提交
var flag = await CommitAsync();
rsp.Message = flag ? "更新成功" : "更新失败";
rsp.Success = flag;
rsp.Data = entity.Id;
return rsp;
}));
}
public void UpdateRole(Guid id, UpdateRoleRequest request)
{
request.Id = id;
IRoleService roleService = IoC.Container.Resolve <IRoleService>();
roleService.Update(request);
}
public async Task <IActionResult> OnGet()
{
var response = await _roleService.GetRole(new GetRoleRequest()
{
Id = Id
});
if (!response.IsSuccessful)
{
return(NotFound());
}
PermissionsLookup = await _cache.Permissions();
RoleEntity = response.Role;
FormData = new UpdateRoleRequest()
{
Id = response.Role.Id,
Description = response.Role.Description,
Name = response.Role.Name,
PermissionIds = response.Permissions.Select(c => new CheckboxItemSelection()
{
Id = c.Id,
Selected = true
}).ToList()
};
return(Page());
}
public EditRoleModel(IRoleService roleService, ICacheManager cache)
{
_roleService = roleService;
_cache = cache;
PermissionsLookup = new List <PermissionEntity>();
FormData = new UpdateRoleRequest();
}
public IHttpActionResult UpdateRole([FromBody] UpdateRoleRequest request)
{
try
{
request.ValidateNotNull();
RoleDomain roleDomain = _roleManipulation.GetRoleById(request.Id);
if (roleDomain == null)
{
return(NotFound());
}
roleDomain.Name = request.Name;
roleDomain.IsActive = request.IsActive;
roleDomain.ManipulationLogId = request.ManipulationLogId;
_roleManipulation.UpdateRole(roleDomain);
return(Ok(new UpdateRoleResponse()
{
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public BaseResponse UpdateRole(UpdateRoleRequest request)
{
var roleName = string.IsNullOrWhiteSpace(request.RoleName) ? string.Empty : request.RoleName;
var baseRoles = (request.BaseRoles ?? Enumerable.Empty <string>()).ToArray();
IdentityRepository.UpdateRoleInRoles(roleName, baseRoles);
return(BaseResponse.Ok());
}
/// <summary>
/// 修改角色
/// </summary>
/// <param name="request">修改角色参数</param>
public async Task UpdateAsync(UpdateRoleRequest request)
{
var entity = await RoleRepository.FindAsync(request.Id.ToGuid());
request.MapTo(entity);
await RoleManager.UpdateAsync(entity);
await UnitOfWork.CommitAsync();
}
public async Task <IActionResult> UpdateRoleAsync([FromBody] UpdateRoleRequest role)
{
if (await _service.UpdateRoleAsync(role) == 0)
{
return(NoContent());
}
else
{
return(Ok(new { role.Id }));
}
}
public IActionResult UpdateRole([FromBody] UpdateRoleRequest updateRequest)
{
try
{
var user = userRepository.UpdateRole(updateRequest);
return(Ok(user));
}
catch (Exception e)
{
throw e;
}
}
protected override void Handle(UpdateRoleRequest request, DtoResponse <RoleDto> response)
{
var role = _roleRepository.GetByKey(request.Key);
if (role != null)
{
role.ReviseName(request.Name);
var roleDto = Mapper.Map <Role, RoleDto>(role);
response.DataTransferObject = roleDto;
}
}
public async Task UpdateRoleAsync(UpdateRoleView view)
{
var request = new UpdateRoleRequest
{
Id = view.Id,
RoleName = view.RoleName,
Permissions = GetPermissions(view.PermissionSections),
Description = view.Description,
UpdatedBy = "Klen"
};
await _requestHelper.SendRequestAsync(BaseUrl, HttpMethod.Put, JsonConvert.SerializeObject(request, Formatting.None));
}
public async Task <Response <string> > UpdateRoleAsync(UpdateRoleRequest request)
{
var role = await _roleManager.FindByIdAsync(request.Id);
if (role == null)
{
throw new ApiException("not found id");
}
role.Name = request.Name;
await _roleManager.UpdateAsync(role);
return(new Response <string>(role.Id));
}
public async Task <bool> Handle(UpdateRoleRequest request, CancellationToken cancellationToken)
{
if (!context.Roles.Any(u => u.Id == request.Id))
{
return(false);
}
var role = mapper.Map <Role>(request.RoleViewModel);
context.Roles.Update(role);
await context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> UpdateRole(Guid Id, UpdateRoleRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = await _roleService.UpdateRole(Id, request);
if (role == null)
{
return(BadRequest(role));
}
return(Ok(role));
}
public async Task <int> UpdateRoleAsync(UpdateRoleRequest roleView)
{
var role = new Role
{
Id = roleView.Id,
Description = roleView.Description,
RoleName = roleView.RoleName,
Permissions = roleView.Permissions,
UpdatedBy = roleView.UpdatedBy,
UpdatedTime = DateTime.UtcNow
};
return(await _repository.UpdateRoleAsync(role));
}
public async Task <IActionResult> UpdateRoleAsync([FromRoute] Guid id, [FromBody] UpdateRoleRequest request, [FromHeader(Name = "If-Match")] byte[] rowVersion)
{
ValidatePathIdWithRequestBodyId(id, request.Id);
request.SetRowVersion(rowVersion);
var updateRoleCommand = _mapper.Map <UpdateRoleRequest, UpdateRoleCommand>(request);
await _communicationBus.SendCommandAsync(updateRoleCommand);
var getRoleOutputQuery = await _getRoleQueryHandler.HandleAsync(new GetRoleInputQuery(id));
var getRoleResponse = _mapper.Map <RoleOutputQuery, GetRoleResponse>(getRoleOutputQuery);
return(Ok(getRoleResponse));
}
public UpdateRoleResponse UpdateRole(UpdateRoleRequest request)
{
UpdateRoleResponse response = new UpdateRoleResponse();
Role role = _roleRepository.Get(request.Id);
role.Name = request.RolesUpdateModel.Name;
role.UserType = request.RolesUpdateModel.UserType;
_roleRepository.Update(role);
_unitOfWork.Commit();
return(response);
}
public async Task <IActionResult> EditRole(UpdateRoleRequest request)
{
if (ModelState.IsValid)
{
var response = await _adminService.UpdateRole(request);
if (response.IsSuccessful)
{
AddNotifications(response);
return(RedirectToAction(nameof(AdminController.RoleManagement)));
}
AddFormErrors(response);
}
return(View(new EditRoleViewModel(request)));
}
public void Update(UpdateRoleRequest request)
{
this.ValidateUpdateRequest(request);
using (IUnitOfWork uow = new UnitOfWork(RepositoryType.MSSQL))
{
IRoleRepository repository = IoC.Container.Resolve <IRoleRepository>(uow);
Role existedRole = repository.GetById(request.Id.ToString(), "Permissions");
existedRole.Name = request.Name;
existedRole.Key = App.Common.Helpers.UtilHelper.ToKey(request.Name);
existedRole.Description = request.Description;
this.RemoveRemovedPermissions(existedRole, request, uow);
this.AddAddedPermission(existedRole, request, uow);
uow.Commit();
}
}
public override async Task <Empty> UpdateRole(UpdateRoleRequest request, ServerCallContext context)
{
var command = new UpdateRoleCommand
{
Id = request.Id,
Name = request.Name,
IsEnabled = request.IsEnabled,
PermissionIds = request.PermissionIds
.Select(x => (Guid)x)
.ToList(),
};
await _authorizationApp.UpdateRoleAsync(command);
return(new Empty());
}
private void RemoveRemovedPermissions(Role existedRole, UpdateRoleRequest request, IUnitOfWork uow)
{
if (existedRole.Permissions.Count == 0)
{
return;
}
IList <Guid> existPers = existedRole.Permissions.Select(item => item.Id).ToList();
IEnumerable <Guid> removedItems = existPers.Except(request.Permissions);
foreach (Guid item in removedItems)
{
Permission per = existedRole.Permissions.FirstOrDefault(perItem => perItem.Id == item);
existedRole.Permissions.Remove(per);
}
}
public async Task <IActionResult> Update(UpdateRoleRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _roleService.UpdateRole(request);
if (result.IsSuccessed == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> Update([FromBody] UpdateRoleRequest request)
{
try
{
var response = await _serviceProvider.HandlerAsync(request);
return(new JsonResult(response));
}
catch (Exception ex)
{
return(new JsonResult(new ResponseBase()
{
Result = -1, ResultInfo = ex.Message
}));
}
}
public async Task Edit(string name = null, ServerPermissions permissions = null, Color color = null, bool? isHoisted = null, int? position = null)
{
var updateRequest = new UpdateRoleRequest(Server.Id, Id)
{
Name = name ?? Name,
Permissions = (permissions ?? Permissions).RawValue,
Color = (color ?? Color).RawValue,
IsHoisted = isHoisted ?? IsHoisted
};
var updateResponse = await Client.ClientAPI.Send(updateRequest).ConfigureAwait(false);
if (position != null)
{
int oldPos = Position;
int newPos = position.Value;
int minPos;
Role[] roles = Server.Roles.OrderBy(x => x.Position).ToArray();
if (oldPos < newPos) //Moving Down
{
minPos = oldPos;
for (int i = oldPos; i < newPos; i++)
roles[i] = roles[i + 1];
roles[newPos] = this;
}
else //(oldPos > newPos) Moving Up
{
minPos = newPos;
for (int i = oldPos; i > newPos; i--)
roles[i] = roles[i - 1];
roles[newPos] = this;
}
var reorderRequest = new ReorderRolesRequest(Server.Id)
{
RoleIds = roles.Skip(minPos).Select(x => x.Id).ToArray(),
StartPos = minPos
};
await Client.ClientAPI.Send(reorderRequest).ConfigureAwait(false);
}
}
/// <summary> Creates a new role. </summary>
public async Task<Role> CreateRole(string name, ServerPermissions? permissions = null, Color color = null, bool isHoisted = false)
{
if (name == null) throw new ArgumentNullException(nameof(name));
var createRequest = new CreateRoleRequest(Id);
var createResponse = await Client.ClientAPI.Send(createRequest).ConfigureAwait(false);
var role = AddRole(createResponse.Id);
role.Update(createResponse);
var editRequest = new UpdateRoleRequest(role.Server.Id, role.Id)
{
Name = name,
Permissions = (permissions ?? role.Permissions).RawValue,
Color = (color ?? Color.Default).RawValue,
IsHoisted = isHoisted
};
var editResponse = await Client.ClientAPI.Send(editRequest).ConfigureAwait(false);
role.Update(editResponse);
return role;
}
