public IList<ProductListElement> GetFilteredProductList(ProductFilter filter)
{
using(ORMDataContext context = GetDataContext())
{
var products = from p in context.Products
where
(!filter.HasDisplay.HasValue || p.HasDisplay == filter.HasDisplay) &&
(!filter.Interface.HasValue || p.IntInterface.Equals((int?)filter.Interface)) &&
(!filter.MemoryCapacityFrom.HasValue || p.MemoryCapacity >= filter.MemoryCapacityFrom) &&
(!filter.MemoryCapacityTo.HasValue || p.MemoryCapacity <= filter.MemoryCapacityTo) &&
(!filter.WarrantyFrom.HasValue || p.Warranty >= filter.WarrantyFrom) &&
(!filter.WarrantyTo.HasValue || p.Warranty <= filter.WarrantyTo) &&
(p.Name.ToLower().Contains(filter.ProductName.ToLower())) &&
(p.Producer.Name.ToLower().Contains(filter.ProducerName.ToLower()))
select
new ProductListElement
{
HasDisplay = p.HasDisplay,
Producer = p.Producer.Name,
Interface = p.Interface,
MemoryCapacity = p.MemoryCapacity,
Name = p.Name,
Warranty = p.Warranty
};
return products.ToList();
}
}
public void FilterByBlueReturn2()
{
ProductFilter filter = new ProductFilter();
IList<Product> products = this.BuildProducts();
var result = filter.FilterBy(products, new ColorSpecification(ProductColor.Blue));
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result, Has.All.Matches<Product>(x => x.Color == ProductColor.Blue));
}
public void FilterBySmallReturn2()
{
ProductFilter filter = new ProductFilter();
IList<Product> products = this.BuildProducts();
var result = filter.FilterBy(products, new SizeSpecification(ProductSize.Small));
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result, Has.All.Matches<Product>(x => x.Size == ProductSize.Small));
}
public void FilterByBlueReturn2()
{
// arrange
ProductFilter filter = new ProductFilter();
IList<Product> products = BuildProducts();
// act
var result = filter.By(products, new SpecificationColor(Color.Blue));
// assert
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result, Has.All.Matches<Product>(x => x.Color == Color.Blue));
}
public void FilterByBlueAndSmallReturn1()
{
// arrange
ProductFilter filter = new ProductFilter();
IList<Product> products = BuildProducts();
// act
var result = filter.ByColorAndSize(products, ProductColor.Blue, ProductSize.Small);
// assert
Assert.That(result.Count(), Is.EqualTo(1));
Assert.That(result, Has.All.Matches<Product>(x => x.Size == ProductSize.Small));
}
public void FilterBySmallReturn2()
{
// arrange
ProductFilter filter = new ProductFilter();
IList<Product> products = BuildProducts();
// act
var result = filter.By(products, new SpecificationSize(Size.Small));
// assert
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result, Has.All.Matches<Product>(x => x.Size == Size.Small));
}
public async Task <List <Product> > List(ProductFilter filter)
{
if (filter == null)
{
return(new List <Product>());
}
IQueryable <ProductDAO> ProductDAOs = DataContext.Product;
ProductDAOs = DynamicFilter(ProductDAOs, filter);
ProductDAOs = DynamicOrder(ProductDAOs, filter);
var Products = await DynamicSelect(ProductDAOs, filter);
return(Products);
}
public async Task <IReadOnlyCollection <Product> > ListUpdatedSinceAsync(DateTimeOffset sinceDate)
{
var filter = new ProductFilter()
{
Order = "updated_at asc",
Limit = 200,
PublishedStatus = "any",
UpdatedAtMin = sinceDate.Subtract(TimeSpan.FromSeconds(1))
};
var products = await _productService.ListAsync(filter);
return(products.ToArray());
}
public IEnumerable <Product> GetProducts(ProductFilter filter = null)
{
var query = TestData.Products;
if (filter?.CategoryId != null)
{
query = query.Where(product => product.CategoryId == filter.CategoryId);
}
if (filter?.BrandId != null)
{
query = query.Where(product => product.BrandId == filter.BrandId);
}
return(query);
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var products = TestData.Products;
if (filter is null)
{
return(products);
}
//if (filter.BrandId != null)
// products = products.Where(p => p.BrandId == filter.BrandId);
//if (filter.SectionId != null)
// products = products.Where(p => p.SectionId == filter.SectionId);
return(products);
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var query = _context.Products.Include("Brand").Include("Section").AsQueryable();
if (filter.BrandId.HasValue)
{
query = query.Where(c => c.BrandId.HasValue && c.BrandId.Value.Equals(filter.BrandId.Value));
}
if (filter.SectionId.HasValue)
{
query = query.Where(c => c.SectionId.Equals(filter.SectionId.Value));
}
return(query.ToList());
}
public IEnumerable <Product> GetProducts(ProductFilter productFilter = null)
{
var query = TestData.Products;
if (productFilter?.SectionId is { } section_id)
{
query = query.Where(product => product.SectionId == section_id);
}
if (productFilter?.BrandId is { } brand_id)
{
query = query.Where(product => product.BrandId == brand_id);
}
return(query);
}
public async void GetByCategoryTest()
{
ProductFilter productFilter = new ProductFilter();
productFilter.CategoryId = CategorySeed.rtv_i_agd.Id;
ICollection <Product> products = await _productRepository.GetByFilter(productFilter);
Assert.True(products.Contains(ProductSeed.konsola_ps4));
Assert.True(products.Contains(ProductSeed.telewizor));
Assert.True(products.Contains(ProductSeed.laptop_uzywany));
Assert.True(products.Contains(ProductSeed.komputer_nowy));
Assert.True(products.Contains(ProductSeed.pralka));
}
public override Task <Product> SelectByID(ProductFilter request, ServerCallContext context)
{
var query = db.Products.Find(request.ProductID);
Product prod = new Product()
{
ProductID = query.ProductID,
ProductName = query.ProductName,
ProductPrice = query.ProductPrice,
ProviderCNPJ = query.ProviderCNPJ,
Description = query.Description
};
return(Task.FromResult(prod));
}
public IEnumerable <Product> GetProducts(ProductFilter Filter = null)
{
var query = TestDB.Products;
if (Filter?.СategoryId is { } category_id)
{
query = query.Where(product => product.CategoryId == category_id).ToList();
}
if (Filter?.BrandId is { } brand_id)
{
query = query.Where(product => product.BrandId == brand_id).ToList();
}
return(query);
}
public async void GetByProductStatesTest()
{
ProductFilter productFilter = new ProductFilter();
productFilter.ProductStatesIds.Add(ProductStateSeed.nowy.Id);
productFilter.ProductStatesIds.Add(ProductStateSeed.uszkodzony.Id);
ICollection <Product> products = await _productRepository.GetByFilter(productFilter);
Assert.True(products.Contains(ProductSeed.arduino));
Assert.True(products.Contains(ProductSeed.komputer_nowy));
Assert.True(products.Contains(ProductSeed.etui));
Assert.True(products.Contains(ProductSeed.powerbank));
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var products = _products;
if (filter.BrandId.HasValue)
{
products = products.Where(p => p.BrandId == filter.BrandId).ToList();
}
if (filter.CategoryId.HasValue)
{
products = products.Where(p => p.CategoryId == filter.CategoryId).ToList();
}
return(products);
}
public ProductFilter ConvertFilterDTOToFilterEntity(ProductMaster_ProductFilterDTO ProductMaster_ProductFilterDTO)
{
ProductFilter ProductFilter = new ProductFilter();
ProductFilter.Selects = ProductSelect.ALL;
ProductFilter.Id = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.Id
};
ProductFilter.Code = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.Code
};
ProductFilter.Name = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.Name
};
ProductFilter.Description = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.Description
};
ProductFilter.TypeId = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.TypeId
};
ProductFilter.StatusId = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.StatusId
};
ProductFilter.MerchantId = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.MerchantId
};
ProductFilter.CategoryId = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.CategoryId
};
ProductFilter.BrandId = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.BrandId
};
ProductFilter.WarrantyPolicy = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.WarrantyPolicy
};
ProductFilter.ReturnPolicy = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.ReturnPolicy
};
ProductFilter.ExpiredDate = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.ExpiredDate
};
ProductFilter.ConditionOfUse = new StringFilter {
StartsWith = ProductMaster_ProductFilterDTO.ConditionOfUse
};
ProductFilter.MaximumPurchaseQuantity = new LongFilter {
Equal = ProductMaster_ProductFilterDTO.MaximumPurchaseQuantity
};
return(ProductFilter);
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var products = _products;
if (filter.SectionId.HasValue)
{
products = products.Where(p => p.SectionId.Equals(filter.SectionId)).ToList();
}
if (filter.BrandId.HasValue)
{
products = products.Where(p => p.BrandId.HasValue && p.BrandId.Value.Equals(filter.BrandId.Value)).ToList();
}
return(products);
}
public List <ProductModel> SearchProducts(ProductFilter model)
{
using (UnitOfWork unitOfWork = _unitOfWorkFactory.Create())
{
IEnumerable <Product> products = unitOfWork.Products.GetAllWithBrandsCategoriesAndOrders()
.ByPriceFrom(model.PriceFrom)
.ByPriceTo(model.PriceTo)
.ByName(model.Name)
.ByCategoryId(unitOfWork, model.CategoryId)
.ByBrandId(unitOfWork, model.BrandId);
return(Mapper.Map <List <ProductModel> >(products));
}
}
public override async Task <List <VideoCard> > GetAllAsync(ProductFilter filter)
{
if (filter != null && filter.MotherboardId != Guid.Empty && filter.CaseId != Guid.Empty)
{
var motherboard = await _context.Motherboards.FirstOrDefaultAsync(m => m.Id == filter.MotherboardId);
var computerCase = await _context.Cases.FirstOrDefaultAsync(cc => cc.Id == filter.CaseId);
return(await _entities.Where(vc =>
vc.Interface.Equals(motherboard.GraphicInterface) && vc.Width <= computerCase.VideoCardWidth)
.ToListAsync());
}
return(await _entities.ToListAsync());
}
public IEnumerable <Product> Sales(ProductFilter filterParams)
{
var ProductCategories = filterParams.ProductCategories != null?filterParams.ProductCategories.Split(',').ToList() : new List <string>();
var ProductTypes = filterParams.ProductTypes != null?filterParams.ProductTypes.Split(',').ToList() : new List <string>();
var Companies = filterParams.Companies != null?filterParams.Companies.Split(',').ToList() : new List <string>();
var listOfProducts = _productRepo.GetAllProducts(Companies,
ProductTypes, ProductCategories, filterParams.Page,
filterParams.PageSize, filterParams.OrderByColumn, filterParams.OrderDirection);
return(listOfProducts);
}
public ActionResult Home(ProductFilter filter, int page = 1)
{
var model = _productService.FilterPage(filter, page);
if (Request.IsAjaxRequest())
{
return(PartialView("~/Views/Product/Partial/ProductList.cshtml", model));
}
return(View(new ProductViewModel {
Filter = filter,
list = model
}));
}
public async void GetByDeliveryMethodsTest()
{
ProductFilter productFilter = new ProductFilter();
productFilter.DeliveryMethodsIds.Add(DeliveryMethodSeed.odbior_osobisty_po_przedplacie.Id);
productFilter.DeliveryMethodsIds.Add(DeliveryMethodSeed.list_ekonomiczny.Id);
ICollection <Product> products = await _productRepository.GetByFilter(productFilter);
Assert.True(products.Contains(ProductSeed.telefon_xiaomi));
Assert.True(products.Contains(ProductSeed.powerbank));
Assert.True(products.Contains(ProductSeed.arduino));
Assert.True(products.Contains(ProductSeed.komputer_nowy));
}
public async void GetByOfferTypeTest()
{
ProductFilter productFilter = new ProductFilter();
productFilter.OfferType = OfferType.AUCTION;
ICollection <Product> products = await _productRepository.GetByFilter(productFilter);
products = await _productRepository.GetByFilter(productFilter);
Assert.True(products.Contains(ProductSeed.telewizor));
Assert.True(products.Contains(ProductSeed.laptop_uzywany));
Assert.True(products.Contains(ProductSeed.telefon_xiaomi));
}
public void MongodbStoreManagement()
{
try
{
Console.WriteLine("\n\t*****Store MongoDb Implementation*****\n");
InsertStore();
RemoveStore(new MongoStore()
{
StoreName = "HemKop"
});
var productList = new List <MongoProduct>()
{
new MongoProduct()
{
Name = "Salt", Price = 34.57m, ProductInStock = 8, ManufacturerDetails = new Manufacturer()
{
ManufacturerName = "SSS", PhoneNumber = 762892347, Place = "Chalmers"
}
},
new MongoProduct()
{
Name = "Muffins", Price = 50.37m, ProductInStock = 16, ManufacturerDetails = new Manufacturer()
{
ManufacturerName = "AWE", PhoneNumber = 762892856, Place = "Hjlmar"
}
}
};
UpdateStore(new MongoStore()
{
Id = "5ef5c31458ed8642580d7cc3", StoreName = "Pressbyran", StoreAddress = "777 Chalmers", PinCode = 2222, ProductDetails = productList
});
GetAllStores();
GetByStoreId("5ef5c31458ed8642580d7cbf");
//StoreFilter
IMongoDbProductRepository productRepository = new MongoDbProductRepository();
IMongoStore storeRepository = new MongoDbStoreRepository();
ProductFilter storeFilter = new ProductFilter(productRepository, storeRepository);
//searchBy Store
storeFilter.GetStoresBySearch("Lidl");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task <IActionResult> Get([FromQuery] ProductFilter filters)
{
var result = new HttpResult <ProductDto>(this._logger);
try
{
var searchResult = await this._app.GetByFilters(filters);
return(result.ReturnCustomResponse(this._app, searchResult, filters));
}
catch (Exception ex)
{
return(result.ReturnCustomException(ex, "Seed - Product", filters, new ErrorMapCustom()));
}
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var products = _products;
if (filter.SectionId.HasValue)
{
products = products.Where(x => x.SectionId == filter.SectionId.Value).ToList();
}
if (filter.BrandId.HasValue)
{
products = products.Where(x => x.BrandId == filter.BrandId.Value).ToList();
}
return(products);
}
public void TestFilter_ByName()
{
var products = new[] { new Product {
Name = "test1"
}, new Product {
Name = "test2"
}, }.AsQueryable();
var filter = new ProductFilter();
var filteredUsers = filter.Filter(products, new ProductFilterOptions {
Name = "2"
}).ToArray();
Assert.AreEqual(1, filteredUsers.Length);
Assert.AreEqual("test2", filteredUsers.Single().Name);
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var products = _context.Products.AsQueryable(); //В данной фильтрации, фильтрация будет происходить на уровне базы данных
if (filter.SectionId.HasValue)
{
products = products.Where(p => p.SectionId == filter.SectionId);
}
if (filter.BrandId.HasValue)
{
products = products.Where(p => p.BrandId == filter.BrandId);
}
return(products.ToList());
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var contextProducts = _context.Products.Include(p => p.Category).Include(p => p.Brand).AsQueryable();
if (filter.BrandId.HasValue)
{
contextProducts.Where(c => c.BrandId.HasValue && c.BrandId.Value.Equals(filter.BrandId.Value));
}
if (filter.CategoryId.HasValue)
{
contextProducts = contextProducts.Where(c => c.CategoryId.Equals(filter.CategoryId.Value));
}
return(contextProducts.ToList());
}
public IEnumerable <Product> GetProducts(ProductFilter productFilter)
{
var products = _products;
if (productFilter.CategoryID.HasValue)
{
products = products.Where(x => x.CategoryId == productFilter.CategoryID.Value).ToList();
}
if (productFilter.BrandID.HasValue)
{
products = products.Where(x => x.BrandId == productFilter.BrandID.Value).ToList();
}
return(products);
}
public IEnumerable <Product> GetProducts(ProductFilter filter)
{
var query = _context.Products.AsQueryable();
if (filter.BrandId.HasValue)
{
query = query.Where(c => c.BrandId.HasValue && c.BrandId.Value.Equals(filter.BrandId.Value));
}
if (filter.CategoryId.HasValue)
{
query = query.Where(c => c.CategoryId.Equals(filter.CategoryId.Value));
}
return(query.ToList());
}
public ActionResult Products(int page = 1, int pageSize = 20, string sortby = "")
{
ProductFilter filter = (ProductFilter)Session["ProductFilter"];
if (filter == null)
{
filter = new ProductFilter();
Session["ProductFilter"] = filter;
}
var model = _proRepo.GetProductPaging(filter, page, pageSize, sortby);
ViewBag.PageNumber = page;
ViewBag.Title = "Danh sách nhóm sản phẩm";
return(View(model));
}
public ActionResult ModelDetail(int Id)
{
SingleModels singleModel = new SingleModels();
Task.Run(() =>
{
ProductFilter filter = new ProductFilter
{
Id = Id
};
singleModel = manager.GetProduct(filter, Token());
}).Wait();
return(View(singleModel));
}
public override Task <Empty> Delete(ProductFilter request, ServerCallContext context)
{
var query = db.Products.Find(request.ProductID);
db.Products.Remove(new DataAccess.Product()
{
ProductID = query.ProductID,
ProductName = query.ProductName,
ProductPrice = query.ProductPrice,
ProviderCNPJ = query.ProviderCNPJ,
Description = query.Description
});
db.SaveChanges();
return(Task.FromResult(new Empty()));
}
private ProductFilter GetFilter()
{
ProductFilter filter = new ProductFilter
{ProductName = ProductNameTextBox.Text, ProducerName = ProducerNameTextBox.Text,};
if(MinMemoryCapacityCheckBox.Checked)
{
MinMemoryCapacityTextBox.Text = MinMemoryCapacityTextBox.Text == string.Empty
? "0" : MinMemoryCapacityTextBox.Text;
filter.MemoryCapacityFrom = Int32.Parse(MinMemoryCapacityTextBox.Text);
}
if(MaxMemoryCapacityCheckBox.Checked)
{
MaxMemoryCapacityTextBox.Text = MaxMemoryCapacityTextBox.Text == string.Empty
? "0" : MaxMemoryCapacityTextBox.Text;
filter.MemoryCapacityTo = Int32.Parse(MaxMemoryCapacityTextBox.Text);
}
return filter;
}
public IList<ProductListElement> GetFilteredProductList(ProductFilter filter)
{
return GetProductListAll();
}
public void UpdateProductSelection(ProductFilter filter)
{
if (WAFShopHelper.SiteHasShop(GetSiteId())) {
// if (WAFShopHelper.GetCurrentShopId() > 0) {
AqlQuery query = WAFContext.Session.CreateQuery();
AqlAliasShop aliasShop = new AqlAliasShop();
AqlAliasProductCategory aliasProdCat = new AqlAliasProductCategory();
AqlAliasProductBase aliasProduct = new AqlAliasProductBase();
AqlAliasManufacturer aliasManufacturer = new AqlAliasManufacturer();
AqlAliasRelShopProductCategory relShopCategories = new AqlAliasRelShopProductCategory(aliasShop, aliasProdCat);
AqlAliasRelProductCategoryProducts relAliasProdCatProducts = new AqlAliasRelProductCategoryProducts(relShopCategories, aliasProduct, aliasProdCat);
AqlAliasRelManufacturerProducts aliasRelManufacturerProducts = new AqlAliasRelManufacturerProducts(aliasManufacturer, relAliasProdCatProducts, aliasProduct);
switch (filter) {
case ProductFilter.NoFilter:
query.From(aliasProduct);
break;
case ProductFilter.ProductCategory:
int prodCatId = Utils.GetIntegerOnly(ddlProductCategoryFilter.SelectedValue);
if (prodCatId > 0) {
query.Where(aliasProdCat.NodeId == prodCatId);
}
query.From(relAliasProdCatProducts);
break;
case ProductFilter.Stock:
int rangeType = Utils.GetIntegerOnly(ddlStockCriteria.SelectedValue);
switch ((RangeCriteria)rangeType) {
case RangeCriteria.Above:
int aboveNumber = Utils.GetIntegerOnly(txtStockFilterLevel1.Text);
query.Where(aliasProduct.NumberInStock >= aboveNumber);
break;
case RangeCriteria.Below:
int belowNum = Utils.GetIntegerOnly(txtStockFilterLevel1.Text);
query.Where(aliasProduct.NumberInStock <= belowNum);
break;
case RangeCriteria.Between:
int level1Num = Utils.GetIntegerOnly(txtStockFilterLevel1.Text);
int level2Num = Utils.GetIntegerOnly(txtStockFilterLevel2.Text);
query.Where(aliasProduct.NumberInStock > level1Num & aliasProduct.NumberInStock < level2Num);
break;
case RangeCriteria.EqualTo:
int stockNumber = Utils.GetIntegerOnly(txtStockFilterLevel1.Text);
query.Where(aliasProduct.NumberInStock == stockNumber);
break;
default:
break;
}
query.From(relAliasProdCatProducts);
break;
case ProductFilter.Price:
int criteriaType = Utils.GetIntegerOnly(ddlPriceCriteria.SelectedValue);
switch ((RangeCriteria)criteriaType) {
case RangeCriteria.Above:
int aboveNumber = Utils.GetIntegerOnly(txtPriceFilterLevel1.Text);
query.Where(aliasProduct.PriceExVat >= aboveNumber);
break;
case RangeCriteria.Below:
int belowNum = Utils.GetIntegerOnly(txtPriceFilterLevel1.Text);
query.Where(aliasProduct.PriceExVat <= belowNum);
break;
case RangeCriteria.Between:
int level1Num = Utils.GetIntegerOnly(txtPriceFilterLevel1.Text);
int level2Num = Utils.GetIntegerOnly(txtPriceFilterLevel2.Text);
query.Where(aliasProduct.PriceExVat > level1Num & aliasProduct.PriceExVat < level2Num);
break;
case RangeCriteria.EqualTo:
int priceNumber = Utils.GetIntegerOnly(txtPriceFilterLevel1.Text);
query.Where(aliasProduct.PriceExVat == priceNumber);
break;
default:
break;
}
query.From(relAliasProdCatProducts);
break;
case ProductFilter.Brand:
int brandId = Utils.GetIntegerOnly(ddlBrandFilter.SelectedValue);
if (brandId > 0) {
query.Where(aliasManufacturer.NodeId == brandId);
}
query.From(aliasRelManufacturerProducts);
break;
case ProductFilter.Search:
query.Where(Aql.Like(aliasProduct.Name, "*" + txtSearch.Text + "*"));
query.From(relAliasProdCatProducts);
break;
default:
query.From(relAliasProdCatProducts);
break;
}
if (!chkShowVariantNodes.Checked) {
query.Where(aliasProduct.Subvariant == false);
}
//query.Distinct();
query.Select<ProductBase>();
query.Select(aliasProduct.NumberInStock);
query.Select(aliasProduct.NodeId);
query.Select(aliasProduct.PriceExVat);
query.Select(aliasProduct.Name);
query.Select(aliasProduct.CreateDate);
query.Select(aliasProduct.ChangeDate);
if (WAFShopHelper.SiteHasShop(WAFContext.Request.SiteId)) {
if (filter == ProductFilter.NoFilter) {
query.Where(aliasProduct.SiteId == WAFContext.Session.SiteId);
} else {
query.Where(AqlShop.NodeId == WAFShopHelper.GetCurrentShopId());
}
//
} else {
query.Where(AqlSite.NodeId == WAFContext.Request.SiteId);
}
query.IncludeUnpublished = true;
contentListProducts.Query = query;
contentListProducts.DataBind();
} else {
contentListProducts.Enabled = false;
}
}
private void ShowFilterPanel(ProductFilter filter)
{
switch (filter) {
case ProductFilter.NoFilter:
ShowPanels(false, false, false, false, false);
break;
case ProductFilter.ProductCategory:
ShowPanels(false, false, true, false, false);
break;
case ProductFilter.Stock:
ShowPanels(false, false, false, false, true);
break;
case ProductFilter.Price:
ShowPanels(false, true, false, false, false);
break;
case ProductFilter.Brand:
ShowPanels(true, false, false, false, false);
break;
case ProductFilter.Search:
ShowPanels(false, false, false, true, false);
break;
default:
ShowPanels(false, false, false, false, false);
break;
}
}
