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); }