private void UpdateGroupsForTransferredItem(Item newItem, Order destinationOrder)
{
var group = destinationOrder.ServingCourseGroups.FirstOrDefault(s => s.GroupName == newItem.SCourseGroup.GroupName);
if (group != null)
{
newItem.SCourseGroup = group;
}
else
{
newItem.SCourseGroup.Order = destinationOrder;
newItem.SCourseGroup.OrderKey = destinationOrder.OrderKey;
destinationOrder.ServingCourseGroups.Add(newItem.SCourseGroup);
}
group = destinationOrder.CourseGroups.FirstOrDefault(s => s.GroupName == newItem.CourseGroup.GroupName);
if (group != null)
{
newItem.CourseGroup = group;
}
else
{
newItem.CourseGroup.Order = destinationOrder;
newItem.CourseGroup.OrderKey = destinationOrder.OrderKey;
destinationOrder.CourseGroups.Add(newItem.CourseGroup);
}
DbOrderItem.UpdateGroupInformation(newItem);
destinationOrder.Items.Add(newItem);
}
private void TransferOrder(Order order)
{
TransferView transferView = new TransferView();
transferView.Order = order;
transferView.ShowInTaskbar = false;
transferView.ShowDialog();
if (transferView.ModalResul)
{
foreach (var servingCourse in order.DisplayGroups)
{
foreach (var item in servingCourse.Items)
{
DbOrderItem.UpdateItemOnTransfer(item.OrderItemKey, transferView.SelectedTerminal.TerminalId, OrderStatus.Transfered);
}
}
TcpStreamSender transferStream = new TcpStreamSender();
TcpStreamMessage transferMessage = new TcpStreamMessage(transferView.SelectedTerminal.TerminalIpAddress, inMessageType: TcpStreamMessageType.Order);
transferMessage.AddData(order.OrderKey);
var transferSuccessful = transferStream.SendMessage(transferMessage);
if (transferSuccessful)
{
ChefmateController.Instance.AnalyticalData.TotalOrdersCount--;
ChefmateController.Instance.AnalyticalData.CurrentOrdersCount--;
ChefmateController.Instance.AnalyticalData.CurrentItems -= order.Items.Count;
ChefmateController.Instance.RemoveOrder(order);
PublishRedrawEvent();
}
}
}
private void ProcessTransferWhenDestinationNotExist(List <Order> existingOrders, Order newOrder)
{
List <Item> processedItem = new List <Item>();
foreach (var order in existingOrders)
{
foreach (var newItem in newOrder.Items)
{
var existingItem = order.Items.FirstOrDefault(s => s.DisplayAttributes.IsOriginalItem && s.Name == newItem.Name && s.Sides.Count == newItem.Sides.Count &&
s.Options.Count == newItem.Options.Count && !processedItem.Contains(s));
if (existingItem != null)
{
CopyBasiDetails(existingItem, newItem);
processedItem.Add(existingItem);
UpdateTransferProperty(existingItem);
DbOrderItem.UpdateGroupInformation(newItem);
}
}
order.UpdateOrder();
if (order.Items.Count == 0)
{
AnalyticalData.TotalOrdersCount--;
AnalyticalData.CurrentOrdersCount--;
}
//order.FilterOrders(CurrentSettings.GroupType, CurrentSettings.OrderInfoDisplay);
}
newOrder.Items.RemoveAll(s => s.OrderItemKey == 0);
}
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 StartItem(Item item)
{
item.OrderStatus = OrderStatus.Started;
item.SCourseGroup.OrderStatus = OrderStatus.Started;
item.CourseGroup.OrderStatus = OrderStatus.Started;
item.SCourseGroup.Order.OrderStatus = OrderStatus.Started;
DbOrderItem.UpdateOrderItemStatus(item.OrderItemKey, OrderStatus.Started);
}
private void UpdateItemTerminalKey(Item inItem)
{
// set item status to normal
DbOrderItem.UpdateOrderItemStatus(inItem.OrderItemKey, OrderStatus.Normal);
// update terminalKey for the item
DbOrderItem.UpdateOrderItemTerminalKey(inItem.OrderItemKey, _outputTerminal.TerminalId);
}
private void AddNote(Item item)
{
item.Note = KeyboardController.Instance.OpenKeyBoard("Enter Note", item.Note);
if (!string.IsNullOrWhiteSpace(item.Note) && item.Note.Length > 80)
{
item.Note = item.Note.Substring(0, 80);
}
item.IsNoteVisible = true;
DbOrderItem.UpdateOrderItemNote(item.OrderItemKey, item.Note);
}
private void CopyBasiDetails(Item source, Item destination)
{
destination.OrderItemKey = source.OrderItemKey;
destination.OrderStatus = source.OrderStatus;
destination.ArrivalTime = source.ArrivalTime;
//destination.SCourseGroup.CalledAway = source.SCourseGroup.CalledAway;
if (!string.IsNullOrWhiteSpace(source.Note))
{
destination.Note = source.Note;
DbOrderItem.UpdateOrderItemNote(destination.OrderItemKey, destination.Note);
}
}
private void BumpItem(Item inItem, bool isBumbedFromGroup = false)
{
var item = inItem;
if (!isBumbedFromGroup)
{
var order = ChefmateController.Instance.TotalOrders.FirstOrDefault(s => s.OrderKey == inItem.OrderKey);
if (order != null)
{
item = order.Items.FirstOrDefault(s => s.OrderItemKey == inItem.OrderItemKey);
}
}
if (!item.DisplayAttributes.IsOriginalItem)
{
return;
}
ChangeItemStatus(item, OrderStatus.Bumped);
foreach (var side in item.Sides)
{
side.ItemStatus = OrderStatus.Bumped;
}
foreach (var option in item.Options)
{
option.ItemStatus = OrderStatus.Bumped;
}
if (ChefmateController.Instance.CurrentSettings.OutputTime == OutputTime.ItemBumped)
{
OutputItem(item);
}
var group = ChefmateController.Instance.CurrentSettings.GroupType == GroupType.ServingCourse
? item.SCourseGroup
: item.CourseGroup;
if (group.Order.OrderState == OrderState.Complete && ChefmateController.Instance.CurrentSettings.OutputType != OutputType.KitchenTerminal &&
item.OrderItemKey > 0)
{
DbOrderItem.ItemBumped(item.OrderItemKey, DateTime.Now);
}
if (!isBumbedFromGroup && group.Order.OrderStatus == OrderStatus.Bumped)
{
BumpOrder(group.Order);
}
}
public void ChangeOrderStatus(Order order, OrderStatus inOrderStatus)
{
if (order != null)
{
// Set the orders status
order.OrderStatus = inOrderStatus;
foreach (Group group in order.DisplayGroups)
{
foreach (Item item in group.Items)
{
DbOrderItem.UpdateOrderItemStatus(item.OrderItemKey, inOrderStatus);
}
}
}
}
public void ChangeItemStatus(Item item, OrderStatus inStatus)
{
if (inStatus != OrderStatus.Canceled)
{
item.OrderStatus = inStatus;
if (item.OrderItemKey > 0)
{
DbOrderItem.UpdateOrderItemStatus(item.OrderItemKey, inStatus);
}
var group = ChefmateController.Instance.CurrentSettings.GroupType == GroupType.ServingCourse ? item.SCourseGroup : item.CourseGroup;
if (group != null)
{
CheckStatus(group);
}
}
}
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);
}
}
public void BumpOrder(Order inOrder)
{
var order = ChefmateController.Instance.TotalOrders.FirstOrDefault(s => s.OrderKey == inOrder.OrderKey);
foreach (var group in order.DisplayGroups)
{
if (group.OrderStatus != OrderStatus.Bumped && group.OrderStatus != OrderStatus.Canceled)
{
BumpGroup(group, true);
}
}
if (ChefmateController.Instance.CurrentSettings.OutputTerminal <= 0)
{
foreach (var item in order.Items)
{
if (item.OrderItemKey > 0)
{
DbOrderItem.UpdateOrderItemTerminalKey(item.OrderItemKey, 0);
}
}
}
if (ChefmateController.Instance.CurrentSettings.OutputTime == OutputTime.OrderBumped)
{
OutputOrder(order);
}
if (order.OrderState == OrderState.Complete || order.OrderState == OrderState.Runner)
{
ChefmateController.Instance.AnalyticalData.CurrentItems -= order.Items.Count;
ChefmateController.Instance.AnalyticalData.CurrentOrdersCount--;
var currentOrderMakeTime = DateTime.Now.Subtract(order.ArrivalTime);
ChefmateController.Instance.AnalyticalData.TotalMakeTime =
new TimeSpan(ChefmateController.Instance.AnalyticalData.TotalMakeTime.Ticks +
currentOrderMakeTime.Ticks);
}
ChefmateController.Instance.RemoveOrder(order);
if (order.OrderKey > 0)
{
DbOrder.OrderBumped(order.OrderKey, DateTime.Now);
}
}
