// PUT: odata/Notes(5)
public async Task<IHttpActionResult> Put([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.Put(note);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NoteExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(note);
}
// PUT: odata/PlatformsImporter(5)
public async Task<IHttpActionResult> Put([FromODataUri] string key, Delta<Platform> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Platform platform = await db.Platforms.FindAsync(key);
if (platform == null)
{
return NotFound();
}
patch.Put(platform);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlatformExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(platform);
}
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);
}
// PUT: odata/Claims(5)
public async Task<IHttpActionResult> Put([FromODataUri] Guid key, Delta<Claim> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var claim = await db.Claims.FindAsync(key);
if (claim == null)
{
return NotFound();
}
patch.Put(claim);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaimExists(key))
{
return NotFound();
}
throw;
}
return Updated(claim);
}
// PUT: odata/Users(5)
public async Task<IHttpActionResult> Put( [FromODataUri] int key, Delta<Account> patch )
{
Validate( patch.GetEntity() );
if ( !ModelState.IsValid )
{
return BadRequest( ModelState );
}
var user = await _db.Accounts.SingleOrDefaultAsync( u => u.Id == key );
if ( user == null )
{
return NotFound();
}
patch.Put( user );
try
{
await _db.SaveChangesAsync();
}
catch ( DbUpdateConcurrencyException )
{
if ( !ApplicationUserExists( key ) )
{
return NotFound();
}
else
{
throw;
}
}
return Updated( user );
}
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<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);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<TranslatedCompany> delta, [ValueProvider(typeof(CultureValueProviderFactory))] string culture = "en-US")
{
var company = new Company(delta.GetEntity(), culture);
company.Map = UpdateMapImage(company.Map);
var tochange = _companiesManager.Patch(key, company);
try
{
await _companiesManager.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!_companiesManager.Exists(tochange.Id))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(tochange);
}
// PUT: odata/Students(5)
public async Task<IHttpActionResult> Put([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.Put(student);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(student);
}
// PUT: odata/Employees(5)
public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Employee> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
// delta.Put(employee);
// TODO: Save the patched entity.
// return Updated(employee);
return StatusCode(HttpStatusCode.NotImplemented);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Product> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
// delta.Patch(product);
// TODO: Save the patched entity.
// return Updated(product);
return StatusCode(HttpStatusCode.NotImplemented);
}
// PUT: odata/Players(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<Player> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
var player = (from p in _cricketContext.Players
where p.Id == key
select p).First();
delta.Put(player);
// TODO: Save the patched entity.
// return Updated(player);
return StatusCode(HttpStatusCode.NotImplemented);
}
// 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 async Task<IHttpActionResult> Patch([FromODataUri] System.Guid key, Delta<Tournament> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
// delta.Patch(tournament);
// TODO: Save the patched entity.
// return Updated(tournament);
return StatusCode(HttpStatusCode.NotImplemented);
}
public async Task<IHttpActionResult> Patch([FromODataUri] string key, Delta<Namespace> ns, [ValueProvider(typeof(CultureValueProviderFactory))] string culture = "en-US")
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var entity = await db.Dictionaries.FindAsync(key);
if (entity == null)
{
return NotFound();
}
foreach (var property in ns.GetChangedPropertyNames())
{
if (property == nameof(entity.Description))
{
entity.Description = ns.GetEntity().Description;
}
}
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NamespaceExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(entity);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Translation> translation, [ValueProvider(typeof(CultureValueProviderFactory))] string culture = "en-US")
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var entity = (from term in db.Terms.Where(t => t.Id == key)
join termTranslation in db.TermTranslations.Where(t => t.Culture == culture)
on term.Id equals termTranslation.TermId
select term).Include(t => t.Translations).SingleOrDefault();
if (entity == null)
{
return NotFound();
}
var translationEntity = translation.GetEntity();
var tr = entity.Translations.FirstOrDefault();
foreach (var property in translation.GetChangedPropertyNames())
{
// term
if (property == nameof(entity.Key))
{
entity.Key = translationEntity.Key;
} else if (property == nameof(entity.DictionryId))
{
entity.DictionryId = translationEntity.NamespaceId;
}
// term translation
if (property == nameof(tr.Value))
{
tr.Value = translationEntity.Value;
}
}
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TranslationExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(entity);
}
public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Course> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Course course = await db.Courses.FindAsync(key);
if (course == null)
{
return NotFound();
}
patch.Patch(course);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(course);
}
public async Task<IHttpActionResult> Patch([FromODataUri] string key, Delta<TranslatedPost> delta, [ValueProvider(typeof(CultureValueProviderFactory))] string culture = "en-US")
{
var post = new Post(delta.GetEntity(), culture);
var tochange = _postsManager.Patch(key, post);
try
{
await _postsManager.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!_postsManager.Exists(tochange.Id))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(tochange);
}
public async Task<IHttpActionResult> Patch([FromODataUri] Guid key, Delta<ExerciseSet> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
ExerciseSet exerciseSet = await db.ExerciseSets.FindAsync(key);
if (exerciseSet == null)
{
return NotFound();
}
patch.Patch(exerciseSet);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExerciseSetExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(exerciseSet);
}
public IHttpActionResult Patch([FromODataUri] int key, Delta<Player> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
var player = (from p in _cricketContext.Players
where p.Id == key
select p).First();
// Attach to EF to get change tracking
_cricketContext.Players.Attach(player);
// patch the entity
delta.Patch(player);
player.Id = key;
_cricketContext.SaveChanges();
return Updated(player);
}
// PUT: odata/Nodes(368b4443-1629-4f7a-a7e0-62e2e2047276)
public IHttpActionResult Put([FromODataUri] System.Guid key, Delta<Node> delta)
{
Validate(delta.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// TODO: Get the entity here.
// delta.Put(node);
// TODO: Save the patched entity.
// return Updated(node);
return StatusCode(HttpStatusCode.NotImplemented);
}
public void CanCreateDeltaOfDerivedTypes()
{
var delta = new Delta <Base>(typeof(Derived));
Assert.IsType(typeof(Derived), delta.GetEntity());
}
public async Task CompaniesController_Patch_WhenICallPatch()
{
// Given
var companiesController = _container.Resolve<CompaniesController>();
// When
const int id = 2;
var delta = new Delta<TranslatedCompany>();
delta.TrySetPropertyValue("Logo", Guid.NewGuid().ToString());
delta.TrySetPropertyValue("Headquarters", Guid.NewGuid().ToString());
var updateResult = await companiesController.Patch(id, delta) as UpdatedODataResult<TranslatedCompany>;
// Then
Assert.NotNull(updateResult);
Assert.NotNull(updateResult.Entity);
var company = delta.GetEntity();
Assert.Equal(id, updateResult.Entity.Id);
Assert.Equal(company.Logo, updateResult.Entity.Logo);
Assert.Equal(company.Headquarters, updateResult.Entity.Headquarters);
}
// PUT: odata/Users(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<User> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
User user = db.Users.Find(key);
if (user == null)
{
return NotFound();
}
patch.Put(user);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(user);
}
// HTTP PATCH - Update
public async Task<IHttpActionResult> Patch([FromODataUri] string key, Delta<Person> person)
{
try
{
Logger.Instance.Info(string.Format("Start HTTP PATCH - People(key, person) is called.\r\nKey is: {0}\r\nPerson is: {1}",key, person));
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var entity = await DemoDataSources.Instance.People.FindAsync(key);
if (entity == null)
{
return NotFound();
}
person.Patch(entity);
try
{
await Task.Run(() =>
{
Person toBeRemovedPerson = DemoDataSources.Instance.People.Where(p => p.ID == key).First();
DemoDataSources.Instance.People.Remove(toBeRemovedPerson);
DemoDataSources.Instance.People.Add(person.GetEntity());
});
}
catch
{
if (null == DemoDataSources.Instance.People.Where(p => p.ID == key).First())
{
return NotFound();
}
else
{
throw;
}
}
Logger.Instance.Info("Done HTTP PATCH - People(key, person)");
return Updated(entity);
}
catch (Exception e)
{
Logger.Instance.Error(string.Format("HTTP PATCH - People({0}, {1})\r\n{2}", key, person, e.ToString()));
return BadRequest(e.Message);
}
finally
{
// nothing else
}
}
public async Task<IHttpActionResult> Patch([FromODataUri] Guid key, Delta<Workout> patch)
{
// TODO Implement concurrency check: http://www.asp.net/mvc/overview/getting-started/getting-started-with-ef-using-mvc/handling-concurrency-with-the-entity-framework-in-an-asp-net-mvc-application
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Workout workout = await db.Workouts.FindAsync(key);
if (workout == null)
{
return NotFound();
}
patch.Patch(workout);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(workout);
}
// PUT: odata/ResidentViewModels(5)
public IHttpActionResult Put([FromODataUri] int key, Delta<Contracts.IResident> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
Contracts.IResident residentViewModel = db.GetAllResidents().Where(r => r.Id == key).FirstOrDefault();
if (residentViewModel == null)
{
return NotFound();
}
patch.Put(residentViewModel);
//try
//{
// db.EditRoom(residentViewModel);
//}
//catch (DbUpdateConcurrencyException)
//{
// if (!ResidentViewModelExists(key))
// {
// return NotFound();
// }
// else
// {
// throw;
// }
//}
return Updated(residentViewModel);
}
public async Task<IHttpActionResult> Patch([FromODataUri] Guid key, Delta<WorkoutSession> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
WorkoutSession workoutSession = await db.WorkoutSessions.FindAsync(key);
if (workoutSession == null)
{
return NotFound();
}
patch.Patch(workoutSession);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutSessionExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(workoutSession);
}
