public void PartialUpdate(T value, List <string> properties) { var dbEntityEntry = DatabaseContext.Entry(value); foreach (var property in properties) { dbEntityEntry.Property(property).IsModified = true; } }
public void Delete(TEntity deletedEntity) { if (_context.Entry(deletedEntity).State == EntityState.Detached) { _context.Set <TEntity>().Attach(deletedEntity); } _context.Set <TEntity>().Remove(deletedEntity); }
public void DBContextEntryLoad() { using (var context = new NorthwindContext()) { var employeeTerritories = context.EmployeeTerritories.First(); context.Entry(employeeTerritories).Reference(a => a.Employee).Load(); context.Entry(employeeTerritories).Reference(a => a.Territory).Query().Load(); } }
public void Update(TEntity entity) { _context.Entry(entity).State = EntityState.Modified; try { _context.SaveChanges(); } catch (DbUpdateConcurrencyException) { throw; } }
public async Task <JsonResult> UpdateData([System.Web.Http.FromBody] OrderDetailProductViewModel orderDetailProductViewModel) { if (ModelState.IsValid) { int orderid = orderDetailProductViewModel.OrderDetail.OrderID; int productid = orderDetailProductViewModel.Product.ProductID; db.Entry(orderDetailProductViewModel.OrderDetail).State = EntityState.Modified; db.Entry(orderDetailProductViewModel.Product).State = EntityState.Modified; await db.SaveChangesAsync(); return(Json(new { Result = "Save OK" })); } return(Json(new { Result = "Save Fail" })); }
public async Task <IActionResult> PutCustomer(string 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 static bool UpdateTicketType(TicketType Type) { bool result = false; using (var ctx = new NorthwindContext()) { using (var dbContextTransaction = ctx.Database.BeginTransaction()) { try { TicketType Query = (from t in ctx.TicketTypes where Type.Id == t.Id select t).FirstOrDefault(); ctx.Entry(Query).CurrentValues.SetValues(Type); ctx.SaveChanges(); dbContextTransaction.Commit(); result = true; } catch (Exception) { dbContextTransaction.Rollback(); result = false; } } } return(result); }
public async Task <IActionResult> PutProduct([FromRoute] int id, [FromBody] Product product) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != product.ProductId) { return(BadRequest()); } _context.Entry(product).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
//delete //delete (physical) or change (logical update) the entire entity record //the value returned is the number of rows affected public int Products_Delete(int productid) { using (var context = new NorthwindContext()) { //Physical Delete //the physical removal of a record from the database ////locate the instance of the entity to be removed //var existing = context.Products.Find(productid); ////is it there //if (existing == null) //{ // throw new Exception("Record has been remove already."); //} ////Stage //context.Products.Remove(existing); ////commit //return context.SaveChanges(); //Logical delete //you normal set a property to a specific value to // indicate the record should be considered gone //this is actually an update of the record //locate the instance of the entity to be removed var existing = context.Products.Find(productid); //set the property to the specific value existing.Discontinued = true; //Stage context.Entry(existing).State = System.Data.Entity.EntityState.Modified; //commit return(context.SaveChanges()); } }
public async Task <IActionResult> PutOrderDetail([FromRoute] string id, [FromBody] OrderDetail orderDetail) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != orderDetail.Id) { return(BadRequest()); } _context.Entry(orderDetail).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrderDetailExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
//this method deletes a record from the database // or //this method logically flags a record to be deemed deleted from the database //this method returns the number of records affected on the database public int Products_Delete(int productid) { //start transaction using (var context = new NorthwindContext()) { ////physical delete //var existing = context.Products.Find(productid); ////stage //context.Products.Remove(existing); ////commit //return context.SaveChanges(); //logical delete var existing = context.Products.Find(productid); //alter the data value on the record that will // logically deem the deleted deleted //You should NOT rely on the user to do this // alternation on the web form existing.Discontinued = true; //stage context.Entry(existing).State = System.Data.Entity.EntityState.Modified; //commit return(context.SaveChanges()); } //to query your database using a non primary key value //this will require a sql procedure to call //the namespace System.Data.SqlClient is required //the returning datatype is IEnumerable<T> //this returning datatype will be cast using ToList() on the return }
public async Task <IActionResult> PutCategory(int id, [FromBody] Category category) { if (id != category.CategoryId) { return(BadRequest()); } _context.Entry(category).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutTerritory([FromRoute] string id, [FromBody] Territory territory) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != territory.TerritoryId) { return(BadRequest()); } _context.Entry(territory).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TerritoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutOrders(int id, Orders orders) { if (id != orders.OrderId) { return(BadRequest()); } _context.Entry(orders).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrdersExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public static bool UpdateClient(Client Client) { bool result = false; using (var ctx = new NorthwindContext()) { using (var dbContextTransaction = ctx.Database.BeginTransaction()) { try { Client query = (from x in ctx.Clients where x.Id == Client.Id select x).FirstOrDefault(); ctx.Entry(query).CurrentValues.SetValues(Client); ctx.SaveChanges(); dbContextTransaction.Commit(); result = true; } catch (Exception) { dbContextTransaction.Rollback(); result = false; } } } return(result); }
public async Task <IHttpActionResult> PutCategory(int id, Category category) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != category.CategoryID) { return(BadRequest()); } db.Entry(category).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <ActionResult> PutSupplier(int id, [FromBody] Supplier editedSupplier) { if (id == editedSupplier.SupplierId) { return(BadRequest()); } northwindContext.Entry(editedSupplier).State = EntityState.Modified; try { await northwindContext.SaveChangesAsync(); } catch (DBConcurrencyException) { var isSupplierExist = northwindContext.Suppliers.Any(a => a.SupplierId == id); if (!isSupplierExist) { return(NotFound()); } else { throw; } } return(NoContent()); }
/// <summary> /// Get entity by primary key /// </summary> /// <param name="id">primary key to find</param> /// <param name="references">empty, one or more navigation property by name</param> /// <returns>Entity if found along with navigation items if specified</returns> public async Task <TEntity> GetTask(int id, string[] references = null) { var model = await _dbSet.FindAsync(id); if (references == null) { return(model); } foreach (var reference in references) { _context.Entry((object)model).Reference(reference).Load(); } return(model); }
public async Task <ActionResult> PutEmployee(int id, [FromBody] Employee editedEmployee) { if (id != editedEmployee.EmployeeId) { return(BadRequest()); } northwindContext.Entry(editedEmployee).State = EntityState.Modified; try { await northwindContext.SaveChangesAsync(); } catch (DBConcurrencyException) { if (!EmployeeExists(id)) { return(NotFound()); } else { throw; } } return(Ok()); }
public async Task <IHttpActionResult> PutEmployee(int id, Employee employee) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != employee.EmployeeID) { return(BadRequest()); } db.Entry(employee).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EmployeeExists(id)) { return(NotFound()); } throw; } return(StatusCode(HttpStatusCode.NoContent)); }
public IHttpActionResult PutCustomer(string id, Customer customer) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != customer.CustomerID) { return(BadRequest()); } db.Entry(customer).State = EntityState.Modified; try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!CustomerExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <IActionResult> PutRegion(int id, Region region) { if (id != region.Id) { return(BadRequest()); } _context.Entry(region).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!RegionExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
//Delete //physical delete: physical removal of the record from the database //logical delete: usually some record attribute is set to indicate // that this record should be ignored //input: the pkey value of the record //output: rows affected public int Product_Delete(int productid) { //transaction using (var context = new NorthwindContext()) { //physical // removal of record from the database ////find and retain the record to remove //var existing = context.Products.Find(productid); ////stage record for removal //context.Products.Remove(existing); ////commit //return context.SaveChanges(); //logical // this action will actually be an Update // any attributes that are required for tracking // need to be handled // the attribute that indicates the record is logically // removed needs to be handled //find record to be "deleted" var existing = context.Products.Find(productid); //adjust logical/tracking attributes //existing.LastModified = DateTime.Now; existing.Discontinued = true; //stage for update context.Entry(existing).State = System.Data.Entity.EntityState.Modified; //commit return(context.SaveChanges()); } }
public async Task <ActionResult <Product> > PutProduct(int id, [FromBody] Product product) { if (id != product.ProductId) { return(BadRequest()); } northwindContext.Entry(product).State = EntityState.Modified; try { await northwindContext.SaveChangesAsync(); } catch (DBConcurrencyException) { if (!ProductExisit(id)) { return(NotFound()); } else { throw; } } return(product); }
public async Task <IActionResult> PutEmployees([FromRoute] int id, [FromBody] Employees employees) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != employees.EmployeeID) { return(BadRequest()); } _context.Entry(employees).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EmployeesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
//Update //the update will receive an instance <T> //the instance will have the pkey value //the commit will return the number of rows affected public int Product_Update(Product item) { using (var context = new NorthwindContext()) { //optional: //there could be an attribute(s) on your table // that track alternations to the database // record such as date of change, security id // of person making the change //let us assume that there is an attribute on // the record which records the update date //item.LastModified = DateTime.Now; //staging //this update approach will update the entire // record on the data that matches // the pkey value of the instance context.Entry(item).State = System.Data.Entity.EntityState.Modified; //commit //the execution returns the number of rows affected return(context.SaveChanges()); } }
//this method deletes a record from the database // or //the method logically flags a record to be deemed deleted forn the databse //this method reutrns the number of records affected on the database public int Products_Delete(int productid) { //start transaction using (var context = new NorthwindContext()) { //physical delete //var existing = context.Products.Find(productid); //stage //context.Products.Remove(existing); //commit //return context.SaveChanges(); //logical var existing = context.Products.Find(productid); //alter the data balue on the record that will // logically deem the deketed deketed //You should NOT rely on the user to do this // alternation on the web form existing.Discontinued = true; //stage context.Entry(existing).State = System.Data.Entity.EntityState.Modified; //commit return(context.SaveChanges()); } }
//Delete //physical: will remove the record physically from the database //logical: will usually set an attribute on the database record // indicating that the record should be ignored in // normal processing //input: only the pkey value is required //output: number of rows affected public int Product_Delete(int productid) { using (var context = new NorthwindContext()) { //physical ////find record on database to delete //var existing = context.Products.Find(productid); ////remove the physical instance (staging) //context.Products.Remove(existing); ////commit //return context.SaveChanges(); //logical //find record on database to "delete" var existing = context.Products.Find(productid); //staging //the attribute used to flag the records // as a logical delete SHOULD be set by // the controller method and NOT be relied // upon by the used existing.Discontinued = true; //existing.LastModied = DateTime.Now; as in update //the staging for a logical delete is actually an // an update context.Entry(existing).State = System.Data.Entity.EntityState.Modified; //commit return(context.SaveChanges()); } }
public async Task <IActionResult> PutCustomers([FromRoute] string id, [FromBody] Customers customers) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != customers.CustomerID) { return(BadRequest()); } _context.Entry(customers).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CustomersExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutProducts(int id, Products products) { var context = new NorthwindContext(); if (id != products.ProductId) { return(BadRequest()); } context.Entry(products).State = EntityState.Modified; try { context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductsExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }