private async Task <bool> HandleRemovedPermissionMappings( long roleId, IEnumerable <RolePermissionMappingIdentityViewModel> permissionMappings, IEnumerable <int> grantedPermissionIds, long actionId, CancellationToken cancellationToken) { var removedPermissionMappingIds = permissionMappings .Where(x => !grantedPermissionIds.Contains(x.PermissionId)) .Select(x => x.Id) .ToArray(); if (!removedPermissionMappingIds.Any()) { return(false); } RolesLogMessages.RolePermissionMappingsDeleting(_logger, roleId, removedPermissionMappingIds); await _rolesRepository.UpdatePermissionMappingsAsync( removedPermissionMappingIds, deletionId : actionId, cancellationToken); RolesLogMessages.RolePermissionMappingsDeleted(_logger, roleId); return(true); }
private async Task <bool> HandleAddedPermissions( IEnumerable <RolePermissionMappingIdentityViewModel> permissionMappings, IEnumerable <int> grantedPermissionIds, long roleId, long actionId, CancellationToken cancellationToken) { var addedPermissionIds = grantedPermissionIds .Except(permissionMappings.Select(x => x.PermissionId)) .ToArray(); if (!addedPermissionIds.Any()) { return(false); } RolesLogMessages.RolePermissionMappingsCreating(_logger, roleId, addedPermissionIds); var mappingIds = await _rolesRepository.CreatePermissionMappingsAsync( roleId, addedPermissionIds, actionId, cancellationToken); RolesLogMessages.RolePermissionMappingsCreated(_logger, roleId, mappingIds); return(true); }
public async ValueTask <OperationResult> ValidateIdsAsync( IReadOnlyCollection <long> roleIds, CancellationToken cancellationToken) { RolesLogMessages.RoleIdsValidating(_logger, roleIds); if (!roleIds.Any()) { RolesLogMessages.RoleIdsValidationSucceeded(_logger); return(OperationResult.Success); } var invalidRoleIds = roleIds .Except((await GetCurrentIdentitiesAsync(cancellationToken)) .Select(x => x.Id)) .ToArray(); if (invalidRoleIds.Length == 0) { RolesLogMessages.RoleIdsValidationSucceeded(_logger); return(OperationResult.Success); } else if (invalidRoleIds.Length == 1) { RolesLogMessages.RoleIdsValidationFailed(_logger, invalidRoleIds); return(new DataNotFoundError($"Role ID {invalidRoleIds.First()}")); } else { RolesLogMessages.RoleIdsValidationFailed(_logger, invalidRoleIds); return(new DataNotFoundError($"Role IDs {string.Join(", ", invalidRoleIds)}")); } }
public async Task <OperationResult <long> > CreateAsync( RoleCreationModel creationModel, ulong performedById, CancellationToken cancellationToken) { RolesLogMessages.RoleCreating(_logger, creationModel, performedById); using var transactionScope = _transactionScopeFactory.CreateScope(); TransactionsLogMessages.TransactionScopeCreated(_logger); var nameValidationResult = await ValidateNameAsync(creationModel.Name, null, cancellationToken); if (nameValidationResult.IsFailure) { RolesLogMessages.RoleNameValidationFailed(_logger, creationModel.Name, nameValidationResult); return(nameValidationResult.Error); } RolesLogMessages.RoleNameValidationSucceeded(_logger, creationModel.Name); var grantedPermissionIdsValidationResult = await _permissionsService.ValidateIdsAsync(creationModel.GrantedPermissionIds, cancellationToken); if (grantedPermissionIdsValidationResult.IsFailure) { RolesLogMessages.PermissionIdsValidationFailed(_logger, creationModel.GrantedPermissionIds, grantedPermissionIdsValidationResult); return(grantedPermissionIdsValidationResult.Error); } RolesLogMessages.PermissionIdsValidationSucceeded(_logger, creationModel.GrantedPermissionIds); var actionId = await _auditableActionsRepository.CreateAsync( (int)RoleManagementAdministrationActionType.RoleCreated, _systemClock.UtcNow, performedById, cancellationToken); AuditingLogMessages.AuditingActionCreated(_logger, actionId); var roleId = await _rolesRepository.CreateAsync( creationModel.Name, actionId, cancellationToken); RolesLogMessages.RoleCreated(_logger, roleId); var mappingIds = await _rolesRepository.CreatePermissionMappingsAsync( roleId, creationModel.GrantedPermissionIds, actionId, cancellationToken); RolesLogMessages.RolePermissionMappingsCreated(_logger, roleId, mappingIds); _memoryCache.Remove(_getCurrentIdentitiesCacheKey); RolesLogMessages.RoleIdentitiesCacheCleared(_logger); transactionScope.Complete(); TransactionsLogMessages.TransactionScopeCommitted(_logger); return(roleId.ToSuccess()); }
public async Task <OperationResult> DeleteAsync( long roleId, ulong performedById, CancellationToken cancellationToken) { RolesLogMessages.RoleDeleting(_logger, roleId, performedById); using var transactionScope = _transactionScopeFactory.CreateScope(); TransactionsLogMessages.TransactionScopeCreated(_logger); var actionId = await _auditableActionsRepository.CreateAsync( (int)RoleManagementAdministrationActionType.RoleDeleted, _systemClock.UtcNow, performedById, cancellationToken); AuditingLogMessages.AuditingActionCreated(_logger, actionId); var deleteResult = await _rolesRepository.UpdateAsync( roleId : roleId, actionId : actionId, isDeleted : true, cancellationToken : cancellationToken); if (deleteResult.IsSuccess) { RolesLogMessages.RoleDeleted(_logger, roleId, deleteResult.Value); _memoryCache.Remove(_getCurrentIdentitiesCacheKey); RolesLogMessages.RoleIdentitiesCacheCleared(_logger); RolesLogMessages.RoleDeletingNotificationPublishing(_logger, roleId); await _messenger.PublishNotificationAsync( new RoleDeletingNotification( roleId, actionId), cancellationToken); RolesLogMessages.RoleDeletingNotificationPublished(_logger, roleId); transactionScope.Complete(); TransactionsLogMessages.TransactionScopeCommitted(_logger); } else { RolesLogMessages.RoleDeleteFailed(_logger, roleId, deleteResult); } return(deleteResult); }
public ValueTask <IReadOnlyCollection <RoleIdentityViewModel> > GetCurrentIdentitiesAsync( CancellationToken cancellationToken) => _memoryCache.OptimisticGetOrCreateAsync <IReadOnlyCollection <RoleIdentityViewModel> >(_getCurrentIdentitiesCacheKey, async entry => { RolesLogMessages.RoleIdentitiesFetchingCurrent(_logger); entry.Priority = CacheItemPriority.High; var result = await _rolesRepository.AsyncEnumerateIdentities( isDeleted: false) .ToArrayAsync(cancellationToken); RolesLogMessages.RoleIdentitiesFetchedCurrent(_logger); return(result); });
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); }