Exemplo n.º 1
0
        public async Task <PaginatedBurnRuleList> GetPagedAsync(BurnRuleListRequestModel request, bool includeContents)
        {
            var predicate = PredicateBuilder.New <BurnRuleEntity>(c => !c.IsDeleted);

            if (!string.IsNullOrWhiteSpace((request.Title)))
            {
                predicate = predicate.And(c => c.Title.ToLower()
                                          .Contains(request.Title.Trim().ToLower()));
            }

            if (request.PartnerId != null)
            {
                predicate = predicate
                            .And(c => c.BurnRulePartners.Any(p => p.PartnerId == request.PartnerId));
            }

            using (var context = _msSqlContextFactory.CreateDataContext())
            {
                var query = context.BurnRules.AsNoTracking();
                if (includeContents)
                {
                    query = query
                            .Include(e => e.BurnRuleContents)
                            .Include(e => e.BurnRulePartners);
                }

                var results = await query
                              .Where(predicate)
                              .ToListAsync();

                var total = results.Count;

                var skip = (request.CurrentPage - 1) * request.PageSize;

                results = results
                          .OrderByDescending(c =>
                {
                    switch (c.Vertical)
                    {
                    case Vertical.RealEstate:
                        return(3);

                    case Vertical.Hospitality:
                        return(2);

                    case Vertical.Retail:
                        return(1);

                    default:
                        return(0);
                    }
                })
                          .ThenBy(c => c.Order)
                          .ThenByDescending(c => c.CreationDate)
                          .Skip(skip)
                          .Take(request.PageSize)
                          .ToList();

                return(new PaginatedBurnRuleList
                {
                    BurnRules = _mapper.Map <List <BurnRuleModel> >(results),
                    CurrentPage = request.CurrentPage,
                    PageSize = request.PageSize,
                    TotalCount = total
                });
            }
        }
 public async Task <PaginatedBurnRuleList> GetPagedAsync(BurnRuleListRequestModel paginationModel)
 {
     return(await _burnRuleRepository.GetPagedAsync(paginationModel, false));
 }