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 async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Report> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Report report = await db.Reports.FindAsync(key);
if (report == null)
{
return NotFound();
}
patch.Patch(report);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReportExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(report);
}
// PUT: odata/Parking(5)
public async Task<IHttpActionResult> Put([FromODataUri] long key, Delta<Parking> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Parking parking = await db.Parkings.FindAsync(key);
if (parking == null)
{
return NotFound();
}
patch.Put(parking);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkingExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(parking);
}
// PUT: odata/BOOKs(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<BOOK> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
BOOK bOOK = db.BOOKS.Find(key);
if (bOOK == null)
{
return NotFound();
}
patch.Put(bOOK);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!BOOKExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(bOOK);
}
public IHttpActionResult Patch([FromODataUri] string key, Delta<Friend> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Friend friend = db.Friends.Find(key);
if (friend == null)
{
return NotFound();
}
patch.Patch(friend);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!FriendExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(friend);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Login> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Login login = db.LoginSet.Find(key);
if (login == null)
{
return NotFound();
}
patch.Patch(login);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!LoginExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(login);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<SpecialAbility> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
SpecialAbility specialAbility = db.SpecialAbilities.Find(key);
if (specialAbility == null)
{
return NotFound();
}
patch.Patch(specialAbility);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!SpecialAbilityExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(specialAbility);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Ayle> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Ayle ayle = db.Ayle.Find(key);
if (ayle == null)
{
return NotFound();
}
patch.Patch(ayle);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!AyleExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(ayle);
}
// PUT: odata/RelUserModules(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<RelUserModule> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
RelUserModule relUserModule = await db.RelUserModule.FindAsync(key);
if (relUserModule == null)
{
return NotFound();
}
patch.Put(relUserModule);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RelUserModuleExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(relUserModule);
}
public IHttpActionResult Patch(Delta<SampleModel> delta)
{
// Using the Patch method on Delta<T>, will only overwrite only the properties whose value has
// changed.
var model = new SampleModel();
delta.Patch(model);
// Using Delta doesn't invoke validation on the values that are provided, so use the Validate method
// on the model object after patching to validate it.
this.Validate(model);
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var builder = new StringBuilder();
builder.AppendLine("Updated Properties:");
foreach(var property in delta.GetChangedPropertyNames())
{
object value;
delta.TryGetPropertyValue(property, out value);
builder.AppendLine(String.Format("\t{0} : {1}", property, value));
}
return Text(builder.ToString());
}
// PUT: odata/Members(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Member> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Member member = await db.Members.FindAsync(key);
if (member == null)
{
return NotFound();
}
patch.Put(member);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MemberExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(member);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<WorkType> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
WorkType worktype = await db.WorkTypes.FindAsync(key);
if (worktype == null)
{
return NotFound();
}
patch.Patch(worktype);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkTypeExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(worktype);
}
public IHttpActionResult Patch([FromODataUri] string key, Delta<AspNetUserLogin> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
AspNetUserLogin aspNetUserLogin = db.AspNetUserLogins.Find(key);
if (aspNetUserLogin == null)
{
return NotFound();
}
patch.Patch(aspNetUserLogin);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!AspNetUserLoginExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(aspNetUserLogin);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Movie> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Movie movie = db.Movies.Find(key);
if (movie == null)
{
return NotFound();
}
patch.Patch(movie);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(movie);
}
public IHttpActionResult Patch([FromODataUri] long key, Delta<Employee> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Employee employee = db.Employees.Find(key);
if (employee == null)
{
return NotFound();
}
patch.Patch(employee);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(employee);
}
// PUT: odata/TauschObjs(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<TauschObj> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
TauschObj tauschObj = db.TauschObjs.Find(key);
if (tauschObj == null)
{
return NotFound();
}
patch.Put(tauschObj);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TauschObjExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(tauschObj);
}
// PUT: odata/Basic_Information1(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Basic_Information> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Basic_Information basic_Information = await db.Basic_Information.FindAsync(key);
if (basic_Information == null)
{
return NotFound();
}
patch.Put(basic_Information);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Basic_InformationExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(basic_Information);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<MatchHistoryDetail> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
MatchHistoryDetail matchHistoryDetail = db.MatchHistoryDetails.Find(key);
if (matchHistoryDetail == null)
{
return NotFound();
}
patch.Patch(matchHistoryDetail);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!MatchHistoryDetailExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(matchHistoryDetail);
}
// PUT: odata/ActiveHotelProduct(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<ActiveHotelProduct> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
ActiveHotelProduct activeHotelProduct = await db.ActiveHotelProduct.FindAsync(key);
if (activeHotelProduct == null)
{
return NotFound();
}
patch.Put(activeHotelProduct);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ActiveHotelProductExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(activeHotelProduct);
}
public IHttpActionResult Patch([FromODataUri] string key, Delta<Customer> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Customer customer = db.Customers.Find(key);
if (customer == null)
{
return NotFound();
}
patch.Patch(customer);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(customer);
}
public IHttpActionResult Patch([FromODataUri] string key, Delta<Ingredient> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Ingredient ingredient = db.Ingredients.Find(key);
if (ingredient == null)
{
return NotFound();
}
patch.Patch(ingredient);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!IngredientExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(ingredient);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Categories> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Categories categories = db.Categories.Find(key);
if (categories == null)
{
return NotFound();
}
patch.Patch(categories);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoriesExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(categories);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<TodoList> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
TodoList todolist = await db.TodoLists.FindAsync(key);
if (todolist == null)
{
return NotFound();
}
patch.Patch(todolist);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TodoListExists(key))
{
return NotFound();
}
throw;
}
return Updated(todolist);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Contact> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Contact contact = db.Contacts.Find(key);
if (contact == null)
{
return NotFound();
}
patch.Patch(contact);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(contact);
}
// PUT: odata/FoodDescriptions(5)
public async Task<IHttpActionResult> Put([FromODataUri] string key, Delta<FoodDescription> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
FoodDescription foodDescription = await db.FoodDescriptions.FindAsync(key);
if (foodDescription == null)
{
return NotFound();
}
patch.Put(foodDescription);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FoodDescriptionExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(foodDescription);
}
// PUT: odata/IdentityBinderLinkHistory(5)
public async Task<IHttpActionResult> Put([FromODataUri] long key, Delta<IdentityBinderLinkHistory> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
IdentityBinderLinkHistory identityBinderLinkHistory = await db.IdentityBinderLinkHistory.FindAsync(key);
if (identityBinderLinkHistory == null)
{
return NotFound();
}
patch.Put(identityBinderLinkHistory);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IdentityBinderLinkHistoryExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(identityBinderLinkHistory);
}
public IHttpActionResult Patch([FromODataUri] Guid key, Delta<WorkTaskModel> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
WorkTaskModel workTaskModel = db.WorkTaskModels.Find(key);
if (workTaskModel == null)
{
return NotFound();
}
patch.Patch(workTaskModel);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkTaskModelExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(workTaskModel);
}
// PUT: odata/Programs(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<Program> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Program program = db.Programs.Find(key);
if (program == null)
{
return NotFound();
}
patch.Put(program);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProgramExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(program);
}
// PUT: odata/OrganizationIdentityDirectory(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<OrganizationIdentityDirectory> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
OrganizationIdentityDirectory organizationIdentityDirectory = await db.OrganizationIdentityDirectory.FindAsync(key);
if (organizationIdentityDirectory == null)
{
return NotFound();
}
patch.Put(organizationIdentityDirectory);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrganizationIdentityDirectoryExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(organizationIdentityDirectory);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Hazard> patch)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Hazard hazard = await db.Hazards.FindAsync(key);
if (hazard == null)
{
return NotFound();
}
patch.Patch(hazard);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HazardExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(hazard);
}
public void CanCreateDeltaOfDerivedTypes()
{
var delta = new Delta <Base>(typeof(Derived));
Assert.IsType(typeof(Derived), delta.GetEntity());
}
public virtual async Task <HttpResponseMessage> Patch([FromODataUri] TKey key, Delta <TEntity> patch)
{
TEntity patchedEntity = await PatchEntityAsync(key, patch);
return(EntitySetControllerHelpers.PatchResponse <TEntity>(Request, patchedEntity));
}
public void Can_Declare_A_Delta_Of_An_AbstractClass()
{
Delta <AbstractBase> abstractDelta = null;
Assert.Null(abstractDelta);
}
public virtual HttpResponseMessage Patch([FromODataUri] TKey key, Delta <TEntity> patch)
{
TEntity patchedEntity = PatchEntity(key, patch);
return(EntitySetControllerHelpers.PatchResponse(Request, patchedEntity));
}
/// <summary>
/// This method should be overridden to apply a partial update to an existing entity in the entity set.
/// </summary>
/// <param name="key">The entity key of the entity to update.</param>
/// <param name="patch">The patch representing the partial update.</param>
/// <returns>A <see cref="Task"/> that contains the updated entity when it completes.</returns>
protected internal virtual Task <TEntity> PatchEntityAsync(TKey key, Delta <TEntity> patch)
{
throw EntitySetControllerHelpers.PatchEntityNotImplementedResponse(Request);
}