/// <summary> /// Initializes a new instance of the <see cref="OrdersTabItemViewModel"/> class. /// </summary> /// <param name="modalDialogProvider">The modal dialog service.</param> /// <param name="serviceFactory">The service factory.</param> public OrdersTabItemViewModel(IMainViewModel mainViewModel, IModalDialogProvider modalDialogProvider, IServiceFactory serviceFactory) : base(mainViewModel, modalDialogProvider, serviceFactory) { OrderDetailsViewModel = new OrderDetailsViewModel(MainViewModel, ModalDialogProvider, ServiceFactory); OrderListViewModel = new OrderListViewModel(MainViewModel, OrderDetailsViewModel, ModalDialogProvider, ServiceFactory); OrderDetailsViewModel.DeliveryNoteDetailsViewModel.ItemSaved += new System.EventHandler(DeliveryNoteDetailsViewModel_ItemSaved); OrderDetailsViewModel.DeliveryNoteDetailsViewModel.IsReadOnlyChanged += new System.EventHandler(DeliveryNoteDetailsViewModel_IsReadOnlyChanged); OrderDetailsViewModel.DeliveryNoteListViewModel.ItemDeactivatedFlagChanged += new System.EventHandler(DeliveryNoteListViewModel_ItemDeactivatedFlagChanged); }
public async Task <IActionResult> DetailTracking(int Id) { OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeader.Include(el => el.Customer).FirstOrDefaultAsync(m => m.Id == Id), OrderDetails = await _db.OrderDetails.Where(m => m.OrderId == Id).ToListAsync() }; orderDetailsViewModel.OrderHeader.Customer = await _db.ApplicationUser.FirstOrDefaultAsync(u => u.Id == orderDetailsViewModel.OrderHeader.UserId); return(View(orderDetailsViewModel)); }
public async Task <IActionResult> GetCusOrderDetails(int id) { OrderDetailsViewModel orderDetailsVM = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeader.FirstOrDefaultAsync(m => m.Id == id), OrderDetails = await _db.OrderDetails.Where(m => m.OrderId == id).ToListAsync() }; orderDetailsVM.OrderHeader.ApplicationUser = await _db.ApplicationUser.FirstOrDefaultAsync(u => u.Id == orderDetailsVM.OrderHeader.UserId); return(PartialView("_IndividualCusOrderDetails", orderDetailsVM)); }
public IActionResult DeleteOrderPost(OrderDetailsViewModel orderDetailsViewModel) { try { _orderService.DeleteOrder(orderDetailsViewModel.Id); return(RedirectToAction("Index")); } catch { return(View("ExceptionView")); } }
// GET: Orders/Details/5 public async Task <IActionResult> Details(int?id) { if (id == null) { return(NotFound()); } var order = await _db.Orders.SingleOrDefaultAsync(m => m.Id == id); if (order == null) { return(NotFound()); } // Except for admins, if you don't own this order, don't look at it var userId = _userManager.GetUserId(User); if (User.IsInRole("admin") == false) { if (order.OrderedById != userId) { return(NotFound()); } } if (order == null) { return(NotFound()); } IQueryable <Booking> bookings = _db.Bookings .Include(b => b.Show) .ThenInclude(s => s.Movie) .Include(b => b.Show) .ThenInclude(s => s.Cinema) .Include(b => b.Tickets) .ThenInclude(t => t.PricingType) .Include(b => b.Seats) .Where(b => b.OrderId == order.Id) .AsNoTracking(); OrderDetailsViewModel viewModel = new OrderDetailsViewModel { Order = order, DateCreated = (DateTime)_db.Entry(order).Property("CreatedAt").CurrentValue }; viewModel.Order.Bookings = await bookings.ToListAsync(); return(View(viewModel)); }
public IActionResult Get(string status = null) { List <OrderDetailsViewModel> orderListVm = new List <OrderDetailsViewModel>(); IEnumerable <OrderHeader> orderHeadersList; if (User.IsInRole(SD.CustomerRole)) { //RETRIEVE ALL ORDER FOR THAT CUSTOMER var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); orderHeadersList = _unitOfWork.OrderHeader.GetAll(u => u.UserId == claim.Value, null, "ApplicationUser"); } else { orderHeadersList = _unitOfWork.OrderHeader.GetAll(null, null, "ApplicationUser"); } if (status == SD.StatusCanceled) { orderHeadersList = orderHeadersList.Where(o => o.Status == SD.StatusCanceled || o.Status == SD.StatusRefunded || o.Status == SD.PaymentStatusRejected); } else { if (status == SD.StatusCompleted) { orderHeadersList = orderHeadersList.Where(o => o.Status == SD.StatusCompleted); } else { orderHeadersList = orderHeadersList.Where(o => o.Status == SD.StatusReady || o.Status == SD.StatusInProcess || o.Status == SD.StatusSubmitted || o.Status == SD.PaymentStatusPending); } } foreach (var orderHeader in orderHeadersList) { OrderDetailsViewModel model = new OrderDetailsViewModel() { OrderHeader = orderHeader, OrderDetailsList = _unitOfWork.OrderDetails.GetAll(c => c.OrderId == orderHeader.Id).ToList() }; orderListVm.Add(model); } return(Json(new { data = orderListVm })); }
public IActionResult OrderDetails(int id) { var products = _productRepository.GetAllProducts().OrderBy(p => p.Name); var orderDetailsViewModel = new OrderDetailsViewModel() { Order = _orderRepository.GetOrderById(id), OrderDetails = _orderDetailRepository.GetOrderDetailsByOrderId(id), Status = _orderRepository.GetOrderById(id).Status }; return(View(orderDetailsViewModel)); }
public async Task <IActionResult> Confirm(int id) { var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel() { DonHang = await _db.DonHangs.Include(o => o.KhachHang).Include(o => o.VanChuyen).Include(o => o.ThanhToan).FirstOrDefaultAsync(o => o.Id == id && o.KhachHangID == claim.Value), OrderDetails = await _db.OrderDetails.Where(o => o.DonHangId == id).ToListAsync() }; return(View(orderDetailsViewModel)); }
//pop up order details public async Task <IActionResult> GetOrderDetails(int Id) { //create an object OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeader.Include(el => el.ApplicationUser).FirstOrDefaultAsync(m => m.Id == Id), OrderDetails = await _db.OrderDetails.Where(m => m.OrderId == Id).ToListAsync() }; //orderDetailsViewModel.OrderHeader.ApplicationUser = await _db.ApplicationUser.FirstOrDefaultAsync(u => u.Id == orderDetailsViewModel.OrderHeader.UserId); return(PartialView("_IndividualOrderDetails", orderDetailsViewModel)); }
public async Task <OrderDetailsViewModel> GetOrderDetails(int orderId) { var order = await orderService.GetOrder(orderId); var result = new OrderDetailsViewModel { OrderViewModel = mapper.Map <OrderViewModel>(order), ApplicationUserViewModel = mapper.Map <ApplicationUserViewModel>(order.ApplicationUser), OrderItemsViewModel = mapper.Map <IEnumerable <OrderItemViewModel> >(order.OrderItems) }; return(result); }
// GET: Order/Details/5 public IActionResult Details(int id) { var order = _orderService.GetById(id); var orderItems = _orderItemService.GetOrderItemsByOrderId(order.OrderId); var model = new OrderDetailsViewModel { Order = order, Items = orderItems }; return(View(model)); }
[Authorize] //login to access this method public async Task <IActionResult> Confirm(int Id) { var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderDetailsViewModel OrderDetailsViewModel = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeader.Include(x => x.ApplicationUser).FirstOrDefaultAsync(x => x.Id == Id && x.UserId == claim.Value), //hanya menampilkan order dari masing2 user OrderDetails = await _db.OrderDetails.Where(x => x.OrderId == Id).ToListAsync() }; return(View(OrderDetailsViewModel)); }
public async Task <IActionResult> Confirm(int id) { var userId = (this.User.Identity as ClaimsIdentity).FindFirst(ClaimTypes.NameIdentifier).Value; var orderDetail = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeaders .Include(c => c.AppUser) .FirstOrDefaultAsync(o => o.Id == id && o.AppUserId == userId), OrderDetails = await _db.OrderDetails.Where(o => o.OrderHeaderId == id).ToListAsync() }; return(View(orderDetail)); }
public IActionResult OrderPickupDetails(int orderId) { OrderDetailsViewModel orderDetailsVM = new OrderDetailsViewModel() { OrderHeader = _db.OrderHeader.Where(o => o.Id == orderId).FirstOrDefault() }; orderDetailsVM.OrderHeader.ApplicationUser = _db.ApplicationUser.Where(u => u.Id == orderDetailsVM.OrderHeader.UserId).FirstOrDefault(); orderDetailsVM.OrderDetail = _db.OrderDetails.Where(o => o.OrderId == orderDetailsVM.OrderHeader.Id).ToList(); return(View(orderDetailsVM)); }
public async Task <IActionResult> Confirm(Guid id) { //var claimsIdentity = (ClaimsIdentity)User.Identity; //var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel { OrderHeader = await _db.OrderHeader.Include(o => o.User).FirstOrDefaultAsync(o => o.Id.ToString().Equals(id.ToString())), OrderDetails = await _db.OrderDetails.Where(o => o.OrderId.ToString().Equals(id.ToString())).ToListAsync() }; return(View(orderDetailsViewModel)); }
public IActionResult DeleteOrderPost(OrderDetailsViewModel orderDetailsViewModel) { try { _orderService.DeleteOrder(orderDetailsViewModel.Id); return(RedirectToAction("Index")); } catch (Exception ex) { ViewData["ErrMessage"] = ex.Message; return(View("ExceptionView")); } }
public async Task <IActionResult> Confirm(int id) { var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel() { OrderHeader = await _db.OrderHeader.Include(o => o.ApplicationUser).FirstOrDefaultAsync(o => o.Id == id && o.UserId == claim.Value), OrderDetails = await _db.OrderDetails.Where(o => o.OrderId == id).ToListAsync() }; return(View(orderDetailsViewModel)); }
public IHttpActionResult Details(Guid id) { try { OrderDetailsViewModel model = this.order.Details(id); return(Ok(model)); } catch (BadRequestException bre) { ModelState.AddModelError(CommonConstants.ErrorKey, bre.Message); return(BadRequest(ModelState)); } }
public IActionResult DeleteOrderPost(OrderDetailsViewModel orderDetailsViewModel) { //find the index of the order var index = StaticDb.Orders.FindIndex(x => x.Id == orderDetailsViewModel.Id); //check if the order exists if (index == -1) { return(View("ResourceNotFound")); } StaticDb.Orders.RemoveAt(index); return(RedirectToAction("Index")); }
public IActionResult GetOrder(int id, int orderId) { var order = Context.Orders.Include(o => o.ExtraItems).SingleOrDefault(x => x.Id.Equals(orderId) && x.CustomerId.Equals(id)); if (order == null) { return(NotFound()); } var orderViewModel = new OrderDetailsViewModel(order.CustomerId, order.CarId, order.ExtraItems, order.TotalCost); return(Ok(orderViewModel)); }
public async Task <IActionResult> GetOrderDetails(int id) { var orderDetailViewModel = new OrderDetailsViewModel { OrderHeader = await this.db.OrderHeader.FirstOrDefaultAsync(h => h.Id == id), OrderDetails = await this.db.OrderDetails.Where(d => d.OrderId == id).ToListAsync() }; orderDetailViewModel.OrderHeader.ApplicationUser = await this.db.ApplicationUser.FirstOrDefaultAsync(u => u.Id == orderDetailViewModel.OrderHeader.UserId); return(this.PartialView("_IndividualOrderDetails", orderDetailViewModel)); }
/// <summary> /// Constructor /// </summary> /// <param name="_objOrderDetailsViewModel"></param> /// <param name="commandStatus"></param> public OrderDetailsModel(OrderDetailsViewModel _objOrderDetailsViewModel, string commandStatus) { orderDetailsViewModel = _objOrderDetailsViewModel; if (commandStatus.Equals("cancel")) { CallWebserviceCancel(); } else { CallWebserviceReorder(); } }
public FrmSellProduct() { InitializeComponent(); CustomerViewModel = new CustomerViewModel(); ProductViewModel = new ProductViewModel(); OrderDetailsViewModel = new OrderDetailsViewModel(); OrderViewModel = new OrderViewModel(); GridViewOrderDetails = new BindingList <OrderDetails>(); Order = new Order(); }
//pass order header id public IActionResult Details(int id) { var orderDetailsViewModel = new OrderDetailsViewModel() { OrderHeader = _unitOfWork.OrderHeader .GetFirstOrDefault(orderHeader => orderHeader.Id == id, includeProperties: "ApplicationUser"), OrderDetailList = _unitOfWork.OrderDetail .GetAll(orderDetails => orderDetails.OrderHeaderId == id, includeProperties: "Product") }; return(View(orderDetailsViewModel)); }
public IActionResult ShipOrder(OrderDetailsViewModel orderDetailsViewModel) { var orderHeader = _unitOfWork.OrderHeader .GetFirstOrDefault(order => order.Id == orderDetailsViewModel.OrderHeader.Id); orderHeader.TrackingNumber = orderDetailsViewModel.OrderHeader.TrackingNumber; orderHeader.Carrier = orderDetailsViewModel.OrderHeader.Carrier; orderHeader.OrderStatus = GlobalUti.StatusShipped; orderHeader.ShippingDate = DateTime.Now; _unitOfWork.Save(); return(RedirectToAction(nameof(Index))); }
public async Task <IActionResult> Create(OrderDetailsViewModel order) { this.telemetry.TrackEvent("Create Order"); if (this.ModelState.IsValid) { InvoiceDetailsViewModel invoice; invoice = await this.eCommerceService.SubmitOrder(order).ConfigureAwait(false); return(this.RedirectToAction("Index", new { invoiceId = invoice.Id })); } return(this.RedirectToAction("Index", "Cart", new { orderId = order.Id })); }
/// <inheritdoc/> public async Task <OrderDetailsViewModel> AddOrderAsync(OrderDetailsViewModel order) { NotNullValidator.ThrowIfNull(order, nameof(order)); // Order entity is used for Shopping cart and at any point as there can only be one shopping cart, checking for existing shopping cart var getExistingOrder = await this.GetOrdersAsync($" e.UserId = '{order.UserId}' and e.OrderStatus = '{OrderStatus.Cart}' ").ConfigureAwait(false); OrderDetailsViewModel existingOrder = getExistingOrder.FirstOrDefault(); if (existingOrder != null) { order.Id = existingOrder.Id; order.Etag = existingOrder.Etag; if (order.OrderStatus == OrderStatus.Submitted.ToString()) { order.OrderPlacedDate = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture); order.DeliveryDate = DateTime.UtcNow.AddDays(5).ToString(CultureInfo.InvariantCulture); Random trackingId = new Random(); order.TrackingId = trackingId.Next(int.MaxValue); // generating random tracking number } else { order.Products.AddRange(existingOrder.Products); // For cart append products order.OrderStatus = OrderStatus.Cart.ToString(); } order.OrderTotal = order.Products.Sum(x => x.Price); await this.UpdateOrderAsync(order).ConfigureAwait(false); return(order); } else { order.OrderStatus = OrderStatus.Cart.ToString(); order.Id = Guid.NewGuid().ToString(); order.OrderTotal = order.Products.Sum(x => x.Price); using var orderRequest = new StringContent(JsonSerializer.Serialize(order), Encoding.UTF8, ContentType); var orderResponse = await this.httpClient.PostAsync(new Uri($"{this.applicationSettings.Value.DataStoreEndpoint}api/orders"), orderRequest).ConfigureAwait(false); if (!orderResponse.IsSuccessStatusCode) { await this.ThrowServiceToServiceErrors(orderResponse).ConfigureAwait(false); } var createdOrderDAO = await orderResponse.Content.ReadFromJsonAsync <Packt.Ecommerce.Data.Models.Order>().ConfigureAwait(false); // Mapping var createdOrder = this.autoMapper.Map <OrderDetailsViewModel>(createdOrderDAO); return(createdOrder); } }
public async Task <IActionResult> Confirm(int id) { //Identity the user Id var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderDetailsViewModel orderDetailsVM = new OrderDetailsViewModel() { OrderHeader = await context.OrderHeaders.Include(m => m.ApplicationUser).FirstOrDefaultAsync(m => m.Id == id && m.UserId == claim.Value), OrderDetails = await context.OrderDetails.Where(m => m.OrderId == id).ToListAsync() }; return(View(orderDetailsVM)); }
public IActionResult Details(int id) { if (id < 1) { return(BadRequest()); } try { var mappedEmployees = EmployeeMapper.MapManyToViewModel(employeeService.GetEmployees()); if (mappedEmployees == null) { mappedEmployees = new List <EmployeeViewModel>(); } var mappedInvoices = InvoiceMapper.MapManyToViewModel(invoiceService.GetInvoices()); if (mappedInvoices == null) { mappedInvoices = new List <InvoiceViewModel>(); } var mappedProducts = ProductMapper.MapManyToViewModel(productService.GetProducts()); if (mappedProducts == null) { mappedProducts = new List <ProductViewModel>(); } var mappedProtocols = ProtocolMapper.MapManyToViewModel(protocolService.GetProtocols()); if (mappedProtocols == null) { mappedProtocols = new List <ProtocolViewModel>(); } var mappedClients = ClientMapper.MapManyToViewModel(clientService.GetClients()); if (mappedClients == null) { mappedClients = new List <ClientViewModel>(); } var order = orderService.GetOrderById(id); var mappedOrder = OrderMapper.MapToViewModel(order, order.Employee, order.Client, order.Product, order.Protocol, order.Invoice); var orderDetails = new OrderDetailsViewModel(mappedEmployees, mappedClients, mappedProducts, mappedProtocols, mappedInvoices, mappedOrder); return(View(orderDetails)); } catch (Exception ex) { return(NotFound(ex.Message)); } }
public IActionResult Get(string status = null) { List <OrderDetailsViewModel> orderListVM = new List <OrderDetailsViewModel>(); IEnumerable <OrderHeader> OrderHeaderList; if (User.IsInRole(SD.CustomerRole)) { //retrive all orders for that customer var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); OrderHeaderList = _unitOfWork.OrderHeader.GetAll(u => u.UserId == claim.Value, null, "ApplicationUser"); } else { OrderHeaderList = _unitOfWork.OrderHeader.GetAll(null, null, "ApplicationUser"); } if (status == "cancelled") { OrderHeaderList = OrderHeaderList.Where(o => o.Status == SD.StatusCancelled || o.Status == SD.StatusRefunded || o.Status == SD.PaymentStatusRejected); } else { if (status == "completed") { OrderHeaderList = OrderHeaderList.Where(o => o.Status == SD.StatusCompleted); } else { OrderHeaderList = OrderHeaderList.Where(o => o.Status == SD.StatusReady || o.Status == SD.StatusInProcess || o.Status == SD.StatusSubmitted || o.Status == SD.PaymentStatusPending); } } foreach (OrderHeader item in OrderHeaderList) { OrderDetailsViewModel individual = new OrderDetailsViewModel { OrderHeader = item, OrderDetails = _unitOfWork.OrderDetail.GetAll(o => o.OrderId == item.Id).ToList() }; orderListVM.Add(individual); } return(Json(new { data = orderListVM })); }
public void Check_sending_retail_info() { restore = true; var order = session.Query <Order>().FirstOrDefault(); if (order == null) { var address = session.Query <Address>().FirstOrDefault(); if (address == null) { address = new Address { Name = "Тестовый адрес доставки" }; session.Save(address); } var price = session.Query <Price>().FirstOrDefault(); if (price == null) { price = new Price("тест"); session.Save(price); } var offer = session.Query <Offer>().FirstOrDefault(r => r.Price == price); if (offer == null) { offer = new Offer(price, 100); session.Save(offer); } order = new Order(address, offer); session.Save(order); } var model = new OrderDetailsViewModel(order); model.User.SendRetailMarkup = true; UseWindow(model, async(w, view) => { var grid = view.Descendants <DataGrid>().First(c => c.Name == "Lines"); var column = DataGridHelper.FindColumn(grid.Columns, "Розничная наценка"); Assert.IsNotNull(column); }); user.SendRetailMarkup = false; model = new OrderDetailsViewModel(order); model.User.SendRetailMarkup = false; UseWindow(model, async(w, view) => { var grid = view.Descendants <DataGrid>().First(c => c.Name == "Lines"); var column = DataGridHelper.FindColumn(grid.Columns, "Розничная наценка"); Assert.IsNull(column); }); }
public void VerifyTransactionInfoModificationsInOrderDetails() { var orderDetailsViewModel = new OrderDetailsViewModel(new MockAccountPositionService(), null); var transactionInfo = new TransactionInfo { TickerSymbol = "Fund0", TransactionType = TransactionType.Buy }; orderDetailsViewModel.TransactionInfo = transactionInfo; orderDetailsViewModel.TransactionType = TransactionType.Sell; Assert.AreEqual(TransactionType.Sell, transactionInfo.TransactionType); orderDetailsViewModel.TickerSymbol = "Fund1"; Assert.AreEqual("Fund1", transactionInfo.TickerSymbol); }