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);
}
}
