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);
}
