public async Task <IActionResult> PutProduct(int id, Product product)
{
if (id != product.ID)
{
return(BadRequest());
}
_context.Entry(product).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task<IHttpActionResult> PutSalesOrder(long id, SalesOrder salesOrder)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != salesOrder.Id)
{
return BadRequest();
}
db.Entry(salesOrder).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public async Task <IHttpActionResult> PutTransaction(long id, Transaction transaction)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != transaction.Id)
{
return(BadRequest());
}
db.Entry(transaction).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutProductTab(int id, ProductTabDetailsDto productTabDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ProductTypeList = productTabDetails.ProductTypes;
List <ProductType> productTypes = new List <ProductType>();
foreach (var i in ProductTypeList)
{
var pT = from pt in db.ProductTypes where pt.Id == i select pt;
pT.ForEach(pt => productTypes.Add(pt));
}
var productTab = db.ProductTabs.Find(id);
if (productTab != null)
{
productTab.Active = productTabDetails.Active;
productTab.Color = productTabDetails.Color;
productTab.Name = productTabDetails.Name;
productTab.Priority = productTabDetails.Priority;
}
productTab.ProductTypes.Clear();
productTypes?.ForEach(e => productTab.ProductTypes.Add(e));
if (id != productTab.Id)
{
return(BadRequest());
}
db.Set <ProductTab>().Attach(productTab);
db.Entry(productTab).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductTabExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutProductType(int id, ProductTypeDetailsDto productTypeDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ProductGroupList = productTypeDetails.ProductGroups;
List <ProductGroup> productGroups = new List <ProductGroup>();
foreach (var i in ProductGroupList)
{
var pG = from pg in db.ProductGroups where pg.Id == i select pg;
pG.ForEach(pg => productGroups.Add(pg));
}
var productType = db.ProductTypes.Find(id);
if (productType != null)
{
productType.Color = productTypeDetails.Color;
productType.Name = productTypeDetails.Name;
productType.Price = productTypeDetails.Price;
}
productType.ProductGroups.Clear();
productGroups?.ForEach(e => productType.ProductGroups.Add(e));
if (id != productType.Id)
{
return(BadRequest());
}
db.Set <ProductType>().Attach(productType);
db.Entry(productType).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutProductGroup(long id, ProductGroupDetailsDto productGroupDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ProductList = productGroupDetails.Products;
List <Product> products = new List <Product>();
foreach (var i in ProductList)
{
var product = from pr in db.Products where pr.Id == i select pr;
product.ForEach(pr => products.Add(pr));
}
var productGroup = db.ProductGroups.Find(id);
if (productGroup != null)
{
productGroup.Name = productGroupDetails.Name;
}
productGroup.Products.Clear();
products?.ForEach(e => productGroup.Products.Add(e));
if (id != productGroup.Id)
{
return(BadRequest());
}
db.Set <ProductGroup>().Attach(productGroup);
db.Entry(productGroup).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductGroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <ActionResult <Receipt> > PostReceipt(List <ReceiptLineDto> receiptLineDto)
{
// Read product data from DB for incoming product IDs
var products = new Dictionary <int, Product>();
var productsArr = await _context.Products.ToListAsync();
foreach (var p in productsArr)
{
products[p.ID] = p;
}
try
{
// Build receipt from DTO
var newReceipt = new Receipt
{
ReceiptTimestamp = DateTime.UtcNow,
ReceiptLines = receiptLineDto.Select(rl => new ReceiptLine
{
ID = 0,
BoughtProduct = products[rl.ProductID],
Amount = rl.Amount,
TotalPrice = rl.Amount * products[rl.ProductID].UnitPrice
}).ToList()
};
newReceipt.TotalPrice = newReceipt.ReceiptLines.Sum(rl => rl.TotalPrice);
if (newReceipt.ReceiptLines.Count == 0)
{
return(BadRequest());
}
_context.Receipts.Add(newReceipt);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetReceipt", new { id = newReceipt.ID }, newReceipt));
}
catch (KeyNotFoundException e)
{
return(BadRequest());
}
}
