public void OrderManagerEditOrderTest(DateTime date, int orderNumber, string customerName, string state, string productType, decimal area, string expectedName, string expectedState, string expectedProduct, decimal expectedArea, bool expectedResult)
{
TestOrderRepository testOrderRepo = new TestOrderRepository();
TestProductRepository testProductRepo = new TestProductRepository();
TestTaxRepository testTaxRepo = new TestTaxRepository();
OrderManager manager = new OrderManager(testOrderRepo, testProductRepo, testTaxRepo);
DisplaySingleOrderResponse singleResponse = manager.GetOrderToEdit(date, orderNumber);
Assert.AreEqual(singleResponse.Order.Date, date);
Assert.AreEqual(singleResponse.Order.OrderNumber, orderNumber);
Assert.AreEqual(singleResponse.Order.CustomerName, customerName);
Assert.AreEqual(singleResponse.Order.State, state);
Assert.AreEqual(singleResponse.Order.ProductType, productType);
Assert.AreEqual(singleResponse.Order.Area, area);
EditOrderResponse response = manager.EditOrder(date, orderNumber, expectedName, expectedState, expectedProduct, expectedArea);
// DisplaySingleOrderResponse afterEditResponse = manager.GetOrderToEdit(date, orderNumber);
if (response.Success)
{
testOrderRepo.UpdateThisOrder(response.Order);
DisplaySingleOrderResponse afterEditResponse = manager.GetOrderToEdit(date, orderNumber);
Assert.AreEqual(afterEditResponse.Order.Date, date);
Assert.AreEqual(afterEditResponse.Order.OrderNumber, orderNumber);
Assert.AreEqual(afterEditResponse.Order.CustomerName, expectedName);
Assert.AreEqual(afterEditResponse.Order.State, expectedState);
Assert.AreEqual(afterEditResponse.Order.ProductType, expectedProduct);
Assert.AreEqual(afterEditResponse.Order.Area, expectedArea);
}
//testOrderRepo.UpdateThisOrder(response.Order);
//Assert.AreEqual(expectedResult,
}
public EditOrderResponse EditOrder(Order order)
{
EditOrderResponse editOrderResponse = new EditOrderResponse();
editOrderResponse.EditedOrder = _orderRepository.LoadOrder(order.OrderDate, order.OrderNumber);
editOrderResponse.StateTax = _taxRepository.LoadTaxes(order.State);
editOrderResponse.ProductType = _productRepository.LoadProducts(order.ProductType);
if (editOrderResponse.StateTax == null)
{
editOrderResponse.Success = false;
editOrderResponse.Message = $"{order.State} is not a state we sell.";
}
else if (editOrderResponse.ProductType == null)
{
editOrderResponse.Success = false;
editOrderResponse.Message = $"{order.ProductType} is not a valid product type.";
}
else
{
editOrderResponse.Success = true;
order.CostPerSquareFoot = editOrderResponse.ProductType.MaterialUnitCost;
order.LaborCostPerSquareFoot = editOrderResponse.ProductType.LaborUnitCost;
order.TaxRate = editOrderResponse.StateTax.TaxRate;
_orderRepository.Edit(order);
}
return(editOrderResponse);
}
public void CanEditOrder(DateTime orderDate, int orderNumber, string newCustomerName, string newState, string newProductType, decimal newArea, bool expected)
{
OrderManager orderManager = OrderManagerFactory.create(orderDate);
TaxManager taxManager = TaxManagerFactory.create();
DisplayTaxResponse taxResponse = taxManager.DisplayTaxResponse(newState);
ProductManager productManager = ProductManagerFactory.create();
DisplayProductResponse productResponse = productManager.DisplayProductResponse(newProductType);
Orders order = new Orders()
{
Area = newArea,
CostPerSquareFoot = productResponse.Products.CostPerSquareFoot,
CustomerName = newCustomerName,
LaborCostPerSquareFoot = productResponse.Products.LaborCostPerSquareFoot,
OrderNumber = orderNumber,
ProductType = productResponse.Products.ProductType,
State = taxResponse.Tax.StateAbbreviation,
TaxRate = taxResponse.Tax.TaxRate,
};
EditOrderResponse orderResponse = orderManager.EditOrder(order);
Assert.AreEqual(orderResponse.Success, expected);
}
public void CanEditOrder(string orderDate, int orderNumber, string customerName, string state, decimal taxRate, string product,
decimal area, decimal costPerFt, decimal laborPerFt, decimal matCost, decimal laborCost, decimal tax,
decimal total, bool expectedResult)
{
OrderManager manager = OrderManagerFactory.Create();
Order editOrder = new Order();
editOrder.OrderDate = orderDate;
editOrder.OrderNumber = orderNumber;
editOrder.CustomerName = customerName;
editOrder.State = state;
editOrder.TaxRate = taxRate;
editOrder.ProductType = product;
editOrder.Area = area;
editOrder.CostPerSquareFoot = costPerFt;
editOrder.LaborCostPerSqareFoot = laborPerFt;
editOrder.MaterialCost = matCost;
editOrder.LaborCost = laborCost;
editOrder.Tax = tax;
editOrder.Total = total;
EditOrderResponse response = manager.EditOrder(orderDate, orderNumber);
Assert.IsNotNull(response.Order);
Assert.AreEqual(response.Success, expectedResult);
}
internal static void Run()
{
Order oldOrder = LookupOrder();
string name = EditCustomerName(oldOrder.CustomerName);
StateTax tax = EditState(oldOrder.StateTax);
Material product = EditProduct(oldOrder.Product);
decimal area = EditArea(oldOrder.Area);
Order newOrder = new Order(oldOrder, name, tax, product, area);
Console.Clear();
ConsoleIO.PrintOrder(newOrder, true);
bool saveEditedOrder = ConsoleIO.ConsoleKeyConfirmationSwitch("Would you like to replace the old order with this updated order?", true);
if (saveEditedOrder)
{
Console.Clear();
Manager manager = ManagerFactory.Create();
EditOrderResponse editResponse = manager.EditOrder(newOrder);
if (editResponse.Success)
{
Console.WriteLine("Order updated successfully.");
}
else
{
Console.WriteLine(editResponse.Message);
}
}
Console.Write("Press any key to continue...");
Console.ReadKey();
}
//public Order EditOrder(int orderNumber, Order updatedOrder)
//{
//}
public EditOrderResponse EditOrderResponse(DateTime orderDate, string custName, string stateAbbrev, string prodType, decimal area, decimal taxRate,
decimal cost, decimal labor, decimal materialCost, decimal laborCost, decimal tax, decimal total)
{
EditOrderResponse response = new EditOrderResponse();
Order order = new Order();
response.Order = order;
//need to get number by next avail order number
//response.Order.OrderNumber = 3;
response.Order.OrderDate = orderDate;
response.Order.CustomerName = custName;
response.Order.State = stateAbbrev;
response.Order.ProductType = prodType;
response.Order.Area = area;
//tax is where response stateAbbrev == tax.StateAbbrev
//prod is where response.ProductType == product.productType
response.Order.TaxRate = taxRate;
response.Order.CostPerSquareFoot = cost;
response.Order.LaborCostPerSquareFoot = labor;
response.Order.LaborCost = laborCost;
response.Order.MaterialCost = materialCost;
//response.TaxRate = tax.TaxRate;
response.Order.Tax = tax;
response.Order.Total = total;
return(response);
}
public void Execute()
{
IUserIO userIO = new UserIO();
userIO.Clear();
FlooringManager manager = FlooringFactoryManager.Create();
userIO.WriteLine("DELETE ORDER:");
userIO.WriteLine("");
userIO.WriteLine(new string('=', 60));
userIO.WriteLine("");
DateTime dateTime = HelperMethods.GetDateTime("Enter the order date: ");
int OrderNumber = HelperMethods.GetIntFromUser("Enter the order number: ");
EditOrderResponse response = new EditOrderResponse();
Order order = manager.GetOrderByOrderNumber(dateTime, OrderNumber);
if (order == null)
{
response.Success = false;
response.Message = "No orders exist with this date.";
}
else
{
userIO.DisplayOrder(order);
if (HelperMethods.GetYesNoAnswerFromUser("Would you like to delete this order?"))
{
manager.DeleteOrder(order);
response.Success = true;
response.Message = "Order successfully deleted.";
}
}
}
public void TestEditOrder(string inputtedDate, int orderNumber, string newCustomerName, string newState,
string newProductType, decimal newArea, ResponseType expectedResult)
{
Manager manager = ManagerFactory.Create(inputtedDate);
EditOrderResponse response = manager.EditOrder(inputtedDate, orderNumber, newCustomerName, newState,
newProductType, newArea);
Assert.AreEqual(expectedResult, response.ResponseType);
}
public EditOrderResponse EditOrder(Orders updatedOrder)
{
EditOrderResponse response = new EditOrderResponse();
response.Orders = updatedOrder;
response.Success = true;
return(response);
}
public void EditRuleTest(DateTime OrderDate, string CustomerName, string State, string ProductType, decimal Area, bool expectedResponse)
{
EditOrderResponse actual = new EditOrderResponse();
IEditOrder Edit = new EditOrderRule();
actual = Edit.EditRules(OrderDate, CustomerName, State, ProductType, Area, actual);
Assert.AreEqual(expectedResponse, actual.success);
}
public EditOrderResponse EditOrderResponse(Orders updatedOrder)
{
EditOrderResponse response = new EditOrderResponse();
_orderRepository.EditOrder(updatedOrder);
response.Success = true;
return(response);
}
internal void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Edit an Order");
Console.WriteLine("------------------------------------");
DateTime date = ConsoleIO.GetDateFromUser();
int orderNumber = ConsoleIO.GetOrderNumberFromUser();
var orderToEdit = manager.GetOrderToEdit(date, orderNumber);
if (!orderToEdit.Success)
{
Console.WriteLine(orderToEdit.Message);
Console.ReadKey();
return;
}
ConsoleIO.DisplayCustomerOrderDetails(orderToEdit.Order);
string editedCustomerName = ConsoleIO.EditCustomerName(orderToEdit.Order.CustomerName);
ConsoleIO.DisplayCustomerOrderDetails(orderToEdit.Order);
string editedState = ConsoleIO.EditState(orderToEdit.Order.State);
ConsoleIO.DisplayCustomerOrderDetails(orderToEdit.Order);
List <Product> products = manager.GetAllProducts();
ConsoleIO.DisplayProductsToUser(products);
string editedProductType = ConsoleIO.EditProductType(orderToEdit.Order.ProductType);
ConsoleIO.DisplayCustomerOrderDetails(orderToEdit.Order);
decimal editedArea = ConsoleIO.EditArea(orderToEdit.Order.Area);
DateTime keepOrderDate = orderToEdit.Order.Date;
int keepOrderNumber = orderToEdit.Order.OrderNumber;
EditOrderResponse response = manager.EditOrder(keepOrderDate, keepOrderNumber, editedCustomerName, editedState, editedProductType, editedArea);
if (!response.Success)
{
Console.WriteLine(response.Message);
Console.ReadKey();
}
else
{
ConsoleIO.DisplayOrderSummary(response.Order);
Console.ReadKey();
if (!ConsoleIO.ConfirmOrderPlacement())
{
ConsoleIO.OrderCancelledMessage();
}
else
{
manager.UpdateThisOrder(response.Order);
ConsoleIO.OrderPlacedMessage();
}
}
}
public EditOrderResponse EditOrder(Order order, DateTime OrderDate, int OrderNumber)
{
EditOrderResponse response = new EditOrderResponse();
response.Order = _orderRepository.EditOrder(order, OrderDate, OrderNumber);
if (response.Order == null)
{
response.Sucess = true;
}
return(response);
}
public void Execute()
{
OrderManager orderManager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Remove Order");
Console.WriteLine("--------------------------------");
DateTime orderDate = ConsoleIO.AskEditDateTime("Enter order date: ");
DisplayOrderResponse displayResponse = orderManager.DisplayOrder(orderDate);
if (displayResponse.Success)
{
ConsoleIO.DisplayListOrderDetails(displayResponse.ListOfOrders);
}
else
{
Console.WriteLine("An error occurerd: ");
Console.WriteLine(displayResponse.Message);
}
int orderNumber = ConsoleIO.GetRequiredIntFromUser("Enter order number: ");
EditOrderResponse editResponse = orderManager.EditOrder(orderDate, orderNumber);
if (!editResponse.Success)
{
Console.WriteLine("An error occured");
Console.WriteLine(editResponse.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
else
{
Console.WriteLine();
ConsoleIO.DisplayOrderDetails(editResponse.Order);
Console.WriteLine();
if (ConsoleIO.GetYesNoAnswerFromUser("Are you sure you want to remove this order?") == "Y")
{
//need to update instead of save.
orderManager.RemoveOrder(editResponse.Order);
Console.WriteLine("Order removed");
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
else
{
Console.WriteLine("Remove Cancelled");
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
}
public EditOrderResponse EditOrder(DateTime OrderDate, string CustomerName, string State, string ProductType, decimal Area)
{
EditOrderResponse response = new EditOrderResponse();
response.Orders = _orderRepository.LoadOrders(OrderDate);
IEditOrder editRule = new EditOrderRule();
response = editRule.EditRules(OrderDate, CustomerName, State, ProductType, Area, response);
return(response);
}
public EditOrderResponse ExportEditOrder(List <Order> orders, Order order, string date, int orderNumber)
{
EditOrderResponse response = new EditOrderResponse();
response.Orders = orders; //the lists of orders with that order date
response.Order = order; //the edited order
var orderIndex = orders.FindIndex(o => o.OrderNumber == orderNumber); //find index where to replace the edited order
orders.RemoveAt(orderIndex); //removes the old order
orders.Insert(orderIndex, order); //replace the old order index with the edited one
_orderRepository.OverwriteFile(orders, date); //sends orders to be exported to file
response.Success = true;
return(response);
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Edit order");
Console.WriteLine("--------------------------");
Console.Write("Enter the order date (DDMMYYYY):");
string orderDate = Console.ReadLine();
Console.Write("Enter the order number: ");
string orderNumber = Console.ReadLine();
LookupOrderResponse response = manager.LookupOrder(orderDate, orderNumber);
if (response.Success)
{
Console.Write("Customer Name: ");
SendKeys.SendWait(Convert.ToString(response.Order.CustomerName));
string newCustomerName = Console.ReadLine();
Console.Write("State: ");
SendKeys.SendWait(Convert.ToString(response.Order.State));
string newState = Console.ReadLine();
Console.Write("Product Type: ");
SendKeys.SendWait(Convert.ToString(response.Order.ProductType));
string newProductType = Console.ReadLine();
Console.Write("Area: ");
SendKeys.SendWait(Convert.ToString(response.Order.Area));
string newArea = Console.ReadLine();
Console.Write("Save changes? (Y/N):");
string saveInput = Console.ReadLine();
if (saveInput == "Y")
{
EditOrderResponse editResponse = manager.EditOrder(orderDate, orderNumber, newCustomerName,
newState, newProductType, newArea);
}
}
else
{
Console.WriteLine("An error occurred: ");
Console.WriteLine(response.Message);
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public async Task Test_editorder()
{
//----------------------------------------------------------------------------
// submit bid
//----------------------------------------------------------------------------
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.limit,
label = "mylabel",
price = 1000,
post_only = true,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
Assert.That(response.order, Is.Not.Null);
// wait
await Task.Delay(1 << 9);
//----------------------------------------------------------------------------
// modify bid
//----------------------------------------------------------------------------
// form request
EditOrderRequest req2 = new EditOrderRequest()
{
order_id = response.order.order_id,
amount = 20,
price = 500,
};
// execute request
EditOrderResponse res2 = await this.deribit.Trading.EditOrder(req2);
// assert
var modifiedorder = res2.order;
Assert.That(modifiedorder.order_id, Is.EqualTo(req2.order_id));
Assert.That(modifiedorder.amount, Is.EqualTo(req2.amount));
Assert.That(modifiedorder.price, Is.EqualTo(req2.price));
//----------------------------------------------------------------------------
// cleanup
var response2 = await this.deribit.Trading.CancelAll();
// assert
Assert.That(response2.cancelledcount, Is.GreaterThan(0));
}
public EditOrderResponse EditOrder(Order order, DateTime orderDate, string newCustomerName, string newStateName, string newProductType, decimal newArea)
{
List <Order> Orders = ProductionRepository.GetOrders();
List <Products> Products = ProductionRepository.GetProducts();
List <Taxes> Taxes = ProductionRepository.GetTaxes();
EditOrderResponse response = new EditOrderResponse();
if (!Orders.Any(o => o.OrderDate == orderDate))
{
response.Success = false;
response.Message = "Error: That Order Cannot be Found in Our System. Please Check Date and Re-Enter.";
return(response);
}
if (!Taxes.Any(t => t.StateAbbreviation == newStateName))
{
response.Success = false;
response.Message = "Error: Incorrect State Code - Please Check Records and Re-Enter.";
return(response);
}
if (!Products.Any(p => p.ProductType.ToUpper() == newProductType.ToUpper()))
{
response.Success = false;
response.Message = "Error: That is Not a Current Product in Our System.";
return(response);
}
if (newArea <= 0)
{
response.Success = false;
response.Message = "Error: Area Must be a Positive Number.";
return(response);
}
else
{
response.NewCustomerName = newCustomerName;
response.NewStateName = newStateName;
response.NewProductType = newProductType;
response.NewArea = newArea;
response.Success = true;
response.Message = "Order Successfully Changed!";
return(response);
}
}
public EditOrderResponse EditOrder(Order editOrder)
{
EditOrderResponse response = new EditOrderResponse();
if (_orderRepository.GetAllOrders(editOrder.Date).Any(x => x.OrderNumber == editOrder.OrderNumber))
{
response.Success = true;
response.Message = "An order is being edited";
}
else
{
response.Success = false;
response.Message = "This order cannot be edited, because it does not exist";
}
return(response);
}
public EditOrderResponse EditOrder(Orders newOrdersInfo)
{
EditOrderResponse response = new EditOrderResponse();
if (_order.Update(newOrdersInfo))
{
response.Success = true;
response.order = newOrdersInfo;
}
else
{
response.Success = false;
response.Message = "It's invalid";
}
return(response);
}
public EditOrderResponse EditOrder(Orders order, DateTime orderDate)
{
EditOrderResponse response = new EditOrderResponse();
try
{
_orderRepository.EditOrder(order, orderDate);
response.Success = true;
}
catch (Exception e)
{
response.Message = "The edited order was not saved. Contact IT.";
throw;
}
return(response);
}
public EditOrderResponse EditOrder(Orders order)
{
EditOrderResponse editResponse = new EditOrderResponse();
if (!_orderRepository.EditOrder(order))
{
editResponse.Success = false;
editResponse.Message = $"Cannot edit {order.OrderNumber}.";
}
else
{
editResponse.Success = true;
editResponse.Message = $"Successfully edited order {order.OrderNumber}.";
}
return(editResponse);
}
public EditOrderResponse EditOrder(string datestring, FlooringOrder newOrder)
{
EditOrderResponse response = new EditOrderResponse();
try
{
_orderRepository.Update(datestring, newOrder);
}
catch (Exception e)
{
response.Success = false;
response.Message = e.Message;
}
response.Success = true;
response.newOrder = newOrder;
return(response);
}
public EditOrderResponse EditOrder(Order oldOrder, Order newOrder, DateTime orderDate, int orderNumber)
{
EditOrderResponse response = new EditOrderResponse();
response.NewOrder = newOrder;
response.Success = _ordersRepository.EditOrder(oldOrder, newOrder, orderDate, orderNumber);
if (!response.Success)
{
response.Message = $"Your order was not successfully edited, try again later.";
}
else
{
response.OldOrder = RemoveOrder(oldOrder.OrderNumber, oldOrder.Date).Order;
response.NewOrder = AddOrder(newOrder).Order;
response.Message = $"Your order was successfuly edited.";
}
return(response);
}
public EditOrderResponse EditOrder(DateTime orderDate, int orderNumber)
{
EditOrderResponse response = new EditOrderResponse();
response.Order = _orderRepo.LoadOrder(orderDate, orderNumber);
if (response.Order == null)
{
response.Success = false;
response.Message = "Invalid order number entry";
}
else
{
response.Success = true;
}
return(response);
}
public EditOrderResponse EditOrder(Order newOrder)
{
EditOrderResponse response = new EditOrderResponse()
{
NewOrder = newOrder
};
try
{
_orderRepo.ReplaceOrder(newOrder);
response.Success = true;
}
catch (Exception e)
{
response.Success = false;
response.Message = "Error: something went wrong while trying to save the order to the repository. Contact IT.\n" + $"({e.Message})";
}
return(response);
}
public EditOrderResponse EditOrder(string date, int orderNumber)
{
EditOrderResponse response = new EditOrderResponse();
var orders = _orderRepository.ReadOrders(date); //returns list of all orders from that order date
try
{
response.Orders = orders; //returns the lists of orders with that order date
var orderToBeEdited = response.Orders.FirstOrDefault(o => o.OrderNumber == orderNumber); //filtered out one to be edited
response.Order = orderToBeEdited; //returns the order to be edited
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <IHttpActionResult> Edit([FromUri] Guid OrderId, [FromBody] EditOrderRequest request)
{
try
{
if (request.Amount <= 0)
{
return(BadRequest());
}
var order = await _repository.Get <Order>(OrderId);
if (order == null)
{
return(NotFound());
}
order.ClientId = request.ClientId;
order.Description = request.Description;
order.Amount = request.Amount;
var rows = await _repository.Save(order);
if (rows == 0)
{
return(BadRequest());
}
order = await _repository.Get <Order>(order.Id);
var response = new EditOrderResponse
{
Result = order
};
return(Ok(response));
}
catch (Exception)
{
// TODO: Log exception
}
return(InternalServerError());
}
public void CanEditOrder(string name, string state, string productType, decimal area, bool expected)
{
OrderManager orderManager = new OrderManager(orderRepo);
Order editOrder = new Order
{
OrderNumber = 99,
OrderDate = DateTime.Parse("08/07/2020"),
CustomerName = name,
State = state,
TaxRate = 6.25m,
ProductType = productType,
Area = area,
CostPerSquareFoot = 2.25m,
LaborCostPerSquareFoot = 2.25m
};
OrderLookupResponse ogOrder = orderManager.LookupOrder(editOrder.OrderNumber, editOrder.OrderDate);
EditOrderResponse editResponse = orderManager.EditOrder(ogOrder.Order, editOrder);
Assert.AreEqual(expected, editResponse.Success);
}
