Exemple #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);
            }
        }
Exemple #2
0
        public bool AddOrderItem(OrderItem ordItem)
        {
            if (OrderItemsList.Count > 0)
            {
                foreach (var Item in OrderItemsList)
                {
                    if (Item.PizzaItem.ToString().Equals(ordItem.PizzaItem.ToString()))
                    {
                        return(false);
                    }
                }
            }


            OrderItemsList.Add(ordItem);
            OnPropertyChanged("TotalPrice");
            return(true);
        }
        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);
            }
        }
Exemple #4
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);
            }
        }
Exemple #5
0
        public void AddOrderItem(Pizza pizzaItem, int quantity)
        {
            OrderItem ordItm = new OrderItem(pizzaItem, quantity);

            OrderItemsList.Add(ordItm);
        }
Exemple #6
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);
            }
        }
Exemple #7
0
        public async void ExecuteLoginCheckCommand()
        {
            try
            {
                LoadingMessage = "Loading!! Please wait a while";
                IsLoading      = true;
                if (CancelingUser == null)
                {
                    return;
                }
                if (string.IsNullOrEmpty(CancelingUser.UserName))
                {
                    DependencyService.Get <IMessage>().ShortAlert("UserName is empty");
                }
                else if (string.IsNullOrEmpty(CancelingUser.Password))
                {
                    DependencyService.Get <IMessage>().ShortAlert("Password is empty");
                }
                else
                {
                    var res = await LoginConnection.CheckAccessAsync(CancelingUser);

                    if (res.ToLower() == "success")
                    {
                        double qty       = 0;
                        double decreased = 0;
                        double left      = 0;

                        if (SelectedOrderItem.Quantity > 0)
                        {
                            var items = OrderItemsList.Where(x => x.REFSNO == SelectedOrderItem.SNO).ToList();
                            foreach (var i in items)
                            {
                                qty += i.Quantity;
                                if (i.SNO > 0)
                                {
                                    decreased += i.Quantity;
                                }
                            }
                        }

                        var neg = -(SelectedOrderItem.Quantity + qty);
                        if (neg < 0)
                        {
                            var items = OrderItemsList.Where(x => x.REFSNO == SelectedOrderItem.SNO).ToList();
                            foreach (var i in items)
                            {
                                if (i.SNO == 0)
                                {
                                    i.Quantity = -(SelectedOrderItem.Quantity - decreased);
                                    i.Remarks  = CancelingUser.Remarks;
                                    RefreshOrderItemsList();
                                    CancelingUser = new User();
                                    IsCancel      = false;
                                    IsLoading     = false;
                                    return;
                                }
                            }

                            var item    = SubMenuList.Find(x => x.MCODE == SelectedOrderItem.MCODE);
                            var KOTItem = M.MenuItem.MenuItemsToKOTProd(item);
                            KOTItem.Remarks  = CancelingUser.Remarks;
                            KOTItem.Quantity = neg;
                            KOTItem.REFSNO   = SelectedOrderItem.SNO;
                            OrderItemsList.Add(KOTItem);
                        }
                    }
                    else
                    {
                        DependencyService.Get <IMessage>().ShortAlert(res);
                    }
                }
                RefreshOrderItemsList();

                CancelingUser = new User();
                IsCancel      = false;
                IsLoading     = false;
            }catch (Exception ex)
            {
                IsCancel  = false;
                IsLoading = false;
                DependencyService.Get <IMessage>().ShortAlert(ex.Message);
            }
        }