public async Task Should_Not_Remove_Still_Valid_Grant(TestDatabase testDb) { var validGrant = new Models.PersistedGrant { Key = Guid.NewGuid().ToString(), ClientId = "test-app", Type = "reference", SubjectId = "42", Expiration = DateTime.UtcNow.AddDays(3), Data = "testdata" }; using (var session = testDb.OpenSession()) { await session.SaveAsync(validGrant.ToEntity()); await session.FlushAsync(); } await CreateTokenCleanupServiceSut(testDb, TestOperationalStoreOptions).RemoveExpiredGrantsAsync(); using (var session = testDb.OpenSession()) { (await session.GetAsync <PersistedGrant>(validGrant.Key)).Should().NotBeNull(); } await CleanupTestDataAsync(testDb); }
public async Task StoreAsync(Models.PersistedGrant grant) { try { if (grant == null) { throw new ArgumentNullException("grant cant be null"); } var ncachePersistantGrant = grant.ToEntity(); await _repository.AddAsync(ncachePersistantGrant); if (_isDebugLoggingEnabled) { _logger.LogDebug("Grant {key} stored", grant.Key); } } catch (Exception ex) { if (_isErrorLoggingEnabled) { _logger.LogError( ex, $"something went wrong with StoreAsync for " + $"grant key {grant.Key}"); } throw; } }
public void Map() { var model = new Models.PersistedGrant(); var entity = PersistedGrantMappers.ToEntity(model); model = PersistedGrantMappers.ToModel(entity); // Assert Assert.IsNotNull(entity); Assert.IsNotNull(model); }
private PersistedGrant Map(Models.PersistedGrant grant) { return(new PersistedGrant { ClientId = grant.ClientId, CreationTime = grant.CreationTime, Data = grant.Data, Expiration = grant.Expiration, Key = grant.Key, SubjectId = grant.SubjectId, Type = grant.Type }); }
public async Task StoreAsync(Models.PersistedGrant grant) { using (var connection = new SqlConnection(_dapperStoreOptions.DbConnectionString)) { await RemoveAsync(grant.Key); var sql = $@" INSERT INTO PersistedGrant(K, Type, SubjectId, ClientId, CreationTime, Expiration, Data) VALUES(@Key, @Type, @SubjectId, @ClientId, @CreationTime, @Expiration, @Data); "; await connection.ExecuteAsync(sql, new { grant.Key, grant.Type, grant.SubjectId, grant.ClientId, grant.CreationTime, grant.Expiration, grant.Data }); } }
public void ToEntity_MapsKeyWithDefaultHash() { const string key = "some-key"; var persistedGrant = new Models.PersistedGrant() { Key = key }; var entity = persistedGrant.ToEntity(); var expectedKeyValue = CryptographyHelper.CreateHash(key); Assert.Equal(expectedKeyValue, entity.Key); }
private Models.PersistedGrant Map(Models.PersistedGrant existing, PersistedGrant grant) { if (existing == null) { existing = new Models.PersistedGrant(); } existing.ClientId = grant.ClientId; existing.CreationTime = grant.CreationTime; existing.Data = grant.Data; existing.Expiration = grant.Expiration; existing.Key = grant.Key; existing.SubjectId = grant.SubjectId; existing.Type = grant.Type; return(existing); }
public void Map() { // Arrange var mapperConfiguration = new MapperConfiguration(expression => { expression.AddProfile <PersistedGrantMapperProfile>(); }); var mapper = new AutoMapperWrapper(new Mapper(mapperConfiguration)); var model = new Models.PersistedGrant(); // Act var entity = mapper.Map <Entities.PersistedGrant>(model); model = mapper.Map <Models.PersistedGrant>(entity); // Assert Assert.NotNull(entity); Assert.NotNull(model); mapperConfiguration.AssertConfigurationIsValid(); }
public static Entities.PersistedGrant ToEntity(this Models.PersistedGrant model) { return(model == null ? null : Mapper.Map <Entities.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 Models.PersistedGrant model, Entities.PersistedGrant entity) { Mapper.Map(model, entity); }
public static void UpdateEntity(this Models.PersistedGrant token, Documents.PersistedGrant target) { Mapper.Map(token, target); }
public static Documents.PersistedGrant ToDocument(this Models.PersistedGrant token) { return(token == null ? null : Mapper.Map <Documents.PersistedGrant>(token)); }
public async Task StoreAsync(Models.PersistedGrant grant) { try { if (grant == null) { throw new ArgumentNullException( nameof(grant), "grant cant be null"); } await _inner.StoreAsync(grant); var cacheKey = Utilities.CreateCachedPersistedGrantStoreKey(grant); var item = new CacheItem(grant.ToEntity()) { Tags = Utilities.CreateCachePersistedGrantStoreTags(grant), Expiration = Utilities.DetermineCachePersistedGrantStoreExpiration( grant, _handle.options) }; var result = await _setFallBackPolicy .ExecuteAsync(async() => { await _handle.cache.InsertAsync(cacheKey, item) .ConfigureAwait(false); return(true); }).ConfigureAwait(false); if (result) { if (_debugLoggingEnabled) { _logger.LogDebug( $"Persisted grant with key {grant.Key} " + $"successfully stored"); } } else { if (_errorLoggingEnabled) { _logger.LogError( $"Caching problems with persistant store cache"); } } } catch (Exception ex) { if (_errorLoggingEnabled) { _logger.LogError( ex, $"something went wrong with StoreAsync " + $"for grant key {grant.Key}"); } throw; } }
public async Task <Models.PersistedGrant> GetAsync(string key) { try { if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentNullException( "key cant be null or white space", nameof(key)); } var cacheKey = Utilities.CreateCachedPersistedGrantStoreKey(key); var cachedPersistedGrant = await _getPersistedGrantPolicy .ExecuteAsync(async() => { return(await Task.Run(() => _handle.cache.Get <PersistedGrant>(cacheKey) ).ConfigureAwait(false)); }).ConfigureAwait(false); Models.PersistedGrant persistedGrant = null; if (cachedPersistedGrant == null) { persistedGrant = await _inner.GetAsync(key); if (persistedGrant != null) { if (_debugLoggingEnabled) { _logger.LogDebug( $"Cache Miss: Persisted grant {key}" + $"acquired from IPersistedGrantStore"); } var item = new CacheItem(persistedGrant.ToEntity()) { Tags = Utilities.CreateCachePersistedGrantStoreTags( persistedGrant), Expiration = Utilities.DetermineCachePersistedGrantStoreExpiration ( persistedGrant, _handle.options) }; bool result = await _setFallBackPolicy .ExecuteAsync(async() => { await _handle.cache.InsertAsync(cacheKey, item) .ConfigureAwait(false); return(true); }).ConfigureAwait(false); if (_errorLoggingEnabled && !result) { _logger.LogError( $"Caching problems with persistant store cache"); } } else { if (_debugLoggingEnabled) { _logger.LogDebug( $"Persisted grant {key} not found"); } } } else { persistedGrant = cachedPersistedGrant.ToModel(); if (_debugLoggingEnabled) { _logger.LogDebug( $"Cache Hit: Persisted grant {key}" + $"acquired from NCache"); } } return(persistedGrant); } catch (Exception ex) { if (_errorLoggingEnabled) { _logger.LogError( ex, $"something went wrong with GetAsync for {key}"); } throw; } }