public async Task <IActionResult> UpdateRole(RoleUpdateRequest request)
{
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetRole(request.RoleId);
//modifica solo se admin o se utente richiedente è lo stesso che ha creato
if (entity == null)
{
return(NotFound());
}
//Aggiornamento dell'entità
entity.Name = request.Name;
entity.Description = request.Description;
//Salvataggio
var validations = await AuthorizationLayer.UpdateRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
var permissions = AuthorizationLayer.FetchPermissionsOnRole(entity.Id);
//Confermo
return(Ok(ContractUtils.GenerateContract(entity, permissions)));
}
/// <summary>
/// Updates a role.
/// </summary>
/// <param name="id">The ID of the role to update.</param>
/// <param name="request">A <see cref="RoleUpdateRequest" /> containing the information to update.</param>
/// <returns>The newly updated <see cref="Role"/>.</returns>
public Task <Role> UpdateAsync(string id, RoleUpdateRequest request)
{
return(Connection.PatchAsync <Role>("roles/{id}", request, new Dictionary <string, string>
{
{ "id", id }
}));
}
public void InitialData()
{
request = new RoleUpdateRequest()
{
Username = "******",
Roles = new List <string>()
{
Roles.Admin,
Roles.Analyst,
Roles.User
}
};
}
private async void Commit()
{
try
{
isCommit = true;
GetData();
RoleUpdateRequest roleUpdate = new RoleUpdateRequest {
Id = _currentRoleObject.Id,
Name = _currentRoleObject.Name,
Description = _currentRoleObject.Description,
Rights = _currentRoleObject.Rights,
};
var data = await _Controller.Update(roleUpdate);
ObjectReturn = data;
if (data != null)
{
if (data.Status == Utilities.Common.UpdateStatus.Successfull)
{
lbInfo.Invoke(new MethodInvoker(delegate
{
lbInfo.Text = $"Commit is successfull: {data.Message}";
}));
}
else
{
lbInfo.Invoke(new MethodInvoker(delegate
{
lbInfo.Text = $"Commit is failure: {data.Message}";
}));
}
isCommit = false;
return;
}
else
{
lbInfo.Invoke(new MethodInvoker(delegate
{
lbInfo.Text = "No reponse";
}));
}
isCommit = false;
}
catch (Exception ex)
{
isCommit = false;
MessageBox.Show(ex.ToString());
}
}
public async Task <UpdateStatusViewModel> Update(RoleUpdateRequest request)
{
var sessions = Core.Token;
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions);
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _client.PutAsync($"/api/Roles", httpContent);
var result = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <UpdateStatusViewModel>(result));
}
return(null);
}
/// <summary>
/// 逻辑删除
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public RoleUpdateResponse DeleteRole(RoleUpdateRequest request)
{
RoleUpdateResponse response = new RoleUpdateResponse();
var res = UpdateRoleDal.Instance.DeleteRole(request.RoleAll);
if (res > 0)
{
response.Message = "删除成功";
}
else
{
response.Status = false;
response.Message = "删除失败，请检查网络";
}
return(response);
}
public async Task <ApiResultLite> UpdateAsync(RoleUpdateRequest model)
{
var role = await _roleManager.FindByIdAsync(model.Id.ToString());
if (role == null)
{
return(new ApiErrorResultLite("Role không tồn tại"));
}
role.Name = model.Name;
role.Description = model.Description;
var result = await _roleManager.UpdateAsync(role);
if (!result.Succeeded)
{
return(new ApiErrorResultLite("Cập nhật không thành công"));
}
return(new ApiSuccessResultLite());
}
public BasicResponse <RoleInfo> UpdateRole(RoleUpdateRequest rolerequest)
{
RoleInfo roleDTO = rolerequest.RoleInfo;
if (string.IsNullOrEmpty(roleDTO.RoleID))
{
ThrowException("UpdateRole", new Exception("角色编号不能为空！"));
}
if (string.IsNullOrEmpty(roleDTO.RoleName))
{
ThrowException("UpdateRole", new Exception("角色名称不能为空！"));
}
var _role = ObjectConverter.Copy <RoleInfo, RoleModel>(rolerequest.RoleInfo);
_Repository.UpdateRole(_role);
var roleresponse = new BasicResponse <RoleInfo>();
roleresponse.Data = ObjectConverter.Copy <RoleModel, RoleInfo>(_role);
return(roleresponse);
}
/// <summary>
/// Put the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Put(RoleUpdateRequest request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.AdminOnly);
WebRole result;
try {
context.Open();
context.LogInfo(this, string.Format("/role PUT Id='{0}'", request.Id));
Role role = Role.FromId(context, request.Id);
role = request.ToEntity(context, role);
role.Store();
context.LogDebug(this, string.Format("Role {0} updated by user {1}", role.Identifier, User.FromId(context, context.UserId).Username));
result = new WebRole(role, true);
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
public async Task <IActionResult> UpdateRole(Guid id, [FromBody] RoleUpdateRequest roleUpdateRequest)
{
if (roleUpdateRequest == null || string.IsNullOrWhiteSpace(roleUpdateRequest.Name))
{
return(HandleBadRequest("A valid role name needs to be provided."));
}
try
{
Role role = await RoleService.UpdateRole(id, roleUpdateRequest.Name);
return(Ok(new RoleResponse(role)));
}
catch (EntityNotFoundException exception)
{
return(HandleResourceNotFoundException(exception));
}
catch (Exception exception)
{
return(HandleUnexpectedException(exception));
}
}
public RoleUpdateResponse DeleteRole(RoleUpdateRequest request)
{
return(UpdateRoleBll.Instance.DeleteRole(request));
}
public async Task Test_roles_crud_sequence()
{
// Add a new role
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var newRoleResponse = await _apiClient.Roles.CreateAsync(newRoleRequest);
newRoleResponse.Should().NotBeNull();
newRoleResponse.Name.Should().Be(newRoleRequest.Name);
newRoleResponse.Description.Should().Be(newRoleRequest.Description);
// Update the role
var updateRoleRequest = new RoleUpdateRequest
{
Name = $"{Guid.NewGuid():N}role",
};
var updateRoleResponse = await _apiClient.Roles.UpdateAsync(newRoleResponse.Id, updateRoleRequest);
updateRoleResponse.Should().NotBeNull();
updateRoleResponse.Name.Should().Be(updateRoleRequest.Name);
// Get a single role
var role = await _apiClient.Roles.GetAsync(newRoleResponse.Id);
role.Should().NotBeNull();
role.Name.Should().Be(updateRoleResponse.Name);
// Create a user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
var user = await _apiClient.Users.CreateAsync(newUserRequest);
// Assign a user to the role
var assignUsersRequest = new AssignUsersRequest
{
Users = new[]
{
user.UserId
}
};
await _apiClient.Roles.AssignUsersAsync(role.Id, assignUsersRequest);
// Ensure the user is assigned to the role
var assignedUsers = await _apiClient.Roles.GetUsersAsync(role.Id);
assignedUsers.Should().NotBeNull();
assignedUsers.First().UserId.Should().Be(user.UserId);
// Ensure the Role is assigned to user
var assignedRoles = await _apiClient.Users.GetRolesAsync(user.UserId, new PaginationInfo());
assignedRoles.Should().NotBeNull();
assignedRoles.First().Id.Should().Be(role.Id);
// Delete the role and ensure we get an exception when trying to fetch them again
await _apiClient.Roles.DeleteAsync(role.Id);
Func <Task> getFunc = async() => await _apiClient.Roles.GetAsync(role.Id);
getFunc.Should().Throw <ErrorApiException>().And.ApiError.Error.Should().Be("Not Found");
// Delete the user
await _apiClient.Users.DeleteAsync(user.UserId);
}
public BasicResponse <RoleInfo> UpdateRole(RoleUpdateRequest rolerequest)
{
return(_roleService.UpdateRole(rolerequest));
}
public async Task <UpdateStatusViewModel> Update(RoleUpdateRequest request)
{
var result = await _apiClient.Update(request);
return(result);
}
/// <summary>
/// Updates a role.
/// </summary>
/// <param name="id">The ID of the role to update.</param>
/// <param name="request">A <see cref="RoleUpdateRequest" /> containing the information to update.</param>
/// <returns>The newly updated <see cref="Role"/>.</returns>
public Task <Role> UpdateAsync(string id, RoleUpdateRequest request)
{
return(Connection.SendAsync <Role>(new HttpMethod("PATCH"), BuildUri($"roles/{EncodePath(id)}"), request, DefaultHeaders));
}
/// <summary>
/// 获取逻辑删除方法
/// </summary>
/// <param name="getRequest"></param>
/// <returns></returns>
public JsonResult DeleteRole(RoleUpdateRequest request)
{
return(Json(RoleBll.Instance.DeleteRole(request), JsonRequestBehavior.AllowGet));
}
public async Task <ApiResultLite> UpdateAsync(RoleUpdateRequest request)
{
var result = await _roleService.UpdateAsync(request);
return(result);
}
public BasicResponse <RoleInfo> UpdateRole(RoleUpdateRequest rolerequest)
{
var responseStr = HttpClientHelper.Post(Webapi + "/v1/Role/Update?token=" + Token, JSONHelper.ToJSONString(rolerequest));
return(JSONHelper.ParseJSONString <BasicResponse <RoleInfo> >(responseStr));
}
/// <summary>
/// 逻辑删除
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public RoleUpdateResponse DeleteRole(RoleUpdateRequest request)
{
return(ApiRequestHelper.Post <RoleUpdateRequest, RoleUpdateResponse>(request));
}
