예제 #1
0
        //Command Execution for Order Clicked in KOTMainMenuPage
        public void ExecuteOrderCommand(M.MenuItem obj)
        {
            try
            {
                if (obj.SetQuantity == 0)
                {
                    DependencyService.Get <IMessage>().ShortAlert("Enter Quantity to Order");
                    return;
                }
                else
                {
                    var selected = SelectedItemsList.ToList().Find(x => x.MCODE == obj.MCODE);

                    var item    = OrderItemsList.ToList().Find(x => ((x.MCODE == obj.MCODE) && (x.SNO == 0)));
                    var KOTItem = M.MenuItem.MenuItemsToKOTProd(obj);

                    KOTItem.Quantity = (double)obj.SetQuantity;
                    OrderItemsList.Add(KOTItem);
                    DependencyService.Get <IMessage>().ShortAlert("Item added to Order List");

                    selected.SetQuantity = 0;

                    SelectedItemCount(obj);

                    //OrderItemsList = new ObservableCollection<KOTProd>(OrderItemsList);
                    //OrderItemsList.OrderBy(x => x.SNO);
                    DecreaseItemCount();
                }
            }catch (Exception ex)
            {
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }
예제 #2
0
        //Function for viewing the change in KOTMainMenuPage
        public void SelectedItemCount(M.MenuItem obj)
        {
            try
            {
                var     selected = SelectedItemsList.ToList().Find(x => x.MCODE == obj.MCODE);
                var     items    = OrderItemsList.Where(x => x.MCODE == selected.MCODE).ToList();
                decimal count    = 0;
                foreach (var i in items)
                {
                    count = count + (decimal)i.Quantity;
                }
                selected.QUANTITY = count;

                decimal setCount = 0;
                var     newItems = items.Where(x => x.SNO == 0).ToList();
                if (newItems != null)
                {
                    foreach (var i in newItems)
                    {
                        setCount = setCount + (decimal)i.Quantity;
                    }
                    selected.SetQuantity = setCount;
                }
            }
            catch (Exception ex)
            {
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }
예제 #3
0
        public void ExecuteDecreaseMenuItemCommand(M.MenuItem menuItem)
        {
            if (menuItem.QUANTITY < 1)
            {
                DependencyService.Get <IMessage>().ShortAlert("Cannot decrease");
                return;
            }

            var items = OrderItemsList.ToList().Where(x => (x.MCODE == menuItem.MCODE && x.Quantity > 0));
            var obj   = items.ToList().Find(x => x.SNO == 0);

            if (obj == null)
            {
                DependencyService.Get <IMessage>().ShortAlert("Cannot decrease already Ordered Items from here");
                return;
                //decimal count = 0;
                //foreach (var item in items)
                //{
                //    count += (decimal)item.Quantity;
                //}
                //if (count > 1)
                //{
                //    obj = items.ToList().Find(x => (x.Quantity-x.DecQuantity) > 1);
                //}
                //else
                //{
                //    DependencyService.Get<IMessage>().ShortAlert("Cannot decrease");
                //    return;
                //}
            }
            ExecuteDecreaseOrderCommand(obj);
        }
예제 #4
0
 //Function for Viewing Items of Selected Group
 private void ViewSelectedMenu(M.MenuItem value)
 {
     try
     {
         SelectedItemsList = new ObservableCollection <M.MenuItem>(MenuItemsList.Where(x => x.PARENT == value.MCODE));
         CountOrderQuantity();
     }
     catch (Exception e)
     {
     }
 }
예제 #5
0
        public void RefreshOrderItemsList()
        {
            try
            {
                //OrderItemsList = new ObservableCollection<KOTProd>(OrderItemsList);
                //OrderItemsList.OrderBy(x => x.SNO);
                DecreaseItemCount();

                if (!string.IsNullOrEmpty(SelectedOrderItem.MCODE))
                {
                    M.MenuItem selectedObj = new M.MenuItem()
                    {
                        MCODE = SelectedOrderItem.MCODE
                    };
                    SelectedItemCount(selectedObj);
                }
                CheckSetQuantity();
            }catch (Exception ex)
            {
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }
예제 #6
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);
            }
        }
예제 #7
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);
            }
        }