private static void ApplyPaging(IPagingRequestModel model, IQueryPaging query)
{
int page = model.Page ?? 1;
int pagesize = model.PageSize ?? 100;
query.Skip = pagesize * (page - 1);
query.Take = pagesize;
}
//-----------------------------------------------------------
/// <summary>
/// Executes the query against the repository (database).
/// </summary>
/// <param name="searchQuery"></param>
/// <param name="sequence"></param>
/// <returns></returns>
protected virtual async Task <PagingResult <T> > GetTheResult(IQueryPaging searchQuery, IQueryable <T> sequence)
{
var resultCount = sequence.Count();
var result = (searchQuery.Take > 0)
? await(sequence.Skip(searchQuery.Skip).Take(searchQuery.Take).ToListAsync())
: await(sequence.ToListAsync());
bool hasNext = (searchQuery.Skip <= 0 && searchQuery.Take <= 0) ? false : (searchQuery.Skip + (searchQuery.Take - 1) < resultCount);
return(new PagingResult <T>()
{
Count = resultCount,
HasNext = hasNext,
Results = result
});
}
public static IQueryable <T> ApplyPaging <T>(this IQueryable <T> query, IQueryPaging queryObj)
{
if (queryObj == null)
{
return(query);
}
if (queryObj.PageIndex < 0)
{
queryObj.PageIndex = 0;
}
if (queryObj.PageSize <= 0)
{
queryObj.PageSize = 25;
}
return(query.Skip(queryObj.PageIndex * queryObj.PageSize).Take(queryObj.PageSize));
}
public async Task <IEnumerable <IDomainUser> > SearchByProperties(string query, IQuerySort sort, IQueryPaging paging)
{
var usersId = await(
from user in _store.Set <TUser>().AsQueryable()
join claim in _store.Set <IdentityUserClaim <TKey> >().AsQueryable() on user.Id equals claim.UserId into userClaims
from c in userClaims.DefaultIfEmpty()
where
(user.UserName.Contains(query) ||
user.Email.Contains(query) ||
c.ClaimValue.Contains(query)) ||
query == null
group user by user.Id)
.Sort(sort)
.Paginate(paging)
.Select(s => s.Key)
.ToListAsync();
return(_userManager.Users.Where(w => usersId.Contains(w.Id)));
}
public static IQueryable <TEntity> ApplyPaging <TEntity>(this IQueryable <TEntity> src, IQueryPaging paging) where TEntity : IDbEntity
{
if (paging != null)
{
src = src.Skip(paging.Offset).Take(paging.PageSize);
}
return(src);
}
public IQueryResult <ProductCategory> GetPaged(Expression <Func <ProductCategory, bool> > predicate, IQueryPaging queryObj = null)
{
throw new NotImplementedException();
}
public async Task <PagingResult <RoutePointEntity> > Search(IQueryPaging pager)
{
IQueryable <RoutePointEntity> sequence = this._context.RoutesPoint.Include(rp => rp.RouteInfo).Where(rp => rp.Status == 1);
return(await GetTheResult(pager, sequence));
}
public virtual IQueryResult <TEntity> GetPaged(Expression <Func <TEntity, bool> > predicate, IQueryPaging queryObj = null)
{
QueryResult <TEntity> result = new QueryResult <TEntity>();
IQueryable <TEntity> query = _dbSet;
query = query.ApplyFilter(predicate);
if (queryObj == null)
{
result.TotalItems = query.Count();
result.Items = query;
return(result);
}
result.TotalItems = query.Count();
query = query.ApplyPaging(queryObj);
result.Items = query;
return(result);
}
