public ActionResult Details(int Id)
{
OrderEditViewModel ordervm = new OrderEditViewModel();
Usuario usuario = db.Usuarios.Find(SessionHelper.GetUser());
Order order = db.Orders.Find(Id);
ViewBag.Title = "Pedido del Centro " + order.Center.Descripcion;
ViewBag.SubTitle = "Estado: " + order.Status.Descripcion;
ViewBag.isAdmin = usuario.Rol.IsAdmin;
ordervm.Id = order.Id;
ordervm.CenterId = order.CenterId;
ordervm.OrderProductViewModels = new List <OrderProductViewModel>();
var products = db.Products.Where(x => x.Enable).ToList();
var centerProducts = db.CenterProducts.Where(x => x.CenterId == ordervm.CenterId).ToList();
foreach (var item in products)
{
OrderProductViewModel orderProduct = new OrderProductViewModel
{
Product = item.Descripcion,
ProductId = item.Id,
ProductType = item.SupplieMedical.Descripcion,
QuantityDelivered = order.OrderProducts.Where(x => x.ProductId == item.Id).Select(x => x.QuantityDelivered).FirstOrDefault(),
Quantity = order.OrderProducts.Where(x => x.ProductId == item.Id).Select(x => x.Quantity).FirstOrDefault(),
OutStock = item.OutStock,
Stock = centerProducts.Where(x => x.ProductId == item.Id).Select(x => x.Stock).FirstOrDefault()
};
ordervm.OrderProductViewModels.Add(orderProduct);
}
return(View(ordervm));
}
// GET: Orders/Create
public ActionResult Create()
{
OrderCreateViewModel ordervm = new OrderCreateViewModel();
Usuario usuario = db.Usuarios.Find(SessionHelper.GetUser());
ViewBag.Title = "Pedido del Centro " + usuario.Center?.Descripcion;
ordervm.CenterId = usuario.CenterId.Value;
ordervm.OrderProductViewModels = new List <OrderProductViewModel>();
var products = db.Products.Where(x => x.Enable).ToList();
// var centerProducts = db.CenterProducts.Where(x => x.CenterId == ordervm.CenterId).ToList();
var center = db.Centers.Where(x => x.Id == ordervm.CenterId).Include(x => x.CenterProducts).FirstOrDefault();
var centerProducts = center.CenterProducts;
ordervm.TieneStockSinCargar = center.TieneStockSinCargar();
foreach (var item in products)
{
OrderProductViewModel orderProduct = new OrderProductViewModel
{
Product = item.Descripcion,
ProductId = item.Id,
ProductType = item.SupplieMedical.Descripcion,
Quantity = 0,
QuantityDelivered = 0,
OutStock = item.OutStock,
Stock = centerProducts.Where(x => x.ProductId == item.Id).Select(x => x.Stock).FirstOrDefault()
};
ordervm.OrderProductViewModels.Add(orderProduct);
}
return(View(ordervm));
}
public void Add(OrderProductViewModel orderProduct)
{
_unitOfWork.BeginTransaction();
var user = _userRepository.GetById(orderProduct.Order.User.Id);
var productIds = orderProduct.Products.Select(x => x.Id);
var products = productIds.Select(productId => _productRepository.GetById(productId)).ToList();
var order = new Order()
{
Id = Guid.NewGuid(),
User = user,
Quantity = orderProduct.Order.Quantity,
Product = null,
Products = products
};
_orderRepositry.Add(order);
foreach (var product in products)
{
var orderProductModel = new OrderProduct
{
Id = Guid.NewGuid(),
Order = order,
Product = product,
Products = products,
Quantity = orderProduct.Quantity
};
_orderProductRepository.Add(orderProductModel);
}
_unitOfWork.Commit();
}
public IHttpResponse Order(OrderProductViewModel viewModel)
{
var username = this.User.Username;
var user = this.Db.Users
.Where(u => u.Username == username)
.SingleOrDefault();
var barcode = viewModel.Barcode;
var product = this.Db.Products
.Where(b => b.Barcode == barcode)
.SingleOrDefault();
if (product == null)
{
return(this.BadRequestError("Invalid product barcode."));
}
var quantity = viewModel.Quantity;
var order = new Order
{
Product = product,
Cashier = user,
Total = product.Price * quantity,
Quantity = quantity,
Status = Status.Active
};
this.Db.Orders.Add(order);
this.Db.SaveChanges();
return(Redirect("/"));
}
public OrderEditViewModel GetOrder(int id)
{
OrderEditViewModel ordervm = new OrderEditViewModel();
Order order = db.Orders.Find(id);
ordervm.CenterId = order.CenterId;
ordervm.Id = order.Id;
ViewBag.PasaAEntregado = (order.Status.Id == (int)StatusOrder.Solicitado);
ordervm.OrderProductViewModels = new List <OrderProductViewModel>();
ordervm.Center = order.Center.Descripcion;
ordervm.Date = order.InitialDate.ToString("dd/MM/yyyy");
ordervm.NroPedido = order.NroPedido.ToString();
var products = db.Products.Where(x => x.Enable).ToList();
var centerProducts = db.CenterProducts.Where(x => x.CenterId == ordervm.CenterId).ToList();
foreach (var item in products)
{
OrderProductViewModel orderProduct = new OrderProductViewModel
{
Product = item.Descripcion,
ProductId = item.Id,
ProductType = item.SupplieMedical.Descripcion,
Quantity = order.OrderProducts.Where(x => x.ProductId == item.Id).Select(x => x.Quantity).FirstOrDefault(),
QuantityDelivered = order.OrderProducts.Where(x => x.ProductId == item.Id).Select(x => x.QuantityDelivered).FirstOrDefault(),
OutStock = item.OutStock,
Stock = centerProducts.Where(x => x.ProductId == item.Id).Select(x => x.Stock).FirstOrDefault()
};
ordervm.OrderProductViewModels.Add(orderProduct);
}
return(ordervm);
}
public OrderProductMaterialViewModel(OrderProductMaterial orderProductMaterial)
{
OrderProduct = new OrderProductViewModel(orderProductMaterial.OrderProduct);
Material = new MaterialViewModel(orderProductMaterial.Material);
Supplier = new SupplierViewModel(orderProductMaterial.Supplier);
Quantity = orderProductMaterial.Quantity;
DeliveryDate = orderProductMaterial.DeliveryDate;
Price = orderProductMaterial.Price;
Rate = orderProductMaterial.Rate;
}
public IActionResult AddProductToOrder(OrderProductViewModel model)
{
var order = _context.Orders.Single(c => c.ID == model.Order.ID);
var product = _context.Products.Single(p => p.ID == model.SelectedProduct);
order.Products.Add(product);
_context.Update(order);
_context.SaveChanges();
return(RedirectToAction("Edit", new { ID = model.Order.ID }));
}
public async Task <IActionResult> Post([FromBody] OrderProductViewModel order)
{
var newOrder = await _orderProductService.PlaceOrder(order);
if (newOrder == null)
{
return(NotFound("Order not Placed"));
}
return(Ok());
}
public MainPage()
{
this.InitializeComponent();
this.DataContext = new OrderProduct();
orderProductViewModel = new OrderProductViewModel();
viewModel = new ViewModel();
// PopulatePersonViewModel("file.json").GetAwaiter();
// JsonService.WriteToFile($@"C:\Users....Documents\MyFiles", new Person("Nataliya", "Lisjo", , "Degerfors", 69335));//connect to JsonService
}
public async Task PlaceOrder_WithProperInput_ReturnsTrue()
{
var order = new OrderProductViewModel()
{
ProductId = Guid.Parse("ad21cc19-3b7e-4ba8-fe2c-08d8eab84682"),
Quantity = 1
};
var result = await _orderProductService.PlaceOrder(order);
Assert.IsNotNull(result);
}
public void SaveOrderProduct(OrderProductViewModel orderProduct)
{
var op = OrderProductViewModel.ToOrderProduct(orderProduct);
op.Genotype = u_repo.GetGenotype(op.GenotypeId);
op.Material = u_repo.GetMaterials().SingleOrDefault(m => m.Id == op.MaterialId);
u_repo.SaveOrderProduct(op);
var savedVM = OrderProductViewModel.Create(op);
savedVM.CopyTo(orderProduct);
}
public OrderProductAddressViewModel(OrderProductAddress orderProductAddress)
{
OrderProduct = new OrderProductViewModel(orderProductAddress.OrderProduct);
Address = new AddressViewModel(orderProductAddress.Address);
OrderProductAddressSizes = new List <OrderProductAddressSizeViewModel>();
OrderProductAddressProductionDates = new List <OrderProductAddressProductionDateViewModel>();
DeliveryDate = orderProductAddress.DeliveryDate;
OrderProductAddressDeliveries = new List <OrderProductAddressDeliveryViewModel>();
}
public IActionResult CompletedOrderDetail(int?id)
{
OrderProductViewModel opvm = new OrderProductViewModel(id, _context);
if (id == null)
{
return(NotFound());
}
return(View(opvm));
}
//Select Product To Add to Order: ID
public IActionResult AddProduct(int ID)
{
var order = _context.Orders.Where(o => o.ID == ID).Include(p => p.Products).Single();
var products = _context.Products.ToList();
var orderProducts = new OrderProductViewModel()
{
Order = order, Products = products
};
return(View(orderProducts));
}
public async Task <IActionResult> DeleteProductFromShelf(OrderProductViewModel viewModel)
{
var orderProduct = await _context.OrderProducts
.FirstOrDefaultAsync(
op => op.OrderId == viewModel.OrderId &&
op.ProductId == viewModel.ProductId);
_context.OrderProducts.Remove(orderProduct);
await _context.SaveChangesAsync();
return(Ok());
}
public OrderDetails mapOrderDetails(Product product, OrderProductViewModel fromFront, string orderId)
{
OrderDetailsData detailsItem = new OrderDetailsData
{
ProductId = product.Id,
Price = product.Data.Price * fromFront.quantity,
Quantity = fromFront.quantity,
OrderId = orderId
};
return(new OrderDetails(detailsItem));
}
public OrderProductView()
{
InitializeComponent();
WindowStartupLocation = WindowStartupLocation.CenterScreen;
var viewModel = new OrderProductViewModel();
this.DataContext = viewModel;
if (viewModel.CloseAction == null)
{
viewModel.CloseAction = new Action(this.Close);
}
}
public OrderProductDeliveryViewModel(OrderProductDelivery orderProductDelivery)
{
OrderProduct = new OrderProductViewModel(orderProductDelivery.OrderProduct);
DeliveryId = orderProductDelivery.DeliveryId;
DeliveryDate = orderProductDelivery.DeliveryDate;
DeliveryImagePath = orderProductDelivery.DeliveryImagePath;
AcceptanceId = orderProductDelivery.AcceptanceId;
AcceptanceDate = orderProductDelivery.AcceptanceDate;
AcceptanceImagePath = orderProductDelivery.AcceptanceImagePath;
OrderProductDeliveryMaterials = new List <OrderProductDeliveryMaterialViewModel>();
}
private OrderViewModel CreateOrders(List <OrderItemViewModel> orderItems, AppUserDto owner)
{
var newOrder = new OrderViewModel()
{
OrderId = Guid.NewGuid().ToString(),
CreatedDate = DateTime.UtcNow,
Status = "InProcess",
AppUserId = owner.AppUserId
};
//Keeping history
//var orderItemsToHistory = await _itemsHistoryComparer.GetOrderHistoryToRecordAsync(owner, orderItems);
//var newOrderHistory = _mapper.Map<OrderHistoryDto>(newOrder);
if (orderItems.Count() > 0)
{
foreach (var item in orderItems)
{
var orderItem = _mapper.Map <OrderItemViewModel>(item);
orderItem.OrderId = newOrder.OrderId;
orderItem.CreatedDate = DateTime.UtcNow;
orderItem.Order = newOrder;
//Keeping history
//var newOrderItemHistory = new OrderItemHistoryDto();
//if (ItemsHistoryComparer.CompareTwoItems(item,))
//{
//}
// _mapper.Map<OrderItemHistoryDto>(orderItem);
var orderProduct = new OrderProductViewModel()
{
OrderId = newOrder.OrderId,
ProductId = item.ProductId,
};
newOrder.TotalPrice += orderItem.TotalQuantityPrice;
newOrder.OrderItems.Add(orderItem);
newOrder.OrderProducts.Add(orderProduct);
//newOrderHistory.OrderItems.Add(newOrderItemHistory);
//newOrderHistory.ProductIdDetail = item.ProductId;
//newOrder.OrderHistory = newOrderHistory;
//newOrder.AppUser.OrderHistoryCount += 1;
}
}
return(newOrder);
}
public async Task <IActionResult> AddProductToShelf(OrderProductViewModel viewModel)
{
var orderProduct = new OrderProduct
{
ProductId = viewModel.ProductId,
OrderId = viewModel.OrderId,
Quantity = viewModel.Quantity
};
_context.OrderProducts.Add(orderProduct);
await _context.SaveChangesAsync();
return(Ok());
}
public ActionResult DeleteOrderProduct(OrderProductViewModel product)
{
if (product == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
o_repo.DeleteOrderProduct(product);
return(Json(new { text = $"order product {product.Id} was deleted" }));
}
catch (Exception e)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, e.Message));
}
}
public async Task <ActionResult> GetAllProducts()
{
List <Product> allProducts = await _productRepository.GetAllAsync();
List <OrderProductViewModel> opvm = new List <OrderProductViewModel>();
foreach (var c in allProducts)
{
OrderProductViewModel pvm = new OrderProductViewModel()
{
ProductID = c.ProductID,
Price = c.Price,
ProductName = c.Name,
};
opvm.Add(pvm);
}
return(Json(opvm, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Landing(int id)
{
Product product = await _products.GetOneByIdAsync(id);
OrderProductViewModel opvm = new OrderProductViewModel();
opvm.ProductID = product.ID;
opvm.Sku = product.Sku;
opvm.Name = product.Name;
opvm.Price = product.Price;
opvm.Description = product.Description;
opvm.QtyAvail = product.QtyAvail;
opvm.Image = product.Image;
opvm.Category = product.Category;
opvm.Meaty = product.Meaty;
return(View(opvm));
}
public IActionResult PersonalRoom()
{
var orderUR = new OrderURViewModel();
var userReviews = new List <UserReviewViewModel>();
var orderProductViewModels = new List <OrderProductViewModel>();
User user = new User();
string name = User.Identity.Name;
var us = db.Users.Where(u => u.UserName == name);
user = us.First();
ViewBag.User = user;
var or = db.Orders.Where(o => o.UserId == user.Id);
foreach (var order in or.AsEnumerable())
{
var orderProduct = new OrderProductViewModel();
orderProduct.Order = order;
orderProduct.Product = db.Products.Find(order.ProductId);
orderProductViewModels.Add(orderProduct);
}
foreach (var ur in db.UserReviews.ToList())
{
var urVM = new UserReviewViewModel();
string tempName = db.Users.Find(ur.UserId).UserName;
urVM.UserName = tempName;
urVM.UserReview = ur;
userReviews.Add(urVM);
}
orderUR.OrderProductViewModels = orderProductViewModels;
orderUR.UserReviewViewModel = userReviews;
return(View(orderUR));
}
public async Task <IActionResult> Update(OrderProductViewModel item)
{
if (!ModelState.IsValid)
{
return(Redirect("/"));
}
var result = await this.ordersService
.UpdateQuantity(
this.User.Identity.Name,
item.Id,
item.Quantity);
if (!result)
{
return(Redirect("/"));
}
return(this.RedirectToAction(nameof(ShoppingCart)));
}
public ActionResult SaveOrderProduct(OrderProductViewModel product)
{
if (product == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
o_repo.SaveOrderProduct(product);
JsonNetResult jsonNetResult = new JsonNetResult();
jsonNetResult.Data = product;
jsonNetResult.SerializerSettings.DateFormatString = "yyyy-MM-dd";
return(jsonNetResult);
}
catch (Exception e)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, e.Message));
}
}
public async Task <ActionResult> ProductsPerOrder(int orderID)
{
Order order = await _orderRepository.GetByIDAsync(orderID);
List <OrderProductViewModel> opvm = new List <OrderProductViewModel>();
foreach (var c in order.ProductsOrderInfo)
{
var product = await _productRepository.GetByIDAsync(c.productID);
OrderProductViewModel pvm = new OrderProductViewModel()
{
ProductInfoID = c.ProductWithCompletedOrderID,
ProductID = c.productID,
Price = c.PricePayed,
ProductName = product.Name
};
opvm.Add(pvm);
}
return(Json(opvm, JsonRequestBehavior.AllowGet));
}
public async Task <OrderProduct> PlaceOrder(OrderProductViewModel order)
{
if (order.ProductId == Guid.Empty)
{
throw new Exception("Product Id is empty");
}
var productEntity = new OrderProduct()
{
Quantity = order.Quantity,
InvoiceDate = DateTime.UtcNow,
DeliveredDate = DateTime.UtcNow.AddDays(2),
CustomerId = Guid.Parse("15154833-940f-4c5c-a507-f3ec0d23c3ee"),
ProductId = order.ProductId,
};
var result = await _orderProductRepository.PlaceOrder(productEntity);
if (result == null)
{
return(null);
}
return(result);
}
public void DeleteOrderProduct(OrderProductViewModel orderProduct)
{
var op = OrderProductViewModel.ToOrderProduct(orderProduct);
u_repo.DeleteOrderProduct(op);
}
public List <OrderProductViewModel> GetOrderProducts(int orderId)
{
var products = u_repo.GetOrderProducts(op => op.OrderId == orderId).Select(op => OrderProductViewModel.Create(op)).ToList();
return(products);
}
