public void Add(params T[] items)
{
foreach (T item in items)
{
_context.Entry(item).State = Microsoft.EntityFrameworkCore.EntityState.Added;
}
_context.SaveChanges();
}
public async Task <IActionResult> PutOrderMasters([FromRoute] int id, [FromBody] OrderMasters orderMasters)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderMasters.OrderNo)
{
return(BadRequest());
}
_context.Entry(orderMasters).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderMastersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutItemMaster([FromRoute] int id, [FromBody] ItemMaster itemMaster)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != itemMaster.ItemId)
{
return(BadRequest());
}
_context.Entry(itemMaster).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemMasterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCustomer(Guid id, Customer customer)
{
if (id != customer.CustomerId)
{
return(BadRequest());
}
_context.Entry(customer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Order ModifyOrder(Order order)
{
_ctx.Entry(order).State = EntityState.Modified;
var entity = _ctx.Orders.FirstOrDefault(item => item.Id == order.Id);
if (entity != null)
{
entity = order;
}
return(entity);
}
public Client ModifyClient(Client client)
{
_ctx.Entry(client).State = EntityState.Modified;
var entity = _ctx.Clients.FirstOrDefault(item => item.Id == client.Id);
if (entity != null)
{
entity = client;
}
return(entity);
}
public async Task <IActionResult> PutOrderDetails([FromRoute] int id, [FromBody] OrderDetails orderDetails)
{
_context.Entry(orderDetails).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderDetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(orderDetails));
}
public async Task <IActionResult> Edit(int id, [Bind("OrderID,FirstName,LastName,City,State,DOB,RowVersion")] Order order)
{
if (id != order.OrderID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var orderToUpdate = await _context.Order.FirstOrDefaultAsync(m => m.OrderID == order.OrderID);
if (orderToUpdate == null)
{
Order deletedorder = new Order();
await TryUpdateModelAsync(orderToUpdate);
ModelState.AddModelError(string.Empty,
"Unable to save changes. The Order was deleted by another user.");
return(View(deletedorder));
}
_context.Entry(orderToUpdate).Property("RowVersion").OriginalValue = order.RowVersion;
_context.Entry(orderToUpdate).Property("FirstName").OriginalValue = order.FirstName;
_context.Entry(orderToUpdate).Property("LastName").OriginalValue = order.LastName;
_context.Entry(orderToUpdate).Property("City").OriginalValue = order.City;
_context.Entry(orderToUpdate).Property("State").OriginalValue = order.State;
if (await TryUpdateModelAsync <Order>(
orderToUpdate,
"",
s => s.FirstName, s => s.LastName, s => s.City, s => s.State, s => s.DOB))
{
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateConcurrencyException ex)
{
var exceptionEntry = ex.Entries.Single();
var clientValues = (Order)exceptionEntry.Entity;
var databaseEntry = exceptionEntry.GetDatabaseValues();
if (databaseEntry == null)
{
ModelState.AddModelError(string.Empty,
"Unable to save changes. The order was deleted by another user.");
}
else
{
var databaseValues = (Order)databaseEntry.ToObject();
if (databaseValues.FirstName != clientValues.FirstName)
{
ModelState.AddModelError("FirstName", $"Current value: {databaseValues.FirstName}");
}
if (databaseValues.LastName != clientValues.LastName)
{
ModelState.AddModelError("LastName", $"Current value: {databaseValues.LastName}");
}
if (databaseValues.City != clientValues.City)
{
ModelState.AddModelError("City", $"Current value: {databaseValues.City}");
}
if (databaseValues.State != clientValues.State)
{
ModelState.AddModelError("State", $"Current value: {databaseValues.State}");
}
ModelState.AddModelError(string.Empty, "The record you attempted to edit "
+ "was modified by another user after you got the original value. The "
+ "edit operation was canceled and the current values in the database "
+ "have been displayed. If you still want to edit this record, click "
+ "the Save button again. Otherwise click the Back to List hyperlink.");
orderToUpdate.RowVersion = (byte[])databaseValues.RowVersion;
ModelState.Remove("RowVersion");
}
}
}
}
return(View(order));
}
