public ActionResult Track(string searchString, string currentFilter, int?page)
{
if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}
ViewBag.CurrentFilter = searchString;
List <OrderTrack> orders = db.OrderTracks.Where(x => x.OrderNumber.OrderNumber == searchString).OrderByDescending(x => x.status).ToList();
OrderIndexViewModel oivn1 = new OrderIndexViewModel()
{
orders = orders
};
if (!String.IsNullOrEmpty(searchString))
{
orders = orders.Where(o => o.OrderNumber.Equals(searchString)).ToList();
}
return(View(oivn1));
}
// GET: Orders
public ActionResult Index(string SearchString, String city, int page = 1)
{
var orders = db.Orders.OfType <Order>();
if (!String.IsNullOrEmpty(SearchString))
{
orders = orders.Where(a => a.City.Name.ToUpper().Contains(SearchString.ToUpper()) ||
a.Order_description.ToUpper().Contains(SearchString.ToUpper()) ||
a.Order_title.ToUpper().Contains(SearchString.ToUpper()));
}
var cities = orders.Select(o => o.City.Name).Distinct();
ViewBag.city = new SelectList(cities);
//pagination steps
int pageSize = 6;
var pager = new Pager(orders.Count(), page, pageSize);
OrderIndexViewModel vModel = new OrderIndexViewModel()
{
Orders = orders.OrderBy(a => a.Order_date).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize),
Pager = pager,
SearchString = SearchString,
City = city,
};
return(View(vModel));
}
public async Task <IActionResult> Index(OrderIndexViewModel orderIndexViewModel, CancellationToken cancellationToken)
{
if (ModelState.IsValid)
{
var viewModel = new List <TicketDetailViewModel>();
var ticketTypes = await _orderService.GetTicketTypesAsync(false, false, cancellationToken);
var ticketIndex = 0;
foreach (var ticketTypeOrdered in orderIndexViewModel.AvailableTicketTypes.Where(x => x.Value.QuantityOrdered > 0))
{
var ticketTypeId = ticketTypeOrdered.Key;
var quantityOrderedForTicketType = ticketTypeOrdered.Value.QuantityOrdered;
for (var i = 0; i < quantityOrderedForTicketType; i++)
{
var ticketType = ticketTypes.FirstOrDefault(x => x.Id == ticketTypeId);
viewModel.Add(new TicketDetailViewModel
{
Id = ++ticketIndex,
TicketType = ticketType != null
? new TicketTypeViewModel(ticketType)
: null,
});
}
}
return(View("TicketDetail", viewModel));
}
return(View(orderIndexViewModel));
}
public async Task <IActionResult> Create(OrderIndexViewModel viewModel)
{
var user = await _userManager.GetUserAsync(User);
var cart = SessionHelper.GetObjectFromJson <List <CartItem> >(HttpContext.Session, "cart");
Order order = new Order();
if (ModelState.IsValid)
{
order.UserId = user.Id;
order.UserName = user.UserName;
order.OrderDate = DateTime.Now.Date;
order.UserAddress = _context.UserAddress.Where(i => i.UserAddressId == viewModel.AddressId).Select(n => n.Address).FirstOrDefault();
order.Total = cart.Sum(item => item.Hamper.HamperPrice * item.Quantity);
order.TotalWithShipping = order.Total + (decimal)7.5;
_context.Add(order);
foreach (var hamper in cart)
{
OrderHamper orderHamper = new OrderHamper();
orderHamper.OrderId = order.OrderId;
orderHamper.HamperName = hamper.Hamper.HamperName;
orderHamper.Qty = hamper.Quantity;
_context.Add(orderHamper);
}
//_context.Add(orderHamper);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Index(OrderGetDTO dtoGet, OrderPostDTO dtoPost)
{
OrderIndexViewModel model = orderManager.PostOrderIndexViewModel(dtoGet, dtoPost);
dbManager.Commit();
return(View("Order", model));
}
public IActionResult Index(OrderGetDTO dto)
{
OrderIndexViewModel model = orderManager.GetOrderIndexViewModel(dto);
dbManager.Commit();
return(View("Order", model));
}
public IActionResult UpdateOrder(OrderIndexViewModel model)
{
ViewData["Message"] = "";
if (model.FurnitureCount <= 0)
{
ViewData["Message"] += "Неправильное значение количества мебели";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else if (model.DiscountPercent < 0 || model.DiscountPercent > 99)
{
ViewData["Message"] += "Неправильное значение скидки";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else if (model.Price <= 0)
{
ViewData["Message"] += "Неправильное значение стоимости";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else
{
var order = db.Orders.Where(item => item.Id == model.Id).FirstOrDefault();
order.DiscountPercent = model.DiscountPercent;
order.ClientId = db.Clients.Where(item => item.Name == model.ClientName).First().Id;
order.EmployeeId = db.Employees.Where(item => item.FIO == model.EmployeeFIO).First().Id;
order.Price = model.Price;
order.FurnitureCount = model.FurnitureCount;
order.FurnitureId = db.Furniture.Where(item => item.Name == model.FurnitureName).First().Id;
order.IsCompleted = model.IsCompleted ? 1 : 0;
db.SaveChanges();
cache.Remove("Orders");
return(RedirectToAction("Index", "Order"));
}
}
public ActionResult Index(int?page)
{
OrderIndexViewModel model = new OrderIndexViewModel();
model.OrderList = _orderService.GetAll().OrderByDescending(i => i.Date_Rented).ToPagedList(page ?? 1, PAGE_SIZE);
return(View(GetIndexViewModel(model)));
}
private OrderIndexViewModel GetIndexViewModel(OrderIndexViewModel currModel)
{
currModel.FilterModel = currModel.FilterModel ?? new OrderFilterModel();
//To wlasciwie ta sama lista Tak = 1, Nie = 0
currModel.ReturnedSelectList = _itemService.GetAvaibleSelectList();
currModel.CustomerSelectList = _customerService.GetSelectCustomerList();
return(currModel);
}
public IActionResult Index()
{
IEnumerable <Tour> Tours = db.Tours.Where(t => t.CountOfPlace > 0);
OrderIndexViewModel viewModel = new OrderIndexViewModel {
Tours = Tours, Vouchers = db.Vouchers
};
return(View(viewModel));
}
public ActionResult Index()
{
var model = new OrderIndexViewModel
{
Orders = _session.Query <Order>().ToList()
};
return(View(model));
}
// GET: Orders
public IActionResult Index()
{
var model = new OrderIndexViewModel
{
Orders = _orderManager.GetOrders()
};
return(View(model));
}
public ActionResult Index()
{
var model = new OrderIndexViewModel
{
Orders = _session.Query<Order>().ToList()
};
return View(model);
}
private OrderIndexViewModel FillViewModel(OrderIndexViewModel model)
{
model.Areas = dbManager.GetAll <OrderArea>().ToList().Where(x => !String.IsNullOrEmpty(x.Name)).ToList();
model.Dispetchers = employeeManager.GetFreeDispetchers(model.Order);
model.Chiefs = employeeManager.GetFreeChiefs(model.Order);
model.MiningMasters = employeeManager.GetFreeMasters(model.Order);
model.Machines = GetMachinesForOrder(model.Order);
return(model);
}
public IActionResult DeleteOrder(OrderIndexViewModel model)
{
ViewData["Message"] = "";
var order = db.Orders.Where(item => item.Id == model.Id).FirstOrDefault();
db.Orders.Remove(order);
db.SaveChanges();
cache.Remove("Orders");
return(RedirectToAction("Index", "Order"));
}
public OrderIndexViewModel GetOrderIndexViewModel(OrderGetDTO dto)
{
var model = new OrderIndexViewModel {
Order = dto.OrderIdForce != 0 ? dbManager.GetById <Order>(dto.OrderIdForce) : Get(dto)
};
FillViewModel(model);
return(model);
}
public ActionResult Index(OrderFilterModel filterModel)
{
OrderIndexViewModel model = new OrderIndexViewModel()
{
OrderList = filterModel.IsFiltered ? _orderService.Filter(filterModel).ToPagedList() : _orderService.GetAll().ToPagedList(1, PAGE_SIZE),
FilterModel = filterModel,
};
return(View(GetIndexViewModel(model)));
}
// GET: Orders
public async Task <IActionResult> Index()
{
// var bellyful_v03Context = _context.Order.Include(o => o.Recipient).Include(o => o.Status).Include(o => o.Volunteer);
// return View(await bellyful_v03Context.ToListAsync());
var ordersVMs = new List <OrderIndexViewModel>();
foreach (var o in _context.Order)
{
var vm = new OrderIndexViewModel
{
OrderId = o.OrderId
};
if (o.CreatedDatetime != null)
{
vm.PlacedTime = o.CreatedDatetime;
}
if (o.AssignDatetime != null)
{
vm.AssignedTime = o.AssignDatetime;
}
if (o.PickupDatetime != null)
{
vm.PickedUpTime = o.PickupDatetime;
}
if (o.DeliveredDatetime != null)
{
vm.DeliveredTime = o.DeliveredDatetime;
}
if (o.StatusId != null)
{
vm.StatusId = o.StatusId.Value;
}
if (o.VolunteerId != null)
{
var ss = await _context.GetVolunteerForIndex(o.VolunteerId.Value);
vm.VIdName = ss;
}
vm.RIdName = await _context.GetRecipientForIndex(o.RecipientId);
if (o.StatusId != null)
{
vm.Status = _context.OrderStatus.FindAsync(o.StatusId.Value).Result.Content;
}
ordersVMs.Add(vm);
}
ordersVMs.Sort();
return(View(ordersVMs));
}
// GET: Orders
public async Task <IActionResult> Index()
{
OrderIndexViewModel viewModel = new OrderIndexViewModel();
var user = await _userManager.GetUserAsync(User);
viewModel.UserName = user.UserName;
viewModel.Orders = _context.Order.Where(i => i.UserId == user.Id).ToList();
//var orderId = viewModel.Orders.Select(i => i.OrderId).FirstOrDefault();
viewModel.OrderHampers = _context.OrderHamper.ToList();
return(View(viewModel));
}
public IActionResult Index()
{
var orders = _db.Orders.ToList();
var title = "Orders";
var model = new OrderIndexViewModel
{
Orders = orders,
Title = title
};
return(View(model));
}
public IActionResult Delivered()
{
var orders = _db.Orders.Where(o => o.IsDelivered == true).ToList();
var title = "Orders Completed";
var model = new OrderIndexViewModel
{
Orders = orders,
Title = title
};
return(View("Index", model));
}
public IActionResult New()
{
var orders = _db.Orders.Where(o => o.IsDelivered == false).ToList();
var title = "New Orders";
var model = new OrderIndexViewModel
{
Orders = orders,
Title = title
};
return(View("Index", model));
}
public IActionResult Index(int page = 1)
{
var orders = _orderManager.Get(page);
var config = new MapperConfiguration(cfg => cfg.CreateMap <OrderModel, OrderViewModel>());
var mapper = new Mapper(config);
var ordersVM = mapper.Map <List <OrderViewModel> >(orders.Order);
var indexVM = new OrderIndexViewModel
{
Order = ordersVM,
PageViewModel = orders.PageViewModel
};
return(View(indexVM));
}
public IActionResult OrderIndex()
{
List <Order> orders = _repository.GetAllOrders();
List <OrderViewModel> orderViewModels = new List <OrderViewModel>();
foreach (var order in orders)
{
OrderViewModel orderViewModel = new OrderViewModel(order.OrderId, order.BuyerName, order.BuyerSurname,
order.ContactEmail, order.TotalPrice, order.OrderPlacedTime);
orderViewModels.Add(orderViewModel);
}
OrderIndexViewModel indexViewModel = new OrderIndexViewModel(orderViewModels);
return(View(indexViewModel));
}
public IActionResult Index(bool ship = false)
{
var result = _orderService.GetAll(ship);
if (!result.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = result.Message }));
}
var model = new OrderIndexViewModel
{
Orders = result.Data,
Control = ship
};
return(View(model));
}
// GET: Orders/Create
public async Task <IActionResult> Create()
{
OrderIndexViewModel viewModel = new OrderIndexViewModel();
var user = await _userManager.GetUserAsync(User);
var cart = SessionHelper.GetObjectFromJson <List <CartItem> >(HttpContext.Session, "cart");
viewModel.UserName = user.UserName;
viewModel.UserId = user.Id;
viewModel.Addresses = _context.UserAddress.Where(i => i.ApplicationUserId == user.Id).ToList();
viewModel.OrderDate = DateTime.Now.Date;
viewModel.CartItems = cart;
//viewModel.Price = cart.Select(p => p.Hamper.HamperPrice).FirstOrDefault();
viewModel.Total = cart.Sum(item => item.Hamper.HamperPrice * item.Quantity);
viewModel.TotalWithShipping = viewModel.Total + (decimal)7.5;
return(View(viewModel));
}
public IActionResult Index()
{
//Create vm
IEnumerable <Order> list = _orderDataService.GetAll();
IEnumerable <Branch> branchList = _branchDataService.GetAll();
IEnumerable <Category> categoryList = _categoryDataService.GetAll();
OrderIndexViewModel vm = new OrderIndexViewModel
{
Total = list.Count(),
Orders = list,
Categories = categoryList,
Branches = branchList
};
return(View(vm));
}
// GET: OrderTracks
public ActionResult Index()
{
List <OrderTrack> Pending = db.OrderTracks.Where(x => x.status == OrderStat.pending).OrderByDescending(x => x.status).ToList();
List <OrderTrack> OnOurWarehouse = db.OrderTracks.Where(x => x.status == OrderStat.OnOurWarehouse).OrderByDescending(x => x.status).ToList();
List <OrderTrack> OnItsWay = db.OrderTracks.Where(x => x.status == OrderStat.OnItsWay).OrderByDescending(x => x.status).ToList();
List <OrderTrack> Delivered = db.OrderTracks.Where(x => x.status == OrderStat.Delivered).OrderByDescending(x => x.status).ToList();
List <OrderTrack> cancelledOrders = db.OrderTracks.Where(x => x.status == OrderStat.Cancelled).OrderByDescending(x => x.status).ToList();
OrderIndexViewModel oivn = new OrderIndexViewModel()
{
Pending = Pending,
OnOurWarehouse = OnOurWarehouse,
OnItsWay = OnItsWay,
Delivered = Delivered,
cancelledOrders = cancelledOrders
};
return(View(oivn));
}
// GET: Orders
public ActionResult Index(string sortOrder, int?page)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.LastNameSortParam = sortOrder == "date_asc" ? "date_desc" : "date_asc";
var orders = db.Orders.Include(x => x.Units);
switch (sortOrder)
{
case "date_desc":
orders = orders.OrderByDescending(x => x.DeliveryDate);
break;
case "date_asc":
orders = orders.OrderBy(x => x.DeliveryDate);
break;
default:
orders = orders.OrderBy(x => x.DeliveryDate);
break;
}
var orderDataModel = new List <OrderIndexViewModel>();
foreach (var order in orders.ToList())
{
var newOrder = new OrderIndexViewModel {
DeliveryDate = order.DeliveryDate ?? DateTime.Now,
OrderID = order.OrderID,
Customer = String.Format("{0} {1}", order.Customer.FirstName, order.Customer.LastName),
Units = new List <String>()
};
foreach (var unit in order.Units.ToList())
{
newOrder.Units.Add(String.Format("{0}m {1} na {2} cijene {3} eura", unit.Amount, unit.WoodType, unit.SawingType, unit.Price));
}
orderDataModel.Add(newOrder);
}
int pageSize = 10;
int pageNumber = (page ?? 1);
return(View(orderDataModel.ToPagedList(pageNumber, pageSize)));
}
public IActionResult IndexLoggedIn()
{
Order currentActiveOrder = this.orderService.GetActiveOrder(this.User.Id);
var viewModel = new OrderIndexViewModel();
foreach (var orderProduct in currentActiveOrder.Products)
{
viewModel.Products.Add(new ProductIndexViewModel
{
Name = orderProduct.Product.Name,
Price = $"${orderProduct.Product.Price:F2}"
});
}
viewModel.TotalPrice = $"{currentActiveOrder.Products.Sum(p => p.Product.Price)}";
return(this.View(viewModel));
}
public IActionResult AddOrder(OrderIndexViewModel model)
{
ViewData["Message"] = "";
if (model.FurnitureCount <= 0)
{
ViewData["Message"] += "Неправильное значение количества мебели";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else if (model.DiscountPercent < 0 || model.DiscountPercent > 99)
{
ViewData["Message"] += "Неправильное значение скидки";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else if (model.Price <= 0)
{
ViewData["Message"] += "Неправильное значение стоимости";
return(View("~/Views/Order/Index.cshtml", GetViewModel()));
}
else
{
var id = 0;
if (db.Orders.Count() != 0)
{
id = db.Orders.Select(item => item.Id).Max();
}
id++;
db.Orders.Add(new Order()
{
Id = id,
ClientId = db.Clients.Where(item => item.Name == model.ClientName).First().Id,
DiscountPercent = model.DiscountPercent,
FurnitureCount = model.FurnitureCount,
Price = model.Price,
IsCompleted = model.IsCompleted ? 1 : 0,
EmployeeId = db.Employees.Where(item => item.FIO == model.EmployeeFIO).First().Id,
FurnitureId = db.Furniture.Where(item => item.Name == model.FurnitureName).First().Id
});
db.SaveChanges();
cache.Remove("Orders");
return(RedirectToAction("Index", "Order"));
}
}
