/// <inheritdoc/>
    public async Task <IEnumerable <IdentityProviderName> > GetAllSchemeNamesAsync()
    {
        using var activity = Tracing.StoreActivitySource.StartActivity("CachingIdentityProviderStore.GetAllSchemeNames");

        var result = await _allCache.GetOrAddAsync("__all__",
                                                   _options.Caching.IdentityProviderCacheDuration,
                                                   async() => await _inner.GetAllSchemeNamesAsync());

        return(result);
    }
Esempio n. 2
0
    private async Task BuildModelAsync(string returnUrl)
    {
        Input = new InputModel
        {
            ReturnUrl = returnUrl
        };

        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);

        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == Duende.IdentityServer.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            View = new ViewModel
            {
                EnableLocalLogin = local,
            };

            Input.Username = context?.LoginHint;

            if (!local)
            {
                View.ExternalProviders = new[] { new ViewModel.ExternalProvider {
                                                     AuthenticationScheme = context.IdP
                                                 } };
            }

            return;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
                        .Where(x => x.DisplayName != null)
                        .Select(x => new ViewModel.ExternalProvider
        {
            DisplayName          = x.DisplayName ?? x.Name,
            AuthenticationScheme = x.Name
        }).ToList();

        var dyanmicSchemes = (await _identityProviderStore.GetAllSchemeNamesAsync())
                             .Where(x => x.Enabled)
                             .Select(x => new ViewModel.ExternalProvider
        {
            AuthenticationScheme = x.Scheme,
            DisplayName          = x.DisplayName
        });

        providers.AddRange(dyanmicSchemes);


        var allowLocal = true;
        var client     = context?.Client;

        if (client != null)
        {
            allowLocal = client.EnableLocalLogin;
            if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
            {
                providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
            }
        }

        View = new ViewModel
        {
            AllowRememberLogin = LoginOptions.AllowRememberLogin,
            EnableLocalLogin   = allowLocal && LoginOptions.AllowLocalLogin,
            ExternalProviders  = providers.ToArray()
        };
    }
 /// <inheritdoc/>
 public Task <IEnumerable <IdentityProviderName> > GetAllSchemeNamesAsync()
 {
     return(_inner.GetAllSchemeNamesAsync());
 }