public Task <LazyLoadingDataSetResult <TItem> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions)
{
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 dataUri = $"{lazyLoadingOptions.DataUri.TrimEnd('/')}?{lazyLoadingOptions.RequestParams}{PagingParams(pageableOptions)}{SortingParams(sortingOptions)}";
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));
}
}
public Task <LazyLoadingDataSetResult <WeatherForecast> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
{
var items = staticRepositoryCollections.Forecasts.Values.AsQueryable();
var sortExp = sortingOptions?.SortExpression;
if (!string.IsNullOrEmpty(sortExp))
{
if (sortingOptions.SortDescending)
{
sortExp += " descending";
}
items = items.OrderBy(sortExp);
}
items = items
.Skip(pageableOptions.PageSize * pageableOptions.CurrentPage)
.Take(pageableOptions.PageSize);
return(Task.FromResult(new LazyLoadingDataSetResult <WeatherForecast>
{
Items = items.ToList(),
TotalCount = staticRepositoryCollections.Forecasts.Count
}));
}
public Task <LazyLoadingDataSetResult <WeatherForecast> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
{
var startDate = DateTime.Now;
var rng = new Random();
var items = Enumerable.Range(1, 20)
.Skip(pageableOptions.PageSize * pageableOptions.CurrentPage)
.Take(pageableOptions.PageSize)
.Select(index => new WeatherForecast
{
Date = startDate.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
});
items = string.IsNullOrEmpty(sortingOptions.SortExpression)
? items
: items.AsQueryable().OrderBy(sortingOptions.SortExpression).ToList();
return(Task.FromResult(
new LazyLoadingDataSetResult <WeatherForecast>
{
Items = items.ToList(),
TotalCount = 100
}));
}
private void SortingParams(QueryBuilder builder, ISortingOptions sortingOptions)
{
if (!string.IsNullOrWhiteSpace(sortingOptions.SortExpression))
{
builder.Add("sortExpression", sortingOptions.SortExpression);
builder.Add("sortDescending", sortingOptions.SortDescending.ToString());
}
}
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 Task <LazyLoadingDataSetResult <TItem> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
=> Task.FromResult(new LazyLoadingDataSetResult <TItem>()
{
Items = new List <TItem>(),
TotalCount = 0
});
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));
}
public Task <LazyLoadingDataSetResult <Order> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
{
var customerId = Convert.ToInt32(lazyLoadingOptions.RequestParams["CustomerId"]);
var customerOrders = orders.Where(o => o.CustomerId == customerId);
var pageableCustomerOrders = customerOrders
.Skip(pageableOptions.PageSize * pageableOptions.CurrentPage)
.Take(pageableOptions.PageSize)
.ToList();
return(Task.FromResult(new LazyLoadingDataSetResult <Order>
{
Items = pageableCustomerOrders,
TotalCount = customerOrders.Count()
}));
}
public Task <LazyLoadingDataSetResult <TItem> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions)
{
var dataUri = $"{lazyLoadingOptions.DataUri.TrimEnd('/')}?{PagingParams(pageableOptions)}{SortingParams(sortingOptions)}";
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));
}
}
public Task <LazyLoadingDataSetResult <WeatherForecast> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
{
var startDate = DateTime.Now;
var rng = new Random();
var items = staticRepositoryCollections.Forecasts
.Skip(pageableOptions.PageSize * pageableOptions.CurrentPage)
.Take(pageableOptions.PageSize);
items = string.IsNullOrEmpty(sortingOptions.SortExpression)
? items
: items.AsQueryable().OrderBy(sortingOptions.SortExpression).ToList();
return(Task.FromResult(
new LazyLoadingDataSetResult <WeatherForecast>
{
Items = items.ToList(),
TotalCount = 100
}));
}
private string SortingParams(ISortingOptions sortingOptions)
=> string.IsNullOrWhiteSpace(sortingOptions.SortExpression)
? string.Empty
: $"&sortExpression={sortingOptions.SortExpression}&sortDescending={sortingOptions.SortDescending}";
public Task <LazyLoadingDataSetResult <Order> > GetGroupedTablePageData(ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
throw new NotImplementedException();
}
public static IQueryable <TItem> ApplySortingToQueryable <TItem>(this IQueryable <TItem> queryable, ISortingOptions sortingOptions)
{
if (string.IsNullOrEmpty(sortingOptions?.SortExpression))
{
return(queryable);
}
return(sortingOptions.SortDescending
? queryable.OrderByDescending(sortingOptions.SortExpression)
: queryable.OrderBy(sortingOptions.SortExpression));
}
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));
}
