//expects fail since this is not a valid order number
////// ////// ////// ////// ////// ////// ////// ////// ////// /////
////// Defines rule and defines each varible for one account //////
////// AND defines expectedResult /////
public void LookupOrderFileTest
(int orderYr, int orderMnth, int orderDay, int orderNum, bool expectedResult)
{
////// ////// ////// ////// ////// ////// ///// ///// ///// /////
////// Creates instance of repo to call the method being tested ///
//IDeposit deposit = new NoLimitDepositRule();
//OrderManager orderRepo = new OrderManagerFactory.Create();
//_manager = OrderManagerFactory.Create();
OrderManager manager = new OrderManager(new OrderTestRepo2());
//IDeposit deposit = new NoLimitDepositRule();
////// ////// ////// ////// ////// ///
////// Creats 1 account object //////
DateTime testDate = new DateTime();
testDate = new DateTime(orderYr, orderMnth, orderDay);
int testOrderNum = orderNum;
////// ////// ////// ////// ////// //////
////// Call the method being tested /////
// AccountDepositResponse response = deposit.Deposit(account, amount);
OrderLookupResponse response = new OrderLookupResponse();
response = manager.LookupOrder(testDate, orderNum);
Assert.AreEqual(expectedResult, response.Success);
}
public OrderLookupResponse LookupOrder(string orderdate, int ordernumber)
{
OrderLookupResponse orderlookupresponse = new OrderLookupResponse();
OrderDateFileResponse orderdatefile = _orderRepository.GetPath(orderdate);
if (string.IsNullOrEmpty(orderdatefile.path))
{
orderlookupresponse.Success = false;
orderlookupresponse.Message = $"File not found for Order date {orderdate} or some problem. Please contact IT.";
}
else
{
orderlookupresponse.order = _orderRepository.LoadOrder(orderdatefile.path, ordernumber);
if (orderlookupresponse.order == null)
{
orderlookupresponse.Success = false;
orderlookupresponse.Message = $"No orders with order date {orderdate} and order number {ordernumber}. Please enter another order date and or order number or contact IT!";
}
else
{
orderlookupresponse.Success = true;
if (orderlookupresponse.order.CustomerName.Contains("|"))
{
orderlookupresponse.order.CustomerName = orderlookupresponse.order.CustomerName.Replace("|", ",");
}
}
}
return(orderlookupresponse);
}
public OrderLookupResponse LookupOrder(OrderInfo orderInfo)
{
OrderLookupResponse response = DIContainer.Kernel.Get <OrderLookupResponse>();
if (orderInfo.OrderDate != _orderRepository.GetOrderDate())
{
_orderRepository.FetchOrders(orderInfo.OrderDate);
}
var fileresponse = _orderRepository.GetOrder(orderInfo);
if (fileresponse.Success)
{
response.OrderInfo = fileresponse.OrderInfo;
response.Message = fileresponse.Message;
response.Success = true;
}
else
{
response.OrderInfo = orderInfo;
response.Success = false;
response.Message = fileresponse.Message;
}
return(response);
}
// sets orderlookup response into motion
public OrderLookupResponse DisplayOrder(string orderDate)
{
OrderLookupResponse response = new OrderLookupResponse();
DateValidation(orderDate);
if (Date.OrderDate.ToString() == Date.DATE_TIME_ORIGIN)
{
response.Order = null;
}
else
{
response.Order = _orderRepository.DisplayOrder(Date.OrderDate);
}
if (response.Order == null)
{
response.Success = false;
response.Message = $"{orderDate} is not a valid order date.";
}
else
{
response.Success = true;
}
return(response);
}
public void Execute()
{
OrderManager manager = DIContainer.Kernel.Get <OrderManager>();
var tempOrderInfo = DIContainer.Kernel.Get <OrderInfo>();
Console.Clear();
var orderDate = Input.GetOrderDate();
var orderNumber = Input.GetOrderNumber();
tempOrderInfo = DIContainer.Kernel.Get <OrderInfo>();
tempOrderInfo.OrderDate = orderDate;
tempOrderInfo.OrderNumber = orderNumber;
OrderLookupResponse response = manager.LookupOrder(tempOrderInfo);
if (response.Success)
{
Output.SendToConsole(response.OrderInfo);
}
else
{
Output.SendToConsole("An error occurred: \n");
Output.SendToConsole(response.Message);
}
Output.SendToConsole("\nPress any key to continue...");
Console.ReadKey();
;
}
private string GetEditOrderState(OperationsManager manager, OrderLookupResponse response)
{
bool isCorrectStateFormat = false;
string userInput = "";
do
{
Console.Clear();
Console.WriteLine(pageHeader);
Console.WriteLine("\n***Edit Order Number {0} for {1}/{2}/{3}***", response.Order.OrderNumber, _orderDate.Substring(0, 2), _orderDate.Substring(2, 2), _orderDate.Substring(4, 4));
Console.WriteLine("\nIf you wish to edit a field, type in the new information. If you wish to leave the field unchanged, simply press enter.");
Console.WriteLine("\nCustomer Name ({0}): {1}", response.Order.CustomerName, nameInput);
Console.Write("State ({0}): ", response.Order.State);
userInput = Console.ReadLine();
if (manager.CheckAddState(userInput).Success || userInput == "")
{
isCorrectStateFormat = true;
}
else
{
isCorrectStateFormat = false;
Console.WriteLine();
Console.WriteLine(manager.CheckAddState(userInput).Message);
Console.Write(ConsoleIO.anyKey);
Console.ReadKey();
}
} while (!isCorrectStateFormat);
return(userInput);
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
DateTime orderDate;
Console.Clear();
Console.WriteLine("Lookup an Order");
Console.WriteLine("----------------------");
Console.Write("Enter the Order Date: ");
while (!DateTime.TryParse(Console.ReadLine(), out orderDate))
{
Console.WriteLine("That is not a valid format, please try again");
}
OrderLookupResponse response = manager.AllOrderLookup(orderDate);
if (response.Success)
{
foreach (Order order in response.Orders)
{
ConsoleIO.DisplayOrder(order);
}
}
else
{
Console.WriteLine("An error has occured: ");
Console.WriteLine(response.Message);
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return;
}
public OrderLookupResponse LookupOrder(int dateResult)
{
OrderLookupResponse response = new OrderLookupResponse();
response.Order = _orderRepository.LoadDate(dateResult);
if (response.Order == null || dateResult == 0)
{
response.Success = false;
response.Message = $"{dateResult} is not a valid date.";
Console.ReadLine();
}
//else if (response.Order != )
//{
//}
else
{
response.Success = true;
}
return(response);
}
public void AskProduct(OrderLookupResponse response)
{
ProductManager productManager = ProductFactory.Create();
while (true)
{
Console.Write($"Enter Product ({response.Order.ProductType}): ");
string product = Console.ReadLine();
ProductResponse productResponse = productManager.ProductInfo(product);
if (String.IsNullOrEmpty(product))
{
ConsoleIO.DisplayOrderDetails(response.Order);
return;
}
else
{
if (productResponse.Success)
{
response.Order.ProductType = productResponse.Product.ProductType;
response.Order.LaborCostPerSquareFoot = productResponse.Product.LaborCostPerSquareFoot;
response.Order.CostPerSquareFoot = productResponse.Product.CostPerSquareFoot;
ConsoleIO.DisplayOrderDetails(response.Order);
break;
}
else
{
Console.WriteLine(productResponse.Message);
ConsoleIO.PressAnyKey();
continue;
}
}
}
}
public void AskState(OrderLookupResponse response)
{
TaxManager taxManager = TaxFactory.Create();
while (true)
{
Console.Clear();
Console.Write($"Enter State ({response.Order.State}): ");
string state = (Console.ReadLine()).ToUpper();
TaxResponse taxResponse = taxManager.TaxRate(state);
if (string.IsNullOrEmpty(state))
{
ConsoleIO.DisplayOrderDetails(response.Order);
return;
}
else
{
if (taxResponse.Success)
{
response.Order.State = taxResponse.Tax.StateAbbreviation; //set state
response.Order.TaxRate = taxResponse.Tax.TaxRate; //make sure the new tax goes through
ConsoleIO.DisplayOrderDetails(response.Order);
break;
}
else
{
Console.WriteLine(taxResponse.Message);
ConsoleIO.PressAnyKey();
continue;
//Console.Clear();
}
}
}
}
public void TestlookupReponse(int year, int month, int day, string customerName, int orderNumber, string state, decimal taxRate, string productType, decimal area,
decimal costPerSquareFoot, decimal laborCostPerSquareFoot, decimal materialCost, decimal laborCost, decimal tax, decimal total, bool expectedResult)
{
OrderManager manager = OrderManagerFactory.Create();
Order ord = new Order();
ord.Date = new DateTime(year, month, day);
ord.CustomerName = customerName;
ord.OrderNumber = orderNumber;
ord.State = state;
ord.TaxRate = taxRate;
ord.ProductType = productType;
ord.Area = area;
ord.CostPerSquareFoot = costPerSquareFoot;
ord.LaborCostPerSquareFoot = laborCostPerSquareFoot;
ord.MaterialCost = materialCost;
ord.LaborCost = laborCost;
ord.Tax = tax;
ord.Total = total;
OrderLookupResponse response = manager.LookupOrder(ord.Date, orderNumber);
if (response.Success)
{
Assert.IsNotNull(response.order);
Assert.AreEqual(response.order.ProductType, productType);
Assert.AreEqual(response.order.Area, area);
}
Assert.AreEqual(expectedResult, response.Success);
}
public void RemoveOrderTest(string OrderDate, int OrderNumber, string CustomerName, decimal Area, string State, decimal TaxRate, string Product, decimal CostPerSquareFoot, decimal LaborCostPerSquareFoot, bool expectedResult)
{
OrderManager manager = new OrderManager(new OrderTestRepository(), new StateTaxTestRepository(), new ProductTestRepository());
Order order = new Order();
order.OrderDate = DateTime.Parse(OrderDate);
order.OrderNumber = OrderNumber;
order.CustomerName = CustomerName;
order.Area = Area;
order.State = State;
order.TaxRate = TaxRate;
order.ProductType = Product;
order.CostPerSquareFoot = CostPerSquareFoot;
order.LaborCostPerSquareFoot = LaborCostPerSquareFoot;
order.LaborCost = order.Area * order.LaborCostPerSquareFoot;
order.MaterialCost = order.Area * order.CostPerSquareFoot;
order.Tax = ((order.MaterialCost + order.LaborCost) * (order.TaxRate / 100));
order.Total = (order.MaterialCost + order.LaborCost + order.Tax);
OrderLookupResponse response = manager.RemoveOrder(order, order.OrderDate);
Assert.AreEqual(expectedResult, response.Success);
}
public void CheckEdit()
{
OrderManager manager = OrderFactory.Create();
Order order = new Order
{
OrderNumber = 212,
CustomerName = "Duck Duck",
State = "New York",
TaxRate = 8,
ProductType = "Wood",
Area = 900,
CostPerSquareFoot = 5,
LaborCostPerSquareFoot = 10,
OrderDate = new DateTime(2018, 05, 25)
};
manager.EditOrder(order);
OrderLookupResponse response = manager.LookupOrder(order.OrderNumber, order.OrderDate);
Assert.IsNotNull(response.Order);
Assert.AreEqual(response.Order.CustomerName, order.CustomerName);
Assert.AreEqual(response.Order.State, order.State);
Assert.AreEqual(response.Order.TaxRate, order.TaxRate);
Assert.AreEqual(response.Order.ProductType, order.ProductType);
Assert.AreEqual(response.Order.Area, order.Area);
Assert.AreEqual(response.Order.CostPerSquareFoot, order.CostPerSquareFoot);
Assert.AreEqual(response.Order.LaborCostPerSquareFoot, order.LaborCostPerSquareFoot);
Assert.AreEqual(response.Order.OrderDate, order.OrderDate);
}
public OrderLookupResponse DeleteOrder(int orderNumber, string date)
{
Validation validate = new Validation();
OrderDateExist dateExist = new OrderDateExist();
dateExist.IsDateFormatOk = validate.ValidFormat(date);
dateExist.DoesOrderDateExist = _orderRepository.FindDate(date);
OrderLookupResponse response = new OrderLookupResponse();
response.Order = _orderRepository.LoadOrder(orderNumber);
if (dateExist.IsDateFormatOk == false)
{
response.Message = "Order date format was invalid.";
return(response);
}
if (dateExist.DoesOrderDateExist && response.Order != null)
{
response.Success = true;
response.Order = _orderRepository.DeleteOrder(orderNumber, date);
return(response);
}
else
{
response.Success = false;
response.Message = $"Order Number: {orderNumber} does not exist in file.";
}
return(response);
}
public void Execute()
{
Console.Clear();
Console.WriteLine("Lookup an Order");
Console.WriteLine("---------------------");
Console.WriteLine("Enter an order date: ");
string userInput = Console.ReadLine();
var path = ConsoleIO.UserDateValidateToString(userInput);
OrderManager manager = OrderManagerFactory.Create(path);
OrderLookupResponse respose = manager.LookupOrders(path);
if (respose.Success)
{
ConsoleIO.DisplayOrderDetails(respose.orders, ConsoleIO.UserDateValidateToString(userInput));
}
else
{
Console.WriteLine("An error has occurred: ");
Console.WriteLine(respose.Message);
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public void CanEditOrder()
{
DateTime orderDate = new DateTime(2017, 03, 03);
int orderNumber = 1;
OrderManager manager = new OrderManager(new OrderRepository(), new ProductRepository(), new TaxesRepository());
OrderLookupResponse response = manager.FindSelectOrder(orderNumber, orderDate);
Order selectOrder = response.IndivOrder;
//edit the order
selectOrder.CustomerName = "Goliath";
selectOrder.ProductType = "Laminate";
//load edited order back
manager.editOrder(selectOrder, orderDate);
//Load edited order again
OrderLookupResponse verify = manager.FindSelectOrder(orderNumber, orderDate);
Order checker = verify.IndivOrder;
//check new edited information
Assert.AreEqual("Goliath", checker.CustomerName);
Assert.AreEqual("Laminate", checker.ProductType);
//check unchanged information stayed the same
Assert.AreEqual("OH", checker.State);
Assert.AreEqual(100, checker.Area);
}
public void CanLookupOrders()//tests ability get order data from mock file repo and return the list of orders
{
DateTime date = new DateTime(2013, 06, 01);
OrderManager manager = OrderManagerFactory.Create();
OrderLookupResponse response = manager.LookupOrders(date);
Assert.IsNotNull(response.ListOfOrders);
Assert.IsTrue(response.Success);
Assert.AreEqual(3, response.ListOfOrders.Count);
Order check = response.ListOfOrders[2];
Assert.AreEqual(3, check.OrderNumber);
Assert.AreEqual("Jake", check.CustomerName);
Assert.AreEqual("OH", check.State);
Assert.AreEqual(6.25M, check.TaxRate);
Assert.AreEqual("Tile", check.ProductType);
Assert.AreEqual(700, check.Area);
Assert.AreEqual(3.50M, check.CostPerSquareFoot);
Assert.AreEqual(4.15M, check.LaborCostPerSquareFoot);
Assert.AreEqual(2450, check.MaterialCost);
Assert.AreEqual(2905, check.LaborCost);
Assert.AreEqual(334.687500, check.Tax);
Assert.AreEqual(5689.687500, check.Total);
}
public void CanDeleteOrder(int orderNumber, string date, bool expected)
{
DateTime orderDate = DateTime.Parse(date);
Order _order = new Order
{
OrderDate = DateTime.Parse("08/07/2020"),
OrderNumber = 100,
CustomerName = "Chuck Testa",
State = "OH",
TaxRate = 6.25m,
ProductType = "Carpet",
Area = 100.5m,
CostPerSquareFoot = 2.25m,
LaborCostPerSquareFoot = 2.25m,
};
OrderManager orderManager = new OrderManager(orderRepo);
AddOrderResponse addOrderResponse = orderManager.AddOrder(_order);
OrderLookupResponse orderLookup = orderManager.LookupOrder(orderNumber, orderDate);
if (orderLookup.Success)
{
DeleteOrderResponse deleteOrderResponse = orderManager.DeleteOrder(orderLookup.Order);
Assert.AreEqual(expected, deleteOrderResponse.Success);
}
else
{
Assert.AreEqual(expected, orderLookup.Success);
}
}
public void CanAddOrderToFile()
{
if (File.Exists(filepath))
{
File.Delete(filepath);
}
OrderManager manager = OrderManagerFactory.Create();
Order newOrder = new Order();
DateTime date = new DateTime(2018, 01, 01);
newOrder.OrderDate = date;
newOrder.CustomerName = "Bill Johnson";
newOrder.State = "PA";
newOrder.ProductType = "Wood";
newOrder.Area = 300;
manager.AddProductToOrder(newOrder);
manager.AddStateToOrder(newOrder);
manager.SaveOrder(newOrder);
OrderLookupResponse response = manager.LookupOrders(newOrder.OrderDate);
Assert.AreEqual(2, response.ListOfOrders.Count);
}
public void Execute()
{
string date;
do
{
Console.Clear();
Console.Write("Enter Date <MM/DD/YYY>: ");
} while (!Validation.OrderDateValidation(Console.ReadLine(), false, out date));
OrderLookupResponse response = OrderManagerFactory.Create().LookupOrders(date);
if (response.Success)
{
Console.Clear();
foreach (var order in response.Orders)
{
Console.WriteLine(border);
// information is pass into Display Method
Output.DisplayIO.DisplayOrderSummary(date, order);
Console.WriteLine(border);
}
}
else
{
Console.WriteLine(response.Message);
}
Console.ReadKey();
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Lookup an order");
Console.WriteLine("-------------------------");
Console.Write("Enter the date you are interested in (use MMDDYYYY format):");
string orderDate = Console.ReadLine();
//validation date but make sure to get rid of forward slashes
OrderLookupResponse response = manager.LookupOrder(orderDate);
if (response.Success)
{
ConsoleIO.DisplayOrderDetails(response.Orders, orderDate);
}
else
{
Console.WriteLine("An error occurred: ");
Console.WriteLine(response.Message);
}
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
}
