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