/// <inheritdoc/>
public IPagedData <AnimalSummary> SearchPaged(IQueryableFilter <AnimalSummary> filter, IPagingOptions pagingOptions, OrderingOptions <AnimalOrderType>?orderingOptions = null)
{
return(dbContext.Animals
.SelectAnimalSummaries()
.FilterOnObject(filter)
.Order(orderingOptions)
.Paginate(pagingOptions));
}
public static PagedResponse <TProjection> Paged <TEntity, TProjection>(this IQueryable <TEntity> query,
IPaging paging, IQueryableOrder <TProjection> queryableOrder, IQueryableFilter <TEntity> entitySpec = null,
IQueryableFilter <TProjection> projectionSpec = null, IConfigurationProvider configurationProvider = null)
where TEntity : class, IHasId where TProjection : class
=> query
.EitherOrSelf(entitySpec, x => x.Where(entitySpec))
.EitherProjectTo <TEntity, TProjection>(configurationProvider)
.EitherOrSelf(projectionSpec, x => x.Where(projectionSpec))
.OrderBy(queryableOrder)
.ToPagedResponse(paging);
public FilteredPaginatedDataProvider(IQueryableFilter <TData> filter,
IQueryablePaginator <TData, TViewModel> paginator,
IQueryable <TData> dataSource,
Converter <TData, TViewModel> converter)
{
_filter = filter;
_paginator = paginator;
_dataSource = dataSource;
_converter = converter;
}
public async Task CountAsync_GivenNullFilter_ThrowsArgumentNullException()
{
// Arrange
var repository = uow.Repository <Person>();
IQueryableFilter <Person> filter = null;
// Act
async Task action() => await repository.CountAsync(filter).ConfigureAwait(false);
// Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(action).ConfigureAwait(false);
}
public void Count_GivenNullFilter_ThrowsArgumentNullException()
{
// Arrange
var repository = uow.Repository <Person>();
IQueryableFilter <Person> filter = null;
// Act
void action() => repository.Count(filter);
// Assert
Assert.ThrowsException <ArgumentNullException>(action);
}
public IQueryableTypeFilter GetFilter(Type type, IQueryableFilter queryableFilter)
{
try{
return(!Filters.ContainsKey(type)
? Filters[DefaultFilterType].FirstOrDefault(f => f.QueryableFilter == queryableFilter)
: Filters[type].FirstOrDefault(f => f.QueryableFilter == queryableFilter));
}
catch (NullReferenceException exception)
{
throw new NullReferenceException($"One of the QueryableTypeFilters in the QueryableTypeFilterMap<{type}> doesn't have a QueryableFilter defined. Make sure it is also added to the QueryableFilterMap.", exception);
}
}
public static IPagedEnumerable <TProjection> Paged <TEntity, TProjection>(this IQueryable <TEntity> query,
IPaging spec, IQueryableOrder <TProjection> queryableOrder, Expression <Func <TEntity, TProjection> > projectionExpression, IQueryableFilter <TEntity> entitySpec = null,
IQueryableFilter <TProjection> projectionSpec = null)
where TEntity : class, IHasId
where TProjection : class, IHasId
=> query
.EitherOrSelf(entitySpec, x => x.Where(entitySpec))
.Select(projectionExpression)
.EitherOrSelf(projectionSpec, x => x.Where(projectionSpec))
.OrderBy(queryableOrder)
.OrderByIdIfNotOrdered()
.ToPagedEnumerable(spec);
public void Find_GivenNullFilterAndNonNullPaginator_ThrowsArgumentNullException()
{
// Arrange
var repository = uow.Repository <Person>();
IQueryableFilter <Person> filter = null;
IQueryablePaginator <Person> paginator = new SortingPaginator <Person>();
// Act
void action() => repository.Find(filter, paginator);
// Assert
Assert.ThrowsException <ArgumentNullException>(action);
}
/// <inheritdoc/>
public virtual IPagedData <MedicalTransaction> Find(IQueryableFilter <MedicalTransaction> filter,
ListSortDirection sortDirection,
IPagingOptions pagingOptions)
{
Logger.LogInformation("Finding {@PageSize} medical transaction for page {@PageNumber}...", pagingOptions.PageSize, pagingOptions.PageNumber);
var x = LivestockContext.MedicalTransactions
.AsNoTracking()
.SortByCriteria(t => t.TransactionDate, sortDirection)
.MapToMedicalTransactions()
.FilterOnObject(filter)
.ToList();
return(LivestockContext.MedicalTransactions
.AsNoTracking()
.SortByCriteria(t => t.TransactionDate, sortDirection)
.MapToMedicalTransactions()
.FilterOnObject(filter)
.Paginate(pagingOptions));
}
/// <summary>
/// Construct new <see cref="DataProviderBuilder{TData,TViewModel}"/> instance
/// </summary>
/// <param name="queryable"></param>
/// <remarks>This class is not intended to be constructed by app developers directly. Rather, they should use it as part of <see cref="DataTableBuilder{TViewModel}"/></remarks>
public DataProviderBuilder(IQueryable <TData> queryable)
{
_queryable = queryable;
_filter = new QueryableFilter <TData>();
_converter = DefaultConverter;
}
public QueryableTypeFilter(IQueryableFilter queryableFilter, Func <Expression, Expression, Expression> filter)
{
QueryableFilter = queryableFilter;
Filter = filter;
}
public virtual Task <IEnumerable <TEntity> > FindAsync(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator, CancellationToken cancellationToken = default)
{
return(FindAsync(filter, paginator, includePaths: null, cancellationToken));
}
public virtual async Task <IEnumerable <TEntity> > FindAsync(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator, IEntityIncludePaths <TEntity> includePaths, CancellationToken cancellationToken = default)
{
return(await CreateQuery(includePaths).Filter(filter).Paginate(paginator).ToListAsync(cancellationToken).ConfigureAwait(false));
}
public virtual IEnumerable <TEntity> Find(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator, IEntityIncludePaths <TEntity> includePaths)
{
return(CreateQuery(includePaths).Filter(filter).Paginate(paginator).ToList());
}
public virtual async Task <int> CountAsync(IQueryableFilter <TEntity> filter, CancellationToken cancellationToken = default)
{
return(await CreateQuery(includePaths : null).Filter(filter).CountAsync(cancellationToken).ConfigureAwait(false));
}
public IQueryableTypeFilter GetTypeFilter(Type type, IQueryableFilter queryableFilter) => _filterMap.GetFilter(type, queryableFilter);
public static IQueryable <T> Filter <T>(this IQueryable <T> sequence, IQueryableFilter <T> filter)
{
Ensure.Argument.NotNull(filter, nameof(filter));
return(filter.Filter(sequence));
}
public virtual IEnumerable <TEntity> Find(IQueryableFilter <TEntity> filter)
{
return(DataStore.AsQueryable().Filter(filter));
}
public static IQueryable <T> Where <T>(this IQueryable <T> source, IQueryableFilter <T> spec)
where T : class
=> spec.Apply(source);
public static long Count <T>(this IQueryable <T> query, IQueryableFilter <T> spec) where T : class => query.Apply(spec).Count();
/// <summary>
/// Filters an <see cref="IQueryable"/> of <typeparamref name="TData"/> items based on
/// the provided <paramref name="filter"/> of <see cref="IQueryableFilter{TData}"/>.
/// </summary>
/// <typeparam name="TData">
/// The type of data the <paramref name="query"/> is about.
/// </typeparam>
/// <param name="query">
/// The <see cref="IQueryable"/> query of <typeparamref name="TData"/> items.
/// </param>
/// <param name="filter">
/// The <see cref="IQueryableFilter{TData}"/> that contains the
/// implementation of the filter logic.
/// </param>
/// <returns>
/// The filtered version of the <paramref name="query"/>.
/// </returns>
public static IQueryable <TData> FilterOnObject <TData>(this IQueryable <TData> query, IQueryableFilter <TData> filter)
{
return(filter.Filter(query));
}
/// <summary>
/// Specify object which will override default support for filtering and ordering data
/// </summary>
/// <param name="filter">This object will handle filtering and ordering of data. Usually it's of class derived from <see cref="QueryableFilter{TData}"/></param>
/// <returns>The original builder object</returns>
/// <remarks>This method changes and returns the original builder object</remarks>
public DataProviderBuilder <TData, TViewModel> WithFilter(IQueryableFilter <TData> filter)
{
_filter = filter;
return(this);
}
public virtual int Count(IQueryableFilter <TEntity> filter)
{
return(DataStore.AsQueryable().Filter(filter).Count());
}
public virtual IEnumerable <TEntity> Find(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator, IEntityIncludePaths <TEntity> includePaths)
{
return(Find(filter, paginator));
}
public virtual IEnumerable <TEntity> Find(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator)
{
return(DataStore.AsQueryable().Filter(filter).Paginate(paginator));
}
public virtual Task <IEnumerable <TEntity> > FindAsync(IQueryableFilter <TEntity> filter, CancellationToken cancellationToken = default)
{
return(Task.FromResult(Find(filter)));
}
public virtual Task <int> CountAsync(IQueryableFilter <TEntity> filter, CancellationToken cancellationToken = default)
{
return(Task.FromResult(Count(filter)));
}
public virtual int Count(IQueryableFilter <TEntity> filter)
{
return(CreateQuery(includePaths: null).Filter(filter).Count());
}
public virtual Task <IEnumerable <TEntity> > FindAsync(IQueryableFilter <TEntity> filter, IQueryablePaginator <TEntity> paginator, IEntityIncludePaths <TEntity> includePaths, CancellationToken cancellationToken = default)
{
return(Task.FromResult(Find(filter, paginator, includePaths)));
}
public virtual IEnumerable <TEntity> Find(IQueryableFilter <TEntity> filter)
{
return(Find(filter, includePaths: null));
}
