public ActionResult EditOrder(EditOrderViewModel model)
{
GetOrderById_Result CurOrder = new HotelConnection().GetOrderById(model.ID).FirstOrDefault();
if (ModelState.IsValid)
{
List <int> UnAvailableRooms = _context.GetOrders().Where(order => ((order.ID != model.ID) && !order.IsCancelled && !(order.FromDate >= model.ToDate || order.ToDate <= model.FromDate))).Select(r => r.RoomId).ToList();
HashSet <int> UnAvailableRoomIds = new HashSet <int>(UnAvailableRooms);
if (UnAvailableRoomIds.Contains(model.RoomId))
{
ModelState.AddModelError("", "Room not available at designated date range!");
return(View(model));
}
else
{
_context.UpdateExistingOrder(model.ID, model.UserId, model.RoomId, model.FromDate, model.ToDate, model.IsCancelled, model.TotalCost);
}
return(RedirectToAction("ManageOrders"));
}
PopulateUserDropDownList(CurOrder.UserId);
PopulateRoomDropDownList(CurOrder.RoomId);
return(View(model));
}
public EditOrder(EditOrderViewModel edit)
{
List <Order> order = db.Orders.Where(m => m.TableNo == edit.EditTableId).ToList();
Mappings map = new Mappings();
//Delete Order
if (edit.OrderDeletion == true)
{
ManageRestaurant manage = new ManageRestaurant();
foreach (Order index in order)
{
db.Orders.Remove(index);
db.SaveChanges();
}
manage.TableStatus((int)edit.EditTableId, false);
}
//Update Order
else
{
for (int index = 0; index < edit.EditedQuantity.Count(); index++)
{
order[index].Quantity = edit.EditedQuantity[index];
db.Entry(order[index]).State = EntityState.Modified;
db.SaveChanges();
}
}
}
public IActionResult Put([FromBody] EditOrderViewModel orderViewModel)
{
try
{
var order = _orderRepository.ListOrder(x => x.Id == orderViewModel.Id).FirstOrDefault();
if (order == null)
{
return(BadRequest($"The OrderId ({orderViewModel.Id}) does not exists!"));
}
var newOrderDetails = _mapper.Map <List <OrderDetail> >(orderViewModel.Items);
order.Items.Clear();
foreach (var item in newOrderDetails)
{
order.Items.Add(item);
}
order.UserId = orderViewModel.UserId;
order.RegionId = orderViewModel.RegionId;
order.OrderDate = orderViewModel.OrderDate;
order.PaymentStatusId = orderViewModel.PaymentStatusId;
order.UpdatedOn = DateTime.Now;
order.UpdatedBy = User.Identity.Name;
_orderRepository.Update(order);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public ActionResult EditOrder(int?id)
{
if (id == null)
{
return(View("Error"));
}
GetOrderById_Result OrderToEdit;
EditOrderViewModel OrderVM;
OrderToEdit = _context.GetOrderById(id).FirstOrDefault();
var CurRoom = _context.GetRoomById(OrderToEdit.RoomId).FirstOrDefault();
if (OrderToEdit == null)
{
return(View("Error"));
}
OrderVM = new EditOrderViewModel
{
ID = OrderToEdit.ID,
UserId = OrderToEdit.UserId,
RoomId = OrderToEdit.RoomId,
FromDate = OrderToEdit.FromDate,
ToDate = OrderToEdit.ToDate,
UnitPrice = CurRoom.Price,
TotalCost = OrderToEdit.TotalCost,
IsCancelled = OrderToEdit.IsCancelled
};
PopulateUserDropDownList(OrderVM.UserId);
PopulateRoomDropDownList(OrderVM.RoomId);
return(View(OrderVM));
}
public ActionResult EditOrder(EditOrderViewModel model)
{
var order = unitOfWork.Orders.Get(model.orderId);
model.tableId = unitOfWork.Places.Get(model.placeId).TableId;
order.OrderTips = model.Tips;
switch (model.submitButton)
{
case "Pay":
{
order.OrderStatus = 4;
break;
}
case "Save":
{
order.OrderStatus = model.SelectedStatus;
break;
}
case "Void":
{
order.OrderStatus = 5;
break;
}
}
unitOfWork.Orders.AddOrUpdate(order);
return(RedirectToAction("Table", "Home", new { id = model.tableId }));
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Order order = await context.Orders
.Include(o => o.OrderProducts.Select(op => op.Product))
.FirstOrDefaultAsync(o => o.Id == id);
if (order == null)
{
return(HttpNotFound());
}
EditOrderViewModel model = new EditOrderViewModel();
model.Id = order.Id;
model.Name = order.Name;
model.CustomerId = order.CustomerId;
model.AvailableCustomers = GetAvailableCustomers();
if (order.OrderProducts.Any())
{
foreach (var orderProduct in order.OrderProducts.OrderBy(op => op.Product.Name))
{
model.OrderProducts.Add(new OrderProductViewModel(orderProduct));
}
}
return(View(model));
}
public IActionResult Edit(EditOrderViewModel editOrderViewModel)
{
//trailerSelected = context.Trailers.Where(x => x.TrailerID == editOrderViewModel.TrailerForLoadID).Single();
Order order = context.Orders.FirstOrDefault(o => o.OrderID == editOrderViewModel.OrderID);
Trailer newTrailer = context.Trailers.FirstOrDefault(t => t.TrailerID == editOrderViewModel.TrailerForLoadID);
Trailer oldTrailer = context.Trailers.FirstOrDefault(t => t.TrailerID == order.TrailerForLoadID);
order.OrderNumber = editOrderViewModel.OrderNumber;
order.CustomerOrdersID = editOrderViewModel.CustomerOrdersID;
//if (order.TrailerForLoadID != trailerSelected.TrailerID){
// order.TrailerForLoad.TrailerStatus = "Available";
// trailerSelected.TrailerStatus = "Unavailable";
//}
if (oldTrailer.TrailerID != newTrailer.TrailerID)
{
oldTrailer.TrailerStatus = "Available";
newTrailer.TrailerStatus = "Unavailable";
}
order.TrailerForLoadID = newTrailer.TrailerID; //editOrderViewModel.TrailerForLoadID;
//save changes
context.SaveChanges();
return(Redirect("/"));
}
public void TestSaveCommand()
{
Order order = TestHelper.GetTestOrder();
Mock <IServiceFactory> mockServiceFactory = new Mock <IServiceFactory>();
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().GetOrder(1)).Returns(order);
EditOrderViewModel viewModel = new EditOrderViewModel(mockServiceFactory.Object, order.Id);
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().UpdateOrder(It.IsAny <Order>())).Returns(viewModel.Order);
viewModel.Order.InvoiceNumber = "Black";
bool orderUpdated = false;
string color = string.Empty;
viewModel.OrderUpdated += (s, e) =>
{
orderUpdated = true;
color = e.Order.InvoiceNumber;
};
viewModel.SaveCommand.Execute(null);
Assert.IsTrue(orderUpdated);
Assert.IsTrue(color == "Black");
}
public async Task <IActionResult> Edit(EditOrderViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var order = await _context.Orders.SingleOrDefaultAsync(m => m.OrderId == model.OrderId);
order.Price = model.Price;
order.Description = model.Description;
order.Status = model.Status;
Console.WriteLine("Website ID {0}", model.WebsiteId);
order.Website = await _context.Websites.SingleOrDefaultAsync(c => c.WebsiteId == model.WebsiteId);
Console.WriteLine("Website: {0}", order.Website.Domain);
_context.Update(order);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(model.OrderId))
{
return(View("NotFound"));
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(int id, [Bind("OrderId,CSRId,CustomerId,DatePlaced,DateDue,StatusId,Rush,Install,Price,Content")] Order order)
{
if (id != order.OrderId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(order);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(order.OrderId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
EditOrderViewModel editOrderViewModel = new EditOrderViewModel(_context);
editOrderViewModel.Order = order;
return(View(editOrderViewModel));
}
public void TestCancelCommand()
{
Order order = new Order()
{
Id = 1, InvoiceNumber = "White"
};
Mock <IServiceFactory> mockServiceFactory = new Mock <IServiceFactory>();
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().GetOrder(1)).Returns(order);
EditOrderViewModel viewModel = new EditOrderViewModel(mockServiceFactory.Object, order.Id);
bool canceled = false;
viewModel.CancelEditOrder += (s, e) => canceled = true;
Assert.IsTrue(!canceled);
viewModel.CancelCommand.Execute(null);
Assert.IsTrue(viewModel.CancelCommand.CanExecute(null));
Assert.IsTrue(canceled);
}
public async Task <IActionResult> Edit(int id)
{
var order = this.orderService.GetById(id);
var editOrder = new EditOrderViewModel(order.Id, order.ShoeCount, order.ShoeType, order.Shoe, order.OrderPrice);
return(this.View(editOrder));
}
private void EditOrder()
{
MostRecentOrdersRecord record = dataGrid.SelectedItem as MostRecentOrdersRecord;
if (record == null)
{
return;
}
EditOrderViewModel edit_model = new EditOrderViewModel
{
Mode = EditOrderViewModel.ModelMode.Edit,
OrderID = record.OrderID
};
EditOrderWindow window = new EditOrderWindow(edit_model);
window.Owner = this;
window.ShowDialog();
if (window.DialogResult == false)
{
return;
}
}
public EditOrderView()
{
InitializeComponent();
var vm = new EditOrderViewModel();
vm.Navigation = Navigation;
BindingContext = vm;
}
//Update Order
public JsonResult EditOrderUpdateData(EditOrderViewModel order)
{
if (order == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
EditOrder edit = new EditOrder(order);
return(Json(true, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(EditOrderViewModel model)
{
RecaptchaVerificationHelper recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (string.IsNullOrEmpty(recaptchaHelper.Response))
{
ModelState.AddModelError("", "Captcha відповідь не може бути пустою.");
return(View("Edit", model));
}
RecaptchaVerificationResult recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
ModelState.AddModelError("", "Невірна captcha відповідь.");
return(View("Edit", model));
}
HttpCookie consumerBasketRawDataCookie = Request.Cookies["ConsumerBasket"];
if (consumerBasketRawDataCookie == null)
{
ModelState.AddModelError("", "Не вибрано жодного товару для покупки");
}
if (ModelState.IsValid)
{
List <ProductInBasketViewModel> productInBasketViewModels = JsonConvert.DeserializeObject <List <ProductInBasketViewModel> >(
HttpContext.Server.UrlDecode(consumerBasketRawDataCookie.Value));
Order order = _ordersBL.CreateOrder(new CreateOrderQuery
{
Person = new CreateOrderQuery.AddPersonQuery
{
Email = model.Email,
MiddleName = model.MiddleName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
FirstName = model.FirstName
},
OrderedProducts = new List <CreateOrderQuery.AddOrderedProductQuery>(
productInBasketViewModels.Select(
p => new CreateOrderQuery.AddOrderedProductQuery
{
ProductId = p.Id,
Quantity = p.Quantity
}).ToList()),
AdditionalComment = model.AdditionalComment
});
TempData[Constants.TempDataKeys.ORDER_ID] = order.Id;
return(RedirectToAction("OrderDetails", new { orderId = order.Id }));
}
return(View("Edit", model));
}
public IActionResult CheckOutEdit(EditOrderViewModel order)
{
if (ModelState.IsValid)
{
Order newOrder = _orderRepository.EditOrder(order);
//return RedirectToAction("OrderCompleted", new RouteValueDictionary(newOrder));
return(RedirectToAction("OrderCompleted", new { newOrder.OrderId }));
}
return(View(order));
}
public ActionResult EditOrder(int id)
{
var result = new EditOrderViewModel();
using (var context = new EfDbContext())
{
result.Order = context.Orders.Find(id);
result.OrderPosition = context.OrderPositions.Where(o => o.OrderId == id).Include(o => o.Product).ToList();
}
return(View(result));
}
private void OnWireViewModelEvents(ViewModelBase viewModel)
{
EditOrderViewModel vm = viewModel as EditOrderViewModel;
if (vm != null)
{
vm.OrderUpdated += OnOrderUpdated;
vm.CancelEditOrder += OnCancelEditOrder;
vm.ErrorOccured += OnErrorOccured;
}
}
public ActionResult EditOrder(int?tableNo)
{
if (tableNo == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EditOrderViewModel order = new EditOrderViewModel();
order.OrderList = map.DisplayOrdersByTable(tableNo);
ViewBag.obj = map.DisplayTable(true);
return(View(order));
}
public PartialViewResult GetOrders(int placeId)
{
EditOrderViewModel model = new EditOrderViewModel();
model.Menu = unitOfWork.MenuItems.GetAll().ToList();
model.placeId = placeId;
model.tableId = unitOfWork.Places.Get(placeId).TableId;
model.orders = unitOfWork.Orders.GetAll().Where(x => x.OrderPlaceId == placeId &&
(x.OrderStatus == 1 || x.OrderStatus == 2 || x.OrderStatus == 3));
model.statusList = unitOfWork.Status.GetAll().Where(x => x.StatusId == 1 || x.StatusId == 2 || x.StatusId == 3).ToList();
return(PartialView(model));
}
public ActionResult Edit(EditOrderViewModel model)
{
var order = _orderService.GetOrder(model.Id);
if (!ModelState.IsValid)
{
return(BuildModel(order, model));
}
order.Status = model.Status;
_notifier.Add(NotifyType.Information, T("The order has been saved"));
return(RedirectToAction("ListOrders", "CustomerAdmin", new { id = order.CustomerId }));
}
public ActionResult EditOrderInfo(EditOrderViewModel model, Guid orderId, string queryString)
{
if (!this.ModelState.IsValid)
{
throw new InvalidOperationException();
}
var page = this.utils.ExtractPageFromQuery(queryString);
var query = this.utils.ExtractSearchQueryFromQuery(queryString);
this.requestService.UpdateRequestInfo(orderId, model.FirstName, model.LastName, model.Phone, model.Address, model.BoolStatus);
return(this.RedirectToAction("Index", new { query, page }));
}
private dynamic BuildModel(OrderPart order, EditOrderViewModel editModel)
{
return(Shape.Order(
Order: order,
Details: order.Details.Join(_productRepository.Table, x => x.ProductId, x => x.Id, (record, productRecord) =>
Shape.Detail
(
Sku: productRecord.Sku,
Price: productRecord.UnitPrice,
Quantity: record.Quantity,
Total: record.Total
)).ToArray(),
EditModel: editModel
));
}
public ActionResult Edit(int id, EditOrderViewModel editOrderViewModel)
{
if (!ModelState.IsValid)
{
return(View(editOrderViewModel));
}
var order = _manager.GetByPrimaryKey(id);
order = Mapper.Map(editOrderViewModel, order);
_manager.Update(order);
return(RedirectToAction("Index"));
}
public void TestViewModelConstruction()
{
Order order = TestHelper.GetTestOrder();
order.Id = 1;
Mock <IServiceFactory> mockServiceFactory = new Mock <IServiceFactory>();
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().GetOrder(1)).Returns(order);
EditOrderViewModel viewModel = new EditOrderViewModel(mockServiceFactory.Object, order.Id);
Assert.IsTrue(viewModel.Order != null);
Assert.IsTrue(viewModel.Order.Id == order.Id && viewModel.Order.InvoiceNumber == order.InvoiceNumber);
}
public ActionResult EditOrder(EditOrderViewModel editedOrder)
{
if (ModelState.IsValid)
{
using (var context = new EfDbContext())
{
context.Entry(editedOrder.Order).State = EntityState.Modified;
context.SaveChanges();
}
TempData["message"] = "Udało się zapisać zmiany";
return(RedirectToAction("Orders"));
}
TempData["message"] = "Nie udało się zapisać zmian";
return(View(editedOrder));
}
public JsonResult EditOrder(EditOrderViewModel order)
{
using (var db = new CobraOnboarddbEntities())
{
var orderdetails = db.OrderHeaders.Where(x => x.Id == order.Id).FirstOrDefault();
{
orderdetails.PersonId = order.Ord.CustomerId;
}
var orderheader = db.OrderDetails.Where(x => x.OderId == order.Id).FirstOrDefault();
{
orderheader.ProductId = order.Ord.ProductId;
}
db.SaveChanges();
}
return(new JsonResult());
}
public void TestCanSaveCommand()
{
Order order = TestHelper.GetTestOrder();
Mock <IServiceFactory> mockServiceFactory = new Mock <IServiceFactory>();
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().GetOrder(1)).Returns(order);
EditOrderViewModel viewModel = new EditOrderViewModel(mockServiceFactory.Object, order.Id);
Assert.IsFalse(viewModel.SaveCommand.CanExecute(null));
viewModel.Order.InvoiceNumber = "Black";
Assert.IsTrue(viewModel.SaveCommand.CanExecute(null));
}
public void PutEditOrder(EditOrderViewModel model)
{
if (!ModelState.IsValid)
{
throw new Exception("Couldn't change order status");
}
if ((OrderStatus)model.Status == OrderStatus.InDelivery)
{
orderService.SetOrderIsInDelivery(model.OrderId, model.EstimatedDeliveryTime.Value);
}
else
{
orderService.ChangeStatus(model.OrderId, (OrderStatus)model.Status);
}
}
