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 async Task <IdentityServer4.Models.IdentityResource> RollupAsync(Neo4jIdentityServer4IdentityResource identityResource,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
identityResource.ThrowIfNull(nameof(identityResource));
var foundIdentityResource = await GetIdentityResourceAsync(identityResource, cancellationToken);
IdentityResource model = null;
if (foundIdentityResource != null)
{
model = foundIdentityResource.ToModel();
var claims = await GetIdentityClaimsAsync(foundIdentityResource, cancellationToken);
foreach (var claim in claims)
{
model.UserClaims.Add(claim.Type);
}
var rollup = new IdentityResourceRollup()
{
IdentityResourceJson = JsonConvert.SerializeObject(model),
};
await AddRollupAsync(foundIdentityResource, rollup);
}
return(model);
}
public virtual async Task CreateStandardResourcesAsync()
{
var wechatClaimTypes = new string[]
{
AbpWeChatClaimTypes.AvatarUrl,
AbpWeChatClaimTypes.City,
AbpWeChatClaimTypes.Country,
AbpWeChatClaimTypes.NickName,
AbpWeChatClaimTypes.OpenId,
AbpWeChatClaimTypes.Privilege,
AbpWeChatClaimTypes.Province,
AbpWeChatClaimTypes.Sex,
AbpWeChatClaimTypes.UnionId
};
var wechatResource = new IdentityServer4.Models.IdentityResource(
WeChatOfficialOAuthConsts.ProfileKey,
WeChatOfficialOAuthConsts.DisplayName,
wechatClaimTypes);
foreach (var claimType in wechatClaimTypes)
{
await AddClaimTypeIfNotExistsAsync(claimType);
}
await AddIdentityResourceIfNotExistsAsync(wechatResource);
}
public async Task AddResourceAsync(IdentityResource resource)
{
var resourceEntity = resource.ToEntity();
IdentityDbContext.IdentityResources.Add(resourceEntity);
await IdentityDbContext.SaveChangesAsync();
}
public RemoveIdentityResourceCommand(string name)
{
Resource = new IdentityServer4.Models.IdentityResource()
{
Name = name
};
}
private async Task <HttpResponseMessage> CreateNewIdentityResource(IdentityServer4.Models.IdentityResource identityResource)
{
var stringContent = new StringContent(JsonConvert.SerializeObject(identityResource), Encoding.UTF8, "application/json");
var response = await HttpClient.PostAsync("/api/identityresource", stringContent);
return(response);
}
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);
}
/// <summary>
/// Convert from <see cref="IdentityServer4.Models.IdentityResource"/> to <see cref="Scope"/>
/// </summary>
/// <param name="identity"></param>
/// <returns></returns>
public static Scope ToScope(this IdentityServer4.Models.IdentityResource identity)
{
return(new Scope
{
Name = identity.Name,
DisplayName = identity.DisplayName,
Description = identity.Description,
Emphasize = identity.Emphasize,
Required = identity.Required
});
}
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 IdentityResource(Guid id, IdentityServer4.Models.IdentityResource resource)
{
Id = id;
Name = resource.Name;
DisplayName = resource.DisplayName;
Description = resource.Description;
Enabled = resource.Enabled;
Required = resource.Required;
Emphasize = resource.Emphasize;
ShowInDiscoveryDocument = resource.ShowInDiscoveryDocument;
UserClaims = resource.UserClaims.Select(claimType => new IdentityClaim(id, claimType)).ToList();
}
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 IdentityResourceDto(Guid id, IdentityServer4.Models.IdentityResource resource)
{
Id = id;
Name = resource.Name;
DisplayName = resource.DisplayName;
Description = resource.Description;
Enabled = resource.Enabled;
Required = resource.Required;
Emphasize = resource.Emphasize;
ShowInDiscoveryDocument = resource.ShowInDiscoveryDocument;
UserClaims = resource.UserClaims.Select(claimType => new IdentityClaimDto(id, claimType)).ToList();
Properties = resource.Properties.ToDictionary(x => x.Key, x => x.Value);
}
protected virtual async Task AddIdentityResourceIfNotExistsAsync(IdentityServer4.Models.IdentityResource resource)
{
if (await IdentityResourceRepository.CheckNameExistAsync(resource.Name))
{
return;
}
await IdentityResourceRepository.InsertAsync(
new IdentityResource(
GuidGenerator.Create(),
resource
)
);
}
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));
}
public virtual async Task CreateStandardResourcesAsync()
{
var resources = new IdentityServer4.Models.IdentityResource[]
{
new IdentityServer4.Models.IdentityResources.OpenId(),
new IdentityServer4.Models.IdentityResources.Profile(),
new IdentityServer4.Models.IdentityResources.Email(),
new IdentityServer4.Models.IdentityResources.Address(),
new IdentityServer4.Models.IdentityResources.Phone()
};
foreach (var resource in resources)
{
await AddIfNotExistsAsync(resource);
}
}
/// <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));
}
}
private async Task <IdentityResource> ConvertToModelAsync(IdentityResourceEntity entity)
{
var resource = new IdentityResource
{
Enabled = entity.Enabled,
Name = entity.Name,
DisplayName = entity.DisplayName,
Description = entity.Description,
};
await foreach (var claim in _identityClaims.EnumAsync(entity.Name))
{
resource.UserClaims.Add(claim.Claim);
}
var converted = resource;
return(converted);
}
public async Task StoreAsync(IdentityResource resource)
{
await _identityResources.InsertAsync(new IdentityResourceEntity(resource.Name) {
Description = resource.Description,
DisplayName = resource.DisplayName,
Enabled = resource.Enabled,
Emphasize = resource.Emphasize,
Required = resource.Required,
ShowInDiscoveryDocument = resource.ShowInDiscoveryDocument,
});
foreach (var claim in resource.UserClaims)
{
await _identityClaims.InsertAsync(new IdentityClaimEntity
{
Name = resource.Name,
Claim = claim,
});
}
}
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());
}
public UpdateIdentityResourceCommand(IdentityServer4.Models.IdentityResource resource, string oldIdentityResourceName)
{
Resource = resource;
this.OldIdentityResourceName = oldIdentityResourceName;
}
public UpdateIdentityResourceCommand(IdentityServer4.Models.IdentityResource resource)
{
Resource = resource;
}
private static void SeedIdentityClaims(IAdminStore <Entity.IdentityClaim> identityClaimStore, IdentityServer4.Models.IdentityResource resource)
{
foreach (var claim in resource.UserClaims)
{
identityClaimStore.CreateAsync(new Entity.IdentityClaim
{
Id = Guid.NewGuid().ToString(),
IdentityId = resource.Name,
Type = claim
}).GetAwaiter().GetResult();
}
}
private static void SeedIdentityProperties(IAdminStore <Entity.IdentityProperty> identityPropertyStore, IdentityServer4.Models.IdentityResource resource)
{
foreach (var property in resource.Properties)
{
identityPropertyStore.CreateAsync(new Entity.IdentityProperty
{
Id = Guid.NewGuid().ToString(),
IdentityId = resource.Name,
Key = property.Key,
Value = property.Value
}).GetAwaiter().GetResult();
}
}
public RegisterIdentityResourceCommand(IdentityServer4.Models.IdentityResource resource)
{
Resource = resource;
}
public void UpdateResource(string id, IdentityResource resource)
{
UpdateResourceAsync(id, resource).Wait();
}
public void AddResource(IdentityResource resource)
{
AddResourceAsync(resource).Wait();
}
/// <summary>
/// Maps a model to an entity.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static IdentityResource ToEntity(
this IdentityServer4.Models.IdentityResource model)
{
return(model == null ? null : Mapper.Map <IdentityResource>(model));
}
public static IdentityResource ToEntity(this IdentityServer4.Models.IdentityResource resource)
{
return(resource == null ? null : Mapper.Map <IdentityResource>(resource));
}
