public IHttpActionResult PatchToCompany(int key, Delta<Company> company) { var navigateCompany = Employees.First(e => e.ID == key).Company; company.Patch(Employees.First(e => e.ID == key).Company); if (navigateCompany.Name == "Umbrella") { company.Patch(UmbrellaController.Umbrella); } else { return BadRequest(); } return StatusCode(HttpStatusCode.NoContent); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<Product> patch) { if (!ModelState.IsValid) { return BadRequest(ModelState); } Product product = db.Products.Find(key); if (product == null) { return NotFound(); } patch.Patch(product); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(key)) { return NotFound(); } else { throw; } } return Updated(product); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<ETOPlaybook> product) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var entity = await _context.ETOPlaybooks.FindAsync(key); if (entity == null) { return NotFound(); } product.Patch(entity); try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { //if (!ProductExists(key)) //{ // return NotFound(); //} //else //{ throw; //} } return Updated(entity); }
public IHttpActionResult Patch(int key, Delta<Employee> employee) { Employee originalEmployee = Employees.Single(e => e.Id == key); employee.Patch(originalEmployee); return Ok(employee); }
public async Task<IHttpActionResult> Patch([FromODataUri] string customerId, Delta<Customer> customer) { if (!ModelState.IsValid) return BadRequest(ModelState); var entity = await _Repository.GetEntityAsync(new FindCustomerByIdSpecificationStrategy(customerId)); if (entity == null) return NotFound(); try { customer.Patch(entity); _Repository.Modify(entity); await _Repository.SaveAsync(); return Updated(entity); } catch (DbUpdateConcurrencyException) { if (!CustomerExists(customerId)) return NotFound(); else throw; } }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Product> product) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var entity = await db.Products.FindAsync(key); if (entity == null) { return NotFound(); } product.Patch(entity); try { await db.SaveChangesAsync(); } catch (Exception ex) { if (!ProductExists(key)) { return NotFound(); } else { throw; } } return Updated(entity); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Customer> Customer) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var entity = await db.Customers.FindAsync(key); if (entity == null) { return NotFound(); } Customer.Patch(entity); try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CustomerExists(key)) { return NotFound(); } else { throw; } } return Updated(entity); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<Category> patch) { if (!ModelState.IsValid) { return BadRequest(ModelState); } Category category = db.Categories.Find(key); if (category == null) { return NotFound(); } patch.Patch(category); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(key)) { return NotFound(); } else { throw; } } return Updated(category); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<Order> patch) { if (!ModelState.IsValid) { return BadRequest(ModelState); } Order order = db.Orders.Find(key); if (order == null) { return NotFound(); } patch.Patch(order); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!OrderExists(key)) { return NotFound(); } else { throw; } } return Updated(order); }
public IHttpActionResult PatchMe(Delta<Person> patch) { if (!ModelState.IsValid) { return BadRequest(ModelState); } patch.Patch(TripPinSvcDataSource.Instance.Me); return Updated(TripPinSvcDataSource.Instance.Me); }
public IHttpActionResult Patch(int key, Delta<File> patch) { File original = _files.FirstOrDefault(c => c.FileId == key); if (original == null) { return NotFound(); } patch.Patch(original); return Updated(original); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<ContactType> delta) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var contactType = _db.ContactType.Single(t => t.ContactTypeID == key); delta.Patch(contactType); _db.SaveChanges(); return Updated(contactType); }
public IHttpActionResult Patch(int key, Delta<Account> patch) { IEnumerable<Account> appliedAccounts = Accounts.Where(a => a.Id == key); if (appliedAccounts.Count() == 0) { return BadRequest(string.Format("The entry with Id {0} doesn't exist", key)); } Account account = appliedAccounts.Single(); patch.Patch(account); return Ok(account); }
public IHttpActionResult PatchPerson([FromODataUri] string firstName, [FromODataUri] string lastName, Delta<Person> delta) { var person = _repo.Get(firstName, lastName); if (person == null) { return NotFound(); } delta.Patch(person); person.FirstName = firstName; person.LastName = lastName; _repo.UpdateOrAdd(person); return Updated(person); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<ScheduledTask> entityDelta) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var entity = await Context.ScheduledTasks.FindAsync(key); if (entity == null) { return NotFound(); } entityDelta.Patch(entity); try { await Context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { return NotFound(); } return Updated(entity); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Customer> patch) { object id; if (!ModelState.IsValid) { return BadRequest(ModelState); } else if (patch.TryGetPropertyValue("Id", out id) && (int)id != key) { return BadRequest("The key from the url must match the key of the entity in the body"); } Customer originalEntity = await context.Customers.FindAsync(key); if (originalEntity == null) { return NotFound(); } else { patch.Patch(originalEntity); await context.SaveChangesAsync(); } return Updated(originalEntity); }
public void CanPatch_OpenType() { // Arrange var address = new SimpleOpenAddress { City = "City", Street = "Street", Properties = new Dictionary <string, object> { { "IntProp", 9 }, { "ListProp", new List <int> { 1, 2, 3 } } } }; PropertyInfo propertyInfo = typeof(SimpleOpenAddress).GetProperty("Properties"); var delta = new Delta <SimpleOpenAddress>(typeof(SimpleOpenAddress), null, propertyInfo); delta.TrySetPropertyValue("City", "ChangedCity"); delta.TrySetPropertyValue("IntProp", 1); // Act delta.Patch(address); // Assert // unchanged Assert.Equal("Street", address.Street); Assert.Equal(new List <int> { 1, 2, 3 }, address.Properties["ListProp"]); // changed Assert.Equal("ChangedCity", address.City); Assert.Equal(1, address.Properties["IntProp"]); }
// PUT: odata/Orders(5) public async Task<IHttpActionResult> Put([FromODataUri] long key, Delta<CGC.DH.Order.API.Models.Order> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } CGC.DH.Order.API.Models.Order order = await db.Orders.FindAsync(key); if (order == null) { return NotFound(); } //patch.Put(order); patch.Patch(order); try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrderExists(key)) { return NotFound(); } else { throw; } } return Updated(order); }
public IHttpActionResult Patch(int orderId, int lineId, Delta<OrderLine> patch) { var orderLine = _orderLines.FirstOrDefault(o => o.ID == lineId && o.OrderId == orderId); if (orderLine == null) { return NotFound(); } patch.Patch(orderLine); return Updated(orderLine); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Customer> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } var customer = await _db.Customers.FindAsync(key); if (customer == null) { return NotFound(); } patch.Patch(customer); try { await _db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CustomerExists(key)) { return NotFound(); } throw; } return Updated(customer); }
private Task<ProductDiamond> UpdatePatchAsync(ProductDiamond entity, Delta<ProductDiamond> patch) { patch.Patch(entity); return UpdateAsync(entity); }
private Task<ProductDiamond> CreatePatchAsync(Delta<ProductDiamond> patch) { var entity = new ProductDiamond(); patch.Patch(entity); return CreateAsync(entity); }
public async Task<IHttpActionResult> Patch([FromODataUri] Guid key, Delta<Note> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } Note note = await db.Notes.FindAsync(key); if (note == null) { return NotFound(); } patch.Patch(note); try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NoteExists(key)) { return NotFound(); } else { throw; } } return Updated(note); }
public IHttpActionResult Patch(int key, Delta<Employee> delta) { Employee originalEmployee = Employees.SingleOrDefault(c => c.ID == key); if (originalEmployee == null) { Employee temp = new Employee(); delta.Patch(temp); Employees.Add(temp); return Created(temp); } delta.Patch(originalEmployee); return Ok(delta); }
public IHttpActionResult PatchAttributeRouting(int key, Delta<Account> patch, ODataQueryOptions<Account> queryOptions) { IEnumerable<Account> appliedAccounts = Accounts.Where(a => a.Id == key); if (appliedAccounts.Count() == 0) { return BadRequest(string.Format("The entry with Id {0} doesn't exist", key)); } if (queryOptions.IfMatch != null) { IQueryable<Account> ifMatchAccounts = queryOptions.IfMatch.ApplyTo(appliedAccounts.AsQueryable()).Cast<Account>(); if (ifMatchAccounts.Count() == 0) { return BadRequest(string.Format("The entry with Id {0} has been updated", key)); } } Account account = appliedAccounts.Single(); patch.Patch(account); return Ok(account); }
public IHttpActionResult Patch(int key, Delta<ETagsCustomer> patch, ODataQueryOptions<ETagsCustomer> queryOptions) { IEnumerable<ETagsCustomer> appliedCustomers = customers.Where(c => c.Id == key); if (appliedCustomers.Count() == 0) { return BadRequest(string.Format("The entry with Id {0} doesn't exist", key)); } if (queryOptions.IfMatch != null) { IQueryable<ETagsCustomer> ifMatchCustomers = queryOptions.IfMatch.ApplyTo(appliedCustomers.AsQueryable()).Cast<ETagsCustomer>(); if (ifMatchCustomers.Count() == 0) { return StatusCode(HttpStatusCode.PreconditionFailed); } } ETagsCustomer customer = appliedCustomers.Single(); patch.Patch(customer); return Ok(customer); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<OptionSetEntity> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } OptionSetEntity optionSetEntity = db.OptionSetEntities.Find(key); if (optionSetEntity == null) { return NotFound(); } patch.Patch(optionSetEntity); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!OptionSetEntityExists(key)) { return NotFound(); } else { throw; } } return Updated(optionSetEntity); }
public async Task<IHttpActionResult> Patch([FromODataUri] string key, Delta<Award> patch) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var award = await db.Awards.FindAsync(key); if (award == null) { return NotFound(); } patch.Patch(award); try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { throw; } return Updated(award); }
public IHttpActionResult Patch([FromODataUri] int key, Delta<Person> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } Person person = db.People.Find(key); if (person == null) { return NotFound(); } patch.Patch(person); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!PersonExists(key)) { return NotFound(); } else { throw; } } return Updated(person); }
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Student> patch) { Validate(patch.GetEntity()); if (!ModelState.IsValid) { return BadRequest(ModelState); } Student student = await db.Students.FindAsync(key); if (student == null) { return NotFound(); } patch.Patch(student); try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!StudentExists(key)) { return NotFound(); } else { throw; } } return Updated(student); }
public IHttpActionResult PatchManager(int key, Delta<Manager> employee) { Manager originalEmployee = Employees.OfType<Manager>().Single(e => e.Id == key); employee.Patch(originalEmployee); return Ok(originalEmployee); }