private void buttonOK_Click(object sender, EventArgs e)
{
SelectedFilters.Clear();
for (int i = 0; i < checkedFilterList.Items.Count; i++)
{
if (checkedFilterList.GetItemChecked(i))
{
SelectedFilters.Add(i);
}
}
}
//Final Search filter
//SearchFilter filter = new SearchFilter();
private void OnSelectResultItem(object[] selectedItems)
{
if (selectedItems?.Length > 0)
{
var result = (string)selectedItems[0];
if (!SelectedFilters.Any(x => x.Filters.Contains(result)))
{
var filter = new HorsifyFilter()
{
SearchType = SearchType,
Filters = new System.Collections.Generic.List <string>()
{
result
}
};
SelectedFilters.Add(filter);
//this.SelectedFilters.Add(result);
}
}
}
private bool CompareSelectedFilters(ICollection <FilterObject> newList)
{
if (newList.Count != SelectedFilters.Count)
{
return(false);
}
foreach (FilterObject filter in newList)
{
FilterObject existingFilter = SelectedFilters.FirstOrDefault(p => p.Tag == filter.Tag);
if (existingFilter == null)
{
return(false);
}
if (existingFilter.Value != filter.Value)
{
return(false);
}
}
foreach (FilterObject filter in SelectedFilters)
{
FilterObject existingFilter = newList.FirstOrDefault(p => p.Tag == filter.Tag);
if (existingFilter == null)
{
return(false);
}
if (existingFilter.Value != filter.Value)
{
return(false);
}
}
return(true);
}
public ActionResult FilterSortProducts([Form] ShopFilteringOptions filteringOptions,
[Form] SelectedFilters selectedFilters)
{
int? storeID = TempData["storeId"] as int?;
int? catID = TempData["catId"] as int?;
var formOption = Request.Form["SortOption"];
SortOption sortOption = (SortOption)Enum.Parse(typeof(SortOption), formOption);
return(RedirectToAction("Products",
new {
SortOption = sortOption,
storeId = storeID,
catId = catID,
filteringOptions.Price_MinValue,
filteringOptions.Price_MaxValue,
filteringOptions.Rating_Min,
filteringOptions.Allowed_Days,
filteringOptions.Availability,
selectedFilters.PriceFilterSelected,
selectedFilters.RatingFilterSelected,
selectedFilters.NewArrivalFilterSelected,
selectedFilters.AvailabilityFilterSelected
}));
}
public ActionResult Products(int?storeId, int?catId, [Form] ShopFilteringOptions filteringOptions,
[Form] SelectedFilters selectedFilters,
[Form] QueryOptions queryOptions,
string searchQuery = null, bool flag1 = false, bool isKLId = false)
{
if (queryOptions == null)
{
queryOptions = new QueryOptions();
}
TempData["storeId"] = storeId;
TempData["catId"] = catId;
bool?recFlag = TempData["flag"] as bool?;
if (recFlag != null && recFlag == true)
{
TempData["flag"] = null;
return(RedirectToAction("Products", new { storeId, catId, queryOptions }));
}
else if (TempData["AddedToCart"] is bool flag && flag)
{
TempData["flag"] = flag;
}
ViewBag.Flag = TempData["AddedToCart"] as bool?;
Category parent = null;
Dictionary <string, int> parentList = new Dictionary <string, int>();
List <int> catProdIds = null;
List <KL_Category> klCategories = new List <KL_Category>();
if (isKLId)
{
List <Category> categories = null;
klCategories = db.KL_Categories
.Where(m => m.KL_CategoryId == catId)
.ToList();
var parentCat = db.KL_Categories.FirstOrDefault(m => m.Id == catId);
var klCatQueue = new Queue <KL_Category>();
klCatQueue.Enqueue(parentCat);
catProdIds = new List <int>();
while (klCatQueue.Count > 0 && klCatQueue.Dequeue() is KL_Category kl_category)
{
categories = db.Categories
.Where(m => m.KL_CategoryId == kl_category.Id)
.ToList();
foreach (var cat in categories)
{
var stocks = db.Stocks
.Include(m => m.Product)
.Where(m => m.Product.CategoryId == cat.Id)
.Select(m => m.Id)
.ToList();
catProdIds = catProdIds.Concat(stocks).ToList();
}
foreach (var kl_cat in db.KL_Categories
.Where(m => m.KL_CategoryId == kl_category.Id)
.ToList())
{
klCatQueue.Enqueue(kl_cat);
}
}
if (catProdIds.Count == 0)
{
ViewBag.EmptyMessage = "No products available";
}
}
else
{
parent = db.Categories.FirstOrDefault(m => m.Id == (catId ?? 0));
while (parent != null)
{
parentList.Add(parent.Name, parent.Id);
parent = db.Categories.FirstOrDefault(m => m.Id == parent.CategoryId);
}
catProdIds = db.Products.Where(m => m.CategoryId == (catId ?? m.CategoryId))
.Select(m => m.Id).ToList();
}
var store = db.Stores.FirstOrDefault(m => m.Id == (storeId ?? 0));
var thresholdDate = DateTime.Now;
bool dateFlag = false;
if (filteringOptions.Allowed_Days == -1)
{
dateFlag = true;
}
else
{
thresholdDate = thresholdDate.AddDays(-1 * filteringOptions.Allowed_Days);
}
SearchParam search = null;
if (!string.IsNullOrEmpty(searchQuery))
{
var stocks = db.Stocks
.Include(m => m.Product)
.Where(m => m.Product.Name.ToUpper().Contains(searchQuery.ToUpper()))
.OrderBy(m => m.Product.Name)
.Select(m => m.Id)
.Distinct()
.ToArray();
var categories = db.Categories
.Where(m => m.Name.ToUpper().Contains(searchQuery.ToUpper()))
.OrderBy(m => m.Name)
.Select(m => m.Id)
.Distinct()
.ToArray();
TempData["Search"] = searchQuery;
search = new SearchParam {
Categories = categories,
Stocks = stocks
};
}
var model = new ShopProductsViewModel
{
CategoryId = catId,
IsKlCat = isKLId,
KL_Categories = klCategories,
Stocks = (search == null || (search.Categories == null && search.Stocks == null)) ?
db.Stocks
.Include(m => m.Product)
.Where(m => m.StoreId == (storeId ?? m.StoreId) &&
catProdIds.Contains(m.ProductId) &&
m.Price >= filteringOptions.Price_MinValue &&
m.Price <= filteringOptions.Price_MaxValue &&
m.Product.Rating >= filteringOptions.Rating_Min &&
m.Product.IsActive == true &&
(filteringOptions.Availability || m.Status == StockStatus.InStock))
.OrderBy(queryOptions.Sort)
.ToList()
:
new List <Stock>(),
Max = new Dictionary <int, int>(),
Breadcrum = (store != null && parent != null) ? new Dictionary <string, int>()
: null,
SelectedOption = queryOptions.SortOption,
StoreId = storeId,
FilteringOptions = filteringOptions,
CurrencySymbol = (store != null) ? store.DefaultCurrencyType : "Rs."
};
if (search != null)
{
if (search.Categories != null && search.Categories.Count() > 0)
{
model.Stocks = db.Stocks
.Include(m => m.Product)
.Where(m => search.Categories.Contains(m.Product.CategoryId) &&
m.Price >= filteringOptions.Price_MinValue &&
m.Price <= filteringOptions.Price_MaxValue &&
m.Product.Rating >= filteringOptions.Rating_Min &&
m.Product.IsActive == true &&
(filteringOptions.Availability || m.Status == StockStatus.InStock))
.OrderBy(queryOptions.Sort)
.ToList();
}
if (search.Stocks != null && search.Stocks.Count() > 0)
{
model.Stocks = model.Stocks.Concat(db.Stocks
.Include(m => m.Product)
.Where(m => search.Stocks.Contains(m.Id) &&
m.Price >= filteringOptions.Price_MinValue &&
m.Price <= filteringOptions.Price_MaxValue &&
m.Product.Rating >= filteringOptions.Rating_Min &&
m.Product.IsActive == true &&
(filteringOptions.Availability || m.Status == StockStatus.InStock))
.OrderBy(queryOptions.Sort)
.ToList()).ToList();
}
}
var stockList = model.Stocks ?? new List <Stock>();
foreach (var stock in stockList)
{
if (!dateFlag && (stock.StockingDate - thresholdDate).Days < 0)
{
model.Stocks.Remove(stock);
}
}
if (queryOptions.Sort == "Id ASC")
{
model.Stocks.Sort();
}
if (model.Breadcrum != null)
{
model.Breadcrum.Add(store.Name, store.Id);
var keys = parentList.Keys.ToList();
keys.Reverse();
foreach (var key in keys)
{
model.Breadcrum.Add(key, parentList[key]);
}
}
var cart = GetCart();
foreach (var stk in model.Stocks ?? new List <Stock>())
{
var available = 0;
if (stk.MaxAmtPerUser < stk.CurrentStock)
{
available = stk.MaxAmtPerUser;
}
else
{
available = stk.CurrentStock;
}
var cartItm = cart.CartItems
.FirstOrDefault(m => m.StockId == stk.Id && m.IsEditable);
if (cartItm != null)
{
model.Max.Add(stk.Id, available - cartItm.Qty);
}
else
{
model.Max.Add(stk.Id, available);
}
}
if (model.FilterViewModel == null)
{
model.FilterViewModel = new ShopFilterViewModel {
PriceSelection = new PriceSelection(),
RatingSelection = new RatingSelection(),
NewestArrivalSelection = new NewestArrivalSelection(),
AvailabilitySelection = new AvailabilitySelection()
};
}
model.FilterViewModel.PriceSelection.PriceItemSelected = selectedFilters.PriceFilterSelected;
model.FilterViewModel.RatingSelection.RatingItemSelected = selectedFilters.RatingFilterSelected;
model.FilterViewModel.NewestArrivalSelection.NewestArrivalItemSelected = selectedFilters.NewArrivalFilterSelected;
model.FilterViewModel.AvailabilitySelection.AvailabilityItemSelected = selectedFilters.AvailabilityFilterSelected;
model.FilterViewModel.MinValue = filteringOptions.Price_MinValue;
model.FilterViewModel.MaxValue = filteringOptions.Price_MaxValue;
return(View(model));
}
public ActionResult FiltersPartialPost(ShopProductsViewModel model)
{
var priceOption = Request.Form["PriceList"];
var ratingOption = Request.Form["RatingList"];
var newArrivalsOption = Request.Form["NewArrivalsList"];
var availabilityOption = Request.Form["AvailabilityList"];
var options = new ShopFilteringOptions();
var selectedOptions = new SelectedFilters();
if (priceOption != null)
{
switch (priceOption)
{
case "1":
{
options.Price_MaxValue = 1000;
break;
}
case "2":
{
options.Price_MinValue = 1000;
options.Price_MaxValue = 2000;
break;
}
case "3":
{
if (model.FilterViewModel.MinValue > 0 && model.FilterViewModel.MaxValue > 0)
{
options.Price_MaxValue = model.FilterViewModel.MaxValue;
options.Price_MinValue = model.FilterViewModel.MinValue;
}
break;
}
}
}
else
{
priceOption = "0";
}
if (ratingOption != null)
{
switch (ratingOption)
{
case "1":
{
options.Rating_Min = 5;
break;
}
case "2":
{
options.Rating_Min = 4;
break;
}
case "3":
{
options.Rating_Min = 3;
break;
}
case "4":
{
options.Rating_Min = 2;
break;
}
case "5":
{
options.Rating_Min = 1;
break;
}
}
}
else
{
ratingOption = "0";
}
if (newArrivalsOption != null)
{
switch (newArrivalsOption)
{
case "1":
{
options.Allowed_Days = 30;
break;
}
case "2":
{
options.Allowed_Days = 60;
break;
}
case "3":
{
break;
}
}
}
else
{
newArrivalsOption = "0";
}
if (availabilityOption != null)
{
switch (availabilityOption)
{
case "1":
{
options.Availability = false;
break;
}
case "2":
{
options.Availability = true;
break;
}
}
}
else
{
availabilityOption = "0";
}
selectedOptions.PriceFilterSelected = int.Parse(priceOption);
selectedOptions.RatingFilterSelected = int.Parse(ratingOption);
selectedOptions.NewArrivalFilterSelected = int.Parse(newArrivalsOption);
selectedOptions.AvailabilityFilterSelected = int.Parse(availabilityOption);
return(RedirectToAction("Products", new { storeId = (model.CategoryId == null) ?
null as int? :
db.Categories
.FirstOrDefault(m => m.Id == model.CategoryId)
.StoreId,
catId = model.CategoryId,
options.Price_MinValue, options.Price_MaxValue,
options.Rating_Min, options.Allowed_Days,
options.Availability,
selectedOptions.PriceFilterSelected,
selectedOptions.RatingFilterSelected,
selectedOptions.NewArrivalFilterSelected,
selectedOptions.AvailabilityFilterSelected,
SortOption = model.SelectedOption }));
}
