public static void RequestingToSaveOrder(string orderDate, Order order)
{
string placeOrder = "";
while (true)
{
Console.Clear();
Output.DisplayIO.DisplayOrderSummary(orderDate, order);
Console.Write("Do you want to save this order (Y/N): ");
switch (placeOrder = Console.ReadLine())
{
case "Y":
//Saved order number for the next availabe order #
SaveOrderResponse response = OrderManagerFactory.Create().SaveOrder(orderDate, order);
Console.WriteLine("Saving to repository: {0}", response.Success ? "Successful" : "Failed");
Console.ReadKey();
return;
case "N":
Console.WriteLine("You Didn't save the new order to repository");
Console.ReadKey();
return;
}
}
}
public string CreateNewOrder([FromBody] string req)
{
var result = String.Empty;
var request = new SaveOrderRequest();
var response = new SaveOrderResponse();
try
{
OrderService service = new OrderService();
request = JsonConvert.DeserializeObject <SaveOrderRequest>(req);
ClaimsIdentity identity = (ClaimsIdentity)User.Identity;
int userID = Int32.Parse(identity.Claims.Where(x => x.Type == "UserID").First().Value);
if (request.Order.OrderTypeID == (byte)EOrderTypes.Online)
{
request.Order.CustomerID = userID;
}
response = service.PerformCreateNewOrder(request);
}
catch (Exception ex)
{
response = new SaveOrderResponse()
{
MessageString = ex.Message,
MessageStatusID = (byte)EMessageStatus.Success
};
}
result = JsonConvert.SerializeObject(response);
return(result);
}
public string UpdateOrderStatus([FromBody] string req)
{
var result = String.Empty;
var request = new UpdateOrderRequest();
var response = new SaveOrderResponse();
try
{
using (var db = new CuddlyWombatEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Configuration.ProxyCreationEnabled = false;
request = JsonConvert.DeserializeObject <UpdateOrderRequest>(req);
OrderService service = new OrderService();
response = service.PerformUpdateOrderStatus(request);
}
}
catch (Exception ex)
{
response = new SaveOrderResponse()
{
MessageString = ex.Message,
MessageStatusID = (byte)EMessageStatus.Success
};
}
result = JsonConvert.SerializeObject(response);
return(result);
}
public SaveOrderResponse PerformCreateNewOrder(SaveOrderRequest request)
{
SaveOrderResponse response = new SaveOrderResponse();
try
{
using (var db = new CuddlyWombatEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Configuration.ProxyCreationEnabled = false;
db.Orders.Add(request.Order);
db.SaveChanges();
foreach (var o in request.OrderMenuItems)
{
o.OrderID = request.Order.OrderID;
db.OrderMenuItems.Add(o);
}
db.SaveChanges();
response.MessageString = "New Order is successfully created";
response.MessageStatusID = (byte)EMessageStatus.Success;
}
}
catch (Exception ex)
{
response.MessageStatusID = (byte)EMessageStatus.Exception;
response.MessageString = ex.Message;
}
return(response);
}
public void SaveOrderTest()
{
OrderManager manager = OrderManagerFactory.Create();
SaveOrderResponse response = manager.SaveOrder("01012020", "Ima Customer", "OH", "Tile", "99");
Assert.AreEqual(response.Order.CustomerName, "Ima Customer");
}
public SaveOrderResponse SaveOrder(SaveOrderRequest request)
{
var response = new SaveOrderResponse();
try
{
var basketRecord = new BasketRecord
{
DeliveryType = request.DeliveryType,
Total = request.GrandTotal,
Voucher = request.Voucher,
User = _database.Query <UserRecord>().First(x => x.Id == request.UserId),
Status = request.Status
};
_database.Save(basketRecord);
var basketId = _database.Query <BasketRecord>().OrderByDescending(x => x.Id).FirstOrDefault()?.Id;
foreach (var order in request.Orders)
{
var orderRecord = new OrderRecord
{
Basket = _database.Query <BasketRecord>().First(x => x.Id == basketId),
Pizza = _database.Query <PizzaRecord>().First(x => x.Id == order.PizzaId),
Size = _database.Query <SizeRecord>().First(x => x.Id == order.SizeId),
Total = order.SubTotal
};
_database.Save(orderRecord);
var orderId = _database.Query <OrderRecord>().OrderByDescending(x => x.Id).FirstOrDefault()?.Id;
foreach (var toppingId in order.ExtraToppingIds)
{
var basketToppingRecord = new OrderToppingRecord
{
Order = _database.Query <OrderRecord>().First(x => x.Id == orderId),
Topping = _database.Query <ToppingRecord>().First(x => x.Id == toppingId)
};
_database.Save(basketToppingRecord);
}
}
}
catch (Exception exception)
{
response.AddError(new Error
{
Code = ErrorCodes.DatabaseError,
UserMessage = "Something went wrong when saving Order to database.",
TechnicalMessage = $"Following exception was thrown: {exception.Message}"
});
}
return(response);
}
public void SetUp()
{
var database = new Mock <IDatabase>();
database.Setup(x => x.Query <UserRecord>()).Throws(new Exception("Something went wrong"));
var subject = new OrderRepository(database.Object);
_result = subject.SaveOrder(new SaveOrderRequest());
}
public void CanOnlySaveValidOrders(string name, decimal area, string productType, string state, bool expected)
{
Order order = new Order();
order.CustomerName = name;
order.Area = area;
order.ProductType = productType;
order.State = state;
OrderValidator validator = new OrderValidator();
SaveOrderResponse actual = validator.SaveOrder(order);
Assert.AreEqual(expected, actual.EverythingIsAlright);
}
public async Task <SaveOrderResponse> SaveAsync(Order order)
{
try
{
await _orderRepository.AddAsync(order);
await _unitOfWork.CompleteAsync();
return(SaveOrderResponse.Successful(order));
}
catch (Exception ex)
{
return(SaveOrderResponse.Error($"An error occured while saving the order: {ex.Message}"));
}
}
public SaveOrderResponse SaveOrder(string date, Order order)
{
SaveOrderResponse response = new SaveOrderResponse();
if (!_orderRepository.SaveOrder(date, order))
{
response.Success = false;
response.Message = $"Unable to save {order.OrderNumber} on {date}";
}
else
{
response.Success = true;
}
return(response);
}
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);
}
public SaveOrderResponse SaveOrder(Order order)
{
SaveOrderResponse finalResponse = new SaveOrderResponse();
AddNameRule nameRule = new AddNameRule();
GetNameResponse nameResponse = new GetNameResponse();
nameResponse = nameRule.GetName(order.CustomerName);
AddAreaRule areaRule = new AddAreaRule();
GetAreaResponse areaResponse = new GetAreaResponse();
areaResponse = areaRule.GetArea(order.Area.ToString());
AddProductRule productRule = new AddProductRule();
GetProductResponse productResponse = new GetProductResponse();
productResponse = productRule.GetProduct(order.ProductType);
AddTaxesRule taxesRule = new AddTaxesRule();
GetTaxesResponse taxesResponse = new GetTaxesResponse();
taxesResponse = taxesRule.GetTaxes(order.State);
finalResponse.NameIsOkay = nameResponse.Success;
finalResponse.AreaIsOkay = areaResponse.Success;
finalResponse.ProductIsOkay = productResponse.Success;
finalResponse.TaxIsOkay = taxesResponse.Success;
if (finalResponse.NameIsOkay && finalResponse.AreaIsOkay && finalResponse.ProductIsOkay && finalResponse.TaxIsOkay)
{
finalResponse.EverythingIsAlright = true;
}
else
{
finalResponse.EverythingIsAlright = false;
}
return(finalResponse);
}
public void Execute()
{
OrderManager manager = OrderManagerFactory.Create();
Console.Clear();
Console.WriteLine("Add an Order");
Console.WriteLine("--------------------------");
Console.Write("Enter the order date (DDMMYYYY): ");
string orderDate = Console.ReadLine();
Console.Write("Enter the customer name: ");
string customerName = Console.ReadLine();
Console.Write("Enter the state abbreviation: ");
string stateAbbreviation = Console.ReadLine();
Console.Write("Enter the product type: ");
string prodType = Console.ReadLine();
Console.Write("Enter the area: ");
string area = Console.ReadLine();
SaveOrderResponse response = manager.SaveOrder(orderDate, customerName, stateAbbreviation, prodType, area);
if (response.Success)
{
Console.WriteLine("The order has been saved.");
}
else
{
Console.WriteLine("An error occurred: ");
Console.WriteLine(response.Message);
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public void SaveOrdersToFile(List <Order> orders, string filePath)
{
SaveOrderResponse[] response = new SaveOrderResponse[orders.Count];
OrderValidator validator = new OrderValidator();
int iterator = 0;
foreach (Order o in orders)
{
response[iterator] = validator.SaveOrder(o);
iterator++;
}
bool justDandy = true;
for (int i = 0; i < response.Length; i++)
{
if (response[i].EverythingIsAlright)
{
continue;
}
else
{
justDandy = false;
}
}
if (justDandy)
{
OrderRepository.SaveOrders(orders, filePath);
}
else
{
throw new Exception("GOD HAS ABANDONED US, THE PROGRAM IS FOR NAUGHT, THE DEVIL HAS TAKEN HUMAN FORM");
}
}
public void SetUp()
{
_database = new Mock <IDatabase>();
_database.Setup(x => x.Query <UserRecord>()).Returns(new List <UserRecord> {
new UserRecord {
Id = 1
}
});
_database.Setup(x => x.Query <BasketRecord>()).Returns(new List <BasketRecord> {
new BasketRecord {
Id = 1
}
});
_database.Setup(x => x.Query <PizzaRecord>()).Returns(new List <PizzaRecord> {
new PizzaRecord {
Id = 2
}
});
_database.Setup(x => x.Query <SizeRecord>()).Returns(new List <SizeRecord> {
new SizeRecord {
Id = 3
}
});
_database.Setup(x => x.Query <OrderRecord>()).Returns(new List <OrderRecord> {
new OrderRecord {
Id = 2
}
});
_database.Setup(x => x.Query <ToppingRecord>())
.Returns(new List <ToppingRecord> {
new ToppingRecord {
Id = 4
}
});
_database.Setup(x => x.Save(It.IsAny <BasketRecord>())).Returns(new BasketRecord {
Id = 1
});
_database.Setup(x => x.Save(It.IsAny <OrderRecord>())).Returns(new OrderRecord {
Id = 2
});
_database.Setup(x => x.Save(It.IsAny <OrderToppingRecord>())).Returns(new OrderToppingRecord {
Id = 3
});
var subject = new OrderRepository(_database.Object);
var saveOrderRequest = new SaveOrderRequest
{
DeliveryType = DeliveryType.Collection.ToString(),
GrandTotal = 1200,
Voucher = "SOME_VOUCHER",
UserId = 1,
Status = OrderStatus.Complete.ToString(),
Orders = new List <Data.Order.Order>
{
new Data.Order.Order
{
SubTotal = 1000,
PizzaId = 2,
SizeId = 3,
ExtraToppingIds = new List <int> {
4
}
}
}
};
_result = subject.SaveOrder(saveOrderRequest);
}
public SaveOrderResponse SaveOrder(
string stringOrderDate,
string customerName,
string state,
string productType,
string area)
{
SaveOrderResponse response = new SaveOrderResponse();
DateTime orderDate;
if (!DateTime.TryParseExact(stringOrderDate, "ddMMyyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None, out orderDate))
{
response.Success = false;
response.Message = ($"{stringOrderDate} is not a valid date.");
return(response);
}
if (orderDate.Date <= DateTime.Today)
{
response.Success = false;
response.Message = "The Order Date must be later than today. ";
return(response);
}
else if (customerName == "")
{
response.Success = false;
response.Message = "The Customer Name must not be blank.";
return(response);
}
else if (taxRep.LoadTax(state) == null)
{
response.Success = false;
response.Message = $"There is no tax rate for {state}.";
return(response);
}
else if (productRep.LoadProduct(productType) == null)
{
response.Success = false;
response.Message = $"There is no {productType} Product Type.";
return(response);
}
else
{
response.Success = true;
Tax tax = taxRep.LoadTax(state);
Product product = productRep.LoadProduct(productType);
decimal taxRate = Convert.ToDecimal(tax.TaxRate);
decimal areaDecimal = Convert.ToDecimal(area);
decimal material = areaDecimal * product.CostPerSquareFoot;
decimal labor = areaDecimal * product.LaborCostPerSquareFoot;
decimal taxTotal = ((material + labor) * (taxRate / 100));
decimal total = material + labor + taxTotal;
Order order = new Order
{
OrderNumber = GetOrderNumber(stringOrderDate),
CustomerName = customerName,
State = state,
TaxRate = taxRate,
ProductType = productType,
Area = Convert.ToInt16(area),
CostPerSquareFoot = product.CostPerSquareFoot,
LaborCostPerSquareFoot = product.LaborCostPerSquareFoot,
MaterialCost = material,
LaborCost = labor,
Tax = taxTotal,
Total = total
};
response.Order = order;
_orderRepository.AddOrder(response.Order, stringOrderDate);
}
return(response);
}
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();
}
public SaveOrderResponse PerformUpdateOrderStatus(UpdateOrderRequest request)
{
SaveOrderResponse response = new SaveOrderResponse();
var modifiedDate = DateTime.Now;
try
{
using (var db = new CuddlyWombatEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Configuration.ProxyCreationEnabled = false;
var orderToUpdate = (from o in db.Orders
where o.OrderID == request.OrderID
select o).FirstOrDefault();
if (orderToUpdate != null)
{
var orderHistory = new OrderHistory()
{
OrderID = orderToUpdate.OrderID,
TableID = orderToUpdate.TableID,
CustomerID = orderToUpdate.CustomerID,
OrderTypeID = orderToUpdate.OrderTypeID,
OrderStatusID = orderToUpdate.OrderStatusID,
TotalPrice = orderToUpdate.TotalPrice,
PickUpTime = orderToUpdate.PickUpTime,
IsPaid = orderToUpdate.IsPaid,
DateCreated = orderToUpdate.DateCreated,
DateModified = modifiedDate
};
db.OrderHistories.Add(orderHistory);
orderToUpdate.OrderStatusID = request.OrderStatusID;
orderToUpdate.DateModified = modifiedDate;
}
else
{
response.MessageString = "Please select an order";
response.MessageStatusID = (byte)EMessageStatus.Fail;
return(response);
}
db.SaveChanges();
if (request.OrderStatusID == (byte)EOrderStatus.Canceled)
{
response.MessageString = "Order is cancelled";
}
else if (request.OrderStatusID == (byte)EOrderStatus.Completed)
{
response.MessageString = "Order Status updated to Completed";
}
response.MessageStatusID = (byte)EMessageStatus.Success;
}
}
catch (Exception ex)
{
response.MessageStatusID = (byte)EMessageStatus.Exception;
response.MessageString = ex.Message;
}
return(response);
}
