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