public async Task <OperationResult> UpdateAsync(
long roleId,
RoleUpdateModel updateModel,
CancellationToken cancellationToken)
{
using var logScope = OperationLogMessages.BeginOperationScope(_logger, this);
OperationLogMessages.OperationPerforming(_logger);
OperationLogMessages.OperationAuthorizing(_logger);
var authResult = await _authorizationService.RequirePermissionsAsync(
new[] { (int)AdministrationPermission.ManageRoles },
cancellationToken);
if (authResult.IsFailure)
{
OperationLogMessages.OperationNotAuthorized(_logger);
return(authResult.Error);
}
OperationLogMessages.OperationAuthorized(_logger);
var performedById = _authenticationService.CurrentTicket !.UserId;
var result = await _rolesService.UpdateAsync(roleId, updateModel, performedById, cancellationToken);
OperationLogMessages.OperationPerformed(_logger, result);
return(result);
}
public static void RoleUpdating(
ILogger logger,
long roleId,
RoleUpdateModel updateModel,
ulong performedById)
=> _roleUpdating.Invoke(
logger,
roleId,
updateModel,
performedById);
public async Task <OperationResult> UpdateAsync(
long roleId,
RoleUpdateModel updateModel,
ulong performedById,
CancellationToken cancellationToken)
{
RolesLogMessages.RoleUpdating(_logger, roleId, updateModel, performedById);
using var transactionScope = _transactionScopeFactory.CreateScope();
TransactionsLogMessages.TransactionScopeCreated(_logger);
var nameValidationResult = await ValidateNameAsync(updateModel.Name, roleId, cancellationToken);
if (nameValidationResult.IsFailure)
{
RolesLogMessages.RoleNameValidationFailed(_logger, updateModel.Name, nameValidationResult);
return(nameValidationResult);
}
RolesLogMessages.RoleNameValidationSucceeded(_logger, updateModel.Name);
var grantedPermissionIdsValidationResult = await _permissionsService.ValidateIdsAsync(updateModel.GrantedPermissionIds, cancellationToken);
if (grantedPermissionIdsValidationResult.IsFailure)
{
RolesLogMessages.PermissionIdsValidationFailed(_logger, updateModel.GrantedPermissionIds, grantedPermissionIdsValidationResult);
return(grantedPermissionIdsValidationResult);
}
RolesLogMessages.PermissionIdsValidationSucceeded(_logger, updateModel.GrantedPermissionIds);
var now = _systemClock.UtcNow;
var actionId = await _auditableActionsRepository.CreateAsync(
(int)RoleManagementAdministrationActionType.RoleModified,
now,
performedById,
cancellationToken);
AuditingLogMessages.AuditingActionCreated(_logger, actionId);
var updateResult = await _rolesRepository.UpdateAsync(
roleId : roleId,
actionId : actionId,
name : updateModel.Name,
cancellationToken : cancellationToken);
if (updateResult.IsFailure && !(updateResult.Error is NoChangesGivenError))
{
RolesLogMessages.RoleUpdateFailed(_logger, roleId, updateResult);
return(updateResult);
}
RolesLogMessages.RoleUpdated(_logger, roleId, updateResult);
var anyChanges = updateResult.IsSuccess;
RolesLogMessages.RolePermissionMappingIdentitiesFetching(_logger, roleId);
var permissionMappings = await _rolesRepository.AsyncEnumeratePermissionMappingIdentities(
roleId : roleId,
isDeleted : false)
.ToArrayAsync(cancellationToken);
RolesLogMessages.RolePermissionMappingIdentitiesFetched(_logger, roleId);
anyChanges |= await HandleRemovedPermissionMappings(
roleId,
permissionMappings,
updateModel.GrantedPermissionIds,
actionId,
cancellationToken);
anyChanges |= await HandleAddedPermissions(
permissionMappings,
updateModel.GrantedPermissionIds,
roleId,
actionId,
cancellationToken);
if (!anyChanges)
{
RolesLogMessages.RoleUpdateNoChangesGiven(_logger, roleId);
return(new NoChangesGivenError($"Role ID {roleId}"));
}
RolesLogMessages.RoleUpdatingNotificationPublishing(_logger, roleId);
await _messenger.PublishNotificationAsync(
new RoleUpdatingNotification(
roleId,
actionId),
cancellationToken);
RolesLogMessages.RoleUpdatingNotificationPublished(_logger, roleId);
transactionScope.Complete();
TransactionsLogMessages.TransactionScopeCommitted(_logger);
_memoryCache.Remove(_getCurrentIdentitiesCacheKey);
RolesLogMessages.RoleIdentitiesCacheCleared(_logger);
return(OperationResult.Success);
}
