public virtual async Task RemoveAllAsync(PersistedGrantFilter filter)
{
await PersistentGrantRepository.DeleteAsync(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
}
public Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
throw new NotSupportedException();
}
protected virtual string GetSetKey(PersistedGrantFilter filter) => (!filter.ClientId.IsNullOrEmpty(), !filter.SessionId.IsNullOrEmpty(), !filter.Type.IsNullOrEmpty()) switch
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
_dbRepository.Delete<PersistedGrant>(i => i.SubjectId == filter.SubjectId && i.ClientId == filter.ClientId && i.Type == filter.Type);
return Task.FromResult(0);
}
public async Task RemoveAllAsync(PersistedGrantFilter filter)
{
await using var db = dbFactory();
await InnerRemoveList(db.PersistedGrants.Filter(filter), db);
}
public async Task <IEnumerable <IdentityServer4.Models.PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
Validate(filter);
var list = await _persistedGrantRepository.TrackEntities.Where(x => (string.IsNullOrWhiteSpace(filter.SubjectId) || x.SubjectId == filter.SubjectId) &&
(string.IsNullOrWhiteSpace(filter.ClientId) || x.ClientId == filter.ClientId) &&
(string.IsNullOrWhiteSpace(filter.Type) || x.Type == filter.Type)).ToListAsync();
var dto = list.Select(x => x.MapTo <IdentityServer4.Models.PersistedGrant>());
return(dto);
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
return(Collection.DeleteManyAsync(CreateFilter(filter)));
}
/// <summary>
/// Removes all grants based on the filter.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns>A task.</returns>
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
this._repository.Delete <PersistedGrantFilter>(x => true);
return(Task.FromResult(0));
}
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
// TODO. Cover all the bases. It currently looks like the default service is only asking for subject id
return(await GetAllAsync(filter.SubjectId));
}
public Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
var result = _dbRepository.Where <PersistedGrant>(persistedGrant => PersistedGrantfilter(filter, persistedGrant));
return(Task.FromResult(result.AsEnumerable()));
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
_dbRepository.Delete <PersistedGrant>(i => PersistedGrantfilter(filter, i));
return(Task.FromResult(0));
}
public async Task RemoveAllAsync(PersistedGrantFilter filter)
{
await _grantRepository.DeleteManyAsync(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
return(_innerPersistedGrantStore.RemoveAllAsync(filter));
}
public Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
return(_innerPersistedGrantStore.GetAllAsync(filter));
}
public async Task RemoveAllAsync(PersistedGrantFilter filter)
{
await _persistedGrantRepository.DeleteAsync(FilterPersistedGrant(filter));
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
_repository.RemoveAll(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
return(Task.CompletedTask);
}
protected virtual Expression <Func <PersistedGrantEntity, bool> > FilterPersistedGrant(PersistedGrantFilter filter)
{
var predicate = PredicateBuilder.New <PersistedGrantEntity>();
if (!filter.SubjectId.IsNullOrWhiteSpace())
{
predicate = predicate.And(x => x.SubjectId == filter.SubjectId);
}
if (!filter.SessionId.IsNullOrWhiteSpace())
{
predicate = predicate.And(x => x.SessionId == filter.SessionId);
}
if (!filter.ClientId.IsNullOrWhiteSpace())
{
predicate = predicate.And(x => x.ClientId == filter.ClientId);
}
if (!filter.Type.IsNullOrWhiteSpace())
{
predicate = predicate.And(x => x.Type == filter.Type);
}
return(predicate);
}
private static IQuery ApplyPersistedGrantFilter(ISession session, string hqlStatement, PersistedGrantFilter filter)
{
var hqlQuery = session.CreateQuery(hqlStatement);
if (!string.IsNullOrWhiteSpace(filter.SubjectId))
{
hqlQuery.SetString("subjectId", filter.SubjectId);
}
if (!string.IsNullOrWhiteSpace(filter.SessionId))
{
hqlQuery.SetString("sessionId", filter.SessionId);
}
if (!string.IsNullOrWhiteSpace(filter.ClientId))
{
hqlQuery.SetString("clientId", filter.ClientId);
}
if (!string.IsNullOrWhiteSpace(filter.Type))
{
hqlQuery.SetString("type", filter.Type);
}
return(hqlQuery);
}
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
return(await Collection.Find(CreateFilter(filter)).ToListAsync());
}
private IQueryable <PersistedGrantExtra> Filter(IQueryable <PersistedGrantExtra> query, PersistedGrantFilter filter)
{
if (!String.IsNullOrWhiteSpace(filter.ClientId))
{
query = query.Where(x => x.ClientId == filter.ClientId);
}
if (!String.IsNullOrWhiteSpace(filter.SessionId))
{
query = query.Where(x => x.SessionId == filter.SessionId);
}
if (!String.IsNullOrWhiteSpace(filter.SubjectId))
{
query = query.Where(x => x.SubjectId == filter.SubjectId);
}
if (!String.IsNullOrWhiteSpace(filter.Type))
{
query = query.Where(x => x.Type == filter.Type);
}
return(query);
}
public Task<IEnumerable<PersistedGrant>> GetAllAsync(PersistedGrantFilter filter)
{
var result = _dbRepository.Where<PersistedGrant>(i => i.SubjectId == filter.SubjectId);
return Task.FromResult(result.AsEnumerable());
}
private static IQueryable <Entities.PersistedGrant> Filter(IQueryable <Entities.PersistedGrant> query, PersistedGrantFilter filter)
{
if (!string.IsNullOrWhiteSpace(filter.ClientId))
{
query = query.Where(x => x.ClientId == filter.ClientId);
}
if (!string.IsNullOrWhiteSpace(filter.SessionId))
{
query = query.Where(x => x.SessionId == filter.SessionId);
}
if (!string.IsNullOrWhiteSpace(filter.SubjectId))
{
query = query.Where(x => x.SubjectId == filter.SubjectId);
}
if (!string.IsNullOrWhiteSpace(filter.Type))
{
query = query.Where(x => x.Type == filter.Type);
}
return(query);
}
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
await using var db = dbFactory();
return(await db.PersistedGrants.AsNoTracking().Filter(filter).ToListAsync());
}
public Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
throw new InvalidOperationException($"Grants are not supported.");
}
public static IQueryable <PersistedGrant> Filter(this IQueryable <PersistedGrant> query, PersistedGrantFilter filter)
{
return(query
.FilterByIfNotWhitespace(filter.ClientId, i => i.ClientId == filter.ClientId)
.FilterByIfNotWhitespace(filter.SessionId, i => i.SessionId == filter.SessionId)
.FilterByIfNotWhitespace(filter.SubjectId, i => i.SubjectId == filter.SubjectId)
.FilterByIfNotWhitespace(filter.Type, i => i.Type == filter.Type));
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
throw new InvalidOperationException($"Grants are not supported.");
}
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
throw new NotSupportedException();
}
public virtual async Task <IEnumerable <PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
var entities = await _persistedGrantRepository.GetAllListAsync(FilterPersistedGrant(filter));
return(ObjectMapper.Map <List <PersistedGrant> >(entities));
}
/// <summary>
/// Delete all the grants with given filter
/// </summary>
/// <param name="filter">The filter to delete</param>
/// <returns></returns>
public Task RemoveAllAsync(PersistedGrantFilter filter)
{
return(this.grantsRepository.DeleteAllBy(ToFilterModel(filter)));
}
public virtual async Task <IEnumerable <IdentityServer4.Models.PersistedGrant> > GetAllAsync(PersistedGrantFilter filter)
{
var persistedGrants = await PersistentGrantRepository.GetListAsync(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
return(ObjectMapper.Map <List <PersistedGrant>, List <IdentityServer4.Models.PersistedGrant> >(persistedGrants));
}
