public Model.Order CreateOrder(Model.Order order)
{
Entity.Order added = _context.Orders.Add(_mapper.ParseOrder(order, true)).Entity;
_context.SaveChanges();
_context.ChangeTracker.Clear();
return(_mapper.ParseOrder(added));
}
public Entity.Order ParseOrder(Model.Order order, bool create)
{
if (order is null)
{
return(null);
}
if (create)
{
return(new Entity.Order
{
DateCreated = order.DateCreated,
CustomerId = order.CustomerId,
StoreId = order.LocationId,
Total = order.Total,
Placed = order.Closed
});
}
else
{
return(new Entity.Order
{
Id = order.Id,
DateCreated = order.DateCreated,
CustomerId = order.CustomerId,
StoreId = order.LocationId,
Total = order.Total,
Placed = order.Closed
});
}
}
public Model.Order AddOrder(Model.Order newOrder, Model.Location location)
{
Entity.Order DBOrder = new Entity.Order {
Cusername = newOrder.Customer.UserName,
LocationId = location.LocationID,
Orderdate = newOrder.Orderdate,
Total = newOrder.Total
};
_context.Orders.Add(DBOrder);
_context.SaveChanges();
List <Model.Item> items = newOrder.Items;
foreach (Model.Item item in items)
{
_context.Items.Add(
new Entity.Item {
LocationId = DBOrder.LocationId,
OrderId = DBOrder.OrderId,
ProductName = item.Product.ProductName,
Price = item.Product.Price,
Quantity = item.Quantity
}
);
changeInventory(location, item, -1 * item.Quantity);
}
_context.SaveChanges();
return(newOrder);
}
public Model.Order UpdateOrder(Model.Order order, Model.Location location, Model.Customer customer)
{
Entity.Order updateOrder = _context.Orders.Single(ord => ord.OrderId == order.OrderID);
updateOrder.Total = order.Total;
_context.SaveChanges();
Log.Information("DL persisted order update to DB");
return(order);
}
public Model.Order ParseOrder(Entity.Order order)
{
Model.Order newOrder = new Model.Order(order.Date);
newOrder.OrderID = order.OrderId;
newOrder.Total = decimal.ToDouble(order.Total);
newOrder.Customer = ParseCustomer(order.Cust);
newOrder.Location = ParseLocation(order.Location);
return(newOrder);
}
public Entity.Order ParseOrder(Model.Order order)
{
return(new Entity.Order
{
CustomerName = order.CustomerName,
ProdID = order.ProdID,
OrderQuantity = order.OrderQuantity,
OrderTotal = order.OrderTotal
});
}
public Entity.Order ParseOrder(Model.Order order)
{
return(new Entity.Order
{
CustomerID = order.CustID,
LocationID = order.LocID,
ProductID = order.ProID,
Quantity = order.Quantity,
Total = order.Total,
});
}
public Entity.Order ParseOrder(Model.Order order)
{
return(new Entity.Order
{
Total = Convert.ToDecimal(order.Total),
Date = order.Date,
CustId = order.Customer.CustID,
LocationId = order.Location.LocationID,
//Cust = ParseCustomer(order.Customer),
//Location = ParseLocation(order.Location)
});
}
public Model.Order AddOrder(Model.Order order, Model.Location location, Model.Customer customer)
{
_context.Orders.Add(
new Entity.Order {
LocationId = order.LocationID,
CustomerId = order.CustomerID,
Total = order.Total,
OrderDate = order.OrderDate
}
);
Log.Information("DL persisted order add to DB");
_context.SaveChanges();
return(order);
}
//to DB(createorder)
public Entity.StoreOrder ParseOrder(Model.Order order)
{
if (order.Id == null)
{
return(new Entity.StoreOrder
{
Customer = order.Customer.Id,
Location = order.Location.Id,
Total = order.Total
});
}
return(new Entity.StoreOrder
{
Customer = order.Customer.Id,
Total = order.Total,
Location = order.Location.Id,
Id = (int)order.Id
});
}
public Entity.Order ToEntity(Model.Order order)
{
List <Entity.LineItem> items = new List <Entity.LineItem>();
if (order.LineItems is not null && order.LineItems.Count > 0)
{
foreach (Model.LineItem item in order.LineItems)
{
items.Add(ToEntity(item));
}
}
return(new Entity.Order {
CustomerId = order.CustomerId,
StoreId = order.LocationId,
Placed = order.Closed,
DateCreated = order.DateCreated,
LineItems = items
});
}
public Entity.Order ParseOrder(Model.Order order)
{
if (order.OrderID == null)
{
return(new Entity.Order()
{
OrderCustomer = (int)order.CustomerID,
OrderLocation = (int)order.LocationID,
//OrderDate = order.OrderDate
OrderItems = order.OrderItems.Select(x => ParseOrderItems(x)).ToList()
});
}
return(new Entity.Order
{
Id = (int)order.OrderID,
OrderCustomer = (int)order.CustomerID,
OrderLocation = (int)order.LocationID,
//OrderDate = order.OrderDate
});
}
public void PlaceOrder(Models.Order order)
{
Entities.StoreOrder o = new Entities.StoreOrder();
if (order.Location.LocationID != null)
{
o.LocationId = (int)order.Location.LocationID;
}
if (order.Customer.CustomerID != null)
{
o.CustomerId = (int)order.Customer.CustomerID;
}
o.CheckedOut = DateTime.Now;
ctx.StoreOrders.Add(o);
foreach (Models.Item i in order.Items)
{
Entities.OrderItem oi = new Entities.OrderItem();
if (i.Product.ProductID != null)
{
oi.ProductId = (int)i.Product.ProductID;
}
oi.Quantity = i.Quantity;
o.OrderItems.Add(oi);
}
ctx.SaveChanges();
try {
transaction.Commit();
using var log = new LoggerConfiguration()
.WriteTo.File("log.txt", rollingInterval: RollingInterval.Day, shared: true)
.CreateLogger();
log.Information("TRANSACTION: Committed");
transaction.Dispose();
transaction = ctx.Database.BeginTransaction();
} catch (Exception e) {
Console.WriteLine(e.StackTrace);
using var log = new LoggerConfiguration()
.WriteTo.File("log.txt", rollingInterval: RollingInterval.Day, shared: true)
.CreateLogger();
log.Information("TRANSACTION: Rolled back due to database throwing exception");
transaction.Rollback();
}
}
public Models.Order ParseOrder(Entities.StoreOrder order)
{
Models.Order o = new Models.Order();
o.OrderID = order.OrderId;
o.Customer = ParseCustomer(order.Customer);
o.Location = ParseLocation(order.Location);
o.CheckedOut = order.CheckedOut != null;
if (o.CheckedOut)
{
o.CheckoutTimestamp = (DateTime)order.CheckedOut;
}
List <Models.Item> items = new List <Models.Item>();
foreach (Entities.OrderItem item in order.OrderItems)
{
Models.Item i = new Models.Item();
i.Product = ParseProduct(item.Product);
i.Quantity = item.Quantity;
items.Add(i);
}
o.Items = items;
return(o);
}
public Entity.Order ParseOrder(Model.Order order)
{
//when customer has no orders, NO id is set
if (order.Id == 0)
{
return(new Entity.Order
{
Total = order.Total,
Date = order.Date,
CustomerId = order.CustomerId,
LocationId = order.LocationId
});
}
//for updating and deleting
return(new Entity.Order
{
Total = order.Total,
Date = order.Date,
CustomerId = order.CustomerId,
LocationId = order.LocationId,
Id = order.Id
});
}
static void Login()
{
string name;
do
{
name = userInterface.GetLine("Enter your name: ");
} while (name.Equals(""));
currentUser = dataStore.GetCustomer(name);
if (currentUser == null)
{
currentUser = new StoreModels.Customer();
currentUser.Name = name;
currentUser.CustomerID = dataStore.AddCustomer(name, currentUser);
}
cart = new StoreModels.Order();
cart.Customer = currentUser;
managerMenu = false;
if (currentUser.IsManager)
{
managerMenu = userInterface.GetLine("Would you like to log in as a manager? [ y / N ]: ").ToLower().Equals("y");
}
Console.Clear();
}
public Model.Order AddOrder(Model.Order newOrder)
{
_context.Orders.Add(_mapper.ParseOrder(newOrder));
_context.SaveChanges();
return(newOrder);
}
public Entities.StoreOrder ParseOrder(Models.Order order)
{
return(new Entities.StoreOrder());
}
static bool MainMenu()
{
while (currentUser != null)
{
userInterface.PrintText("Welcome, " + currentUser.Name);
userInterface.PrintText(
"Please choose an option to continue...\n" +
(managerMenu ? "[0] View inventory changes\n" : "[0] View cart\n") +
(managerMenu ? "[1] Restock item\n" : (cart.CheckedOut ? "[1] Check Cart Inventory\n" : "[1] Add item to cart\n")) +
"[2] Search for items\n" +
(cart.CheckedOut ? "[3] Repeat Order\n" : (managerMenu ? "[3] Save inventory changes\n" : "[3] Check Out\n")) +
(managerMenu ? "[4] View order history\n" : (cart.CheckedOut ? "[4] Close previous order\n" : "[4] View Previous Order\n")) +
"[5] Log Out\n" +
"[6] Exit"
);
switch (userInterface.GetLine())
{
case "0": // View cart
Console.Clear();
ViewCartMenu();
break;
case "1": // Search available items & add to cart | Check inventory of items in cart
Console.Clear();
if (cart.CheckedOut)
{
string inventoryLog = "Checking whether all products from this order are still in stock\n";
bool canReorder = true;
foreach (Item item in cart.Items)
{
int curInventory = dataStore.GetLocationInventory(cart.Location, item.Product);
inventoryLog += "\n" + item.Product.ProductName + " in stock: " + curInventory + " (ordered " + item.Quantity + ')';
if (curInventory < item.Quantity)
{
canReorder = false;
}
}
inventoryLog += "\n\nYour order is" + (canReorder ? "" : " not") + " in stock.";
userInterface.PrintResult(inventoryLog);
break;
}
AddToCartMenu();
break;
case "2": // Search full item list
Console.Clear();
ListProductsMenu();
break;
case "3": // Check out | Copy Cart
Console.Clear();
if (cart.CheckedOut)
{
bool canReorder = true;
foreach (Item item in cart.Items)
{
int curInventory = dataStore.GetLocationInventory(cart.Location, item.Product);
if (curInventory < item.Quantity)
{
canReorder = false;
}
}
if (canReorder)
{
Order newCart = cart.copy();
foreach (Item item in cart.Items)
{
dataStore.UpdateLocationInventory(newCart.Location, item.Product, item.Quantity * (managerMenu ? 1 : -1));
}
cart = newCart;
newCart.Customer = currentUser;
userInterface.PrintResult("Copied all items into your cart");
}
else
{
userInterface.PrintResult("Not enough inventory to copy this order");
}
break;
}
if (cart.Items.Count == 0)
{
userInterface.PrintResult("Please add at least one item to your cart first");
break;
}
if (managerMenu || userInterface.GetLine("Your total is " + cart.Total.ToString("C") + "\nCheck out? [ y / N ]: ").ToLower().Equals("y"))
{
userInterface.PrintResult(managerMenu ? "Restock successful" : "Order successful, thanks for shopping with us!");
cart.CheckedOut = true;
cart.CheckoutTimestamp = DateTime.Now;
dataStore.PlaceOrder(cart);
cart = new Order();
cart.Customer = currentUser;
}
Console.Clear();
break;
case "4": // View previous order | return to current order
Console.Clear();
if (cart.CheckedOut)
{
cart = new Order();
cart.Customer = currentUser;
break;
}
bool sortByPrice = userInterface.GetLine("Sort by price? (default: date) [ y / N ]: ").ToLower().Equals("y");
bool desc = userInterface.GetLine("Use descending order? [ y / N ]: ").ToLower().Equals("y");
string loc = userInterface.GetLine("Enter a location to filter by or press enter to view all orders: ");
List <Order> previousOrders = managerMenu ? dataStore.GetAllOrders() : dataStore.GetCustomerOrders(currentUser);
if (!loc.Equals(""))
{
for (int i = previousOrders.Count - 1; i >= 0; i--)
{
if (previousOrders[i].Location.LocationName.Equals(loc))
{
continue;
}
previousOrders.RemoveAt(i);
}
}
if (sortByPrice)
{
previousOrders.Sort((o1, o2) => {
decimal diff = o1.Total - o2.Total;
if (diff == 0)
{
return(0);
}
if (diff < 0)
{
return(-1);
}
return(1);
});
}
if (desc)
{
previousOrders.Reverse();
}
int index = CartSelectMenu(previousOrders);
if (index < 0)
{
break;
}
if (userInterface.GetLine("This will overwrite your current cart\nProceed? [ y / N ]: ").ToLower().Equals("y"))
{
cart = previousOrders[index];
}
Console.Clear();
break;
case "5": // Log out
Console.Clear();
currentUser = null;
break;
case "6": // Exit
Console.Clear();
return(true);
default:
Console.Clear();
userInterface.PrintText("Invalid input, please enter one of the given options");
break;
}
}
return(false);
}
