private void UpdateOrder(KOTProd item)
        {
            var index = OrderItemsList.IndexOf(item);

            OrderItemsList.Remove(item);
            OrderItemsList.Insert(index, item);
        }
示例#2
0
        public void ExecuteSplitOkCommand()
        {
            try
            {
                var sno   = TransferItemsList.FirstOrDefault().SNO;
                var found = OrderItemsList.ToList().Find(x => x.SNO == sno);
                if (found != null)
                {
                    OrderItemsList.Remove(found);
                }

                //var count = OrderItemsList.ToList().MaxBy(x => x.SNO);
                var items = OrderItemsList.Select(i => i.SNO).ToList();
                var count = 0;
                if (items.Count > 0)
                {
                    count = items.Max();
                }

                foreach (var i in TransferItemsList)
                {
                    count++;
                    i.SNO = count;
                }

                foreach (var i in TransferItemsList)
                {
                    var newItem = new KOTProd(i);
                    newItem.Quantity = i.Quantity;
                    OrderItemsList.Add(newItem);
                }
                IsSplit = false;
            }catch (Exception ex)
            {
                IsSplit = false;
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }
示例#3
0
        //Command Execution for Increasing Quantity
        public void ExecuteIncreaseCommand(M.MenuItem obj)
        {
            try
            {
                var selected = SelectedItemsList.ToList().Find(x => x.MCODE == obj.MCODE);
                selected.SetQuantity += 1;
                var item = OrderItemsList.ToList().Find(x => ((x.MCODE == obj.MCODE) && (x.SNO == 0)));

                var KOTItem = M.MenuItem.MenuItemsToKOTProd(obj);
                if (item == null)
                {
                    KOTItem.Quantity = 1;
                    OrderItemsList.Add(KOTItem);
                }
                else
                {
                    item.Quantity += 1;
                    if (item.Quantity > 0)
                    {
                        item.REFSNO = 0;
                    }
                    else if (item.Quantity == 0)
                    {
                        OrderItemsList.Remove(item);
                    }
                }

                SelectedItemCount(obj);

                //OrderItemsList = new List<KOTProd>(OrderItemsList);
                //OrderItemsList.OrderBy(x => x.SNO);
                DecreaseItemCount();
            }
            catch (Exception ex)
            {
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }
示例#4
0
 public void ExecuteCancelCommand(KOTProd obj)
 {
     try
     {
         if (obj.SNO == 0)
         {
             OrderItemsList.Remove(obj);
             var item = SelectedItemsList.ToList().Find(x => x.MCODE == obj.MCODE);
             if (item != null)
             {
                 item.SetQuantity = 0;
             }
             RefreshOrderItemsList();
         }
         else
         {
             if ((obj.Quantity + obj.DecQuantity) == 0)
             {
                 DependencyService.Get <IMessage>().ShortAlert("Order already Cancelled");
                 return;
             }
             if (obj.Quantity < 0)
             {
                 DependencyService.Get <IMessage>().ShortAlert("Cannot Cancel negative order");
                 return;
             }
             SelectedOrderItem = obj;
             IsCancel          = true;
         }
         CountOrderQuantity();
     }
     catch (Exception ex)
     {
         DependencyService.Get <IMessage>().ShortAlert(ex.Message);
     }
 }
示例#5
0
        public void ExecuteDecreaseOrderCommand(KOTProd obj)
        {
            try
            {
                //new KOTProd (SNO = 0 )
                if (obj.SNO == 0)
                {
                    if (obj.Quantity > 1)
                    {
                        var item = OrderItemsList.ToList().Find(x => (x.MCODE == obj.MCODE) && (x.SNO == 0));
                        item.Quantity -= 1;
                        OrderItemsList = new ObservableCollection <KOTProd>(OrderItemsList);
                        OrderItemsList.OrderBy(x => x.SNO);

                        M.MenuItem selectedObj = new M.MenuItem()
                        {
                            MCODE = obj.MCODE
                        };
                        SelectedItemCount(selectedObj);
                    }
                    else if (obj.Quantity == 1)
                    {
                        var item = OrderItemsList.ToList().Find(x => (x.MCODE == obj.MCODE) && (x.SNO == 0));
                        OrderItemsList.Remove(item);
                        M.MenuItem selectedObj = new M.MenuItem()
                        {
                            MCODE = obj.MCODE
                        };
                        SelectedItemCount(selectedObj);
                    }
                    else if (obj.Quantity < 1)
                    {
                        DependencyService.Get <IMessage>().ShortAlert("Cannot decrease");
                    }
                }

                //old saved KOTProd ( SNO > 0 )
                else
                {
                    //if quantity is negative return
                    if (obj.Quantity <= 1 || (obj.Quantity + obj.DecQuantity) <= 1)
                    {
                        DependencyService.Get <IMessage>().ShortAlert("Cannot Decrease. Only one Item left.Click Cancel");
                        return;
                    }

                    var items = OrderItemsList.Where(x => x.MCODE == obj.MCODE).ToList();

                    var    negativeItems = items.Where(x => x.REFSNO == obj.SNO);
                    double qty           = 0;
                    double negQty        = 0;
                    foreach (var i in negativeItems)
                    {
                        negQty += i.Quantity;
                    }

                    var match = items.Find(x => x.REFSNO == obj.SNO && x.SNO == 0);
                    if (match != null)
                    {
                        qty = obj.Quantity + negQty;
                        if (qty > 1)
                        {
                            obj.DecQuantity -= 1;
                            match.Quantity  -= 1;
                        }
                        else if (qty == 1)
                        {
                            SelectedOrderItem = obj;
                            IsCancel          = true;
                        }
                    }
                    else
                    {
                        obj.DecQuantity -= 1;
                        var item    = SubMenuList.Find(x => x.MCODE == obj.MCODE);
                        var KOTItem = M.MenuItem.MenuItemsToKOTProd(item);
                        KOTItem.Quantity = -1;
                        KOTItem.REFSNO   = obj.SNO;
                        OrderItemsList.Add(KOTItem);
                        DependencyService.Get <IMessage>().ShortAlert("Item added to Order List");
                    }

                    RefreshOrderItemsList();
                }
            }
            catch (Exception ex)
            {
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }