private bool CheckIfStockItemAvailable(Guid productGuid)
{
var stockController = new StocksController();
var firstOrDefault = _db.StockItems.FirstOrDefault(g => g.StockItemProduct.ProductGuid == productGuid);
return(firstOrDefault != null && stockController.GetStockItemQuantity(firstOrDefault.StockItemGuid) > 0);
}
public async Task <IHttpActionResult> PostProduct(Product product, Guid stockGuid, int maxQuantity = 0,
int minQuantity = 0)
{
//verify data
if (!ModelState.IsValid)
{
foreach (var v in ModelState.Values)
{
foreach (var e in v.Errors)
{
if (e.Exception != null)
{
return
(BadRequest(
"Something went wrong. Please check your form fields for disallowed or missing values."));
}
}
}
return(BadRequest(ModelState));
}
var stockController = new StocksController();
//generate new guid for the product
product.ProductGuid = Guid.NewGuid();
//add product to db context
db.Products.Add(product);
//save changes to db
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ProductExists(product.ProductGuid))
{
return(Conflict());
}
throw;
}
if (stockGuid != new Guid("00000000-0000-0000-0000-000000000000"))
{
await stockController.CreateStockItem(stockGuid, product, maxQuantity, minQuantity);
}
return(CreatedAtRoute("DefaultApi", new { id = product.ProductGuid }, product));
}
public async Task <IHttpActionResult> PutProduct(Guid id, ProductDetailsViewModel product)
{
//verify data
if (!ModelState.IsValid)
{
foreach (var v in ModelState.Values)
{
foreach (var e in v.Errors)
{
if (e.Exception != null)
{
return
(BadRequest(
"Something went wrong. Please check your form fields for disallowed or missing values."));
}
}
}
return(BadRequest(ModelState));
}
if (id != product.Product.ProductGuid)
{
return(BadRequest());
}
var stockController = new StocksController();
db.Entry(product.Product).State = EntityState.Modified;
//save data
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
throw;
}
await stockController.UpdateStockItem(product.ProductStockItem, product.Product);
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PostSupplyItems(List <SupplyItemProductViewModel> supplyItems,
Guid supplyGuid)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var stockController = new StocksController();
//create the Supplyitems and link them to the Supply
foreach (var p in supplyItems)
{
var supplyItem = new SupplyItem
{
SupplyItemGuid = Guid.NewGuid(),
SupplyItemSupply = _db.Supplys.FirstOrDefault(g => g.SupplyGuid == supplyGuid),
SupplyItemStockItem =
_db.StockItems.FirstOrDefault(g => g.StockItemProduct.ProductGuid == p.ProductGuid),
SupplyQuantity = p.SupplyQuantity
};
_db.SupplyItems.Add(supplyItem);
try
{
await _db.SaveChangesAsync();
}
catch (DbUpdateException)
{
}
await stockController.CreateStockTransaction(new StockItemViewModel
{
StockItemGuid = supplyItem.SupplyItemStockItem.StockItemGuid,
StockItemQuantity = supplyItem.SupplyQuantity,
Supply = supplyItem.SupplyItemSupply,
Order = null
});
}
return(CreatedAtRoute("DefaultApi", new { id = supplyItems }, supplyItems));
}
public async Task <IHttpActionResult> PostOrderItems(List <OrderItemProductViewModel> orderItems, Guid orderGuid)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var stockController = new StocksController();
//create the orderitems and link them to the order
foreach (var p in orderItems)
{
var orderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
OrderItemOrder = db.Orders.FirstOrDefault(g => g.OrderGuid == orderGuid),
OrderItemStockItem =
db.StockItems.FirstOrDefault(g => g.StockItemProduct.ProductGuid == p.ProductGuid),
OrderQuantity = p.OrderQuantity
};
db.OrderItems.Add(orderItem);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
}
await stockController.CreateStockTransaction(new StockItemViewModel
{
StockItemGuid = orderItem.OrderItemStockItem.StockItemGuid,
StockItemQuantity = -orderItem.OrderQuantity,
Order = orderItem.OrderItemOrder,
Supply = null
});
}
return(CreatedAtRoute("DefaultApi", new { id = orderItems }, orderItems));
}
public async Task <IHttpActionResult> DeleteProduct(Guid id)
{
//verify data
if (!db.Products.Any(g => g.ProductGuid == id))
{
return(BadRequest());
}
var stocksController = new StocksController();
var product = await db.Products.FindAsync(id);
product.ProductDeleted = true;
db.Entry(product).State = EntityState.Modified;
//save changes
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
throw;
}
var stockItem = await db.StockItems.FirstOrDefaultAsync(si => si.StockItemProduct.ProductGuid == id);
await stocksController.DeleteStockItem(stockItem.StockItemGuid);
return(StatusCode(HttpStatusCode.NoContent));
}
