private void UpdatePermissionItem(Guid id, string name, string key, string desc)
{
UpdatePermissionRequest request = new UpdatePermissionRequest(id, name, key, desc);
IPermissionService service = IoC.Container.Resolve <IPermissionService>();
service.Update(request);
}
public void Security_Permission_UpdatePermission_ShouldBeSuccess_WithValidRequest()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(this.createdPermissionResponse.Id, "new updated name" + Guid.NewGuid(), "New updated Key " + Guid.NewGuid(), "desc");
IResponseData <string> response = this.Connector.Put <UpdatePermissionRequest, string>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count == 0);
}
public void UpdatePermission([FromUri] Guid id, UpdatePermissionRequest request)
{
request.Id = id;
IPermissionService permissionService = IoC.Container.Resolve <IPermissionService>();
permissionService.Update(request);
}
public async Task <UpdatePermissionResponse> UpdatePermission(UpdatePermissionRequest request)
{
var session = await _sessionService.GetAuthenticatedSession();
var response = new UpdatePermissionResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
await uow.UserRepo.UpdatePermission(new Infrastructure.Repositories.UserRepo.Models.UpdatePermissionRequest()
{
Id = request.Id,
Name = request.Name,
Group_Name = request.GroupName,
Description = request.Description,
Updated_By = session.User.Entity.Id
});
uow.Commit();
}
_cache.Remove(CacheConstants.Permissions);
var permissions = await _cache.Permissions();
var permission = permissions.FirstOrDefault(c => c.Id == request.Id);
await _sessionService.WriteSessionLogEvent(new Models.ServiceModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.PermissionUpdated
});
response.Notifications.Add($"Permission '{permission.Key}' has been updated", NotificationTypeEnum.Success);
return(response);
}
private void ValidateUpdateRequest(UpdatePermissionRequest request)
{
IPermissionRepository perRepo = IoC.Container.Resolve <IPermissionRepository>();
IValidationException validationException = ValidationHelper.Validate(request);
Permission per = perRepo.GetById(request.Id.ToString());
if (per == null)
{
validationException.Add(new App.Common.Validation.ValidationError("security.addPermission.validation.invalidId"));
}
per = perRepo.GetByName(request.Name);
if (per != null && per.Id != request.Id)
{
validationException.Add(new App.Common.Validation.ValidationError("security.addPermission.validation.nameAlreadyExist"));
}
per = perRepo.GetByKey(request.Key);
if (per != null && per.Id != request.Id)
{
validationException.Add(new App.Common.Validation.ValidationError("security.addPermission.validation.keyAlreadyExist"));
}
validationException.ThrowIfError();
}
public async Task <UpdatePermissionResponse> Update(UpdatePermissionRequest request, AdminKey adminKey = null, HttpClient httpClient = null)
{
using (var api = new GetAddesssApi(adminKey ?? AdminKey, HttpClient ?? httpClient))
{
return(await api.Permission.Update(request));
}
}
public async Task <IActionResult> PutPermissionByRoleId(string roleId, [FromBody] UpdatePermissionRequest request)
{
//create new permission list from user changed
//// CREATE NEW LIST PERMISSION TO SAVE PERMISSION THOSE USER CHANGED
var newPermissions = new List <Permission>();
foreach (var p in request.Permissions)
{
newPermissions.Add(new Permission(p.FunctionId, roleId, p.CommandId));
}
//// GET ALL PERMISSION WITH ROLE ID (KEY OF ROLE) WHICH EXIST IN DATABASE AND REMOVE THEM
var existingPermissions = _context.Permissions.Where(x => x.RoleId == roleId);
_context.Permissions.RemoveRange(existingPermissions);
//// ADD NEW PERMISSIONS INTO DATABASE TO CHANGE PERMISSION OF THAT ROLE AND SAVE CHANGE
_context.Permissions.AddRange(newPermissions.Distinct(new MyPermissionComparer()));
var result = await _context.SaveChangesAsync();
//// IF RESULT AFTER UPDATE IS GREATER THAN 0 (TRUE), RETURN STATUS 201, ELSE RETURN 400
if (result > 0)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse("Save permission failed")));
}
public void Security_Permission_CreatePermission_ShouldThrowException_WithEmptyId()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(Guid.Empty, "new updated name" + Guid.NewGuid(), "New updated Key " + Guid.NewGuid(), "desc");
IResponseData <object> response = this.Connector.Put <UpdatePermissionRequest, object>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "common.validation.invalidRequest"));
}
public void Security_Permission_UpdatePermission_ShouldThrowException_WithEmptyNameAndKey()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(this.createdPermissionResponse.Id, string.Empty, string.Empty, "desc");
IResponseData <string> response = this.Connector.Put <UpdatePermissionRequest, string>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.nameIsRequire"));
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.keyIsRequire"));
}
public void UpdatePermission(UpdatePermissionRequest request)
{
ValidateUpdateRequest(request);
using (IUnitOfWork uow = new UnitOfWork(new AppDbContext(IOMode.Write))) {
IPermissionRepository perRepo = IoC.Container.Resolve <IPermissionRepository>(uow);
Permission existedPermission = perRepo.GetById(request.Id.ToString());
existedPermission.Name = request.Name;
existedPermission.Key = request.Key;
existedPermission.Description = request.Description;
perRepo.Update(existedPermission);
uow.Commit();
}
}
public override async Task <Empty> UpdatePermission(UpdatePermissionRequest request, ServerCallContext context)
{
var command = new UpdatePermissionCommand
{
Id = request.Id,
Code = request.Code,
Name = request.Name,
Description = request.Description,
IsEnabled = request.IsEnabled,
};
await _authorizationApp.UpdatePermissionAsync(command);
return(new Empty());
}
public async Task OnGet()
{
var response = await _permissionsService.GetPermission(new GetPermissionRequest()
{
Id = Id
});
Key = response.Permission.Key;
FormData = new UpdatePermissionRequest()
{
Id = response.Permission.Id,
Description = response.Permission.Description,
GroupName = response.Permission.Group_Name,
Name = response.Permission.Name
};
}
public UpdatePermissionRequestValidatorTest()
{
request = new UpdatePermissionRequest()
{
Permissions = new List <PermissionVm>()
{
new PermissionVm()
{
CommandId = "ADD",
FunctionId = "CONTENT",
RoleId = "Admin"
}
}
};
validator = new UpdatePermissionRequestValidator();
}
public async Task <IActionResult> EditPermission(UpdatePermissionRequest request)
{
if (ModelState.IsValid)
{
var response = await _adminService.UpdatePermission(request);
if (response.IsSuccessful)
{
AddNotifications(response);
return(RedirectToAction(nameof(AdminController.PermissionManagement)));
}
AddFormErrors(response);
}
var viewModel = new EditPermissionViewModel(request);
return(View(viewModel));
}
public IResponseData <string> UpdatePermission([FromUri] Guid id, UpdatePermissionRequest request)
{
IResponseData <string> response = new ResponseData <string>();
try
{
request.Id = id;
IPermissionService permissionService = IoC.Container.Resolve <IPermissionService>();
permissionService.UpdatePermission(request);
}
catch (ValidationException ex)
{
response.SetErrors(ex.Errors);
response.SetStatus(System.Net.HttpStatusCode.PreconditionFailed);
}
return(response);
}
public async Task UpdatePermission(UpdatePermissionRequest request)
{
var sqlStoredProc = "sp_permission_update";
var response = await DapperAdapter.GetFromStoredProcAsync <int>
(
storedProcedureName : sqlStoredProc,
parameters : request,
dbconnectionString : DefaultConnectionString,
sqltimeout : DefaultTimeOut,
dbconnection : _connection,
dbtransaction : _transaction);
if (response == null || response.FirstOrDefault() == 0)
{
throw new Exception("No items have been updated");
}
}
public async Task <IActionResult> UpdatePermissionAsync([FromRoute] Guid id, [FromBody] UpdatePermissionInput input)
{
if (id != input.Id)
{
return(BadRequest());
}
var request = new UpdatePermissionRequest
{
Id = input.Id,
Code = input.Code,
Name = input.Name,
Description = input.Description,
IsEnabled = input.IsEnabled,
};
var response = await _authorizationClient.UpdatePermissionAsync(request);
return(NoContent());
}
public IHttpActionResult UpdatePermission(UpdatePermissionRequest request)
{
request.ValidateNotNull();
PermissionDomain permissionDomain = _permissionManipulation.GetPermissionById(request.Id);
if (permissionDomain == null)
{
return(NotFound());
}
permissionDomain.Code = request.Code;
permissionDomain.IsActive = request.IsActive;
permissionDomain.ModuleId = request.ModuleId;
_permissionManipulation.UpdatePermission(permissionDomain);
return(Ok(new UpdatePermissionResponse()
{
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
public async Task <IActionResult> PutPermissionByRoleId(string roleId, [FromBody] UpdatePermissionRequest request)
{
//create new permission list from user changed
var newPermissions = new List <Permission>();
foreach (var p in request.Permissions)
{
newPermissions.Add(new Permission(p.FunctionId, p.RoleId, p.CommandId));
}
var existingPermissions = _context.Permissions.Where(x => x.RoleId == roleId);
_context.Permissions.RemoveRange(existingPermissions);
_context.Permissions.AddRange(newPermissions.Distinct(new MyPermissionComparer()));
var result = await _context.SaveChangesAsync();
if (result > 0)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse("Save permission failed")));
}
public async Task <UpdatePermissionResponse> UpdatePermission(UpdatePermissionRequest request)
{
var sessionUser = await _sessionManager.GetUser();
var response = new UpdatePermissionResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
await uow.UserRepo.UpdatePermission(new Repositories.DatabaseRepos.UserRepo.Models.UpdatePermissionRequest()
{
Id = request.Id,
Name = request.Name,
Group_Name = request.GroupName,
Description = request.Description,
Updated_By = sessionUser.Id
});
uow.Commit();
}
_cache.Remove(CacheConstants.Permissions);
var permissions = await _cache.Permissions();
var permission = permissions.FirstOrDefault(c => c.Id == request.Id);
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.PermissionUpdated,
Info = new Dictionary <string, string>()
{
{ "Key", permission.Key }
}
});
response.Notifications.Add($"Permission '{permission.Key}' has been updated", NotificationTypeEnum.Success);
return(response);
}
public async Task <IActionResult> OnGet()
{
var response = await _permissionsService.GetPermission(new GetPermissionRequest()
{
Id = Id
});
if (!response.IsSuccessful)
{
return(NotFound());
}
Key = response.Permission.Key;
FormData = new UpdatePermissionRequest()
{
Id = response.Permission.Id,
Description = response.Permission.Description,
GroupName = response.Permission.Group_Name,
Name = response.Permission.Name
};
return(Page());
}
private void ValidateUpdateRequest(UpdatePermissionRequest request)
{
if (string.IsNullOrWhiteSpace(request.Name))
{
throw new App.Common.Validation.ValidationException("security.addPermission.validation.nameIsRequire");
}
IPermissionRepository perRepo = IoC.Container.Resolve <IPermissionRepository>();
Permission per = perRepo.GetByName(request.Name);
if (per != null && per.Id != request.Id)
{
throw new App.Common.Validation.ValidationException("security.addPermission.validation.nameAlreadyExist");
}
if (string.IsNullOrWhiteSpace(request.Key))
{
throw new App.Common.Validation.ValidationException("security.addPermission.validation.keyIsRequire");
}
per = perRepo.GetByName(request.Key);
if (per != null && per.Id != request.Id)
{
throw new App.Common.Validation.ValidationException("security.addPermission.validation.keyAlreadyExist");
}
}
public async Task <IActionResult> PutPermission([FromRoute] Guid permissionId, [FromBody] UpdatePermissionRequest request)
{
var updated = await _permissionService.UpdatePermissionAsync(permissionId, request);
if (updated != null)
{
return(Ok(updated));
}
return(NotFound());
}
public async static Task <UpdatePermissionResponse> Update(GetAddesssApi api, UpdatePermissionRequest request, string path, AdminKey adminKey)
{
if (api == null)
{
throw new ArgumentNullException(nameof(api));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
api.SetAuthorizationKey(adminKey);
var response = await api.Put(path, request);
var body = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
var message = MessageResponse.GetMessageResponse(body);
return(new UpdatePermissionResponse.Success((int)response.StatusCode, response.ReasonPhrase, body, message.Message));
}
return(new UpdatePermissionResponse.Failed((int)response.StatusCode, response.ReasonPhrase, body));
}
public async Task <UpdatePermissionResponse> Update(UpdatePermissionRequest request)
{
return(await Update(Api, request, Path, AdminKey));
}
public async Task <IActionResult> Update([FromBody] UpdatePermissionRequest request, CancellationToken cancellationToken = default)
{
await _mediator.Send(request, cancellationToken);
return(NoContent());
}
public EditPermissionModel(IPermissionsService permissionsService)
{
_permissionsService = permissionsService;
FormData = new UpdatePermissionRequest();
}
public async Task <PermissionResponse> UpdatePermissionAsync(Guid permissionId, UpdatePermissionRequest permissionToUpdate)
{
var updatedPermission = _mapper.Map <Permission>(permissionToUpdate);
updatedPermission.Id = permissionId;
var updated = await _permissionRepo.UpdatePermissionAsync(updatedPermission);
if (updated)
{
return(await GetPermissionByIdAsync(updatedPermission.Id));
}
return(null);
}
