private void AddTransferOrder(Order order)
{
order.FilterOrders(CurrentSettings.GroupType, CurrentSettings.OrderInfoDisplay);
List <Order> sourceOrders = TotalOrders.Where(s => s.TableTabName == order.SourceTableName).ToList();
order.DisplayAttributes.SourceTabTableText = order.SourceTableName;
var destinationOrders = TotalOrders.FirstOrDefault(s => s.TableTabName == order.TableTabName);
if (destinationOrders != null)
{
ProcessTransferWhenDestinationExist(sourceOrders, order, destinationOrders);
destinationOrders.DisplayAttributes.SourceTabTableText = order.DisplayAttributes.SourceTabTableText;
}
else
{
order.OrderState = OrderState.Complete;
DbOrder.AddOrder(order, CurrenTerminal.TerminalId, false);
ProcessTransferWhenDestinationNotExist(sourceOrders, order);
TotalOrders.Add(order);
AnalyticalData.TotalOrdersCount++;
AnalyticalData.CurrentOrdersCount++;
}
if (CurrentSettings.ConfirmOnTransfer)
{
ShowMessageBox("Order Transferred", order.SourceTableName + " is transferred to " + order.TableTabName);
}
TotalOrders.RemoveAll(s => s.Items.Count == 0);
PublishRedrawEvent();
}
private void AddCancelOrder(Order order)
{
List <Item> processedItem = new List <Item>();
List <Item> processedExistingItem = new List <Item>();
List <Order> sourceOrders = TotalOrders.Where(s => s.TableTabName == order.TableTabName).ToList();
foreach (var sourceOrder in sourceOrders)
{
foreach (var newItem in order.Items)
{
var existingItem = sourceOrder.Items.FirstOrDefault(s => s.OrderItemPosKey == newItem.OrderItemPosKey && !processedItem.Contains(s) &&
!processedExistingItem.Contains(s));
if (existingItem != null)
{
processedExistingItem.Add(existingItem);
processedItem.Add(newItem);
if (!existingItem.DisplayAttributes.IsOriginalItem)
{
UpdateTransferProperty(existingItem);
}
existingItem.OrderStatus = OrderStatus.Canceled;
DbOrderItem.ItemBumped(existingItem.OrderItemKey, DateTime.Now);
DbOrderItem.UpdateOrderItemStatus(existingItem.OrderItemKey, OrderStatus.Canceled);
}
}
}
order.Items.RemoveAll(s => processedItem.Contains(s));
if (order.Items.Count > 0)
{
AddCreditOrder(order);
}
}
private void AddCreditOrder(Order order)
{
TotalOrders.Add(order);
if (CurrentSettings.ConfirmOnRefund)
{
ShowMessageBox("Refund Order", "A Refund Order has come in.");
}
PublishAddOrder(order);
}
private void AddRunnerOrder(Order inOrder)
{
var order = TotalOrders.FirstOrDefault(s => s.OrderKey == inOrder.OrderKey);
if (order != null)
{
foreach (var item in inOrder.Items)
{
if (order.Items.FirstOrDefault(s => s.OrderItemKey == item.OrderItemKey) == null)
{
var servigCourseGroup =
order.ServingCourseGroups.FirstOrDefault(
s => s.OrderGroupKey == item.SCourseGroup.OrderGroupKey);
if (servigCourseGroup != null)
{
item.SCourseGroup = servigCourseGroup;
}
else
{
item.SCourseGroup.Order = order;
order.ServingCourseGroups.Add(item.SCourseGroup);
}
var courseGroup =
order.CourseGroups.FirstOrDefault(
s => s.OrderGroupKey == item.CourseGroup.OrderGroupKey);
if (courseGroup != null)
{
item.CourseGroup = courseGroup;
}
else
{
item.CourseGroup.Order = order;
order.CourseGroups.Add(item.CourseGroup);
}
order.Items.Add(item);
AnalyticalData.CurrentItems++;
}
}
}
else
{
AnalyticalData.TotalOrdersCount++;
AnalyticalData.CurrentOrdersCount++;
inOrder.ServingCourseGroups.ToList().ForEach(s => AnalyticalData.CurrentItems += s.Items.Count);
TotalOrders.Add(inOrder);
}
PublishRedrawEvent();
}
public void LoadAllOrders()
{
try
{
var orders = DatabaseOrderBuilder.Instance.GetAllOrders(CurrenTerminal.TerminalId);
foreach (var order in orders)
{
TotalOrders.Add(order);
}
}
catch (Exception ex)
{
ChefmateLogger.Instance.LogError("ChefmateController.LoadAllOrders", ex.Message);
throw ex;
}
}
public void AddRecallOrder(Order inOrder)
{
lock (_syncRoot)
{
var order = DbOrder.GetOrder(inOrder.OrderKey, 0, true);
AnalyticalData.CurrentOrdersCount++;
AnalyticalData.CurrentItems += order.Items.Count;
TimeSpan recalledOrderMakeTime = order.BumpTime - order.ArrivalTime;
AnalyticalData.TotalMakeTime = new TimeSpan(AnalyticalData.TotalMakeTime.Ticks - recalledOrderMakeTime.Ticks);
foreach (var item in order.Items)
{
DbOrderItem.UpdateOrderItemTerminalKey(item.OrderItemKey, CurrenTerminal.TerminalId);
}
TotalOrders.Add(order);
PublishAddOrder(order);
}
}
private void CallAwayOrder(Order inOrder)
{
var orders = TotalOrders.Where(s => s.TableTabName == inOrder.TableTabName);
foreach (var order in orders)
{
foreach (var group in inOrder.ServingCourseGroups)
{
var existingGroup = order.ServingCourseGroups.FirstOrDefault(s => s.GroupPosKey == group.GroupPosKey);
if (existingGroup != null)
{
existingGroup.CalledAway = true;
DbOrderGroup.CallAwayGroup(existingGroup.OrderGroupKey, true);
}
}
}
}
public static IQueryable <StatisticsViewModel> CustomersStatistics(ApplicationDbContext _context)
{
List <Order> Orders = new List <Order>();
IQueryable <StatisticsViewModel> data =
from Order in _context.Orders
group Order by Order.Customer into TotalOrders
select new StatisticsViewModel
{
Customer = TotalOrders.Key,
TotalOrders = TotalOrders.Count(),
TotalOrderCost = TotalOrders.Sum(t => t.TotalCost),
StatusTypeFullfilled = TotalOrders.Count(e => (int)e.Status == 0),
StatusTypeInProgress = TotalOrders.Count(e => (int)e.Status == 2)
};
return(data);
}
private void LoadAllOrders()
{
try
{
this.Dispatcher.BeginInvoke(new Action(() =>
{
ChefmateController.Instance.LoadAllOrders();
RedrawOrders();
AnalyticalData.TotalOrdersCount += TotalOrders.Count;
AnalyticalData.CurrentOrdersCount += TotalOrders.Count;
TotalOrders.ForEach(s => { AnalyticalData.CurrentItems += s.Items.Count; });
UpdateOrderInfoDisplay();
this.IsEnabled = true;
}));
}
catch (Exception ex)
{
this.IsEnabled = true;
ChefmateLogger.Instance.LogError("LoadAllOrders", ex.Message);
}
}
private void AddCompleteOrder(Order order)
{
if (order.OrderKey == 0)
{
DbOrder.AddOrder(order, CurrenTerminal.TerminalId);
}
if (OutputTime.Immediately == CurrentSettings.OutputTime)
{
OutputController.Instance.OutputOrder(order);
}
else
{
if (order.OrderState == OrderState.Complete || order.OrderState == OrderState.Runner)
{
AnalyticalData.TotalOrdersCount++;
AnalyticalData.CurrentOrdersCount++;
AnalyticalData.CurrentItems += order.Items.Count;
}
TotalOrders.Add(order);
}
}
public void RemoveOrder(Order order)
{
TotalOrders.Remove(order);
}
