public void OnGet()
{
Players = playerRepository.GetPlayerStats();
if (SearchTerms != null)
{
string[] splitTerms = SearchTerms.Split(" ");
//this is here because for some reason the Data project does not seem to recognize the Contains(2 inputs) overload despite necessary dependencies
Players = Players.Where(player => splitTerms.Any(term => player.FirstName.Contains(term, StringComparison.InvariantCultureIgnoreCase)) || splitTerms.Any(term => player.LastName.Contains(term, StringComparison.InvariantCultureIgnoreCase)));
}
}
protected override Expression BuildExpression(MemberExpression property)
{
Expression searchExpression1 = null;
Expression searchExpression2 = null;
if (!string.IsNullOrEmpty(SearchTerms) && this.Comparator == NumericComparators.In)
{
Expression combinedExpression = null;
foreach (string val in SearchTerms.Split(','))
{
// this.Comparator = NumericComparators.In;
this.SearchTerm = Convert.ToDecimal(val);
searchExpression1 = this.GetFilterExpression(property);
if (!ReferenceEquals(searchExpression1, null) && !ReferenceEquals(searchExpression2, null))
{
combinedExpression = Expression.OrElse(searchExpression2, searchExpression1);
searchExpression1 = combinedExpression;
}
searchExpression2 = searchExpression1;
}
return(combinedExpression);
}
else
if (this.SearchTerm.HasValue)
{
searchExpression1 = this.GetFilterExpression(property);
}
if (this.Comparator == NumericComparators.InRange && this.SearchTerm2.HasValue)
{
searchExpression2 = Expression.LessThanOrEqual(property, Expression.Constant(this.SearchTerm2.Value));
}
if (searchExpression1 == null && searchExpression2 == null)
{
return(null);
}
else if (searchExpression1 != null && searchExpression2 != null)
{
var combinedExpression = Expression.AndAlso(searchExpression1, searchExpression2);
return(combinedExpression);
}
else if (searchExpression1 != null)
{
return(searchExpression1);
}
else
{
return(searchExpression2);
}
}
private bool DoesItemHaveSearchTerms(IOrderItem item)
{
string[] terms = SearchTerms.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
string itemString = item.DisplayName + " " + item.Description;
foreach (string term in terms)
{
if (!itemString.Contains(term, StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
}
return(true);
}
public void OnGet()
{
Items = Menu.FullMenu();
if (SearchTerms != null)
{
string[] multipleTerms = SearchTerms.Split(" ");
Items = Items.Where(item =>
{
foreach (string term in multipleTerms)
{
if (item.ToString().Contains(term, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
if (item.Description.Contains(term, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
}
return(false);
});
}
if (ItemCategory != null && ItemCategory.Length != 0)
{
Items = from item in Items
where item.ItemCategory != null && ItemCategory.Contains(item.ItemCategory)
select item;
}
if (CaloriesMin != null && CaloriesMax != null)
{
Items = from item in Items
where item.Calories >= CaloriesMin && item.Calories <= CaloriesMax
select item;
}
if (PriceMin != null && PriceMax != null)
{
Items = from item in Items
where item.Price >= PriceMin && item.Price <= PriceMax
select item;
}
//Items = Search(SearchTerms);
//Items = FilterByCategory(Items, ItemCategory);
//Items = FilterByCalories(Items, CaloriesMin, CaloriesMax);
//Items = FilterByPrice(Items, PriceMin, PriceMax);
}
/// <summary>
/// retrieves filters and handles the filtering
/// </summary>
public void OnGet()
{
SearchTerms = Request.Query["SearchTerms"];
ItemType = Request.Query["ItemType"];
CaloriesMinTemp = Request.Query["CaloriesMin"];
CaloriesMaxTemp = Request.Query["CaloriesMax"];
PriceMinTemp = Request.Query["PriceMin"];
PriceMaxTemp = Request.Query["PriceMax"];
if (CaloriesMinTemp != null && !CaloriesMinTemp.Equals(""))
{
CaloriesMin = double.Parse(CaloriesMinTemp);
}
if (CaloriesMaxTemp != null && !CaloriesMaxTemp.Equals(""))
{
CaloriesMax = double.Parse(CaloriesMaxTemp);
}
if (PriceMinTemp != null && !PriceMinTemp.Equals(""))
{
PriceMin = double.Parse(PriceMinTemp);
}
if (PriceMaxTemp != null && !PriceMaxTemp.Equals(""))
{
PriceMax = double.Parse(PriceMaxTemp);
}
Items = Menu.FullMenu();
// Search movie titles for the SearchTerms
if (SearchTerms != null)
{
var searchterms = SearchTerms.Split(' ').ToList();
Items = Items
.Where(x => searchterms.Any(y => x.ToString().Contains(y, StringComparison.InvariantCultureIgnoreCase) || x.Description.Contains(y, StringComparison.InvariantCultureIgnoreCase)));
}
Items = Menu.FilterByItemType(Items, ItemType);
Items = Menu.FilterByCalories(Items, CaloriesMin, CaloriesMax);
Items = Menu.FilterByPrice(Items, PriceMin, PriceMax);
}
public void OnGet()
{
CurrentMenu = Menu.FullMenu();
IEnumerable <IOrderItem> CurDescriptionMenu = Menu.FullMenu();
//Filter by term
if (SearchTerms != null)
{
foreach (string d in SearchTerms.Split(' '))
{
foreach (IOrderItem item in CurrentMenu)
{
CurDescriptionMenu = CurDescriptionMenu.Where(item => item.Description.ToLower().Contains(d.ToLower()));
CurrentMenu = CurrentMenu.Where(item => item.ToString().ToLower().Contains(SearchTerms.ToLower()) || item.Description.ToLower().Contains(d.ToLower()));
}
foreach (IOrderItem curitem in CurDescriptionMenu)
{
CurrentMenu.Append(curitem);
}
}
}
//Filter by calories
if (CalMin != null || CalMax != null)
{
foreach (IOrderItem item in CurrentMenu)
{
CurrentMenu = CurrentMenu.Where(item => (CalMin != null && item.Calories >= CalMin) || (CalMax != null && item.Calories <= CalMax));
if (CalMax != null && CalMin != null)
{
CurrentMenu = CurrentMenu.Where(item => item.Calories >= CalMin && item.Calories <= CalMax);
}
}
}
//filter by price
if (PriceMin != null || PriceMax != null)
{
foreach (IOrderItem item in CurrentMenu)
{
CurrentMenu = CurrentMenu.Where(item => (PriceMin != null && item.Price >= PriceMin) || (PriceMax != null && item.Price <= PriceMax));
if (PriceMax != null && PriceMin != null)
{
CurrentMenu = CurrentMenu.Where(item => item.Price >= PriceMin && item.Price <= PriceMax);
}
}
}
//filter by category
if (Category.Count() != 0)
{
foreach (IOrderItem item in CurrentMenu)
{
CurrentMenu = CurrentMenu.Where(item => (item is Entree && Category.Contains("Entrees")) || (Category.Contains("Sides") && item is Side) || (Category.Contains("Drinks") && item is Drink));
}
}
}
public void OnGet(double?priceMin, double?priceMax, int?caloriesMin, int?caloriesMax)
{
SearchTerms = Request.Query["SearchTerms"];
Categories = Request.Query["Categories"];
CaloriesMin = caloriesMin;
CaloriesMax = caloriesMax;
PriceMin = priceMin;
PriceMax = priceMax;
// Old searching and filtering methods
//Items = Menu.Search(Items, SearchTerms);
//List<string> categories = new List<string>();
//foreach (string category in Categories)
//{
// categories.Add(category);
//}
//Items = Menu.FilterByCategory(Items, categories);
//Items = Menu.FilterByCalories(Items, CaloriesMin, CaloriesMax);
//Items = Menu.FilterByPrice(Items, PriceMin, PriceMax);
// New searching and filtering methods using Linq
Items = Menu.FullMenu();
// Search for keywords in names and descriptions
if (SearchTerms != null)
{
string[] seperateSearchTerms = SearchTerms.Split(' ');
List <IOrderItem> foundItems = new List <IOrderItem>();
foreach (string term in seperateSearchTerms)
{
var nameItemMatch = Items.Where(item => item.Name != null && item.Name.Contains(term, StringComparison.InvariantCultureIgnoreCase));
var descriptionItemMatch = Items.Where(item => item.Description != null && item.Description.Contains(term, StringComparison.InvariantCultureIgnoreCase));
foreach (IOrderItem item in nameItemMatch)
{
foundItems.Add(item);
}
foreach (IOrderItem item in descriptionItemMatch)
{
foundItems.Add(item);
}
}
Items = foundItems;
}
// Filter by specific categories
if (Categories != null && Categories.Length != 0)
{
if (Categories.Length == 3)
{
// All categories are checked, so there is no need to filter by category
}
else if (Categories.Length == 2)
{
// Two categories are checked
if ((Categories[0].Equals("Entree") || Categories[1].Equals("Entree")) && (Categories[0].Equals("Drink") || Categories[1].Equals("Drink")))
{
// Entree and drink are selected
Items = Items.Where(item => item is Entree || item is Drink);
}
else if ((Categories[0].Equals("Entree") || Categories[1].Equals("Entree")) && (Categories[0].Equals("Side") || Categories[1].Equals("Side")))
{
// Entree and side are selected
Items = Items.Where(item => item is Entree || item is Side);
}
else if ((Categories[0].Equals("Side") || Categories[1].Equals("Side")) && (Categories[0].Equals("Drink") || Categories[1].Equals("Drink")))
{
// Drink and side are selected
Items = Items.Where(item => item is Drink || item is Side);
}
}
else
{
// One category is checked
if (Categories[0].Equals("Entree"))
{
Items = Items.Where(item => item is Entree);
}
else if (Categories[0].Equals("Side"))
{
Items = Items.Where(item => item is Side);
}
else if (Categories[0].Equals("Drink"))
{
Items = Items.Where(item => item is Drink);
}
}
}
// Filter by input prices
if (PriceMin == null && PriceMax == null)
{
}
else if (PriceMin == null)
{
Items = Items.Where(item => item.Price <= PriceMax);
}
else if (PriceMax == null)
{
Items = Items.Where(item => item.Price >= PriceMin);
}
else
{
Items = Items.Where(item => item.Price >= PriceMin && item.Price <= PriceMax);
}
// Filter by input calories
if (CaloriesMin == null && CaloriesMax == null)
{
}
else if (CaloriesMin == null)
{
Items = Items.Where(item => item.Calories <= CaloriesMax);
}
else if (CaloriesMax == null)
{
Items = Items.Where(item => item.Calories >= CaloriesMin);
}
else
{
Items = Items.Where(item => item.Calories >= CaloriesMin && item.Calories <= CaloriesMax);
}
List <IOrderItem> entrees = new List <IOrderItem>();
List <IOrderItem> sides = new List <IOrderItem>();
List <IOrderItem> drinks = new List <IOrderItem>();
foreach (IOrderItem item in Items)
{
if (item is Entree)
{
entrees.Add(item);
}
else if (item is Side)
{
sides.Add(item);
}
else if (item is Drink)
{
drinks.Add(item);
}
}
Entrees = entrees;
Sides = sides;
Drinks = drinks;
}
public void OnGet()
{
// Filter by search terms
if (SearchTerms != null)
{
MenuList = Menu.FullMenu().Where(item => (item.ToString() != null && item.ToString().Contains(SearchTerms, StringComparison.InvariantCultureIgnoreCase)) || (item.Description != null && item.Description.Contains(SearchTerms, StringComparison.InvariantCultureIgnoreCase)));
if (MenuList.Count() == 0)
{
string[] terms = SearchTerms.Split(' ');
foreach (string s in terms)
{
if (MenuList.Count() > 0)
{
IEnumerable <IOrderItem> newList = Menu.FullMenu().Where(item => (item.ToString() != null && item.ToString().Contains(s, StringComparison.InvariantCultureIgnoreCase)) || (item.Description != null && item.Description.Contains(s, StringComparison.InvariantCultureIgnoreCase)));
MenuList = MenuList.Concat(newList);
}
else
{
MenuList = Menu.FullMenu().Where(item => (item.ToString() != null && item.ToString().Contains(s, StringComparison.InvariantCultureIgnoreCase)) || (item.Description != null && item.Description.Contains(s, StringComparison.InvariantCultureIgnoreCase)));
}
}
}
}
// Filter by category
if (!(Categories == null || Categories.Count() == 0))
{
MenuList = MenuList.Where(item => (item is Entree && Categories.Contains("Entree")) || (item is Drink && Categories.Contains("Drink")) || (item is Side && Categories.Contains("Side")));
}
// Filter by calories
if (CalorieMin != null || CalorieMax != null)
{
if (CalorieMin == null)
{
MenuList = MenuList.Where(item => item.Calories <= CalorieMax);
}
else if (CalorieMax == null)
{
MenuList = MenuList.Where(item => item.Calories >= CalorieMin);
}
else
{
MenuList = MenuList.Where(item => item.Calories >= CalorieMin && item.Calories <= CalorieMax);
}
}
// Filter by price
if (PriceMin != null || PriceMax != null)
{
if (PriceMin == null)
{
MenuList = MenuList.Where(item => item.Price <= PriceMax);
}
else if (PriceMax == null)
{
MenuList = MenuList.Where(item => item.Price >= PriceMin);
}
else
{
MenuList = MenuList.Where(item => item.Price >= PriceMin && item.Price <= PriceMax);
}
}
//MenuList = Menu.FilterByCategory(Menu.Search(SearchTerms), Categories);
//MenuList = Menu.FilterByCalories(MenuList, CalorieMin, CalorieMax);
//MenuList = Menu.FilterByPrice(MenuList, PriceMin, PriceMax);
}
/// <summary>
/// This code runs during initial start of the webpage. AnyTime the submit button is clicked this code will run again calling on
/// the filter methods provided in the Menu.cs class to filter the food results in the html webpage
/// </summary>
/// <param name="CaloriesMin">Minimum calories specified by user</param>
/// <param name="CaloriesMax">Maximum Calories specified by user</param>
/// <param name="PricesMin">minimum Price specified by user</param>
/// <param name="PricesMax">Maximum Price specified by user</param>
public void OnGet(uint?CaloriesMin, uint?CaloriesMax, double?PricesMin, double?PricesMax)
{
SearchTerms = Request.Query["SearchTerms"];
FoodTypes = Request.Query["FoodTypes"];
this.CaloriesMin = CaloriesMin; //keeps value updated after a search on the html
this.CaloriesMax = CaloriesMax; //keeps value updated after a search on the html
this.PricesMin = PricesMin;
this.PricesMax = PricesMax;
//set the displayed results to All original Entrees, sides, drinks (avoids the first search needing to refer to Entrees.Where()
DisplayedEntrees = Entrees;
DisplayedSides = Sides;
DisplayedDrinks = Drinks;
if (FoodTypes.Count() != 0) //no checkboxes are not checked so ignore category search
{
List <IOrderItem> emptyList = new List <IOrderItem>();
if (FoodTypes.Contains("Entrees"))
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree is Entree);
}
else
{
DisplayedEntrees = emptyList;
}
if (FoodTypes.Contains("Sides"))
{
DisplayedSides = DisplayedSides.Where(side => side is Side);
}
else
{
DisplayedSides = emptyList;
}
if (FoodTypes.Contains("Drinks"))
{
DisplayedDrinks = DisplayedDrinks.Where(drink => drink is Drink);
}
else
{
DisplayedDrinks = emptyList;
}
}
//Categories
//DisplayedEntrees = Menu.FilterByType(Entrees, FoodTypes); //starts filtering from All entrees
//DisplayedSides = Menu.FilterByType(Sides, FoodTypes);
//DisplayedDrinks = Menu.FilterByType(Drinks, FoodTypes);
//testing Linq method/ query sql
if (SearchTerms != null) //search terms using LINQ Where() method
{
//note we should separate string into a string array and then run through this multiple times to accumulate a list
// so that we can use multiple search words without achieving minimal results
string[] splitString = SearchTerms.Split(' ');
IEnumerable <IOrderItem> listEntrees = Enumerable.Empty <IOrderItem>();
IEnumerable <IOrderItem> listSides = Enumerable.Empty <IOrderItem>();
IEnumerable <IOrderItem> listDrinks = Enumerable.Empty <IOrderItem>();
IEnumerable <IOrderItem> list = Enumerable.Empty <IOrderItem>();
foreach (string word in splitString)
{
//listEntrees = DisplayedEntrees.Where(entree => entree.ToString() != null
//&& entree.ToString().Contains(word, StringComparison.InvariantCultureIgnoreCase));
list = DisplayedEntrees.Where(entree => entree.ToString() != null &&
(entree.ToString().Contains(word, StringComparison.InvariantCultureIgnoreCase) ||
entree.Description.Contains(word, StringComparison.InvariantCultureIgnoreCase)));
listEntrees = listEntrees.Concat(list);
list = DisplayedSides.Where(side => side.ToString() != null &&
(side.ToString().Contains(word, StringComparison.InvariantCultureIgnoreCase) ||
side.Description.Contains(word, StringComparison.InvariantCultureIgnoreCase)));
listSides = listSides.Concat(list);
list = DisplayedDrinks.Where(drink => drink.ToString() != null &&
(drink.ToString().Contains(word, StringComparison.InvariantCultureIgnoreCase) ||
drink.Description.Contains(word, StringComparison.InvariantCultureIgnoreCase)));
listDrinks = listDrinks.Concat(list);
}
DisplayedEntrees = listEntrees;
DisplayedSides = listSides;
DisplayedDrinks = listDrinks;
}
//Search terms filter... using functions() from menu.cs
//DisplayedEntrees = Menu.Search(DisplayedEntrees, SearchTerms);
//DisplayedSides = Menu.Search(DisplayedSides, SearchTerms);
//DisplayedDrinks = Menu.Search(DisplayedDrinks, SearchTerms);
if ((CaloriesMin != 0 && CaloriesMin != null) || (CaloriesMax != 0 && CaloriesMax != null)) //Calories filter using LINQ Where() method
{
if (CaloriesMax == 0 || CaloriesMax == null)
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Calories >= CaloriesMin);
DisplayedSides = DisplayedSides.Where(side => side.Calories >= CaloriesMin);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Calories >= CaloriesMin);
}
else if (CaloriesMin == 0 || CaloriesMin == null)
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Calories <= CaloriesMax);
DisplayedSides = DisplayedSides.Where(side => side.Calories <= CaloriesMax);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Calories <= CaloriesMax);
}
else //both min and max are specified are available
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Calories >= CaloriesMin && entree.Calories <= CaloriesMax);
DisplayedSides = DisplayedSides.Where(side => side.Calories >= CaloriesMin && side.Calories <= CaloriesMax);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Calories >= CaloriesMin && drink.Calories <= CaloriesMax);
}
}
//Calories filter: ...using functions() from menu.cs
//DisplayedEntrees = Menu.FilterByCalories(DisplayedEntrees, CaloriesMin, CaloriesMax);
//DisplayedSides = Menu.FilterByCalories(DisplayedSides, CaloriesMin, CaloriesMax);
//DisplayedDrinks = Menu.FilterByCalories(DisplayedDrinks, CaloriesMin, CaloriesMax);
if ((PricesMin != 0 && PricesMin != null) || (PricesMax != 0 && PricesMax != null)) //Prices filter using LINQ Where() method
{
if (PricesMax == 0 || PricesMax == null)
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Price >= PricesMin);
DisplayedSides = DisplayedSides.Where(side => side.Price >= PricesMin);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Price >= PricesMin);
}
else if (PricesMin == 0 || PricesMin == null)
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Price <= PricesMax);
DisplayedSides = DisplayedSides.Where(side => side.Price <= PricesMax);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Price <= PricesMax);
}
else //both min and max are specified are available
{
DisplayedEntrees = DisplayedEntrees.Where(entree => entree.Price >= PricesMin && entree.Price <= PricesMax);
DisplayedSides = DisplayedSides.Where(side => side.Price >= PricesMin && side.Price <= PricesMax);
DisplayedDrinks = DisplayedDrinks.Where(drink => drink.Price >= PricesMin && drink.Price <= PricesMax);
}
}
//Prices filter: ..using functions() from menu.cs
//DisplayedEntrees = Menu.FilterByPrices(DisplayedEntrees, PricesMin, PricesMax);
//DisplayedSides = Menu.FilterByPrices(DisplayedSides, PricesMin, PricesMax);
//DisplayedDrinks = Menu.FilterByPrices(DisplayedDrinks, PricesMin, PricesMax);
}
