public void Properties_Map()
{
var model = new ApiResource()
{
Description = "description",
DisplayName = "displayname",
Name = "foo",
Scopes = { new Scope("foo1"), new Scope("foo2") },
Enabled = false
};
var mappedEntity = model.ToEntity();
mappedEntity.Scopes.Count.Should().Be(2);
var foo1 = mappedEntity.Scopes.FirstOrDefault(x => x.Name == "foo1");
foo1.Should().NotBeNull();
var foo2 = mappedEntity.Scopes.FirstOrDefault(x => x.Name == "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 async Task StoreAsync(Model.ApiResource model)
{
var entity = model.ToEntity();
try
{
// Remove old scope indexes
var existingEntity = await StorageContext.GetEntityBlobAsync <Entities.ApiResource>(entity.Name, StorageContext.ApiResourceBlobContainer);
if (existingEntity != null &&
existingEntity.Scopes != null &&
existingEntity.Scopes.Count > 0)
{
//Remove old scope indexes
var deleteIndexes = existingEntity?.Scopes?.Select(s => s.Name).Distinct().Select(i => GenerateResourceIndexEntity(entity.Name, i)).ToList();
await DeleteScopeIndexesAsync(deleteIndexes, StorageContext.ApiResourceTable);
}
// Add new scope indexes
var newIndexes = entity?.Scopes?.Select(s => s.Name).Distinct().Select(i => GenerateResourceIndexEntity(entity.Name, i)).ToList();
await CreateScopeIndexesAsync(newIndexes, StorageContext.ApiResourceTable);
await StorageContext.SaveBlobAsync(entity.Name, JsonConvert.SerializeObject(entity), StorageContext.ApiResourceBlobContainer);
}
catch (AggregateException agg)
{
ExceptionHelper.LogStorageExceptions(agg, (tblEx) =>
{
_logger.LogWarning("exception updating {apiName} api resource in table storage: {error}", model.Name, tblEx.Message);
}, (blobEx) =>
{
_logger.LogWarning("exception updating {apiName} api resource in blob storage: {error}", model.Name, blobEx.Message);
});
throw;
}
}
private void InitializeIdentityServerDatabase(IApplicationBuilder app)
{
using (var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope()) {
serviceScope.ServiceProvider.GetRequiredService <PersistedGrantDbContext>().Database.Migrate();
var context = serviceScope.ServiceProvider.GetRequiredService <ConfigurationDbContext>();
context.Database.Migrate();
if (!context.Clients.Any())
{
var client1 = new IdentityServer4.Models.Client {
ClientId = "demo.client1",
AllowedGrantTypes = GrantTypes.ClientCredentials,
ClientSecrets =
{
new IdentityServer4.Models.Secret("secret".Sha256())
},
AllowedScopes = { "demo.api1" },
ClientName = "Demo Client1"
};
context.Clients.Add(client1.ToEntity());
context.SaveChanges();
}
if (!context.ApiResources.Any())
{
var api1 = new IdentityServer4.Models.ApiResource {
Name = "demo.api1",
DisplayName = "demo api",
Description = "this is just for demo"
};
context.ApiResources.Add(api1.ToEntity());
context.SaveChanges();
}
}
}
public void Update(ApiResource obj)
{
var apiResource = DbSet.FirstOrDefault(w => w.Name == obj.Name);
var newOne = obj.ToEntity();
newOne.Id = apiResource.Id;
DbSet.Update(newOne);
}
public async Task StoreAsync(Model.ApiResource model)
{
var entity = model.ToEntity();
try
{
// Remove old scope indexes
var existingEntity = await StorageContext.GetEntityBlobAsync <Entities.ApiResource>(entity.Name, StorageContext.ApiResourceBlobContainer).ConfigureAwait(false);
if (existingEntity != null &&
existingEntity.Scopes != null &&
existingEntity.Scopes.Count > 0)
{
//Remove old scope indexes
var deleteIndexes = existingEntity?.Scopes?.Select(s => s.Name).Distinct().Select(i => GenerateResourceIndexEntity(entity.Name, i));
await DeleteScopeIndexesAsync(deleteIndexes, StorageContext.ApiResourceTable).ConfigureAwait(false);
}
// Add new scope indexes
var newIndexes = entity?.Scopes?.Select(s => s.Name).Distinct().Select(i => GenerateResourceIndexEntity(entity.Name, i));
await CreateScopeIndexesAsync(newIndexes, StorageContext.ApiResourceTable).ConfigureAwait(false);
await StorageContext.SaveBlobWithHashedKeyAsync(entity.Name,
JsonConvert.SerializeObject(entity), StorageContext.ApiResourceBlobContainer)
.ConfigureAwait(false);
//Create ApiScopes that don't exist
List <string> entityScopes = entity.Scopes?.Select(s => s.Name).ToList();
if (entityScopes.Count > 0)
{
List <Model.ApiScope> existingApiScopes = (await FindApiScopesByNameAsync(entityScopes).ConfigureAwait(false)).ToList();
foreach (string entityScope in entityScopes.Where(w => !String.IsNullOrEmpty(w)).Distinct())
{
if (!existingApiScopes.Any(a => entityScope.Equals(a.Name, StringComparison.Ordinal)))
{
await StoreAsync(new Model.ApiScope()
{
Name = entityScope
}).ConfigureAwait(false);
}
}
}
var entities = await GetAllApiResourceEntitiesAsync().ConfigureAwait(false);
entities = entities.Where(e => entity.Name != e.Name).Concat(new Entities.ApiResource[] { entity });
await UpdateApiResourceCacheFileAsync(entities).ConfigureAwait(false);
}
catch (AggregateException agg)
{
ExceptionHelper.LogStorageExceptions(agg, (tblEx) =>
{
_logger.LogWarning("exception updating {apiName} api resource in table storage: {error}", model.Name, tblEx.Message);
}, (blobEx) =>
{
_logger.LogWarning("exception updating {apiName} api resource in blob storage: {error}", model.Name, blobEx.Message);
});
throw;
}
}
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 <bool> AddApiResource(IdentityServer4.Models.ApiResource resource)
{
bool Result = false;
await Context.ApiResources.AddAsync(resource.ToEntity());
Result = await Context.SaveChangesAsync() > 0;
return(Result);
}
private static void AddTestEntitiesToSql(IS4.Client client, IS4.ApiResource apiResource)
{
using (var identityContext = IdentityDbContext)
{
identityContext.Database.ExecuteSqlCommand(DeleteDataSql);
identityContext.ApiResources.Add(apiResource.ToEntity());
identityContext.Clients.Add(client.ToEntity());
identityContext.SaveChanges();
}
}
public async Task UpdateWithChildrens(string oldName, ApiResource irs)
{
var apiDb = await DbSet
.Include(s => s.UserClaims)
.Where(x => x.Name == oldName).FirstAsync();
var newIr = irs.ToEntity();
newIr.Id = apiDb.Id;
newIr.ShallowCopyTo(apiDb);
}
public async Task <MessageModel <string> > SaveData(ApiResourceDto request)
{
if (request != null && request.Id == 0)
{
IdentityServer4.Models.ApiResource apiResource = new IdentityServer4.Models.ApiResource()
{
Name = request?.Name,
DisplayName = request?.DisplayName,
Description = request?.Description,
Enabled = true,
UserClaims = request?.UserClaims?.Split(","),
};
var result = (await _configurationDbContext.ApiResources.AddAsync(apiResource.ToEntity()));
await _configurationDbContext.SaveChangesAsync();
}
if (request != null && request.Id > 0)
{
var modelEF = (await _configurationDbContext.ApiResources
.Include(d => d.UserClaims)
.ToListAsync()).FirstOrDefault(d => d.Id == request.Id);
modelEF.Name = request?.Name;
modelEF.DisplayName = request?.DisplayName;
modelEF.Description = request?.Description;
var apiResourceClaim = new List <IdentityServer4.EntityFramework.Entities.ApiResourceClaim>();
if (!string.IsNullOrEmpty(request?.UserClaims))
{
request?.UserClaims.Split(",").Where(s => s != "" && s != null).ToList().ForEach(s =>
{
apiResourceClaim.Add(new IdentityServer4.EntityFramework.Entities.ApiResourceClaim()
{
ApiResource = modelEF,
ApiResourceId = modelEF.Id,
Type = s
});
});
modelEF.UserClaims = apiResourceClaim;
}
var result = (_configurationDbContext.ApiResources.Update(modelEF));
await _configurationDbContext.SaveChangesAsync();
}
return(new MessageModel <string>()
{
success = true,
msg = "添加成功",
});
}
public async Task <IActionResult> Put(string resourceName, [FromBody] IroncladResource model)
{
if (string.Equals(resourceName, "auth_api", StringComparison.OrdinalIgnoreCase))
{
return(this.BadRequest(new { Message = $"Cannot modify the authorization console web API" }));
}
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 = $"API 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,
Scopes = model.ApiScopes.Select(scope => new Scope(scope.Name, scope.UserClaims)).ToList(),
};
// NOTE (Cameron): If the secret is updated we want to add the new secret...
if (!string.IsNullOrEmpty(model.ApiSecret))
{
resource.ApiSecrets = new List <Secret> {
new Secret(model.ApiSecret.Sha256())
};
}
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.Scopes = entity.Scopes ?? document.Scopes;
document.Enabled = model.Enabled ?? document.Enabled;
if (!string.IsNullOrEmpty(model.ApiSecret))
{
document.Secrets.Add(entity.Secrets.First());
}
session.Update(document);
await session.SaveChangesAsync();
}
return(this.Ok());
}
public IActionResult AddApiResource(ApiResourceViewModel apiResourceViewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var apiResource = new ApiResourceModel(apiResourceViewModel.Name, apiResourceViewModel.DisplayName);
_configurationDbContext.ApiResources.Add(apiResource.ToEntity());
_configurationDbContext.SaveChanges();
_trackTelemetry.TrackEvent(EventName.AddApiResource, EventType.Action, EventStatus.Success);
return(RedirectToAction(nameof(Index)));
}
public static void SeedConfiguration(IConfigurationDbContext context)
{
Log.Information("Seeding Identity Server configuration");
if (!context.Clients.Any())
{
context.Clients.Add(new Client
{
ClientId = "spa",
ClientName = "SPA Client",
ClientUri = "http://localhost:4200",
AllowedGrantTypes = GrantTypes.Implicit,
AllowAccessTokensViaBrowser = true,
RequireConsent = false,
RedirectUris =
{
"http://localhost:4200",
"http://localhost:4200/auth-callback",
"http://localhost:4200/silent.html",
},
PostLogoutRedirectUris = { "http://localhost:4200" },
AllowedCorsOrigins = { "http://localhost:4200" },
AllowedScopes = { "openid", "profile", "api" }
}.ToEntity());
context.SaveChanges();
}
if (!context.IdentityResources.Any())
{
context.IdentityResources.AddRange(new IdentityResource[]
{
new IdentityResources.OpenId(),
new IdentityResources.Profile()
}.Select(r => r.ToEntity()));
context.SaveChanges();
}
if (!context.ApiResources.Any())
{
var apiResource = new ApiResource("api", "Application api");
context.ApiResources.Add(apiResource.ToEntity());
context.SaveChanges();
}
}
public async Task <IActionResult> Post([FromBody] IroncladResource model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(this.BadRequest(new { Message = $"Cannot create an API resource without a name" }));
}
if (string.IsNullOrEmpty(model.ApiSecret))
{
return(this.BadRequest(new { Message = $"Cannot create an API resource without a secret" }));
}
var resource = new IdentityServerResource(model.Name, model.DisplayName)
{
ApiSecrets = new List <Secret> {
new Secret(model.ApiSecret.Sha256())
},
};
// optional properties
resource.UserClaims = model.UserClaims ?? resource.UserClaims;
resource.Scopes = model.ApiScopes?.Select(item => new Scope(item.Name, item.UserClaims)).ToList() ?? resource.Scopes;
resource.Enabled = model.Enabled ?? resource.Enabled;
using (var session = this.store.LightweightSession())
{
if (session.Query <PostgresResource>().Any(document => document.Name == model.Name))
{
return(this.StatusCode((int)HttpStatusCode.Conflict, new { Message = "API resource already exists" }));
}
session.Insert(resource.ToEntity());
await session.SaveChangesAsync();
}
return(this.Created(new Uri(this.HttpContext.GetIdentityServerRelativeUrl("~/api/apiresources/" + model.Name)), null));
}
public void Add(ApiResource obj)
{
DbSet.Add(obj.ToEntity());
}
public static void ConfigurationDbContextSeed(this ModelBuilder modelBuilder)
{
var clientGrantTypeEntity = new ClientGrantType
{
Id = -1,
GrantType = GrantType.ResourceOwnerPassword,
ClientId = -1,
};
var clientScopes = new[]
{
new ClientScope
{
ClientId = -1,
Id = -1,
Scope = "record-keep-api"
},
new ClientScope
{
ClientId = -1,
Id = -2,
Scope = IdentityServerConstants.StandardScopes.OpenId
},
new ClientScope
{
ClientId = -1,
Id = -3,
Scope = IdentityServerConstants.StandardScopes.Profile
}
};
var client = new Client
{
ClientId = "record-keep",
AccessTokenType = AccessTokenType.Jwt,
RequireClientSecret = false,
AllowOfflineAccess = false,
AllowAccessTokensViaBrowser = true
};
var clientEntity = client.ToEntity();
clientEntity.Id = -1;
var apiResourceClaimEntity = new ApiResourceClaim
{
Id = -1,
ApiResourceId = -1,
Type = JwtClaimTypes.Name
};
var apiResourceScopesEntity = new ApiScope
{
Name = "record-keep-api",
Id = -1,
DisplayName = "Record Keep API",
ApiResourceId = -1,
};
var apiResource = new ApiResource
{
Name = "record-keep-api",
DisplayName = "Record Keep API"
};
var apiResourceEntity = apiResource.ToEntity();
apiResourceEntity.Id = -1;
var openIdIdentity = new IdentityResources.OpenId().ToEntity();
var profileIdentity = new IdentityResources.Profile().ToEntity();
openIdIdentity.Id = -1;
profileIdentity.Id = -2;
var identityClaimOpenId = new IdentityClaim
{
Id = -1,
Type = JwtClaimTypes.Subject,
IdentityResourceId = -1
};
var identityClaims = new List <IdentityClaim>
{
identityClaimOpenId
};
var index = -2;
foreach (var claims in profileIdentity.UserClaims)
{
identityClaims.Add(new IdentityClaim
{
Id = index,
Type = claims.Type,
IdentityResourceId = -2,
});
index--;
}
openIdIdentity.UserClaims = new List <IdentityClaim>();
profileIdentity.UserClaims = new List <IdentityClaim>();
modelBuilder.Entity <ClientGrantType>().HasData(clientGrantTypeEntity);
modelBuilder.Entity <ClientScope>().HasData(clientScopes);
modelBuilder.Entity <IdentityServer4.EntityFramework.Entities.Client>().HasData(clientEntity);
modelBuilder.Entity <ApiResourceClaim>().HasData(apiResourceClaimEntity);
modelBuilder.Entity <ApiScope>().HasData(apiResourceScopesEntity);
modelBuilder.Entity <IdentityServer4.EntityFramework.Entities.ApiResource>().HasData(apiResourceEntity);
modelBuilder.Entity <IdentityResource>().HasData(openIdIdentity, profileIdentity);
modelBuilder.Entity <IdentityClaim>().HasData(identityClaims);
}