private async Task <Client> CreateNewClient(string clientId, string clientName, GrantTypesEnum grantTypesEnum, List <string> redirectUris, List <string> postLogoutRedirectUris, List <string> allowedScopes, List <string> clientSecrets, bool allowOfflineAccess)
{
var newClient = new Client
{
ClientId = clientId,
ClientName = clientName,
ClientSecrets = GetClientSecrets(clientSecrets),
AllowedGrantTypes = GetGrantType(grantTypesEnum),
RedirectUris = redirectUris,
PostLogoutRedirectUris = postLogoutRedirectUris,
AllowedScopes = allowedScopes,
AllowOfflineAccess = allowOfflineAccess
};
_configurationContext.Clients.Add(newClient.ToEntity());
try
{
await _configurationContext.SaveChangesAsync();
return(newClient);
}
catch (Exception)
{
return(null);
}
}
public async Task <bool> CreateAccessControlAsync(AccessControl model)
{
await Context.AccessControls.AddAsync(model.ToEntity());
var result = await Context.SaveChangesAsync();
return(result > 0);
}
public async Task <bool> CreateServiceAsync(Service model)
{
await Context.Services.AddAsync(model.ToEntity());
var result = await Context.SaveChangesAsync();
return(result > 0);
}
public async Task CreateIdentityResource(string siteId, IdentityResource identityResource, CancellationToken cancellationToken = default(CancellationToken))
{
var ent = identityResource.ToEntity();
ent.SiteId = siteId;
context.IdentityResources.Add(ent);
await context.SaveChangesAsync();
}
public async Task <bool> CreateTenantAsync(Tenant model)
{
await Context.Tenants.AddAsync(model.ToEntity());
var result = await Context.SaveChangesAsync();
return(result > 0);
}
public async Task CreateScope(string siteId, Scope scope, CancellationToken cancellationToken = default(CancellationToken))
{
var ent = scope.ToEntity();
ent.SiteId = siteId;
context.Scopes.Add(ent);
await context.SaveChangesAsync();
}
public async Task <IActionResult> Create([FromBody] CreateClientRequest request)
{
var clientId = (request.UserId + "client_id_" + request.ApplicationName).Sha256();
int i = 0;
Console.WriteLine("clientId = " + clientId);
while (true)
{
Console.WriteLine("IndexOf + = " + (clientId.IndexOf('+') >= 0).ToString());
if (clientId.IndexOf('+') >= 0)
{
clientId = (request.UserId + "client_id_" + request.ApplicationName + "_" + i).Sha256();
Console.WriteLine("clientId = " + clientId);
i++;
}
else
{
break;
}
}
var clientSecret = ("client_secret_" + request.ApplicationName).Sha256();
request.RedirectUris.Add("http://localhost:7030/Auth/AuthorizationGrantCode");
IdentityServer4.Models.Client client = new IdentityServer4.Models.Client
{
ClientName = request.ApplicationName,
ClientId = clientId,
ClientSecrets =
{
new IdentityServer4.Models.Secret(clientSecret.Sha256())
},
AllowedGrantTypes = { GrantType.AuthorizationCode, GrantType.ClientCredentials },
RedirectUris = request.RedirectUris,
AllowedScopes = request.Scopes,
RequireConsent = true,
AlwaysSendClientClaims = true
};
var entry = await _configurationDbContext.Clients.AddAsync(client.ToEntity());
if (await _configurationDbContext.SaveChangesAsync() > 0)
{
List <string> scopes = new List <string>();
foreach (var item in entry.Entity.AllowedScopes)
{
scopes.Add(item.Scope);
}
var response = new CreateClientResponse
{
ClientId = entry.Entity.ClientId,
ClientSecret = clientSecret,
RedirectUris = entry.Entity.RedirectUris.Select(x => x.RedirectUri).ToList(),
ApplicationName = request.ApplicationName,
Scopes = entry.Entity.AllowedScopes.Select(x => x.Scope).Join(",")
};
return(await Task.FromResult(Ok(response)));
}
return(BadRequest());
}
public async Task <Client> AddAsync(Client client)
{
var clientEntity = client.ToEntity();
var entityEntry = await context.Clients.AddAsync(clientEntity);
await context.SaveChangesAsync();
return(entityEntry.Entity.ToModel());
}
public async Task CreateClient(string siteId, Client client, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var ent = client.ToEntity();
ent.SiteId = siteId;
context.Clients.Add(ent);
await context.SaveChangesAsync().ConfigureAwait(false);
}
public async Task CreateApiResource(string siteId, ApiResource apiResource, CancellationToken cancellationToken = default(CancellationToken))
{
var ent = apiResource.ToEntity();
ent.SiteId = siteId;
foreach (var s in ent.Scopes)
{
s.SiteId = siteId;
}
context.ApiResources.Add(ent);
await context.SaveChangesAsync();
}
private static async Task EnsureSeedData(IConfigurationDbContext context)
{
Console.WriteLine("Seeding database...");
if (!await context.Clients.AnyAsync())
{
Console.WriteLine("Clients being populated");
foreach (var client in Config.GetClients().ToList())
{
await context.Clients.AddAsync(client.ToEntity());
}
await context.SaveChangesAsync();
}
else
{
Console.WriteLine("Clients already populated");
}
if (!await context.IdentityResources.AnyAsync())
{
Console.WriteLine("IdentityResources being populated");
foreach (var resource in Config.GetIdentityResources().ToList())
{
await context.IdentityResources.AddAsync(resource.ToEntity());
}
await context.SaveChangesAsync();
}
else
{
Console.WriteLine("IdentityResources already populated");
}
if (!await context.ApiResources.AnyAsync())
{
Console.WriteLine("ApiResources being populated");
foreach (var resource in Config.GetApiResources().ToList())
{
await context.ApiResources.AddAsync(resource.ToEntity());
}
await context.SaveChangesAsync();
}
else
{
Console.WriteLine("ApiResources already populated");
}
Console.WriteLine("Done seeding database.");
Console.WriteLine();
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(Page());
}
var tool = await _context.Tools.FindAsync(id);
if (tool != null)
{
var client = await _identityContext.Clients.FindAsync(tool.IdentityServerClientId);
if (client != null)
{
_identityContext.Clients.Remove(client);
await _identityContext.SaveChangesAsync();
}
_context.Tools.Remove(tool);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync()
{
if (ApiResource.Id <= 0)
{
return(Page());
}
var apiResource = await _context.ApiResources.FindAsync(ApiResource.Id).ConfigureAwait(false);
if (apiResource == null)
{
return(Page());
}
apiResource.Name = ApiResource.Name;
apiResource.DisplayName = ApiResource.DisplayName;
apiResource.Description = apiResource.Description;
apiResource.Enabled = ApiResource.Enabled;
apiResource.LastAccessed = ApiResource.LastAccessed;
apiResource.NonEditable = ApiResource.NonEditable;
apiResource.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Index", new { ApiResource.Id }));
}
public async Task <IActionResult> Add(JavaScriptClientInputModel model)
{
if (ModelState.IsValid)
{
var client = new Client
{
ClientId = model.ClientId,
ClientName = model.ClientName,
AllowedGrantTypes = GrantTypes.Code,
RequirePkce = true,
RequireClientSecret = false,
RedirectUris = { model.RedirectUri },
PostLogoutRedirectUris = { model.PostLogoutRedirectUri },
AllowedCorsOrigins = { model.AllowedCorsOrigin },
AllowedScopes = model.AllowedScopes.Split(','),
RequireConsent = model.RequiredConsent
};
await configurationService.Clients.AddAsync(client.ToEntity());
await configurationService.SaveChangesAsync();
return(View("Success"));
}
return(View());
}
internal async Task <Client> CreateImplicitClientAsync(IConfigurationDbContext _configurationContext)
{
var newClient = new Client
{
ClientId = ClientId,
ClientName = ClientName,
AllowedGrantTypes = GrantTypes.Implicit,
RedirectUris = RedirectUris.Select(a => a.Trim()).ToList(),
PostLogoutRedirectUris = PostLogoutRedirectUris.Select(a => a.Trim()).ToList(),
AllowedScopes = AllowedScopes
};
try
{
_configurationContext.Clients.Add(newClient.ToEntity());
await _configurationContext.SaveChangesAsync();
return(newClient);
}
catch (Exception)
{
return(null);
}
}
public async Task <Client> UpdateClientAsync(IConfigurationDbContext _configurationContext)
{
var updateClient = await _configurationContext.Clients.Include(a => a.AllowedScopes).Include(a => a.RedirectUris).Include(a => a.PostLogoutRedirectUris).Include(a => a.AllowedGrantTypes).Where(a => a.Id == id).FirstOrDefaultAsync();
var newClientModel = new Client
{
ClientName = ClientName,
RedirectUris = RedirectUris.Select(a => a.Trim()).ToList(),
PostLogoutRedirectUris = PostLogoutRedirectUris.Select(a => a.Trim()).ToList(),
AllowedScopes = AllowedScopes
}.ToEntity();
updateClient.ClientName = newClientModel.ClientName;
updateClient.RedirectUris.Clear();
updateClient.RedirectUris = newClientModel.RedirectUris;
updateClient.PostLogoutRedirectUris.Clear();
updateClient.PostLogoutRedirectUris = newClientModel.PostLogoutRedirectUris;
updateClient.AllowedScopes.Clear();
updateClient.AllowedScopes = newClientModel.AllowedScopes;
try
{
_configurationContext.Clients.Update(updateClient);
await _configurationContext.SaveChangesAsync();
return(updateClient.ToModel());
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> OnPostAsync()
{
if (IdentityResource.Id <= 0)
{
return(Page());
}
var identityResource = await _context.IdentityResources.FindAsync(IdentityResource.Id).ConfigureAwait(false);
if (identityResource == null)
{
return(Page());
}
identityResource.Name = IdentityResource.Name;
identityResource.DisplayName = IdentityResource.DisplayName;
identityResource.Description = identityResource.Description;
identityResource.Enabled = IdentityResource.Enabled;
identityResource.Emphasize = IdentityResource.Emphasize;
identityResource.Required = IdentityResource.Required;
identityResource.ShowInDiscoveryDocument = IdentityResource.ShowInDiscoveryDocument;
identityResource.NonEditable = IdentityResource.NonEditable;
identityResource.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Index", new { IdentityResource.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
ApiResource.Created = DateTime.UtcNow;
_context.ApiResources.Add(ApiResource);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("./Details/Index", new { ApiResource.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients.FindAsync(Client.Id).ConfigureAwait(false);
if (client == null)
{
return(Page());
}
client.AbsoluteRefreshTokenLifetime = Client.AbsoluteRefreshTokenLifetime;
client.AccessTokenLifetime = Client.AccessTokenLifetime;
client.AccessTokenType = Client.AccessTokenType;
client.AllowAccessTokensViaBrowser = Client.AllowAccessTokensViaBrowser;
client.AllowOfflineAccess = Client.AllowOfflineAccess;
client.AllowPlainTextPkce = Client.AllowPlainTextPkce;
client.AllowRememberConsent = Client.AllowRememberConsent;
client.AlwaysIncludeUserClaimsInIdToken = Client.AlwaysIncludeUserClaimsInIdToken;
client.AlwaysSendClientClaims = Client.AlwaysSendClientClaims;
client.AuthorizationCodeLifetime = Client.AuthorizationCodeLifetime;
client.BackChannelLogoutSessionRequired = Client.BackChannelLogoutSessionRequired;
client.BackChannelLogoutUri = Client.BackChannelLogoutUri;
client.ClientClaimsPrefix = Client.ClientClaimsPrefix;
client.ClientId = Client.ClientId;
client.ClientName = Client.ClientName;
client.ClientUri = Client.ClientUri;
client.ConsentLifetime = Client.ConsentLifetime;
client.Description = Client.Description;
client.DeviceCodeLifetime = Client.DeviceCodeLifetime;
client.EnableLocalLogin = Client.EnableLocalLogin;
client.Enabled = Client.Enabled;
client.FrontChannelLogoutSessionRequired = Client.FrontChannelLogoutSessionRequired;
client.FrontChannelLogoutUri = Client.FrontChannelLogoutUri;
client.IdentityTokenLifetime = Client.IdentityTokenLifetime;
client.IncludeJwtId = Client.IncludeJwtId;
client.LogoUri = Client.LogoUri;
client.NonEditable = Client.NonEditable;
client.PairWiseSubjectSalt = Client.PairWiseSubjectSalt;
client.ProtocolType = Client.ProtocolType;
client.RefreshTokenExpiration = Client.RefreshTokenExpiration;
client.RefreshTokenUsage = Client.RefreshTokenUsage;
client.RequireClientSecret = Client.RequireClientSecret;
client.RequireConsent = Client.RequireConsent;
client.RequirePkce = Client.RequirePkce;
client.SlidingRefreshTokenLifetime = Client.SlidingRefreshTokenLifetime;
client.UpdateAccessTokenClaimsOnRefresh = Client.UpdateAccessTokenClaimsOnRefresh;
client.Updated = DateTime.UtcNow;
client.UserCodeType = Client.UserCodeType;
client.UserSsoLifetime = Client.UserSsoLifetime;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Index", new { Client.Id }));
}
public async Task <IdentityResource> AddAsync(IdentityResource identityResource)
{
var identityResourceEntity = identityResource.ToEntity();
await context.IdentityResources.AddAsync(identityResourceEntity);
await context.SaveChangesAsync();
return(identityResourceEntity.ToModel());
}
public async Task <IActionResult> OnPostAsync()
{
if (ApiResource.Id <= 0)
{
return(Page());
}
var apiResource = await _context.ApiResources
.Include(x => x.Secrets)
.SingleOrDefaultAsync(x => x.Id == ApiResource.Id)
.ConfigureAwait(false);
if (apiResource == null)
{
return(Page());
}
if (ApiResource.Secrets != null)
{
foreach (var apiSecret in ApiResource.Secrets.Where(x => x.Id > 0))
{
var secret = apiResource.Secrets.Single(x => x.Id.Equals(apiSecret.Id));
secret.Type = apiSecret.Type;
secret.Value = apiSecret.Value;
secret.Description = apiSecret.Description;
secret.Expiration = apiSecret.Expiration;
}
apiResource.Secrets.AddRange(ApiResource.Secrets.Where(x => x.Id == 0).Select(x => new ApiSecret
{
Type = x.Type,
Value = x.Value,
Description = x.Description,
Expiration = x.Expiration,
Created = DateTime.UtcNow
}));
var secrets = apiResource.Secrets.Where(x => !ApiResource.Secrets.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var secret in secrets)
{
apiResource.Secrets.Remove(secret);
}
}
else
{
apiResource.Secrets = new List <ApiSecret>();
}
apiResource.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Secrets", new { ApiResource.Id }));
}
private async Task SeedClientsAsync()
{
if (_corsOptions?.Origins != null && _corsOptions.Origins.Any())
{
foreach (var origin in _corsOptions.Origins)
{
var client = new Client
{
ClientId = $"{Guid.NewGuid()}",
ClientName = "Angular Client",
AllowedGrantTypes = GrantTypes.Implicit,
AllowAccessTokensViaBrowser = true,
RedirectUris =
{
$"{origin}/account/login-success",
$"{origin}/silent-callback.html"
},
RequireConsent = false,
PostLogoutRedirectUris = { $"{origin}/logout-success" },
AllowedCorsOrigins = { origin },
AllowedScopes =
{
IdentityServerConstants.StandardScopes.OpenId,
IdentityServerConstants.StandardScopes.Profile,
IdentityServerConstants.StandardScopes.Email,
IdentityServerConstants.StandardScopes.Phone,
IdentityServerConstants.StandardScopes.Address,
"api1",
"api2.full_access",
"api2.read_only",
"roles"
}
};
_configurationDbContext.Clients.Add(client.ToEntity());
}
}
await _configurationDbContext.SaveChangesAsync();
}
public async Task <IActionResult> OnPostAsync()
{
if (ApiResource.Id <= 0)
{
return(Page());
}
var apiResource = await _context.ApiResources
.Include(x => x.Scopes)
.SingleOrDefaultAsync(x => x.Id == ApiResource.Id)
.ConfigureAwait(false);
if (apiResource == null)
{
return(Page());
}
if (ApiResource.Scopes != null)
{
foreach (var apiResourceScope in ApiResource.Scopes.Where(x => x.Id > 0))
{
var scope = apiResource.Scopes.Single(x => x.Id == apiResourceScope.Id);
scope.Name = apiResourceScope.Name;
scope.DisplayName = apiResourceScope.DisplayName;
scope.Description = apiResourceScope.Description;
scope.Emphasize = apiResourceScope.Emphasize;
scope.Required = apiResourceScope.Required;
scope.ShowInDiscoveryDocument = apiResourceScope.ShowInDiscoveryDocument;
}
apiResource.Scopes.AddRange(ApiResource.Scopes.Where(x => x.Id == 0));
var scopes = apiResource.Scopes.Where(x => !ApiResource.Scopes.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var scope in scopes)
{
apiResource.Scopes.Remove(scope);
}
}
else
{
apiResource.Scopes = new List <ApiScope>();
}
apiResource.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Scopes", new { ApiResource.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (ApiResource.Id <= 0)
{
return(Page());
}
var apiResource = await _context.ApiResources.FindAsync(ApiResource.Id).ConfigureAwait(false);
if (apiResource == null)
{
return(Page());
}
_context.ApiResources.Remove(apiResource);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients.FindAsync(Client.Id).ConfigureAwait(false);
if (client == null)
{
return(Page());
}
_context.Clients.Remove(client);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients
.Include(x => x.Properties)
.SingleOrDefaultAsync(x => x.Id.Equals(Client.Id))
.ConfigureAwait(false);
if (client == null)
{
return(Page());
}
if (Client.Properties != null)
{
foreach (var clientProperty in Client.Properties.Where(x => x.Id > 0))
{
var property = client.Properties.Single(x => x.Id.Equals(clientProperty.Id));
property.Key = clientProperty.Key;
property.Value = clientProperty.Value;
}
client.Properties.AddRange(Client.Properties.Where(x => x.Id == 0));
var properties = client.Properties.Where(x => !Client.Properties.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var property in properties)
{
client.Properties.Remove(property);
}
}
else
{
client.Properties = new List <ClientProperty>();
}
client.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Properties", new { Client.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients
.Include(x => x.Claims)
.SingleOrDefaultAsync(x => x.Id.Equals(Client.Id))
.ConfigureAwait(false);
if (client == null)
{
return(Page());
}
client.Updated = DateTime.UtcNow;
if (Client.Claims != null)
{
foreach (var clientClaim in Client.Claims.Where(x => x.Id > 0))
{
var claim = client.Claims.Single(x => x.Id.Equals(clientClaim.Id));
claim.Type = clientClaim.Type;
claim.Value = clientClaim.Value;
}
client.Claims.AddRange(Client.Claims.Where(x => x.Id == 0));
var claims = client.Claims.Where(x => !Client.Claims.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var claim in claims)
{
client.Claims.Remove(claim);
}
}
else
{
client.Claims = new List <ClientClaim>();
}
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/Claims", new { Client.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients
.Include(x => x.RedirectUris)
.SingleOrDefaultAsync(x => x.Id.Equals(Client.Id))
.ConfigureAwait(false);
if (client == null)
{
return(Page());
}
if (Client.RedirectUris != null)
{
foreach (var clientRedirectUri in Client.RedirectUris.Where(x => x.Id > 0))
{
var redirectUri = client.RedirectUris.Single(x => x.Id.Equals(clientRedirectUri.Id));
redirectUri.RedirectUri = clientRedirectUri.RedirectUri;
}
client.RedirectUris.AddRange(Client.RedirectUris.Where(x => x.Id == 0));
var redirectUris = client.RedirectUris.Where(x => !Client.RedirectUris.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var redirectUri in redirectUris)
{
client.RedirectUris.Remove(redirectUri);
}
}
else
{
client.RedirectUris = new List <ClientRedirectUri>();
}
client.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/RedirectUris", new { Client.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (ApiResource.Id <= 0)
{
return(Page());
}
var apiResource = await _context.ApiResources
.Include(x => x.UserClaims)
.SingleOrDefaultAsync(x => x.Id.Equals(ApiResource.Id))
.ConfigureAwait(false);
if (apiResource == null)
{
return(Page());
}
if (ApiResource.UserClaims != null)
{
foreach (var apiResourceClaimType in ApiResource.UserClaims.Where(x => x.Id > 0))
{
var claimType = apiResource.UserClaims.Single(x => x.Id.Equals(apiResourceClaimType.Id));
claimType.Type = apiResourceClaimType.Type;
}
apiResource.UserClaims.AddRange(ApiResource.UserClaims.Where(x => x.Id == 0));
var claimTypes = apiResource.UserClaims.Where(x => !ApiResource.UserClaims.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var claimType in claimTypes)
{
apiResource.UserClaims.Remove(claimType);
}
}
else
{
apiResource.UserClaims = new List <ApiResourceClaim>();
}
apiResource.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/ClaimTypes", new { ApiResource.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (Client.Id <= 0)
{
return(Page());
}
var client = await _context.Clients
.Include(x => x.IdentityProviderRestrictions)
.SingleOrDefaultAsync(x => x.Id.Equals(Client.Id))
.ConfigureAwait(false);
if (client == null)
{
return(Page());
}
if (Client.IdentityProviderRestrictions != null)
{
foreach (var clientIdPRestriction in Client.IdentityProviderRestrictions.Where(x => x.Id > 0))
{
var idPRestriction = client.IdentityProviderRestrictions.Single(x => x.Id.Equals(clientIdPRestriction.Id));
idPRestriction.Provider = clientIdPRestriction.Provider;
}
client.IdentityProviderRestrictions.AddRange(Client.IdentityProviderRestrictions.Where(x => x.Id == 0));
var idPRestrictions = client.IdentityProviderRestrictions.Where(x => !Client.IdentityProviderRestrictions.Any(y => y.Id.Equals(x.Id))).ToArray();
foreach (var idPRestriction in idPRestrictions)
{
client.IdentityProviderRestrictions.Remove(idPRestriction);
}
}
else
{
client.IdentityProviderRestrictions = new List <ClientIdPRestriction>();
}
client.Updated = DateTime.UtcNow;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(RedirectToPage("../Details/IdPRestrictions", new { Client.Id }));
}