public static Task <PaginatedResult <TItem> > MakePageAsync <TCount, TItem>(this IPaginator paginator, IRepositoryBase repository,
IQueryable <TCount> countQuery,
IQueryable <TItem> itemsQuery,
PaginatedQuery model, CancellationToken cancellationToken = default)
where TCount : class where TItem : class
{
if (paginator == null)
{
throw new ArgumentNullException(nameof(paginator));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (countQuery == null)
{
throw new ArgumentNullException(nameof(countQuery));
}
if (itemsQuery == null)
{
throw new ArgumentNullException(nameof(itemsQuery));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
return(paginator.MakePageAsync(repository, countQuery, itemsQuery, model.Page, model.PageSize, cancellationToken));
}
public async Task <IPagedResults <EvacueeListItem> > GetEvacueesPaginatedAsync(EvacueeSearchQueryParameters searchQuery)
{
var query = AssembleQuery(searchQuery);
var pagedQuery = new PaginatedQuery <Models.Db.ViewEvacuee>(query, searchQuery.Offset, searchQuery.Limit);
var evacuees = await pagedQuery.Query.Sort(MapSortToFields(searchQuery.SortBy)).Distinct().Select(e => mapper.Map <EvacueeListItem>(e)).ToArrayAsync();
return(new PaginatedList <EvacueeListItem>(evacuees, pagedQuery.Pagination));
}
public async Task <Paginated <TEntity> > GetWherePaginated(PaginatedQuery <TEntity> query)
{
int start = (query.Page - 1) * query.PageSize;
List <TEntity> data = new List <TEntity>();
if (query.Order == Enumerators.Order.Ascending)
{
if (query.ChildObjectNamesToInclude != null && query.ChildObjectNamesToInclude.Count() > 0)
{
var queryable = _context.Set <TEntity>().AsQueryable();
foreach (var item in query.ChildObjectNamesToInclude)
{
queryable = queryable.Include(item);
}
queryable = queryable.Where(query.predicate).OrderBy(x => x.Id).AsNoTracking().Skip(start).Take(query.PageSize);
data = await queryable.ToListAsync();
}
else
{
data = await _context.Set <TEntity>().Where(query.predicate).OrderBy(x => x.Id).AsNoTracking().Skip(start).Take(query.PageSize).ToListAsync();
}
}
else
{
if (query.ChildObjectNamesToInclude != null && query.ChildObjectNamesToInclude.Count() > 0)
{
var queryable = _context.Set <TEntity>().AsQueryable();
foreach (var item in query.ChildObjectNamesToInclude)
{
queryable = queryable.Include(item);
}
data = await queryable.Where(query.predicate).OrderByDescending(x => x.Id).AsNoTracking().Skip(start).Take(query.PageSize).ToListAsync();
}
else
{
data = await _context.Set <TEntity>().Where(query.predicate).OrderByDescending(x => x.Id).AsNoTracking().Skip(start).Take(query.PageSize).ToListAsync();
}
}
var count = await CountWhere(query.predicate);
return(new Paginated <TEntity> {
Page = query.Page, PageSize = query.PageSize, Data = data, TotalCount = count
});
}
public async Task <PaginatedResult <ProductsListModel> > GetPage(PaginatedQuery request)
{
var query = _readOnlyRepository.Query <Product>(x => x.Status == EnabledStatus.Enabled);
if (!string.IsNullOrEmpty(request.Term))
{
var term = request.Term.Trim();
query = query.Where(x => x.Name.Contains(term));
}
var sortCriteria = request.GetSortCriteria();
var items = query
.ProjectTo <ProductsListModel>(_mapper.ConfigurationProvider)
.OrderByOrDefault(sortCriteria, x => x.Name);
var page = await _paginator.MakePageAsync(_readOnlyRepository, query, items, request);
return(page);
}
public async Task <IActionResult> Get([FromQuery] PaginatedQuery query)
{
var page = await _cartService.GetPage(query);
return(Ok(page));
}
public ActionResult <PagedListResult <Hero> > Paginated([FromQuery] PaginatedQuery query)
{
return(Ok(businessLayer.GetPaginated(query.PageNumber, query.PageSize, query.OrderBy, query.SortDirection)));
}
public async Task <IPagedResults <EvacueeListItem> > GetEvacueesAsync(EvacueeSearchQueryParameters searchQuery)
{
if (searchQuery.HasSortBy())
{
// Sort by whatever parameter was included with the query
searchQuery.SortBy = MapSortToFields(searchQuery.SortBy);
}
else
{
// default search is always sort descending by ess file number
searchQuery.SortBy = "-essFileNumber";
};
var query = db.ViewEvacuees
// Inactive evacuees are soft deleted. We do not return them or give the user the option yet.
.Where(e => e.Active == searchQuery.Active)
// we sort the larger collection first before letting the subset (paginated ones be sorted)
.Sort(MapSortToFields(searchQuery.SortBy));
if (searchQuery.HasQuery())
{
// Simple search. When a search query is provided search should match multiple things from the record. Query can match multiple things.
query = query.Where(e =>
EF.Functions.Like(e.LastName, $"%{searchQuery.Query}%") ||
e.IncidentTaskNumber == searchQuery.Query ||
e.RegistrationId == searchQuery.Query ||
EF.Functions.Like(e.EvacuatedTo, $"%{searchQuery.Query}%") ||
EF.Functions.Like(e.EvacuatedFrom, $"%{searchQuery.Query}%"));
}
else
{
// Advanced search. There is a null query. However the client has supplied other specific parameters to search by.
// if a search parameter is not null, then add a "where" clause to the query matching the supplied UTF-16 query string
if (!string.IsNullOrWhiteSpace(searchQuery.LastName))
{
query = query.Where(e => EF.Functions.Like(e.LastName, $"%{searchQuery.LastName}%"));
}
if (!string.IsNullOrWhiteSpace(searchQuery.FirstName))
{
query = query.Where(e => EF.Functions.Like(e.FirstName, $"%{searchQuery.FirstName}%"));
}
if (!string.IsNullOrWhiteSpace(searchQuery.IncidentTaskNumber))
{
query = query.Where(e => e.IncidentTaskNumber == searchQuery.IncidentTaskNumber);
}
if (!string.IsNullOrWhiteSpace(searchQuery.EssFileNumber))
{
query = query.Where(e => e.RegistrationId == searchQuery.EssFileNumber);
}
if (!string.IsNullOrWhiteSpace(searchQuery.EvacuatedFrom))
{
query = query.Where(e => e.EvacuatedFrom == searchQuery.EvacuatedFrom);
}
if (!string.IsNullOrWhiteSpace(searchQuery.EvacuatedTo))
{
query = query.Where(e => e.EvacuatedTo == searchQuery.EvacuatedTo);
}
// if has referrals has a value do some things. Else is omit the where clause so it is omitted
if (searchQuery.HasReferrals.HasValue)
{
// (Why can searchQuery be valueless in the object? It should take memory space whether we intantiate it or not.)
if (searchQuery.HasReferrals.Value)
{
// set the "where" clause for only evacuees with referrals
query = query.Where(e => e.HasReferrals);
}
else
{
// set the "where" clause for only evacuees without referrals
query = query.Where(e => !e.HasReferrals);
}
}
// allow for filtering on registration completion state
if (searchQuery.RegistrationCompleted.HasValue)
{
query = query.Where(e => e.IsFinalized == searchQuery.RegistrationCompleted.Value);
}
}
// build the paginated query
var pagedQuery = new PaginatedQuery <Models.Db.ViewEvacuee>(query, searchQuery.Offset, searchQuery.Limit);
// get results back from
var results = await pagedQuery.Query.Sort(MapSortToFields(searchQuery.SortBy)).ToArrayAsync();
// map the evacueeList
return(new PaginatedList <EvacueeListItem>(results.Select(mapper.Map <EvacueeListItem>), pagedQuery.Pagination));
}
public async Task <IActionResult> GetCategories([FromQuery] PaginatedQuery query)
{
var page = await _productsService.GetCategories(query);
return(Ok(page));
}
public async Task <IActionResult> Get([FromQuery] PaginatedQuery query, Guid categoryid)
{
var page = await _productsService.GetPage(query, categoryid);
return(Ok(page));
}
