public IEnumerable <ApiProductUserDto> GetUserQueriedProductList(ProductFiltersViewModel searchModel)
        {
            var products = _productRepository.SearchResultFromSqlStoredProcedure(searchModel.Name,
                                                                                 searchModel.PriceFrom,
                                                                                 searchModel.PriceTo,
                                                                                 searchModel.DateTimeTo,
                                                                                 searchModel.DateTimeFrom,
                                                                                 searchModel.ProductCategoryId);

            var requestContext = HttpContext.Current.Request.RequestContext;

            var apiproducts = products.Select(p => new ApiProductUserDto()
            {
                Name          = p.Name,
                Id            = p.Id,
                AmountInStock = p.AmountInStock,
                Price         = p.Price,
                Description   = p.Description,
                BuyLink       = new UrlHelper(requestContext).Action("Buy", "Cart", new { id = p.Id, Area = "" }),
                DetailsLink   = new UrlHelper(requestContext).Action("Details", "Product", new { id = p.Id, Area = "" }),
                Thumbnail     = new UrlHelper(requestContext).Content("~/Images/" + p.ThumbnailName ?? "no-image.jpg"),
            });


            return(apiproducts);
        }
        public IEnumerable <ApiProductDto> GetAdminQueriedProductList(ProductFiltersViewModel searchModel)
        {
            var products = _productRepository.SearchResultFromSqlStoredProcedure(searchModel.Name,
                                                                                 searchModel.PriceFrom,
                                                                                 searchModel.PriceTo,
                                                                                 searchModel.DateTimeTo,
                                                                                 searchModel.DateTimeFrom,
                                                                                 searchModel.ProductCategoryId);

            var requestContext = HttpContext.Current.Request.RequestContext;

            var apiproducts = products.Select(p => new ApiProductDto()
            {
                Name          = p.Name,
                CategoryName  = p.CategoryName,
                AmountInStock = p.AmountInStock,
                DateOfAdding  = p.DateOfAdding?.ToString("dd/MM/yyyy"),
                Price         = p.Price,
                Description   = p.Description,
                EditLink      = new UrlHelper(requestContext).Action("Edit", "Product", new { id = p.Id, Area = "Admin" }),
                DeleteLink    = new UrlHelper(requestContext).Action("Delete", "Product", new { id = p.Id, Area = "Admin" }),
            });

            return(apiproducts);
        }
Exemple #3
0
        private SortDefinition <Product> GetSortings(ProductFiltersViewModel model)
        {
            List <SortDefinition <Product> > sortings = new List <SortDefinition <Product> >();
            var priceSorting = PriceSorting(model);

            if (priceSorting != null)
            {
                sortings.Add(priceSorting);
            }

            var ratingSorting = RatingSorting(model);

            if (ratingSorting != null)
            {
                sortings.Add(ratingSorting);
            }

            if (sortings.Count > 0)
            {
                return(Builders <Product> .Sort.Combine(sortings));
            }
            else
            {
                return(null);
            }
        }
Exemple #4
0
        public List <Product> GetFilteredProducts(ProductFiltersViewModel model, int offset, int qty)
        {
            IMongoCollection <Product> collection = ProductConnect();
            var filters = new List <FilterDefinition <Product> >();

            if (model.Filters != null)
            {
                filters = Filters(model.Filters);
            }

            filters.AddRange(StaticFilters(model));
            var filter = Builders <Product> .Filter.And(filters);

            var qresult  = collection.Find(filter);
            var sortings = GetSortings(model);

            if (sortings != null)
            {
                qresult = qresult.Sort(sortings);
            }

            var result = qresult
                         .Skip(offset)
                         .Limit(qty)
                         .ToList();

            return(result);
        }
Exemple #5
0
        public PartialViewResult Filter(ProductFiltersViewModel model)
        {
            ClearHttp();
            HttpContext.Session.SetOrUpdate <ProductFiltersViewModel>("ProductFilters", model);
            var result = CategoryProductLogic.GetProductsWithFilters(model, 0, Qty, model.inputSearch);

            return(PartialView("ProductCard", result.GetModel));
        }
        public ProductFiltersViewModel GetProductSearch()
        {
            var viewModel = new ProductFiltersViewModel
            {
                ProductCategories = _productCategoryService.GetProductCategoryList(),
            };

            return(viewModel);
        }
Exemple #7
0
        public async Task <IActionResult> GetTotalQtyByFilters([FromQuery] ProductFiltersViewModel filtersVM)
        {
            try
            {
                var filtersDto = _mapper.Map <ProductFiltersViewModel, ProductFiltersDto>(filtersVM);
                int qty        = await _productUseCases.GetTotalQtyByFilters(filtersDto);

                return(Ok(qty));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Exemple #8
0
        public async Task <IActionResult> GetByFilters([FromQuery] ProductFiltersViewModel filtersVM)
        {
            try
            {
                var filtersDto = _mapper.Map <ProductFiltersViewModel, ProductFiltersDto>(filtersVM);
                IEnumerable <ProductDto> productsDto = await _productUseCases.GetByFilters(filtersDto);

                IEnumerable <ProductViewModel> productsVM = _mapper.Map <IEnumerable <ProductDto>, IEnumerable <ProductViewModel> >(productsDto);
                return(Ok(productsVM));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Exemple #9
0
        public async Task <IActionResult> CreatePdf([FromQuery] ProductFiltersViewModel filtersVM)
        {
            try
            {
                var          filtersDto = _mapper.Map <ProductFiltersViewModel, ProductFiltersDto>(filtersVM);
                MemoryStream stream     = await _productUseCases.CreatePdf(filtersDto);

                stream.Position = 0;
                return(File(stream, "application/pdf"));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Exemple #10
0
        private SortDefinition <Product> PriceSorting(ProductFiltersViewModel model)
        {
            if (model.SortPrice == "Low")
            {
                return(Builders <Product> .Sort.Ascending(x => x.Price));
            }

            if (model.SortPrice == "High")
            {
                return(Builders <Product> .Sort.Descending(x => x.Price));
            }
            else
            {
                return(null);
            }
        }
Exemple #11
0
        public SortDefinition <Product> RatingSorting(ProductFiltersViewModel model)
        {
            if (model.SortRating == "Low")
            {
                return(Builders <Product> .Sort.Ascending(x => x.Rating));
            }

            if (model.SortRating == "High")
            {
                return(Builders <Product> .Sort.Descending(x => x.Rating));
            }
            else
            {
                return(null);
            }
        }
        public async Task <ProductFiltersViewModel> GetFilters()
        {
            // TODO: create api method to get all filter setup
            var brands = await _shopy.ListBrands();

            var sizes = await _shopy.ListSizes();

            var categoriesLookup = await _shopy.LookupCategories();

            var viewModel = new ProductFiltersViewModel
            {
                BrandFilters    = _mapper.Map <IEnumerable <FilterViewModel> >(brands),
                SizeFilters     = _mapper.Map <IEnumerable <FilterViewModel> >(sizes),
                CategoryFilters = _mapper.Map <IEnumerable <FilterViewModel> >(categoriesLookup),
            };

            return(viewModel);
        }
Exemple #13
0
        public PartialViewResult GetMore(string category, int offset, string inputSearch)
        {
            ProductLogic.ModelOrError <OutputModelsForCategoryProduct.CategoryProductsModel> model;
            ProductFiltersViewModel filters = new ProductFiltersViewModel {
                Category = category, inputSearch = inputSearch
            };

            if (HttpContext.Session.Keys.Contains("ProductFilters"))
            {
                filters = HttpContext.Session.Get <ProductFiltersViewModel>("ProductFilters");
            }
            model = CategoryProductLogic.GetProductsWithFilters(filters, offset, Qty, inputSearch);
            if (model.GetModel != null)
            {
                return(PartialView("ProductCard", model.GetModel));
            }
            return(null);
        }
Exemple #14
0
        private FilterDefinition <Product> PriceFilter(ProductFiltersViewModel model)
        {
            FilterDefinition <Product> priceFilter;
            var maxFilter = FilterDefinition <Product> .Empty;
            var minFilter = FilterDefinition <Product> .Empty;

            if (model.MaxPrice.HasValue)
            {
                maxFilter = Builders <Product> .Filter.Lte("Price", model.MaxPrice.Value);
            }

            if (model.MinPrice.HasValue)
            {
                minFilter = Builders <Product> .Filter.Gte("Price", model.MinPrice.Value);
            }

            priceFilter = maxFilter & minFilter;
            return(priceFilter);
        }
Exemple #15
0
        public FilterDefinition <Product> RatingFilter(ProductFiltersViewModel model)
        {
            FilterDefinition <Product> ratingFilter;
            var maxFilter = FilterDefinition <Product> .Empty;
            var minFilter = FilterDefinition <Product> .Empty;

            if (model.MaxRating.HasValue)
            {
                maxFilter = Builders <Product> .Filter.Lte("Rating", model.MaxRating.Value);
            }

            if (model.MinRating.HasValue)
            {
                minFilter = Builders <Product> .Filter.Gte("Rating", model.MinRating.Value);
            }

            ratingFilter = maxFilter & minFilter;
            return(ratingFilter);
        }
Exemple #16
0
        public IActionResult CategoryProducts(string category)
        {
            ClearHttp();
            var filters = new ProductFiltersViewModel();

            filters.Category = category;
            string inputString = Request.Query.FirstOrDefault(p => p.Key == "inputSearch").Value;

            filters.inputSearch = inputString;
            var model = CategoryProductLogic.GetProductsWithFilters(filters, 0, Qty, inputString);

            if (model.GetModel != null)
            {
                return(View(model.GetModel));
            }
            TempData.AddOrUpdate("Error", model.GetErrorMessage);


            return(Redirect(Request.Headers["Referer"].ToString()));
        }
Exemple #17
0
        public List <FilterDefinition <Product> > StaticFilters(ProductFiltersViewModel model)
        {
            var categoryFilter = CategoryFilter(model);
            FilterDefinition <Product> priceFilter = PriceFilter(model);
            var ratingFilter = RatingFilter(model);

            if (model.inputSearch == null)
            {
                return(new List <FilterDefinition <Product> > {
                    categoryFilter, priceFilter, ratingFilter
                });
            }
            else
            {
                var searchFilter = Builders <Product> .Filter.Text(model.inputSearch);

                return(new List <FilterDefinition <Product> > {
                    searchFilter, categoryFilter, priceFilter, ratingFilter
                });
            }
        }
Exemple #18
0
 private FilterDefinition <Product> CategoryFilter(ProductFiltersViewModel model)
 {
     return(Builders <Product> .Filter.Eq("CategoryName", model.Category));
 }
        public IHttpActionResult UserSearch(ProductFiltersViewModel dto)
        {
            var productList = _productService.GetUserQueriedProductList(dto);

            return(Ok(productList));
        }