/// <summary> /// Applies the order by filter to the queryable. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <param name="source">The queryable.</param> /// <param name="orderByFilter">The order by filter.</param> /// <returns>A collection of entities.</returns> public static FilterResult <TEntity> ToFilteredResult <TEntity>( this IQueryable <TEntity> source, OrderByFilter orderByFilter) where TEntity : class, IDataEntity { if (source == null) { return(new FilterResult <TEntity>()); } else if (orderByFilter == null) { return(new FilterResult <TEntity>(source.GetPage(1, 20).ToList(), source.Count())); } ValidateOrderBy <TEntity>(orderByFilter); // Order by if (!string.IsNullOrEmpty(orderByFilter.OrderBy)) { var orderBy = orderByFilter.PropertyMappings.MapProperty(orderByFilter.OrderBy); source = source.OrderBy(orderBy, orderByFilter.SortOrder); } // Paging return(new FilterResult <TEntity>(source.GetPage(orderByFilter.Page, orderByFilter.PageSize).ToList(), source.Count())); }
/// <summary> /// Applies the order by filter to the queryable. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <param name="source">The queryable.</param> /// <param name="orderByFilter">The order by filter.</param> /// <returns>A collection of entities.</returns> public static IQueryable <TEntity> Filter <TEntity>( this IQueryable <TEntity> source, OrderByFilter orderByFilter) where TEntity : class, IDataEntity { if (source == null) { throw new ArgumentNullException(nameof(source)); } else if (orderByFilter == null) { return(source); } ValidateOrderBy <TEntity>(orderByFilter); // Order by if (!string.IsNullOrEmpty(orderByFilter.OrderBy)) { var orderBy = orderByFilter.PropertyMappings.MapProperty(orderByFilter.OrderBy); source = source.OrderBy(orderBy, orderByFilter.SortOrder); } // Paging source = source.GetPage(orderByFilter.Page, orderByFilter.PageSize); return(source); }
private static void ValidateOrderBy <TEntity>(OrderByFilter orderByFilter) { if (!string.IsNullOrWhiteSpace(orderByFilter.OrderBy)) { var orderBy = orderByFilter.PropertyMappings.MapProperty(orderByFilter.OrderBy); ValidateOrderBy <TEntity>(orderBy); } }
/// <inheritdoc /> public async Task <int> GetCountAsync(OrderByFilter orderByFilter, Expression <Func <TEntity, bool> >?filter = null) { IQueryable <TEntity> query = DbSet; if (filter != null) { query = query.Where(filter); } return(await query.Filter(orderByFilter).CountAsync()); }
/// <inheritdoc /> public int GetCount(OrderByFilter orderByFilter, Expression <Func <TEntity, bool> >?filter = null) { IQueryable <TEntity> query = DbSet; if (filter != null) { query = query.Where(filter); } return(query.Filter(orderByFilter).Count()); }
public void When_Find_is_called_then_collection_should_be_ordered_ascending() { // Arrange var searchCriteria = new OrderByFilter { OrderBy = "name", }; // Act var result = SystemUnderTest.Find(searchCriteria); // Assert result.First().Name.Should().Be("Apple", because: "the collection is ordered by product name ascending"); }
public void When_Validate_is_called_with_member_path_then_no_validation_exception_should_be_thrown() { // Arrange var filter = new OrderByFilter { OrderBy = "category.name", }; // Act Action action = () => Data.Repositories.QueryableExtensions.Filter(Products, filter); // Assert action.Should().NotThrow(because: "it is allowed to order via member paths"); }
/// <inheritdoc /> public virtual async Task <IEnumerable <TEntity> > FindAsync( OrderByFilter orderByFilter, Expression <Func <TEntity, bool> >?filter = null) { IQueryable <TEntity> query = DbSet; // Filter if (filter != null) { query = query.Where(filter); } return(await query.Filter(orderByFilter).ToListAsync()); }
/// <inheritdoc /> public virtual IEnumerable <TEntity> Find( OrderByFilter orderByFilter, Expression <Func <TEntity, bool> >?filter = null) { IQueryable <TEntity> query = DbSet; // Filter if (filter != null) { query = query.Where(filter); } return(query.Filter(orderByFilter).ToList()); }
public void When_Find_is_called_then_collection_should_be_paged() { // Arrange var searchCriteria = new OrderByFilter { Page = 2, PageSize = 1, }; // Act var result = SystemUnderTest.Find(searchCriteria); // Assert result.Count().Should().Be(1, because: "the page size is 1"); result.First().Name.Should().Be("How To Cook", because: "the page is 2, the page size is 1 and the product 'How To Cook' is the second item in the collection"); }
public void When_a_property_is_mapped_no_order_by_validation_error_should_be_thrown() { // Arrange var filter = new OrderByFilter { OrderBy = "categoryName", }; filter.PropertyMappings.Add("categoryName", "category.name"); // Act Action action = () => Data.Repositories.QueryableExtensions.Filter(Products, filter); // Assert action.Should().NotThrow(because: "it is allowed to order via member paths"); }
/// <summary> /// Applies the order by filter to the queryable. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <param name="source">The queryable.</param> /// <param name="orderByFilter">The order by filter.</param> /// <returns>A collection of entities.</returns> public static async Task <FilterResult <TEntity> > ToFilteredResultAsync <TEntity>( this IQueryable <TEntity> source, OrderByFilter orderByFilter) where TEntity : class, IDataEntity { List <TEntity> items; int count; if (source == null) { return(new FilterResult <TEntity>()); } else if (orderByFilter == null) { items = await source.GetPage(1, 20).ToListAsync(); count = await source.CountAsync(); return(new FilterResult <TEntity>(items, count)); } ValidateOrderBy <TEntity>(orderByFilter); // Order by if (!string.IsNullOrEmpty(orderByFilter.OrderBy)) { var orderBy = orderByFilter.PropertyMappings.MapProperty(orderByFilter.OrderBy); source = source.OrderBy(orderBy, orderByFilter.SortOrder); } // Paging items = await source.GetPage(orderByFilter.Page, orderByFilter.PageSize).ToListAsync(); count = await source.CountAsync(); return(new FilterResult <TEntity>(items, count)); }