public async Task GetAllResources_WhenAllResourcesRequested_ExpectAllResourcesIncludingHidden(DbContextOptions <ConfigurationDbContext> options) { var visibleIdentityResource = CreateIdentityTestResource(); var visibleApiResource = CreateApiResourceTestResource(); var visibleApiScope = CreateApiScopeTestResource(); var hiddenIdentityResource = new IdentityResource { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; var hiddenApiResource = new ApiResource { Name = Guid.NewGuid().ToString(), Scopes = { Guid.NewGuid().ToString() }, ShowInDiscoveryDocument = false }; var hiddenApiScope = new ApiScope { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; using (var context = new ConfigurationDbContext(options)) { context.IdentityResources.Add(visibleIdentityResource.ToEntity()); context.ApiResources.Add(visibleApiResource.ToEntity()); context.ApiScopes.Add(visibleApiScope.ToEntity()); context.IdentityResources.Add(hiddenIdentityResource.ToEntity()); context.ApiResources.Add(hiddenApiResource.ToEntity()); context.ApiScopes.Add(hiddenApiScope.ToEntity()); context.SaveChanges(); } Resources resources; using (var context = new ConfigurationDbContext(options)) { var store = new ResourceStore(context, FakeLogger <ResourceStore> .Create(), new NoneCancellationTokenProvider()); resources = await store.GetAllResourcesAsync(); } Assert.NotNull(resources); Assert.NotEmpty(resources.IdentityResources); Assert.NotEmpty(resources.ApiResources); Assert.NotEmpty(resources.ApiScopes); Assert.Contains(resources.IdentityResources, x => x.Name == visibleIdentityResource.Name); Assert.Contains(resources.IdentityResources, x => x.Name == hiddenIdentityResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == visibleApiResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == hiddenApiResource.Name); Assert.Contains(resources.ApiScopes, x => x.Name == visibleApiScope.Name); Assert.Contains(resources.ApiScopes, x => x.Name == hiddenApiScope.Name); }
ScopeViewModel CreateScopeViewModel(ApiScope scope) { return(new ScopeViewModel { Name = scope.Name, DisplayName = scope.DisplayName, Description = scope.Description, Emphasize = scope.Emphasize, Required = scope.Required, }); }
public async Task <ResultResponseDto> AddAsync(ApiResourceAddRequestDto dto) { var result = dto.ValidResult(); if (!result.Success) { return(Result.ReFailure <ResultResponseDto>(result)); } ApiResource apiResource = new ApiResource(dto.Name, dto.DisplayName, dto.UserClaims); apiResource.Description = dto.Description; //获取数据商店 IApiResourceRepositories dataStore = this.ServiceProvider.GetRequiredService <IApiResourceRepositories>(); if (await dataStore.GetIdAsync(apiResource.Name) > 0) { return(Result.ReFailure <ResultResponseDto>(apiResource.Name + " Api资源已经存在", ResultCodes.InvalidParameter)); } //添加秘钥 foreach (var item in dto.Secrets) { Secret secret = new Secret(item.Value, item.Type, item.Description, item.Expiration); if (!secret.IsValid()) { return(Result.ReFailure <ResultResponseDto>("请求参数错误", ResultCodes.InvalidParameter)); } apiResource.Secrets.Add(secret); } //添加包含范围 foreach (var item in dto.Scopes) { ApiScope scope = Mapper.Map <ApiScope>(item); if (!scope.IsValid()) { return(Result.ReFailure <ResultResponseDto>("请求参数错误", ResultCodes.InvalidParameter)); } //判断数据库以及当前Api资源是否存在当前Api范围 if (await dataStore.GetScopeIdAsync(scope.Name) > 0 || apiResource.Scopes.ToList().Exists(f => f.Name == scope.Name)) { return(Result.ReFailure <ResultResponseDto>(scope.Name + "Api范围已经存在", ResultCodes.InvalidParameter)); } apiResource.Scopes.Add(scope); } if (!apiResource.IsValid()) { return(Result.ReFailure <ResultResponseDto>("请求参数错误,Api资源不合法", ResultCodes.InvalidParameter)); } base.State = apiResource; await base.WriteStateAsync(); return(Result.ReSuccess <ResultResponseDto>()); }
public IActionResult AddScope() { var scope = new ApiScope { Name = "api_meteo_scope", Enabled = true }; _confContext.ApiScopes.Add(scope.ToEntity()); _confContext.SaveChanges(); return(Ok()); }
/// <summary> /// Determines if client is allowed access to the API scope. /// </summary> /// <param name="client"></param> /// <param name="apiScope"></param> /// <returns></returns> protected virtual Task <bool> IsClientAllowedApiScopeAsync(Client client, ApiScope apiScope) { var allowed = client.AllowedScopes.Contains(apiScope.Name); if (!allowed) { _logger.LogError("Client {client} is not allowed access to scope {scope}.", client.ClientId, apiScope.Name); } return(Task.FromResult(allowed)); }
protected virtual async Task ValidateScopeAsync(Client client, Resources resourcesFromStore, ParsedScopeValue requestedScope, ResourceValidationResult result) { if (requestedScope.ParsedName == "offline_access") { if (await IsClientAllowedOfflineAccessAsync(client)) { result.Resources.OfflineAccess = true; result.ParsedScopes.Add(new ParsedScopeValue("offline_access")); } else { result.InvalidScopes.Add("offline_access"); } return; } IdentityResource identity = resourcesFromStore.FindIdentityResourcesByScope(requestedScope.ParsedName); if (identity != null) { if (await IsClientAllowedIdentityResourceAsync(client, identity)) { result.ParsedScopes.Add(requestedScope); result.Resources.IdentityResources.Add(identity); } else { result.InvalidScopes.Add(requestedScope.RawValue); } return; } ApiScope apiScope = resourcesFromStore.FindApiScope(requestedScope.ParsedName); if (apiScope != null) { if (await IsClientAllowedApiScopeAsync(client, apiScope)) { result.ParsedScopes.Add(requestedScope); result.Resources.ApiScopes.Add(apiScope); foreach (ApiResource item in resourcesFromStore.FindApiResourcesByScope(apiScope.Name)) { result.Resources.ApiResources.Add(item); } } else { result.InvalidScopes.Add(requestedScope.RawValue); } } else { _logger.LogError("Scope {scope} not found in store.", requestedScope.ParsedName); result.InvalidScopes.Add(requestedScope.RawValue); } }
public virtual async Task <int> DeleteApiScopeAsync(ApiScope apiScope) { var resourceScopeToDelete = await DbContext.ApiResourceScopes.SingleOrDefaultAsync(x => x.Scope.Equals(apiScope.Name)); DbContext.ApiResourceScopes.Remove(resourceScopeToDelete); var apiScopeToDelete = await DbContext.ApiScopes.SingleOrDefaultAsync(x => x.Id == apiScope.Id); DbContext.ApiScopes.Remove(apiScopeToDelete); return(await AutoSaveChangesAsync()); }
public virtual async Task <int> UpdateApiScopeAsync(int apiResourceId, ApiScope apiScope) { ////Remove old relations await RemoveApiScopeClaimsAsync(apiScope); ///Remove properties //Update with new data DbContext.ApiScopes.Update(apiScope); return(await AutoSaveChangesAsync()); }
public async Task <IActionResult> CreateApiScope([FromBody] ApiScope model) { if (!ModelState.IsValid) { return(new BadRequestObjectResult(ModelState)); } await _apiScopeService.AddApiScopeAsync(model); return(Ok()); }
private ScopeViewModel CreateScopeViewModel(ApiScope scope, bool check) { return(new ScopeViewModel { Name = scope.Name, DisplayName = scope.DisplayName, Description = scope.Description, Emphasize = scope.Emphasize, Required = scope.Required, Checked = check || scope.Required }); }
public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check) { return(new ScopeViewModel { Value = parsedScopeValue.RawValue, DisplayName = apiScope.DisplayName ?? apiScope.Name, Description = apiScope.Description, Emphasize = apiScope.Emphasize, Required = apiScope.Required, Checked = check || apiScope.Required }); }
public async Task InsertNewApiScope(ApiScope apiScope) { var apiScopeEntity = apiScope.MapApiScopes(); await using var connection = new SqlConnection(_connectionString); await connection.OpenAsync(); var query = $"insert into {_options.DbSchema}.ApiScopes (Name, DisplayName, Description, Required, Emphasize, ShowInDiscoveryDocument, Enabled)" + $" VALUES (@Name, @DisplayName, @Description, @Required, @Emphasize, @ShowInDiscoveryDocument, @Enabled)"; await connection.ExecuteAsync(query, apiScopeEntity); }
/// <summary> /// Add new api scope /// </summary> /// <param name="apiResourceId"></param> /// <param name="apiScope"></param> /// <returns>This method return new api scope id</returns> public virtual async Task <int> AddApiScopeAsync(int apiResourceId, ApiScope apiScope) { var apiResource = await DbContext.ApiResources.Where(x => x.Id == apiResourceId).SingleOrDefaultAsync(); apiScope.ApiResource = apiResource; DbContext.ApiScopes.Add(apiScope); await AutoSaveChangesAsync(); return(apiScope.Id); }
public static ApiScopes MapApiScopes(this ApiScope scope) { return(new ApiScopes { Name = scope.Name, DisplayName = scope.DisplayName, Description = scope.Description, Required = scope.Required, Emphasize = scope.Emphasize, ShowInDiscoveryDocument = scope.ShowInDiscoveryDocument, Enabled = scope.Enabled }); }
/// <summary> /// Add ApiScope /// </summary> /// <param name="dto"></param> /// <returns></returns> public ApiScope BuildApiScope(ApiScopeBindingDto dto) { var scope = new ApiScope { Name = dto.Name, DisplayName = dto.DisplayName, Description = dto.Description, ApiResourceId = dto.ApiResourceId, Emphasize = true }; return(scope); }
ScopeModel CreateScopeModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check) { return(new ScopeModel { Value = parsedScopeValue.RawValue, // todo: use the parsed scope value in the display? DisplayName = apiScope.DisplayName ?? apiScope.Name, Description = apiScope.Description, Emphasize = apiScope.Emphasize, Required = apiScope.Required, Checked = check || apiScope.Required }); }
public async Task GetAllResources_WhenAllResourcesRequested_ExpectAllResourcesIncludingHidden() { var visibleIdentityResource = CreateIdentityTestResource(); var visibleApiResource = CreateApiResourceTestResource(); var visibleApiScope = CreateApiScopeTestResource(); var hiddenIdentityResource = new IdentityResource { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; var hiddenApiResource = new ApiResource { Name = Guid.NewGuid().ToString(), Scopes = { Guid.NewGuid().ToString() }, ShowInDiscoveryDocument = false }; var hiddenApiScope = new ApiScope { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; await _context.IdentityResources.AddAsync(visibleIdentityResource.ToEntity()); await _context.ApiResources.AddAsync(visibleApiResource.ToEntity()); await _context.ApiScopes.AddAsync(visibleApiScope.ToEntity()); await _context.IdentityResources.AddAsync(hiddenIdentityResource.ToEntity()); await _context.ApiResources.AddAsync(hiddenApiResource.ToEntity()); await _context.ApiScopes.AddAsync(hiddenApiScope.ToEntity()); Resources resources; var store = new ResourceStore(_context, FakeLogger <ResourceStore> .Create()); resources = await store.GetAllResourcesAsync(); Assert.NotNull(resources); Assert.NotEmpty(resources.IdentityResources); Assert.NotEmpty(resources.ApiResources); Assert.NotEmpty(resources.ApiScopes); Assert.Contains(resources.IdentityResources, x => x.Name == visibleIdentityResource.Name); Assert.Contains(resources.IdentityResources, x => x.Name == hiddenIdentityResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == visibleApiResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == hiddenApiResource.Name); Assert.Contains(resources.ApiScopes, x => x.Name == visibleApiScope.Name); Assert.Contains(resources.ApiScopes, x => x.Name == hiddenApiScope.Name); }
public ApiScope ToScope() { var result = new ApiScope( Data.Name, Data.DisplayName ?? string.Empty, Data.UserClaims ?? Enumerable.Empty <string>()) { Enabled = !Data.Disabled, Emphasize = Data.Emphasize, Required = Data.Required }; return(result); }
public async Task <ApiScope> AddAsync(ApiScope apiScope) { try { var result = await this.DbContext.AddAsync(apiScope); this.DbContext.SaveChanges(); return(result.Entity); } catch (Exception ex) { throw ex; } }
public async Task <int> UpdateApiScopeAsync(int apiResourceId, ApiScope apiScope) { var apiResource = await _dbContext.ApiResources.Where(x => x.Id == apiResourceId).SingleOrDefaultAsync(); apiScope.ApiResource = apiResource; //Remove old relations await RemoveApiScopeClaimsAsync(apiScope); //Update with new data _dbContext.ApiScopes.Update(apiScope); return(await AutoSaveChangesAsync()); }
protected internal virtual ScopeViewModel CreateScopeViewModel(ApiScope apiScope) { if (apiScope == null) { throw new ArgumentNullException(nameof(apiScope)); } var model = this.CreateScopeViewModelInternal(apiScope); model.Emphasize = apiScope.Emphasize; model.Required = apiScope.Required; return(model); }
/// <summary> /// Converts from. /// </summary> /// <param name="model">The model.</param> /// <returns></returns> public ApiScopeDetails ConvertFrom(ApiScope model) { if (model == null) { return(null); } return(new ApiScopeDetails { Enabled = model.Enabled, DisplayName = model.DisplayName, Name = model.Name, Description = model.Description }); }
public static Models.ApiScope ToModel(this ApiScope entity) { return(entity is null ? null : new Models.ApiScope { Description = entity.Description, DisplayName = entity.DisplayName, Emphasize = entity.Emphasize, Enabled = entity.Enabled, Name = entity.Name, Properties = entity.Properties, Required = entity.Required, ShowInDiscoveryDocument = entity.ShowInDiscoveryDocument, UserClaims = entity.UserClaims }); }
public async Task SetApiScopeAsync(ApiScope apiScope, SetApiParam param, CancellationToken cancellationToken) { var config = await GetConfigDaoAsync(param.Authority, cancellationToken); var newApis = config.Apis == null ? new List <ApiScope>() : new List <ApiScope>(config.Apis); var oldApi = newApis.Where(e => e.Name.Equals(apiScope.Name, StringComparison.Ordinal)).FirstOrDefault(); if (oldApi != null) { newApis.Remove(oldApi); } newApis.Add(apiScope); config.Apis = newApis; await SetConfigDaoAsync(param.Authority, cancellationToken, config); }
public async Task <bool> CanInsertApiScopeAsync(ApiScope apiScope) { if (apiScope.Id == 0) { var existsWithSameName = await _dbContext.ApiScopes.Where(x => x.Name == apiScope.Name).SingleOrDefaultAsync(); return(existsWithSameName == null); } else { var existsWithSameName = await _dbContext.ApiScopes.Where(x => x.Name == apiScope.Name && x.Id != apiScope.Id).SingleOrDefaultAsync(); return(existsWithSameName == null); } }
public static IEnumerable <ApiScope> GetApiScopes() { List <ApiScope> apiScopes = new List <ApiScope>(); foreach (var item in ApiNames) { var configuration = Configuration.GetSection(item); string[] names = configuration.GetSection("ApiScope").Value.Split(","); foreach (var name in names) { ApiScope apiScope = new ApiScope(name, name); apiScopes.Add(apiScope); } } return(apiScopes); }
public static ApiScopeModel FromEntity(ApiScope apiScope) { return(new ApiScopeModel { Id = apiScope.Id, Enabled = apiScope.Enabled, Name = apiScope.Name, DisplayName = apiScope.DisplayName, Description = apiScope.Description, Required = apiScope.Required, Emphasize = apiScope.Emphasize, ShowInDiscoveryDocument = apiScope.ShowInDiscoveryDocument, UserClaims = apiScope.UserClaims, Properties = apiScope.Properties, }); }
private ScopeViewModel ToModel(ApiScope entity) { return(new ScopeViewModel { Id = entity.Id, Enabled = entity.Enabled, Name = entity.Name, DisplayName = entity.DisplayName, Description = entity.Description, Required = entity.Required, ShowInDiscoveryDocument = entity.ShowInDiscoveryDocument, Emphasize = entity.Emphasize, UserClaims = entity.UserClaims .Select(x => x.Type).ToList() }); }
private void HandleCollectionProperties(ScopeViewModel model, ApiScope apiScope) { // deassign them if (apiScope.UserClaims != null) { apiScope.UserClaims.Clear(); } // assign them apiScope.UserClaims = model.UserClaims .Select(x => new ApiScopeClaim { Scope = apiScope, Type = x }).ToList(); }
public async Task Serialize_ApiScope_Test() { await Task.CompletedTask; var apiScope = new ApiScope(); var json = JsonConvert.SerializeObject(apiScope, this.JsonSerializerSettings); Assert.AreEqual("{}", json); apiScope = new ApiScope { Name = "name" }; json = JsonConvert.SerializeObject(apiScope, this.JsonSerializerSettings); Assert.AreEqual("{\"Name\":\"name\"}", json); }