/// <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);
}
