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