public ScopeViewModel(IdentityResource identity, bool check)
{
Name = identity.Name;
DisplayName = identity.DisplayName;
Description = identity.Description;
Emphasize = identity.Emphasize;
Required = identity.Required;
Checked = check || identity.Required;
}
public async Task <ApiResult <long> > Put([FromBody] IdentityResource value)
{
if (!ModelState.IsValid)
{
return(new ApiResult <long>(l,
BasicControllerEnums.UnprocessableEntity,
ModelErrors()));
}
using (var tran = configDb.Database.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
#region Update Entity
// 需要先更新value，否则更新如claims等属性会有并发问题
configDb.Update(value);
configDb.SaveChanges();
#endregion
#region Find Entity.Source
var source = await configDb.IdentityResources.Where(x => x.Id == value.Id)
.Include(x => x.UserClaims)
.AsNoTracking()
.FirstOrDefaultAsync();
#endregion
#region Update Entity.Claims
if (value.UserClaims != null && value.UserClaims.Count > 0)
{
#region delete
var EntityIDs = value.UserClaims.Select(x => x.Id).ToList();
if (EntityIDs.Count > 0)
{
var DeleteEntities = source.UserClaims.Where(x => !EntityIDs.Contains(x.Id)).Select(x => x.Id).ToArray();
if (DeleteEntities.Count() > 0)
{
//var sql = string.Format("DELETE IdentityClaims WHERE ID IN ({0})",
// string.Join(",", DeleteEntities));
configDb.Database.ExecuteSqlCommand($"DELETE IdentityClaims WHERE ID IN ({string.Join(",", DeleteEntities)})");
}
}
#endregion
#region update
var UpdateEntities = value.UserClaims.Where(x => x.Id > 0).ToList();
if (UpdateEntities.Count > 0)
{
UpdateEntities.ForEach(x =>
{
configDb.Database.ExecuteSqlCommand($"UPDATE IdentityClaims SET [Type]={x.Type} WHERE Id = {x.Id}");
});
}
#endregion
#region insert
var NewEntities = value.UserClaims.Where(x => x.Id == 0).ToList();
if (NewEntities.Count > 0)
{
NewEntities.ForEach(x =>
{
configDb.Database.ExecuteSqlCommand($"INSERT INTO IdentityClaims VALUES ({source.Id},{x.Type})");
});
}
#endregion
}
#endregion
tran.Commit();
}
catch (Exception ex)
{
tran.Rollback();
return(new ApiResult <long>(l,
BasicControllerEnums.ExpectationFailed,
ex.Message));
}
}
return(new ApiResult <long>(value.Id));
}
public static Models.IdentityResource ToModel(this IdentityResource resource)
{
return(resource == null ? null : Mapper.Map <Models.IdentityResource>(resource));
}
public async Task <int> AddIdentityResourceAsync(IdentityResource identityResource)
{
_dbContext.IdentityResources.Add(identityResource);
return(await AutoSaveChangesAsync());
}
public async Task Should_Retrieve_All_Resources_Including_Hidden_Ones(TestDatabase testDb)
{
var visibleIdentityResource = CreateTestIdentityResource("identity_visible");
var visibleApiResource = CreateTestApiResource("api_visible", new[] { Guid.NewGuid().ToString() });
var visibleApiScope = CreateTestApiScopeForResource("api_visible_scope", new[] { Guid.NewGuid().ToString() });
visibleApiResource.Scopes.Add(visibleApiScope.Name);
var hiddenIdentityResource = new IdentityResource()
{
Name = "identity_hidden",
ShowInDiscoveryDocument = false
};
var hiddenApiResource = new ApiResource()
{
Name = "api_hidden",
Scopes = { Guid.NewGuid().ToString() },
ShowInDiscoveryDocument = false
};
var hiddenApiScope = new ApiScope()
{
Name = "api_scope_hidden",
ShowInDiscoveryDocument = false
};
using (var session = testDb.OpenSession())
{
await session.SaveAsync(visibleIdentityResource.ToEntity());
await session.SaveAsync(visibleApiResource.ToEntity());
await session.SaveAsync(visibleApiScope.ToEntity());
await session.SaveAsync(hiddenIdentityResource.ToEntity());
await session.SaveAsync(hiddenApiResource.ToEntity());
await session.SaveAsync(hiddenApiScope.ToEntity());
await session.FlushAsync();
}
var loggerMock = new Mock <ILogger <ResourceStore> >();
Resources resources;
using (var session = testDb.OpenStatelessSession())
{
var store = new ResourceStore(session, loggerMock.Object);
resources = await store.GetAllResourcesAsync();
}
resources.Should().NotBeNull();
resources.IdentityResources.Should().NotBeEmpty();
resources.IdentityResources.Count.Should().Be(2);
resources.ApiResources.Should().NotBeEmpty();
resources.ApiResources.Count.Should().Be(2);
resources.ApiScopes.Should().NotBeEmpty();
resources.ApiScopes.Count.Should().Be(2);
resources.IdentityResources.Any(ir => ir.Name == visibleIdentityResource.Name).Should().BeTrue();
resources.IdentityResources.Any(ir => ir.Name == hiddenIdentityResource.Name).Should().BeTrue();
resources.ApiResources.Any(ar => ar.Name == visibleApiResource.Name).Should().BeTrue();
resources.ApiResources.Any(ar => ar.Name == hiddenApiResource.Name).Should().BeTrue();
resources.ApiScopes.Any(s => s.Name == visibleApiScope.Name).Should().BeTrue();
resources.ApiScopes.Any(s => s.Name == hiddenApiScope.Name).Should().BeTrue();
await CleanupTestDataAsync(testDb);
}
public void AddIdentityResource(IdentityResource identityResource)
{
_db.IdentityResources.Add(identityResource);
}
public static Faker <RegisterIdentityResourceCommand> GenerateRegisterCommand(IdentityResource id = null)
{
return(new Faker <RegisterIdentityResourceCommand>().CustomInstantiator(faker =>
new RegisterIdentityResourceCommand(IdentityResourceFaker.GenerateIdentiyResource().Generate())));
}
public static DomainModel.IdentityServer4.IdentityResource ToEntity(this IdentityResource model)
{
return(model == null ? null : Mapper.Map <DomainModel.IdentityServer4.IdentityResource>(model));
}
public static Faker <UpdateIdentityResourceCommand> GenerateUpdateCommand(IdentityResource id = null, string oldIdentityResourceName = null)
{
return(new Faker <UpdateIdentityResourceCommand>().CustomInstantiator(faker =>
new UpdateIdentityResourceCommand(IdentityResourceFaker.GenerateIdentiyResource().Generate(), oldIdentityResourceName ?? faker.Internet.DomainName())));
}
public async Task AddIdentityResourceAsync(IdentityResource resource)
{
await _configurationDbContext.AddIdentityResource(resource.ToEntity());
}
public async Task <IActionResult> Edit(long id, IdentityResource idResource)
{
var src = await _context.IdentityResources
.Include(x => x.UserClaims)
.AsNoTracking()
.SingleOrDefaultAsync(m => m.Id == id);
#region Claims
List <IdentityClaim>
Claims_Add = null,
Claims_Update = null,
Claims_Delete = null;
var claims = DeserializeFormData <IdentityClaim>("UserClaims");
if (claims.Count > 0)
{
Claims_Add = claims.Where(x => x.Id == 0).ToList();
Claims_Update = claims.Where(x => x.Id > 0).ToList();
var Ids = claims.Select(x => x.Id).ToList();
if (Ids.Count > 0)
{
Claims_Delete = src.UserClaims.Where(x => !Ids.Contains(x.Id)).ToList();
}
}
#endregion
#region Submit to database
if (ModelState.IsValid)
{
try
{
_context.Update(idResource);
await _context.SaveChangesAsync();
#region Claims
if (Claims_Add.Count > 0)
{
Claims_Add.ForEach(x => x.IdentityResource = idResource);
_context.AddRange(Claims_Add);
await _context.SaveChangesAsync();
}
if (Claims_Update.Count > 0)
{
Claims_Update.ForEach(x => x.IdentityResource = idResource);
_context.UpdateRange(Claims_Update);
await _context.SaveChangesAsync();
}
if (Claims_Delete.Count > 0)
{
Claims_Delete.ForEach(x => x.IdentityResource = null);
_context.RemoveRange(Claims_Delete);
await _context.SaveChangesAsync();
}
#endregion
}
catch (DbUpdateConcurrencyException)
{
if (!Exists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
#endregion
return(View(idResource));
}
public async Task AddIdentityResource(IdentityResource entity)
{
await DocumentClient.CreateDocumentAsync(_identityResourcesUri, entity);
}
public static IdentityResourceDTO ToDTO(this IdentityResource entity)
{
return(entity == null ? null : Mapper.Map <IdentityResourceDTO>(entity));
}
