private async Task SaveAsync()
{
try
{
var updateDto = new UpdatePermissionsDto
{
Permissions = _groups
.SelectMany(g => g.Permissions)
.Select(p => new UpdatePermissionDto {
IsGranted = p.IsGranted, Name = p.Name
})
.ToArray()
};
await PermissionAppService.UpdateAsync(_providerName, _providerKey, updateDto);
await CurrentApplicationConfigurationCacheResetService.ResetAsync();
await InvokeAsync(_modal.Hide);
}
catch (Exception ex)
{
await HandleErrorAsync(ex);
}
}
public async Task OpenAsync(string providerName, string providerKey, string entityDisplayName = null)
{
_providerName = providerName;
_providerKey = providerKey;
var result = await PermissionAppService.GetAsync(_providerName, _providerKey);
_entityDisplayName = entityDisplayName ?? result.EntityDisplayName;
_groups = result.Groups;
_grantedPermissionCount = 0;
_notGrantedPermissionCount = 0;
foreach (var permission in _groups.SelectMany(x => x.Permissions))
{
if (permission.IsGranted && permission.GrantedProviders.All(x => x.ProviderName != _providerName))
{
_disabledPermissions.Add(permission);
continue;
}
if (permission.IsGranted)
{
_grantedPermissionCount++;
}
else
{
_notGrantedPermissionCount++;
}
}
_selectedTabName = GetNormalizedGroupName(_groups.First().Name);
_modal.Show();
}
public virtual async Task <IActionResult> OnPostAsync()
{
ValidateModel();
var updatePermissionDtos = Groups
.SelectMany(g => g.Permissions)
.Select(p => new UpdatePermissionDto
{
Name = p.Name,
IsGranted = p.IsGranted
})
.ToArray();
await PermissionAppService.UpdateAsync(
ProviderName,
ProviderKey,
new UpdatePermissionsDto
{
Permissions = updatePermissionDtos
}
);
await LocalEventBus.PublishAsync(
new CurrentApplicationConfigurationCacheResetEventData()
);
return(NoContent());
}
public virtual async Task <IActionResult> OnGetAsync()
{
ValidateModel();
var result = await PermissionAppService.GetAsync(ProviderName, ProviderKey);
EntityDisplayName = !string.IsNullOrWhiteSpace(ProviderKeyDisplayName)
? ProviderKeyDisplayName
: result.EntityDisplayName;
Groups = ObjectMapper
.Map <List <PermissionGroupDto>, List <PermissionGroupViewModel> >(result.Groups)
.OrderBy(g => g.DisplayName)
.ToList();
foreach (var group in Groups)
{
new FlatTreeDepthFinder <PermissionGrantInfoViewModel>().SetDepths(group.Permissions);
}
foreach (var group in Groups)
{
group.IsAllPermissionsGranted = group.Permissions.All(p => p.IsGranted);
}
SelectAllInAllTabs = Groups.All(g => g.IsAllPermissionsGranted);
return(Page());
}
private async Task SaveAsync()
{
try
{
var updateDto = new UpdatePermissionsDto
{
Permissions = _groups
.SelectMany(g => g.Permissions)
.Select(p => new UpdatePermissionDto {
IsGranted = p.IsGranted, Name = p.Name
})
.ToArray()
};
if (!updateDto.Permissions.Any(x => x.IsGranted))
{
if (!await Message.Confirm(L["RemoveAllPermissionsWarningMessage"].Value))
{
return;
}
}
await PermissionAppService.UpdateAsync(_providerName, _providerKey, updateDto);
await CurrentApplicationConfigurationCacheResetService.ResetAsync();
await InvokeAsync(_modal.Hide);
}
catch (Exception ex)
{
await HandleErrorAsync(ex);
}
}
private async Task SaveAsync()
{
var updateDto = new UpdatePermissionsDto
{
Permissions = _groups
.SelectMany(g => g.Permissions)
.Select(p => new UpdatePermissionDto {
IsGranted = p.IsGranted, Name = p.Name
})
.ToArray()
};
await PermissionAppService.UpdateAsync(_providerName, _providerKey, updateDto);
_modal.Hide();
}
public async Task TestPermissionHandler()
{
var userRepository = new Repository <User>(KodkodInMemoryContext);
var permissionRepository = new Repository <Permission>(KodkodInMemoryContext);
var roleRepository = new Repository <Role>(KodkodInMemoryContext);
var rolePermissionRepository = new Repository <RolePermission>(KodkodInMemoryContext);
var permissionAppService = new PermissionAppService(userRepository, permissionRepository, roleRepository, rolePermissionRepository, Mapper);
var requirements = new List <PermissionRequirement>
{
new PermissionRequirement(ApiUserPermission)
};
var authorizationHandlerContext = new AuthorizationHandlerContext(requirements, ContextUser, null);
var permissionHandler = new PermissionHandler(permissionAppService);
await permissionHandler.HandleAsync(authorizationHandlerContext);
Assert.True(authorizationHandlerContext.HasSucceeded);
}
public async Task OpenAsync(string providerName, string providerKey)
{
_providerName = providerName;
_providerKey = providerKey;
var result = await PermissionAppService.GetAsync(_providerName, _providerKey);
_entityDisplayName = result.EntityDisplayName;
_groups = result.Groups;
_disabledPermissions =
_groups.SelectMany(x => x.Permissions)
.Where(
x => x.IsGranted &&
x.GrantedProviders.All(y => y.ProviderName != _providerName)
).ToList();
_selectedTabName = GetNormalizedGroupName(_groups.First().Name);
_modal.Show();
}
public PermissionAppServiceTest()
{
_fixture = new Fixture();
var mapperMock = new Mock <IMapper>();
_mapperMock = mapperMock.Object;
ConfigureRoleList();
var permissionServiceMock = new Mock <IPermissionService>();
permissionServiceMock
.Setup(x => x.ComposeRole(It.IsAny <IdentityRole>(), It.IsAny <IEnumerable <Claim> >()))
.Returns(ConfigureRole());
_permissionServiceMock = permissionServiceMock.Object;
var identityRepositoryMock = new Mock <IIdentityRepository>();
identityRepositoryMock
.Setup(x => x.GetAllRoles())
.Returns(ConfigureIdentityRole());
identityRepositoryMock
.Setup(x => x.GetAllUsers())
.Returns(new List <ApplicationUser>());
_identityRepositoryMock = identityRepositoryMock;
_permissionAppServiceMock = new PermissionAppService
(
identityRepositoryMock.Object,
_permissionServiceMock,
_mapperMock
);
}
