protected virtual void CheckFilter(PagedFilter filter)
{
if (!filter.TenantRestrict && !CurrentUser.Right.CanSuperuser)
{
filter.TenantRestrict = true;
}
}
public async Task <IActionResult> Get([FromQuery] PageFilter pageFilter, [FromQuery] OfferViewModelFilter filter)
{
Expression <Func <Offer, bool> > offerFilter = OfferFilter.ConvertTo(filter);
offerFilter = offerFilter.AndAlso(x => x.Active == true);
PagedFilter <Offer> pagedFilter =
new PagedFilter <Offer>(pageFilter.Page, pageFilter.Limit, offerFilter);
Expression <Func <Offer, object> >[] includes = new Expression <Func <Offer, object> >[] {
x => x.Employer,
x => x.OfferType
};
PagedResult <Offer> offers = await _offerService.Get(pagedFilter, include : includes);
IEnumerable <OfferViewModel> offerViewModel = OfferViewModel.From(offers.Data);
PagedResult <OfferViewModel> queryResult = new PagedResult <OfferViewModel>(offerViewModel,
offers.Page,
offers.Limit,
offers.ElementsCount);
return(Ok(queryResult));
}
public async Task <PagedResult <TEntity> > Get(PagedFilter <TEntity> pagedFilter,
IEnumerable <Expression <Func <TEntity, object> > > includes,
Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderBy = null)
{
var elementsCountTask = CountAsync(pagedFilter.Filter);
IQueryable <TEntity> query = includes != null
? includes.Aggregate(_context.Set <TEntity>().AsQueryable(),
(current, include) => current.Include(include))
: _context.Set <TEntity>();
query = query.Where(pagedFilter.Filter);
if (orderBy != null)
{
query = orderBy(query);
}
var elementsTask = query.Skip(pagedFilter.GetOmittedPages())
.Take(pagedFilter.Limit)
.AsNoTracking()
.ToListAsync();
await Task.WhenAll(elementsTask, elementsCountTask);
return(new PagedResult <TEntity>(elementsTask.Result, pagedFilter.Page, pagedFilter.Limit,
elementsCountTask.Result));
}
public async Task <IActionResult> GetProduct([FromQuery] PagedFilter filter, [FromQuery] int brandid, [FromQuery] int categoryid, [FromQuery] String status)
{
var resfilter = new PagedFilter(filter.pageIndex, filter.pageSize);
var productDTOs = await _context.product
.Where(p =>
(brandid != 0 ? p.brandId == brandid : true) &&
(categoryid != 0 ? p.categoryId == categoryid : true) &&
(status != null ? p.status.Equals(status) : true))
.Select(p => p.toProductDTO())
.ToListAsync();
foreach (var productDTO in productDTOs)
{
// Create skuDTOs
var skuDTOs = await _context.skus.Where(sku => sku.productId == productDTO.id).Select(sku => sku.toskuDTO()).ToListAsync();
foreach (var skuDTO in skuDTOs)
{
// Create imageDTOs
skuDTO.images = await _context.images.Where(img => img.skuId == skuDTO.id).Select(img => img.toimageDto()).ToListAsync();
}
productDTO.skus = skuDTOs;
}
var route = Request.Path.Value;
var totalcount = await _context.product.Select(p => p.toProductDTO()).CountAsync();
var pagedesponse = Pagedresponse.createpagedresponse <ProductDTO>(productDTOs, filter, totalcount, _uriservice, route);
return(Ok(pagedesponse));
}
public async Task <IActionResult> GetOrders([FromQuery] PagedFilter filter, [FromQuery] int id, [FromQuery] DateTime createdate, [FromQuery] String paymentmethod, [FromQuery] decimal shippingfee, [FromQuery] String status)
{
var resfilter = new PagedFilter(filter.pageIndex, filter.pageSize);
var orderDTOs = await _context.ordertable
.Where(q =>
(id != 0 ? q.id == id : true) &&
(createdate == null ? DateTime.Compare(createdate, q.createDate) == 0 : true) &&
(paymentmethod != null ? q.paymentMethod.Equals(paymentmethod) : true) &&
(shippingfee != 0 ? q.shippingFee == shippingfee : true) &&
(status != null ? q.status.Equals(status) : true)
).Select(order => order.toorder_tblDTO()).ToListAsync();
foreach (var orderDTO in orderDTOs)
{
var customerEntity = await _context.customers.FindAsync(orderDTO.customerId);
orderDTO.customer = customerEntity.tocustomerDTO();
var orderItemDTOs = await _context.orderitem.Where(item => item.orderTableId == orderDTO.id).Select(item => item.toorder_itemDTO()).ToListAsync();
orderItemDTOs.ForEach(orderItemDTO => {
var skuDTO = _context.skus.Find(orderItemDTO.skuId).toskuDTO();
skuDTO.images = _context.images.Where(image => image.skuId == skuDTO.id).Select(image => image.toimageDto()).ToList();
orderItemDTO.sku = skuDTO;
});
orderDTO.orderItems = orderItemDTOs;
}
var route = Request.Path.Value;
var totalcount = await _context.ordertable.Select(p => p.toorder_tblDTO()).CountAsync();
var pagedesponse = Pagedresponse.createpagedresponse <OrderTableDTO>(orderDTOs, filter, totalcount, _uriService, route);
return(Ok(pagedesponse));
}
public async Task <ItemsViewModel <FelhasznaloListViewModel> > ListAsync(PagedFilter
filter, CancellationToken cancellationToken)
{
if (filter is null)
{
throw new ArgumentNullException(nameof(filter));
}
var totalCount = await
_dbContext.Felhasznalok.CountAsync(cancellationToken);
var felhasznalok = await _dbContext.Felhasznalok
.Skip(filter.Skip)
.Take(filter.Take)
.Select(x => new FelhasznaloListViewModel
{
Id = x.Id,
Felhasznalonev = x.Felhasznalonev,
Email = x.Email,
Jelszo = x.Jelszo
})
.ToListAsync(cancellationToken);
return(new ItemsViewModel <FelhasznaloListViewModel>
{
Items = felhasznalok,
TotalCount = totalCount
});
}
public async Task <IActionResult> GetSkus([FromQuery] PagedFilter filter)
{
var resfilter = new PagedFilter(filter.pageIndex, filter.pageSize);
List <SkuDTO> d = new List <SkuDTO>();
var data2 = await _context.skus.ToListAsync();
foreach (var sku1 in data2)
{
var newsku = new SkuDTO
{
id = sku1.id,
seller_sku = sku1.seller_sku,
available = sku1.available,
quantity = sku1.quantity,
color = sku1.color,
size = sku1.size,
height = sku1.height,
width = sku1.width,
length = sku1.length,
weight = sku1.weight,
price = sku1.price,
productId = sku1.productId,
images = _context.images.Where(x => x.skuId == sku1.id).Select(p => p.toimageDto())
};
d.Add(newsku);
}
var data = await _context.skus.Select(p => p.toskuDTO()).ToListAsync();
return(Ok(data));
}
public async Task <IActionResult> GetOrderItems([FromQuery] PagedFilter filter1)
{
var filter = new PagedFilter(filter1.pageIndex, filter1.pageSize);
var data = await _context.orderitem.Select(p => p.toorder_itemDTO()).ToListAsync();
return(Ok(data));
}
public Uri getpageurl(PagedFilter filter, string route)
{
var endpointurl = new Uri(string.Concat(_base_url, route));
var modifield = (QueryHelpers.AddQueryString(endpointurl.ToString(), "pagenumber", filter.pageIndex.ToString()));
modifield = (QueryHelpers.AddQueryString(modifield, "pagesize", filter.pageSize.ToString()));
return(new Uri(modifield));
}
public FilterResult <T> Search <T>(PagedFilter <TEntity> filter, Expression <Func <TEntity, T> > parser)
{
var query =
Table
.AsNoTracking()
.Where(filter.ToExpresion())
.Select(parser);
return(Paginate(filter, query));
}
public async Task <PagedCollection <OwnerDto> > GetAllAsync(PagedFilter filter)
{
var result = new PagedCollection <OwnerDto>();
var owners = await OwnerPropertyDbContext.Owners.AsNoTracking().Where(w => !w.IsDeleted).Skip(filter.Page * filter.Take).Take(filter.Take).ToListAsync();
result.Items = owners.MapTo <IEnumerable <OwnerDto> >().ToList();
result.Total = await OwnerPropertyDbContext.Owners.CountAsync(w => !w.IsDeleted);
return(result);
}
public static void ApplyPaging(this IRestRequest request, PagedFilter filter)
{
if (filter.PageNumber.HasValue)
{
request.AddQueryParameter("page_num", filter.PageNumber.Value.ToString());
}
if (filter.PageSize.HasValue)
{
request.AddQueryParameter("page_size", filter.PageSize.Value.ToString());
}
}
public async void Owners_Paged_from_6_to_10()
{
var ownerDomain = new OwnerDomain(_fixture.GetDbContext());
var filter = new PagedFilter {
Page = 1, Take = 5
};
var result = await ownerDomain.GetAllAsync(filter);
Assert.True(result.Items.FirstOrDefault()?.Id == 6);
Assert.True(result.Total == 10);
}
public async Task <List <User> > FilterUsers(PagedFilter <User, UserSortFields> filter)
{
var users = Users;
if (filter != null)
{
users = users.FilterQuery(filter);
}
return(await users.ToListAsync());
}
public async Task <PagedCollection <UserWithBalanceDto> > GetListAsync(PagedFilter pagedFilter)
{
Debug.Assert(pagedFilter == null);
var result = new PagedCollection <UserWithBalanceDto>();
var users = await BalanceManagementDbContext.Users.AsNoTracking().Where(w => !w.IsDeleted).Skip(pagedFilter.Page * pagedFilter.Take).Take(pagedFilter.Take).ToListAsync();
result.Items = users.MapTo <IEnumerable <UserWithBalanceDto> >().ToList();
result.Total = await BalanceManagementDbContext.Users.CountAsync(w => !w.IsDeleted);
return(result);
}
public async Task <IActionResult> GetListAsync([FromQuery] PagedFilter filter)
{
var userId = (int?)null;
if (GetRole() == Roles.User)
{
userId = GetUser();
}
var result = await _accountService.GetListAsync(userId, filter);
return(result.Items.Any() ? (IActionResult)Ok(result) : NotFound());
}
public async Task <IPagedList <Vehicle> > GetAvailableVehicles(PagedFilter filter)
{
var vehicleListAsync = await _context.Vehicles.Where(x => x.IsDeleted == false && x.BookingDate.AddHours(24) < DateTime.UtcNow).OrderBy(x => x.Make).ThenBy(x => x.Model).Skip(filter.Skip)
.Take(filter.Take).ToListAsync();
return(new PagedList <Vehicle>
{
Take = filter.Take,
Skip = filter.Skip,
Total = vehicleListAsync.Count,
Results = vehicleListAsync
});
}
public async Task <PagedCollection <AccountDto> > GetListAsync(int?userId, PagedFilter pagedFilter)
{
var pagedCollection = new PagedCollection <AccountDto>
{
Items = (await BalanceManagementDbContext.Accounts
.Where(w => !w.IsDeleted && w.UserId == (userId ?? w.UserId))
.Skip(pagedFilter.Page * pagedFilter.Take)
.Take(pagedFilter.Take).AsNoTracking().ToListAsync()).MapTo <List <AccountDto> >(),
Total = await BalanceManagementDbContext.Accounts.CountAsync(w => !w.IsDeleted)
};
return(pagedCollection);
}
public async Task <IActionResult> GetBalanceByAccountAsync(int id, [FromQuery] PagedFilter filter)
{
if (GetRole() == Roles.User && !await _accountService.IsOwnerAccountAsync(GetUser(), id))
{
return(Forbid());
}
var userId = GetRole() == Roles.User ? GetUser() : (int?)null;
var accountFilter = new AccountFilter {
AccountId = id, Page = filter.Page, Take = filter.Take, UserId = userId
};
var result = await _accountTransactionService.GetTransactionByAccountAsync(accountFilter);
return(result.Items.Any() ? (IActionResult)Ok(result) : NotFound());
}
public async Task <IPagedList <VehicleListingVm> > GetAvailableVehicles(PagedFilter filter)
{
var availableVehicles = await _vehicleRepository.GetAvailableVehicles(filter);
return(new PagedList <VehicleListingVm>
{
Take = availableVehicles.Take,
Skip = availableVehicles.Skip,
Total = availableVehicles.Total,
Results = availableVehicles.Results.Select(x => new VehicleListingVm {
Id = x.Id, Make = x.Make, Model = x.Model, IsDeleted = x.IsDeleted, CreatedOn = x.CreatedOn, UpdatedOn = x.UpdatedOn
}).ToList()
});
}
public async Task <IActionResult> Get([FromQuery] PageFilter pageFilter)
{
PagedFilter <OfferType> pagedFilter =
new PagedFilter <OfferType>(pageFilter.Page, pageFilter.Limit);
var offerTypes = await _offerTypeService.Get(pagedFilter);
var offerTypesDto = OfferTypeDto.From(offerTypes.Data);
PagedResult <OfferTypeDto> queryResult = new PagedResult <OfferTypeDto>(offerTypesDto,
offerTypes.Page,
offerTypes.Limit,
offerTypes.ElementsCount);
return(Ok(queryResult));
}
public void Process(PagedFilter filter, QueryStatistics stats)
{
Paging.Total = stats.TotalResults;
Paging.Intervals = Paging.Total / filter.Take;
if (Paging.Intervals * filter.Take == Paging.Total)
{
Paging.Intervals--;
}
Paging.Loadable = filter.Skip < Paging.Intervals;
var favourites = 0;
if (!filter.FavouriteRestrict)
{
foreach (var item in Result)
{
if (Favs.Any(f => f.Id == item.Id))
{
item.Favourite = true;
favourites++;
}
item.Searchable = new List <string>();
}
}
else
{
foreach (var item in Result)
{
item.Favourite = true;
item.Searchable = new List <string>();
favourites++;
}
}
Favourites = favourites;
Paging.Skip = filter.Skip;
}
public async Task <PagedResult <TEntity> > Get(PagedFilter <TEntity> pagedFilter,
Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderBy)
{
var elementsCountTask = CountAsync(pagedFilter.Filter);
IQueryable <TEntity> query = _context.Set <TEntity>().Where(pagedFilter.Filter);
if (orderBy != null)
{
query = orderBy(query);
}
var elementsTask = query.Skip(pagedFilter.GetOmittedPages())
.Take(pagedFilter.Limit)
.AsNoTracking()
.ToListAsync();
await Task.WhenAll(elementsTask, elementsCountTask);
return(new PagedResult <TEntity>(elementsTask.Result, pagedFilter.Page, pagedFilter.Limit,
elementsCountTask.Result));
}
public async Task <ActionResult <ItemsViewModel <FelhasznaloListViewModel> > > Get([FromQuery] PagedFilter filter, CancellationToken cancellationToken)
{
return(await _felhasznaloService.ListAsync(filter, cancellationToken));
}
public override async Task <IRavenQueryable <M> > Init(IRavenQueryable <M> query, PagedFilter filter, string favKey)
{
if (filter.TenantRestrict)
{
query = query.Where(c => c.TenantId == CurrentUser.TenantId);
}
if (filter.AuthorKeys.Any())
{
query = query.Where(v => v.AuthorId.In(filter.AuthorKeys));
}
return(await base.Init(query, filter, favKey));
}
public Task <List <TEntity> > FindAllAsync <TSortFields>(PagedFilter <TEntity, TSortFields> filter)
{
return(Query().FilterQuery(filter).ToListAsync());
}
public virtual async Task <PagedResult <T> > Get(PagedFilter <T> pagedFilter,
Func <IQueryable <T>, IOrderedQueryable <T> > orderBy = null)
{
return(await Repository.Get(pagedFilter, orderBy));
}
public PagedResult <Stock> List([FromUri] PagedFilter filter)
{
var query = _stockRepository.AsQueryable();
return(PagedResult <Stock> .From(query, filter));
}
public FilterResult <T> Search <T>(PagedFilter <TEntity> filter) where T : IToDto <TEntity, T>
{
var instance = Activator.CreateInstance <T>();
return(Search(filter, instance.ToDto()));
}
protected FilterResult <T> Search <T>(PagedFilter <T> filter, IQueryable <T> query)
{
query = query.Where(filter.ToExpresion());
return(Paginate(filter, query));
}
