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