/* Called by form1's wrapper function
* Encapsulates an order with an OrderContainer, adds the order to the order list.
* Then confirms the order
*/
public void DoAddOrderToListAndConfirmOrder(Order order, bool isAdjustedOrder)
{
OrderContainer orderCon = new OrderContainer(order);
if (isAdjustedOrder)
{
orderCon.Status = "Active(Adjusted)";
}
OrderList.Add(orderCon); //Add the OrderContainer to the OrderList to update the UI list
//there seems to be a bug where an existing messageId tries to be inserted again
try {
OrderTableByMsgId.Add(order.MessageId, orderCon); //Insert the entry into the table for easily updating order status
} catch (Exception e) {
Debug.WriteLine(order.MessageId + " already inserted in OrderTable. " + e.Message);
}
if (order.Service == "GrubHub")
{
InsertToOrderNumTable(orderCon); //We insert the entry into the table with orderNum as the key
}
//Automatically confirm the order, if the URL was successfully parsed
if (order.ConfirmURL != "Failed to parse")
{
ConfirmOrder(orderCon);
}
UpdateOrderUI(); //Update the Item List in the GUI to match the selected row
PlaySound(Program.NotificationSoundPath); //play the nofication sound
}
/*
* 将订单加入已点列表的方法
* */
private void AddOrder(String DTitle, int number)
{
int index = 0;
foreach (AddOrderTmp orderTmp in addOrders)
{
if (DTitle == orderTmp.DTitle)
{
//列表中已经存在的项目，把数量加一下然后退出
addOrders[index].DNumber = (int.Parse(addOrders[index].DNumber) + number).ToString();
OrderContainer container = new OrderContainer(addOrders[index]);
//ListBox方法里面没有替换，只能是先删除然后插入
OrderList.Items.RemoveAt(index);
ListBoxItem boxItem = new ListBoxItem();
boxItem.Content = container;
OrderList.Items.Insert(index, boxItem);
CountPriceSummary();
return;
}
index++;
}
Dish dish = DishInfoConnector.GetDish(DTitle.Trim());
AddOrderTmp addOrder = new AddOrderTmp(DTitle, dish.DPrice.ToString(), number.ToString());
OrderContainer orderContainer = new OrderContainer(addOrder);
orderContainer.CancelButton.Click += DeleteThisOrderItem;
ListBoxItem item = new ListBoxItem();
item.Content = orderContainer;
OrderList.Items.Add(item);
addOrders.Add(addOrder); //用addOrders存储已点的菜品
CountPriceSummary();
}
public ActionResult Buy(int pokemonId, string returnUrl, string info = null)
{
var container = new OrderContainer();
var user = db.Users.FirstOrDefault(l => l.Login == HttpContext.User.Identity.Name);
var pokemon = db.Pokemons.Find(pokemonId);
if (user != null)
{
if (pokemon != null)
{
container.Pokemon_for_Order = pokemon;
container.User_for_Order = user;
ViewBag.pokemonName = pokemon.Name;
if (info != null)
{
ViewBag.info = info;
}
return(View("OrderForm", container));
}
else
{
return(RedirectToAction("List", "Pokemon"));
}
}
return(RedirectToAction("Login", "Pokemon"));
}
/* Called by form1's actual button handle function
* Gets the order that is currently selected, if any, and then prints it, and sets the Print Status
* To protect from spam, we disable the button on click, and then only enable the button after the
* print status is set. Maybe use a timer that starts afer print status is set.
*/
public void HandlePrintButtonClick()
{
Form1 mainForm = (Form1)ParentForm;
mainForm.SetPrintButtonEnabledStatus(false);
mainForm.SetPrintButtonColor("#90979B");
DataGridViewSelectedRowCollection selectedRows = dataGridViewOrderList.SelectedRows;
if (selectedRows.Count > 0)
{
OrderContainer orderCon = (OrderContainer)selectedRows[0].DataBoundItem;
if (orderCon == null)
{
return; //incase there are no orders
}
bool printed = PrinterUtility.PrintOrder(orderCon);
if (printed)
{
orderCon.PrintStatus = "Printed";
}//else error messages are handled in the print utility
//To force the form to update the print status value.
//dataGridViewOrderList.Refresh() maybe useful if using a "Print All" button
orderListBindingSrc.ResetCurrentItem();
}
mainForm.SetPrintButtonEnabledStatus(true);
mainForm.SetPrintButtonColor("#4A5157");
}
private string SaveToOrders(OrderContainer container, out string result)
{
var user = db.Users.FirstOrDefault(e => e.Email == container.User_for_Order.Email);
if (user != null)
{
string login = user.Login;
if (login == HttpContext.User.Identity.Name)
{
Orders newOrder = new Orders
{
UserID = user.UserID,
PokemonID = container.Pokemon_for_Order.PokemonID,
Count = container.order.Count,
Date = container.order.Date,
};
db.Orders.Add(newOrder);
db.SaveChanges();
return(result = "OK");
}
else
{
return(result = "This is not your email");
}
}
return(result = null);
}
public ActionResult Checkout(OrderContainer container)
{
if (container != null)
{
container.order = new Orders();
container.order.Date = DateTime.Now;
container.order.Count = 1;
string result = SaveToOrders(container, out result);
if (result == "OK")
{
SendLetter(container);
return(RedirectToAction("News", "Pokemon"));
}
else
{
if (result != null)
{
ViewBag.pokemonName =
ViewBag.info = result;
}
else
{
ViewBag.info = "There is no user with email: " + container.User_for_Order.Email;
}
return(View("OrderForm"));
}
}
return(View("List"));
}
public void DispatchOrderContainerToReceivers(OrderContainer oc)
{
foreach (OrderReceiver p in oc.orderReceivers)
{
p.AddOrderContainerAtAppropriatePosition(oc.Copy());
}
}
/* Updates the UI to match the order in the selected row by
* updating the Order Details and Item List
*/
private void UpdateOrderUI()
{
DataGridViewSelectedRowCollection selectedRows = dataGridViewOrderList.SelectedRows;
OrderContainer selectedRow = (OrderContainer)selectedRows[0].DataBoundItem;
UpdateItemListUI(selectedRow);
UpdateOrderDetailsUI(selectedRow);
UpdateItemDetailsUI();
}
static void Main(string[] args)
{
OrderContainer <Order> orderCont = new OrderContainer <Order>();
orderCont.OrderInsert += new OrderContainer <Order> .InsertOrderDelegate <Order>(orderCont_OrderInsert);
OrderContainer <DayOrder> dayorderCont = new OrderContainer <DayOrder>();
dayorderCont.OrderInsert += new OrderContainer <DayOrder> .InsertOrderDelegate <DayOrder>(dayorderCont_OrderInsert);
}
private void UpdateNavigationButtonDisplay(double offset = 0)
{
var backwardEnabled = offset > 0;
var forwardEnabled = offset + (this.ActualWidth + 10) < _cordX + _orderWidth;
BackwardNavigationButton.IsEnabled = backwardEnabled;
LeftNavigationButton.IsEnabled = backwardEnabled;
ForwardNavigationButton.IsEnabled = forwardEnabled;
RightNavigationButton.IsEnabled = forwardEnabled;
OrderContainer.Focus();
}
private string GetPhone(OrderContainer orderContainer)
{
if (orderContainer.NotRegisteredUser)
{
return(orderContainer.Phone);
}
else
{
return(orderContainer.User.PhoneNumber);
}
}
private void MainWindow_Activated(object sender, EventArgs e)
{
if (OrderContainer.ActualWidth > 0)
{
OrderWidth = this.ActualWidth / ChefmateController.Instance.PageColumns;
HorizontalScale = this.ActualWidth / (ChefmateController.Instance.PageColumns * OrderWidth);
}
_maxHeight = OrderContainer.ActualHeight;
ParentScroller.Width = this.ActualWidth;
OrderContainer.MinWidth = this.ActualWidth;
OrderContainer.Focus();
}
//把已有的菜单从数据库中加载出来
private void LoadExistOrder()
{
addOrders = OrderInfoConnector.GetOrdersByTId(TId);
foreach (AddOrderTmp addOrder in addOrders)
{
OrderContainer orderContainer = new OrderContainer(addOrder);
orderContainer.CancelButton.Click += DeleteThisOrderItem;
ListBoxItem item = new ListBoxItem();
item.Content = orderContainer;
OrderList.Items.Add(item);
}
CountPriceSummary();
}
private void MainWindow_PreviewKeyUp(object sender, KeyEventArgs e)
{
this.Focus();
if (ChefmateController.Instance.CurrentSettings.KeypadOperation == KeypadOperation.BumpByLocation)
{
BumpByLoacation(e.Key);
}
else
{
BumpByChitTableNumber(e.Key);
}
OrderContainer.Focus();
}
/* The callback used by Request's Confirm order functions to update
* the orderCon's confirm status in the associated row, based on the
* http code
*/
private void UpdateConfirmStatusUI(OrderContainer orderCon, HttpStatusCode code)
{
int codeNum = (int)code;
if (codeNum >= 200 && codeNum <= 299)
{
orderCon.ConfirmStatus = string.Concat("Confirmed (", ((int)code), ")");
}
else
{
orderCon.ConfirmStatus = string.Concat("Failed (", ((int)code), ")");
}
dataGridViewOrderList.Refresh();
}
private void Recall(object sender, RoutedEventArgs e)
{
RecallOrderView recallOrderView = new RecallOrderView
{
ShowInTaskbar = false
};
recallOrderView.ShowDialog();
if (recallOrderView.ModalResult && recallOrderView.SelectedOrder != null)
{
ChefmateController.Instance.AddRecallOrder(recallOrderView.SelectedOrder);
}
OrderContainer.Focus();
}
static void Main(string[] args)
{
OrderContainer <Order> container = new OrderContainer <Order>();
//Sort By Instrument
SortByInstrument <Order> sortInst = new SortByInstrument <Order>();
container.SortOrder <SortByInstrument <Order> >(sortInst);
//Sort By Order ID
SortByOrderID <Order> sortID = new SortByOrderID <Order>();
container.SortOrder <SortByOrderID <Order> >(sortID);
}
/* If the orderCon's orderNum already exists in the table, we add the orderCon to the list, else
* we insert a new entry with the new orderCon inserted into the entry's list
*/
public void InsertToOrderNumTable(OrderContainer orderCon)
{
List <OrderContainer> orderConList;
if (OrderTableByOrdNum.TryGetValue(orderCon.Order.OrderNumber, out orderConList))
{
orderConList.Add(orderCon);
}
else
{
orderConList = new List <OrderContainer>();
orderConList.Add(orderCon);
OrderTableByOrdNum.Add(orderCon.Order.OrderNumber, orderConList); //Insert the entry into the table for tracking grubhub cancelled orders
}
}
public void LoadOrders()
{
mainScrollView.Controls.Clear();
OrderContainer obj; //347 hieght
int x = 5;
int y = 1;
foreach (var item in OrderStore.GetUnCompletedOrders())
{
obj = new OrderContainer(item);
obj.Location = new Point(x, y);
x += 349;
mainScrollView.Controls.Add(obj);
}
}
static void Main(string[] args)
{
//Generic type instantiation using reference type
OrderContainer <OrderObj> orderObjContainer = new OrderContainer <OrderObj>(10);
//Add and retrieve reference type order
orderObjContainer.AddOrder(new OrderObj());
OrderObj orderObj = orderObjContainer.GetOrder(0);
//Generic type instantiation using value type
OrderContainer <OrderStruct> orderStructContainer = new OrderContainer <OrderStruct>(10);
//Add and retrieve value type order
orderStructContainer.AddOrder(new OrderStruct());
OrderStruct orderStruct = orderStructContainer.GetOrder(0);
}
static void Main(string[] args)
{
//create order container to store reference type orders
OrderContainer orderObjContainer = new OrderContainer(10);
//Adding orders of reference type
orderObjContainer.AddOrder(new OrderObj());
//Cast Operation
OrderObj orderObj = orderObjContainer.GetOrder(0) as OrderObj;
//create order container to store value type orders
OrderContainer orderStructContainer = new OrderContainer(10);
//Adding orders of value type
//Boxing Cost
orderStructContainer.AddOrder(new OrderStruct());
//Unboxing Cost
object orderStruct = orderStructContainer.GetOrder(0);
}
private void OnRightReleaseSetDestination()
{
if (GameManager.Instance.IM.IsMouseButtonPressed[GameManager.Instance.IM.RMB])
{
var ray = GameManager.Instance.currentMainCamera.GetComponentsInChildren <Camera>()[0].ScreenPointToRay(GameManager.Instance.IM.MousePosition);
RaycastHit hit = new RaycastHit();
Physics.Raycast(ray, out hit, Mathf.Infinity);
if (hit.collider != null)
{
okayEndpos = true;
endpos = hit.point;
}
else
{
okayEndpos = false;
}
}
if (okayEndpos && GameManager.Instance.IM.IsMouseButtonReleased[GameManager.Instance.IM.RMB])
{
bool add = GameManager.Instance.IM.IsKeyHeld[GameManager.Instance.IM.LShift_Key];
Vector3 startpos = transform.position;
if (add && currentPath.ActualPathExists())
{
startpos = currentPath.LastActualWaypoint;
}
//AskPathTo(startpos, endpos, add, okayLookAt, toLookAt);
OrderContainer oc = new OrderContainer(typeof(MovementOrder), null, new List <OrderReceiver>()
{
GetComponentInParent <OrderReceiver>()
},
new List <object>()
{
endpos, add, okayLookAt, toLookAt
}, -1);
GameManager.Instance.currentMainHandler.orderHandler.DispatchOrderContainerToReceivers(oc);
okayEndpos = false;
}
}
/* Initializes the callback function and calls the appropriate
* function to confirm the order
*/
private void ConfirmOrder(OrderContainer orderCon)
{
var cb = new Requests.ConfirmOrderCallBack(UpdateConfirmStatusUI);
switch (orderCon.Service)
{
case "DoorDash":
Requests.ConfirmDoorDashOrder(orderCon, cb);
break;
case "GrubHub":
Requests.ConfirmGrubHubOrder(orderCon, cb);
break;
default:
Debug.WriteLine("Unhandled confirm for service: " + orderCon.Service);
break;
}
}
private void Setting(object sender, RoutedEventArgs e)
{
var displayType = ChefmateController.Instance.CurrentSettings.GroupType;
var settingView = new SettingView {
ShowInTaskbar = false, Topmost = true
};
settingView.ShowDialog();
IsRecallEnabled = ChefmateController.Instance.CurrentSettings.TerminalType == TerminalType.Kitchen;
Properties.Settings.Default.DatabasePath = ChefmateController.Instance.CurrentSettings.DbPath;
Properties.Settings.Default.DatabaseAddress = ChefmateController.Instance.CurrentSettings.DbIpAddress;
Properties.Settings.Default.Save();
ChefmateController.Instance.SaveSettings();
SetFont();
if (displayType != ChefmateController.Instance.CurrentSettings.GroupType)
{
RedrawOrders();
}
OrderContainer.Focus();
}
public async Task <JsonResult> RegisteredOrder(string OrdersStringJSON)
{
var orderContainer = new OrderContainer {
DateTime = DateTime.Now, IsAccepted = false, NotRegisteredUser = false, UserId = User.Identity.GetUserId()
};
try
{
JavaScriptSerializer js = new JavaScriptSerializer();
ICollection <Order> orders = js.Deserialize <ICollection <Order> >(OrdersStringJSON);
orderContainer.Order = orders;
}
catch (Exception)
{
return(Json("Local Storage error!"));
}
await _roomService.AddOrderContainerAsync(orderContainer);
return(Json("Successful order!"));
}
public void ProcessOrder(OrderContainer container)
{
string MailToAddress = container.User_for_Order.Email;
string MailFromAddress = "*****@*****.**";
bool UseSsl = false;
string Username = "******";
string Password = "******";
string ServerName = "gmauil.com";
int ServerPort = 587;
using (var smtpClient = new SmtpClient())
{
smtpClient.EnableSsl = UseSsl;
smtpClient.Host = ServerName;
smtpClient.Port = ServerPort;
smtpClient.UseDefaultCredentials = false;
smtpClient.Credentials = new NetworkCredential(Username, Password);
StringBuilder body = new StringBuilder()
.AppendLine("A new order has been submitted")
.AppendLine(container.order.Date.ToString())
.AppendLine(container.Pokemon_for_Order.Name)
.AppendLine(container.order.Count.ToString());
MailMessage mailMessage = new MailMessage(
MailFromAddress,
MailToAddress,
"New order submitted!",
body.ToString());
try
{
smtpClient.Send(mailMessage);
}
catch
{
}
}
}
public static List <OrderViewModel> AllOrderViewModels()
{
OrderContainer orderContainer = new OrderContainer();
List <OrderViewModel> orderViews = new List <OrderViewModel>();
foreach (Order order in orderContainer.GetAll())
{
OrderViewModel orderView = new OrderViewModel()
{
id = order.id,
totaalPrijs = order.TotaalPrijs(),
betaalStatus = order.betaald ? "betaald" : "Nog te betalen",
klantId = order.klantId,
date = order.date,
};
if (order.klantId.HasValue)
{
orderView.klantNaam = order.GetKlant().naam;
}
orderViews.Add(orderView);
}
return(orderViews);
}
public async Task <ActionResult> NotRegisteredOrder(NotRegisteredOrderViewModel model)
{
if (!ModelState.IsValid)
{
@ViewBag.OrderContainer = model.OrdersStringJSON;
return(View());
}
if (model.OrdersStringJSON == null)
{
ModelState.AddModelError("", "Error, empty Local Storage!");
return(View(model));
}
else
{
var orderContainer = new OrderContainer {
DateTime = DateTime.Now, IsAccepted = false, NotRegisteredUser = true, Phone = model.Phone
};
try
{
JavaScriptSerializer js = new JavaScriptSerializer();
ICollection <Order> orders = js.Deserialize <ICollection <Order> >(model.OrdersStringJSON);
orderContainer.Order = orders;
}
catch (Exception)
{
ModelState.AddModelError("", "Local Storage error!");
return(View(model));
}
await _roomService.AddOrderContainerAsync(orderContainer);
return(RedirectToAction("Index"));
}
}
/* Updates the fields of Order Details */
private void UpdateOrderDetailsUI(OrderContainer orderCon)
{
Order order = orderCon.Order;
nameTextBox.Text = order.CustomerName;
contactNumTextBox.Text = order.ContactNumber;
orderNumTextBox.Text = order.OrderNumber;
orderSizeTextBox.Text = order.OrderSize.ToString();
if (order.NumOfDrinks > 0 && order.NumOfSnacks == 0)
{
orderSizeTextBox.Text += " (all Drinks)";
}
else if (order.NumOfSnacks > 0 && order.NumOfDrinks == 0)
{
orderSizeTextBox.Text += " (all Snacks)";
}
else if (order.NumOfDrinks > 0 && order.NumOfSnacks > 0)
{
orderSizeTextBox.Text += " (" + order.NumOfDrinks + " Drinks, " + order.NumOfSnacks + " Snacks)";
}
messageIdTextBox.Text = order.MessageId;
}
private void SendLetter(OrderContainer container)
{
orderProcessor.ProcessOrder(container);
}
