public async Task AddResourceAsync(IdentityResource resource)
{
var resourceEntity = resource.ToEntity();
IdentityDbContext.IdentityResources.Add(resourceEntity);
await IdentityDbContext.SaveChangesAsync();
}
public async Task <IActionResult> Post([FromBody] IroncladResource model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(this.BadRequest(new { Message = $"Cannot create an identity resource without a name" }));
}
if (model.UserClaims?.Any() == false)
{
return(this.BadRequest(new { Message = $"Cannot create an identity resource without any claims" }));
}
var resource = new IdentityServerResource(model.Name, model.DisplayName, model.UserClaims);
// optional properties
resource.Enabled = model.Enabled ?? resource.Enabled;
using (var session = this.store.LightweightSession())
{
if (session.Query <PostgresResource>().Any(item => item.Name == model.Name))
{
return(this.StatusCode((int)HttpStatusCode.Conflict, new { Message = "Identity resource already exists" }));
}
session.Insert(resource.ToEntity());
await session.SaveChangesAsync();
}
return(this.Created(new Uri(this.HttpContext.GetIdentityServerRelativeUrl("~/api/identityresources/" + model.Name)), null));
}
public Task Create(IdentityServer4.Models.IdentityResource resouce)
{
if (resouce == null)
{
throw new ArgumentNullException(nameof(resouce));
}
State.IdentityResource = resouce.ToEntity();
return(WriteStateAsync());
}
protected virtual async Task AddIdentityResourceIfNotExistsAsync(IdentityServer4.Models.IdentityResource resource)
{
if (await IdentityResourceRepository.CheckNameExistAsync(resource.Name))
{
return;
}
var entity = resource.ToEntity();
await IdentityResourceRepository.InsertAsync(entity, true);
}
public async Task UpdateResourceAsync(string id, IdentityResource resource)
{
var existingResource = await IdentityDbContext.IdentityResources
.Where(r => r.Name.Equals(id, StringComparison.OrdinalIgnoreCase) &&
!r.IsDeleted)
.SingleOrDefaultAsync();
resource.ToEntity(existingResource);
IdentityDbContext.IdentityResources.Update(existingResource);
await IdentityDbContext.SaveChangesAsync();
}
public void IdentityResourceModelToEntityConfigurationIsValid()
{
var model = new IdentityServer4.Models.IdentityResource();
// TODO: set references
var mappedEntity = model.ToEntity();
var mappedModel = mappedEntity.ToModel();
Assert.NotNull(mappedModel);
Assert.NotNull(mappedEntity);
IdentityResourceMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
}
public async Task AddResourceAsync(IdentityResource resource)
{
var resourceEntity = resource.ToEntity();
IdentityDbContext.IdentityResources.Add(resourceEntity);
await IdentityDbContext.SaveChangesAsync();
await EventService.RaiseAsync(
new EntityCreatedAuditEvent <IdentityResource>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
resource.Name,
resource,
SerializationSettings));
}
/// <summary>
/// 创建或者更新资源
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <Result> CreateOrUpdateIdentityResourceAsync(IdentityResourceDto dto)
{
if (dto.UserClaims == null || dto.UserClaims.Count == 0)
{
return(FailedResult("UserClaims不能为空值"));
}
IdentityServer4.Models.IdentityResource model = mapper.Map <IdentityServer4.Models.IdentityResource>(dto);
var entity = model.ToEntity();
if (!dto.Id.HasValue || dto.Id == 0)
{
//创建
await configurationDbContext.IdentityResources.AddAsync(entity).ConfigureAwait(false);
}
else
{
entity.Id = dto.Id.Value;
var fromDbEntity = await IdentityResources.FirstOrDefaultAsync(e => e.Id == entity.Id).ConfigureAwait(false);
if (fromDbEntity == null)
{
return(FailedResult("不存在身份资源"));
}
fromDbEntity = mapper.Map(entity, fromDbEntity);
}
try
{
int rows = await configurationDbContext.SaveChangesAsync().ConfigureAwait(false);
if (rows == 0)
{
return(FailedResult("已执行，但未更新数据库"));
}
return(OkResult());
}
catch (DbUpdateException ex)
{
return(FailedResult(ex));
}
}
public async Task UpdateResourceAsync(string id, IdentityResource resource)
{
var existingResource = await IdentityDbContext.IdentityResources
.Where(r => r.Name == id &&
!r.IsDeleted)
.SingleOrDefaultAsync();
resource.ToEntity(existingResource);
IdentityDbContext.IdentityResources.Update(existingResource);
await IdentityDbContext.SaveChangesAsync();
await EventService.RaiseAsync(
new EntityUpdatedAuditEvent <IdentityResource>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
resource.Name,
resource,
SerializationSettings));
}
public async Task <IActionResult> Put(string resourceName, [FromBody] IroncladResource model)
{
if (model.UserClaims?.Any() == false)
{
return(this.BadRequest(new { Message = $"Cannot update an identity resource without any claims" }));
}
using (var session = this.store.LightweightSession())
{
var document = await session.Query <PostgresResource>().SingleOrDefaultAsync(item => item.Name == resourceName);
if (document == null)
{
return(this.NotFound(new { Message = $"Identity resource '{resourceName}' not found" }));
}
// NOTE (Cameron): Because of the mapping/conversion unknowns we rely upon the Postgres integration to perform that operation which is why we do this...
var resource = new IdentityServerResource
{
UserClaims = model.UserClaims,
};
var entity = resource.ToEntity();
// update properties (everything supported is an optional update eg. if null is passed we will not update)
document.DisplayName = model.DisplayName ?? document.DisplayName;
document.UserClaims = entity.UserClaims ?? document.UserClaims;
document.Enabled = model.Enabled ?? document.Enabled;
session.Update(document);
await session.SaveChangesAsync();
}
return(this.Ok());
}
