private ConsentViewModel CreateConsentViewModel(
string returnUrl,
Client client,
IdentityServer4.Models.Resources resources,
ConsentInputModel model = null)
{
var vm = new ConsentViewModel
{
RememberConsent = model?.RememberConsent ?? true,
ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>(),
ReturnUrl = returnUrl,
ClientName = client.ClientName,
ClientUrl = client.ClientUri,
ClientLogoUrl = client.LogoUri,
AllowRememberConsent = client.AllowRememberConsent
};
vm.IdentityScopes = resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();
vm.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
vm.ResourceScopes = vm.ResourceScopes.Union(new [] {
GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServerConstants.StandardScopes.OfflineAccess) || model == null)
});
}
return(vm);
}
private ConsentViewModel CreateConsentViewModel(
ConsentInputModel model, string returnUrl,
AuthorizationRequest request,
Client client, IdentityServer4.Models.Resources resources)
{
var vm = new ConsentViewModel();
vm.RememberConsent = model?.RememberConsent ?? true;
vm.ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>();
vm.ReturnUrl = returnUrl;
vm.ClientName = client.ClientName ?? client.ClientId;
vm.ClientUrl = client.ClientUri;
vm.ClientLogoUrl = client.LogoUri;
vm.AllowRememberConsent = client.AllowRememberConsent;
vm.IdentityScopes = resources.IdentityResources.Select(x => CreateScopeViewModel(x, Enumerable.Contains(vm.ScopesConsented, x.Name) || model == null)).ToArray();
vm.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => CreateScopeViewModel(x, Enumerable.Contains(vm.ScopesConsented, x.Name) || model == null)).ToArray();
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
vm.ResourceScopes = Enumerable.Union(vm.ResourceScopes, new ScopeViewModel[] {
GetOfflineAccessScope(Enumerable.Contains(vm.ScopesConsented, IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null)
});
}
return(vm);
}
/// <inheritdoc/>
public Task <IdentityServer4.Models.Resources> GetAllResourcesAsync()
{
var apiResources = _authContext.Application.ApiResources?.Select(_ => ConvertToResource <ApiResource>(_)) ?? new ApiResource[0];
var identityResources = GetIdentityResourcesFrom(_authContext);
var resources = new IdentityServer4.Models.Resources(identityResources, apiResources);
return(Task.FromResult(resources));
}
public async Task <IdentityServer4.Models.Resources> GetAllResourcesAsync()
{
var identityResources = await _repository.GetAllAsync <IdentityResource>();
var apiResources = await _repository.GetAllAsync <ApiResource>();
var apiScopes = await _repository.GetAllAsync <ApiScope>();
var result = new IdentityServer4.Models.Resources(identityResources, apiResources, apiScopes);
return(result);
}
public Task <IdentityServer4.Models.Resources> GetAllResourcesAsync()
{
var apiResources = GetApiResources().ApiResources.Select(api => api);
var identityResources = GetApiResources().IdentityResources.Select(id => id);
var scopeResources = GetApiResources().ApiScopes.Select(id => id);
var resources = new IdentityServer4.Models.Resources(identityResources, apiResources, scopeResources);
return(Task.FromResult(resources));
}
public Task <IdentityServer4.Models.Resources> GetAllResourcesAsync()
{
var identity = _context.IdentityResources.AsQueryable();
var apis = _context.ApiResources.AsQueryable();
var result = new IdentityServer4.Models.Resources(
identity.ToArray().Select(x => x.ToModel()).AsEnumerable(),
apis.ToArray().Select(x => x.ToModel()).AsEnumerable());
_logger.LogDebug("Found {scopes} as all scopes in database", result.IdentityResources.Select(x => x.Name).Union(result.ApiResources.SelectMany(x => x.Scopes).Select(x => x.Name)));
return(Task.FromResult(result));
}
public Task <is4Models.Resources> GetAllResourcesAsync()
{
var identity = _identityResourceService.GetAll();
var apis = _apiResourceService.GetAll();
var result = new is4Models.Resources(
_mapper.Map <List <is4Models.IdentityResource> >(identity),
_mapper.Map <List <is4Models.ApiResource> >(apis));
_logger.LogDebug("Found {scopes} as all scopes in database", result.IdentityResources.Select(x => x.Name).Union(result.ApiResources.SelectMany(x => x.Scopes).Select(x => x.Name)));
return(Task.FromResult(result));
}
private void CreateConsentViewModel(string returnUrl, AuthorizationRequest request, IdentityServer4.Models.Client client,
IdentityServer4.Models.Resources resources, IList <string> consentedScopes)
{
ConsentData.ReturnUrl = returnUrl;
ConsentData.ClientName = client.ClientName ?? client.ClientId;
ConsentData.ClientUrl = client.ClientUri;
ConsentData.ClientLogoUrl = client.LogoUri;
ConsentData.AllowRememberConsent = client.AllowRememberConsent;
ConsentData.IdentityScopes = resources.IdentityResources.Select(x => CreateScopeViewModel(x, consentedScopes == null || consentedScopes.Contains(x.Name))).ToArray();
ConsentData.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => CreateScopeViewModel(x, consentedScopes == null || consentedScopes.Contains(x.Name))).ToArray();
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
ConsentData.ResourceScopes = ConsentData.ResourceScopes.Union(new ScopeViewModel[] {
GetOfflineAccessScope(consentedScopes == null || consentedScopes.Contains(IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess))
});
}
}
private ConsentViewModel CreateConsentViewModel(
string returnUrl,
Client client,
IdentityServer4.Models.Resources resources,
AuthorizationRequest request,
ConsentInputModel model = null)
{
var vm = new ConsentViewModel
{
RememberConsent = model?.RememberConsent ?? true,
ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>(),
ReturnUrl = returnUrl,
ClientName = client.ClientName,
ClientUrl = client.ClientUri,
ClientLogoUrl = client.LogoUri,
AllowRememberConsent = client.AllowRememberConsent
};
vm.IdentityScopes = resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();
var apiScopes = new List <ScopeViewModel>();
foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
{
var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
if (apiScope != null)
{
var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
apiScopes.Add(scopeVm);
}
}
if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
{
apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
}
vm.ApiScopes = apiScopes;
return(vm);
}
public async Task <IActionResult> OnGetAsync(string returnUrl)
{
AuthorizationRequest = await identityServer.GetAuthorizationContextAsync(returnUrl).ConfigureAwait(false);
if (AuthorizationRequest == null)
{
return(Forbid());
}
ViewModel = new ConsentInputViewModel
{
ReturnUrl = returnUrl,
RememberConsent = true
};
var scopes = AuthorizationRequest.ValidatedResources.ParsedScopes.Select(e => e.ParsedName);
Resources = await resourceStore.FindEnabledResourcesByScopeAsync(scopes)
.ConfigureAwait(false);
return(Page());
}
/// See <see cref="IResourceStore"/> for more.
public Task <IsResources> GetAllResourcesAsync()
{
var resources = new IsResources(_identityResources, _apiResources);
return(Task.FromResult(resources));
}
public ConsentViewModel(ConsentInputModel model, string returnUrl, AuthorizationRequest request, Client client, IdentityServer4.Models.Resources resources)
{
RememberConsent = model?.RememberConsent ?? true;
ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>();
ReturnUrl = returnUrl;
ClientName = client.ClientName;
ClientUrl = client.ClientUri;
ClientLogoUrl = client.LogoUri;
AllowRememberConsent = client.AllowRememberConsent;
IdentityScopes = resources.IdentityResources.Select(x => new ScopeViewModel(x, ScopesConsented.Contains(x.Name) || model == null)).ToArray();
ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => new ScopeViewModel(x, ScopesConsented.Contains(x.Name) || model == null)).ToArray();
if (resources.OfflineAccess)
{
ResourceScopes = ResourceScopes.Union(new ScopeViewModel[] {
ScopeViewModel.GetOfflineAccess(ScopesConsented.Contains(IdentityServerConstants.StandardScopes.OfflineAccess) || model == null)
});
}
}
