public ActionResult ProductList(int productOrderID, int?page, string searchContent)
{
var currentPage = page ?? 1;
ViewData["PageSize"] = _pageSize;
ViewData["searchContent"] = searchContent;
List <Product> products = (from r in _entities.Products
join h in _entities.ProductOrderDetails on r.ID equals h.ProductID
where h.ProductOrderID == productOrderID && (string.IsNullOrEmpty(searchContent) ||
r.Name.Contains(searchContent) ||
r.NameChi.Contains(searchContent) ||
r.ItemCode.Contains(searchContent))
select r).ToList();
ViewData["TotalPages"] = (int)Math.Ceiling((float)products.Count() / _pageSize);
if ((int)ViewData["TotalPages"] < currentPage)
{
currentPage = 1;
}
ViewData["CurrentPage"] = currentPage;
products = (products.AsQueryable().OrderBy(a => a.ItemCode).Skip((currentPage - 1) * _pageSize).Take(_pageSize)).ToList();
var viewModel = new ProductOrderViewModel
{
Products = products,
ProductOrder = _entities.ProductOrders.SingleOrDefault(a => a.ID == productOrderID),
};
return(View(viewModel));
}
//GET List Of All Products for sale
public ActionResult Merchandise()
{
ProductOrderViewModel productOrderViewModel = new ProductOrderViewModel();
productOrderViewModel.Products = db.Products.Include(p => p.Files).ToList();
return(View(productOrderViewModel));
}
public ActionResult Details(int id, bool recentOrder)
{
List <int> productIDs = (from r in _entities.ProductOrderDetails where r.ProductOrderID == id select r.ProductID).ToList();
List <Product> products = new List <Product> ();
foreach (int iID in productIDs)
{
products.Add(_entities.Products.Single(a => a.ID == iID));
}
MembershipUser muc = Membership.GetUser();
int memberOrderID = (from r in _entities.MemberOrders where r.ProductOrderID == id && r.MemberInfo.MemberID == (Guid)muc.ProviderUserKey select r.ID).FirstOrDefault();
ProductOrder productOrder = _entities.ProductOrders.Single(a => a.ID == id);
DateTime today = DateTime.Today;
bool uPO = true;
if (productOrder.OrderCloseDate < today)
{
uPO = false;
}
ProductOrderViewModel viewModel = new ProductOrderViewModel
{
ProductOrder = productOrder,
ProductOrderIDs = (from r in _entities.ProductOrders.Where(a => a.OrderCloseDate >= today && uPO || !uPO && a.OrderCloseDate < today) orderby r.OrderCloseDate, r.ID select r.ID).ToList(),
Products = products,
MemberOrderID = memberOrderID,
};
ViewData["RecentOrder"] = recentOrder;
return(View(viewModel));
}
public async Task <IActionResult> Order(int id, ProductOrderViewModel model)
{
var product = await _context.Products.FindAsync(id);
product.Stock = product.Stock - model.Quantity;
_context.Products.Update(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public ActionResult Details([Bind(Include = "ID,ProductID,Quantity")] ProductOrderViewModel model)
{
if (ModelState.IsValid)
{
return(RedirectToAction("AddToCart", "ShoppingCart", new { id = model.ProductID, qty = model.Quantity }));
}
model.Product = context.Products.Find(model.ProductID);
return(View(model));
}
//
// GET: /Store/Details/5
public ActionResult Details(int id)
{
var product = context.Products.Find(id);
var vm = new ProductOrderViewModel()
{
Product = product, ProductID = product.ID, Quantity = 1
};
return(View(vm));
}
// POST: Products/Details/5
public async Task <IActionResult> Details(ProductOrderViewModel poViewModel)
{
//var product = await _repository.GetAsync(id);
//if (product == null)
//{
// return NotFound();
//}
return(View(poViewModel));
}
public ActionResult ClearCart()
{
var viewModel = new ProductOrderViewModel
{
Product = db.Products.ToList <Product>(),
Category = db.Categories.ToList <Category>()
};
Session["ProductOrderViewModel"] = viewModel;
return(View("ShoppingCart", viewModel));
}
public ActionResult Edit(int id)
{
var productOrder = _entities.ProductOrders.Single(a => a.ID == id);
List <Product> products = (from r in _entities.ProductOrderDetails where r.ProductOrderID == id select r.Product).ToList();
ProductOrderViewModel viewModel = new ProductOrderViewModel
{
ProductOrder = productOrder,
};
return(View(viewModel));
}
public ActionResult Create()
{
ProductOrderViewModel viewModel = new ProductOrderViewModel
{
ProductOrder = new ProductOrder(),
//Products = _entities.Products.Take(200).ToList(),
};
viewModel.ProductOrder.Title = "[Please input order Title]";
viewModel.ProductOrder.OrderOpenDate = DateTime.Today.ToUniversalTime().AddHours(8);
viewModel.ProductOrder.OrderCloseDate = DateTime.Today.ToUniversalTime().AddHours(8).AddDays(10);
return(View(viewModel));
}
public ActionResult AddProduct(ProductOrderViewModel productOrderView)
{
//Validamos que selecionen un customer
var orderView = Session["orderView"] as OrderView;
var productID = int.Parse(Request["product_id"]);
if (productID == 0)
{
ErrorSmS = "Debes seleccionar un producto";
LlenarProducts();
return(View(productOrderView));
}
var product = db.Products.Find(productID);
if (product == null)
{
ErrorSmS = "El producto no existe.";
LlenarProducts();
return(View(productOrderView));
}
//Buscamos el producto en la lista para aumentar la cantidad a pedir
productOrderView = orderView.Products.Find(p => p.product_id == productID);
//Si no aparece lo creamos y si aparece le sumamo a la cantidad la que me enviaron en el form
if (productOrderView == null)
{
productOrderView = new ProductOrderViewModel
{
description = product.description,
list_price = product.list_price,
product_id = product.product_id,
quantity = int.Parse(Request["quantity"]),
product_name = product.product_name
};
}
else
{
productOrderView.quantity += int.Parse(Request["quantity"]);
LlenarCustomers();
return(View("NewOrder", orderView));
}
orderView.Products.Add(productOrderView);
LlenarCustomers();
return(View("NewOrder", orderView));
}
public ActionResult Index()
{
var viewModel = (ProductOrderViewModel)Session["ProductOrderViewModel"];
if (viewModel == null)
{
viewModel = new ProductOrderViewModel
{
Product = db.Products.ToList <Product>(),
Category = db.Categories.ToList <Category>()
};
Session["ProductOrderViewModel"] = viewModel;
}
return(View(viewModel));
}
private bool ValidateInput(Models.Order newOrder)
{
ProductOrderViewModel viewData = (ProductOrderViewModel)Session["ProductOrderViewModel"];
bool isValid = true;
if (newOrder == null)
{
ErrorMessage = "Please enter all the required fields";
isValid = false;
}
else if (newOrder.FirstName == "")
{
ErrorMessage = "Please enter first name!";
isValid = false;
}
else if (newOrder.LastName == "")
{
ErrorMessage = "Please enter last name!";
isValid = false;
}
else if (newOrder.Address == "")
{
ErrorMessage = "Please enter address details!";
isValid = false;
}
else if (newOrder.Phone == "")
{
ErrorMessage = "Please enter phone number!";
isValid = false;
}
else if (newOrder.PostalCode == "")
{
ErrorMessage = "Please enter post code!";
isValid = false;
}
else if (newOrder.Email == "" || newOrder.Email.ToString().Contains("@") == false)
{
ErrorMessage = "Please enter email address!";
isValid = false;
}
else if (viewData.CartTotal < 11)
{
ErrorMessage = "You need to spend £11 or more to order!";
isValid = false;
}
return(isValid);
}
public async Task <IActionResult> OrderStatus(int?statusId)
{
if (statusId == null)
{
statusId = 1;
}
ProductOrderViewModel orders = new ProductOrderViewModel();
orders.Statuses = await webAPI.GetAllAsync <Status>(ApiURL.STATUS);
var token = await webAPIToken.New();
orders.Orders = await webAPI.GetAllAsync <AllUserOrders>(ApiURL.All_ORDERS_BY_STATUS + statusId, token);
return(View(orders));
}
public async Task <IActionResult> Order(int?id)
{
var product = await _context.Products.FindAsync(id);
if (product == null)
{
return(NotFound());
}
var productOrderViewModel = new ProductOrderViewModel
{
ProductId = product.Id,
ProductName = product.ProductName,
Stock = product.Stock
};
return(View(productOrderViewModel));
}
public async Task <ActionResult> OrdersPerProduct(int productID)
{
Product product = await _productRepository.GetByIDAsync(productID);
List <ProductOrderViewModel> povm = new List <ProductOrderViewModel>();
List <Order> ordersForProduct = await _orderRepository.GetAllOrdersPerProduct(productID);
foreach (var o in ordersForProduct)
{
if (o == null)
{
throw new Exception("BUG for some reason. Fix T");
}
float price = o.ProductsOrderInfo.Sum(p => p.PricePayed);
ProductOrderViewModel cvm = new ProductOrderViewModel(o);
cvm.FullPrice = price;
povm.Add(cvm);
}
return(Json(povm, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(FormCollection collection, ProductOrder productOrder)
{
try
{
_entities.AddToProductOrders(productOrder);
_entities.SaveChanges();
productOrder = (from r in _entities.ProductOrders select r).OrderByDescending(x => x.ID).First();
return(RedirectToAction("Index", "Product", new { productOrderID = productOrder.ID, recentOrder = false }));
}
catch
{
ProductOrderViewModel viewModel = new ProductOrderViewModel
{
ProductOrder = productOrder,
};
return(View(viewModel));
}
}
// GET: Products/Details/5
public async Task <IActionResult> Details(int id)
{
var product = await _repository.GetAsync(id);
if (product == null)
{
return(NotFound());
}
// add locations to select from for drop down list on view
var poViewModel = new ProductOrderViewModel
{
ProductID = product.ProductID,
Name = product.Name,
Price = product.Price
};
return(View(poViewModel));
}
public ActionResult Order(Order order)
{
try
{
if (ValidateInput(order))
{
order.OrderDate = DateTime.UtcNow;
order.Status = (byte)OrderStatus.New;
order.OrderId = Guid.NewGuid();
order.Description = order.Description ?? "";
ProductOrderViewModel viewData = (ProductOrderViewModel)Session["ProductOrderViewModel"];
order.Total = viewData.CartTotal;
foreach (var cart in viewData.CartItems)
{
OrderDetail orderDetail = new OrderDetail();
orderDetail.OrderDetailId = Guid.NewGuid();
orderDetail.Quantity = cart.Count;
orderDetail.UnitPrice = cart.Product.Price;
orderDetail.ProductId = cart.ProductId;
orderDetail.OrderId = order.OrderId;
db.OrderDetails.Add(orderDetail);
}
db.Orders.Add(order);
db.SaveChanges();
Session["ProductOrderViewModel"] = null;
return(Json(new Order {
IsSuccess = true, ErrorMessage = ""
}));
}
}
catch (Exception ex)
{
return(Json(new Order {
IsSuccess = false, ErrorMessage = ErrorMessage
}));
}
return(Json(new Order {
IsSuccess = false, ErrorMessage = ErrorMessage
}));
}
public ActionResult AddToCart(int productId)
{
var viewModel = (ProductOrderViewModel)Session["ProductOrderViewModel"];
if (viewModel == null)
{
viewModel = new ProductOrderViewModel
{
Product = db.Products.ToList <Product>(),
Category = db.Categories.ToList <Category>()
};
Session["ProductOrderViewModel"] = viewModel;
}
var newCart = new Cart();
bool exist = false;
foreach (Cart cart in viewModel.CartItems)
{
if (cart.ProductId == productId)
{
cart.Count++;
viewModel.CartTotal += cart.Product.Price;
exist = true;
}
}
if (!exist)
{
newCart.CartId = Guid.NewGuid().ToString();
newCart.Product = db.Products.FirstOrDefault(p => p.ProductId == productId);
newCart.ProductId = productId;
newCart.DateCreated = DateTime.UtcNow;
newCart.Count = 1;
viewModel.CartTotal += newCart.Product.Price;
viewModel.CartItems.Add(newCart);
}
Session["ProductOrderViewModel"] = viewModel;
return(View("ShoppingCart", viewModel));
}
public IActionResult Create(int id)
{
var user = this._userServices.GetUserByUsername(this.User.Identity.Name);
var product = _productServices.GetProductById(id);
var productsView = new ProductOrderViewModel()
{
ProductId = product.Id,
Title = product.Title,
Price = product.Price,
QuantityFromDb = product.Quantity
};
var address = _addressesServices.GetAllUserAddresses(User.Identity.Name).ToList();
var addressViewModel = address.Select(x => new OrderAdressViewModel()
{
CityName = x.City.Name,
CityPostcode = x.City.Postcode,
Description = x.Description,
Street = x.Street,
Id = x.Id
}).ToList();
var supplierViewModels = this._suppliersService.All().Select(x => new SupplierViewModel()
{
Id = x.Id,
Name = x.Name,
IsDefault = x.IsDefault,
PriceToHome = x.PriceToHome,
PriceToOffice = x.PriceToOffice
}).ToList();
// var supplierViewModels = _mapper.Map<IList<SupplierViewModel>>(suppliers);
if (user.FirstName == null)
{
user.FirstName = "XXX";
}
if (user.LastName == null)
{
user.LastName = "XXX";
}
if (user.PhoneNumber == null)
{
user.PhoneNumber = "XXX";
}
var fullName = $"{user.FirstName} {user.LastName}";
var createOrderViewModel = new CreateOrderViewModel
{
FullName = fullName,
PhoneNumber = user.PhoneNumber,
OrderAddressesViewModel = addressViewModel.ToList(),
ProductOrderViewModel = productsView,
SuppliersViewModel = supplierViewModels
};
return(this.View(createOrderViewModel));
}
public ActionResult ProcessOrderDetails(ProductOrderViewModel processProductOrderVM)
{
var orderNumber = db.Orders.Where(o => o.ClientId == processProductOrderVM.ClientId && o.SupplierId == processProductOrderVM.SupplierId && o.ClientApproval == 0).FirstOrDefault();
int myOrderId = 0;
if (processProductOrderVM.OrderId > 0)
{
myOrderId = processProductOrderVM.OrderId;
}
else
{
myOrderId = orderNumber.Id;
}
var itemExistsInOrder = db.OrderDetails.Where(o => o.OrderId == myOrderId && o.ManufacturerProductId == processProductOrderVM.ManufacturerProductId).FirstOrDefault();
if (itemExistsInOrder != null) //Checks if the item already exists in the order
{ //if so, change the Quantity and the QuantityPrice, then change the TotalPrice of the order
itemExistsInOrder.Quantity = itemExistsInOrder.Quantity + processProductOrderVM.Quantity;
itemExistsInOrder.QuantityPrice = itemExistsInOrder.QuantityPrice + (processProductOrderVM.Quantity * processProductOrderVM.ProductPrice);
db.SaveChanges();
var order = db.Orders.Find(myOrderId);
decimal count = 0;
foreach (var item in order.OrderDetails) //count the total price of the order
{
count += (decimal)item.QuantityPrice;
}
order.TotalPrice = count;
db.SaveChanges();
return(Redirect(Request.UrlReferrer.ToString())); //returns the previous view
}
else
{ //if the item does not exists, add a new record in the OrderDetails table.
var orderDetails = new OrderDetails
{
OrderId = myOrderId,
ManufacturerProductId = processProductOrderVM.ManufacturerProductId,
Quantity = processProductOrderVM.Quantity,
QuantityPrice = processProductOrderVM.Quantity * processProductOrderVM.ProductPrice,
ItemPrice = (double)processProductOrderVM.ProductPrice / processProductOrderVM.PackageQuantity,
TotalOrderPrice = null,
ManufacturerProducts = db.ManufacturerProducts.FirstOrDefault(m => m.Id.Equals(processProductOrderVM.ManufacturerProductId)),
Orders = db.Orders.FirstOrDefault(o => o.Id.Equals(myOrderId))
};
if (ModelState.IsValid)
{
db.OrderDetails.Add(orderDetails);
db.SaveChanges();
var order = db.Orders.Find(myOrderId);
decimal count = 0;
foreach (var item in order.OrderDetails) //count the total price of the order
{
count += (decimal)item.QuantityPrice;
}
order.TotalPrice = count;
db.SaveChanges();
//return RedirectToAction("MyOrders", new { id = processProductOrderVM.ClientId });
return(Redirect(Request.UrlReferrer.ToString())); //returns the previous view
}
}
return(View("ShowProducts", "Home"));
}
public ActionResult AddToOrder(ProductOrderViewModel productOrderVM)
{
var countOrders = db.Orders.Where(o => o.ClientId == productOrderVM.ClientId && o.SupplierId == productOrderVM.SupplierId).Count();
if (countOrders > 1)
{
var openOrder = db.Orders.Where(o => o.ClientId == productOrderVM.ClientId && o.SupplierId == productOrderVM.SupplierId && o.ClientApproval == 0).FirstOrDefault();
if (openOrder != null)
{
ProductOrderViewModel model = new ProductOrderViewModel
{
OrderId = openOrder.Id,
ManufacturerProductId = productOrderVM.ManufacturerProductId,
Quantity = productOrderVM.Quantity,
ProductPrice = productOrderVM.ProductPrice,
PackageQuantity = productOrderVM.PackageQuantity,
ClientId = productOrderVM.ClientId
};
return(RedirectToAction("ProcessOrderDetails", model));
}
var order = new Orders
{
ClientApproval = 0,
SupplierApproval = 0,
CreateDate = DateTime.Now,
//TotalPrice = productOrderVM.ProductPrice * productOrderVM.Quantity,
ClientId = productOrderVM.ClientId,
Clients = db.Clients.FirstOrDefault(c => c.Id.Equals(productOrderVM.ClientId)),
SupplierId = productOrderVM.SupplierId,
Suppliers = db.Suppliers.FirstOrDefault(c => c.Id.Equals(productOrderVM.SupplierId))
};
if (ModelState.IsValid)
{
db.Orders.Add(order);
db.SaveChanges();
return(RedirectToAction("ProcessOrderDetails", productOrderVM));
}
}
else if (countOrders == 1)
{
var openOrder = db.Orders.Where(o => o.ClientId == productOrderVM.ClientId && o.SupplierId == productOrderVM.SupplierId && o.ClientApproval == 0).FirstOrDefault();
if (openOrder != null)
{
ProductOrderViewModel model = new ProductOrderViewModel
{
OrderId = openOrder.Id,
ManufacturerProductId = productOrderVM.ManufacturerProductId,
Quantity = productOrderVM.Quantity,
ProductPrice = productOrderVM.ProductPrice,
PackageQuantity = productOrderVM.PackageQuantity,
ClientId = productOrderVM.ClientId
};
return(RedirectToAction("ProcessOrderDetails", model));
}
var order = new Orders
{
ClientApproval = 0,
SupplierApproval = 0,
CreateDate = DateTime.Now,
ClientId = productOrderVM.ClientId,
Clients = db.Clients.FirstOrDefault(c => c.Id.Equals(productOrderVM.ClientId)),
SupplierId = productOrderVM.SupplierId,
Suppliers = db.Suppliers.FirstOrDefault(c => c.Id.Equals(productOrderVM.SupplierId))
};
if (ModelState.IsValid)
{
db.Orders.Add(order);
db.SaveChanges();
return(RedirectToAction("ProcessOrderDetails", productOrderVM));
}
}
var newOrder = new Orders
{
ClientApproval = 0,
SupplierApproval = 0,
CreateDate = DateTime.Now,
ClientId = productOrderVM.ClientId,
Clients = db.Clients.FirstOrDefault(c => c.Id.Equals(productOrderVM.ClientId)),
SupplierId = productOrderVM.SupplierId,
Suppliers = db.Suppliers.FirstOrDefault(c => c.Id.Equals(productOrderVM.SupplierId))
};
if (ModelState.IsValid)
{
db.Orders.Add(newOrder);
db.SaveChanges();
return(RedirectToAction("ProcessOrderDetails", productOrderVM));
}
productOrderVM.Suppliers = db.Suppliers.ToList();
productOrderVM.Clients = db.Clients.ToList();
//return View("MyOrders", productOrderVM);
return(View("ShowProducts", "Home"));
}
public ActionResult GroundTotal()
{
var productOrderViewModel = new ProductOrderViewModel();
return(View(productOrderViewModel));
}
// GET: ProductDetail
public ActionResult Index(int id)
{
using (GoodSupplyEntities db = new GoodSupplyEntities())
{
if ((string)Session["UserType"] == "Client")
{
int userId = Int32.Parse((string)Session["UserId"]);
var user = db.Clients.Where(u => u.Id == userId).FirstOrDefault();
var productModel = db.ManufacturerProducts.Include(m => m.Manufacturers).Include(m => m.Products).SingleOrDefault(m => m.Id == id);
ProductOrderViewModel model = new ProductOrderViewModel
{
ManufacturerProductId = productModel.Id,
ProductName = productModel.Products.Name,
ManufacturerName = productModel.Manufacturers.Name,
CommercialName = productModel.Name,
CatalogNumber = productModel.CatalogNumber,
ImageUrl = productModel.ImageUrl,
PackageQuantity = productModel.PackageQuantity,
Width = productModel.Width,
Length = productModel.Length,
Height = productModel.Height,
ManufacturerId = productModel.ManufacturerId,
Manufacturers = db.Manufacturers.FirstOrDefault(m => m.Id.Equals(productModel.ManufacturerId)),
ProductId = productModel.ProductId,
Products = db.Products.FirstOrDefault(p => p.Id.Equals(productModel.ProductId)),
ClientId = user.Id,
PricesList = db.Prices.Where(p => p.ManufacturerProductId.Equals(productModel.Id)).ToList(),
Suppliers = db.Suppliers.ToList()
};
return(View(model));
}
else if ((string)Session["UserType"] == "Supplier")
{
int userId = Int32.Parse((string)Session["UserId"]);
var user = db.Suppliers.Where(u => u.Id == userId).FirstOrDefault();
var productModel = db.ManufacturerProducts.Include(m => m.Manufacturers).Include(m => m.Products).SingleOrDefault(m => m.Id == id);
ProductOrderViewModel model = new ProductOrderViewModel
{
ManufacturerProductId = productModel.Id,
ProductName = productModel.Products.Name,
ManufacturerName = productModel.Manufacturers.Name,
CommercialName = productModel.Name,
CatalogNumber = productModel.CatalogNumber,
ImageUrl = productModel.ImageUrl,
PackageQuantity = productModel.PackageQuantity,
Width = productModel.Width,
Length = productModel.Length,
Height = productModel.Height,
ManufacturerId = productModel.ManufacturerId,
Manufacturers = db.Manufacturers.FirstOrDefault(m => m.Id.Equals(productModel.ManufacturerId)),
ProductId = productModel.ProductId,
Products = db.Products.FirstOrDefault(p => p.Id.Equals(productModel.ProductId)),
PricesList = db.Prices.Where(p => p.ManufacturerProductId.Equals(productModel.Id)).ToList(),
Suppliers = db.Suppliers.ToList()
};
return(View(model));
}
else
{
var productModel = db.ManufacturerProducts.Include(m => m.Manufacturers).Include(m => m.Products).SingleOrDefault(m => m.Id == id);
ProductOrderViewModel model = new ProductOrderViewModel
{
ManufacturerProductId = productModel.Id,
ProductName = productModel.Products.Name,
ManufacturerName = productModel.Manufacturers.Name,
CommercialName = productModel.Name,
CatalogNumber = productModel.CatalogNumber,
ImageUrl = productModel.ImageUrl,
PackageQuantity = productModel.PackageQuantity,
Width = productModel.Width,
Length = productModel.Length,
Height = productModel.Height,
ManufacturerId = productModel.ManufacturerId,
Manufacturers = db.Manufacturers.FirstOrDefault(m => m.Id.Equals(productModel.ManufacturerId)),
ProductId = productModel.ProductId,
Products = db.Products.FirstOrDefault(p => p.Id.Equals(productModel.ProductId)),
PricesList = db.Prices.Where(p => p.ManufacturerProductId.Equals(productModel.Id)).ToList(),
Suppliers = db.Suppliers.ToList()
};
return(View(model));
}
}
}
