public PaginatedList <Product> GetProducts(int page, int limit, ProductFilterDto Filter = null)
{
using (var ctx = new AppDbContext())
{
var query = ctx.Products.AsQueryable();
query = query.Where(p => p.isDelete == 0);
if (Filter != null)
{
if (Filter.NameProductKeyWord != null && Filter.NameProductKeyWord != "")
{
query = query.Where(p => p.Name.ToLower().Contains((Filter.NameProductKeyWord).ToLower()));
}
if (Filter.ListCategory != null)
{
query = query.Where(p => Filter.ListCategory.Contains(p.Category.Name));
}
if (Filter.ListManufacturer != null)
{
query = query.Where(p => Filter.ListManufacturer.Contains(p.Manufacturer.Name));
}
}
query = query.Include(p => p.Category)
.Include(p => p.Manufacturer)
.OrderBy(p => p.Name);
var products = PaginatedList <Product> .Create(query, page, limit);
return(products);
}
}
public async Task <IHttpActionResult> Get([FromUri] ProductFilterDto filter)
{
var id = (Thread.CurrentPrincipal as UserPrincipal).Id;
var products = await _service.GetData(filter.GetFilter(id));
var dto = _assembler.EntityToDto(products);
return(Ok(dto));
}
public IEnumerable <ProductDto> GetProducts(ProductFilterDto filters)
{
var data = _unitOfWork.ProductRepository
.Find(p => (filters.HasUnitFilter && filters.UnitCodesFilter.Contains(p.Unit.Code)) ||
(filters.HasProductTypeFilter && filters.ProductTypeCodesFilter.Contains(p.ProductType.Code)) ||
(filters.HasCategoryFilter && p.ProductCategories.Any(pc => filters.CategoryCodesFilter.Contains(pc.Category.Code))));
return(_mapper.Map <IEnumerable <ProductDto> >(data));
}
/// <summary>
/// Finds paged products.
/// </summary>
/// <param name="productFilterDto">The filtering DTO</param>
/// <returns>The Product DTO page</returns>
internal IPagedList <ProductDto> FindPaged(ProductFilterDto productFilterDto)
{
return(_modelContext.Set <Product>()
.OrderBy(x => x.Name)
.Select(x => new ProductDto()
{
Id = x.Id, Name = x.Name, Prize = x.Prize
})
.ToPagedList(productFilterDto.Page, productFilterDto.PageSize));
}
protected override IQuery <Product> ApplyWhereClause(IQuery <Product> query, ProductFilterDto filter)
{
return(string.IsNullOrWhiteSpace(filter.Name) || filter.AuctionId.Equals(Guid.Empty)
? query
: query.Where(new CompositePredicate(new List <IPredicate>()
{
new SimplePredicate(nameof(Product.Name), ValueComparingOperator.Equal, filter.Name),
new SimplePredicate(nameof(Product.AuctionId), ValueComparingOperator.Equal, filter.AuctionId)
})));
}
public IActionResult GetProducts(ProductFilterDto filters)
{
try
{
return(Ok(_productService.GetProducts(filters)));
}
catch (Exception)
{
return(NotFound());
}
}
public IHttpActionResult Get([FromUri] ProductFilterDto productFilterDto)
{
if (productFilterDto == null)
{
productFilterDto = new ProductFilterDto();
}
var products = productFilterDto.SkipAndTake(productFilterDto
.ApplyTo(shoppingEntities.Products.Include(t => t.SaleOffs).Where(t => t.Deleted == false))).ToList();
var productDtos = products.ConvertAll(t => new ProductDto(t, t.SaleOffs));
return(Ok(productDtos));
}
public IHttpActionResult GetDeletedProducts([FromUri] Guid shopId, [FromUri] ProductFilterDto productFilterDto)
{
if (productFilterDto == null)
{
productFilterDto = new ProductFilterDto();
}
var products = productFilterDto.SkipAndTake(productFilterDto
.ApplyTo(shoppingEntities.Products.Where(t => t.ShopId == shopId && t.Deleted == true)))
.ToList();
var productDtos = products.ConvertAll(t => new ProductDto(t));
return(Ok(productDtos));
}
public IActionResult Get([FromQuery] ProductFilterDto productFilterdto)
{
var productFilter = new ProductFilter {
Brand = productFilterdto.Brand, Description = productFilterdto.Description, Model = productFilterdto.Model
};
var productEntity = _queryHandler.Handle <ProductFilter, Result <IEnumerable <Product> > >(productFilter);
if (productEntity.IsFailure)
{
return(BadRequest("Unable to fetch details"));
}
var result = _mapper.Map <IEnumerable <ProductDto> >(productEntity.Value);
return(Ok(result));
}
public async Task <IActionResult> GetFilteredProducts([FromBody] ProductFilterDto productFilterDto)
{
try
{
var products = await _blockChainService.GetFilteredProducts(productFilterDto.PageIndex,
productFilterDto.PageSize);
var productsCount = await _blockChainService.GetAllProductsCount();
return(Ok(new { products, productsCount }));
}
catch (Exception ex)
{
Logger.LogException(Log, ex, MethodBase.GetCurrentMethod());
return(new StatusCodeResult(503));
}
}
public async Task <List <Product> > GetAllAsync(ProductFilterDto dto)
{
var query = _ctx.Products.Where(x => true);
if (dto.BookCode != null)
{
query = query.Where(x => x.BookCode == dto.BookCode);
}
if (!string.IsNullOrEmpty(dto.BookName))
{
query = query.Where(x => x.BookName == dto.BookName);
}
var returnValue = await query.ToListAsync();
return(returnValue);
}
private async Task <List <ProductCardDto> > FitProducts(ProductFilter productFilterViewModel)
{
var filter = new ProductFilterDto
{
CategoryId = productFilterViewModel.CategoryId,
BrandIds = productFilterViewModel.BrandsIds,
MinimalPrice = productFilterViewModel.MinimalPrice,
MaximalPrice = productFilterViewModel.MaximalPrice,
PersonalColorType = (PersonalColorType)productFilterViewModel.PersonalColorTypeId,
SizeIds = productFilterViewModel.SizesIds
};
(int counts, List <ProductCardDto> list) = await QueriesDb.SelectProductsAsync(filter,
productFilterViewModel.PageParams.Offset, productFilterViewModel.PageParams.Count);
return(list);
}
public void Should_Return_Products_When_Searched_ByFilter()
{
//set up
MockDependencies();
IEnumerable <Product> products = new List <Product>
{
new Product()
{
Brand = "Sony", Description = "smart TV", Id = "1", Model = "tv1"
},
new Product()
{
Brand = "Samsung", Description = "fridge", Id = "2", Model = "fr1"
},
new Product()
{
Brand = "LG", Description = "washing machine", Id = "3", Model = "ws1"
},
new Product()
{
Brand = "Whirpool", Description = "vaccum cleaner", Id = "4", Model = "vc1"
},
new Product()
{
Brand = "OKia", Description = "dishwasher", Id = "5", Model = "dis1"
},
};
mockIQueryHandler.Setup(x => x.Handle <ProductFilterDto, Result <IEnumerable <Product> > >(It.IsAny <ProductFilterDto>())).Returns(() => Result.Ok(products));
mockICommandHandler.Setup(x => x.Handle <string>(string.Empty));
//arrange
var productController = new ProductsController(mockIQueryHandler.Object, mockICommandHandler.Object, configuration.CreateMapper());
var productFilter = new ProductFilterDto
{
Brand = "Sony", Description = "", Model = ""
};
//test
var actualResult = productController.Get(productFilter) as OkObjectResult;
var productsReturned = actualResult.Value as IEnumerable <ProductDto>;
productsReturned.Should().HaveCount(5, "Five products match search criteria");
}
public async Task <ProductDto[]> GetList(ProductFilterDto filter)
{
_logger.LogDebug($"Calling getList Product");
IQueryable <Product> query = _dbCtx.Products;
if (filter.Id != Guid.Empty)
{
query = query.Where(x => x.Id == filter.Id);
}
if (filter.IdTeacher.HasValue && filter.IdTeacher != Guid.Empty)
{
query = query.Where(x => x.IdTeacher == filter.IdTeacher);
}
var result = await query.OrderBy(x => x.Name).ToArrayAsync();
return(result.Select(x => x.ToDto()).ToArray());
}
public async Task <IActionResult> GetProductFilter([FromQuery] ProductFilterDto filter)
{
return(Ok(await _productservice.GetProductFilter(filter)));
}
public async Task <ServiceResponseWithPagination <List <GetProductDto> > > GetProductFilter(ProductFilterDto filter)
{
var queryable = _dBContext.Products.Include(x => x.ProductGroup).AsNoTracking().AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(filter.Name))
{
queryable = queryable.Where(x => x.Name.Contains(filter.Name.Trim()));
}
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <GetProductDto> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
var dto = await queryable.Paginate(filter).AsNoTracking().ToListAsync();
var prodDto = _mapper.Map <List <GetProductDto> >(dto);
return(ResponseResultWithPagination.Success(prodDto, paginationResult));
}
public IList <IProductFilter> FindAllFilters(IUser currentUser, IProductListInputModel query)
{
// Find the list of products
string url = "ProductService.svc/rest/ListProductFilters2?";
url += addUserUrlDetails(currentUser);
url += "&statusSeed=" + _configuration["Storm:StatusSeed"];
if (query.CategoryIds != null)
{
url += "&categorySeed=" + string.Join(",", query.CategoryIds);
}
if (query.FlagIds != null)
{
url += "&flagSeed=" + string.Join(",", query.FlagIds);
}
if (!string.IsNullOrEmpty(query.Query))
{
url += "&searchString=" + System.Web.HttpUtility.UrlEncode(query.Query);
}
var filterList = _connectionManager.GetResult <List <StormFilter> >(url);
List <IProductFilter> result = new List <IProductFilter>();
Dictionary <string, ProductDto> variants = new Dictionary <string, ProductDto>();
foreach (var item in filterList)
{
var dto = new ProductFilterDto();
dto.Items = new List <IProductFilterItem>();
dto.Name = item.Type;
dto.Type = item.Name;
if (item.Name.Equals("parf"))
{
foreach (var entry in item.Items)
{
dto = new ProductFilterDto();
dto.Items = new List <IProductFilterItem>();
dto.Name = entry.Name;
dto.Type = entry.Id;
if (entry.Items != null)
{
foreach (var valuef in entry.Items)
{
var dtoi = new ProductFilterItem();
dtoi.Count = valuef.Count ?? 0;
dtoi.Id = valuef.Id;
dtoi.Name = valuef.Name;
dtoi.Type = valuef.Type;
dtoi.Value = valuef.Value;
dto.Items.Add(dtoi);
}
}
else if (entry.FalseCount.HasValue)
{
var dtoi = new ProductFilterItem();
dtoi.Count = entry.Count ?? 0;
dtoi.Name = "True";
dto.Items.Add(dtoi);
dtoi = new ProductFilterItem();
dtoi.Count = entry.FalseCount ?? 0;
dtoi.Name = "False";
dto.Items.Add(dtoi);
}
result.Add(dto);
}
}
else if (item.Name.Equals("ohf"))
{
result.Add(dto);
var dtoi = new ProductFilterItem();
dtoi.Count = item.Items[0].Count ?? 0;
dtoi.Name = "Onhand";
dto.Items.Add(dtoi);
}
else
{
foreach (var entry in item.Items)
{
var dtoi = new ProductFilterItem();
dtoi.Count = entry.Count ?? 0;
dtoi.Id = entry.Id;
dtoi.Name = entry.Name;
dtoi.Type = entry.Type;
dtoi.Value = entry.Value;
dto.Items.Add(dtoi);
}
result.Add(dto);
}
}
return(result);
}
public async Task <List <ProductDto> > GetProducts(ProductFilterDto dto)
{
var products = await _productRepository.GetAllAsync(dto);
return(products.Adapt <List <ProductDto> >());
}
public ActionResult PagedList(ProductFilterDto productFilterDto)
{
ViewBag.FilterDto = productFilterDto;
return(PartialView(WebConstants.VIEW_PAGED_LIST, GetService().ReadAdministrationPaged(productFilterDto)));
}
public async Task <ActionResult <ProductDto[]> > GetListFiltered([FromBody] ProductFilterDto filter)
{
var res = await _service.GetList(filter);
return(res);
}
public PaginatedList <ProductDisplayDto> GetProductsForDisplayProduct(int page = 1, int limit = 9, ProductFilterDto Filter = null)
{
var rawProducts = _productRepository.GetProducts(page, limit, Filter);
var productsForReturn = new PaginatedList <ProductDisplayDto>
(
Mapper.Map <List <ProductDisplayDto> >(rawProducts.Data),
rawProducts.TotalRecords,
rawProducts.CurrentPage,
rawProducts.PageRecords
);
return(productsForReturn);
}
public async Task <(int counts, List <ProductCardDto> list)> SelectProductsAsync(ProductFilterDto filter, int offset,
int count)
{
var products = Db.ProductEntities.Where(x => x.CategoryId == filter.CategoryId && x.Price >= filter.MinimalPrice && x.Price <= filter.MaximalPrice);
if (filter.BrandIds.Any())
{
products = products.Where(x => filter.BrandIds.Contains(x.BrandId));
}
var productGoodnesses = Db.ProductColorGoodnessEntities.Where(x => x.PersonalColorTypeId == (int)filter.PersonalColorType);
var resultQuery = from product in products
join productColorGoodness in productGoodnesses on product.ProductId equals productColorGoodness.ProductId
join brand in Db.BrandEntities on product.BrandId equals brand.BrandId
join photo in Db.ProductPhotoEntities on product.ProductId equals photo.ProductId
orderby productColorGoodness.Goodness descending
select new { product, brand, productColorGoodness, photo } into selectResult
group selectResult by selectResult.product into groupByProduct
select new ProductCardDto
{
Product = groupByProduct.Key,
Goodness = groupByProduct.First(x => x.product.ProductId == groupByProduct.Key.ProductId).productColorGoodness.Goodness,
Brand = groupByProduct.First(x => x.product.ProductId == groupByProduct.Key.ProductId).brand,
ProductPhotos = groupByProduct.Where(x => x.product.ProductId == groupByProduct.Key.ProductId).Select(x => x.photo)
};
var result = await resultQuery.ToListAsync();
var allCounts = result.Count;
var ids = result.Select(x => x.Product.ProductId).ToList();
var sizes = await GetProductsSizes(ids);
var sizePredicate = filter.SizeIds.Any() ? (x => filter.SizeIds.Contains(x.SizeTypeId)) : (Func <SizeTypeEntity, bool>)(x => true);
foreach (var productCardDto in result)
{
productCardDto.Sizes = sizes.First(x => x.ProductId == productCardDto.Product.ProductId).Sizes
.Where(sizePredicate).ToList();
}
return(allCounts, result.Skip(offset).Take(count).Where(x => x.Sizes.Any()).ToList());
}
public IPagedList <ProductDto> ReadAdministrationPaged(ProductFilterDto productFilterDto)
{
return(_productDao.FindPaged(productFilterDto));
}
