Esempio n. 1
0
        public async Task <ApiResourceRegistryDto> GetApiResource([FromQuery] string apiName)
        {
            ApiResourcesDto targ = await _apiResourceService.GetApiResourcesAsync(apiName, 1, 1);

            if (targ.ApiResources.Count == 0)
            {
                throw new UserFriendlyErrorPageException($"API[{apiName}]不存在");
            }

            ApiResourceDto         api    = targ.ApiResources[0];
            ApiResourceRegistryDto result = new ApiResourceRegistryDto();

            result.Description = api.Description;
            result.DisplayName = api.DisplayName;
            result.Enabled     = api.Enabled;
            result.Name        = api.Name;
            result.UserClaims  = api.UserClaims;

            var scopes = await _apiResourceService.GetApiScopesAsync(api.Id, 1, int.MaxValue);

            result.Scopes = scopes.Scopes.Select(x => new ApiScope
            {
                Description             = x.Description,
                DisplayName             = x.DisplayName,
                Emphasize               = x.Emphasize,
                Name                    = x.Name,
                Required                = x.Required,
                ShowInDiscoveryDocument = x.ShowInDiscoveryDocument,
                UserClaims              = x.UserClaims
            }).ToList();

            var props = await _apiResourceService.GetApiResourcePropertiesAsync(api.Id, 1, int.MaxValue);

            result.Properties = props.ApiResourceProperties.ToDictionary(x => x.Key, x => x.Value);

            return(result);
        }
Esempio n. 2
0
        public async Task <IActionResult> SaveApiResource([FromBody] ApiResourceRegistryDto api)
        {
            ApiResourcesDto targ = await _apiResourceService.GetApiResourcesAsync(api.Name, 1, 1);

            ApiResourceDto apiDto = ToApiResourceDto(api);
            int            apiId;

            if (targ.ApiResources.Count == 0)
            {
                apiId = await _apiResourceService.AddApiResourceAsync(apiDto);
            }
            else
            {
                apiId     = targ.ApiResources[0].Id;
                apiDto.Id = apiId;
                await _apiResourceService.UpdateApiResourceAsync(apiDto);
            }

            ApiScopesDto scopesInDb = await _apiResourceService.GetApiScopesAsync(apiId, 1, int.MaxValue);

            foreach (var sitem in api.Scopes)
            {
                if (scopesInDb.Scopes.Any(x => x.Name == sitem.Name))
                {
                    continue;
                }

                await _apiResourceService.AddApiScopeAsync(new ApiScopesDto()
                {
                    ApiResourceId           = apiId,
                    Description             = sitem.Description,
                    DisplayName             = sitem.DisplayName,
                    Emphasize               = sitem.Emphasize,
                    Name                    = sitem.Name,
                    Required                = sitem.Required,
                    ShowInDiscoveryDocument = sitem.ShowInDiscoveryDocument,
                    UserClaims              = sitem.UserClaims,
                });
            }

            foreach (var sitem in scopesInDb.Scopes)
            {
                if (api.Scopes.Any(x => x.Name == sitem.Name))
                {
                    continue;
                }

                var apiScope = new ApiScopesDto {
                    ApiResourceId = apiId, ApiScopeId = sitem.Id
                };
                await _apiResourceService.DeleteApiScopeAsync(apiScope);
            }

            ApiResourcePropertiesDto propertiesDto = await _apiResourceService.GetApiResourcePropertiesAsync(apiId, 1, int.MaxValue);

            ApiResourcePropertiesDto[] todele = propertiesDto.ApiResourceProperties.Where(x => api.Properties.ContainsKey(x.Key))
                                                .Select(x => new ApiResourcePropertiesDto()
            {
                ApiResourceId         = apiId,
                ApiResourcePropertyId = x.Id,
                Key   = x.Key,
                Value = x.Value
            }).ToArray();

            foreach (var prop in todele)
            {
                await _apiResourceService.DeleteApiResourcePropertyAsync(prop);
            }

            foreach (var item in api.Properties)
            {
                await _apiResourceService.AddApiResourcePropertyAsync(new ApiResourcePropertiesDto
                {
                    ApiResourceId = apiId,
                    Key           = item.Key,
                    Value         = item.Value
                });
            }

            return(Ok());
        }
Esempio n. 3
0
 public ApiResourcesRequestedEvent(ApiResourcesDto apiResources)
 {
     ApiResources = apiResources;
 }