public async Task <IActionResult> Index(GetListingPagingRequest request)
        {
            var data = await _listingsController.GetAllListing(request);

            if (!data.IsSuccessed)
            {
                ModelState.AddModelError(string.Empty, data.Message);
            }

            return(View(data.ResultObj));
        }
Exemple #2
0
        public async Task <List <ListingViewModel> > GetAllListingAsync(GetListingPagingRequest filter)
        {
            List <Listing> query = await _repository.ListingRepo.FindByCondition(x => x.Status != Status.Disabled).ToListAsync();

            if (filter.MaxPrice.HasValue)
            {
                query = query.Where(x => x.StartingPrice < filter.MaxPrice).ToList();
            }

            if (filter.MaxAge.HasValue)
            {
                query = query.Where(x => x.BuiltYear < filter.MaxAge).ToList();
            }

            if (filter.MinSize.HasValue)
            {
                query = query.Where(x => x.Size > filter.MinSize).ToList();
            }

            if (filter.Limit.HasValue)
            {
                query = query.OrderByDescending(x => x.Id)
                        .Skip(filter.Limit.Value * (filter.Offset.Value - 1))
                        .Take(filter.Limit.Value).ToList();
            }

            if (filter.Sold.HasValue)
            {
                query = query.Where(x => x.Status == Status.Sold).ToList();
            }

            if (filter.Address != null)
            {
                query = query.Where(x => x.AddressLine1.Contains(filter.Address) ||
                                    x.Zip.ToString().Contains(filter.Address) ||
                                    x.City.Contains(filter.Address) ||
                                    x.State.Contains(filter.Address)).ToList();
            }

            if (filter.OrderBy != null)
            {
                query = query.OrderBy(x => x.GetType().GetProperty(filter.OrderBy).GetValue(x, null)).ToList();
            }

            List <ListingViewModel> data = _mapper.Map <List <Listing>, List <ListingViewModel> >(query);

            return(data);
        }
Exemple #3
0
        public async Task <ApiResult <PagedResult <ListingViewModel> > > GetListingPaging(GetListingPagingRequest request)
        {
            var query = await GetAllListingAsync(request);

            foreach (var item in query)
            {
                var listingPhotos = await GetListListingPhotoAsync(item.Id);

                if (listingPhotos.Count > 0)
                {
                    var photos = listingPhotos.Where(x => x.IsDefault == true).FirstOrDefault();

                    if (photos != null)
                    {
                        item.PhotoUrl = photos.PhotoUrl;
                    }
                }
            }

            int totalRow = query.Count();

            var data = query.Skip((request.PageIndex - 1) * request.PageSize)
                       .Take(request.PageSize)
                       .Select(x => x)
                       .ToList();

            var pageResult = new PagedResult <ListingViewModel>()
            {
                TotalRecords = totalRow,
                PageIndex    = request.PageIndex,
                PageSize     = request.PageSize,
                Items        = data
            };

            if (data is null)
            {
                return(new ApiErrorResult <PagedResult <ListingViewModel> >("No records found"));
            }

            return(new ApiSuccessResult <PagedResult <ListingViewModel> >(pageResult));
        }
Exemple #4
0
        public async Task <ApiResult <PagedResult <ListingViewModel> > > GetAllListing([FromQuery] GetListingPagingRequest filter)
        {
            var listings = await _listingService.GetListingPaging(filter);

            return(listings);
        }