public NewSupplierOrder(GetProductClassListDelegate getProductClassListDelegate, GetSuppliersListDelegate getSuppliersListDelegate)
{
productsMetaData = getProductClassListDelegate();
suppliersList = getSuppliersListDelegate();
InitializeComponent();
ProductsNameList = getProductsNames();
}
private static ProductClassList GenerateProductTree(ProductClassList productClassList)
{
ProductClassList productList = new ProductClassList();
foreach (ProductClass product in productClassList.ProductList)
{
Dictionary <string, int> initProductTree = product.InitProductTree;
Dictionary <ProductClass, int> productTree = new Dictionary <ProductClass, int>();
foreach (KeyValuePair <string, int> initTreeBranch in initProductTree)
{
ProductClass productSon = productClassList.GetProduct(initTreeBranch.Key);
if (productSon == null)
{
MessageBox.Show("Error: Product tree Incorrect", "Error");
return(null);
}
else
{
productTree.Add(productSon, initTreeBranch.Value);
}
}
product.ProductTree = productTree;
productList.AddProduct(product);
}
return(productList);
}
public static OrdersList Parse(XmlNodeList customerOrderNodeList, ProductClassList productsList)
{
OrdersList customerOrderList = new OrdersList();
foreach (XmlNode customerOrderNode in customerOrderNodeList)//orders level
{
Order order = new Order(Order.OrderTypeEnum.CustomerOrder);
Customer customer = new Customer();
foreach (XmlNode customerOrderParameter in customerOrderNode)//order parts level
{
XMLCustomerOrderFields XMLcustomerOrderField = (XMLCustomerOrderFields)Enum.Parse(typeof(XMLCustomerOrderFields), customerOrderParameter.Name, true);
switch (XMLcustomerOrderField)
{
case XMLCustomerOrderFields.CustomerName:
customer.Name = customerOrderParameter.InnerText;
break;
case XMLCustomerOrderFields.CustomerID:
customer.ID = customerOrderParameter.InnerText;
break;
case XMLCustomerOrderFields.CustomerOrderID:
order.OrderID = customerOrderParameter.InnerText;
break;
case XMLCustomerOrderFields.CustomerOrderDate:
order.OrderDate = DateTime.Parse(customerOrderParameter.InnerText);
break;
case XMLCustomerOrderFields.CustomerOrderDeliveryDate:
order.OrderDeliveryDate = DateTime.Parse(customerOrderParameter.InnerText);
break;
case XMLCustomerOrderFields.CustomerOrder_Status:
order.OrderStatus = (Order.OrderStatusEnum)Enum.Parse(typeof(Order.OrderStatusEnum), customerOrderParameter.InnerText, true);
break;
case XMLCustomerOrderFields.CustomerOrderProductsList:
order.OrderProductsList = getOrderProductsList(customerOrderParameter, productsList);
break;
default:
break;
} //end switch
} // end order parts level
order.Person = customer;
customerOrderList.AddOrder(order);
}//end orders level
return(customerOrderList);
}
public WarehouseManager(ProductClassList ProductsList, double maxCapacity)
{
Inventory = new Dictionary <ProductClass, double>();
foreach (ProductClass product in ProductsList.ProductList)
{
Inventory.Add(product, 0);
}
MaxCapacity = maxCapacity;
updateCapacity();
}
public static ProductClassList Parse(XmlNodeList productsNodeList, InitDataLoad initDataLoad)
{
ToolTypeClassList toolTypeClassList = initDataLoad.MetaData.ToolTypeMetaData;
ProductClassList productClassList = new ProductClassList();
foreach (XmlNode productNode in productsNodeList)
{
ProductClass product = new ProductClass();
foreach (XmlNode productparameter in productNode)
{
XMLProductFields XMLProductField = (XMLProductFields)Enum.Parse(typeof(XMLProductFields), productparameter.Name, true);
switch (XMLProductField)
{
case XMLProductFields.ProductID:
product.ProductID = productparameter.InnerText;
break;
case XMLProductFields.ProductName:
product.ProductName = productparameter.InnerText;
break;
case XMLProductFields.ProductCapacity:
product.ProductCapacity = int.Parse(productparameter.InnerText);
break;
case XMLProductFields.ProductTree:
product.InitProductTree = getProductTree(productparameter);
break;
case XMLProductFields.ToolList:
product.ToolsTypeList = getToolTypeList(productparameter, toolTypeClassList);
break;
default:
break;
}
}
productClassList.AddProduct(product);
}
productClassList = GenerateProductTree(productClassList);
return(productClassList);
}
public static Dictionary <ProductClass, double> Parse(XmlNodeList InventoryNodeList, InitDataLoad initDataLoad)
{
ProductClassList productsList = initDataLoad.MetaData.ProductsMetaData;
Dictionary <ProductClass, double> Inventory = new Dictionary <ProductClass, double>();
foreach (XmlNode inventoryParameter in InventoryNodeList)
{
WarehouseInventoryFields XMLWarehouseInventoryField = (WarehouseInventoryFields)Enum.Parse(typeof(WarehouseInventoryFields), inventoryParameter.Name, true);
KeyValuePair <ProductClass, double> productInventory = new KeyValuePair <ProductClass, double>();
switch (XMLWarehouseInventoryField)
{
case WarehouseInventoryFields.ProductBranch:
productInventory = getProductInventory(inventoryParameter, productsList);
break;
default:
break;
}
Inventory.Add(productInventory.Key, productInventory.Value);
}
return(Inventory);
}
public static SuppliersList Parse(XmlNodeList suppliersNodeList, InitDataLoad initdataLoad)
{
ProductClassList productsList = initdataLoad.MetaData.ProductsMetaData;
SuppliersList suppliersList = new SuppliersList();
foreach (XmlNode supplierNode in suppliersNodeList)
{
Supplier supplier = new Supplier();
foreach (XmlNode supplierParameter in supplierNode)
{
XMLSuppliersListFields XMLSuppliersListField = (XMLSuppliersListFields)Enum.Parse(typeof(XMLSuppliersListFields), supplierParameter.Name, true);
switch (XMLSuppliersListField)
{
case XMLSuppliersListFields.SupplierID:
supplier.ID = supplierParameter.InnerText;
break;
case XMLSuppliersListFields.SupplierName:
supplier.Name = supplierParameter.InnerText;
break;
case XMLSuppliersListFields.SupplierReliability:
supplier.Reliability = double.Parse(supplierParameter.InnerText);
break;
case XMLSuppliersListFields.SupplierPriceMatrix:
supplier.PriceMatrix = getSupplierPriceMatrix(supplierParameter, productsList);
break;
default:
break;
}
}
suppliersList.AddSupplier(supplier);
}
return(suppliersList);
}
private static KeyValuePair <ProductClass, double> getProductInventory(XmlNode inventoryParameter, ProductClassList productsList)
{
try
{
XmlNodeList inventoryBranchElements = inventoryParameter.ChildNodes;
KeyValuePair <ProductClass, double> productInventory = new KeyValuePair <ProductClass, double>(
productsList.GetProduct(inventoryBranchElements[0].InnerText),
Convert.ToDouble(inventoryBranchElements[1].InnerText));
return(productInventory);
}
catch (Exception)
{ }
return(new KeyValuePair <ProductClass, double>());
}
private static List <PriceTable> getOrderProductsList(XmlNode orderProductsListNode, ProductClassList productsList)
{
List <PriceTable> priceMatrix = new List <PriceTable>();
try
{
foreach (XmlNode orderProductsListBranch in orderProductsListNode)//priceMatrix level
{
PriceTable priceTable = new PriceTable();
XmlNodeList orderProductRowParametersList = orderProductsListBranch.ChildNodes;
foreach (XmlNode orderProductRowParameter in orderProductRowParametersList)//priceMatrix parameters level
{
XMLOrderFields XMLSuppliersListField = (XMLOrderFields)Enum.Parse(typeof(XMLOrderFields), orderProductRowParameter.Name, true);
switch (XMLSuppliersListField)
{
case XMLOrderFields.OrderProductsListBranch_ProductID:
{
ProductClass product = productsList.GetProduct(orderProductRowParameter.InnerText);
if (product == null)
{
MessageBox.Show("Wrong Product in Supplier Matrix", "Error");
}
priceTable.Product = product;
break;
}
case XMLOrderFields.OrderProductsListBranch_Amount:
priceTable.Amount = int.Parse(orderProductRowParameter.InnerText);
break;
case XMLOrderFields.OrderProductsListBranch_Price:
priceTable.Price = double.Parse(orderProductRowParameter.InnerText);
break;
default:
break;
} //end switch
} //end piceMatrix parameters level
priceMatrix.Add(priceTable);
} //end priceMatrix level
} //end try
catch (Exception e)
{
MessageBox.Show(e.ToString());
return(null);
}
return(priceMatrix);
}
public static OrdersList Parse(XmlNodeList OrderNodeList, InitDataLoad initDataLoad, Order.OrderTypeEnum orderType)
{
ProductClassList productsList = initDataLoad.MetaData.ProductsMetaData;
SuppliersList SuppliersMetaData = initDataLoad.MetaData.SuppliersMetaData;
OrdersList orderList = new OrdersList();
foreach (XmlNode customerOrderNode in OrderNodeList)//orders level
{
Order order = new Order(orderType);
Customer customer = new Customer();
foreach (XmlNode orderParameter in customerOrderNode)//order parts level
{
XMLOrderFields XMLcustomerOrderField = (XMLOrderFields)Enum.Parse(typeof(XMLOrderFields), orderParameter.Name, true);
switch (XMLcustomerOrderField)
{
case XMLOrderFields.PersonName:
customer.Name = orderParameter.InnerText;
break;
case XMLOrderFields.PersonID:
customer.ID = orderParameter.InnerText;
break;
case XMLOrderFields.OrderID:
order.OrderID = orderParameter.InnerText;
break;
case XMLOrderFields.OrderDate:
order.OrderDate = DateTime.Parse(orderParameter.InnerText);
break;
case XMLOrderFields.OrderDeliveryDate:
order.OrderDeliveryDate = DateTime.Parse(orderParameter.InnerText);
break;
case XMLOrderFields.Order_Status:
order.OrderStatus = (Order.OrderStatusEnum)Enum.Parse(typeof(Order.OrderStatusEnum), orderParameter.InnerText, true);
break;
case XMLOrderFields.OrderProductsList:
order.OrderProductsList = getOrderProductsList(orderParameter, productsList);
break;
default:
break;
} //end switch
} // end order parts level
if (orderType == Order.OrderTypeEnum.CustomerOrder)
{
order.Person = customer;
}
else
{
order.Person = SuppliersMetaData.GetSupplier(customer.ID);
}
orderList.AddOrder(order);
}//end orders level
return(orderList);
}
private static List <Supplier.PriceMatrixStruct> getSupplierPriceMatrix(XmlNode priceMatrixNode, ProductClassList productsList)
{
List <Supplier.PriceMatrixStruct> priceMatrix = new List <Supplier.PriceMatrixStruct>();
try
{
foreach (XmlNode supplierPriceMatrixBranch in priceMatrixNode)
{
Supplier.PriceMatrixStruct priceMatrixRow = new Supplier.PriceMatrixStruct();
XmlNodeList priceMatrixRowParametersList = supplierPriceMatrixBranch.ChildNodes;
foreach (XmlNode priceMatrixRowParameter in priceMatrixRowParametersList)
{
XMLSuppliersListFields XMLSuppliersListField = (XMLSuppliersListFields)Enum.Parse(typeof(XMLSuppliersListFields), priceMatrixRowParameter.Name, true);
switch (XMLSuppliersListField)
{
case XMLSuppliersListFields.SupplierPriceMatrixBranch_ProductID:
{
ProductClass product = productsList.GetProduct(priceMatrixRowParameter.InnerText);
if (product == null)
{
MessageBox.Show("Wrong Product in Supplier Matrix", "Error");
}
priceMatrixRow.product = product;
break;
}
case XMLSuppliersListFields.SupplierPriceMatrixBranch_UnitPrice:
priceMatrixRow.UnitPrice = double.Parse(priceMatrixRowParameter.InnerText);
break;
case XMLSuppliersListFields.SupplierPriceMatrixBranch_LeadTime:
priceMatrixRow.LeadTime = int.Parse(priceMatrixRowParameter.InnerText);
break;
default:
break;
}
}
priceMatrix.Add(priceMatrixRow);
}
}
catch (Exception)
{
return(null);
}
return(priceMatrix);
}
