public OrderItemVM(order_item oi, menu_item mi, side si)
{
id = oi.id;
this.order_item = oi;
this.menu_item = mi;
order_item_status = (int)oi.order_item_status;
this.side = si;
}
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 SearchViewModel PopulateSearchViewModel(menu_item menuItem)
{
return new SearchViewModel
{
menuItemId = menuItem.id,
name = menuItem.item.name,
description = menuItem.item.description,
metadata = menuItem.item.metadata,
catName = menuItem.menu_category.category.name,
menuName = menuItem.menu_category.menu.name,
price = menuItem.price
};
}
public Boolean edit(menu_item menu_item)
{
menu_item dbVersion = db.menu_item.Find(menu_item.id);
if (dbVersion.version == menu_item.version)
{
((IObjectContextAdapter)db).ObjectContext.Detach(dbVersion);
db.Entry(menu_item).State = EntityState.Modified;
menu_item.version = menu_item.version + 1;
db.SaveChanges();
return true;
}
return false;
}
//Returns the average rating given to a menu item
// returns 0 if never rated
public static double getAverageRating(menu_item mi)
{
double totalRating = 0;
int count = 0;
List<review_order_item> reviews = mi.order_item.
SelectMany(oi => oi.review_order_item).
ToList<review_order_item>();
foreach (review_order_item roi in reviews)
{
count++;
totalRating += (int)roi.rating;
}
if (count == 0) { return 0; }
return Math.Round((double)(totalRating / count), 2);
}
public void AddMenuItem(menu_item mi, side si, OrderStatusHelper.OrderItemStatusEnum orderItemStatus)
{
order_item oi = new order_item();
oi.menu_item_id = mi.id;
if (si.id == -1)
{
oi.sides_id = null;
}
else
{
oi.sides_id = si.id;
}
oi.id = uniqueId--;
oi.order_id = this.id;
oi.order_item_status = (int)orderItemStatus;
this.order_item.Add(oi);
if (this.total == null) this.total = (decimal)0.0;
this.total += mi.price;
}
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);
}
public ActionResult Create(menu_item menu_item)
{
if (ModelState.IsValid)
{
try
{
if (om.Create(menu_item))
{
return RedirectToAction("Index");
}
}
catch (Exception)
{
ViewBag.error = Global.MenuItemCreateError;
}
}
ViewBag.Error = Global.Error_Title;
ViewBag.item_id = new SelectList(db.items, "id", "name", menu_item.item_id);
ViewBag.menu_category_id = new SelectList(db.menu_category, "id", "id", menu_item.menu_category_id);
return View(menu_item);
}
public bool addItemToMenu(int menu_cat_id, ItemFilterVM i_filter, decimal price)
{
bool isSuccess = false;
item item = i_filter.items.First();
menu_category mc = db.menu_category.Find(menu_cat_id);
menu_item mi = new menu_item();
//Initialize values
mi.item_id = item.id;
mi.menu_category_id = menu_cat_id;
item.category_id = db.menu_category.Find(menu_cat_id).category_id;
mi.price = price;
//Inherit parent active status
mi.is_active = mc.is_active;
if (item.name != "" && menu_cat_id != 0)
{
db.items.Add(item);
db.menu_item.Add(mi);
db.SaveChanges();
isSuccess = true;
}
if (isSuccess)
{
HttpContext.Session["message"] = item.name + " successfuly added.";
// Load search data into memory
SearchUtil su = new SearchUtil();
su.ClearAndFill();
}
else
{
HttpContext.Session["error"] = item.name + " could not be added.";
}
return isSuccess;
}
public void MyTestInitialize()
{
//Add test data (order specific)
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
}
/// <summary>
/// Creates an entry of type order item in the database.
/// </summary>
/// <param name="orderEntity">Order that order items belongs to.</param>
/// <param name="billEntity">Bill that order item belongs to.</param>
/// <returns>The created order item entity.</returns>
public order_item AddOrderItem(order orderEntity, bill billEntity, menu_item menuItem)
{
//Initialise
db = new touch_for_foodEntities();
order_item testOrderItem = new order_item();
//Set Attributes
testOrderItem.order_id = orderEntity.id;
testOrderItem.bill_id = billEntity.id;
testOrderItem.menu_item_id = menuItem.id;
testOrderItem.version = 1;
//Save
db.order_item.Add(testOrderItem);
db.SaveChanges();
db.Dispose();
return testOrderItem;
}
public void DeleteConfirmedTestItemActiveException()
{
// Arrange
db = new touch_for_foodEntities();
Menu_ItemController target = new Menu_ItemController();
int expectedMenuItems = db.menu_item.ToList<menu_item>().Count();
menuItem1 = db.menu_item.Find(menuItem1.id);
menuItem1.is_active = true;
db.Entry(menuItem1).State = EntityState.Modified;
db.SaveChanges();
// Act
var actualResult = target.DeleteConfirmed(menuItem1.id) as RedirectToRouteResult;
// Assertions
db = new touch_for_foodEntities();
var actualResultURI = actualResult.RouteValues["action"];
int actualMenuItems = db.menu_item.ToList<menu_item>().Count();
Assert.AreEqual(expectedMenuItems, actualMenuItems);
Assert.IsFalse(db.menu_item.Find(menuItem1.id).is_deleted);
Assert.AreEqual("Index", actualResultURI);
}
/// <summary>
/// Writes a menu_item object to the database
/// </summary>
/// <param name="mi">The menu_item object to write</param>
/// <returns>True if successful, false otherwise</returns>
public bool Create(menu_item mi)
{
db.menu_item.Add(mi);
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);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
table1 = testDatabase.AddTable(restaurant1);
order1 = testDatabase.AddOrder(table1);
user1 = testDatabase.AddUser("*****@*****.**", table1, (int)SiteRoles.Admin);
}
/// <summary>
/// Remove menu item item from database.
/// </summary>
/// <param name="menuEntity">Menu item item to be removed.</param>
public void RemoveMenuItem(menu_item menuItemEntity)
{
db = new touch_for_foodEntities();
if (db.menu_item.Find(menuItemEntity.id) != null)
{
db.menu_item.Remove(db.menu_item.Find(menuItemEntity.id));
db.SaveChanges();
}
db.Dispose();
}
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 ActionResult Edit(menu_item menu_item)
{
if (ModelState.IsValid)
{
try
{
if (om.edit(menu_item))
return RedirectToAction("Index");
else
{
ViewBag.Error = Global.LockError;
}
}
catch (Exception)
{
ViewBag.Error = Global.ServerError;
}
}
else
{
ViewBag.Error = Global.ServerError;
}
if (ViewBag.Error == null)
{
ViewBag.Error = Global.Error_Title;
}
ViewBag.item_id = new SelectList(db.items, "id", "name", menu_item.item_id);
ViewBag.menu_category_id = new SelectList(db.menu_category, "id", "id", menu_item.menu_category_id);
return View(menu_item);
}
public static item filterItem(menu_item mi)
{
item i = (item)db.items.Find(mi.item_id);
return i;
}
public PartialViewResult GetAllReviews(menu_item mi)
{
List<review_order_item> reviews = im.find(mi.id).order_item.SelectMany(oi => oi.review_order_item)
.OrderByDescending(r => r.submitted_on)
.ToList<review_order_item>();
return PartialView("_PastReviewsPartial", reviews);
}
public void MyTestInitialize()
{
//Add test data (order specific)
db = new touch_for_foodEntities();
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
orderItem1 = testDatabase.AddOrderItem(order1, menuItem1);
reviewOrderItem1 = testDatabase.AddReviewOrderItem(review1, orderItem1, "testing1", 2);
reviewOrderItem2 = testDatabase.AddReviewOrderItem(review1, orderItem1, "testing2", 3);
//set parameters for menuItem2
menuItem2 = new menu_item();
menuItem2.item_id = item1.id;
menuItem2.menu_category_id = menuCategory1.id;
menuItem2.price = new decimal(10.99);
menuItem2.is_active = false;
menuItem2.is_deleted = false;
}
/// <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;
}
