/**
* Filters the sides and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static IList<side> FilterListBySide(menu_category menu_category)
{
touch_for_foodEntities db = new touch_for_foodEntities();
List<side> filteredList = new List<side>();
int resto_id = menu_category.menu.resto_id;
// We want all sides that do not exist in this menu_category and that belong to this restaurant.
// is_deleted and is_active need to be considered too. Show only sides where is_active is false
// if side is_deleted is true, then there should be another page to revert that. the side functionality
// I'm putting should only set a side to is_active is true or false
List<side> restaurantSides = db.sides.Where
(
si =>
si.menu_category.menu.resto_id == resto_id
&& si.is_active == false
&& si.is_deleted == false
).ToList();
foreach (var side in restaurantSides)
{
if (side.menu_category_id.Equals(menu_category.id))
{
filteredList.Add(side);
}
}
db.Dispose();
return filteredList;
}
public Boolean edit(menu_category menu_category)
{
MenuCategoryIM im = new MenuCategoryIM(db);
menu_category dbVersion = im.find(menu_category.id);
if (dbVersion.version == menu_category.version)
{
//Activate / Deactivate the menu category means changing the active feild to all menu items inside it
//if (dbVersion.is_active != menu_category.is_active)
//{
MenuItemOM om = new MenuItemOM(db);
IList<menu_item> menu_item_list = menu_category.menu_item.ToList();
for (int i = 0; i < menu_item_list.Count; i++)
{
menu_item mi = menu_item_list.ElementAt(i);
mi.is_active = menu_category.is_active;
om.edit(mi);
}
//}
((IObjectContextAdapter)db).ObjectContext.Detach(dbVersion);
db.Entry(menu_category).State = EntityState.Modified;
menu_category.version = menu_category.version + 1;
db.SaveChanges();
return true;
}
return false;
}
public static void MyClassInitialize(TestContext testContext)
{
//Add test data (order specific)
testDatabase = new TestDatabaseHelper();
item1 = testDatabase.AddItem();
item2 = testDatabase.AddItem();
category1 = testDatabase.AddCategory();
restaurant1 = testDatabase.AddRestaurant();
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
menuItem1 = testDatabase.AddMenuItem(item2, menuCategory1);
}
public static void MyClassInitialize(TestContext testContext)
{
//Add test data (order specific)
testDatabase = new TestDatabaseHelper();
restaurant1 = testDatabase.AddRestaurant();
table1 = testDatabase.AddTable(restaurant1);
user1 = testDatabase.AddUser("*****@*****.**", table1, (int)SiteRoles.Customer);
order1 = testDatabase.AddOrder(table1);
item1 = testDatabase.AddItem();
category1 = testDatabase.AddCategory();
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
orderItem1 = testDatabase.AddOrderItem(order1, menuItem1);
//Session
db = new touch_for_foodEntities();
ReviewController target = new ReviewController();
Session session = new Session(db, target);
session.simulateLogin(user1.username, user1.password);
}
/**
* Filters the categories and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static IList<item> filterListByItem(menu_category menu_category,touch_for_foodEntities db)
{
List<item> filteredList = new List<item>();
MenuItemIM im = new MenuItemIM(db);
int resto_id = menu_category.menu.resto_id;
bool reject = false;
foreach (item i in db.items.ToList())
{
reject = false;
//First check that the category does belong to the restaurant
//Find all usages of the category in question in the current restaurant
List<menu_item> usages = db.menu_item.Where(mi => mi.item_id == i.id && mi.menu_category.menu.resto_id == resto_id).ToList();
//If it was never used by this restaurant, then the restaurant could not have created it
// because create automatically adds the created item to the menu
if (usages.Count == 0)
{
reject = true;
}
if (menu_category.category.id == i.category_id)
{
foreach (menu_item m_i in im.find(false, menu_category.id))
{
if (i.id == m_i.item_id)
{
reject = true;
break;
}
}
if (!reject)
{
filteredList.Add(i);
}
}
}
db.Dispose();
return filteredList;
}
public bool addCategoryToMenu(int menu_id, CategoryFilterVM cat_filter)
{
bool isSuccess = false;
category category = cat_filter.m_category.First();
if (ValidateCategory(category))
{
menu menu = db.menus.Find(menu_id);
menu_category mc = new menu_category();
mc.category_id = category.id;
mc.menu_id = menu_id;
//Inherit parent active status
mc.is_active = menu.is_active;
if (category.name != "" && menu_id != 0)
{
db.categories.Add(category);
db.menu_category.Add(mc);
db.SaveChanges();
isSuccess = true;
}
}
if (isSuccess)
{
HttpContext.Session["message"] = category.name + " successfuly added.";
}
else
{
HttpContext.Session["error"] = category.name + " could not be added - " + ViewBag.Error;
}
return isSuccess;
}
public void CreateTest()
{
//Arrange
db = new touch_for_foodEntities();
Menu_CategoryController target = new Menu_CategoryController(db);
int numberOfMenuCategoriesBefore = db.categories.Find(category1.id).menu_category.ToList<menu_category>().Count();
menu_category menuCategory2 = new menu_category();
menuCategory2.is_active = false;
menuCategory2.category_id = category1.id;
menuCategory2.menu_id = menu1.id;
//Act
target.Create(menuCategory2);
//Assert
db = new touch_for_foodEntities();
int numberOfMenuCategoriesAfter = db.categories.Find(category1.id).menu_category.ToList<menu_category>().Count();
Assert.AreEqual((numberOfMenuCategoriesBefore + 1), numberOfMenuCategoriesAfter);
}
public ItemFilterVM()
{
items = new List<item>();
menu_cat = new menu_category();
}
public SideFilterVM()
{
sides = new List<side>();
menu_cat = new menu_category();
}
public void MyTestInitialize()
{
//Add test data (order specific)
category1 = testDatabase.AddCategory();
restaurant1 = testDatabase.AddRestaurant();
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
table1 = testDatabase.AddTable(restaurant1);
order1 = testDatabase.AddOrder(table1);
item1 = testDatabase.AddItem(category1);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
orderItem1 = testDatabase.AddOrderItem(order1, menuItem1);
}
public void MyTestInitialize()
{
//Add test data (order specific)
category1 = testDatabase.AddCategory();
category2 = testDatabase.AddCategory();
category3 = new category();
category3.name = "CategoryUnitTest";
category3.version = 1;
menuCategory1 = testDatabase.AddMenuCategory(category2, menu1);
//Session
target = new CategoryController();
Session session = new Session(db, target);
}
/// <summary>
/// Remove menu item from database.
/// </summary>
/// <param name="menuCategoryEntity">Menu Category item to be removed.</param>
public void RemoveMenuCategory(menu_category menuCategoryEntity)
{
db = new touch_for_foodEntities();
if (db.menu_category.Find(menuCategoryEntity.id) != null)
{
db.menu_category.Remove(db.menu_category.Find(menuCategoryEntity.id));
db.SaveChanges();
}
db.Dispose();
}
/// <summary>
/// Creates an entry of type side in the database.
/// </summary>
/// <param name="menuCategory">The menu category associated to the side</param>
/// <returns>The created side entity.</returns>
public side AddSide(menu_category menuCategory)
{
//Initialise
db = new touch_for_foodEntities();
side testSide = new side();
//Set Attributes
testSide.name = "UnitTest";
testSide.price = new decimal(2.99);
testSide.version = 1;
testSide.menu_category_id = menuCategory.id;
testSide.is_active = false;
testSide.is_deleted = false;
//Save
db.sides.Add(testSide);
db.SaveChanges();
db.Dispose();
return testSide;
}
/// <summary>
/// Creates an entry of type menu itemin the database.
/// </summary>
/// <param name="itemEntity">The item the menu item represents.</param>
/// <param name="menuCategory">Category the menu item belongs to</param>
/// <returns>The created menu item entry.</returns>
public menu_item AddMenuItem(item itemEntity, menu_category menuCategory)
{
//Initialise
db = new touch_for_foodEntities();
menu_item testMenuItem = new menu_item();
//Set Attributes
testMenuItem.item_id = itemEntity.id;
testMenuItem.menu_category_id = menuCategory.id;
testMenuItem.price = new decimal(10.99);
testMenuItem.is_active = false;
//Save
db.menu_item.Add(testMenuItem);
db.SaveChanges();
db.Dispose();
return testMenuItem;
}
/// <summary>
/// Creates an entry of type menu category in the database.
/// </summary>
/// <param name="categoryEntity">The category the menu category is an extension of</param>
/// <param name="menuEntity">The menu the category belongs to</param>
/// <returns>The created menu category</returns>
public menu_category AddMenuCategory(category categoryEntity, menu menuEntity)
{
//Initialise
db = new touch_for_foodEntities();
menu_category testMenuCategory = new menu_category();
//Set Attributes
testMenuCategory.category_id = categoryEntity.id;
testMenuCategory.menu_id = menuEntity.id;
testMenuCategory.is_active = false;
//Save
db.menu_category.Add(testMenuCategory);
db.SaveChanges();
db.Dispose();
return testMenuCategory;
}
public void MyTestInitialize()
{
//Add test data (order specific)
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
}
public PartialViewResult FilterSides(menu_category menu_cat)
{
SideFilterVM iFilter = new SideFilterVM(menu_cat, SideUtil.FilterListBySide(menu_cat)); //(menu_cat, SideUtil.FilterListBySide(menu_cat));
return PartialView("_SideTable", iFilter);
}
public ActionResult Edit(menu_category menu_category)
{
if (ModelState.IsValid)
{
try
{
if (om.edit(menu_category))
return RedirectToAction("Index");
else
{
ViewBag.Error = Global.VersioningError;
}
}
catch (Exception)
{
ViewBag.Error = Global.ServerError;
}
}
ViewBag.category_id = new SelectList(db.categories, "id", "name", menu_category.category_id);
ViewBag.menu_id = new SelectList(db.menus, "id", "name", menu_category.menu_id);
return View(menu_category);
}
public PartialViewResult FilterItems(menu_category menu_cat)
{
ItemFilterVM iFilter = new ItemFilterVM(menu_cat, ItemUtil.filterListByItem(menu_cat,db));
return PartialView("_ItemTable", iFilter);
}
public void MyTestInitialize()
{
//Add test data (order specific)
item1 = testDatabase.AddItem(category1);
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
//Session
db = new touch_for_foodEntities();
target = new ItemController(db);
Session session = new Session(db, target);
session.simulateLogin(user1.username, user1.password);
}
public SideFilterVM(menu_category category, IList<side> sides_list)
{
menu_cat = category;
sides = sides_list;
}
/// <summary>
/// Writes a menu_category object to the database
/// </summary>
/// <param name="mc">The menu_category object to write</param>
/// <returns>True if successful, false otherwise</returns>
public bool Create(menu_category mc)
{
db.menu_category.Add(mc);
return (db.SaveChanges() == 1);
}
public static void MyClassInitialize(TestContext testContext)
{
testDatabase = new TestDatabaseHelper();
//Add test data (order specific)
item1 = testDatabase.AddItem();
category1 = testDatabase.AddCategory();
restaurant1 = testDatabase.AddRestaurant();
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
table1 = testDatabase.AddTable(restaurant1);
order1 = testDatabase.AddOrder(table1);
user1 = testDatabase.AddUser("*****@*****.**", table1, (int)SiteRoles.Admin);
review1 = testDatabase.AddReview(restaurant1, order1, user1);
}
public ItemFilterVM(menu_category category, IList<item> items_list)
{
menu_cat = category;
items = items_list;
}
