Esempio n. 1
0
        public static async Task DeleteOrder()
        {
            try
            {
                using (RawMaterialOrderBL RawMaterialorderBL = new RawMaterialOrderBL())
                {
                    //Read Sl.No
                    Write("Order #: ");
                    bool isNumberValid = int.TryParse(ReadLine(), out int serial);
                    if (isNumberValid)
                    {
                        serial--;
                        List <RawMaterialOrder> RawMaterialorders = await RawMaterialorderBL.GetAllRawMaterialOrdersBL();

                        if (serial <= RawMaterialorders.Count - 1)
                        {
                            //Confirmation
                            RawMaterialOrder RawMaterialorder = RawMaterialorders[serial];
                            Write("Are you sure? (Y/N): ");
                            string confirmation = ReadLine();

                            if (confirmation.Equals("Y", StringComparison.OrdinalIgnoreCase))
                            {
                                //Invoke DeleteSupplierBL method to delete
                                bool isDeleted = await RawMaterialorderBL.DeleteRawMaterialOrderBL(RawMaterialorder.RawMaterialOrderID);

                                if (isDeleted)
                                {
                                    WriteLine("Order Deleted");
                                }
                                RawMaterialOrderDetailBL      RawMaterialorderDetailBL = new RawMaterialOrderDetailBL();
                                List <RawMaterialOrderDetail> detailsList = await RawMaterialorderDetailBL.GetAllRawMaterialOrderDetailsBL();

                                foreach (RawMaterialOrderDetail item in detailsList)
                                {
                                    if (item.RawMaterialOrderID == RawMaterialorder.RawMaterialOrderID)
                                    {
                                        await RawMaterialorderDetailBL.DeleteRawMaterialOrderDetailBL(item.RawMaterialOrderDetailID);
                                    }
                                }
                            }
                        }
                        else
                        {
                            WriteLine($"Invalid Order #.\nPlease enter a number between 1 to {RawMaterialorders.Count}");
                        }
                    }
                    else
                    {
                        WriteLine($"Invalid number.");
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionLogger.LogException(ex);
                WriteLine(ex.Message);
            }
        }
Esempio n. 2
0
        public static async Task PlaceOrder()
        {
            try
            {
                string                    choice1 = "N";
                List <RawMaterial>        selectedRawMaterials     = new List <RawMaterial>();
                List <double>             quantitylist             = new List <double>();
                RawMaterialOrder          RawMaterialorder         = new RawMaterialOrder();
                IRawMaterialOrderBL       RawMaterialorderBL       = new RawMaterialOrderBL();
                ISupplierBL               SupplierBL               = new SupplierBL();
                Supplier                  Supplier                 = new Supplier();
                RawMaterial               RawMaterial              = new RawMaterial();
                RawMaterialBL             rawMaterialBL            = new RawMaterialBL();
                IRawMaterialOrderDetailBL RawMaterialorderDetailBL = new RawMaterialOrderDetailBL();
                Supplier = await SupplierBL.GetSupplierByEmailBL(CommonData.CurrentUser.Email);

                List <RawMaterial> RawMaterialList = new List <RawMaterial>();


                RawMaterialList = await rawMaterialBL.GetAllRawMaterialsBL();

                foreach (RawMaterial item in RawMaterialList)
                {
                    WriteLine(item.RawMaterialName + "  " + item.RawMaterialCode);
                }
                do
                {
                    WriteLine("Enter the code of the RawMaterial ");
                    string      code        = ReadLine();
                    RawMaterial rawMaterial = await rawMaterialBL.GetRawMaterialByRawMaterialCodeBL("code");

                    if (rawMaterial != null)


                    {
                        WriteLine("Enter the Quantity of the RawMaterial ");
                        RawMaterialorder.RawMaterialTotalQuantity = double.Parse(ReadLine());
                    }
                    else
                    {
                        WriteLine("wrong raw material code");
                    }

                    // RawMaterial rawMaterial1 = await rawMaterialBL.GetRawMaterialByRawMaterialCodeBL(code);
                    selectedRawMaterials.Add(rawMaterial);

                    double RawMaterialorderTotalPrice = rawMaterial.RawMaterialPrice * RawMaterialorder.RawMaterialTotalQuantity;
                    Console.WriteLine("Do you want to add more RawMaterials? Enter  Y/N");
                    choice1 = Console.ReadLine();
                } while (choice1 == "Y");

                int    j = 0;
                double totalorderprice = 0.00;
                double totalquantity   = 0.0;

                foreach (RawMaterial item in selectedRawMaterials)
                {
                    totalorderprice += item.RawMaterialPrice * quantitylist[j];
                    totalquantity   += quantitylist[j];
                    j++;
                }
                Console.WriteLine("Total price of the order" + totalorderprice);
                Console.WriteLine("do you want to place the order? \n Enter 1 for yes 0 for no ");
                int  m = int.Parse(Console.ReadLine());
                Guid orderID;
                if (m == 1)
                {
                    SupplierBL      supplierBL = new SupplierBL();
                    List <Supplier> list1      = await supplierBL.GetAllSuppliersBL();


                    RawMaterialorder.RawMaterialTotalPrice = totalorderprice;

                    RawMaterialorder.SupplierID =


                        RawMaterialorder.RawMaterialTotalQuantity = totalquantity;
                    orderID = await RawMaterialorderBL.AddRawMaterialOrderBL(RawMaterialorder);

                    for (int i = 0; i < selectedRawMaterials.Count; i++)

                    {
                        RawMaterialOrderDetail RawMaterialorderdetail = new RawMaterialOrderDetail();
                        RawMaterialorderdetail.RawMaterialOrderID = orderID;
                        RawMaterial = await rawMaterialBL.GetRawMaterialByRawMaterialCodeBL(selectedRawMaterials[i].RawMaterialCode);

                        RawMaterialorderdetail.RawMaterialID         = RawMaterial.RawMaterialID;
                        RawMaterialorderdetail.RawMaterialQuantity   = quantitylist[i];
                        RawMaterialorderdetail.RawMaterialUnitPrice  = RawMaterial.RawMaterialPrice;
                        RawMaterialorderdetail.RawMaterialTotalPrice = quantitylist[i] * RawMaterial.RawMaterialPrice;

                        await RawMaterialorderDetailBL.AddRawMaterialOrderDetailBL(RawMaterialorderdetail);
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionLogger.LogException(ex);
                WriteLine(ex.Message);
            }
        }