public async Task <ActionResult <IReadOnlyList <ProductDto> > > GetProducts([FromQuery] ProductSpecificationParams productParams)
{
var specification = new ProductSpecification(productParams);
var products = await _repository.ListAsync(specification);
return(Ok(_mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductDto> >(products)));
}
public ProductsWithTypesAndBrandsSpecification(ProductSpecificationParams productsParams)
: base(criteria: p =>
(string.IsNullOrEmpty(productsParams.Search) || p.Name.ToLower().Contains(productsParams.Search)) &&
(!productsParams.BrandId.HasValue || p.ProductBrandId == productsParams.BrandId) &&
(!productsParams.TypeId.HasValue || p.ProductTypeId == productsParams.TypeId)
)
{
IncludeBrandsAndTypes();
ApplyPaging(CalculateSkip(productsParams.PageSize, productsParams.PageIndex), productsParams.PageSize);
if (!string.IsNullOrEmpty(productsParams.SortBy))
{
switch (productsParams.SortBy)
{
case "priceAsc":
AddOrderBy(p => p.Price);
break;
case "priceDesc":
AddOrderByDescending(p => p.Price);
break;
default:
AddOrderBy(p => p.Name);
break;
}
}
else
{
AddOrderBy(p => p.Name);
}
}
public ProductWithFiltersForCountSpecification(ProductSpecificationParams productParams)
: base(p =>
(string.IsNullOrEmpty(productParams.Search) || p.Name.ToLower().Contains(productParams.Search)) && // search product by name
(!productParams.BrandId.HasValue || p.ProductBrandId == productParams.BrandId) && // search prodcut by brand id and
(!productParams.TypeId.HasValue || p.ProductTypeId == productParams.TypeId)) // search product by type id
{
}
public async Task <ActionResult <IReadOnlyList <Product> > > GetProducts([FromQuery] ProductSpecificationParams param)
{
var spec = new ProductsWithTypesAndBrandSpecification(param);
var products = await ProductRepository.GetListWithSpecification(spec);
return(Ok(mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDTO> >(products)));
}
public ProductsWithFiltersForCountSpecification(ProductSpecificationParams productsParams)
: base(criteria: p =>
(string.IsNullOrEmpty(productsParams.Search) || p.Name.ToLower().Contains(productsParams.Search)) &&
(!productsParams.BrandId.HasValue || p.ProductBrandId == productsParams.BrandId) &&
(!productsParams.TypeId.HasValue || p.ProductTypeId == productsParams.TypeId)
)
{
}
public async Task <IActionResult> GetProductSpecifications([FromQuery] ProductSpecificationParams productSpecificationParams)
{
var productSpecifications = await _repository.GetProductSpecifications(productSpecificationParams);
var productSpecificationsToReturn = _mapper.Map <IEnumerable <ProductSpecificationForListDto> >(productSpecifications);
Response.AddPagination(productSpecifications.CurrentPage, productSpecifications.PageSize, productSpecifications.TotalCount, productSpecifications.TotalPages);
return(Ok(productSpecificationsToReturn));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts(
[FromQuery] ProductSpecificationParams productParams)
{
var specification = new ProductsWithTypesAndBrandsSpecification(productParams);
var countSpecification = new ProductWithFiltersForCountSpecification(productParams);
var totalItemsCount = await _productRepository.CountAsync(countSpecification);
var products = await _productRepository.GetListWithSpecification(specification);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize,
totalItemsCount, data)));
}
public async Task <ActionResult <Pagination <ProductDto> > > GetProducts([FromQuery] ProductSpecificationParams productParameters)
{
var specification = new ProductsWithTypesAndBrandsSpecification(productParameters);
var countSpecification = new ProductWithFiltersForCountSpecification(productParameters);
var totalItems = await _productsRepo.CountAsync(countSpecification);
var products = await _productsRepo.ListAsync(specification);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductDto> >(products);
var result = new Pagination <ProductDto>(productParameters.PageIndex, productParameters.PageSize, totalItems,
data);
return(Ok(result));
}
public async Task <ActionResult <GenericPagination <ProductDTO> > > GetProducts(
[FromQuery] ProductSpecificationParams productsParams)
{
var productsWithTypesAndBrandsSpec = new ProductsWithTypesAndBrandsSpecification(productsParams);
var productCountSpec = new ProductsWithFiltersForCountSpecification(productsParams);
var productsCount = await _productRepo.CountAsync(productCountSpec);
var products = await _productRepo.GetAllAsync(productsWithTypesAndBrandsSpec);
var productsDTO = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductDTO> >(products);
return(Ok(new GenericPagination <ProductDTO>(
productsParams.PageIndex,
productsParams.PageSize,
productsCount,
productsDTO)
));
}
public async Task <ActionResult <Pagination <ProductDTO> > > GetProducts(
[FromQuery] ProductSpecificationParams productParams)
{
var spec = new ProductsWithRelatedSpecification(productParams);
var countSpec = new ProductsWithFiltersForCountSpecification(productParams);
var totalItems = await _productRepository.CountAsync(countSpec);
var products = await _productRepository.ListAsync(spec);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductDTO> >(products);
return(Ok(new Pagination <ProductDTO>()
{
Count = totalItems,
Data = data,
PageIndex = productParams.PageIndex,
PageSize = productParams.PageSize,
}));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts(
[FromQuery] ProductSpecificationParams productParams)
{
var specifications = new ProductsWithTypesAndBrandsSpecification(productParams);
var countSpec = new ProductsWithFiltersForCountSpecification(productParams);
var totalItems = await _productsRepository.CountAsync(countSpec);
var products = await _productsRepository.ListAsync(specifications);
if (products == null)
{
return(NotFound(new ApiResponse(404)));
}
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize,
totalItems, data)));
}
public ProductSpecification(ProductSpecificationParams productParams)
: base(x =>
(!productParams.BrandId.HasValue || x.ProductBrandId == productParams.BrandId) && (!productParams.TypeId.HasValue || x.ProductTypeId == productParams.TypeId)
)
{
AddInclude(x => x.ProductType);
AddInclude(x => x.ProductBrand);
AddInclude("ProductImages.Image");
ApplyPaging(productParams.PageSize * (productParams.PageIndex - 1), productParams.PageSize);
AddOrderBy(x => x.Name);
if (!String.IsNullOrEmpty(productParams.Sort))
{
switch (productParams.Sort)
{
case "nameAsc":
AddOrderBy(x => x.Name);
break;
case "nameDesc":
AddOrderByDesc(x => x.Name);
break;
case "priceAsc":
AddOrderBy(x => x.Price);
break;
case "priceDesc":
AddOrderByDesc(x => x.Price);
break;
default:
AddOrderBy(x => x.Name);
break;
}
}
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts([FromQuery] ProductSpecificationParams @params)
{
var spec = new ProductsWithTypesAndBrandsSpecification(@params);
var countSpec = new ProductWithFiltersForCountSpecification(@params);
var totalItems = await _productRepository.CountAsync(countSpec);
var products = await _productRepository.GetEntitiesWithSpecification(spec);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>
{
Count = totalItems,
Data = data,
PageIndex = @params.PageIndex,
PageSize = @params.PageSize
}));
}
public async Task <PagedList <ProductSpecification> > GetProductSpecifications(ProductSpecificationParams productParams)
{
var productSpecifications = _context.ProductSpecifications.OrderBy(p => p.Name).AsQueryable();
if (!string.IsNullOrEmpty(productParams.IsActive))
{
if (productParams.IsActive == "active")
{
productSpecifications = productSpecifications.Where(p => p.IsActive == true);
}
else
{
productSpecifications = productSpecifications.Where(p => p.IsActive == false);
}
}
if (!string.IsNullOrEmpty(productParams.Column) && productParams.Column == "name" && !string.IsNullOrEmpty(productParams.Sorting))
{
if (productParams.Sorting == "ascending")
{
productSpecifications = productSpecifications.OrderBy(p => p.Name);
}
else
{
productSpecifications = productSpecifications.OrderByDescending(p => p.Name);
}
}
if (!string.IsNullOrEmpty(productParams.Column) && productParams.Column == "series" && !string.IsNullOrEmpty(productParams.Sorting))
{
if (productParams.Sorting == "ascending")
{
productSpecifications = productSpecifications.OrderBy(p => p.Series);
}
else
{
productSpecifications = productSpecifications.OrderByDescending(p => p.Series);
}
}
if (!string.IsNullOrEmpty(productParams.Column) && productParams.Column == "manufacturer" && !string.IsNullOrEmpty(productParams.Sorting))
{
if (productParams.Sorting == "ascending")
{
productSpecifications = productSpecifications.OrderBy(p => p.Manufacturer);
}
else
{
productSpecifications = productSpecifications.OrderByDescending(p => p.Manufacturer);
}
}
return(await PagedList <ProductSpecification> .CreateAsync(productSpecifications, productParams.PageNumber, productParams.PageSize));
}
