public async Task <IActionResult> Delete(int id)
{
var apiResourceDto = new ApiResourceDto {
Id = id
};
await _apiResourceService.GetApiResourceAsync(apiResourceDto.Id);
await _apiResourceService.DeleteApiResourceAsync(apiResourceDto);
return(Ok());
}
public async Task <IActionResult> ApiResource(int id)
{
if (id == 0)
{
var apiResourceDto = new ApiResourceDto();
return(View(apiResourceDto));
}
var apiResource = await _apiResourceService.GetApiResourceAsync(id);
return(View(apiResource));
}
/// <summary>
/// 创建Api资源
/// </summary>
/// <param name="dto">Api资源参数</param>
public async Task <Guid> CreateAsync(ApiResourceDto dto)
{
var entity = dto.ToEntity();
await ValidateCreateAsync(entity);
entity.Init();
await ApiResourceRepository.AddAsync(entity);
await UnitOfWork.CommitAsync();
return(entity.Id);
}
public async Task <int> UpdateApiResourceAsync(ApiResourceDto apiResource)
{
var canInsert = await CanInsertApiResourceAsync(apiResource);
if (!canInsert)
{
throw new UserFriendlyViewException(string.Format(_apiResourceServiceResources.ApiResourceExistsValue().Description, apiResource.Name), _apiResourceServiceResources.ApiResourceExistsKey().Description, apiResource);
}
var resource = apiResource.ToEntity();
return(await _apiResourceRepository.UpdateApiResourceAsync(resource));
}
public virtual async Task <int> AddApiResourceAsync(ApiResourceDto apiResource)
{
var canInsert = await CanInsertApiResourceAsync(apiResource);
if (!canInsert)
{
throw new UserFriendlyViewException(string.Format(ApiResourceServiceResources.ApiResourceExistsValue().Description, apiResource.Name), ApiResourceServiceResources.ApiResourceExistsKey().Description, apiResource);
}
var resource = apiResource.ToEntity();
var added = await ApiResourceRepository.AddApiResourceAsync(resource);
await AuditEventLogger.LogEventAsync(new ApiResourceAddedEvent(apiResource));
return(added);
}
public async Task <IActionResult> ApiResource(string id)
{
if (id.IsNotPresentedValidNumber())
{
return(NotFound());
}
if (id == default)
{
var apiResourceDto = new ApiResourceDto();
return(View(apiResourceDto));
}
int.TryParse(id, out var apiResourceId);
var apiResource = await _apiResourceService.GetApiResourceAsync(apiResourceId);
return(View(apiResource));
}
/// <summary>
/// 转换为Api资源
/// </summary>
private ApiResource ToResource(ApiResourceDto dto)
{
if (dto == null)
{
return(null);
}
var result = new ApiResource(dto.Uri, dto.Name)
{
Description = dto.Remark,
Enabled = dto.Enabled.SafeValue()
};
if (dto.Claims != null && dto.Claims.Count > 0)
{
dto.Claims.ForEach(claim => result.UserClaims.Add(claim));
}
return(result);
}
public async Task <ApiResponse> UpdateApiResourceAsync(ApiResourceDto apiResourceDto)
{
//Name is not the primary key, but a unique index and ApiResourceDto does not contain the real key Id.
//So in UI I have to use Name as a key and I make it read only.
var apiResource = await _configurationDbContext.ApiResources.SingleOrDefaultAsync(i => i.Name == apiResourceDto.Name);
if (apiResource == null)
{
return(new ApiResponse(Status400BadRequest, L["The API resource {0} doesn't exist", apiResourceDto.Name]));
}
_configurationDbContext.ApiResources.Remove(apiResource);
_configurationDbContext.ApiResources.Add(apiResourceDto.ToEntity());
await _configurationDbContext.SaveChangesAsync();
return(new ApiResponse(Status200OK, L["API Resource {0} updated", apiResourceDto.Name], apiResourceDto));
}
public ApiResourceDto GetApiResourceDto(int?id)
{
ApiResourceDto apiResourceDto = new ApiResourceDto();
if (!id.HasValue)
{
return(apiResourceDto);
}
if (id.Value <= 0)
{
return(apiResourceDto);
}
ApiResource apiResource = this.Session.Get <ApiResource>(id.Value);
apiResource.UserClaims = this.Session.CreateCriteria <ApiClaim>()
.Add(NHibernate.Criterion.Restrictions.Eq("ApiResourceId", id.Value))
.List <ApiClaim>()
.ToList();
return(apiResource.ToModel());
}
public async Task <IActionResult> ApiResource(ApiResourceDto apiResource)
{
if (!ModelState.IsValid)
{
return(View(apiResource));
}
ComboBoxHelpers.PopulateValuesToList(apiResource.UserClaimsItems, apiResource.UserClaims);
if (apiResource.Id == 0)
{
await _apiResourceService.AddApiResourceAsync(apiResource);
}
else
{
await _apiResourceService.UpdateApiResourceAsync(apiResource);
}
SuccessNotification(string.Format(_localizer["SuccessAddApiResource"], apiResource.Name), _localizer["SuccessTitle"]);
return(RedirectToAction(nameof(ApiResources)));
}
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);
}
public ApiResourceUpdatedEvent(ApiResourceDto originalApiResource, ApiResourceDto apiResource)
{
OriginalApiResource = originalApiResource;
ApiResource = apiResource;
}
public static ApiResource ToEntity(this ApiResourceDto apiResourceDto, ApiResource apiResource = null)
{
return(Mapper.Map <ApiResourceDto, ApiResource>(apiResourceDto, apiResource));
}
public async Task <int> DeleteApiResourceAsync(ApiResourceDto apiResource)
{
var resource = apiResource.ToEntity();
return(await _apiResourceRepository.DeleteApiResourceAsync(resource));
}
public async Task <IActionResult> GetByName(string name)
{
ApiResourceDto item = await _apiResourceService.GetByName(name);
return(Ok(item));
}
public async Task <ApiResponse> UpdateApiResourceAsync([FromBody] ApiResourceDto apiResourceDto) => await _adminManager.UpdateApiResourceAsync(apiResourceDto);
public IActionResult UpdateApiResource(int id, [FromBody] ApiResourceDto ApiResourceDto)
{
this.service.UpdateApiResource(id, ApiResourceDto);
return(Success());
}
public async Task <IActionResult> Post([FromBody] ApiResourceDto dto)
{
var result = await _customResourceService.InsertCustomApiResource(dto);
return(CreatedResponse(result));
}
public static ApiResource ToEntity(this ApiResourceDto resource)
{
return(resource == null ? null : Mapper.Map <ApiResource>(resource));
}
public ApiResourceRequestedEvent(int apiResourceId, ApiResourceDto apiResource)
{
ApiResourceId = apiResourceId;
ApiResource = apiResource;
}
public virtual async Task <bool> CanInsertApiResourceAsync(ApiResourceDto apiResource)
{
var resource = apiResource.ToEntity();
return(await ApiResourceRepository.CanInsertApiResourceAsync(resource));
}
public async Task OnGetAsync()
{
var dataDto = await _apiResourceAppService.GetAsync(Id);
ApiResourceUpdateDto = ObjectMapper.Map <ApiResourceDto, ApiResourceDto>(dataDto);
}
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());
}
public ApiResourceDeletedEvent(ApiResourceDto apiResource)
{
ApiResource = apiResource;
}
/// <summary>
/// 转成Api资源
/// </summary>
public static ApiResource ToEntity(this ApiResourceDto dto)
{
return(dto?.MapTo <ApiResource>());
}
public ApiResourceAddedEvent(ApiResourceDto apiResource)
{
ApiResource = apiResource;
}
public IActionResult GetApiResource(int?id)
{
ApiResourceDto data = this.service.GetApiResourceDto(id);
return(Success(data));
}
public IActionResult AddApiResource([FromBody] ApiResourceDto ApiResourceDto)
{
this.service.AddApiResource(ApiResourceDto);
return(Success());
}
public static ApiResource ToEntity(this ApiResourceDto apiResourceDto)
{
return(_mapper.Map(apiResourceDto, new ApiResource()));
}
