public IActionResult CreateOrder(CreateOrderVM createOrder)
{
var pizza = Database.Menu.FirstOrDefault(p => p.Name == createOrder.PizzaName && p.Size == createOrder.Size);
// some error handling
if (pizza == null)
{
return(RedirectToAction("CreateOrder", new { error = "There is no pizza like that in the menu" }));
}
var user = new User()
{
Id = Database.Users.Count + 1,
FirstName = createOrder.FirstName,
LastName = createOrder.LastName,
Address = createOrder.Address,
Phone = createOrder.Phone
};
var order = new Order
{
Id = Database.Orders.Count + 1,
Delivered = false,
Price = pizza.Price + 2,
Pizza = pizza,
User = user
};
Database.Orders.Add(order);
Database.Users.Add(user);
return(View("OrderComplete"));
}
public ActionResult Create(CreateOrderVM COVM)
{
if (ModelState.IsValid)
{
Order order = new Order
{
CustomerId = Convert.ToInt32(COVM.SelectedCustomer),
OrderStatus = "Active",
OrderDate = COVM.OrderDate.GetValueOrDefault(),
Quantity = COVM.Quantity,
Product = "Dietary Supplement 10oz",
ProductPrice = 20.00M,
DateCreated = DateTime.Now
};
order.OrderAmount = COVM.Quantity * order.ProductPrice;
dbcontext.Orders.Add(order);
dbcontext.SaveChanges();
return(RedirectToAction("Index"));
}
COVM.CustomerList = dbcontext.Customers.Select(x => new SelectListItem
{
Text = x.Email,
Value = x.CustomerID.ToString()
}).ToList();
return(View(COVM));
}
// GET: RepairOrders/Create
public ActionResult Create()
{
var newvm = new CreateOrderVM()
{
customers = db.Customers.ToList(),
RepairGuys = db.RepairGuys.ToList(),
};
return(View(newvm));
}
// GET: Orders/Create
public ActionResult Create()
{
List <ClientVM> clientsViewModel = serviceOrder.MapClientViewModel(db.Clients.ToList());
List <SelectAccessoryVM> accessoryVM = accessoryService.MapSelectAccessoryVM(db.Accessories.ToList());
//ViewBag.ClientID = new SelectList(clientsViewModel, "ID", "FullNameAndPhone");
//ViewBag.AllCarModels = new SelectList(db.Models.ToList(), "ID", "Name");
//ViewBag.ClientID = new SelectList(db.Clients, "ID", "FirstName");
CreateOrderVM newOrder = new CreateOrderVM(clientsViewModel, db.Models.ToList(), accessoryVM);
return(View(newOrder));
}
public ActionResult Create()
{
CreateOrderVM COVM = new CreateOrderVM();
COVM.CustomerList = dbcontext.Customers.Select(x => new SelectListItem
{
Text = x.Email,
Value = x.CustomerID.ToString()
}).ToList();
return(View(COVM));
}
public Order MapOrderViewModel(CarSystemEntities db, CreateOrderVM newOrderVM)//Creates Order Entity Model that is saved to the database from Order view model
{
int newOrderID = newOrderVM.GetHashCode();
DateTime newOrderDate = newOrderVM.OrderDate;
decimal newOrderPrice = CalculateOrderPrice(db, newOrderVM.SelectedModelID, newOrderVM.AccessoriesIDs);
int newOrderClient = newOrderVM.SelectedClientID;
ICollection <OrderDetail> orderDetails = CreateOrderDetailFromOrderVm(newOrderVM.SelectedModelID, newOrderID, newOrderVM.AccessoriesIDs);
Order newOrderEM = new Order(newOrderID, newOrderDate, newOrderPrice, newOrderClient, db.Clients.Find(newOrderClient), orderDetails);
return(newOrderEM);
}
public ActionResult Create(CreateOrderVM createOrderVM)
{
if (ModelState.IsValid)
{
createOrderVM.RepairOrder.Customer = db.Customers.Find(createOrderVM.RepairOrder.Customer.Id);
createOrderVM.RepairOrder.RepairGuy = db.RepairGuys.Find(createOrderVM.RepairOrder.RepairGuy.Id);
//createOrderVM.RepairOrder.RepairGuy = db.RepairGuys.Find(createOrderVM.RepairOrder.RepairGuy.Id);
db.RepairOrders.Add(createOrderVM.RepairOrder);
db.SaveChanges();
return(RedirectToAction("Index"));
}
createOrderVM.customers = db.Customers.ToList();
return(View(createOrderVM));
}
public IActionResult Order(string voiture)
{
if (voiture != null)
{
CreateOrderVM model = new CreateOrderVM()
{
CarName = voiture,
ClientName = "",
Telephone = ""
};
return(View(model));
}
return(View());
}
public ActionResult Create([Bind(Include = "ID,OrderDate,Price,SelectedClientID,SelectedModelID,AccessoriesIDs")] CreateOrderVM newOrder)
{
//Create New Order- mapped from order view model(use only order date and selected ids; Order ID is going to be hash code from OrderVM; Price is going to be decided from model and accessories)
if (ModelState.IsValid)
{
Order order = serviceOrder.MapOrderViewModel(db, newOrder);
db.Orders.Add(order);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//ViewBag.ClientID = new SelectList(db.Clients, "ID", "FirstName", order.ClientID);
return(View());
}
public Order MapEditedOrderViewModel(CarSystemEntities db, CreateOrderVM editedOrder)
{
Order order = db.Orders.Find(editedOrder.ID);
order.OrderDate = editedOrder.OrderDate;
order.Price = CalculateOrderPrice(db, editedOrder.SelectedModelID, editedOrder.AccessoriesIDs);
order.ClientID = editedOrder.SelectedClientID;
order.Client = db.Clients.Find(editedOrder.SelectedClientID);
if (!IsDublicateInOrderDetails(db, editedOrder.SelectedModelID, editedOrder.ID, editedOrder.AccessoriesIDs))
{
order.OrderDetails = CreateOrderDetailFromOrderVm(editedOrder.SelectedModelID, editedOrder.ID, editedOrder.AccessoriesIDs);
RemoveOrderDetailsFromDB(db, editedOrder.ID);
}
return(order);
}
public IActionResult CreateOrder(CreateOrderVM order)
{
Order orderDb = new Order()
{
OrderId = 0, Date = DateTime.Now, ClientName = order.ClientName, CarName = order.CarName, Telephone = order.Telephone
};
db.Orders.Add(orderDb);
db.SaveChanges();
CarListVM model = new CarListVM()
{
cars = db.Cars.ToList()
};
return(View("/Views/Car/Index.cshtml", model));
}
public ActionResult Create(CreateOrderVM model)
{
if (ModelState.IsValid)
{
int orderId = orderServ.CreateOrder(new OrderBO()
{
Date = DateTime.Now,
Status = OrderStatus.New,
Details = model.Text,
UserId = Id
});
mailer.SendEmailOrderChange(Email, orderId, orderServ.GetLocalizedOrderStatusName(OrderStatus.New)).SendAsync();
}
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID,OrderDate,Price,SelectedClientID,SelectedModelID,AccessoriesIDs")] CreateOrderVM editedOrder)
{
Order order = serviceOrder.MapEditedOrderViewModel(db, editedOrder);
try
{
if (ModelState.IsValid && order.OrderDetails != null)
{
//need to check if there is duplicate key in object 'dbo.OrderDetail'
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (System.Data.SqlClient.SqlException)
{
}
ViewBag.ClientID = new SelectList(db.Clients, "ID", "FirstName", order.ClientID);
return(View(order));
}
public async Task <OrderPageVM> CreateNewOrder(CreateOrderVM vm, string userId)
{
var dbOrder = new Order
{
IsActive = vm.IsActive,
Status = "In progress",
StartDate = vm.StartDate,
TableId = vm.TableId,
LocationId = vm.LocationId
};
var orderNew = await _db.Orders.CreateAsync(dbOrder);
var dbOrderUser = new OrderUser
{
OrderId = orderNew.Id,
UserProfileId = _db.UserProfiles.GetAll().FirstOrDefault(m => m.UserId == userId).Id
};
var orderUserNew = await _db.OrderUsers.CreateAsync(dbOrderUser);
var ret = new OrderPageVM(orderNew);
return(ret);
}
public async Task StartSession(CreateOrderVM vm, string userId = null)
{
try
{
if (userId == null)
{
userId = Context.User.Claims.First(c => c.Type == "UserID").Value;
}
var order = await _orderService.CreateNewOrder(vm, userId);
UpdateList(userId, true, order.Id);
var orderers = connects.Where(m => m.OrderIds.Contains(order.Id)).Select(m => m.ConnectionId).ToList();
var tab = await _orderService.AssignMeToOrder(order.WelcomeCode.ToString(), userId);
var page = _orderService.GetOrderByIdAsync(order.Id, userId);
await Clients.Clients(orderers).SendAsync("StartSession", page);
}
catch (Exception e)
{
throw e;
}
}
// GET: Orders/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Order order = db.Orders.Find(id);
if (order == null)
{
return(HttpNotFound());
}
List <ClientVM> clientsViewModel = serviceOrder.MapClientViewModel(db.Clients.ToList());
List <SelectAccessoryVM> accessoryVM = accessoryService.MapSelectAccessoryVM(db.Accessories.ToList());
int modelID = serviceOrder.GetCarModelFromOrder(db, order.ID).ID;
CreateOrderVM editOrderVM = new CreateOrderVM(order.ID, order.OrderDate, order.Price, order.ClientID, modelID, clientsViewModel, db.Models.ToList(), accessoryVM);
//ViewBag.CarModel = serviceOrder.GetCarModelFromOrder(db, id);
// List<ClientVM> clientsViewModel = serviceOrder.MapClientViewModel(db.Clients.ToList());
//ViewBag.ClientID = new SelectList(clientsViewModel, "ID", "FullNameAndPhone", order.ClientID);
return(View(editOrderVM));
}
public OrderDetailPage(Orders selectedOrder)
{
InitializeComponent();
vm = Resources["vm"] as CreateOrderVM;
vm.Orders = selectedOrder;
}
