public async Task <IActionResult> Edit(int id, UpdateOrderViewModel model)
{
if (ModelState.IsValid)
{
var order = await _orderService.GetById(id);
var result = await _orderService.Update(id, order, model.SelectedProductIds);
if (result.Succeeded)
{
TempData["OrderCreated"] = true;
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
}
model.Products = await GetProductList();
model.Clients = await GetClientList();
return(View(model));
}
public void Update(string id, UpdateOrderViewModel model)
{
validateUpdate(model);
if (Valid)
{
Order order = getOrder(id);
if (order == null)
{
AddNotification("Pedido", "Nenhum pedido com este código pode ser encontrado!");
return;
}
if (Valid)
{
clearItems(model, order);
}
if (Valid)
{
addOrUpdateItems(model, order);
}
}
if (Valid)
{
_context.SaveChanges();
}
}
public void Update(UpdateOrderViewModel model)
{
_unitOfWork.BeginTransaction();
var order = _orderRepository.GetById(model.OrderId);
if (order == null)
{
_unitOfWork.Commit();
throw new Exception(ExceptionMessages.OrderException.NOT_FOUND);
}
var user = _userRepository.GetById(model.UserId);
if (user == null)
{
_unitOfWork.Commit();
throw new Exception(ExceptionMessages.UserException.NOT_FOUND);
}
order.User = user;
order.Status = Order.MapToOrderStatus(Convert.ToInt32(model.Status));
//order.DateOrdered = Convert.ToDateTime(model.DateOrdered);
//order.OrderPrice = model.Price;
_orderRepository.Update(order);
_unitOfWork.Commit();
}
public ActionResult UpdateProcess(UpdateOrderViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.TransactionStatus = Helper.OrderStatus;
return(View("Update", viewModel));
}
var orderInDb = _context.Orders.Find(viewModel.OrderId);
if (orderInDb == null)
{
ModelState.AddModelError("", "Something went wrong.");
viewModel.TransactionStatus = Helper.OrderStatus;
return(View("Update", viewModel));
}
orderInDb.Status = viewModel.TransactionStatusId;
orderInDb.ETHTXNNo = viewModel.EthTxnNo;
_context.Entry(orderInDb).State = EntityState.Modified;
_context.SaveChanges();
return(RedirectToAction("Index", "Orders"));
}
private void validateUpdate(UpdateOrderViewModel order)
{
if (order.Items == null || order.Items.Count == 0)
{
AddNotification("Itens", "Pedido inválido! Os pedidos devem conter ao meno um item.");
return;
}
}
public async Task <IActionResult> UpdateOrderAsync([FromRoute] int id, [FromBody] UpdateOrderViewModel model)
{
var command = mapper.Map <UpdateOrderViewModel, UpdateOrderCommandModel>(model);
command.Id = id;
await bus.SendAsync(command);
return(Accepted());
}
public IActionResult Put(string id, [FromBody] UpdateOrderViewModel value)
{
_orderService.Update(id, value);
if (_orderService.Valid)
{
return(Ok());
}
return(BadRequest(_orderService.Notifications));
}
public IHttpActionResult Put(UpdateOrderViewModel modifiedModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_service.Update(_mapper.Map <Order>(modifiedModel));
return(Ok());
}
public ActionResult Update(UpdateOrderViewModel model)
{
if (!ModelState.IsValid)
{
Helpers.InvalidModelState(ModelState);
}
_orderService.Update(model);
return(Json(true));
}
public ActionResult Update(int id)
{
var viewModel = new UpdateOrderViewModel()
{
OrderId = id,
TransactionStatus = Helper.OrderStatus,
TransactionStatusId = _context.Orders.FirstOrDefault(x => x.Id == id).Status
};
return(View("Update", viewModel));
}
private void clearItems(UpdateOrderViewModel model, Order order)
{
var itemCmd = new DeleteItemCommand(_itemRepository, _itemValidator);
foreach (var item in order.Items)
{
if (!model.Items.Any(i => i.Description == item.Description))
{
itemCmd.Execute(item);
AddNotifications(itemCmd);
}
}
}
public async Task <IActionResult> Edit(int id)
{
var order = await _orderService.GetById(id);
var model = new UpdateOrderViewModel
{
Id = order.Id,
Date = order.OrderedDate,
InvoiceNumber = order.InvoiceNumber,
ClientId = order.ClientId,
Clients = await GetClientList(),
Products = await GetProductList()
};
return(View(model));
}
public async Task <IActionResult> Details(UpdateOrderViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var order = await this.ordersRepository.Get(model.Id).ConfigureAwait(false);
order.Status = model.Status;
order.DeliveryComment = model.DeliveryComment;
await this.ordersRepository.Update(order).ConfigureAwait(false);
return(this.RedirectToAction("List"));
}
public IActionResult Update(int Id)
{
try
{
var orderViewModel = new UpdateOrderViewModel()
{
Customers = customerService.GetCustomers(),
Products = productService.AllProducts(),
Order = orderService.FindByOrderId(Id)
};
return(View(orderViewModel));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Edit(int id = 0)
{
Order order = orderRepo.GetSingleEntity(x => x.OrderId == id);
if (order == null)
{
return(HttpNotFound());
}
var viewModel = new UpdateOrderViewModel();
viewModel.Status = statusRepo.GetWithFilterAndOrder();
viewModel.Order = order;
viewModel.StatusId = order.StatusId;
return(View(viewModel));
}
private void addOrUpdateItems(UpdateOrderViewModel model, Order order)
{
var itemCmd = new SaveItemCommand(_itemRepository, _itemValidator);
foreach (var item in model.Items)
{
var entity = item.Adapt <Item>();
entity.PedidoId = order.Id;
itemCmd.Execute(entity);
AddNotifications(itemCmd);
if (Invalid)
{
break;
}
}
}
public IActionResult Update(string id)
{
var order = orderService.GetById(id);
var senderId = order.Sender.Id.ToString();
UpdateOrderViewModel newOrderViewModel = new UpdateOrderViewModel()
{
UpdateId = order.Id.ToString(),
PickupLocation = GetLocationsList(senderId),
DeliveryLocation = GetLocationsList(senderId),
UpDeliveryLocationId = order.DeliveryAddress.Id.ToString(),
UpPickupLocationId = order.PickUpAddress.Id.ToString(),
UpPrice = order.Price,
};
return(PartialView("_Update", newOrderViewModel));
}
public async Task <ActionResult <OrderViewModel> > PutAsync(int id, UpdateOrderViewModel pe)
{
_logger.LogDebug("Put {0} {1} {2} {3}", id, pe.Paid, pe.Cancelled, pe.Reason);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _repository.UpdateOrderAsync(id, pe.Paid, pe.Cancelled, pe.Reason);
if (!result)
{
return(BadRequest(new ProblemDetails()
{
Detail = result.Message
}));
}
return(Ok(_mapper.Map <OrderViewModel>(result.Data)));
}
public ActionResult Edit(UpdateOrderViewModel viewModel)
{
Order order = null;
if (ModelState.IsValid)
{
order = orderRepo.GetSingleEntity(x => x.OrderId == viewModel.Order.OrderId);
order.StatusId = viewModel.StatusId;
order.Comment = viewModel.Order.Comment;
orderRepo.Update(order);
orderRepo.SaveChanges();
return(RedirectToAction("Index"));
}
viewModel.Status = statusRepo.GetWithFilterAndOrder();
viewModel.Order = order;
return(View(viewModel));
}
public IActionResult Update([FromForm] UpdateOrderViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(PartialView("_Update", viewModel));
}
try
{
orderService.Update(viewModel.UpdateId,
viewModel.UpPickupLocationId,
viewModel.UpDeliveryLocationId,
viewModel.UpPrice);
return(PartialView("_Update", viewModel));
}
catch (Exception e)
{
logger.LogError("Failed to update order {@Exception}", e.Message);
logger.LogDebug("Failed to update order {ExceptionMessage}", e);
return(BadRequest(e.Message));
}
}
public PartialViewResult UpdateOrder(UpdateOrderViewModel model)
{
return(PartialView("UpdateOrder", model));
}
public async Task <ActionResult <OrderViewModel> > Update(Guid id, [FromBody] UpdateOrderViewModel body)
{
var result = await Mediator.Send(new UpdateOrderCommand { Id = id, Order = body });
return(Ok(result));
}
public OrderPackage CreateOrder(IModalDialogService modalDialogService, IServiceFactory serviceFactory)
{
var viewModel = new UpdateOrderViewModel(modalDialogService, serviceFactory);
viewModel.OrderPackage = new OrderPackage();
viewModel.DialogMode = DialogMode.Create;
ModalDialogHelper<UpdateOrder>.ShowDialog(viewModel);
if (!viewModel.IsCanceled)
{
return viewModel.OrderPackage;
}
return null;
}
public HttpResponseMessage UpdateOrderStatus(HttpRequestMessage request, UpdateOrderViewModel orderVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var dbOrder = this.orderService.GetById(orderVm.Id);
var orderDetail = this.orderService.GetDetailOrderByOrderId(orderVm.Id);
if (orderDetail != null && orderVm.Status == OrderStatus.Cancelled && dbOrder.Status != orderVm.Status)
{
int[] ArrQuantity = orderDetail.Quantities.ToArray();
int i = 0;
foreach (var item in orderDetail.Products)
{
if (i == orderDetail.Products.Count())
{
break;
}
var dbProduct = this.productService.GetById(item.Id);
if (dbProduct != null)
{
dbProduct.Quantity += ArrQuantity[i];
this.productService.Update(dbProduct);
this.productService.Save();
}
i++;
}
string title = "Huỷ thành công đơn hàng từ Electrolic Store";
StringBuilder builder = new StringBuilder();
BuildSendMailContent(title, builder, orderDetail);
this.mailService.SendMail(orderDetail.Email, title, builder.ToString());
}
if (orderDetail != null && orderVm.PaymentStatus == PaymentStatus.Paid && dbOrder.PaymentStatus != orderVm.PaymentStatus)
{
string title = "Thanh toán thành công đơn hàng từ Electrolic Store";
StringBuilder builder = new StringBuilder();
BuildSendMailContent(title, builder, orderDetail);
this.mailService.SendMail(orderDetail.Email, title, builder.ToString());
}
dbOrder.ShipDate = orderVm.ShipDate;
dbOrder.PaymentStatus = orderVm.PaymentStatus;
dbOrder.ShipStatus = orderVm.ShipStatus;
dbOrder.Status = orderVm.Status;
this.orderService.Update(dbOrder);
this.orderService.Save();
response = request.CreateResponse(HttpStatusCode.Created, dbOrder);
}
return response;
}));
}
