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