public async Task Store_Grants_And_Remove_them()
{
for (int i = 0; i < 5; i++)
{
var key = Guid.NewGuid().ToString("N");
var grant = new IdentityServer4.Models.PersistedGrant
{
Key = key,
Expiration = DateTime.UtcNow.AddDays(1),
Type = "test",
ClientId = $"client{i}",
SubjectId = "sub1",
SessionId = "session1",
CreationTime = DateTime.UtcNow,
Description = "des",
Data = "bla bla",
ConsumedTime = DateTime.UtcNow
};
await persistedGrantStore.StoreAsync(grant);
}
await persistedGrantStore.RemoveAllAsync(new PersistedGrantFilter
{
SubjectId = "sub1"
});
var items = await persistedGrantStore.GetAllAsync(new PersistedGrantFilter
{
SubjectId = "sub1"
});
items.Should().BeEmpty();
}
public async Task Store_Grant_And_Remove_It()
{
var key = Guid.NewGuid().ToString("N");
var grant = new IdentityServer4.Models.PersistedGrant
{
Key = key,
Expiration = DateTime.UtcNow.AddDays(1),
Type = "test",
ClientId = "client1",
SubjectId = "sub1",
SessionId = "session1",
CreationTime = DateTime.UtcNow,
Description = "des",
Data = "bla bla",
ConsumedTime = DateTime.UtcNow
};
await persistedGrantStore.StoreAsync(grant);
await persistedGrantStore.RemoveAsync(key);
var item = await persistedGrantStore.GetAsync(key);
item.Should().BeNull();
}
/// <summary>
/// Stores the asynchronous.
/// </summary>
/// <param name="token">The token.</param>
/// <returns></returns>
public Task StoreAsync(IdentityServer4.Models.PersistedGrant token)
{
var existing = _persistedGrants.SingleOrDefault(x => x.Key == token.Key);
if (existing == null)
{
_logger.LogDebug("{persistedGrantKey} not found in database", token.Key);
var persistedGrant = token.ToEntity();
_persistedGrants.Add(persistedGrant);
}
else
{
_logger.LogDebug("{persistedGrantKey} found in database", token.Key);
token.UpdateEntity(existing);
}
try
{
_uow.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
_logger.LogWarning("exception updating {persistedGrantKey} persisted grant in database: {error}", token.Key, ex.Message);
}
return(Task.FromResult(0));
}
public async Task StoreAsync(PersistedGrant token)
{
var persistedGrant = token.ToEntity();
Logger.LogDebug("storing persisted grant: {persistedGrant}", persistedGrant);
var table = await InitTableAsync();
var operation = TableOperation.InsertOrReplace(persistedGrant);
var result = await table.ExecuteAsync(operation);
Logger.LogDebug("stored {persistedGrantKey} with result {result}", token.Key, result.HttpStatusCode);
}
public void PersistedGrantModelToEntityConfigurationIsValid()
{
var model = new IdentityServer4.Models.PersistedGrant();
// TODO: set references
var mappedEntity = model.ToEntity();
var mappedModel = mappedEntity.ToModel();
Assert.NotNull(mappedModel);
Assert.NotNull(mappedEntity);
PersistedGrantMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
}
public virtual async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var entity = _objectMapper.Map <IdentityServer4.Models.PersistedGrant, PersistedGrant>(grant);
var existing = await _persistentGrantRepository.FindByKeyAsync(grant.Key);
if (existing == null)
{
entity.Id = _guidGenerator.Create();
await _persistentGrantRepository.InsertAsync(entity);
}
else
{
await _persistentGrantRepository.UpdateAsync(entity);
}
}
public static PersistedGrant ToPersistedGrantModel(IdentityServer4.Models.PersistedGrant grant)
{
return(new PersistedGrant
{
Key = grant.Key,
ClientId = grant.ClientId,
SessionId = grant.SessionId,
SubjectId = grant.SubjectId,
Data = grant.Data,
Type = grant.Type,
Description = grant.Description,
Expiration = grant.Expiration.HasValue ? new Nullable <int>(AWSSDKUtils.ConvertToUnixEpochSeconds(grant.Expiration.Value)) : null,
CreationTime = grant.CreationTime,
ConsumedTime = grant.ConsumedTime
});
}
public virtual async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var entity = await PersistentGrantRepository.FindByKeyAsync(grant.Key);
if (entity == null)
{
entity = ObjectMapper.Map <IdentityServer4.Models.PersistedGrant, PersistedGrant>(grant);
EntityHelper.TrySetId(entity, () => GuidGenerator.Create());
await PersistentGrantRepository.InsertAsync(entity);
}
else
{
ObjectMapper.Map(grant, entity);
await PersistentGrantRepository.UpdateAsync(entity);
}
}
public async Task <IdentityServer4.Models.PersistedGrant> GetAsync(string key)
{
var existsGrant = await _repository.GetByKeyAsync(key);
var grant = new IdentityServer4.Models.PersistedGrant();
if (existsGrant != null)
{
grant.Key = existsGrant.Key;
grant.Type = existsGrant.Type;
grant.SubjectId = existsGrant.SubjectId;
grant.SessionId = existsGrant.SessionId;
grant.ClientId = existsGrant.ClientId;
grant.Description = existsGrant.Description;
grant.CreationTime = existsGrant.CreationTime;
grant.Expiration = existsGrant.Expiration;
grant.ConsumedTime = existsGrant.ConsumedTime;
grant.Data = existsGrant.Data;
}
return(grant);
}
public async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var existingGrant = _identityDbContext.PersistedGrants.SingleOrDefault(pg => pg.Key == grant.Key);
if (existingGrant == null)
{
var persistedGrantEntity = grant.ToEntity();
_identityDbContext.PersistedGrants.Add(persistedGrantEntity);
}
else
{
grant.ToEntity(existingGrant);
}
try
{
await _identityDbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
_logger.Warning("Exception updating {grantKey}. Error: {error}", grant.Key, ex.Message);
}
}
public async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var existingGrant = IdentityDbContext.PersistedGrants.SingleOrDefault(pg => pg.Key == grant.Key);
Event evt;
if (existingGrant == null)
{
var persistedGrantEntity = grant.ToEntity();
IdentityDbContext.PersistedGrants.Add(persistedGrantEntity);
evt = new EntityCreatedAuditEvent <PersistedGrant>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
persistedGrantEntity.Key,
persistedGrantEntity,
SerializationSettings);
}
else
{
grant.ToEntity(existingGrant);
evt = new EntityUpdatedAuditEvent <PersistedGrant>(
UserResolverService.Username,
UserResolverService.ClientId,
UserResolverService.Subject,
existingGrant.Key,
existingGrant,
SerializationSettings);
}
try
{
await IdentityDbContext.SaveChangesAsync();
await EventService.RaiseAsync(evt);
}
catch (DbUpdateConcurrencyException ex)
{
_logger.Warning("Exception updating {grantKey}. Error: {error}", grant.Key, ex.Message);
}
}
public async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var existsGrant = await _repository.GetByKeyAsync(grant.Key);
var persistedGrant = new Core.Entities.PersistedGrant
{
Key = grant.Key,
Type = grant.Type,
SubjectId = grant.SubjectId,
SessionId = grant.SessionId,
ClientId = grant.ClientId,
Description = grant.Description,
CreationTime = grant.CreationTime,
Expiration = grant.Expiration,
ConsumedTime = grant.ConsumedTime,
Data = grant.Data
};
try
{
if (existsGrant == null)
{
Log.Debug("{persistedGrantKey} not found in database", grant.Key);
await _repository.InsertAsync(persistedGrant);
}
else
{
Log.Debug("{persistedGrantKey} found in database", grant.Key);
await _repository.UpdateAsync(persistedGrant);
}
}
catch (Exception ex)
{
Log.Error($"PersistedGrantStore >> StoreAsync Error: {ex.Message}");
}
}
public async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
{
var model = grant.MapTo <PersistedGrant>();
await _persistedGrantRepository.InsertAsync(model);
}
internal static PersistedGrant ToEntity(this IdentityServer4.Models.PersistedGrant token)
{
return(token == null ? null : Mapper.Map <PersistedGrant>(token));
}
public static void UpdateEntity(this IdentityServer4.Models.PersistedGrant token, PersistedGrant target)
{
Mapper.Map(token, target);
}
/// <summary>
/// Maps a model to an existing entity instance.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="entity">The entity.</param>
public static void ToEntity(this PersistedGrant model, Entities.PersistedGrant entity)
{
Mapper.Map(model, entity);
}
/// <summary>
/// Maps a model to an entity.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static Entities.PersistedGrant ToEntity(this PersistedGrant model)
{
return(model == null ? null : Mapper.Map <Entities.PersistedGrant>(model));
}
/// <summary>
/// Maps a model to an entity.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static PersistedGrant ToEntity(this IdentityServer4.Models.PersistedGrant model)
{
return(model == null ? null : Mapper.Map <PersistedGrant>(model));
}
/// <summary>
/// Updates an entity from a model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="entity">The entity.</param>
public static void UpdateEntity(this IdentityServer4.Models.PersistedGrant model, PersistedGrant entity)
{
Mapper.Map(model, entity);
}
