public void CanGetProductObject(string productType, bool expected)
{
ProductManager manager = new ProductManager(productRepo);
ProductLookupResponse response = manager.GetProduct(productType);
Assert.AreEqual(expected, response.Success);
}
public string GetProduct(ProductLookupResponse products, Order order)
{
Console.WriteLine("------------------------");
string productType;
foreach (var x in products.Product)
{
Console.WriteLine($"Product type: {x.ProductType}");
Console.WriteLine($"Cost per square foot: {x.CostPerSquareFoot}");
Console.WriteLine($"Labor cost per square foot: {x.CostPerSquareFoot}");
Console.WriteLine("------------------------");
}
Console.Write("Select a product: ");
while (true)
{
productType = Console.ReadLine();
if (order.Edit && productType == "")
{
return(order.ProductType);
}
if (products.Product.Any(x => x.ProductType == productType))
{
order.Recalculate = true;
return(productType);
}
else
{
Console.Write("Error: Product does not exist. Select another product: ");
}
}
}
public void CanGetProductFromFile(string productType, bool expected)
{
ProductManager productManager = ProductManagerFactory.Create();
ProductLookupResponse response = productManager.GetProduct(productType);
Assert.AreEqual(expected, response.Success);
}
public ProductLookupResponse LookupProducts()
{
ProductLookupResponse response = new ProductLookupResponse();
response.Product = _orderTestRepository.LoadProducts();
return(response);
}
public AddOrderResponse AddOrder(Order order)
{
AddOrderResponse response = new AddOrderResponse();
//Validation
if (order.OrderDate < DateTime.Now)
{
response.Success = false;
response.Message = "Order date MUST be in the future!";
return(response);
}
if (order.Area < 100)
{
response.Success = false;
response.Message = "Order area MUST be greater than 100sqft!";
return(response);
}
ProductManager productManager = ProductManagerFactory.Create();
ProductLookupResponse productResponse = productManager.GetProduct(order.ProductType);
if (!productResponse.Success)
{
response.Success = false;
response.Message = $"Product type: {order.ProductType} does not exist!";
return(response);
}
StateTaxManager stateTaxManager = StateTaxManagerFactory.Create();
StateLookupResponse taxResponse = stateTaxManager.GetStateTax(order.State);
if (!taxResponse.Success)
{
response.Success = false;
response.Message = $"No state tax data found for: {order.State}";
return(response);
}
bool duplicateOrder = _orderRepository.List(order.OrderDate)
.Any(o =>
o.CustomerName == order.CustomerName &&
o.State == order.State &&
o.ProductType == order.ProductType &&
o.Area == order.Area
);
if (duplicateOrder)
{
response.Success = false;
response.Message = "Order entered already exists!";
}
else
{
_orderRepository.AddOrder(order);
response.Success = true;
response.Order = order;
}
return(response);
}
private Order AssignProductInfo(string productInput)
{
productResponse = manager.LookupProduct(productInput);
if (productResponse.Success)
{
return(productResponse.ProductInfo);
}
return(null);
}
public void CanChooseProductTest()
{
ProductManager manager = ProductManagerFactory.Create();
ProductLookupResponse response = manager.ChooseProduct("Carpet");
Assert.IsNotNull(response.Product.ProductType);
Assert.IsTrue(response.Success);
Assert.AreEqual("Carpet", response.Product.ProductType);
}
internal static void Execute()
{
Console.Clear();
Console.WriteLine("Add an Order ");
Console.WriteLine("*************************************");
Console.WriteLine();
OrderManager manager = OrderManagerFactory.Create();
DateTime orderDate = ConsoleIO.GetFutureDateTime("Enter a valid Date EX: MM/DD/YYYY ");
string customerName = ConsoleIO.GetStringFromUser("Customer Name: ");
TaxLookupResponse taxResponse = manager.LoadTaxes();
var state = ConsoleIO.GetStateFromUser("State: ", taxResponse.Taxes);
IEnumerable <Product> GetProducts = manager.GetAllProducts();
ConsoleIO.ShowListOfProducts(GetProducts);
ProductLookupResponse productResponse = manager.LoadProducts();
var productType = ConsoleIO.GetProductFromUser("Product Type: ", productResponse.Products);
decimal area = ConsoleIO.GetAreaFromUser("Area: ");
Console.WriteLine();
Console.WriteLine("*************************************");
AddAnOrderResponse addResponse = manager.AddOrder(orderDate, customerName, state, productType, area, 0);
if (!addResponse.Success)
{
Console.WriteLine("An error has occured");
Console.WriteLine(addResponse.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
else
{
Console.WriteLine($"Customer Name: {customerName}, State: {state.Abbreviation}, Product Type: {productType.Name}, Area: {area}");
Console.WriteLine();
if (ConsoleIO.GetYesNoAnswerFromUser($"Are you sure you want to add this file?") == "Y")
{
manager.AddToOrderRepo(addResponse.AddedOrder);
Console.WriteLine("The Order was successfully added.");
Console.WriteLine("Press any key to continue...");
}
else
{
Console.WriteLine("Order cancelled. Press any key to continue.");
Console.WriteLine("Press any key to continue...");
}
Console.ReadLine();
}
}
public Order AddOrderInformation(TaxesLookupResponse taxes, ProductLookupResponse products)
{
Order order = new Order();
order.Edit = false;
order.OrderDate = GetDate();
order.CustomerName = GetName(order);
order.State = GetState(taxes, order);
order.ProductType = GetProduct(products, order);
order.Area = GetArea(order);
order = OrderCalculations(order, taxes, products);
return(order);
}
public ProductLookupResponse LookupProduct(string productInput)
{
ProductLookupResponse response = new ProductLookupResponse();
Order product = _productRepository.GetProductInfo(productInput);
if (product == null)
{
response.Success = false;
response.Message = "Product not found";
}
else
{
response.Success = true;
response.ProductInfo = product;
}
return(response);
}
public ProductLookupResponse LoadProducts()
{
ProductLookupResponse productResponse = new ProductLookupResponse();
productResponse.Products = _productRepository.GetProducts();
if (productResponse.Products == null)
{
productResponse.Success = false;
productResponse.Message = "Is not a valid product type";
}
else
{
productResponse.Success = true;
}
return(productResponse);
}
public ProductLookupResponse ChooseProduct(string ProductType)
{
ProductLookupResponse response = new ProductLookupResponse();
response.Product = _productRepository.ChooseProduct(ProductType);
if (response.Product == null)
{
response.Success = false;
response.Message = $"{ProductType} is not a product we currently sell";
}
else
{
response.Success = true;
}
return(response);
}
public Order EditOrderInformation(Order order, TaxesLookupResponse taxes, ProductLookupResponse products)
{
Console.Clear();
order.Edit = true;
order.Recalculate = false;
order.CustomerName = GetName(order);
order.State = GetState(taxes, order);
order.ProductType = GetProduct(products, order);
order.Area = GetArea(order);
if (order.Recalculate)
{
order = OrderCalculations(order, taxes, products);
}
return(order);
}
public SaveOrderResponse SaveOrder(Order order)
{
SaveOrderResponse response = new SaveOrderResponse();
//Validation
if (order.Area < 100)
{
response.Success = false;
response.Message = "Order area MUST be greater than 100sqft!";
return(response);
}
ProductManager productManager = ProductManagerFactory.Create();
ProductLookupResponse productResponse = productManager.GetProduct(order.ProductType);
if (!productResponse.Success)
{
response.Success = false;
response.Message = $"Product type: {order.ProductType} does not exist!";
return(response);
}
StateTaxManager stateTaxManager = StateTaxManagerFactory.Create();
StateLookupResponse taxResponse = stateTaxManager.GetStateTax(order.State);
if (!taxResponse.Success)
{
response.Success = false;
response.Message = $"No state tax data found for: {order.State}";
return(response);
}
//Save order
_orderRepository.SaveOrder(order);
if (!order.AreEqualOrders(order, _orderRepository.LoadOrder(order.OrderNumber, order.OrderDate)))
{
response.Success = false;
response.Message = "Failed to save order!";
}
else
{
response.Success = true;
}
return(response);
}
//<summary>
// Gets the personal settings.
//</summary>
//<param name="personalSettingsRequest"> The personal settings request. </param>
//<returns> Personal Settings Response. </returns>
#endregion
#region IWerpCommonLookupContract Members
//<summary>
// Gets the list of Products
//</summary>
//<param name="ProductRequest"> The personal settings request. </param>
//<returns> ProductAmcLookupResponse </returns>
ProductLookupResponse IWerpCommonLookupContract.GetProductList(ProductLookupRequest ProductRequest)
{
ProductLookupResponse response = new ProductLookupResponse();
try
{
DataTable dtProductList;
if (string.IsNullOrEmpty(ProductRequest.ProductCode))
{
dtProductList = BoCommonLookup.GetProductList();
}
else
{
dtProductList = BoCommonLookup.GetProductList(ProductRequest.ProductCode.Trim());
}
foreach (DataRow row in dtProductList.Rows)
{
response.ProductListResponse.ProductList.Add(new KeyValuePair <string, string>(row["PAG_AssetGroupCode"].ToString(), row["PAG_AssetGroupName"].ToString()));
}
response.SetServiceResult(true, WerpErrorDto.E_SUCCESS, null);
}
catch (FormatException ex)
{
response.SetServiceResult(false, WerpErrorDto.E_INVALID_INPUT, ex.Message);
}
catch (DataException ex)
{
response.SetServiceResult(false, WerpErrorDto.E_DATABASE, ex.Message);
}
catch (Exception ex)
{
response.SetServiceResult(false, WerpErrorDto.E_GENERIC, ex.Message);
}
finally
{
}
return(response);
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Add an order");
Console.WriteLine("--------------------");
ProductLookupResponse products = manager.LookupProducts();
TaxesLookupResponse taxes = manager.LookupTaxes();
Order order = manager.AddOrderInformation(taxes, products);
Console.Clear();
Console.WriteLine("Order details");
Console.WriteLine("--------------");
ConsoleIO.DisplayOrderDetails(order);
Console.WriteLine("--------------");
Console.WriteLine("Save order? Enter Y/N");
while (true)
{
string prompt = Console.ReadLine();
if (prompt == "Y")
{
manager.AddNewOrder(order);
Console.WriteLine("Order saved. Press any key to continue...");
Console.ReadKey();
return;
}
else if (prompt == "N")
{
Console.WriteLine("Order discarded. Press any key to continue...");
Console.ReadKey();
return;
}
else
{
Console.Write("Invalid input. Enter Y or N: ");
}
}
}
public Order OrderCalculations(Order order, TaxesLookupResponse taxes, ProductLookupResponse products)
{
Taxes stateTax = taxes.Taxes.Where(x => x.StateAbbreviation == order.State).First();
Products productPrices = products.Product.Where(x => x.ProductType == order.ProductType).First();
if (!order.Edit)
{
order.OrderNumber = _orderTestRepository.LoadLastOrder(order.OrderDate).OrderNumber + 1;
}
else
{
order.TaxRate = stateTax.TaxRate;
}
order.CostPerSquareFoot = productPrices.CostPerSquareFoot;
order.LaborCostPerSquareFoot = productPrices.LaborCostPerSquareFoot;
order.MaterialCost = Math.Round(productPrices.CostPerSquareFoot * order.Area, 2);
order.LaborCost = Math.Round(productPrices.LaborCostPerSquareFoot * order.Area, 2);
order.Tax = Math.Round((order.LaborCost + order.MaterialCost) * (stateTax.TaxRate / 100), 2);
order.Total = Math.Round(order.LaborCost + order.MaterialCost + order.Tax, 2);
return(order);
}
public ProductLookupResponse GetProduct(string productType)
{
ProductLookupResponse response = new ProductLookupResponse();
if (productType == "")
{
response.Success = false;
response.Message = "";
return(response);
}
response.Product = _productRepository.GetProduct(productType);
if (response.Product == null)
{
response.Success = false;
response.Message = $"Product info does not exist for {productType}";
return(response);
}
else
{
response.Success = true;
}
return(response);
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Edit an order");
Console.WriteLine("-------------------------------------");
Console.Write("Enter the order date: ");
string date = Console.ReadLine();
OrderLookupResponse response;
if (DateTime.TryParse(date, out DateTime orderDate))
{
response = manager.LookupOrderDate(orderDate);
if (!response.Success)
{
Console.Write("Error: ");
Console.WriteLine(response.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return;
}
}
else
{
Console.WriteLine("Error: The date entered is not a valid date");
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return;
}
Console.Write("Enter the order number:");
string orderNumCheck = Console.ReadLine();
if (int.TryParse(orderNumCheck, out int orderNumber))
{
response = manager.LookupOrderNumber(orderNumber);
if (!response.Success)
{
Console.Write("Error: ");
Console.WriteLine(response.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return;
}
}
else
{
Console.WriteLine("Error: Invalid input");
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return;
}
Order order = response.Order;
ProductLookupResponse products = manager.LookupProducts();
TaxesLookupResponse taxes = manager.LookupTaxes();
Console.WriteLine("Order details");
Console.WriteLine("*******************");
ConsoleIO.DisplayOrderDetails(order);
Console.WriteLine("*******************");
Console.WriteLine("Press any key to continue to the edit screen...");
Console.ReadKey();
Order orderEdit = manager.EditOrderInformation(order, taxes, products);
Console.Clear();
Console.WriteLine("Edited order information");
ConsoleIO.DisplayOrderDetails(orderEdit);
Console.Write("Save these changes? Y/N: ");
while (true)
{
string userInput = Console.ReadLine();
if (userInput == "Y")
{
manager.SaveChanges(orderEdit);
Console.WriteLine("Changes have been saved. Press any key to continue...");
Console.ReadKey();
return;
}
else if (userInput == "N")
{
Console.WriteLine("Changes have been discarded. Press any key to continue...");
Console.ReadKey();
return;
}
}
}
public static void Execute()
{
Console.Clear();
Console.WriteLine("Edit Order");
Console.WriteLine("*************************************");
OrderManager manager = OrderManagerFactory.Create();
var userDateTimeInPut = ConsoleIO.GetDateTimeFromUser();
OrderDateLookupResponse orderDateResponse = manager.OrderLookupDate(userDateTimeInPut);
if (orderDateResponse.Success)
{
foreach (var order in orderDateResponse.ListOfOrders)
{
Console.WriteLine($"Order Number: {order.OrderNumber}, Customer Name: {order.CustomerName}, State {order.State}, Tax Rate: {order.TaxRate}, Area: {order.Area}, Cost Per Square Foot: {order.CostPerSquareFoot}, Labor Cost Per Square Foot: {order.LaborCostPerSquareFoot}, Material Cost: {order.MaterialCost}, Labor Cost: {order.LaborCost}, Tax Total: {order.TotalTax}, Total Cost: {order.TotalCost}");
}
int number = ConsoleIO.GetOrderNumber("Enter the Order number do you want to edit?");
var originalOrder = new Order(orderDateResponse.ListOfOrders.SingleOrDefault(f => f.OrderNumber == number));
Order updatedOrder = new Order(originalOrder);
TaxLookupResponse taxesResponse = manager.LoadTaxes();
ProductLookupResponse productResponse = manager.LoadProducts();
Console.Clear();
updatedOrder.OrderDate = userDateTimeInPut;
updatedOrder.CustomerName = ConsoleIO.EditGetStringFromUser(updatedOrder, $"(Previous Name: {originalOrder.CustomerName}) Enter Customer Name: ");
updatedOrder.State = ConsoleIO.EditGetStateFromUser(updatedOrder, $"(Previous State: {originalOrder.State}) State: ", taxesResponse.Taxes);
updatedOrder.ProductType = ConsoleIO.EditGetProductFromUser(updatedOrder, $"(Previous Type: {originalOrder.ProductType}) Product Type: ", productResponse.Products);
updatedOrder.Area = ConsoleIO.EditGetAreaFromUser(updatedOrder, $"(Previous Area: {originalOrder.Area}) Area: ");
Console.WriteLine($"Customer Name: {updatedOrder.CustomerName}, State: {updatedOrder.State}, Product Type: {updatedOrder.ProductType}, Area: {updatedOrder.Area}");
Console.WriteLine();
if (ConsoleIO.GetYesNoAnswerFromUser($"Are you sure you want to add this file?") == "Y")
{
EditOrderResponse editResponse = manager.EditOrder(updatedOrder);
if (editResponse.Success)
{
Console.WriteLine("The Order was successfully updated.");
Console.WriteLine("Press any key to continue...");
}
else
{
Console.WriteLine("An error occurred.");
Console.WriteLine(editResponse.Message);
}
}
else
{
Console.WriteLine("Edit order was cancelled. Press any key to continue.");
}
Console.ReadLine();
}
else
{
Console.WriteLine("An error has occurred");
Console.WriteLine(orderDateResponse.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
//Takes in an original order, makes a copy, assigns user edits from "editOrder" to the copy and returns copy to be saved
public EditOrderResponse EditOrder(Order originalOrder, Order editOrder)
{
Order order = new Order(originalOrder);
EditOrderResponse response = new EditOrderResponse();
//Assign order properties if not blank or different than the original order
if (order.CustomerName != editOrder.CustomerName && editOrder.CustomerName != "")
{
order.CustomerName = editOrder.CustomerName;
}
if (order.State != editOrder.State && editOrder.State != null)
{
order.State = editOrder.State;
order.TaxRate = editOrder.TaxRate;
}
if (order.Area != editOrder.Area && editOrder.Area != decimal.MinValue)
{
order.Area = editOrder.Area;
}
if (order.ProductType != editOrder.ProductType && editOrder.ProductType != null)
{
order.ProductType = editOrder.ProductType;
order.CostPerSquareFoot = editOrder.CostPerSquareFoot;
order.LaborCostPerSquareFoot = editOrder.LaborCostPerSquareFoot;
}
//Validation or the updated order
if (order.OrderDate < DateTime.Now)
{
response.Success = false;
response.Message = "Order date MUST be in the future!";
return(response);
}
if (order.Area < 100)
{
response.Success = false;
response.Message = "Order area MUST be greater than 100sqft!";
return(response);
}
ProductManager productManager = ProductManagerFactory.Create();
ProductLookupResponse productResponse = productManager.GetProduct(order.ProductType);
if (!productResponse.Success)
{
response.Success = false;
response.Message = $"Product type: {order.ProductType} does not exist!";
return(response);
}
StateTaxManager stateTaxManager = StateTaxManagerFactory.Create();
StateLookupResponse taxResponse = stateTaxManager.GetStateTax(order.State);
if (!taxResponse.Success)
{
response.Success = false;
response.Message = $"No state tax data found for: {order.State}";
return(response);
}
//lookup order and check for changes
OrderLookupResponse lookupResponse = LookupOrder(order.OrderNumber, order.OrderDate);
if (lookupResponse.Success)
{
if (order.AreEqualOrders(lookupResponse.Order, order))
{
response.Success = false;
response.Message = $"No changes entered for Order: {order.OrderNumber} - {order.OrderDate:MM/dd/yyyy}.";
}
else
{
response.Success = true;
response.Order = order;
}
}
else
{
response.Success = false;
response.Message = $"{lookupResponse.Message}\nOrder Number and Order Date cannot be changed!";
}
return(response);
}
public void Execute()
{
Console.Clear();
ConsoleIO.HeadingLable("Add an Order");
Order newOrder = new Order();
newOrder.OrderDate = ConsoleIO.GetDateFromUser("Enter Order Date (ex. MM/DD/YYYY): ");
newOrder.CustomerName = ConsoleIO.GetStringInputFromUser("Customer Name: ");
StateTaxManager stateTaxManager = StateTaxManagerFactory.Create();
bool validState = false;
while (!validState)
{
StateLookupResponse response = stateTaxManager.GetStateTax(ConsoleIO.GetStringInputFromUser("State (ex. MN, or Minnesota): "));
if (response.Success)
{
newOrder.State = response.StateTax.StateAbbreviation;
newOrder.TaxRate = response.StateTax.TaxRate;
validState = true;
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {response.Message}");
}
}
ProductManager productManager = ProductManagerFactory.Create();
ProductListResponse productList = productManager.GetProductList();
if (productList.Success)
{
ConsoleIO.HeadingLable("Product List");
foreach (Product p in productList.Products)
{
ConsoleIO.DisplayProducts(p);
}
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {productList.Message}");
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
return;
}
bool validProduct = false;
while (!validProduct)
{
ProductLookupResponse response = productManager.GetProduct(ConsoleIO.GetStringInputFromUser("Product Name: "));
if (response.Success)
{
newOrder.ProductType = response.Product.ProductType;
newOrder.CostPerSquareFoot = response.Product.CostPerSquareFoot;
newOrder.LaborCostPerSquareFoot = response.Product.LaborCostPerSquareFoot;
validProduct = true;
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {response.Message}");
}
}
newOrder.Area = ConsoleIO.GetAreaFromUser("Area: ");
ConsoleIO.HeadingLable($"{newOrder.CustomerName}'s New Order");
ConsoleIO.DisplayOrderInformation(newOrder, false);
OrderManager orderManager = OrderManagerFactory.Create();
bool submit = ConsoleIO.GetYesNoAnswerFromUser("Would you like to submit this order?");
if (submit)
{
AddOrderResponse addResponse = orderManager.AddOrder(newOrder);
if (addResponse.Success)
{
Console.Clear();
ConsoleIO.YellowMessage("Order Submitted!");
ConsoleIO.DisplayOrderInformation(addResponse.Order, true);
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {addResponse.Message}");
}
}
else
{
ConsoleIO.RedMessage("Add order cancelled.");
}
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
}
public void Execute()
{
Console.Clear();
ConsoleIO.HeadingLable("Edit an Order");
//Get an order with an Order Number and Order Date
int orderNumber = ConsoleIO.GetIntInputFromUser("Order Number: ");
DateTime orderDate = ConsoleIO.GetDateFromUser("Order Date (MM/DD/YYYY): ", true);
//Lookup Order and Begin editing or Error out
OrderManager orderManager = OrderManagerFactory.Create();
OrderLookupResponse orderLookup = orderManager.LookupOrder(orderNumber, orderDate);
if (orderLookup.Success)
{
//Create a new order for the user to fill in params
Order editOrder = new Order();
//Display the order that will be edited
ConsoleIO.HeadingLable($"Editing Order: {orderLookup.Order.OrderNumber} - {orderLookup.Order.OrderDate:MM/dd/yyyy}");
//Get new order name from user, display the old name
editOrder.CustomerName = ConsoleIO.GetStringInputFromUser($"Customer Name ({orderLookup.Order.CustomerName}): ", true);
//Create a state tax object to get correct input from user for new order state params
StateTaxManager stateTaxManager = StateTaxManagerFactory.Create();
bool validInput = false;
while (!validInput)
{
//Get a state tax object that matches the user input unless input is ""
StateLookupResponse stateTaxResponse = stateTaxManager.GetStateTax(ConsoleIO.GetStringInputFromUser($"State (ex. MN, or Minnesota)({orderLookup.Order.State}): ", true));
if (!stateTaxResponse.Success && stateTaxResponse.Message == "")
{
validInput = true;
}
else if (stateTaxResponse.Success)
{
//If tax object exists assign new order state and tax params
editOrder.State = stateTaxResponse.StateTax.StateAbbreviation;
editOrder.TaxRate = stateTaxResponse.StateTax.TaxRate;
validInput = true;
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {stateTaxResponse.Message}");
}
}
//Create a product manager to get a product list
ProductManager productManager = ProductManagerFactory.Create();
ProductListResponse productList = productManager.GetProductList();
//Print out product list or error out
if (productList.Success)
{
ConsoleIO.HeadingLable("Product List");
foreach (Product p in productList.Products)
{
ConsoleIO.DisplayProducts(p);
}
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {productList.Message}");
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
return;
}
//Get valid user input for new order product type
bool validProduct = false;
while (!validProduct)
{
ProductLookupResponse productResponse = productManager.GetProduct(ConsoleIO.GetStringInputFromUser($"Product Name ({orderLookup.Order.ProductType}): ", true));
//User enters nothing and nothing is assigned
if (!productResponse.Success && productResponse.Message == "")
{
validProduct = true;
}
else if (productResponse.Success)
{
//Valid entry assigns new order product params
editOrder.ProductType = productResponse.Product.ProductType;
editOrder.CostPerSquareFoot = productResponse.Product.CostPerSquareFoot;
editOrder.LaborCostPerSquareFoot = productResponse.Product.LaborCostPerSquareFoot;
validProduct = true;
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {productResponse.Message}");
}
}
//Get valid area for new order from user
editOrder.Area = ConsoleIO.GetAreaFromUser($"Area ({orderLookup.Order.Area}): ", true);
//Assign old order params to new order params
EditOrderResponse editResponse = orderManager.EditOrder(orderLookup.Order, editOrder);
//If the edit is successful ask to save order, otherwise error out
if (editResponse.Success)
{
//Display
ConsoleIO.HeadingLable("Updated Order");
ConsoleIO.DisplayOrderInformation(editResponse.Order, true);
bool saveEdit = ConsoleIO.GetYesNoAnswerFromUser("Would you like to submit and save the updated order information?");
if (saveEdit)
{
SaveOrderResponse saveResponse = orderManager.SaveOrder(editResponse.Order);
if (saveResponse.Success)
{
ConsoleIO.YellowMessage($"\nUpdated Order: {editResponse.Order.OrderNumber} - {editResponse.Order.OrderDate:MM/dd/yyyy}");
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {saveResponse.Message}");
}
}
}
else
{
ConsoleIO.RedMessage($"An Error Occured: {editResponse.Message}");
}
}
else
{
ConsoleIO.RedMessage(orderLookup.Message);
}
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
}
