public async Task SeedAsync()
{
(await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
(await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
await _permissionDataSeedContributor.SeedAsync(new DataSeedContext(null));
(await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldNotBeNull();
(await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
}
public async Task <PermissionListResponseModel> GetAsync([NotNull] string providerName, [NotNull] string providerKey)
{
var result = new PermissionListResponseModel {
EntityDisplayName = providerKey, Groups = new List <PermissionGroupModel>()
};
foreach (var group in _permissionDefinitionManager.GetGroups())
{
PermissionGroupModel permissionGroupModel = new()
{
DisplayName = _localizer[group.Name] ?? group.Name,
Name = group.Name,
Permissions = new List <PermissionGrantModel>()
};
foreach (PermissionDefinition?permission in group.GetPermissionsWithChildren())
{
if (permission.IsEnabled && (!permission.AllowedProviders.Any() || permission.AllowedProviders.Contains(providerName)))
{
PermissionGrantModel permissionGrantModel = new()
{
Name = permission.Name,
DisplayName = _localizer[permission.DisplayName ?? permission.Name] ?? permission.Name,
ParentName = permission.Parent?.Name !,
AllowedProviders = permission.AllowedProviders
};
if (permission.AllowedProviders.Any() && !permission.AllowedProviders.Contains(providerName))
{
throw new ApplicationException($"The permission named {permission.Name} has not compatible with the provider named {providerName}");
}
if (!permission.IsEnabled)
{
throw new ApplicationException($"The permission named {permission.Name} is disabled");
}
PermissionGrant?permissionGrant = await _permissionGrantRepository.FindAsync(permission.Name, providerName, providerKey);
permissionGrantModel.IsGranted = permissionGrant != null;
permissionGroupModel.Permissions.Add(permissionGrantModel);
}
}
if (permissionGroupModel.Permissions.Any())
{
result.Groups.Add(permissionGroupModel);
}
}
return(result);
}
public async Task SeedAsync()
{
(await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test").ConfigureAwait(false)).ShouldBeNull();
(await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test").ConfigureAwait(false)).ShouldBeNull();
await _permissionDataSeeder.SeedAsync("Test", "Test", new List <string>()
{
"MyPermission1",
"MyPermission2"
}).ConfigureAwait(false);
(await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test").ConfigureAwait(false)).ShouldNotBeNull();
(await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test").ConfigureAwait(false)).ShouldNotBeNull();
}
public async Task SetAsync()
{
(await _permissionGrantRepository.FindAsync("MyPermission2",
"Test",
"Test")).ShouldBeNull();
await _permissionManager.SetAsync(
"MyPermission2",
"Test",
"Test", true);
(await _permissionGrantRepository.FindAsync("MyPermission2",
"Test",
"Test")).ShouldNotBeNull();
}
public async Task UpdateAsync()
{
(await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
"Test")).ShouldBeNull();
await _permissionAppService.UpdateAsync("Test",
"Test", new UpdatePermissionsDto()
{
Permissions = new UpdatePermissionDto[]
{
new UpdatePermissionDto()
{
IsGranted = true,
Name = "MyPermission1"
}
}
});
(await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
"Test")).ShouldNotBeNull();
}
public async Task SetAsync()
{
_permissionGrantRepository.Insert(
new PermissionGrant(
Guid.NewGuid(),
"MyPermission1",
"Test",
"Test"
)
);
(await _permissionGrantRepository.FindAsync("MyPermission1",
"Test",
"Test")).ShouldNotBeNull();
await _permissionManagementProvider.SetAsync("MyPermission1",
"Test",
false);
(await _permissionGrantRepository.FindAsync("MyPermission1",
"Test",
"Test")).ShouldBeNull();
}
public async Task Cache_Should_Invalidator_WhenPermissionGrantChanged()
{
// IsGrantedAsync will cache PermissionGrant
await _permissionStore.IsGrantedAsync("MyPermission1",
UserPermissionValueProvider.ProviderName,
PermissionTestDataBuilder.User1Id.ToString());
var permissionGrant = await _permissionGrantRepository.FindAsync("MyPermission1",
UserPermissionValueProvider.ProviderName,
PermissionTestDataBuilder.User1Id.ToString());
permissionGrant.ShouldNotBeNull();
await _permissionGrantRepository.DeleteAsync(permissionGrant);
(await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
UserPermissionValueProvider.ProviderName,
PermissionTestDataBuilder.User1Id.ToString()))).ShouldBeNull();
}
public async Task <ActionResult <Client> > Post([FromBody] SaveClientViewModel clientVm)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
var client = await _clientRepository.FindByClientIdAsync(clientVm.Name);
if (client == null)
{
client = await _clientRepository.InsertAsync(
new Client(
Guid.NewGuid(),
clientVm.Name
)
{
ClientName = clientVm.Name,
ProtocolType = "oidc",
Description = clientVm.Name,
AlwaysIncludeUserClaimsInIdToken = true,
AllowOfflineAccess = true,
AbsoluteRefreshTokenLifetime = 31536000, //365 days
AccessTokenLifetime = 31536000, //365 days
AuthorizationCodeLifetime = 300,
IdentityTokenLifetime = 300,
RequireConsent = false
},
autoSave : true
);
}
foreach (var scope in clientVm.Scopes)
{
if (client.FindScope(scope) == null)
{
client.AddScope(scope);
}
}
foreach (var grantType in clientVm.GrantTypes)
{
if (client.FindGrantType(grantType) == null)
{
client.AddGrantType(grantType);
}
}
if (client.FindSecret(clientVm.Secret) == null)
{
client.AddSecret(clientVm.Secret);
}
if (clientVm.RedirectUri != null)
{
if (client.FindRedirectUri(clientVm.RedirectUri) == null)
{
client.AddRedirectUri(clientVm.RedirectUri);
}
}
if (clientVm.PostLogoutRedirectUri != null)
{
if (client.FindPostLogoutRedirectUri(clientVm.PostLogoutRedirectUri) == null)
{
client.AddPostLogoutRedirectUri(clientVm.PostLogoutRedirectUri);
}
}
if (clientVm.Permissions != null)
{
foreach (var permissionName in clientVm.Permissions)
{
if (await _permissionGrantRepository.FindAsync(permissionName, ClientPermissionValueProvider.ProviderName, clientVm.Name) != null)
{
continue;
}
await _permissionGrantRepository.InsertAsync(
new PermissionGrant(
GuidGenerator.Create(),
permissionName,
ClientPermissionValueProvider.ProviderName,
clientVm.Name,
null
)
);
}
}
await _clientRepository.UpdateAsync(client);
var newClient = await _clientRepository.GetAsync(client.Id, true);
return(CreatedAtAction(nameof(GetClient), new { client = client.Id }, newClient));
}
private async Task <bool> VerificarSePermissionParaORoleJaEstaCadastrada(string providerKey, string permission)
{
return(await _permissionGrantRepository.FindAsync(permission, RolePermissionValueProvider.ProviderName, providerKey) != null);
}