public async Task <List <OrderHistoryViewModel> > GetOrderHistory(int userId) { var ListOrderHistory = new List <OrderHistoryViewModel>(); foreach (var item in await db.Orders.Where(p => p.Status == 0).ToListAsync()) { var listOrderHistory = new OrderHistoryViewModel(); listOrderHistory.OrderId = item.Id; listOrderHistory.Total = item.TotalPrice; var CheckOrdertracking = await db.OrderTrackings.FirstOrDefaultAsync(p => p.State == "Delivered" && p.Status == 1); listOrderHistory.State = CheckOrdertracking.State; listOrderHistory.Time = (DateTime)CheckOrdertracking.UpdatedAt; var CountOrderDetail = await db.OrderDetails.Where(p => p.OrderId == CheckOrdertracking.OrderId).ToListAsync(); foreach (var item1 in CountOrderDetail) { var food = await db.Foods.SingleOrDefaultAsync(p => p.Id == item1.FoodId); listOrderHistory.Image = food.Images; } listOrderHistory.CountOrder = CountOrderDetail.Count(); var ListRestaurant = await db.Restaurants.FirstOrDefaultAsync(p => p.Id == item.ShipperId); listOrderHistory.NameRestaurant = ListRestaurant.Name; // addd list ListOrderHistory ListOrderHistory.Add(listOrderHistory); //=============== } return(ListOrderHistory); }
public void UserRegister_Post_GetResult() { //Arrange OrderHistoryViewModel orderHistory = new OrderHistoryViewModel { CustomerName = "", DateAdded = DateTime.Now.ToString(), NoOfProducts = 5, OrderID = 1, Status = "C", Total = 1250 }; var orderService = new Mock <IOrderService>(); var emailSettings = new Mock <EmailSettings>(); // //Act // var controller = new UserController(userUservice.Object, userRepo.Object, apSettings.Object, addressRepo.Object); // orderService.Setup(x => x.RegisterUser(model, model.Password)).Returns(orderHistory); // var result = controller.Register(model); // //Assert // Assert.IsNotNull(result); // Assert.AreEqual(200, (result as OkObjectResult).StatusCode); }
public ActionResult GetOrdersByDate(OrderHistoryViewModel orderHistoryViewModel) { orderHistoryViewModel = orderHistoryViewModel ?? new OrderHistoryViewModel(); var defaultDate = new DateTime(01, 01, 01, 00, 00, 00); if (orderHistoryViewModel.DateFrom == defaultDate) { orderHistoryViewModel.DateFrom = DateTime.UtcNow.AddYears(-100); } if (orderHistoryViewModel.DateTo == defaultDate) { orderHistoryViewModel.DateTo = DateTime.UtcNow.AddDays(-30); } IEnumerable <OrderModel> orderModels = _orderService.GetOrdersByDate(orderHistoryViewModel.DateFrom, orderHistoryViewModel.DateTo); var orderViewModels = Mapper.Map <IEnumerable <OrderViewModel> >(orderModels); orderHistoryViewModel.Orders = orderViewModels.ToList(); return(View("History", orderHistoryViewModel)); }
public ActionResult Transactions() { var user = db.Users.Where(i => i.Login == HttpContext.User.Identity.Name).FirstOrDefault(); if (user != null) { var sold = user.SoldTransactions.OrderByDescending(t => t.CreationDate).ToList(); var bought = user.BoughtTransactions.OrderByDescending(t => t.CreationDate).ToList(); if (sold != null && bought != null) { OrderHistoryViewModel OHVM = new OrderHistoryViewModel() { Sold = sold, Bought = bought }; if (OHVM != null) { return(View(OHVM)); } else { return(new HttpStatusCodeResult(500)); } } else { return(new HttpStatusCodeResult(500)); } } else { return(new HttpStatusCodeResult(404)); } }
public ActionResult OrderHistory() { var model = new OrderHistoryViewModel(); var person = personProvider.GetPerson(CurrentUserName); model.PersonId = person.Id; return(View(model)); }
public OrderHistoryPage() { creation = true; InitializeComponent(); BindingContext = vm = new OrderHistoryViewModel(this); }
public ActionResult Index() { var model = new OrderHistoryViewModel(); LoadOrders(model); model.RewardPoints = HccApp.CustomerPointsManager.FindAvailablePoints(HccApp.CurrentCustomerId); return(View(model)); }
public ActionResult Index(SubscriptionDetailPage currentPage, int paymentPlanId = 0) { var paymentDetail = OrderContext.Current.Get <PaymentPlan>(paymentPlanId); var viewModel = new SubscriptionDetailViewModel(currentPage) { CurrentContent = currentPage, PaymentPlan = paymentDetail }; //Get order that created by var purchaseOrders = OrderContext.Current.LoadByCustomerId <PurchaseOrder>(PrincipalInfo.CurrentPrincipal.GetContactId()) .OrderByDescending(x => x.Created) .Where(x => x.ParentOrderGroupId.Equals(paymentPlanId)) .ToList(); var orders = new OrderHistoryViewModel { Orders = new List <OrderViewModel>() }; foreach (var purchaseOrder in purchaseOrders) { // Assume there is only one form per purchase. var form = purchaseOrder.GetFirstForm(); var billingAddress = new AddressModel(); var payment = form.Payments.FirstOrDefault(); if (payment != null) { billingAddress = _addressBookService.ConvertToModel(payment.BillingAddress); } var orderViewModel = new OrderViewModel { PurchaseOrder = purchaseOrder, Items = form.GetAllLineItems().Select(lineItem => new OrderHistoryItemViewModel { LineItem = lineItem, }).GroupBy(x => x.LineItem.Code).Select(group => group.First()), BillingAddress = billingAddress, ShippingAddresses = new List <AddressModel>() }; foreach (var orderAddress in purchaseOrder.OrderForms.Cast <IOrderForm>().SelectMany(x => x.Shipments).Select(s => s.ShippingAddress)) { var shippingAddress = _addressBookService.ConvertToModel(orderAddress); orderViewModel.ShippingAddresses.Add(shippingAddress); } orders.Orders.Add(orderViewModel); } orders.OrderDetailsPageUrl = UrlResolver.Current.GetUrl(_settingsService.GetSiteSettings <ReferencePageSettings>()?.OrderDetailsPage ?? ContentReference.StartPage); viewModel.Orders = orders; return(View(viewModel)); }
public async Task <IActionResult> OrderHistory() { OrderHistoryViewModel _orderHistoryVM = new OrderHistoryViewModel(); string UserID = User.FindFirstValue(ClaimTypes.NameIdentifier); _orderHistoryVM.OrderList = await _orderService.GetAllOrdersByUserIDAsync(UserID); return(View(_orderHistoryVM)); }
public ActionResult GetOrdersForLastMonth() { var orderHistoryViewModel = new OrderHistoryViewModel { DateFrom = DateTime.UtcNow.AddDays(-30), DateTo = DateTime.UtcNow, }; return(GetOrdersByDate(orderHistoryViewModel)); }
public ActionResult GetHistory() { OrderHistoryViewModel ohvm = new OrderHistoryViewModel { StartDate = DateTime.Now, EndDate = DateTime.Now, OrderList = _orderService.GetOrdersHistory(DateTime.Now, DateTime.Now).ToList() }; return(View("OrderHistory", ohvm)); }
public ActionResult Index() { var orderHistoryViewModel = new OrderHistoryViewModel() { OrderHistoryList = _context.GetCachedOrderHistory() }; orderHistoryViewModel.CreateDataPoints(); return(View(orderHistoryViewModel)); }
public IActionResult OrderHistory() { string currUserEmail = HttpContext.Session.GetString("User"); User currUser = dbContext.Users.Where(u => u.email == currUserEmail).FirstOrDefault(); OrderHistoryViewModel orderHistory = new OrderHistoryViewModel(); orderHistory.myOrders = dbContext.Orders.Where(o => o.UserID == currUser.UserID).ToList(); return(View(orderHistory)); }
public ActionResult Index(OrderHistoryPage currentPage) { var purchaseOrders = OrderContext.Current.GetPurchaseOrders(_customerContext.CurrentContactId) .OrderByDescending(x => x.Created) .ToList(); var lineItems = purchaseOrders.SelectMany(x => x.OrderForms.Any() ? x.OrderForms.First().LineItems.ToList() : new List <LineItem>()); var variations = _contentLoader.GetItems(lineItems.Select(x => _referenceConverter.GetContentLink(x.Code)).ToList(), _preferredCulture).OfType <VariationContent>(); var orders = OrderContext.Current.GetPurchaseOrders(_customerContext.CurrentContactId); var viewModel = new OrderHistoryViewModel { CurrentPage = currentPage, Orders = new List <Order>() }; foreach (var item in orders.OrderByDescending(x => x.Created)) { // Assume there is only one form per purchase. OrderForm form = item.OrderForms[0]; Order order = new Order { PurchaseOrder = item, Items = form.LineItems.Select(lineItem => new OrderHistoryItem { LineItem = lineItem, Variation = variations.FirstOrDefault(y => y.Code == lineItem.Code) }), BillingAddress = new Address(), ShippingAddresses = new List <Address>() }; // Identify the id for all shipping addresses. IEnumerable <string> shippingAddressIdCollection = item.OrderForms.SelectMany(x => x.Shipments).Select(s => s.ShippingAddressId); // Map the billing address using the billing id of the order form. _addressBookService.MapOrderAddressToModel(order.BillingAddress, item.OrderAddresses.Single(x => x.Name == form.BillingAddressId)); // Map the remaining addresses as shipping addresses. foreach (OrderAddress orderAddress in item.OrderAddresses.Where(x => shippingAddressIdCollection.Contains(x.Name))) { ShippingAddress shippingAddress = new ShippingAddress(); _addressBookService.MapOrderAddressToModel(shippingAddress, orderAddress); order.ShippingAddresses.Add(shippingAddress); } viewModel.Orders.Add(order); } return(View(viewModel)); }
public virtual ActionResult GetOrderHistory(string orderId) { LogI("GetOrderHistory, orderId=" + orderId); var model = OrderHistoryViewModel.GetByOrderId(Db, LogService, WeightService, orderId); return(JsonGet(new ValueResult <OrderHistoryViewModel>() { IsSuccess = model != null, Data = model })); }
// GET: Profile/OrderHistory public async Task <IActionResult> OrderHistory() { var user = await GetCurrentUserAsync(); var viewModel = new OrderHistoryViewModel(_context, user); if (viewModel == null) { return(NotFound()); } return(View(viewModel)); }
/// <summary> /// Get and display the order overview /// </summary> /// <returns></returns> public async Task <IActionResult> OrderHistory() { int userId = int.Parse(HttpContext.User.FindFirst(claim => claim.Type == "UserId").Value); List <Order> orders = new List <Order>(); var items = await _orderRepo.GetOrderHistory(userId); orders.AddRange(items); var historyVM = new OrderHistoryViewModel { Orders = orders }; return(View(historyVM)); }
public IActionResult History(string id) { var userHistory = new OrderHistoryViewModel(); userHistory.User = id; long userId = _ctx.GetUsersId(id); userHistory.Orders = _ctx.getUserOrders(userId); return(View("Select", userHistory)); }
public ActionResult ViewOrderHistory() { var user = UserManager.FindById(User.Identity.GetUserId()); if (user == null) { return(View("Error")); } OrderHistoryViewModel model = new OrderHistoryViewModel(); model = OrderHistoryViewModel.GetOrderHistory(user.Id); return(View(model)); }
public ActionResult Index(OrderHistoryPage currentPage) { var storeAppPurchaseOrders = _orderRepository.Load <IPurchaseOrder>(_customerContext.CurrentContactId, "StoreApp") .OrderByDescending(x => x.Created) .ToList(); var purchaseOrders = _orderRepository.Load <IPurchaseOrder>(_customerContext.CurrentContactId) .OrderByDescending(x => x.Created) .ToList(); var viewModel = new OrderHistoryViewModel { CurrentPage = currentPage, Orders = new List <OrderViewModel>() }; foreach (var purchaseOrder in purchaseOrders.Union(storeAppPurchaseOrders).OrderByDescending(x => x.Created)) { // Assume there is only one form per purchase. var form = purchaseOrder.GetFirstForm(); var billingAddress = new AddressModel(); var payment = form.Payments.FirstOrDefault(); if (payment != null) { billingAddress = _addressBookService.ConvertToModel(payment.BillingAddress); } var orderViewModel = new OrderViewModel { PurchaseOrder = purchaseOrder, Items = form.GetAllLineItems().Select(lineItem => new OrderHistoryItemViewModel { LineItem = lineItem, }).GroupBy(x => x.LineItem.Code).Select(group => group.First()), BillingAddress = billingAddress, ShippingAddresses = new List <AddressModel>() }; foreach (var orderAddress in purchaseOrder.Forms.SelectMany(x => x.Shipments).Select(s => s.ShippingAddress)) { var shippingAddress = _addressBookService.ConvertToModel(orderAddress); orderViewModel.ShippingAddresses.Add(shippingAddress); } viewModel.Orders.Add(orderViewModel); } return(View(viewModel)); }
public IActionResult OrderHistory() { var userId = _userManager.GetUserId(User); Customer customer = _unitOfWork.Customers.GetCustomerByWebShopId(userId); var orders = _unitOfWork.Orders.GetOrdersWithProducts(customer.CustomerId); OrderHistoryViewModel viewModel = new OrderHistoryViewModel { Orders = orders }; return(View(viewModel)); }
/// <summary> /// Creates the view model. /// </summary> /// <param name="param">The parameters required to create the view model.</param> /// <returns /> public virtual OrderHistoryViewModel CreateViewModel(GetOrderHistoryViewModelParam param) { if (param == null) { throw new ArgumentNullException("param"); } if (param.CultureInfo == null) { throw new ArgumentException("param.CultureInfo"); } if (param.OrderStatuses == null) { throw new ArgumentException("param.OrderStatuses"); } if (string.IsNullOrWhiteSpace(param.OrderDetailBaseUrl)) { throw new ArgumentException("param.OrderDetailBaseUrl"); } OrderHistoryViewModel viewModel = null; if (param.OrderResult != null && param.OrderResult.Results != null) { viewModel = new OrderHistoryViewModel { Orders = new List <LightOrderDetailViewModel>(), Pagination = BuildOrderHistoryPagination(new OrderHistoryPaginationParam { CultureInfo = param.CultureInfo, CurrentPage = param.Page, TotalNumberOfOrders = param.OrderResult.TotalCount }) }; foreach (var rawOrder in param.OrderResult.Results) { var order = BuildLightOrderDetailViewModel(rawOrder, param); viewModel.Orders.Add(order); } } return(viewModel); }
private void LoadOrders(OrderHistoryViewModel model) { var pageSize = 20; var totalCount = 0; var pageNumber = GetPageNumber(); // pull all Orders model.Orders = HccApp.OrderServices.Orders.FindByUserId(HccApp.CurrentCustomerId, pageNumber, pageSize, ref totalCount); model.PagerData = new PagerViewModel { PageSize = pageSize, TotalItems = totalCount, CurrentPage = pageNumber, PagerUrlFormat = HccUrlBuilder.RouteHccUrl(HccRoute.OrderHistory, new { page = "{0}" }), PagerUrlFormatFirst = HccUrlBuilder.RouteHccUrl(HccRoute.OrderHistory) }; }
public ActionResult PlaceOrder(FormPlaceOrder getID) { int custID = getID.CustomerID; int locID = getID.LocationID; int amounts = getID.Amounts; int recordID = getID.RecordID; var custOrder = _repository.AddToOrder(custID, locID, recordID, amounts); var custOrderModel = new OrderHistoryViewModel() { OrderRecordId = custOrder.OrderRecordId, OrderId = custOrder.OrderId, RecordId = custOrder.RecordId, RecordAmount = custOrder.RecordAmount }; // Display Order Details with Order ID from AddToOrder return(View(custOrderModel)); }
public ActionResult Details(int id) { OrderHistory orderHistory = _orderhistoryRepo.GetOrderHistoryByOrderId(id); var viewModel = new OrderHistoryViewModel { OrderId = orderHistory.OrderId, LocationId = orderHistory.LocationId, CustomerId = orderHistory.CustomerId, Date = orderHistory.Date, Time = orderHistory.Time, Orders = _ordersRepo.GetOrdersByOrderId(id).Select(t => new OrdersViewModel { OrderID = t.OrderID, ProductID = t.ProductID, Name = t.Name, Amount = t.Amount }) }; return(View(viewModel)); }
//GET: Orders/OrderHistory public async Task <IActionResult> OrderHistory(int?id) { OrderHistoryViewModel model = new OrderHistoryViewModel(); var currentUser = await GetCurrentUserAsync(); List <Order> orders = await _context.Order .Include(o => o.PaymentType) .Include(o => o.User) .Include(o => o.OrderProducts) .ThenInclude(op => op.Product) .Where(m => m.UserId == currentUser.Id.ToString() && m.PaymentTypeId != null).ToListAsync(); model.OrderHistory = orders; if (orders == null) { return(RedirectToAction("Index", "Home")); } return(View(model)); }
public List <OrderHistoryViewModel> GetOrderHistory(int ID) { var orders = orderRepository.GetAllByUserID(ID); List <OrderHistoryViewModel> orderHistoryList = new List <OrderHistoryViewModel>(); foreach (var order in orders) { List <OrderDetail> orderDetails = orderDetailRepository.GetAllByOrderID(order.OrderId); OrderHistoryViewModel orderHistory = new OrderHistoryViewModel() { OrderID = order.OrderId, CustomerName = "", Status = "shipped", NoOfProducts = orderDetails.Count, Total = (decimal)order.TotalAmount, DateAdded = order.DateCreated.ToString() }; orderHistoryList.Add(orderHistory); } return(orderHistoryList); }
public ActionResult ViewOrderDetails(FormOrderDetails getID) { try { var orderDetails = _repository.DisplayOrderHistoryDetails(getID.OrderID); var custOrderModel = new OrderHistoryViewModel() { OrderId = orderDetails.OrderId, RecordId = orderDetails.RecordId, RecordAmount = orderDetails.RecordAmount, OrderRecordId = orderDetails.OrderRecordId }; return(View(custOrderModel)); } catch (System.NullReferenceException ex) { Logger logger = LogManager.GetCurrentClassLogger(); logger.ErrorException("Argument Null Exception! Careful", ex); return(View()); } }
public ActionResult MakeShipped(int orderId, DateTime dateFrom, DateTime dateTo) { var orderHistoryViewModel = new OrderHistoryViewModel { DateFrom = dateFrom, DateTo = dateTo, }; OrderModel orderModel = _orderService.GetModelById(orderId); if (orderModel == null || orderModel.IsReadonly || orderModel.OrderStatus != OrderStatus.Payed) { return(RedirectToAction("History", "Order", orderHistoryViewModel)); } orderModel.OrderStatus = OrderStatus.Shipped; _orderService.Update(orderModel); MessageSuccess("The order status has been changed to 'Shipped'. "); return(RedirectToAction("History", "Order", orderHistoryViewModel)); }
// // GET: /Account/OrderHistory public ActionResult OrderHistory(OrderHistoryViewModel model) { Int32 itemsPerPage = 5; User user = _userService.GetWithOrders(Utility.Helpers.IdentityHelpers.GetUserId(this.HttpContext.User.Identity)); IQueryable <Order> ordersQuery = user.Orders.AsQueryable(); if (model.From != null) { ordersQuery = ordersQuery.Where(o => o.OrderDate > model.From); } if (model.To != null) { ordersQuery = ordersQuery.Where(o => o.OrderDate < model.To); } model.Orders = ordersQuery.OrderByDescending(o => o.OrderDate).ToPagedList <Order>(model.PageNumber, itemsPerPage); return(View(model)); }