public async Task <ActionResult> UpdateOrder(PurchaseOrderViewModel order)
{
var updateOrder = await db.PurchaseOrders.FindAsync(order.ID);
if (updateOrder == null)
{
return(HttpNotFound());
}
var Products = await db.PurchaseOrderProducts.Where(p => p.PurchaseOrderId == order.ID).ToListAsync();
db.PurchaseOrderProducts.RemoveRange(Products);
foreach (var p in order.Products)
{
PurchaseOrderProduct orderProduct = new PurchaseOrderProduct
{
PurchaseOrderId = int.Parse(order.ID.ToString()),
ProductId = p.ProductId,
Qty = p.Qty
};
db.PurchaseOrderProducts.Add(orderProduct);
await db.SaveChangesAsync();
}
return(Json(new { updateOrder.PurchaseOrderId, updateOrder.Date }));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ProductId,PurchaseOrderId,QuantityOrdered")] PurchaseOrderProduct purchaseOrderProduct)
{
if (id != purchaseOrderProduct.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(purchaseOrderProduct);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseOrderProductExists(purchaseOrderProduct.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProductId"] = new SelectList(_context.Products, "Id", "Id", purchaseOrderProduct.ProductId);
ViewData["PurchaseOrderId"] = new SelectList(_context.PurchaseOrders, "Id", "Id", purchaseOrderProduct.PurchaseOrderId);
return(View(purchaseOrderProduct));
}
public async Task <ActionResult> SaveOrder(PurchaseOrderViewModel order)
{
var newOrder = new PurchaseOrder
{
VendorID = order.VendorId,
Status = "Pending",
Date = DateTime.Now
};
db.PurchaseOrders.Add(newOrder);
await db.SaveChangesAsync();
foreach (var p in order.Products)
{
PurchaseOrderProduct orderProduct = new PurchaseOrderProduct
{
PurchaseOrderId = newOrder.PurchaseOrderId,
ProductId = p.ProductId,
Qty = p.Qty
};
db.PurchaseOrderProducts.Add(orderProduct);
await db.SaveChangesAsync();
}
return(Json(new { Id = newOrder.PurchaseOrderId, Date = newOrder.Date }));
}
public async Task <IActionResult> PutPurchaseOrderProduct(long id, PurchaseOrderProduct purchaseOrderProduct)
{
if (id != purchaseOrderProduct.Id)
{
return(BadRequest());
}
_context.Entry(purchaseOrderProduct).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseOrderProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// GET: PurchaseOrderProducts/Create
public async Task <IActionResult> CreateAsync(int id)
{
PurchaseOrderProduct purchaseOrderProduct = await _context.PurchaseOrderProducts.Include(pop => pop.Product)
.FirstOrDefaultAsync(pop => pop.ProductId == id);
ViewData["PurchaseOrderId"] = new SelectList(_context.PurchaseOrders.Where(pop => pop.Received == false), "Id", "Name");
return(View(purchaseOrderProduct));
}
private LightProduct GetLightProduct(PurchaseOrderProduct p)
{
return(new LightProduct
{
Id = p.ProductId,
Name = $"{p.Name}{(p.UnitWeight.HasValue && p.UnitWeight > 0 ? " " + p.UnitWeight.Value : "")}",
Reference = p.Reference,
Quantity = p.Quantity
});
}
private static void WriteProductInfo(ExcelWorksheet purchaseOrdersWorksheet, PurchaseOrderProduct product, int i)
{
purchaseOrdersWorksheet.Cells[i, 10].Value = product.Reference;
purchaseOrdersWorksheet.Cells[i, 11].Value = product.Name;
purchaseOrdersWorksheet.Cells[i, 12].Value = product.Quantity;
purchaseOrdersWorksheet.Cells[i, 13].Value = product.UnitWholeSalePrice;
purchaseOrdersWorksheet.Cells[i, 14].Value = product.UnitWholeSalePrice * (1 + product.Vat / 100);
purchaseOrdersWorksheet.Cells[i, 15].Value = product.Vat;
purchaseOrdersWorksheet.Cells[i, 16].Value = product.TotalWholeSalePrice;
purchaseOrdersWorksheet.Cells[i, 17].Value = product.TotalOnSalePrice;
}
public async Task <IActionResult> Create([Bind("Id,ProductId,PurchaseOrderId,QuantityOrdered,ApplicationUserId")] PurchaseOrderProduct purchaseOrderProduct)
{
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
purchaseOrderProduct.ApplicationUserId = user.Id;
purchaseOrderProduct.ProductId = purchaseOrderProduct.Id;
purchaseOrderProduct.Id = 0;
_context.Add(purchaseOrderProduct);
await _context.SaveChangesAsync();
return(Redirect("/PurchaseOrders"));
}
ViewData["ProductId"] = new SelectList(_context.Products, "Id", "Id", purchaseOrderProduct.ProductId);
ViewData["PurchaseOrderId"] = new SelectList(_context.PurchaseOrders, "Id", "Id", purchaseOrderProduct.PurchaseOrderId);
return(View(purchaseOrderProduct));
}
public async Task <PurchaseOrderModel> GetPurchaseOrderById(Guid purchaseOrderID)
{
// get PO Record
var idParam = GetParameter(Resources.PurchaseOrderIdParamName, purchaseOrderID);
var reader = GetDataReader(Resources.GetPurchaseOrderProc, new List <DbParameter> {
idParam
});
if (!reader.HasRows)
{
throw new Exception(Resources.ProductNotFound);
}
await reader.ReadAsync();
var purchaseOrder = new PurchaseOrderModel
{
Id = reader.GetGuid(0),
Number = reader.GetInt32(4),
OrderDate = reader.GetDateTime(5),
IsFinalized = reader.GetBoolean(6),
Supplier = new Supplier
{
Name = reader.GetString(3),
SupplierCode = reader.GetString(2),
Id = reader.GetGuid(1),
CreatedDate = reader.GetDateTime(8)
}
};
if (purchaseOrder.IsFinalized)
{
purchaseOrder.FinalizedDate = reader.GetDateTime(7);
}
await reader.CloseAsync();
var poiParam = GetParameter(Resources.POIdParameterName, purchaseOrderID);
var poiReader = GetDataReader(Resources.GetPurchaseOrderItemsProc, new List <DbParameter> {
poiParam
});
if (!poiReader.HasRows)
{
await poiReader.CloseAsync();
return(purchaseOrder);
}
await poiReader.CloseAsync();
while (await poiReader.ReadAsync())
{
var purchaseOrderItem = new PurchaseOrderProduct
{
Id = poiReader.GetGuid(0),
ProductCode = poiReader.GetString(1),
Price = poiReader.GetDecimal(2),
Description = poiReader.GetString(3),
Quantity = poiReader.GetInt32(4)
};
purchaseOrder.Products.Add(purchaseOrderItem);
}
await poiReader.CloseAsync();
return(purchaseOrder);
}
// Method for changing the Quantity of multiple Products
public async Task <IActionResult> IncreaseProductQuantity(int id)
{
if (ModelState.IsValid)
{
//try
// {
PurchaseOrder purchaseOrder = new PurchaseOrder();
purchaseOrder = await _context.PurchaseOrders
.Include(po => po.PurchaseOrderProducts)
.ThenInclude(pop => pop.Product)
.FirstOrDefaultAsync(m => m.Id == id);
PurchaseOrderProduct purchaseOrderProduct = new PurchaseOrderProduct();
//Conditional to select a product where purchaseOrderId == id
List <Product> products = new List <Product>();
// if (purchaseOrder.PurchaseOrderProduct.PurchaseOrderId == id)
// {
//Define the List of Products from the beginning
products = purchaseOrder.PurchaseOrderProducts.Select(p => p.Product).ToList();
if (purchaseOrder.Received == true)
{
ApplicationUser user = await GetCurrentUserAsync();
//var countProductsGrouped = purchaseOrder.PurchaseOrderProducts.GroupBy(pop => pop.Product.Name).Count();
//Very Close. This is were I need to Update the products with the count of the certain POP
//var product = purchaseOrder.PurchaseOrderProducts.Select(pop => pop.Product);
//if (countProductsGrouped <= 1) { }
// Maybe try foreach groupedproduct in POPViewModel?
// This i wrong.. Maybe foreach product in groupedProducts
//var productsGrouped = purchaseOrder.PurchaseOrderProducts.GroupBy(pop => pop.Product.Name);
//purchaseOrder.PurchaseOrderProduct.QuantityOrdered = countProductsGrouped;
foreach (Product product in purchaseOrder.PurchaseOrderProducts.Select(pop => pop.Product))
{
if (purchaseOrder.PurchaseOrderProducts.GroupBy(pop => pop.Product.Name).Any(pop => pop.Count() < 2))
{
var numberOfProductsGrouped = purchaseOrder.PurchaseOrderProducts.Count();
//purchaseOrder.PurchaseOrderProduct.QuantityOrdered = numberOfProductsGrouped;
product.Quantity = product.Quantity + numberOfProductsGrouped;
;
products.Select(p => p.ApplicationUserId = user.Id);
_context.Update(product);
await _context.SaveChangesAsync();
}
else if (purchaseOrder.PurchaseOrderProducts.GroupBy(pop => pop.Product.Name).Any(pop => pop.Count() > 1))
{
var numberOfProductsGrouped = purchaseOrder.PurchaseOrderProducts.GroupBy(pop => pop.Product.Id).Count();
//purchaseOrder.PurchaseOrderProduct.QuantityOrdered = numberOfProductsGrouped;
product.Quantity = product.Quantity + numberOfProductsGrouped;
;
products.Select(p => p.ApplicationUserId = user.Id);
_context.Update(product);
await _context.SaveChangesAsync();
}
}
;
//product = product.Quantity + purchaseOrder.PurchaseOrderProducts.Select(pop => pop.Product).Count();
//products.Select(p => p.Quantity = p.Quantity + purchaseOrder.PurchaseOrderProducts.Count());
// ApplicationUser user = await GetCurrentUserAsync();
// products.Select(p => p.ApplicationUserId = user.Id);
// _context.Update(product);
// await _context.SaveChangesAsync();
}
else
{
}
//catch (DbUpdateConcurrencyException)
//{
// if (!ProductExists(id))
// {
// return NotFound();
// }
// else
// {
// throw;
// }
//}
return(View(products));
}
return(View(id));
}
public void EditPurchaseOrderProduct(PurchaseOrderProduct purchaseOrderProduct)
{
}
public async Task <ActionResult <PurchaseOrderProduct> > PostPurchaseOrderProduct(PurchaseOrderProduct purchaseOrderProduct)
{
_context.PurchaseOrderProducts.Add(purchaseOrderProduct);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetPurchaseOrderProduct), new { id = purchaseOrderProduct.Id }, purchaseOrderProduct));
}
