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 void Copy(ILazyLoadingOptions lazyLoadingOptions)
{
DataUri = lazyLoadingOptions.DataUri;
PutDataUri = lazyLoadingOptions.PutDataUri;
DeleteUri = lazyLoadingOptions.DeleteUri;
RequestParams = lazyLoadingOptions.RequestParams;
}
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
}));
}
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> > 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 Task <WeatherForecast> DeleteItem(WeatherForecast item, ILazyLoadingOptions lazyLoadingOptions)
{
if (staticRepositoryCollections.Forecasts.TryRemove(item.Id, out var value))
{
return(Task.FromResult(value));
}
return(Task.FromResult(default(WeatherForecast)));
}
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 async Task <TItem> DeleteItem(TItem item, ILazyLoadingOptions lazyLoadingOptions)
{
if (string.IsNullOrWhiteSpace(lazyLoadingOptions.DeleteUri))
{
throw new ArgumentNullException($"When you are using {nameof(LazyTableDataSet<TItem>)} you must specify url for deleteing item. " +
$"If you are using {nameof(LazyTableDataSet<TItem>)} as detail GridView you must configure url by calling method HasDeleteUrl");
}
var match = Regex.Match(lazyLoadingOptions.DeleteUri, DeleteUrlPattern);
if (!match.Success)
{
throw new InvalidOperationException("The DeleteUri must contains {} with name of property with key value.");
}
var realDeleteUri = lazyLoadingOptions.DeleteUri;
try
{
var keyPropertyNames = match.Groups["prop"].Captures;
var propertyValueAccessor = _propertyValueAccessorCache.GetPropertyAccesor(typeof(TItem));
var query = new QueryBuilder();
foreach (Capture keyPropertyName in keyPropertyNames)
{
var keyValue = propertyValueAccessor.GetValue(item, keyPropertyName.Value);
query.Add(keyPropertyName.Value, keyValue.ToString());
}
realDeleteUri = Regex.Replace(lazyLoadingOptions.DeleteUri, DeleteUrlPattern, query.ToString());
var response = await _httpClient.DeleteAsync(realDeleteUri);
if (response.IsSuccessStatusCode)
{
return(item);
}
return(null);
}
catch (Exception ex)
{
_logger.LogError($"Error during deleting item for uri [{realDeleteUri}]. Ex: {ex}");
return(null);
}
}
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 <WeatherForecast> SaveItem(WeatherForecast item, ILazyLoadingOptions lazyLoadingOptions)
{
var id = item.Id;
if (staticRepositoryCollections.Forecasts.TryGetValue(id, out var value))
{
if (staticRepositoryCollections.Forecasts.TryUpdate(id, item, value))
{
// Update Success
return(Task.FromResult(item));
}
}
else if (staticRepositoryCollections.Forecasts.TryAdd(id, item))
{
// Create Success
return(Task.FromResult(item));
}
// Conflict
return(Task.FromResult(default(WeatherForecast)));
}
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 async Task <TItem> SaveItem(TItem item, ILazyLoadingOptions lazyLoadingOptions)
{
if (string.IsNullOrWhiteSpace(lazyLoadingOptions.PutDataUri))
{
throw new ArgumentNullException($"When you are using {nameof(LazyTableDataSet<TItem>)} you must specify url for saving updated item data. " +
$"If you are using {nameof(LazyTableDataSet<TItem>)} as detail GridView you must configure url by calling method HasUpdateUrl");
}
try
{
var response = await httpClient.PutJsonAsync <TItem>(lazyLoadingOptions.PutDataUri, item);
return(response);
}
catch (Exception ex)
{
logger.LogError($"Error during saving data for [{lazyLoadingOptions.PutDataUri}]. Ex: {ex}");
return(null);
}
}
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
}));
}
public Task <LazyLoadingDataSetResult <Order> > GetGroupedTablePageData(ILazyLoadingOptions lazyLoadingOptions, IPagingOptions pageableOptions, ISortingOptions sortingOptions, IGroupingOptions groupingOptions)
{
throw new NotImplementedException();
}
public Task <TItem> SaveItem(TItem item, ILazyLoadingOptions lazyLoadingOptions) => Task.FromResult(item);
public RefreshLazyLoadingOptionsTrigger(ITableDataSet tableDataSet, ILazyLoadingOptions newLazyLoadingOptions)
{
this.tableDataSet = tableDataSet ?? throw new ArgumentNullException(nameof(tableDataSet));
this.newLazyLoadingOptions = newLazyLoadingOptions ?? throw new ArgumentNullException(nameof(newLazyLoadingOptions));
}
public Task <WeatherForecast> DeleteItem(WeatherForecast item, ILazyLoadingOptions lazyLoadingOptions)
{
return(Task.FromResult(item));
}
public Task <WeatherForecast> SaveItem(WeatherForecast item, ILazyLoadingOptions lazyLoadingOptions)
{
item.TemperatureC = item.TemperatureC + 1;
return(Task.FromResult(item));
}
