public IActionResult AddClient(ClientViewModel clientViewModel) { if (!ModelState.IsValid) { return(View()); } var apiScopes = clientViewModel.ApiScopes.Split(" ").Select(apiScope => apiScope.Trim()).ToArray(); var client = new ClientModel { ClientId = clientViewModel.ClientId, ClientName = clientViewModel.ClientName, AllowedGrantTypes = GrantTypes.Implicit, AllowAccessTokensViaBrowser = clientViewModel.AllowAccessTokensViaBrowser, RequireConsent = false, RedirectUris = { clientViewModel.RedirectUri }, PostLogoutRedirectUris = { clientViewModel.PostLogoutRedirectUri }, AllowedCorsOrigins = { clientViewModel.CorsOrigin }, AllowedScopes = apiScopes }; _configurationDbContext.Clients.Add(client.ToEntity()); _configurationDbContext.SaveChanges(); _trackTelemetry.TrackEvent(EventName.AddClient, EventType.Action, EventStatus.Success); return(RedirectToAction(nameof(Index))); }
private static IdentityServer4.Models.Client CreateWpfClient() { var client = new IdentityServer4.Models.Client { ClientId = "Boardgames.WpfClient", ClientName = "Wpf Client for boardgames", RedirectUris = { "http://127.0.0.1:8080/boardgames/" }, //PostLogoutRedirectUris = { "https://notused" }, RequireClientSecret = false, AllowedGrantTypes = GrantTypes.Code, AllowAccessTokensViaBrowser = true, RequirePkce = true, AllowedScopes = { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile, IdentityServerConstants.StandardScopes.OfflineAccess, "Boardgames.WebServerAPI" }, AllowOfflineAccess = true, //Access token life time is 7200 seconds (2 hour) AccessTokenLifetime = 7200, //Identity token life time is 7200 seconds (2 hour) IdentityTokenLifetime = 7200, RefreshTokenUsage = TokenUsage.ReUse, }; return(client); }
private IdentityServer4.Models.Client CreateNewClient(SystemViewModel systemViewModel) { var client = new IdentityServer4.Models.Client { ClientId = Guid.NewGuid().ToString(), ClientName = systemViewModel.SystemName, AllowedGrantTypes = GrantTypes.Hybrid, ClientUri = systemViewModel.ClientUri, Description = systemViewModel.Description, ClientSecrets = { new IdentityServer4.Models.Secret("secret".Sha256()) }, RedirectUris = { systemViewModel.ClientUri + "/signin-oidc" }, PostLogoutRedirectUris = { systemViewModel.ClientUri + "/signout-callback-oidc" }, AllowedScopes = { IdentityServer4.IdentityServerConstants.StandardScopes.OpenId, IdentityServer4.IdentityServerConstants.StandardScopes.Profile, "api1", "access.profile", "role", "token" }, AllowOfflineAccess = true, AllowAccessTokensViaBrowser = true }; return(client); }
public async Task <ActionResult <ResponseModel> > Create(ClientInputModel inputModel) { ResponseModel responseModel = new ResponseModel(); try { // TODO: 效验 #region 效验 // 1.授权类型只能来自选项 // eg: 若选项是两项: CodeAndClientCredentials => authorization_code,client_credentials string selectedGrantTypes = inputModel.AllowedGrantTypes; if (!AllGrantTypes.Contains(selectedGrantTypes)) { responseModel.code = -1; responseModel.message = "创建失败: 不存在此授权类型"; return(await Task.FromResult(responseModel)); } #endregion // InputModel => IdentityServer4.Models IdentityServer4.Models.Client clientModel = new IdentityServer4.Models.Client() { ClientId = inputModel.ClientId, ClientName = inputModel.DisplayName, AllowedGrantTypes = inputModel.AllowedGrantTypes?.Split(","), AllowedScopes = inputModel.AllowedScopes?.Split(","), Description = inputModel.Description, AllowedCorsOrigins = inputModel.AllowedCorsOrigins?.Split(","), ClientSecrets = new List <Secret>() { new Secret(inputModel.ClientSecret.Sha256()) }, PostLogoutRedirectUris = inputModel.PostLogoutRedirectUris?.Split(","), RedirectUris = inputModel.RedirectUris?.Split(","), RequireConsent = inputModel.RequireConsent, AllowAccessTokensViaBrowser = inputModel.AllowAccessTokensViaBrowser, AlwaysIncludeUserClaimsInIdToken = inputModel.AlwaysIncludeUserClaimsInIdToken, AllowOfflineAccess = inputModel.AllowOfflineAccess }; // 保存到数据库 var dbModel = clientModel.ToEntity(); // TODO: 注意: 1.发现使用 DateTime.UtcNow 时间不正确,不知道为什么,明明推荐用这个统一时间 2.就算不手动赋值, 最后也会有创建时间, 更新时间, 而内部用的就是UtcNow dbModel.Created = DateTime.Now; await _configurationDbContext.Clients.AddAsync(dbModel); await _configurationDbContext.SaveChangesAsync(); responseModel.code = 1; responseModel.message = "创建成功 "; } catch (Exception ex) { responseModel.code = -1; responseModel.message = "创建失败: " + ex.Message; } return(await Task.FromResult(responseModel)); }
public static IdentityServer4.Models.Client ViewModelToClient(ClientViewModel clientViewModel) { IdentityServer4.Models.Client Client = new IdentityServer4.Models.Client { ClientId = clientViewModel.Name, ClientName = clientViewModel.Name, AllowedScopes = clientViewModel.Scopes, AlwaysIncludeUserClaimsInIdToken = clientViewModel.IsIncludeIDToken, AllowOfflineAccess = clientViewModel.IsIncludeRefreshToken }; if (clientViewModel.IsPublicClient) { Client.RequireClientSecret = false; } else { Client.ClientSecrets = new[] { new Secret(clientViewModel.Secret.Sha256()) }; } if (!string.IsNullOrEmpty(clientViewModel.PostLogoutRedirectUri) & !string.IsNullOrEmpty(clientViewModel.RedirectUri)) { Client.RedirectUris = new[] { clientViewModel.RedirectUri }; Client.PostLogoutRedirectUris = new[] { clientViewModel.PostLogoutRedirectUri }; } Client.AllowedGrantTypes = Helper.GetGrantType(clientViewModel.GrantType); return(Client); }
private ConsentViewModel CreateConsentViewModel( ConsentInputModel model, string returnUrl, AuthorizationRequest request, IdentityServer4.Models.Client client, Resources resources) { var vm = new ConsentViewModel { RememberConsent = model?.RememberConsent ?? true, ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>(), ReturnUrl = returnUrl, ClientName = client.ClientName ?? client.ClientId, 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( IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null) }); } return(vm); }
public IActionResult CreateClientApps([FromBody] JObject jObject) { try { var applicationName = (string)jObject["applicationName"]; var applicationSecret = (string)jObject["applicationSecret"]; var client = new IdentityServer4.Models.Client { ClientId = Guid.NewGuid().ToString(), ClientSecrets = { new IdentityServer4.Models.Secret(applicationSecret.Sha256()) }, ClientName = applicationName, AllowedGrantTypes = GrantTypes.ClientCredentials, AllowedScopes = { "scim.read.write" }, AccessTokenLifetime = 600 }; _configurationDbContext.Clients.Add(client.ToEntity()); _configurationDbContext.SaveChanges(); return(Ok(client)); } catch (Exception exception) { var errorJobject = CommonFunctions.CreateErrorJobject(exception); Response.Headers.Add("Content-Type", "application/scim+json"); return(StatusCode(StatusCodes.Status500InternalServerError, errorJobject)); } }
private void InitializeIdentityServerDatabase(IApplicationBuilder app) { using (var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope()) { serviceScope.ServiceProvider.GetRequiredService <PersistedGrantDbContext>().Database.Migrate(); var context = serviceScope.ServiceProvider.GetRequiredService <ConfigurationDbContext>(); context.Database.Migrate(); if (!context.Clients.Any()) { var client1 = new IdentityServer4.Models.Client { ClientId = "demo.client1", AllowedGrantTypes = GrantTypes.ClientCredentials, ClientSecrets = { new IdentityServer4.Models.Secret("secret".Sha256()) }, AllowedScopes = { "demo.api1" }, ClientName = "Demo Client1" }; context.Clients.Add(client1.ToEntity()); context.SaveChanges(); } if (!context.ApiResources.Any()) { var api1 = new IdentityServer4.Models.ApiResource { Name = "demo.api1", DisplayName = "demo api", Description = "this is just for demo" }; context.ApiResources.Add(api1.ToEntity()); context.SaveChanges(); } } }
public void Configure(IdentityServer4.Models.Client client) { IClientConfigurationStrategy strategy = null; if (_clientType.Id == ClientType.WebImplicit.Id) { strategy = new WebImplicitClientConfigurationStrategy(); } else if (_clientType.Id == ClientType.WebHybrid.Id) { strategy = new WebHybridClientConfigurationStrategy(); } else if (_clientType.Id == ClientType.Device.Id) { strategy = new DeviceClientConfigurationStrategy(); } else if (_clientType.Id == ClientType.Spa.Id) { strategy = new SpaClientConfigurationStrategy(); } else if (_clientType.Id == ClientType.Native.Id) { strategy = new NativeClientConfigurationStrategy(); } else if (_clientType.Id == ClientType.Machine.Id) { strategy = new MachineClientConfigurationStrategy(); } else { // empty } strategy?.Configure(client); }
public IActionResult AddTestClient(TestClientViewModel clientViewModel) { if (!ModelState.IsValid) { return(View()); } var apiScopes = clientViewModel.ApiScopes.Split(" ").Select(apiScope => apiScope.Trim()).ToArray(); var client = new ClientModel { ClientId = clientViewModel.ClientId, ClientName = clientViewModel.ClientName, AllowedGrantTypes = GrantTypes.ResourceOwnerPasswordAndClientCredentials, ClientSecrets = { new SecretModel(clientViewModel.ClientSecret.Sha256()) }, AllowedScopes = apiScopes }; _configurationDbContext.Clients.Add(client.ToEntity()); _configurationDbContext.SaveChanges(); _trackTelemetry.TrackEvent(EventName.AddTestClient, EventType.Action, EventStatus.Success); return(RedirectToAction(nameof(Index))); }
public async Task <Scope> RollupAsync( Neo4jIdentityServer4ApiResource apiResource, Neo4jIdentityServer4ApiScope apiScope, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); apiResource.ThrowIfNull(nameof(apiResource)); apiScope.ThrowIfNull(nameof(apiScope)); await RaiseApiScopeChangeEventAsync(apiResource, apiScope); var finalResult = new Client(); var apiScopeFound = await GetApiScopeAsync(apiResource, apiScope, cancellationToken); var model = apiScopeFound.ToModel(); var apiScopeClaims = await GetApiScopeClaimsAsync(apiResource, apiScopeFound, cancellationToken); if (apiScopeClaims != null) { foreach (var item in apiScopeClaims) { model.UserClaims.Add(item.Type); } } var rollup = new ApiScopeRollup() { ApiScopeJson = JsonConvert.SerializeObject(model), }; var result = await AddRollupAsync(apiResource, apiScopeFound, rollup, cancellationToken); return(model); }
public void TestClientConversion() { var is4Client = new IS4.Client(); var client = is4Client.ToClientViewModel(); // Secret should never be automatically copied to view model. Assert.Null(client.ClientSecret); }
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 Task Create(IdentityServer4.Models.Client client) { if (client == null) { throw new ArgumentNullException(nameof(client)); } State.Client = client.ToEntity(); return(WriteStateAsync()); }
public void UpdatePostLogoutRedirectUris( IdentityServer4.EntityFramework.Entities.Client client, List <string> postLogoutRedirectUris) { IdentityServer4.Models.Client clientModel = new IdentityServer4.Models.Client(); clientModel.PostLogoutRedirectUris = postLogoutRedirectUris; client.PostLogoutRedirectUris = clientModel.ToEntity().PostLogoutRedirectUris; }
public static Client ToClientViewModel(this IS4.Client client) { if (client == null) { return(null); } var newClient = new Client { // Basic Enabled = client.Enabled, ClientId = client.ClientId, RequireClientSecret = client.RequireClientSecret, AllowedGrantTypes = client.AllowedGrantTypes, RequirePkce = client.RequirePkce, AllowPlainTextPkce = client.AllowPlainTextPkce, RedirectUris = client.RedirectUris, AllowedScopes = client.AllowedScopes, AllowOfflineAccess = client.AllowOfflineAccess, AllowAccessTokensViaBrowser = client.AllowAccessTokensViaBrowser, ProtocolType = client.ProtocolType, // Authentication / Logout PostLogoutRedirectUris = client.PostLogoutRedirectUris, EnableLocalLogin = client.EnableLocalLogin, IdentityProviderRestrictions = client.IdentityProviderRestrictions, LogoutUri = client.LogoutUri, LogoutSessionRequired = client.LogoutSessionRequired, // Token IdentityTokenLifetime = client.IdentityTokenLifetime, AccessTokenLifetime = client.AccessTokenLifetime, AuthorizationCodeLifetime = client.AuthorizationCodeLifetime, AbsoluteRefreshTokenLifetime = client.AbsoluteRefreshTokenLifetime, SlidingRefreshTokenLifetime = client.SlidingRefreshTokenLifetime, RefreshTokenUsage = client.RefreshTokenUsage, RefreshTokenExpiration = client.RefreshTokenExpiration, UpdateAccessTokenClaimsOnRefresh = client.UpdateAccessTokenClaimsOnRefresh, AccessTokenType = client.AccessTokenType, IncludeJwtId = client.IncludeJwtId, AllowedCorsOrigins = client.AllowedCorsOrigins, Claims = client.Claims, AlwaysSendClientClaims = client.AlwaysSendClientClaims, AlwaysIncludeUserClaimsInIdToken = client.AlwaysIncludeUserClaimsInIdToken, PrefixClientClaims = client.PrefixClientClaims, // Consent RequireConsent = client.RequireConsent, AllowRememberConsent = client.AllowRememberConsent, ClientName = client.ClientName, ClientUri = client.ClientUri, LogoUri = client.LogoUri }; return(newClient); }
public void UpdateRedirectUris( IdentityServer4.EntityFramework.Entities.Client client, List <string> redirectUris ) { IdentityServer4.Models.Client clientModel = new IdentityServer4.Models.Client(); clientModel.RedirectUris = redirectUris; client.RedirectUris = clientModel.ToEntity().RedirectUris; }
public void UpdateAllowedScopes( IdentityServer4.EntityFramework.Entities.Client client, List <string> allowedScopes ) { IdentityServer4.Models.Client clientModel = new IdentityServer4.Models.Client(); clientModel.AllowedScopes = allowedScopes; client.AllowedScopes = clientModel.ToEntity().AllowedScopes; }
public async Task <Client> FindClientByIdAsync(string clientId) { Model.Client model = null; Entities.Client entity = await StorageContext.GetEntityBlobAsync <Entities.Client>(clientId, StorageContext.ClientBlobContainer); model = entity?.ToModel(); _logger.LogDebug("{clientName} found in blob storage: {clientFound}", clientId, model != null); return(model); }
static IntegrationTestsFixture() { var api = GetTestApiResource(); Client = GetTestClient(); InMemoryDocumentDbService.AddDocument(api.Name, api); InMemoryDocumentDbService.AddDocument(Client.ClientId, Client); CreateSqlServerDatabase(); AddTestEntitiesToSql(Client, api); }
private static void AddTestEntitiesToSql(IS4.Client client, IS4.ApiResource apiResource) { using (var identityContext = IdentityDbContext) { identityContext.Database.ExecuteSqlCommand(DeleteDataSql); identityContext.ApiResources.Add(apiResource.ToEntity()); identityContext.Clients.Add(client.ToEntity()); identityContext.SaveChanges(); } }
public IActionResult CreateClient(CreateClientModel model, [FromServices] ConfigurationDbContext configContext) { // Generate a unique client ID var clientId = StringHelper.RandomString(20, "abcdefghjkmnpqrstuvwxyz1234567890"); while (configContext.Clients.Where(c => c.ClientId == clientId).FirstOrDefault() != null) { clientId = StringHelper.RandomString(20, "abcdefghjkmnpqrstuvwxyz1234567890"); } var clientSecret = StringHelper.RandomString(40, "abcdefghjkmnpqrstuvwxyz1234567890"); // Generate the origin for the callback Uri redirect = new Uri(model.CallbackUrl); string origin = redirect.Scheme + "://" + redirect.Host; var client = new IdentityServer4.Models.Client { Properties = new Dictionary <string, string>() { { "username", model.Username } }, ClientId = clientId, ClientName = model.Name, ClientUri = model.HomepageUrl, LogoUri = model.LogoUrl, AllowedGrantTypes = model.AllowedGrants, AllowedScopes = model.AllowedScopes, ClientSecrets = { new IdentityServer4.Models.Secret(clientSecret.Sha256()) }, RedirectUris = { model.CallbackUrl }, AllowedCorsOrigins = { origin }, RequireConsent = true, AllowOfflineAccess = true }; configContext.Clients.Add(client.ToEntity()); configContext.SaveChanges(); return(new JsonResult(new { success = true, data = new { id = clientId, secret = clientSecret } })); }
public CreateClientCommand(string clientId, string clientName, string clientUri, string description, string logoUri, ClientType clientType) { Client = new IdentityServer4.Models.Client { ClientId = clientId, ClientName = clientName, ClientUri = clientUri, LogoUri = logoUri, Description = description }; ClientType = clientType; }
public async Task <IActionResult> Post([FromBody] IroncladClient model) { if (string.IsNullOrEmpty(model.Id)) { return(this.BadRequest(new { Message = $"Cannot create a client without a client ID" })); } var accessTokenType = default(AccessTokenType); if (model.AccessTokenType != null && !Enum.TryParse(model.AccessTokenType, out accessTokenType)) { return(this.BadRequest(new { Message = $"Access token type '{model.AccessTokenType}' does not exist" })); } var client = new IdentityServerClient { ClientId = model.Id }; // optional properties client.ClientName = model.Name ?? client.ClientName; client.ClientSecrets = model.Secret == null ? client.ClientSecrets : new HashSet <Secret> { new Secret(model.Secret.Sha256()) }; client.AllowedCorsOrigins = model.AllowedCorsOrigins ?? client.AllowedCorsOrigins; client.RedirectUris = model.RedirectUris ?? client.RedirectUris; client.PostLogoutRedirectUris = model.PostLogoutRedirectUris ?? client.PostLogoutRedirectUris; client.AllowedScopes = model.AllowedScopes ?? client.AllowedScopes; client.AccessTokenType = model.AccessTokenType == null ? client.AccessTokenType : accessTokenType; client.AllowedGrantTypes = model.AllowedGrantTypes ?? client.AllowedGrantTypes; client.AllowAccessTokensViaBrowser = model.AllowAccessTokensViaBrowser ?? client.AllowAccessTokensViaBrowser; client.AllowOfflineAccess = model.AllowOfflineAccess ?? client.AllowOfflineAccess; client.RequireClientSecret = model.RequireClientSecret ?? client.RequireClientSecret; client.RequirePkce = model.RequirePkce ?? client.RequirePkce; client.RequireConsent = model.RequireConsent ?? client.RequireConsent; client.Enabled = model.Enabled ?? client.Enabled; using (var session = this.store.LightweightSession()) { if (session.Query <PostgresClient>().Any(document => document.ClientId == client.ClientId)) { return(this.StatusCode((int)HttpStatusCode.Conflict, new { Message = "Client already exists" })); } session.Insert(client.ToEntity()); await session.SaveChangesAsync(); } return(this.Created(new Uri(this.HttpContext.GetIdentityServerRelativeUrl("~/api/clients/" + model.Id)), null)); }
public async void ShouldAddAndSaveTheClientInTheContext() { var client = new Models.Client(); var context = A.Fake <IConfigurationDbContext>(); var clientRepository = new ClientRepository(context); await clientRepository.AddAsync(client); A.CallTo(() => context.SaveChangesAsync()) .MustHaveHappened(); A.CallTo(() => context.Clients.AddAsync( A <Entities.Client> .Ignored, A <CancellationToken> .Ignored)) .MustHaveHappened(); }
public async Task <JsonResult> GetList(IdentityServer4.Models.Client dto) { JsonResponse json = new JsonResponse(); var query = _context.Clients.AsQueryable(); if (!string.IsNullOrEmpty(dto.ClientId)) { query = query.Where(m => m.ClientId == dto.ClientId); } var list = await query.ToListAsync(); json.status = 0; json.total = list.Count(); json.data = list; return(Json(json)); }
public async Task <bool> AddClient(IdentityServer4.Models.Client client) { bool Result = false; try { await Context.Clients.AddAsync(client.ToEntity()); Result = await Context.SaveChangesAsync() > 0; } catch (Exception E) { var Message = E.Message; } return(Result); }
public void UpdateSecrets( IdentityServer4.EntityFramework.Entities.Client client, List <string> clientSecrets ) { List <IdentityServer4.Models.Secret> SecretModels = new List <IdentityServer4.Models.Secret>(); clientSecrets.ForEach(e => { SecretModels.Add(new IdentityServer4.Models.Secret(e.Sha256())); }); IdentityServer4.Models.Client clientModel = new IdentityServer4.Models.Client(); clientModel.ClientSecrets = SecretModels; client.ClientSecrets = clientModel.ToEntity().ClientSecrets; }
private IdentityServer4.EntityFramework.Entities.Client MapBllToDal(SharedModels.Client client) { IdentityServer4.Models.Client clientModelIds4 = new IdentityServer4.Models.Client(); clientModelIds4.ClientName = client.ClientName; clientModelIds4.ClientUri = client.ClientUri; clientModelIds4.ClientId = client.ClientId; clientModelIds4.FrontChannelLogoutUri = client.FrontChannelLogoutUrl; if (client.ClientSecret != null) { IdentityServer4.Models.Secret secret = new IdentityServer4.Models.Secret(client.ClientSecret.Sha256()); secret.Type = "SharedSecret"; clientModelIds4.ClientSecrets = new List <IdentityServer4.Models.Secret>(); clientModelIds4.ClientSecrets.Add(secret); } clientModelIds4.AllowedGrantTypes = new List <string>(); client.GrantType = client.GrantType.Replace(" ", "_"); clientModelIds4.AllowedGrantTypes.Add(client.GrantType); if (client.ClientProperty != null) { string key = "ApplicationType"; clientModelIds4.Properties = new Dictionary <string, string>(); clientModelIds4.Properties.Add(key, client.ClientProperty); } clientModelIds4.AllowedScopes = new List <string>(); foreach (string scope in client.AllowedScopes) { var replacedScope = scope.Replace(" ", "_"); clientModelIds4.AllowedScopes.Add(replacedScope); } clientModelIds4.RedirectUris = new List <string>(); foreach (string redirctUri in client.RedirectUrls) { clientModelIds4.RedirectUris.Add(redirctUri); } clientModelIds4.PostLogoutRedirectUris = new List <string>(); clientModelIds4.PostLogoutRedirectUris.Add(client.PostLogoutUrl); return(clientModelIds4.ToEntity()); }
public Task <Client> FindClientByIdAsync(string clientId) { var c = uow.Clients.Find(cl => cl.ClientId == clientId).FirstOrDefault(); // preparing the secrets List <Secret> secrets = new List <Secret>(); List <DomainModel.ClientSecret> cs = uow.Clients.GetSecrets(clientId).ToList(); foreach (var s in cs) { secrets.Add(new Secret() { Description = s.Description, Expiration = s.Expiration, Type = s.Type, Value = s.Value }); } // prepapring the allowed grant types List <string> grantTypes = uow.Clients.GetGrantTypes(clientId).Select(x => x.GrantType).ToList(); // preparing scopes List <string> scopes = uow.Clients.GetScopes(clientId).Select(x => x.Scope).ToList(); //prepare cors origins List <string> cors = uow.Clients.GetCorsOrigins(clientId).Select(x => x.Origin).ToList(); IdentityServer4.Models.Client C = new IdentityServer4.Models.Client() { ClientId = c.ClientId, AllowOfflineAccess = c.AllowOfflineAccess, AccessTokenLifetime = c.AccessTokenLifeTime, AllowedGrantTypes = grantTypes, AccessTokenType = c.AccessTokenIsReference? AccessTokenType.Reference : AccessTokenType.Jwt, ClientSecrets = secrets, AllowedScopes = scopes, AllowedCorsOrigins = cors, RefreshTokenExpiration = 0, SlidingRefreshTokenLifetime = c.SlidingRefreshTokenLifetime, Enabled = c.Enabled }; return(Task.FromResult(C)); }