public bool DeleteRMOrderDAL(string RMOrderID)//method to delete order { bool RMOrderDeleted = false; try { RawMaterialOrder deleteRMOrder = null; foreach (RawMaterialOrder item in rawmaterialorderList) { if (item.RMOrderID == RMOrderID) { deleteRMOrder = item; } } if (deleteRMOrder != null) { rawmaterialorderList.Remove(deleteRMOrder); RMOrderDeleted = true; } } catch (Exception ex) { throw new InventoryException(ex.Message); } return(RMOrderDeleted); }
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); } }
private static bool ValidateRawMaterialOrder(RawMaterialOrder rawMaterialOrder) { StringBuilder sb = new StringBuilder(); bool validRawMaterial = true; foreach (RawMaterialOrder item in RawMaterialOrderDAL.rawmaterialorderList) { if (item.RMOrderID == rawMaterialOrder.RMOrderID) { validRawMaterial = false; } } Regex regex = new Regex("^[R][O][0-9][0-9][0-9]$"); bool b = regex.IsMatch(rawMaterialOrder.RMOrderID); if (b != true) { validRawMaterial = false; sb.Append(Environment.NewLine + "Invalid RawMaterialID"); } DateTime mfd = Convert.ToDateTime(rawMaterialOrder.RMOrderDate); DateTime now = DateTime.Now; int res = DateTime.Compare(mfd, now); if (res > 0) { validRawMaterial = false; sb.Append(Environment.NewLine + "invalid ManufactureDate"); } Regex regex1 = new Regex("^[S][0-9][0-9][0-9]$"); bool c = regex.IsMatch(rawMaterialOrder.RMOrderID); if (c != true) { validRawMaterial = false; sb.Append(Environment.NewLine + "invalid SupplierID"); } if (rawMaterialOrder.RMOrderPrice < 0.00) { validRawMaterial = false; sb.Append(Environment.NewLine + "price should be greater than 0"); } if (validRawMaterial == false) { throw new Exception(sb.ToString()); } return(validRawMaterial); }
public RawMaterialOrder SearchRawMaterialOrderDAL(int searchRawMaterialOrderID) { RawMaterialOrder searchRawMaterialOrder = null; try { searchRawMaterialOrder = rawMaterialOrderList.Find(item => item.RawMaterialOrderID == searchRawMaterialOrderID); } catch (InventoryException ex) { throw new InventoryException(ex.Message); } return(searchRawMaterialOrder); }
public static List <RawMaterialOrder> rawmaterialorderList = new List <RawMaterialOrder>(); //list the rawmaterial order public bool AddRMOrderDAL(RawMaterialOrder order, List <RawMaterialOrder> orderDetails) //method to add raw material order { bool RMorderAdded = false; try { orderDetails.Add(order); RMorderAdded = true; } catch (Exception ex) { throw new InventoryException(ex.Message); } return(RMorderAdded); }
public static RawMaterialOrder SearchRawMaterialOrderByIDBL(int searchRawMaterialOrderID) { RawMaterialOrder searchRawMaterialOrder = null; try { RawMaterialOrderDAL rawMaterialOrderDAL = new RawMaterialOrderDAL(); searchRawMaterialOrder = rawMaterialOrderDAL.SearchRawMaterialOrderDAL(searchRawMaterialOrderID); } catch (InventoryException ex) { throw ex; } return(searchRawMaterialOrder); }
public bool AddRMOrderDAL(RawMaterialOrder order, List <RawMaterialOrder> orderDetails) { bool RMorderAdded = false; try { orderDetails.Add(order); RMorderAdded = true; } catch (SystemException ex) { throw new Exception(ex.Message); } return(RMorderAdded); }
public bool AddRawMaterialOrderDAL(RawMaterialOrder newRawMaterialOrder) { bool rawMaterialOrderAdded = false; try { rawMaterialOrderList.Add(newRawMaterialOrder); rawMaterialOrderAdded = true; } catch (InventoryException ex) { throw new InventoryException(ex.Message); } return(rawMaterialOrderAdded); }
public override RawMaterialOrder GetRawMaterialOrderByRawMaterialOrderIDDAL(Guid RawMaterialorderID) { RawMaterialOrder matchingRawMaterialOrder = null; try { //Find RawMaterialOrder based on searchRawMaterialOrderID matchingRawMaterialOrder = RawMaterialorderList.Find( (item) => { return(item.RawMaterialOrderID == RawMaterialorderID); } ); } catch (Exception) { throw; } return(matchingRawMaterialOrder); }
public static bool AddRMOrderDL(RawMaterialOrder order, List <RawMaterialOrder> orderDetails) { bool RMorderAdded = false; try { if (ValidateRawMaterialOrder(order)) { RawMaterialOrderDAL rawMaterialorderDAL = new RawMaterialOrderDAL(); RMorderAdded = rawMaterialorderDAL.AddRMOrderDAL(order, orderDetails); } } catch (SystemException ex) { throw new Exception(ex.Message); } return(RMorderAdded); }
public static bool UpdateRMOrderBL(RawMaterialOrder updateorder) { bool orderUpdated = false; try { if (ValidateRawMaterialOrder(updateorder)) { RawMaterialOrderDAL rawMaterialorderDAL = new RawMaterialOrderDAL(); orderUpdated = rawMaterialorderDAL.UpdateRMOrderDAL(updateorder); } } catch (SystemException ex) { throw new Exception(ex.Message); } return(orderUpdated); }
/// <returns>Determinates whether the new systemUser is added.</returns> public override bool AddRawMaterialOrderDAL(RawMaterialOrder newRawMaterialOrder) { bool RawMaterialorderAdded = false; try { newRawMaterialOrder.RawMaterialOrderID = Guid.NewGuid(); newRawMaterialOrder.RawMaterialOrderDate = DateTime.Now; newRawMaterialOrder.LastmodifiedDateTime = DateTime.Now; RawMaterialorderList.Add(newRawMaterialOrder); RawMaterialorderAdded = true; } catch (Exception) { throw; } return(RawMaterialorderAdded); }
public bool DeleteRawMaterialOrderDAL(int deleteRawMaterialOrderID) { bool rawMaterialOrderDeleted = false; try { RawMaterialOrder deleteRawMaterialOrder = null; if (deleteRawMaterialOrder != null) { rawMaterialOrderList.Remove(deleteRawMaterialOrder); rawMaterialOrderDeleted = true; } } catch (InventoryException ex) { throw new InventoryException(ex.Message); } return(rawMaterialOrderDeleted); }
private static bool ValidateRawMaterialOrder(RawMaterialOrder rawMaterialOrder) { StringBuilder sb = new StringBuilder(); bool validRawMaterialOrder = true; if (rawMaterialOrder.RawMaterialOrderID == 0 || rawMaterialOrder.RawMaterialOrderID > 99999) { validRawMaterialOrder = false; sb.Append("\nInvalid Raw Material OrderID"); } if (rawMaterialOrder.TotalAmount <= 0) { validRawMaterialOrder = false; sb.Append("\nInvalid Total"); } if (validRawMaterialOrder == false) { throw new InventoryException(sb.ToString()); } return(validRawMaterialOrder); }
public RawMaterialOrder GetRMOrdersByOrderIDDAL(string OrderID)// search raw materials order by ID { List <RawMaterialOrder> searchRawMaterialOrder = new List <RawMaterialOrder>(); RawMaterialOrder order = null; try { foreach (RawMaterialOrder item in rawmaterialorderList) { if (item.RMOrderID == OrderID) { order = item; } } } catch (Exception ex) { throw new InventoryException(ex.Message); } return(order); }
public bool UpdateRawMaterialOrderDAL(RawMaterialOrder updateRawMaterialOrder) { bool rawMaterialOrderUpdated = false; try { /*for (int i = 0; i < rawMaterialOrderList.Count; i++) * { * if (rawMaterialOrderList[i].RawMaterialOrderID == updateRawMaterialOrder.RawMaterialOrderID) * { * updateRawMaterialOrder.RawMaterialName = rawMaterialList[i].RawMaterialName; * updateRawMaterial.RawMaterialUnitPrice = rawMaterialList[i].RawMaterialUnitPrice; * rawMaterialOrderUpdated = true; * } * }*/ } catch (InventoryException ex) { throw new InventoryException(ex.Message); } return(rawMaterialOrderUpdated); }
public override bool UpdateRawMaterialOrderDAL(RawMaterialOrder updateRawMaterialOrder) { bool RawMaterialorderUpdated = false; try { RawMaterialOrder matchingRawMaterialOrder = GetRawMaterialOrderByRawMaterialOrderIDDAL(updateRawMaterialOrder.RawMaterialOrderID); if (matchingRawMaterialOrder != null) { matchingRawMaterialOrder = updateRawMaterialOrder; matchingRawMaterialOrder.LastmodifiedDateTime = DateTime.Now; RawMaterialorderUpdated = true; } } catch (Exception) { throw; } return(RawMaterialorderUpdated); }
public static bool AddRawMaterialOrderBL(RawMaterialOrder newRawMaterialOrder) { bool rawMaterialOrderAdded = false; try { if (ValidateRawMaterialOrder(newRawMaterialOrder)) { RawMaterialOrderDAL rawMaterialDAL = new RawMaterialOrderDAL(); rawMaterialOrderAdded = rawMaterialDAL.AddRawMaterialOrderDAL(newRawMaterialOrder); } else { throw new InventoryException("Invalid Order Material Details"); } } catch (InventoryException) { throw; } return(rawMaterialOrderAdded); }
public bool UpdateRMOrderDAL(RawMaterialOrder updateorder)//method to update rawmaterial order { bool orderUpdated = false; try { for (int i = 0; i < rawmaterialorderList.Count; i++) { if (rawmaterialorderList[i].RMOrderID == updateorder.RMOrderID) { updateorder.SupplierID = rawmaterialorderList[i].SupplierID; orderUpdated = true; } } } catch (Exception ex) { throw new InventoryException(ex.Message); } return(orderUpdated); }
public override bool DeleteRawMaterialOrderDAL(Guid deleteRawMaterialOrderID) { bool RawMaterialOrderDeleted = false; try { //Find RawMaterialOrder based on searchRawMaterialOrderID RawMaterialOrder matchingRawMaterialOrder = RawMaterialorderList.Find( (item) => { return(item.RawMaterialOrderID == deleteRawMaterialOrderID); } ); if (matchingRawMaterialOrder != null) { //Delete RawMaterialOrder from the collection RawMaterialorderList.Remove(matchingRawMaterialOrder); RawMaterialOrderDeleted = true; } } catch (Exception) { throw; } return(RawMaterialOrderDeleted); }
public abstract bool UpdateRawMaterialOrderDAL(RawMaterialOrder updateorder);
//Methods for CRUD operations //public abstract double generateTotalPrice(List<int> orders, List<int> quantity); public abstract bool AddRawMaterialOrderDAL(RawMaterialOrder order);
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); } }