public GroupedOrderTagViewModel(Order selectedItem, IGrouping<string, OrderTagGroup> orderTagGroups)
 {
     Name = orderTagGroups.Key;
     OrderTags = orderTagGroups.Select(x => new GroupedOrderTagButtonViewModel(selectedItem, x)).ToList();
     ColumnCount = orderTagGroups.First().ColumnCount;
     ButtonHeight = orderTagGroups.First().ButtonHeight;
 }

 public OrderViewModel(Order model)
 {
     _model = model;
     ResetSelectedQuantity();
     ItemSelectedCommand = new DelegateCommand<OrderViewModel>(OnItemSelected);
     UpdateItemColor();
 }

 public OrderViewModel(Order model, IAutomationService automationService)
 {
     _model = model;
     _automationService = automationService;
     ResetSelectedQuantity();
     ItemSelectedCommand = new DelegateCommand<OrderViewModel>(OnItemSelected);
     UpdateItemColor();
 }

 private static bool OrderStatesEqual(Order order1, Order order2)
 {
     var order1OrderStateValues = order1.GetOrderStateValues().ToList();
     var order2OrderStateValues = order2.GetOrderStateValues().ToList();
     if (!order1OrderStateValues.Any() && !order2OrderStateValues.Any()) return true;
     if (order1OrderStateValues.Count() != order2OrderStateValues.Count()) return false;
     return order1OrderStateValues.All(ps => order2OrderStateValues.Any(cs => cs.Equals(ps)));
 }

 public OrderViewModel(Order model, TicketTemplate ticketTemplate, IAutomationService ruleService)
 {
     _model = model;
     _ticketTemplate = ticketTemplate;
     _automationService = ruleService;
     ResetSelectedQuantity();
     ItemSelectedCommand = new DelegateCommand<OrderViewModel>(OnItemSelected);
     UpdateItemColor();
 }

 private static decimal GetPrice(Order order, decimal serviceAmount, decimal sum, decimal exchangeRate, bool taxIncluded)
 {
     var result = order.GetPrice();
     var tax = taxIncluded ? 0 : order.GetTaxAmount(false, sum, serviceAmount);
     if (serviceAmount != 0 && sum != 0) result += (result * serviceAmount) / sum;
     result += tax;
     result = result / exchangeRate;
     return result;
 }

 public OrderViewModel(Order model, ICacheService cacheService, IApplicationState applicationState)
 {
     _model = model;
     _cacheService = cacheService;
     _applicationState = applicationState;
     ResetSelectedQuantity();
     ItemSelectedCommand = new DelegateCommand<OrderViewModel>(OnItemSelected);
     UpdateItemColor();
 }

 public void Update(Order order)
 {
     StopTimer = false;
     SelectedOrder = order;
     RaisePropertyChanged(() => Start);
     RaisePropertyChanged(() => End);
     RaisePropertyChanged(() => Duration);
     RaisePropertyChanged(() => Price);
     RaisePropertyChanged(() => Value);
 }

 private void UpdateSelector(Order order, decimal serviceAmount, decimal sum, bool taxIncluded)
 {
     var selector = Selectors.FirstOrDefault(x => x.Key == GetKey(order));
     if (selector == null)
     {
         selector = new Selector { Key = GetKey(order), Description = order.MenuItemName + order.GetPortionDesc() };
         Selectors.Add(selector);
     }
     selector.Quantity += order.Quantity;
     selector.Price = GetPrice(order, serviceAmount, sum, ExchangeRate, taxIncluded);
 }

 public static bool CanMergeOrders(Order order1, Order order2)
 {
     if (order1.Quantity != order2.Quantity) return false;
     if (order1.Price != order2.Price) return false;
     if (order1.MenuItemId != order2.MenuItemId) return false;
     if (order1.PortionName != order2.PortionName) return false;
     if (order1.CalculatePrice != order2.CalculatePrice) return false;
     if (order1.IncreaseInventory != order2.IncreaseInventory) return false;
     if (order1.DecreaseInventory != order2.DecreaseInventory) return false;
     if (order1.OrderTagValues.Count > 0 || order2.OrderTagValues.Count > 0) return false;
     if (!OrderStatesEqual(order1, order2)) return false;
     return true;
 }

 public static decimal CalculateOrderTotal(Ticket ticket, Order order)
 {
     var discount = ticket.GetPreTaxServicesTotal();
     if (discount != 0)
     {
         var tsum = ticket.GetPlainSum();
         var rate = tsum > 0 ? (discount * 100) / tsum : 100;
         var tiTotal = order.GetTotal();
         var itemDiscount = (tiTotal * rate) / 100;
         return tiTotal + itemDiscount;
     }
     return order.GetTotal();
 }

        private void ExecuteAutomationCommand(Ticket selectedTicket, Order order, string automationCommand, string automationCommandValue)
        {
            if (string.IsNullOrEmpty(automationCommand)) return;

            if (string.IsNullOrEmpty(automationCommandValue))
            {
                var ac = _cacheService.GetAutomationCommandByName(automationCommand);
                if (ac != null)
                {
                    if (!string.IsNullOrEmpty(ac.Values))
                    {
                        ac.PublishEvent(EventTopicNames.SelectAutomationCommandValue);
                        return;
                    }
                }
            }

            _applicationState.NotifyEvent(RuleEventNames.AutomationCommandExecuted, new
            {
                Ticket = selectedTicket,
                Order = order,
                AutomationCommandName = automationCommand,
                Value = automationCommandValue ?? ""
            });
        }

 private OrderViewModel Add(Order ti)
 {
     var result = new OrderViewModel(ti);
     Orders.Add(result);
     return result;
 }

 public void RemoveOrder(Order order)
 {
     var transactionId = order.AccountTransactionTypeId;
     Orders.Remove(order);
     if (Orders.All(x => x.AccountTransactionTypeId != transactionId))
     {
         TransactionDocument.AccountTransactions.Where(x => x.AccountTransactionTypeId == transactionId)
                .ToList().ForEach(x => TransactionDocument.AccountTransactions.Remove(x));
     }
 }

 public Order CloneOrder(Order item)
 {
     Debug.Assert(_orders.Contains(item));
     var result = ObjectCloner.Clone(item);
     result.CreatedDateTime = DateTime.Now;
     result.Quantity = 0;
     _orders.Add(result);
     return result;
 }

        public Order AddOrder(AccountTransactionType template, string userName, MenuItem menuItem, MenuItemPortion portion, string priceTag, ProductTimer timer)
        {
            Locked = false;
            var order = new Order();
            order.UpdateMenuItem(userName, menuItem, portion, priceTag, 1);
            order.AccountTransactionTypeId = template.Id;

            TransactionDocument.AddSingletonTransaction(template.Id, template, AccountTypeId, AccountId);

            if (menuItem.TaxTemplate != null)
            {
                TransactionDocument.AddSingletonTransaction(order.TaxTempleteAccountTransactionTypeId,
                                                               menuItem.TaxTemplate.AccountTransactionType,
                                                               AccountTypeId, AccountId);
            }

            order.UpdateProductTimer(timer);
            Orders.Add(order);
            return order;
        }

 public Order ExtractSelectedOrder(Order order)
 {
     if (order.SelectedQuantity > 0 && order.SelectedQuantity < order.Quantity)
     {
         return FixOrder(order);
     }
     return order;
 }

 private void UpdateOrderTag(Ticket ticket, Order order, string orderTagGroup, string orderTag)
 {
     var ot = string.IsNullOrEmpty(orderTagGroup)
         ? _cacheService.GetOrderTagGroupByOrderTagName(orderTag)
         : _cacheService.GetOrderTagGroupByName(orderTagGroup);
     if (ot != null)
     {
         var otn = ot.OrderTags.First(x => x.Name == orderTag);
         _ticketService.TagOrders(ticket, new List<Order> { order }, ot, otn, "");
     }
 }

 public decimal GetTaxExcludedSum(Order order)
 {
     var plainSum = order.GetTotal();
     var services = CalculateServices(Calculations.Where(x => !x.IncludeTax), plainSum);
     var tax = TaxIncluded ? order.GetTotalTaxAmount(TaxIncluded, plainSum, services) : 0;
     return plainSum - tax;
 }

 public decimal GetTaxExcludedSum(Order order)
 {
     var tax = TaxIncluded ? order.GetTotalTaxAmount(TaxIncluded, GetPlainSum(), GetPreTaxServicesTotal()) : 0;
     return order.GetTotal() - tax;
 }