public Task <LazyLoadingDataSetResult <TItem> > GetGroupedTablePageData(
ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions,
ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
if (string.IsNullOrWhiteSpace(lazyLoadingOptions.DataUri))
{
throw new ArgumentNullException($"When you using {nameof(LazyLoadedTableDataAdapter<TItem>)} you must specify " +
$"{nameof(LazyLoadingOptions.DataUri)} for lazy data retrieving. If you do not want use lazy loading feature use {nameof(CollectionTableDataAdapter<TItem>)} instead.");
}
var query = new QueryBuilder(lazyLoadingOptions.RequestParams);
PagingParams(query, pageableOptions);
SortingParams(query, sortingOptions);
GroupingParams(query, groupingOptions);
var dataUri = $"{lazyLoadingOptions.DataUri}{query.ToString()}";
try
{
return(httpClient.GetJsonAsync <LazyLoadingDataSetResult <TItem> >(dataUri));
}
catch (Exception ex)
{
logger.LogError($"Error during fetching data from [{dataUri}]. Ex: {ex}");
var emptyResult = new LazyLoadingDataSetResult <TItem>
{
Items = Enumerable.Empty <TItem>().ToList()
};
return(Task.FromResult(emptyResult));
}
}
private void GroupingParams(QueryBuilder builder, IGroupingOptions groupingOptions)
{
if (!string.IsNullOrWhiteSpace(groupingOptions.GroupedProperty?.Name))
{
builder.Add("groupExpression", groupingOptions.GroupedProperty.Name);
}
}
public Task <LazyLoadingDataSetResult <WeatherForecast> > GetGroupedTablePageData(
ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions,
ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
try
{
var items = staticRepositoryCollections.Forecasts.Values.AsQueryable();
var param = Expression.Parameter(typeof(WeatherForecast));
var property = Expression.PropertyOrField(param, groupingOptions.GroupedProperty.Name);
var keyPropertyConstructors = typeof(KeyProperty).GetConstructors();
var newExpr = Expression.New(keyPropertyConstructors.FirstOrDefault(c => c.GetParameters()[0].ParameterType == property.Type)
, property);
var lambda = Expression.Lambda <Func <WeatherForecast, KeyProperty> >(newExpr, param);
var groupedItems = items.GroupBy(lambda)
.Select(grp => new GroupItem <WeatherForecast>(grp.Key.Key, grp.ToList()));
var groupedItemsAfterPaging = groupedItems
.Skip(pageableOptions.PageSize * pageableOptions.CurrentPage)
.Take(pageableOptions.PageSize);
var groupedItemsAfterSorting = new List <GroupItem <WeatherForecast> >();
var sortExp = sortingOptions?.SortExpression;
if (!string.IsNullOrEmpty(sortExp))
{
if (sortingOptions.SortDescending)
{
sortExp += " descending";
}
foreach (var groupItem in groupedItemsAfterPaging)
{
groupedItemsAfterSorting.Add(new GroupItem <WeatherForecast>(groupItem.Key,
groupItem.Items.AsQueryable().OrderBy(sortExp)));
}
}
else
{
groupedItemsAfterSorting = groupedItemsAfterPaging.ToList();
}
return(Task.FromResult(new LazyLoadingDataSetResult <WeatherForecast>()
{
Items = groupedItemsAfterSorting.SelectMany(grp => grp.Items).ToList(),
TotalCount = groupedItems.Count()
}));
}
catch (Exception ex)
{
throw ex;
}
}
public RequestOptions(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions,
IGroupingOptions groupingOptions)
{
this.LazyLoadingOptions = lazyLoadingOptions ?? throw new ArgumentNullException(nameof(lazyLoadingOptions));
this.PageableOptions = pageableOptions ?? throw new ArgumentNullException(nameof(pageableOptions));
this.SortingOptions = sortingOptions ?? throw new ArgumentNullException(nameof(sortingOptions));
this.GroupingOptions = groupingOptions ?? throw new ArgumentNullException(nameof(groupingOptions));
}
private void GroupingParams(QueryBuilder builder, IGroupingOptions groupingOptions)
{
builder.Add("groupExpression", groupingOptions.GroupedProperty.Name);
}
public Task <LazyLoadingDataSetResult <Order> > GetGroupedTablePageData(ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
throw new NotImplementedException();
}
public static IQueryable <GroupItem <TItem> > ApplyFiltersWithGroupingToQueryable <TItem>(this IQueryable <TItem> source, ISortingOptions sortingOptions, IGroupingOptions groupingOptions, IPagingOptions pagingOptions)
{
var groupedItemsQueryable = ApplyGroupingToQueryable(source, groupingOptions.GroupedProperty.Name);
groupedItemsQueryable = ApplySortingToGroupedQueryable(groupedItemsQueryable, sortingOptions, groupingOptions);
pagingOptions.TotalItemsCount = groupedItemsQueryable.Count();
groupedItemsQueryable = ApplyPagingToQueryable(groupedItemsQueryable, pagingOptions);
return(groupedItemsQueryable);
}
public static IQueryable <GroupItem <TItem> > ApplySortingToGroupedQueryable <TItem>(this IQueryable <GroupItem <TItem> > queryable, ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
if (string.IsNullOrEmpty(sortingOptions?.SortExpression))
{
return(queryable);
}
if (sortingOptions.SortExpression != groupingOptions.GroupedProperty.Name)
{
queryable = queryable.Select(x => new GroupItem <TItem>(x.Key,
sortingOptions.SortDescending
? x.AsQueryable().OrderByDescending(sortingOptions.SortExpression)
: x.AsQueryable().OrderBy(sortingOptions.SortExpression)));
return(queryable);
}
return(sortingOptions.SortDescending
? queryable.OrderByDescending(x => x.Key)
: queryable.OrderBy(x => x.Key));
}
public Task <LazyLoadingDataSetResult <TItem> > GetGroupedTablePageData(ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
=> Task.FromResult(new LazyLoadingDataSetResult <TItem>()
{
Items = new List <TItem>(),
TotalCount = 0
});
