public async Task <IActionResult> Approve(IndexOrderViewModel model)
{
var order = await _context.Orders.FirstOrDefaultAsync(o => o.OrderID == model.OrderID);
if (order != null)
{
order.Status = Status.TO_RECEIVE;
order.DateToDeliver = model.DeliverDate;
_context.Entry(order).State = EntityState.Modified;
// update inventory
var inventory =
await _context.Inventories.FirstOrDefaultAsync(iv => iv.ProductID == order.ProductID);
if (inventory != null)
{
// deduct the order
if (inventory.Quantity > 0 && (order.Quantity <= inventory.Quantity) && order.IsRequested == false)
{
inventory.Quantity -= order.Quantity;
_context.Entry(inventory).State = EntityState.Modified;
}
else if (!order.IsRequested)
{
return(Unauthorized());
}
}
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult SearchOrder(DateTime?startDate, DateTime?endDate, OrderStatus orderStatus, int?page)
{
if (startDate == null)
{
startDate = DateTime.UtcNow.AddDays(-5);
}
if (endDate == null)
{
endDate = DateTime.UtcNow.AddHours(2);
}
IList <OrderListViewModel> modelOrderListView = ordersService
.GetAll()
.Where(r => r.OrderStatus == orderStatus &&
r.OrderDate >= startDate &&
r.OrderDate <= endDate)
.OrderByDescending(o => o.OrderDate)
.Select(x => new OrderListViewModel(x))
.ToList();
Pager pager = new Pager(modelOrderListView.Count(), page);
IndexOrderViewModel viewPageIndexModel = new IndexOrderViewModel
{
Items = modelOrderListView.Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize).ToList(),
Pager = pager
};
ViewData["startDate"] = startDate;
ViewData["endDate"] = endDate;
ViewData["orderStatus"] = orderStatus;
return(View(viewPageIndexModel));
}
public IActionResult All()
{
var viewModel = new IndexOrderViewModel
{
Orders = this.ordersService.GetAll <OrderViewModel>(),
};
return(this.View(viewModel));
}
public ActionResult Index(int page = 1)
{
if (page <= 0)
{
return(HttpNotFound());
}
var pageInfo = new PageInfo()
{
PageNumber = page,
TotalItems = dal.GetTotalCountOrders()
};
var pageSize = PageInfo.PageSize;
var orders = dal.GetOrders(((page - 1) * pageSize) + 1, page * pageSize);
if (orders == null)
{
return(HttpNotFound());
}
// var mapp = new MapperConfiguration(cfg => cfg.CreateMap<Order, OrderView>()
// .ForMember(dest => dest.OrderStatus, opt => opt.MapFrom(src => Enum.GetName(typeof(OrderStatus),src.OrderState))));
//
//Mapper.Initialize(cfg => cfg.CreateMap<Order, OrderView>()
// .ForMember(
// dest => dest.OrderStatus,
// opt => opt.MapFrom(src => Enum.GetName(
// typeof(OrderStatus),
// src.OrderState))));
List <OrderView> OrderView = Mapper.Map <IEnumerable <Order>, List <OrderView> >(orders);
for (var i = 0; i < orders.Count; i++)
{
OrderView[i].Sum = dal.GetExtendedPrice(OrderView[i].OrderID);
}
//var model2 = Mapper.Map<Order>(this);
var model = new IndexOrderViewModel()
{
Orders = OrderView,
Page = pageInfo
};
return(View(model));
}
public async Task <IActionResult> DeliveryReport(ReportsViewModel model)
{
DateTime startDateTime = model.FromDate;
DateTime endDateTime = model.ToDate.AddDays(1).AddTicks(-1);
var deliveries = await
_context.Orders.Where(r => r.DateDelivered >= startDateTime && r.DateDelivered <= endDateTime && r.Status == Status.DELIVERED).ToListAsync();
var vm = new IndexOrderViewModel();
vm.Orders = new List <OrderDetails>();
vm.FromDate = model.FromDate;
vm.ToDate = endDateTime;
if (deliveries != null)
{
foreach (var r in deliveries)
{
var product = await _context.Products.FirstOrDefaultAsync(p => p.ProductID == r.ProductID);
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == r.UserID);
var details = new OrderDetails
{
ReturnQuantity = r.Quantity,
FirstName = user.FirstName,
DeliveryAddress = user.Address,
LastName = user.LastName,
DeliverDate = r.DateDelivered,
ProductName = product.ProductName,
Status = r.Status,
Quantity = r.Quantity,
Amount = r.Amount,
OrderID = r.OrderID
};
vm.Orders.Add(details);
}
return(new ViewAsPdf("DeliveryReport", vm)
{
PageOrientation = Orientation.Landscape,
FileName = "DeliveryReport_" + DateTime.Now + ".pdf"
});
}
return(NotFound());
}
public async Task <IActionResult> MyOrders()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var userId = user.Id;
var orders = await _context.Orders.Where(o => o.UserID == userId).ToListAsync();
IndexOrderViewModel vm = new IndexOrderViewModel();
vm.Orders = new List <OrderDetails>();
if (orders != null)
{
foreach (var order in orders)
{
var Product = await _context.Products.FirstOrDefaultAsync(pd => pd.ProductID == order.ProductID);
var return_ = await _context.Returns.FirstOrDefaultAsync(r => r.OrderID == order.OrderID);
var returnQty = -1;
if (return_ != null)
{
returnQty = return_.Quantity;
}
var x = order.DateToDeliver;
var od = new OrderDetails
{
Amount = order.Amount,
Quantity = order.Quantity,
Status = order.Status,
PaymentMethod = order.PaymentMethod,
ProductName = Product.ProductName,
OrderID = order.OrderID,
DatePlaced = order.DateOrdered,
ProductImage = Product.ProductImage,
DeliverDate = order.DateToDeliver,
ProductID = Product.ProductID,
ReturnQuantity = returnQty,
CanBeReturnedUntil = order.DateDelivered.AddDays(7)
};
vm.Orders.Add(od);
}
return(View(vm));
}
return(View());
}
public IActionResult Index(int?page)
{
IList <OrderListViewModel> modelOrderListView = ordersService
.GetAll()
.Where(r => r.OrderStatus != OrderStatus.NotCompleted)
.OrderByDescending(o => o.OrderDate)
.Select(x => new OrderListViewModel(x))
.ToList();
Pager pager = new Pager(modelOrderListView.Count(), page);
IndexOrderViewModel viewPageIndexModel = new IndexOrderViewModel
{
Items = modelOrderListView.Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize).ToList(),
Pager = pager
};
return(View(viewPageIndexModel));
}
public async Task <IActionResult> Index()
{
var orders = await _context.Orders.Where(o => o.Status == Status.PENDING).ToListAsync();
IndexOrderViewModel vm = new IndexOrderViewModel();
vm.Orders = new List <OrderDetails>();
if (orders != null)
{
foreach (var order in orders)
{
var product = await _context.Products.FirstOrDefaultAsync(pd =>
pd.ProductID == order.ProductID);
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == order.UserID);
var od = new OrderDetails
{
Amount = order.Amount,
Quantity = order.Quantity,
Status = order.Status,
PaymentMethod = order.PaymentMethod,
ProductName = product.ProductName,
FirstName = user.FirstName,
LastName = user.LastName,
ProductID = product.ProductID,
OrderID = order.OrderID
};
vm.Orders.Add(od);
}
return(View(vm));
}
return(NotFound());
}
public async Task <IActionResult> Archived()
{
var orders = await _context.Orders.Where(o => o.Status == Status.DELIVERED).ToListAsync();
IndexOrderViewModel vm = new IndexOrderViewModel();
vm.Orders = new List <OrderDetails>();
if (orders != null)
{
foreach (var order in orders)
{
var product = await _context.Products.FirstOrDefaultAsync(pd => pd.ProductID == order.ProductID);
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == order.UserID);
vm.Orders.Add(new OrderDetails
{
Amount = order.Amount,
Quantity = order.Quantity,
Status = order.Status,
DatePlaced = order.DateOrdered,
DeliverDate = order.DateToDeliver,
ProductImage = product.ProductImage,
ProductID = product.ProductID,
ProductName = product.ProductName,
FirstName = user.FirstName,
OrderID = order.OrderID,
LastName = user.LastName,
Price = product.Price
});
}
return(View(vm));
}
return(View());
}
public DeleteOrderCommand(IndexOrderViewModel indexOrderViewModel)
{
IndexOrderViewModel = indexOrderViewModel;
}
public AddNewOrderCommand(IndexOrderViewModel indexOrderViewModel)
{
this.IndexOrderViewModel = indexOrderViewModel;
}
