public ActionResult CreateOrder(OrderVM vm)
{
var products = service.GetAllProducts();
var orders = service.GetAllOrders();
var inventory = service.GrabInventory();
var productOrderQTY = vm.OrderLine.OrderQuantity;
int totalQuantity = 0;
foreach (var i in inventory)
{
if (i.ProductId == vm.OrderLine.OrderId)
{
totalQuantity += i.InventoryQuantity;
}
}
if (totalQuantity > vm.OrderLine.OrderQuantity)
{
ModelState.AddModelError("OrderQuantity", "We don't currently have enough of this item in stock.");
vm.Inventory = service.GrabInventory();
vm.Orders = service.GetAllOrders();
vm.OrderLines = service.GetAllOrderLines();
return(View(vm));
}
if (orders.Any(a => a.OrderNumber == vm.Order.OrderNumber))
{
ModelState.AddModelError("OrderNumber", "A order with this number already exists. Please edit the existing order or find the most recent unused order number.");
vm.Inventory = service.GrabInventory();
vm.Orders = service.GetAllOrders();
vm.OrderLines = service.GetAllOrderLines();
return(View(vm));
}
if (!products.Any(a => a.SKU == vm.Product.SKU))
{
ModelState.AddModelError("SKU", "A product with this SKU does not exist in our database. Please add the product first.");
vm.Inventory = service.GrabInventory();
vm.Orders = service.GetAllOrders();
vm.OrderLines = service.GetAllOrderLines();
return(View(vm));
}
if (ModelState.IsValid)
{
//save order
foreach (var p in products)
{
if (p.SKU == vm.Product.SKU)
{
vm.OrderLine.ProductId = p.ProductId;
}
}
service.SaveOrder(vm.Order, vm.OrderLine);
return(RedirectToAction("AllOrders"));
}
else
{
vm.Inventory = service.GrabInventory();
vm.Orders = service.GetAllOrders();
vm.OrderLines = service.GetAllOrderLines();
return(View(vm));
}
}
public OrderVM GetSpecificOrders(int orderId)
{
OrderVM vm = _db.Orders.Where(o => o.Id == orderId).Select(o => new OrderVM
{
Id = o.Id,
Subtotal = o.Subtotal,
Taxes = o.Taxes,
ConvenienceFee = o.ConvenienceFee,
OutOfAreaFee = o.OutOfAreaFee,
Total = o.Total,
TimeOrdered = o.TimeOrdered,
TimePrepared = o.TimePrepared,
TimeDelivered = o.TimeDelivered,
Runner = o.RunnerInfo.Name,
Restaurant = o.Restaurant.Name,
Area = o.SeatInfo.Area.Name,
Section = o.SeatInfo.Section,
Row = o.SeatInfo.Row,
Chair = o.SeatInfo.Chair,
Items = o.OrderItems.Select(i => new OrderItemVM
{
Name = i.Item.Name,
ImageUrl = i.Item.ImageUrl,
Quantity = i.Quantity
}).ToList()
}).FirstOrDefault();
return(vm);
}
public ActionResult Index2(int?id)
{
//Order order = new Order();
//load created order record on to payment homepage
var order = db.Orders.Where(o => o.OrderID == id).FirstOrDefault();
//if (order.OrderID >= 1)
//{
//IF
//order = db.Orders.Where(o => o.OrderID == (OrdersController.getOrderIDs == 0 ? 1 : OrdersController.getOrderIDs)).SingleOrDefault();
//}
//OrderId for GetRequest.
getOrderIDD = order.OrderID;
var model = new OrderVM
{
OrderID = order.OrderID,
AppointmentId = order.AppointmentId,
PatientId = order.PatientId,
PatientName = order.PatientName,
OrderDate = order.OrderDate,
TotalPrice = order.TotalPrice,
LoyaltyPurchase = order.LoyaltyPurchase,
isApproved = order.isApproved
};
//view order on payment page
return(View(model));
}
public ResponseVM CreateOrder(OrderVM model, string email)
{
bool res = false;
if (email != null)
{
_orderRepository.Create(new Order
{
StartDateTime = model.StartDateTime,
EndDateTime = model.EndDateTime,
OrderUserName = email,
OrderTimeNow = DateTime.Now,
AccountId = model.AccountId
});
_commitProvider.Save();
return(new ResponseVM()
{
Result = true,
Message = "Pet Createed"
});
}
else
{
return(new ResponseVM()
{
Result = res,
Message = "Account not Found!"
});
}
}
public JsonResult Edit(OrderVM O)
{
bool status = false;
if (ModelState.IsValid)
{
using (ApplicationDbContext dc = new ApplicationDbContext())
{
Order order = new Order
{
OrderNo = O.OrderNo,
OrderDate = O.OrderDate,
Description = O.Description
};
foreach (var i in O.OrderDetails)
{
order.OrderDetails.Add(i);
}
dc.Entry(order).State = EntityState.Modified;
dc.SaveChanges();
status = true;
}
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status }
});
}
public ActionResult Details(int id)
{
OrderVM model = new OrderVM();
Product entity = _product.GetByID(id);
model.Code = entity.Code;
model.Description = entity.Description;
model.Price = entity.Price;
model.Title = entity.Title;
model.FromtImage = entity.Image;
int quantity = entity.Quantity;
GenericSelectedList <Order> listUser = new GenericSelectedList <Order>();
model.Quantity = listUser.GetSelectedListIthemQuantity(quantity);
List <Images> listImg = _image.GetAll(x => x.Subject_id == id);
foreach (var item in listImg)
{
model.Image.Add(item.Path);
}
return(View(model));
}
public ActionResult Create(OrderVM orderVM)
{
if (ModelState.IsValid)
{
var CustAddress = new customeraddress();
CustAddress.customer = orderVM.customer;
CustAddress.address = orderVM.address;
if (orderVM.customer.ID == 0)
{
db.customeraddresses.Add(CustAddress);
db.SaveChanges();
}
order objOrder = orderVM.order;
objOrder.orderitems = orderVM.orderItems;
objOrder.OrderNo = GenerateOrderNo();
objOrder.AddressID = CustAddress.address.ID;
objOrder.CustomerID = CustAddress.customer.ID;
db.orders.Add(objOrder);
db.SaveChanges();
// return RedirectToAction("OrderSuccess", orderVM);
Session["cart"] = null;
Session["count"] = null;
return(RedirectToAction("Details", "Orders", new { id = objOrder.ID, newOrder = true }));
}
return(View(orderVM));
}
// POST: api/Order
/* [ResponseType(typeof(Order))]
* public IHttpActionResult PostOrder(Order order)
* {
* try
* {
* //Order table
* if (order.OrderID == 0)
* db.Orders.Add(order);
* else
* db.Entry(order).State = EntityState.Modified;
*
* //OrderItems table
* foreach (var item in order.OrderItems)
* {
* if (item.OrderItemID == 0)
* db.OrderItems.Add(item);
* else
* db.Entry(item).State = EntityState.Modified;
* }
*/
//New Order, Checkout
public IHttpActionResult PostOrder(OrderVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//get item by id
var item = db.Items.Find(model.ItemID); //Checks if an entity with the primary key value exists
//save order to Orders table (52-60)
var order = new Order();
order.CustomerID = model.CustomerID;
//save total
order.GTotal = model.Quantity * item.Price; //Calculating Total
order.OrderNo = GetOrderNo(); //At line 70
db.Orders.Add(order); //Add to the order table
db.SaveChanges(); //Saves changes to the DB
//save item order to OrderItems table
db.OrderItems.Add(new OrderItem {
ItemID = model.ItemID, Quantity = model.Quantity, OrderID = order.OrderID
});
db.SaveChanges(); //Saving changes
return(Ok(new { order.OrderNo, order.GTotal }));
}
public OrderTypeModifier(OrderVM order, Action <string, string, string, string, string, string, string> AddCustomer)
{
_order = order;
SelectedOrderType = new OrderTypeModifierValue();
SelectedOrderType = SelectableOrderTypes.FirstOrDefault(n => n.Value == _order.OrderType); //Select from the list of buttons
SelectedOrderType.IsSelected = true;
EnableMask = true;
if (_order._orderHeader.Customer != null)
{
_phone = _order._orderHeader.Customer.vCustPrimaryPh;
_name = _order._orderHeader.Customer.vCustName;
_address1 = _order._orderHeader.Customer.vCustAddress1;
_address2 = _order._orderHeader.Customer.vCustAddress2;
_city = _order._orderHeader.Customer.vCustCity;
_state = _order._orderHeader.Customer.vCustState;
_zipcode = _order._orderHeader.Customer.vCustZipCode;
}
else
{
searchcustomerById(); //Display selected customer information.
}
_addCustomer = AddCustomer;
// SelectOrderTypeCommand.Execute(SelectableOrderTypes.FirstOrDefault(n=>n.Value==order.OrderType));
}
public ActionResult DeleteRange(int id, string SO, string Prdt, int Qty, string Ltype, string Sdate, string Edate, string Search, string LableType, int PageNo = 0)
{
OrderVM obj = new OrderVM();
obj.SO = SO;
obj.Product = Prdt;
obj.Qty = Qty;
obj.LabelType = Ltype;
obj.StartOrderDate = Sdate;
obj.EndOrderDate = Edate;
obj.hiddenSearch = Search;
obj.hiddenType = LableType;
obj.PageNo = PageNo;
var Result = FirelabelModel.OrderInvoiceRanges.Find(id);
if (Result != null)
{
FirelabelModel.OrderInvoiceRanges.Remove(Result);
FirelabelModel.SaveChanges();
}
obj = SearchData(obj);
TempData["OrderVM"] = null;
TempData["OrderVM"] = obj;
return(RedirectToAction("Index"));
}
public ActionResult Index(OrderVM orderVM, string command)
{
if (command.ToUpper().Contains("SEARCH"))
{
orderVM = SearchData(orderVM);
return(View(orderVM));
}
if (command.ToUpper().Contains("EXPORT"))
{
orderVM = ExportData(orderVM);
string html = GenerateHTML(orderVM);
byte[] pdf = GenerateRuntimePDF(html);
Response.Clear();
MemoryStream ms = new MemoryStream(pdf);
Response.ContentType = "application/pdf";
Response.AddHeader("content-disposition", "attachment;filename=Orders.pdf");
Response.Buffer = true;
ms.WriteTo(Response.OutputStream);
Response.End();
}
return(View(orderVM));
}
public ActionResult AddLableNumber(string[] Begin, string[] End, string addSoNumber, OrderVM orderVM)
{
if (Request.Params["hiddenSearch"] != null)
{
orderVM.hiddenSearch = Request.Params["hiddenSearch"];
}
if (Request.Params["hiddenType"] != null)
{
orderVM.hiddenType = Request.Params["hiddenType"];
}
for (int i = 0; i < Begin.Length; i++)
{
OrderInvoiceRange orderInvoiceRange = new OrderInvoiceRange();
orderInvoiceRange.SO = addSoNumber;
orderInvoiceRange.BeginInvoice = Begin[i];
orderInvoiceRange.EndInvoice = End[i];
FirelabelModel.OrderInvoiceRanges.Add(orderInvoiceRange);
FirelabelModel.SaveChanges();
}
orderVM = SearchData(orderVM);
TempData["OrderVM"] = null;
TempData["OrderVM"] = orderVM;
return(RedirectToAction("Index"));
}
public int Save(OrderVM inputVM)
{
OrderDM inputDM = new OrderDM();
inputDM.UserId = inputVM.UserId;
inputDM.ProductId = inputVM.ProductId;
inputDM.Date = inputVM.Date;
inputDM.Quantity = inputVM.Quantity;
inputDM.TotalPrice = inputVM.TotalPrice;
inputDM.Address = inputVM.Address;
inputDM.Township = inputVM.Township;
inputDM.CreatedUserId = inputVM.CreatedUserId;
inputDM.UpdatedUserId = inputVM.UpdatedUserId;
long time = DateTime.Now.Ticks;
inputDM.Version = time;
inputDM.CreatedDate = time;
inputDM.UpdatedDate = time;
int result = 0;
using (PHOTOLIODBContext context = new PHOTOLIODBContext())
{
context.OrderDMs.Add(inputDM);
result = context.SaveChanges();
}
return(result);
}
public IActionResult PostOrder([FromBody] Order order)
{
using (UnitOfWork <Order> uow = new UnitOfWork <Order>(context, false))
{
// save the new order
order.TimeCreate = DateTime.Now;
uow.Repository.Add(order);
uow.SaveChanges();
OrderVM orderVm = new OrderVM();
orderVm.StyleNos = new List <string>();
using (UnitOfWork <Sku> uowsku = new UnitOfWork <Sku>(context, false))
{
List <Sku> skulList = new List <Sku>(); // ???
foreach (var item in order.OrderItems)
{
var sku = uowsku.Repository.Get(s => s.SkuNo == item.SkuNo);
sku.Quantity -= item.Quantity;
uowsku.Repository.Update(sku);
skulList.Add(sku); // ???
orderVm.StyleNos.Add(sku.StyleNo);
}
uowsku.SaveChanges();
}
Order newOrder = uow.Repository.Get(o => o.TimeCreate == order.TimeCreate &&
o.Name == order.Name);
orderVm.OrderId = newOrder.OrderId;
return(Json(orderVm));
}
}
public IActionResult CreateNewOrder(OrderVM orderVM) //orderVM
{
/*
* var orderVM = new OrderVM()
* {
* CustomerId = 1,
* CustomerLatitude = 6.7,
* CustomerLongitude=79,
* SellerId=4,
* Status="to be confirmed",
* Items = new List<ItemVM>()
* {
* new ItemVM()
* {
* ProductId=5,
* Quantity=5
* },
* new ItemVM()
* {
* ProductId=6,
* Quantity=5
* },
* }
* };
*/
return(Ok(_orderService.CreateNewOrder(orderVM)));
}
public ActionResult OrderBook(int id)
{
if (Session["Student"] != null)
{
dynamic student = Session["Student"];
bool isSameBook = _studentManager.IsSameBookBorrow(student.ID, id);
Book book = _studentManager.GetByBookID(id);
OrderVM order = new OrderVM();
order.bcode = book.Code;
order.bName = book.Name;
order.bAuthonerName = book.AuthorName;
order.oDayFor = 7;
order.sID = student.ID;
order.bID = id;
if (!isSameBook)
{
ViewBag.FMsg = "You have already borrow " + order.bName + "(" + order.bcode + ")book before";
return(View(order));
}
return(View(order));
}
return(RedirectToAction("Login", "Home"));
}
public int AddProduct(int productId)
{
try
{
UserViewModel user = _userService.GetCurrentUser(User.Identity.Name);
OrderVM order = _orderService.GetCurrentOrder(user.Id);
int result = _orderService.AddProduct(order.Id, productId, user.Id);
if (result >= 0)
{
Log.Debug($"Product was added successfully. Result: {result}");
return(result);
}
else
{
Log.Debug($"Product was not added successfully. Result: {result}");
return(result);
}
}
catch (Exception ex)
{
Log.Error($"Message: {ex.Message} | Exception: {ex.InnerException}");
}
return(-1);
}
private void FilterByStatus(OrderStatus status)
{
if (ExecutionTreeView == null)
{
return;
}
ICollectionView view = CollectionViewSource.GetDefaultView(ExecutionTreeView.ItemsSource);
view.Filter = delegate(object o)
{
OrderVM ovm = o as OrderVM;
{
if ((int)status == 0)
{
return(true);
}
if (ovm.Status == status)
{
return(true);
}
}
return(false);
};
}
public async Task <IActionResult> UserOrders()
{
var userId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = await userManager.FindByIdAsync(userId);
int sum = 0;
IEnumerable <Order> orders = OrderRepository.GetOrders(user.Id);
UserOrdersVM userOrders = new UserOrdersVM();
foreach (Order o in orders)
{
OrderVM orderVm = new OrderVM();
foreach (OrderedOutfit ob in orderedOutfitRepository.GetOrderedOutfits(o.Id))
{
CartLine ct = new CartLine
{
Outfit = OutfitRepository.Get(ob.OutfitId),
Quantity = ob.Quantity
};
orderVm.Lines.Add(ct);
}
orderVm.OrderId = o.Id;
userOrders.Orders.Add(orderVm);
sum += o.Price;
}
userOrders.Price = sum;
return(View(userOrders));
}
private void RadioButton_Checked_3(object sender, RoutedEventArgs e)
{
if (ExecutionTreeView == null)
{
return;
}
ICollectionView view = CollectionViewSource.GetDefaultView(ExecutionTreeView.ItemsSource);
view.Filter = delegate(object o)
{
OrderVM ovm = o as OrderVM;
if ((int)ovm.Status == 0)
{
return(true);
}
if ((ovm.Status == OrderStatus.OPEN_REJECTED) ||
(ovm.Status == OrderStatus.CANCEL_REJECTED))
{
return(true);
}
return(false);
};
}
public ActionResult PlaceOrder(List <CartProduct> cpList)
{
OrderVM orderVM = new OrderVM();
orderVM.address = new address();
orderVM.customer = new customer();
orderVM.orderItems = new List <orderitem>();
double total = 0;
if (cpList != null)
{
foreach (var cProd in cpList)
{
orderitem oi = new orderitem();
oi.ProductID = cProd.productID;
oi.Price = cProd.price;
oi.Quantity = cProd.quantity;
orderVM.orderItems.Add(oi);
if (cProd.price != 0 && cProd.quantity != 0)
{
total = ((double)cProd.price * cProd.quantity) + total;
}
}
orderVM.order = new order();
orderVM.order.TotalPrice = total;
orderVM.order.GST = 5;
orderVM.order.GrandTotalWithTax = total;
orderVM.order.DeliveryDate = DateTime.Now.AddDays(30);
orderVM.order.Discount = 0;
orderVM.order.Advance = 0;
}
return(View(orderVM));
}
/// <summary>
/// this function we open a connection and gets its info from the form
/// she then checks the validity of the data and inserts it to the database
/// </summary>
public ActionResult AddOrder()
{
if (Session["Manager"] == null)
{
TempData["Result"] = true;
return(RedirectToAction("", ""));
}
OrderVM cvm = new OrderVM();
Order objOrder = new Order();
OrderDal dal = new OrderDal();
objOrder.orderAmount = Request.Form["Order.orderAmount"];
objOrder.OrderName = Request.Form["Order.OrderName"];
if (ModelState.IsValid)
{
dal.Orders.Add(objOrder);
dal.SaveChanges();
cvm.Order = new Order();
}
else
{
ViewBag.TheResult = true;
return(View("NewOrder"));
}
cvm.Orders = dal.Orders.ToList <Order>();
return(View("NewOrder", cvm));
}
public ActionResult AddOrder(OrderVM model)
{
if (ModelState.IsValid)
{
Order order = new Order();
order.CustomerID = model.CustomerID;
order.EmployeeID = model.EmployeeID;
order.OrderDate = model.OrderDate;
order.RequiredDate = model.RequiredDate;
order.ShippedDate = model.ShippedDate;
order.ShipVia = model.ShipVia;
order.Freight = model.Freight;
order.ShipName = model.ShipName;
order.ShipAddress = model.ShipAddress;
order.ShipCity = model.ShipCity;
order.ShipRegion = model.ShipRegion;
order.ShipPostalCode = model.ShipPostalCode;
order.ShipCountry = model.ShipCountry;
db.Orders.Add(order);
db.SaveChanges();
ViewBag.IslemDurum = EnumIslemDurum.Success;
return(View());
}
else
{
ViewBag.Islemdurum = EnumIslemDurum.ValidationError;
return(View());
}
}
internal void BookCar(OrderVM newOrder)
{
var carToBook = context.Cars.First(c => c.Id == newOrder.CarId);
Orders x = new Orders
{
CustomerId = context.Customers
.Where(c => c.Ssn == newOrder.Ssn)
.Select(c => c.CustomerId)
.FirstOrDefault(),
CarId = newOrder.CarId,
PickUpDate = newOrder.PickUpDate,
ReturnDate = newOrder.ReturnDate,
CurrentMileage = carToBook.Mileage,
IsReturned = false,
IsActive = true,
};
carToBook.IsAvailable = false;
carToBook.TimesRented += 1;
context.Orders.Add(x);
HistoryLog y = new HistoryLog
{
CustomerId = x.CustomerId,
CarId = newOrder.CarId,
Activity = $"Kund {x.CustomerId} hyrde bil {newOrder.CarId}"
};
context.HistoryLog.Add(y);
context.SaveChanges();
}
public SplitPaymentVM(OrderVM order, PaymentSection section, Payment parent)
{
_order = order;
_prevsection = section;
_parent = parent;
_remainedAmount = order.AllTotal;
_paymentType = SplitPaymentType.Card;
//default 3 split
var split = SelectableSplits[1];
split.IsSelected = true;
_selectedSplit = split;
//default evenly split
var splittype = SelectableSplitTypes[0];
splittype.IsSelected = true;
_selectedSplitType = splittype;
PrepareReceipts(order.AllTotal, (int)SelectedSplit.Value, (SplitType)SelectedSplitType.Value);
}
internal void CarToReturn(OrderVM carToReturn)
{
var orderReturned = context.Orders.First(x => x.BookingNr == carToReturn.BookingNr);
var car = context.Cars.First(c => c.Id == orderReturned.CarId);
orderReturned.MileageOnReturn = carToReturn.MileageOnReturn;
orderReturned.DrivenMiles = carToReturn.MileageOnReturn - orderReturned.CurrentMileage;
orderReturned.IsReturned = true;
orderReturned.IsActive = false;
car.ToBeCleaned = true;
car.IsAvailable = true;
car.Mileage += orderReturned.DrivenMiles;
if (car.TimesRented == 3)
{
car.NeedService = true;
car.TimesRented = 0;
}
if (car.Mileage >= 2000)
{
car.ToBeRemoved = true;
}
HistoryLog y = new HistoryLog
{
OrderId = carToReturn.BookingNr,
CustomerId = orderReturned.CustomerId,
CarId = car.Id,
Activity = $"Kund {orderReturned.CustomerId} Lämnade tillbaka bil {car.Id}"
};
context.HistoryLog.Add(y);
context.SaveChanges();
}
public ActionResult ShowOrder(int id = 0)
{
if (id == 0)
{
return(RedirectToAction("Orders"));
}
List <ProductAmountVM> products = new List <ProductAmountVM>();
foreach (OrderCollection orderCollection in orderCollectionFactory.GetBy("OrderID", id))
{
ProductAmountVM pavm = new ProductAmountVM();
ProductVM productVM = new ProductVM();
productVM.Product = productFactory.Get(orderCollection.ProductID);
productVM.Images = imageFactory.GetBy("ProductID", productVM.Product.ID);
productVM.Category = categoryFactory.Get(productVM.Product.CategoryID);
pavm.ProductVM = productVM;
pavm.Amount = orderCollection.Amount;
products.Add(pavm);
}
OrderVM ovm = new OrderVM();
ovm.Order = orderFactory.Get(id);
ovm.Products = products;
return(View(ovm));
}
public IActionResult Match(OrderVM orderVm)
{
if (orderVm.MatchVm.AccountNo == null || orderVm.MatchVm.TransactionId == null)
{
return(RedirectToAction("ConfirmOrder", new { id = orderVm.Order.Id }));
}
if (orderVm.MatchVm.AccountNo == null && orderVm.MatchVm.TransactionId == null)
{
return(RedirectToAction("ConfirmOrder", new { id = orderVm.Order.Id }));
}
var order = _context.Orders.Find(orderVm.Order.Id);
if (order.AccountNo == orderVm.MatchVm.AccountNo && order.TransactionId == orderVm.MatchVm.TransactionId)
{
ViewBag.confirm = "Matched !";
}
var vm = new OrderVM
{
Order = _context.Orders.Find(orderVm.Order.Id)
};
return(View("ConfirmOrder", vm));
}
public JsonResult SaveOrder(OrderVM O)
{
bool status = false;
if (ModelState.IsValid)
{
using (ERP1DataContext dc = new ERP1DataContext())
{
Order Order = new Order {
OrderDate = O.OrderDate, OrderStatus = O.OrderStatus, TotalAmount = O.TotalAmount, Payment = O.Payment
};
foreach (var i in O.OrderDetails)
{
//
// i.TotalAmount =
Order.OrderDetails.Add(i);
}
dc.Orders.InsertOnSubmit(Order);
dc.SubmitChanges();
status = true;
}
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status }
});
}
public async Task <IActionResult> Detail(int orderId)
{
var customerOrders = await _orderRepository.ListAsync(new UserOrderSpec(GlobalConstants.DEFAULT_USERNAME));
var order = customerOrders.FirstOrDefault(o => o.Id == orderId);
if (order == null)
{
return(BadRequest("No such order found for this user."));
}
var viewModel = new OrderVM()
{
OrderDate = order.OrderDate,
OrderItems = order.OrderItems.Select(oi => new OrderItemVM()
{
Discount = 0,
ProductId = oi.Ordered.CategoryId,
ProductName = oi.Ordered.ProductName,
UnitPrice = oi.UnitPrice,
Units = oi.Unit
}).ToList(),
OrderNumber = order.Id,
ShippingAddress = order.ShippingAddress,
Status = "Pending",
Total = order.Total()
};
return(View(viewModel));
}
