public static async Task CancelCustomerOrder()
        {
            IProductBL         productBL     = new ProductBL();
            List <OrderDetail> matchingOrder = new List <OrderDetail>();

            WriteLine("Enter the order number which you want to cancel");
            double orderToBeCancelled = double.Parse(ReadLine());

            WriteLine("Entered Number is: " + orderToBeCancelled);
            try
            {
                using (IOrderBL orderBL = new OrderBL())
                {
                    try
                    {
                        Order order = await orderBL.GetOrderByOrderNumberBL(orderToBeCancelled);

                        using (IOrderDetailBL orderDetailBL = new OrderDetailBL())
                        {
                            matchingOrder = await orderDetailBL.GetOrderDetailsByOrderIDBL(order.OrderId);

                            int a = matchingOrder.Count();
                            WriteLine("No. of Products ordered: " + a);
                        }
                    }
                    catch (Exception)
                    {
                        WriteLine("Invalid OrderId");
                    }
                }
                if (matchingOrder.Count != 0)
                {
                    OrderDetailBL orderDetailBL = new OrderDetailBL();
                    if ((await orderDetailBL.UpdateOrderDeliveredStatusBL(matchingOrder[0].OrderId)))
                    {
                        int serialNo = 0;
                        WriteLine("Products in the order are ");
                        WriteLine("#\t\t ProductID\t\t ProductQuantityOrdered\t\t UnitProductPrice");
                        foreach (OrderDetail orderDetail in matchingOrder)
                        {
                            Product product = await productBL.GetProductByProductIDBL(orderDetail.ProductID);

                            serialNo++;
                            //Console.WriteLine(product.ProductName);
                            WriteLine($"{ serialNo}\t{ orderDetail.ProductID}\t\t{ orderDetail.ProductQuantityOrdered}\t\t{orderDetail.ProductPrice}");
                        }
                        Console.WriteLine("Enter The Product to be Cancelled");
                        int ProductToBeCancelled = int.Parse(Console.ReadLine());
                        if (ProductToBeCancelled <= matchingOrder.Count && ProductToBeCancelled > 0)
                        {
                            Console.WriteLine("Enter The Product Quantity to be Cancelled");
                            int quantityToBeCancelled = int.Parse(Console.ReadLine());
                            if (matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered >= quantityToBeCancelled)
                            {
                                matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered -= quantityToBeCancelled;
                                matchingOrder[ProductToBeCancelled - 1].TotalAmount            -= matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled;
                                Console.WriteLine("Total Refund Amount: " + (matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled));
                                OrderDetailBL orderDetailBL1 = new OrderDetailBL();
                                await orderDetailBL1.UpdateOrderDetailsBL(matchingOrder[ProductToBeCancelled - 1]);

                                Console.WriteLine("Product Cancelled Succesfully");
                            }
                            else
                            {
                                Console.WriteLine("PRODUCT QUANTITY EXCEEDED");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Wrong Input");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Order Can't be cancelled as it is delivered");
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
示例#2
0
        //public static async Task CancelRetailerOrder()
        //{
        //    List<OrderDetail> matchingOrder = new List<OrderDetail>();//list maintains the order details of the order which user wishes to cancel
        //    try
        //    {
        //        using (IRetailerBL retailerBL = new RetailerBL())
        //        {
        //            //gives the current retailer
        //            Retailer retailer = await retailerBL.GetRetailerByEmailBL(CommonData.CurrentUser.Email);
        //            using (IOrderBL orderDAL = new OrderBL())
        //            {
        //                //list of orders ordered by the retailer
        //                List<Order> RetailerOrderList = await orderDAL.GetOrdersByRetailerIDBL(retailer.RetailerID);
        //                Console.WriteLine("Enter the order number which you want to cancel");
        //                int orderToBeCancelled = int.Parse(Console.ReadLine());//user input of order which he has to cancel
        //                foreach (Order order in RetailerOrderList)
        //                {
        //                    using (IOrderDetailBL orderDetailBL = new OrderDetailBL())
        //                    {
        //                        //getting the order details of required order to be cancelled
        //                        List<OrderDetail> RetailerOrderDetails = await orderDetailBL.GetOrderDetailsByOrderIDBL(order.OrderId);
        //                        matchingOrder = RetailerOrderDetails.FindAll(
        //                                   (item) => { return item.OrderSerial == orderToBeCancelled; }
        //                               );
        //                        break;
        //                    }
        //                }

        //                if (matchingOrder.Count != 0)
        //                {
        //                    OrderDetailBL orderDetailBL = new OrderDetailBL();
        //                    //cancel order if order not delivered
        //                    if (!( await orderDetailBL.UpdateOrderDeliveredStatusBL(matchingOrder[0].OrderId)))
        //                    {
        //                        int serial = 0;
        //                        Console.WriteLine("Products in the order are ");
        //                        foreach (OrderDetail orderDetail in matchingOrder)
        //                        {
        //                            //displaying order details with the products ordered
        //                            serial++;
        //                            Console.WriteLine("#\tProductID \t ProductQuantityOrdered");
        //                            Console.WriteLine($"{ serial}\t{ orderDetail.ProductID}\t{ orderDetail.ProductQuantityOrdered}");
        //                        }
        //                        Console.WriteLine("Enter The Product to be Cancelled");
        //                        int ProductToBeCancelled = int.Parse(Console.ReadLine());
        //                        Console.WriteLine("Enter The Product Quantity to be Cancelled");
        //                        int quantityToBeCancelled = int.Parse(Console.ReadLine());
        //                        if (matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered >= quantityToBeCancelled)
        //                        {
        //                            //updating order quantity and revenue
        //                            matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered -= quantityToBeCancelled;
        //                            matchingOrder[ProductToBeCancelled - 1].TotalAmount -= matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled;
        //                            OrderDetailBL orderDetailBL1 = new OrderDetailBL();
        //                            await orderDetailBL1.UpdateOrderDetailsBL(matchingOrder[ProductToBeCancelled - 1]);

        //                            Console.WriteLine("Product Cancelled Succesfully");

        //                        }
        //                        else
        //                        {
        //                            Console.WriteLine("PRODUCT QUANTITY EXCEEDED");
        //                        }
        //                    }
        //                    else
        //                    {
        //                        Console.WriteLine("Order Can't be cancelled as it is delivered");
        //                    }
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception)
        //    {

        //        throw;
        //    }
        //}



        public static async Task CancelRetailerOrder()
        {
            IProductBL         productBL     = new ProductBL();
            List <OrderDetail> matchingOrder = new List <OrderDetail>();//list maintains the order details of the order which user wishes to cancel

            Console.WriteLine("Enter the order number which you want to cancel");
            double orderToBeCancelled = double.Parse(Console.ReadLine());//user input of order which he has to cancel

            Console.WriteLine("Entered Number is: " + orderToBeCancelled);
            try
            {
                using (IOrderBL orderBL = new OrderBL())
                {
                    Order order = await orderBL.GetOrderByOrderNumberBL(orderToBeCancelled);

                    using (IOrderDetailBL orderDetailBL = new OrderDetailBL())
                    {
                        matchingOrder = await orderDetailBL.GetOrderDetailsByOrderIDBL(order.OrderId);

                        int a = matchingOrder.Count();
                        Console.WriteLine(a);
                    }
                }


                if (matchingOrder.Count != 0)
                {
                    OrderDetailBL orderDetailBL = new OrderDetailBL();
                    //cancel order if order not delivered
                    if ((await orderDetailBL.UpdateOrderDeliveredStatusBL(matchingOrder[0].OrderId)))
                    {
                        int serial = 0;

                        Console.WriteLine("Products in the order are ");
                        Console.WriteLine("# \t\t\tProductID \t\t ProductName \t ProductQuantityOrdered");
                        foreach (OrderDetail orderDetail in matchingOrder)
                        {
                            //displaying order details with the products ordered
                            Product product = await productBL.GetProductByProductIDBL(orderDetail.ProductID);

                            serial++;
                            //Console.WriteLine(product.ProductName);
                            Console.WriteLine($"{ serial}\t{ orderDetail.ProductID}\t\t\t{product.ProductName}\t{ orderDetail.ProductQuantityOrdered}");
                        }
                        Console.WriteLine("Enter The Product to be Cancelled");
                        int ProductToBeCancelled = int.Parse(Console.ReadLine());
                        if (ProductToBeCancelled < matchingOrder.Count && ProductToBeCancelled > 0)
                        {
                            Console.WriteLine("Enter The Product Quantity to be Cancelled");
                            int quantityToBeCancelled = int.Parse(Console.ReadLine());
                            if (matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered >= quantityToBeCancelled)
                            {
                                //updating order quantity and revenue
                                matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered -= quantityToBeCancelled;
                                matchingOrder[ProductToBeCancelled - 1].TotalAmount            -= matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled;
                                Console.WriteLine("Total Refund Amount: " + (matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled));
                                OrderDetailBL orderDetailBL1 = new OrderDetailBL();
                                await orderDetailBL1.UpdateOrderDetailsBL(matchingOrder[ProductToBeCancelled - 1]);

                                Console.WriteLine("Product Cancelled Succesfully");
                            }
                            else
                            {
                                Console.WriteLine("PRODUCT QUANTITY EXCEEDED");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Wrong Input");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Order Can't be cancelled as it is delivered");
                    }
                }
                else
                {
                    Console.Write("no id found");
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
示例#3
0
        public static async Task CancelRetailerOrder()
        {
            List <OrderDetail> matchingOrder = new List <OrderDetail>();//list maintains the order details of the order which user wishes to cancel

            try
            {
                using (IRetailerBL retailerBL = new RetailerBL())
                {
                    //gives the current retailer
                    Retailer retailer = await retailerBL.GetRetailerByEmailBL(CommonData.CurrentUser.Email);

                    using (IOrderBL orderDAL = new OrderBL())
                    {
                        //list of orders ordered by the retailer
                        List <Order> RetailerOrderList = await orderDAL.GetOrdersByRetailerIDBL(retailer.RetailerID);

                        Console.WriteLine("Enter the order number which you want to cancel");
                        int orderToBeCancelled = int.Parse(Console.ReadLine());//user input of order which he has to cancel


                        foreach (Order order in RetailerOrderList)
                        {
                            using (IOrderDetailBL orderDetailBL = new OrderDetailBL())
                            {
                                //getting the order details of required order to be cancelled
                                //List<OrderDetail> RetailerOrderDetails
                                matchingOrder = await orderDetailBL.GetOrderDetailsByOrderNumberBL(order.OrderNumber);

                                //matchingOrder = RetailerOrderDetails.FindAll(
                                //           (item) => { return item.OrderNumber == orderToBeCancelled; }
                                //       );
                                //break;
                            }
                        }

                        if (matchingOrder.Count != 0)
                        {
                            OrderDetailBL orderDetailBL = new OrderDetailBL();
                            //cancel order if order not delivered
                            if (!(await orderDetailBL.UpdateOrderDeliveredStatusBL(matchingOrder[0].OrderId)))
                            {
                                int serial = 0;
                                Console.WriteLine("Products in the order are ");
                                foreach (OrderDetail orderDetail in matchingOrder)
                                {
                                    //displaying order details with the products ordered
                                    serial++;
                                    Console.WriteLine("#\tProductID \t ProductQuantityOrdered");
                                    Console.WriteLine($"{ serial}\t{ orderDetail.ProductID}\t{ orderDetail.ProductQuantityOrdered}");
                                }
                                Console.WriteLine("Enter The Product to be Cancelled");
                                int ProductToBeCancelled = int.Parse(Console.ReadLine());
                                Console.WriteLine("Enter The Product Quantity to be Cancelled");
                                int quantityToBeCancelled = int.Parse(Console.ReadLine());
                                if (matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered >= quantityToBeCancelled)
                                {
                                    //updating order quantity and revenue
                                    matchingOrder[ProductToBeCancelled - 1].ProductQuantityOrdered -= quantityToBeCancelled;
                                    matchingOrder[ProductToBeCancelled - 1].TotalAmount            -= matchingOrder[ProductToBeCancelled - 1].ProductPrice * quantityToBeCancelled;
                                    OrderDetailBL orderDetailBL1 = new OrderDetailBL();
                                    await orderDetailBL1.UpdateOrderDetailsBL(matchingOrder[ProductToBeCancelled - 1]);

                                    Console.WriteLine("Product Cancelled Succesfully");
                                }
                                else
                                {
                                    Console.WriteLine("PRODUCT QUANTITY EXCEEDED");
                                }
                            }
                            else
                            {
                                Console.WriteLine("Order Can't be cancelled as it is delivered");
                            }
                        }
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
        }