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 IList <int> GetIndexes(IPagingOptions pagingOptions)
{
return
(Enumerable.Range(0, pagingOptions.PagesCount)
.Where(n => Math.Abs(n - pagingOptions.PageIndex) <= distance)
.ToList());
}
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 MapListActions(ProductSummaryModel model, IPagingOptions entity, string defaultPageSizeOptions)
{
var searchQuery = _catalogSearchQueryFactory.Current;
// View mode
model.AllowViewModeChanging = _catalogSettings.AllowProductViewModeChanging;
// Sorting
model.AllowSorting = _catalogSettings.AllowProductSorting;
if (model.AllowSorting)
{
model.CurrentSortOrder = searchQuery?.CustomData.Get("CurrentSortOrder").Convert <int?>();
model.AvailableSortOptions = _services.Cache.Get("pres:productlistsortoptions-{0}".FormatInvariant(_services.WorkContext.WorkingLanguage.Id), () =>
{
var dict = new Dictionary <int, string>();
foreach (ProductSortingEnum enumValue in Enum.GetValues(typeof(ProductSortingEnum)))
{
if (enumValue == ProductSortingEnum.CreatedOnAsc || enumValue == ProductSortingEnum.Initial)
{
continue;
}
dict[(int)enumValue] = enumValue.GetLocalizedEnum(_localizationService, _services.WorkContext);
}
return(dict);
});
if (!searchQuery.Origin.IsCaseInsensitiveEqual("Search/Search"))
{
model.RelevanceSortOrderName = T("Products.Sorting.Featured");
if ((int)ProductSortingEnum.Relevance == (model.CurrentSortOrder ?? 1))
{
model.CurrentSortOrderName = model.RelevanceSortOrderName;
}
}
if (model.CurrentSortOrderName.IsEmpty())
{
model.CurrentSortOrderName = model.AvailableSortOptions.Get(model.CurrentSortOrder ?? 1) ?? model.AvailableSortOptions.First().Value;
}
}
// Pagination
if (entity?.AllowCustomersToSelectPageSize ?? _catalogSettings.AllowCustomersToSelectPageSize)
{
try
{
model.AvailablePageSizes = (entity?.PageSizeOptions.NullEmpty() ?? defaultPageSizeOptions).Convert <List <int> >();
}
catch
{
model.AvailablePageSizes = new int[] { 12, 24, 36, 48, 72, 120 };
}
}
model.AllowFiltering = true;
}
/// <summary>
/// Finds the medicine types sorted as specified.
/// </summary>
/// <typeparam name="TSortProperty">The type of the property on the object that is the sort key.</typeparam>
/// <param name="sort">The condition that defines the sorting property.</param>
/// <param name="sortDirection">Should the list be sorted ascending or descending.</param>
/// <param name="pagingOptions">The options for pagination.</param>
/// <param name="cancellationToken">A token that can be used to signal operation cancellation.</param>
/// <returns>The sorted list of medicine types.</returns>
public virtual Task <IPagedData <IMedicineType> > FindAsync <TSortProperty>(Expression <Func <IMedicineType, TSortProperty> > sort,
ListSortDirection sortDirection,
IPagingOptions pagingOptions,
CancellationToken cancellationToken)
where TSortProperty : IComparable
{
return(FindAsync(_ => true, sort, sortDirection, pagingOptions, cancellationToken));
}
public Task <LazyLoadingDataSetResult <TItem> > GetTablePageData(
ILazyLoadingOptions lazyLoadingOptions,
IPagingOptions pageableOptions,
ISortingOptions sortingOptions)
=> Task.FromResult(new LazyLoadingDataSetResult <TItem>()
{
Items = new List <TItem>(),
TotalCount = 0
});
/// <summary>
/// Gets a list of page indexes near current page.
/// </summary>
/// <param name="pagingOptions">The settings for paging.</param>
public IList <int> GetIndexes(IPagingOptions pagingOptions)
{
var firstIndex = Math.Max(pagingOptions.PageIndex - distance, 0);
var lastIndex = Math.Min(pagingOptions.PageIndex + distance + 1, pagingOptions.PagesCount);
return(Enumerable
.Range(firstIndex, lastIndex - firstIndex)
.ToList());
}
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 static IQueryable <T> ApplyPaging <T>(this IPagingOptions pagingOptions, IQueryable <T> queryable)
{
if (pagingOptions.PageSize <= 0)
{
return(queryable);
}
return(queryable.Skip(pagingOptions.PageSize * pagingOptions.PageIndex).Take(pagingOptions.PageSize));
}
public static IQueryable <T> ApplyPagination <T>(this IQueryable <T> query, IPagingOptions options)
{
if (options != null)
{
options.Offset = options.Offset ?? 0;
options.Limit = options.Limit ?? 20;
query = query.Skip(options.Offset.Value).Take(options.Limit.Value);
}
return(query);
}
public static T WithPaging <T>(this T query, IPagingOptions paging) where T : IPagableQuery
{
if (paging == null)
{
return(query);
}
query.Options = paging;
return(query);
}
/// <summary>
/// Finds entities that match the given filter, sorted by the criteria and paginated
/// by the given pagination options.
/// </summary>
/// <typeparam name="TEntity">The type that identifies the entity required.</typeparam>
/// <typeparam name="TSortProperty">The type of the sorting property on the entity.</typeparam>
/// <param name="dbSet">The <see cref="IQueryable{TEntity}"/> that will be further constrained.</param>
/// <param name="filter">The filter that will be applied.</param>
/// <param name="sort">The sort condition.</param>
/// <param name="sortDirection">Whether to sort Ascending or Descending.</param>
/// <param name="pagingOptions">The options for pagination.</param>
/// <returns>The filtered, sorted and paged enumerable collection of entities.</returns>
public static IQueryable <TEntity> ConstrainedFind <TEntity, TSortProperty>(this IQueryable <TEntity> query,
Expression <Func <TEntity, bool> > filter,
Expression <Func <TEntity, TSortProperty> > sort,
ListSortDirection sortDirection,
IPagingOptions pagingOptions)
where TEntity : class
{
return(query.ConstrainedFind(filter, sort, sortDirection)
.Skip(pagingOptions.Offset)
.Take(pagingOptions.PageSize));
}
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 CourseListRequestStructure CreateCourseListRequestStructure(IPagingOptions options,
SearchCriteriaStructure searchCriteria, string recordsPerPage)
{
var request = new CourseListRequestStructure()
{
CourseSearchCriteria = searchCriteria,
SortBy = options.SortBy.ToSortType(),
SortBySpecified = true,
PageNo = options.PageNo.ToString(),
RecordsPerPage = recordsPerPage
};
return(request);
}
public static ElasticPagingOptions FromOptions(IPagingOptions options)
{
var elasticOptions = new ElasticPagingOptions();
if (options == null)
{
return(elasticOptions);
}
elasticOptions.Page = options.Page;
elasticOptions.Limit = options.Limit;
return(elasticOptions);
}
public static IQueryable <T> ApplyPagination <T>(this IQueryable <T> query, IPagingOptions options)
{
if (options != null)
{
if (_utilitiesOptions == null)
{
_utilitiesOptions = PaginationUtilitiesOptions.DefaultOptions;
}
options.Offset = options.Offset ?? _utilitiesOptions.PagingOptions.Offset;
options.Limit = options.Limit ?? _utilitiesOptions.PagingOptions.Limit;
query = query.Skip(options.Offset.Value).Take(options.Limit.Value);
}
return(query);
}
/// <inheritdoc/>
public Task <IPagedData <WeightTransaction> > FetchPagedAsync(WeightTransactionFilter filter,
IPagingOptions pagingOptions,
ListSortDirection sortDirection,
CancellationToken cancellationToken)
{
_logger.LogInformation("Fetching paged weight transactions according to a filter. {@Filter}, {@PagingOptions}, {@SortDirection}",
filter,
pagingOptions,
sortDirection);
return(_context.WeightTransactions.AsNoTracking()
.MapToWeightTransaction()
.FilterOnObject(filter)
.SortByCriteria(t => t.TransactionDate, sortDirection)
.PaginateAsync(pagingOptions));
}
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()
}));
}
/// <inheritdoc/>
public virtual IPagedData <MedicalTransaction> Find(IQueryableFilter <MedicalTransaction> filter,
ListSortDirection sortDirection,
IPagingOptions pagingOptions)
{
Logger.LogInformation("Finding {@PageSize} medical transaction for page {@PageNumber}...", pagingOptions.PageSize, pagingOptions.PageNumber);
var x = LivestockContext.MedicalTransactions
.AsNoTracking()
.SortByCriteria(t => t.TransactionDate, sortDirection)
.MapToMedicalTransactions()
.FilterOnObject(filter)
.ToList();
return(LivestockContext.MedicalTransactions
.AsNoTracking()
.SortByCriteria(t => t.TransactionDate, sortDirection)
.MapToMedicalTransactions()
.FilterOnObject(filter)
.Paginate(pagingOptions));
}
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));
}
}
/// <summary>
/// Finds a paged collection of units that match a certain criteria, sorted by the sorting criteria.
/// </summary>
/// <typeparam name="TSortProperty">The type of the property used for sorting.</typeparam>
/// <param name="filter">The filter predicate which specifies the conditions to include a unit.</param>
/// <param name="sort">The criteria for sorting.</param>
/// <param name="sortDirection">Should the list be sorted ascending or descending.</param>
/// <param name="pagingOptions">The options for pagination.</param>
/// <param name="cancellationToken">A token that can be used to signal operation cancellation.</param>
/// <returns>A paged collection of units sorted as specified and filtered by the given criteria.</returns>
public virtual async Task <IPagedData <IUnit> > FindAsync <TSortProperty>(Expression <Func <IUnit, bool> > filter,
Expression <Func <IUnit, TSortProperty> > sort,
ListSortDirection sortDirection,
IPagingOptions pagingOptions,
CancellationToken cancellationToken)
where TSortProperty : IComparable
{
Logger.LogInformation("Finding units...");
var data = await LivestockContext.Units
.ConstrainedFind(filter, sort, sortDirection, pagingOptions)
.Select(unit => Mapper.Map(unit))
.Select(unit => Mapper.Map(unit))
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
Logger.LogDebug("Counting units...");
var totalRecords = await LivestockContext.Units.CountAsync(filter).ConfigureAwait(false);
Logger.LogDebug($"Creating paginated results with {data}, {totalRecords}, {pagingOptions}...");
return(new PagedData <IUnit>(data, pagingOptions.PageSize, pagingOptions.PageNumber, totalRecords));
}
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 IResult <FindACourseSearchResult> CourseDirectorySearch(ICourseSearchCriteria criteria, IPagingOptions options)
{
FindACourseService fac = new FindACourseService(FaCConfiguration, CourseAPIConfiguration);
return(fac.FindACourseSearch(criteria, options).Result);
}
public IResult <Common.Models.FindACourse.FindACourseSearchResult> CreateFindACourseSearchResult(string response, IPagingOptions options, int?itemsperpage)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
if (string.IsNullOrEmpty(response))
{
return(Result.Ok(new FindACourseSearchResult("", 0, 0, new FindACourseSearchItem[] { })));
}
var searchResult = JsonConvert.DeserializeObject <FindACourseSearchResult>(response);
searchResult.PageNo = options.PageNo;
///need to get total courses, divide by items per page, and get a NoOfPages count
searchResult.NoOfPages = searchResult.ODataCount % itemsperpage == 0 ? searchResult.ODataCount.Value / itemsperpage.Value : (searchResult.ODataCount / itemsperpage) + 1;
return(Result.Ok(searchResult));
}
public async Task <IResult <Common.Models.FindACourse.FindACourseSearchResult> > FindACourseSearch(ICourseSearchCriteria criteria, IPagingOptions options)
{
//Bypass current SSL Expiry
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
// Pass the handler to httpclient(from you are calling api)
//var client = new HttpClient(clientHandler)
// Call service to get data
HttpClient client = new HttpClient(clientHandler);
//var criteria = new { PRN };
//criteria.SubjectKeyword = "biology";
criteria.TopResults = Configuration.PerPage;
criteria.PageNo = options.PageNo;
//criteria.QualificationLevels = GetQualLevels(criteria.QualificationLevels):
//criteria.TownOrPostcode = "b44 9ud";
criteria.Distance = 100;
StringContent content = new StringContent(JsonConvert.SerializeObject(criteria), Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", Configuration.ApiKey);
//client.DefaultRequestHeaders.Add("Content-Type", "application/json");
client.DefaultRequestHeaders.Add("UserName", Configuration.UserName);
client.DefaultRequestHeaders.Add("Password", Configuration.Password);
var response = await client.PostAsync($"{Configuration.ApiAddress}/coursesearch", content);
var jsonResult = await response.Content.ReadAsStringAsync();
// Return data as model object
//return Result.Ok(JsonConvert.DeserializeObject<Common.Models.FindACourse.FindACourseSearchResult>(jsonResult));
return(CreateFindACourseSearchResult(jsonResult, options, Configuration.PerPage));
}
private void PagingParams(QueryBuilder builder, IPagingOptions pagingOptions)
{
builder.Add("pagenumber", pagingOptions.CurrentPage.ToString());
builder.Add("pagesize", pagingOptions.PageSize.ToString());
}
/// <summary>
/// Gets a list of page indexes near current page.
/// </summary>
/// <param name="pagingOptions">The settings for paging.</param>
public IList <int> GetIndexes(IPagingOptions pagingOptions)
{
return(Enumerable
.Range(Math.Max(pagingOptions.PageIndex - distance, 0), Math.Min(pagingOptions.PageIndex + distance + 1, pagingOptions.PagesCount))
.ToList());
}
private string PagingParams(IPagingOptions pagingOptions)
=> $"pagenumber={pagingOptions.CurrentPage}&pagesize={pagingOptions.PageSize}";
internal static async Task <IPagedData <TInterface> > FindAsync <TInterface, TData, TDto, TSortProperty>(IQueryable <TData> queryable,
IMapper <TInterface, TDto> mapper,
Expression <Func <TInterface, bool> > filter,
Expression <Func <TInterface, TSortProperty> > sort,
ListSortDirection sortDirection,
IPagingOptions pagingOptions,
CancellationToken cancellationToken)
where TInterface : class
where TData : class, TInterface
where TDto : class, TInterface, new()
where TSortProperty : IComparable
{
var data = queryable.ConstrainedFind(filter, sort, sortDirection, pagingOptions)
.Select(medicineType => mapper.Map(medicineType))
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
var totalRecordCount = queryable.CountAsync(filter, cancellationToken)
.ConfigureAwait(false);
return(new PagedData <TInterface>(await data, pagingOptions.PageSize, pagingOptions.PageNumber, await totalRecordCount));
}
