public void Properties_Map()
{
var model = new ApiResource()
{
Description = "description",
DisplayName = "displayname",
Name = "foo",
Scopes = { "foo1", "foo2" },
Enabled = false
};
var mappedEntity = model.ToEntity();
mappedEntity.Scopes.Count.Should().Be(2);
var foo1 = mappedEntity.Scopes.FirstOrDefault(x => x.Scope == "foo1");
foo1.Should().NotBeNull();
var foo2 = mappedEntity.Scopes.FirstOrDefault(x => x.Scope == "foo2");
foo2.Should().NotBeNull();
var mappedModel = mappedEntity.ToModel();
mappedModel.Description.Should().Be("description");
mappedModel.DisplayName.Should().Be("displayname");
mappedModel.Enabled.Should().BeFalse();
mappedModel.Name.Should().Be("foo");
}
public RemoveApiResourceCommand(string name)
{
Resource = new IdentityServer4.Models.ApiResource()
{
Name = name
};
}
public ActionResult Create(ApiResource api)
{
try
{
if (ModelState.IsValid)
{
var userClaims = new List <string>();
var apiToSave =
new IdentityServer4.Models.ApiResource(api.Name, api.DisplayName, userClaims)
{
Description = api.Description
// ApiSecrets = { new IdentityServer4.Models.Secret(api.Secrets.Sha256()) }
};
_configurationDbContext.ApiResources.Add(apiToSave.ToEntity());
_configurationDbContext.SaveChanges();
TempData["message"] = $"{api.Name} has been created.";
}
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
return(View());
}
}
/// <summary>
/// Maps a model to an entity.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static ApiResource ToEntity(
this IdentityServer4.Models.ApiResource model)
{
return(model == null ?
null :
Mapper.Map <ApiResource>(model));
}
public async Task AddResourceAsync(ApiResource resource)
{
var resourceEntity = resource.ToEntity();
IdentityDbContext.ApiResources.Add(resourceEntity);
await IdentityDbContext.SaveChangesAsync();
}
public void Can_Map()
{
var model = new ApiResource();
var mappedEntity = model.ToEntity();
var mappedModel = mappedEntity.ToModel();
Assert.NotNull(mappedModel);
Assert.NotNull(mappedEntity);
}
public async Task <ApiResource> CreateAsync(string name, string[] userClaims)
{
IdentityServer4.Models.ApiResource apiResourceModel = new IdentityServer4.Models.ApiResource(name, name, userClaims);
// Need to use our own mapper definition as there is a conflict with the AutoMapper used in the included IDS4 package.
ApiResource apiResource = mapper.Map <ApiResource>(apiResourceModel);
identityServerConfigurationContext.ApiResources.Add(apiResource);
await identityServerConfigurationContext.SaveChangesAsync();
return(apiResource);
}
public async Task UpdateResourceAsync(string id, ApiResource resource)
{
var savedResource = await IdentityDbContext.ApiResources
.Where(r => r.Name.Equals(id, StringComparison.OrdinalIgnoreCase) &&
!r.IsDeleted)
.SingleOrDefaultAsync();
resource.ToEntity(savedResource);
IdentityDbContext.ApiResources.Update(savedResource);
await IdentityDbContext.SaveChangesAsync();
}
public void ApiResourceModelToEntityConfigurationIsValid()
{
var model = new IdentityServer4.Models.ApiResource();
// TODO: set references
var mappedEntity = model.ToEntity();
var mappedModel = mappedEntity.ToModel();
Assert.NotNull(mappedModel);
Assert.NotNull(mappedEntity);
ApiResourceMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
}
public async Task <ApiResource> RollupAsync(
Neo4jIdentityServer4ApiResource apiResource,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
apiResource.ThrowIfNull(nameof(apiResource));
var foundApiResource = await GetApiResourceAsync(apiResource, cancellationToken);
ApiResource model = null;
if (foundApiResource != null)
{
model = foundApiResource.ToModel();
var secrets = await GetApiSecretsAsync(apiResource, cancellationToken);
foreach (var secret in secrets)
{
model.ApiSecrets.Add(secret.ToModel());
}
var claims = await GetApiResourceClaimsAsync(apiResource, cancellationToken);
foreach (var claim in claims)
{
model.UserClaims.Add(claim.Type);
}
var apiScopes = await GetApiScopesAsync(apiResource, cancellationToken);
foreach (var apiScope in apiScopes)
{
var apiScopeModel = await GetRollupAsync(apiResource, apiScope, cancellationToken);
model.Scopes.Add(apiScopeModel);
}
var distinctList = model.Scopes.Distinct(new ModelsScopeComparer());
model.Scopes = distinctList.ToList();
var rollup = new ApiResourceRollup()
{
ApiResourceJson = JsonConvert.SerializeObject(model),
};
await AddRollupAsync(apiResource, rollup);
}
return(model);
}
public IActionResult AddApiRessource()
{
IdentityServer4.Models.ApiResource api = new IdentityServer4.Models.ApiResource();
api.Name = "apimeteo";
api.Description = "description de l'api";
api.DisplayName = "API meteo";
api.Enabled = true;
_confContext.ApiResources.Add(api.ToEntity());
_confContext.SaveChanges();
return(Ok());
}
public async Task AddResourceAsync(ApiResource resource)
{
var resourceEntity = resource.ToEntity();
IdentityDbContext.ApiResources.Add(resourceEntity);
await IdentityDbContext.SaveChangesAsync();
await EventService.RaiseAsync(
new EntityCreatedAuditEvent <ApiResource>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
resource.Name,
resource,
SerializationSettings));
}
public IActionResult EditApi(IdentityServer4.Models.ApiResource model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var rapi = _configContext.ApiResources.Where(c => c.Name == model.Name).FirstOrDefault();
var api = model.ToEntity();
rapi.DisplayName = api.DisplayName;
rapi.Description = api.Description;
rapi.UserClaims = api.UserClaims;
_configContext.Update(rapi);
_configContext.SaveChanges();
return(RedirectToAction("ApiResources"));
}
/// <summary>
/// 创建或者更新资源
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <Result> CreateOrUpdateApiResourceAsync(ApiResourceDto dto)
{
IdentityServer4.Models.ApiResource model = mapper.Map <IdentityServer4.Models.ApiResource>(dto);
var entity = model.ToEntity();
if (!dto.Id.HasValue || dto.Id == 0)
{
//创建
await configurationDbContext.ApiResources.AddAsync(entity).ConfigureAwait(false);
}
else
{
entity.Id = dto.Id.Value;
var fromDbEntity = await ApiResources.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, ApiResource resource)
{
var savedResource = await IdentityDbContext.ApiResources
.Where(r => r.Name == id &&
!r.IsDeleted)
.SingleOrDefaultAsync();
resource.ToEntity(savedResource);
IdentityDbContext.ApiResources.Update(savedResource);
await IdentityDbContext.SaveChangesAsync();
await EventService.RaiseAsync(
new EntityUpdatedAuditEvent <ApiResource>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
resource.Name,
resource,
SerializationSettings));
}
public void missing_values_should_use_defaults()
{
var entity = new IdentityServer4.Fsql.Storage.Entities.ApiResource
{
Secrets = new System.Collections.Generic.List <IdentityServer4.Fsql.Storage.Entities.ApiResourceSecret>
{
new IdentityServer4.Fsql.Storage.Entities.ApiResourceSecret
{
}
}
};
var def = new ApiResource
{
ApiSecrets = { new Models.Secret("foo") }
};
var model = entity.ToModel();
model.ApiSecrets.First().Type.Should().Be(def.ApiSecrets.First().Type);
}
public IActionResult CreateApi(IdentityServer4.Models.ApiResource model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var entity = model.ToEntity();
entity.Scopes.Add(new IdentityServer4.EntityFramework.Entities.ApiScope
{
Description = entity.Description,
Name = entity.Name,
DisplayName = entity.DisplayName,
ShowInDiscoveryDocument = true,
Required = false,
Emphasize = false
});
var resources = _configContext.ApiResources.Add(entity);
_configContext.SaveChanges();
return(RedirectToAction("ApiResources"));
}
private static void SeedApiSecrets(IAdminStore <Entity.ApiSecret> apiSecretStore, IdentityServer4.Models.ApiResource resource)
{
foreach (var secret in resource.ApiSecrets)
{
apiSecretStore.CreateAsync(new Entity.ApiSecret
{
ApiId = resource.Name,
Expiration = secret.Expiration,
Description = secret.Description,
Id = Guid.NewGuid().ToString(),
Type = secret.Type,
Value = secret.Value
}).GetAwaiter().GetResult();
}
}
private static void SeedApiApiScopes(IAdminStore <Entity.ApiApiScope> apiApiScopeStore, IdentityServer4.Models.ApiResource resource)
{
foreach (var apiScope in resource.Scopes)
{
apiApiScopeStore.CreateAsync(new Entity.ApiApiScope
{
ApiId = resource.Name,
ApiScopeId = apiScope,
Id = Guid.NewGuid().ToString()
}).GetAwaiter().GetResult();
}
}
public ApiResourceUpdatedEvent(IdentityServer4.Models.ApiResource api)
{
ApiResource = api;
AggregateId = api.Name;
}
public RegisterApiResourceCommand(IdentityServer4.Models.ApiResource apiResource)
{
Resource = apiResource;
}
public UpdateApiResourceCommand(IdentityServer4.Models.ApiResource resource, string oldResourceName)
{
OldResourceName = oldResourceName;
Resource = resource;
}
public ApiResourceBuilder(IdentityServer4.Models.ApiResource resource)
{
}
public void UpdateResource(string id, ApiResource resource)
{
UpdateResourceAsync(id, resource).Wait();
}
public ApiResourceRegisteredEvent(IdentityServer4.Models.ApiResource name)
{
Resource = name;
AggregateId = name.Name;
}
private static void SeedApiClaims(IAdminStore <Entity.ApiClaim> apiClaimStore, IdentityServer4.Models.ApiResource resource)
{
foreach (var claim in resource.UserClaims)
{
apiClaimStore.CreateAsync(new Entity.ApiClaim
{
ApiId = resource.Name,
Id = Guid.NewGuid().ToString(),
Type = claim
}).GetAwaiter().GetResult();
}
}
private static void SeedApiProperties(IAdminStore <Entity.ApiProperty> apiPropertyStore, IdentityServer4.Models.ApiResource resource)
{
foreach (var property in resource.Properties)
{
apiPropertyStore.CreateAsync(new Entity.ApiProperty
{
ApiId = resource.Name,
Id = Guid.NewGuid().ToString(),
Key = property.Key,
Value = property.Value
}).GetAwaiter().GetResult();
}
}
public static ApiResource ToEntity(this IdentityServer4.Models.ApiResource resource)
{
return(resource == null ? null : Mapper.Map <ApiResource>(resource));
}
/// <summary>
/// Maps a model to an entity.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static Entities.ApiResource ToEntity(this IdentityServer4.Models.ApiResource model)
{
return(Mapper.Map <Entities.ApiResource>(model));
}
public void AddResource(ApiResource resource)
{
AddResourceAsync(resource).Wait();
}
