public virtual async Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
var schemes = await SchemeProvider.GetAllSchemesAsync();
var providers = schemes
.Where(x => x.DisplayName != null || x.Name.Equals(AccountOptions.WindowsAuthenticationSchemeName, StringComparison.OrdinalIgnoreCase))
.Select(x => new ExternalProviderModel
{
DisplayName = x.DisplayName,
AuthenticationScheme = x.Name
})
.ToList();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
ExternalProviders = providers.ToArray();
if (IsExternalLoginOnly)
{
//return await ExternalLogin(vm.ExternalLoginScheme, returnUrl);
throw new NotImplementedException();
}
return(Page());
}
protected virtual async Task <List <ExternalProviderModel> > GetExternalProviders()
{
var schemes = await SchemeProvider.GetAllSchemesAsync();
return(schemes
.Where(x => x.DisplayName != null || x.Name.Equals(AccountOptions.WindowsAuthenticationSchemeName, StringComparison.OrdinalIgnoreCase))
.Select(x => new ExternalProviderModel {
DisplayName = x.DisplayName,
AuthenticationScheme = x.Name
})
.ToList());
}
private async Task <IEnumerable <ExternalProvider> > GetExternalLoginsAsync(string returnUrl)
{
var externalProviders = default(IEnumerable <ExternalProvider>);
var context = await Interaction.GetAuthorizationContextAsync(returnUrl);
if (context?.IdP != null && await SchemeProvider.GetSchemeAsync(context.IdP) != null)
{
var enableLocalLogin = context.IdP == IdentityServer4.IdentityServerConstants.LocalIdentityProvider;
externalProviders = !enableLocalLogin
? new ExternalProvider[] { new ExternalProvider {
AuthenticationScheme = context.IdP
} }
: new ExternalProvider[] { };
}
externalProviders = (await SchemeProvider.GetAllSchemesAsync())
.Where((authenticationScheme) => authenticationScheme.DisplayName != null)
.Select
(
(authenticationScheme) => new ExternalProvider
{
DisplayName = authenticationScheme.DisplayName ?? authenticationScheme.Name,
AuthenticationScheme = authenticationScheme.Name
}
).ToList();
var allowLocal = true;
if (context?.Client.ClientId != null)
{
var client = await Clients.FindEnabledClientByIdAsync(context.Client.ClientId);
if (client != null)
{
allowLocal = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
externalProviders = externalProviders.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
}
}
}
return(externalProviders.ToArray());
}
private async Task <RegisterViewModel> BuildRegisterViewModelAsync(string returnUrl)
{
var context = await Interaction.GetAuthorizationContextAsync(returnUrl);
if (context?.IdP != null && await SchemeProvider.GetSchemeAsync(context.IdP) != null)
{
var local = context.IdP == IdentityServer4.IdentityServerConstants.LocalIdentityProvider;
// this is meant to short circuit the UI and only trigger the one external IdP
var viewModel = new RegisterViewModel
{
EnableLocalLogin = local,
Email = context?.LoginHint,
ReturnUrl = returnUrl,
ExternalProviders = !local
? new [] { new ExternalProvider {
AuthenticationScheme = context.IdP
} }
: Enumerable.Empty <ExternalProvider>()
};
return(viewModel);
}
var schemes = await SchemeProvider.GetAllSchemesAsync();
var externalProviders = schemes
.Where((authenticationScheme) => authenticationScheme.DisplayName != null)
.Select
(
(authenticationScheme) => new ExternalProvider
{
DisplayName = authenticationScheme.DisplayName ?? authenticationScheme.Name,
AuthenticationScheme = authenticationScheme.Name
}
).ToList();
var allowLocal = true;
if (context?.Client.ClientId != null)
{
var client = await Clients.FindEnabledClientByIdAsync(context.Client.ClientId);
if (client != null)
{
allowLocal = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
externalProviders = externalProviders
.Where
(
(externalProvider) => client.IdentityProviderRestrictions.Contains(externalProvider.AuthenticationScheme)
)
.ToList();
}
}
}
return(new RegisterViewModel
{
AllowRememberLogin = AccountOptions.AllowRememberLogin,
EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
Email = context?.LoginHint,
ReturnUrl = returnUrl,
ExternalProviders = externalProviders.ToArray()
});
}
/*****************************************/
/* helper APIs for the AccountController */
/*****************************************/
private async Task <LoginViewModel> BuildLoginViewModelAsync(string returnUrl)
{
var context = await Interaction.GetAuthorizationContextAsync(returnUrl);
if (context?.IdP != null && await SchemeProvider.GetSchemeAsync(context.IdP) != null)
{
var local = context.IdP == IdentityServer4.IdentityServerConstants.LocalIdentityProvider;
// this is meant to short circuit the UI and only trigger the one external IdP
var vm = new LoginViewModel
{
EnableLocalLogin = local,
ReturnUrl = returnUrl,
Username = context?.LoginHint,
};
if (!local)
{
vm.ExternalProviders = new[] { new ExternalProvider {
AuthenticationScheme = context.IdP
} };
}
return(vm);
}
var schemes = await SchemeProvider.GetAllSchemesAsync();
var providers = schemes
.Where(x => x.DisplayName != null ||
(x.Name.Equals(AccountOptions.WindowsAuthenticationSchemeName, StringComparison.OrdinalIgnoreCase))
)
.Select(x => new ExternalProvider
{
DisplayName = x.DisplayName,
AuthenticationScheme = x.Name
}).ToList();
var allowLocal = true;
if (context?.ClientId != null)
{
var client = await ClientStore.FindEnabledClientByIdAsync(context.ClientId);
if (client != null)
{
allowLocal = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
}
}
}
return(new LoginViewModel
{
AllowRememberLogin = AccountOptions.AllowRememberLogin,
EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
ReturnUrl = returnUrl,
Username = context?.LoginHint,
ExternalProviders = providers.ToArray()
});
}
public override async Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
var context = await Interaction.GetAuthorizationContextAsync(ReturnUrl);
if (context != null)
{
LoginInput.UserNameOrEmailAddress = context.LoginHint;
//TODO: Reference AspNetCore MultiTenancy module and use options to get the tenant key!
var tenant = context.Parameters[TenantResolverConsts.DefaultTenantKey];
if (!string.IsNullOrEmpty(tenant))
{
CurrentTenant.Change(Guid.Parse(tenant));
Response.Cookies.Append(TenantResolverConsts.DefaultTenantKey, tenant);
}
}
if (context?.IdP != null)
{
LoginInput.UserNameOrEmailAddress = context.LoginHint;
ExternalProviders = new[] { new ExternalProviderModel {
AuthenticationScheme = context.IdP
} };
return(Page());
}
var schemes = await SchemeProvider.GetAllSchemesAsync();
var providers = schemes
.Where(x => x.DisplayName != null || x.Name.Equals(AccountOptions.WindowsAuthenticationSchemeName, StringComparison.OrdinalIgnoreCase))
.Select(x => new ExternalProviderModel
{
DisplayName = x.DisplayName,
AuthenticationScheme = x.Name
})
.ToList();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
if (context?.ClientId != null)
{
var client = await ClientStore.FindEnabledClientByIdAsync(context.ClientId);
if (client != null)
{
EnableLocalLogin = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
}
}
}
ExternalProviders = providers.ToArray();
if (IsExternalLoginOnly)
{
return(await base.OnPostExternalLogin(providers.First().AuthenticationScheme));
}
return(Page());
}