public async Task UpdateAsync(AlbumForUpdatingDto dto) { var albumEntity = await context.Albums .FirstOrDefaultAsync(a => a.Id == dto.Id); mapper.Map(dto, albumEntity); }
public ActionResult PartiallyUpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] JsonPatchDocument<AlbumForUpdatingDto> patchDocument) { if (!_bandAlbumRepository.BandExists(bandId)) { return NotFound(); } Album albumEntity = _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumEntity == null) { return NotFound(); } AlbumForUpdatingDto albumToPatch = _mapper.Map<AlbumForUpdatingDto>(albumEntity); patchDocument.ApplyTo(albumToPatch, ModelState); if (!TryValidateModel(albumToPatch)) return ValidationProblem(ModelState); _mapper.Map(albumToPatch, albumEntity); _bandAlbumRepository.UpdateAlbum(albumEntity); _bandAlbumRepository.Save(); return NoContent(); }
public ActionResult UpdateAlbumForBand(Guid bandID, Guid albumID, [FromBody] AlbumForUpdatingDto album) { if (!_bandAlbumRepository.BandExists(bandID)) { return(NotFound()); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandID, albumID); if (albumFromRepo is null) { var albumToAdd = _mapper.Map <Entities.Album>(album); _bandAlbumRepository.AddAlbum(bandID, albumToAdd); _bandAlbumRepository.Save(); var returnAlbum = _mapper.Map <AlbumDto>(albumToAdd); return(CreatedAtRoute("GetAlbumsForBand", new { bandID = bandID, albumID = returnAlbum.ID }, returnAlbum)); } _mapper.Map(album, albumFromRepo); _bandAlbumRepository.UpdateAlbum(albumFromRepo); _bandAlbumRepository.Save(); return(NoContent()); }
public ActionResult UpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] AlbumForUpdatingDto album) { if (!_bandAlbumRepository.BandExists(bandId)) { return(NotFound()); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { var albumToAdd = _mapper.Map <Entities.Album>(album); albumToAdd.Id = albumId; _bandAlbumRepository.AddAlbum(bandId, albumToAdd); _bandAlbumRepository.Save(); var albumToReturn = _mapper.Map <AlbumsDto>(albumToAdd); return(CreatedAtRoute("GetAlbumForBand", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn)); } _mapper.Map(album, albumFromRepo); _bandAlbumRepository.UpdateAlbum(albumFromRepo); _bandAlbumRepository.Save(); return(NoContent()); }
public ActionResult UpdateAlbum(Guid albumId, Guid bandId, AlbumForUpdatingDto albumToUpdateDto) { if (!_bandAlbumRepository.BandExists(bandId)) { return(StatusCode(StatusCodes.Status404NotFound, new { error = "band doesn't exist" })); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { var albumToCreate = _mapper.Map <Album>(albumToUpdateDto); albumToCreate.Id = albumId; _bandAlbumRepository.AddAlbum(bandId, albumToCreate); _bandAlbumRepository.Save(); var albumToReturn = _mapper.Map <AlbumDto>(albumToCreate); return(CreatedAtRoute("GetAlbumForBand", new { albumId, bandId }, albumToReturn)); } _mapper.Map(albumToUpdateDto, albumFromRepo); _bandAlbumRepository.Save(); return(StatusCode(StatusCodes.Status204NoContent)); }
public async Task <IActionResult> UpdateeSong( int id, [FromBody] AlbumForUpdatingDto dto) { if (!ModelState.IsValid) { return(BadRequest()); } try { var album = await unitOfWork.Albums.GetAsync(id); if (album == null) { return(NotFound()); } if (album.Id != id) { return(BadRequest()); } var isAuthorized = await authorizationService .AuthorizeAsync(User, album.OwenerId, AutherazationOperations.OwenResourse); if (!isAuthorized.Succeeded) { return(Unauthorized()); } await unitOfWork.Albums.UpdateAsync(dto); await unitOfWork.SaveAsync(); album = await unitOfWork.Albums.GetAsync(id); return(Ok(album)); } catch (Exception ex) { logger.LogError(ex, "An error occurred while updating album.", dto); return(StatusCode(500)); } }
public ActionResult UpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] AlbumForUpdatingDto album) { if (!_bandAlbumRepository.BandExists(bandId)) { return(NotFound()); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { return(NotFound()); } _mapper.Map(album, albumFromRepo); _bandAlbumRepository.UpdateAlbum(albumFromRepo); _bandAlbumRepository.Save(); return(NoContent()); }
public ActionResult PartiallyUpdateAlbumForBand(Guid bandID, Guid albumID, [FromBody] JsonPatchDocument <AlbumForUpdatingDto> patchDocument) { if (!_bandAlbumRepository.BandExists(bandID)) { return(NotFound()); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandID, albumID); if (albumFromRepo is null) { var albumDto = new AlbumForUpdatingDto(); patchDocument.ApplyTo(albumDto); var albumToAdd = _mapper.Map <Entities.Album>(albumDto); albumToAdd.ID = albumID; _bandAlbumRepository.AddAlbum(bandID, albumToAdd); _bandAlbumRepository.Save(); var returnAlbum = _mapper.Map <AlbumDto>(albumToAdd); return(CreatedAtRoute("GetAlbumsForBand", new { bandID = bandID, albumID = returnAlbum.ID }, returnAlbum)); } var albumToPatch = _mapper.Map <AlbumForUpdatingDto>(albumFromRepo); patchDocument.ApplyTo(albumToPatch, ModelState); if (!TryValidateModel(albumToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(albumToPatch, albumFromRepo); _bandAlbumRepository.UpdateAlbum(albumFromRepo); _bandAlbumRepository.Save(); return(NoContent()); }
public ActionResult UpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] AlbumForUpdatingDto album) { if (!_bandAlbumRepository.BandExists(bandId)) { return(NotFound()); } var albumFromRepo = _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { return(NotFound()); } //pass the album values to albumFromRepo this is the object in the DBcontext //albumFromRepo is updated and its in a modified state inside of the Dbcontext _mapper.Map(album, albumFromRepo); //the context is updated here, leave off type annotation on Map because put should update all of the properties //_bandAlbumRepository.UpdateAlbum(albumFromRepo); //not implemented in repository _bandAlbumRepository.Save(); return(NoContent()); }
public async Task Update_Album_Should_Persiste() { using (var factory = new MusicStoreContextFactory()) { var albumId = 0; using (var context = factory.CreateMusicStoreContext()) { var album = new AlbumEntity { Name = "Name", Description = "Description" }; context.Albums.Add(album); context.SaveChanges(); albumId = album.Id; } using (var context = factory.CreateMusicStoreContext()) { var albumForUpdateDto = new AlbumForUpdatingDto { Id = albumId, Name = "Updated", Description = "Updated" }; var unitOfWork = new UnitOfWork(context, _mapper); await unitOfWork.Albums.UpdateAsync(albumForUpdateDto); await unitOfWork.SaveAsync(); } using (var context = factory.CreateMusicStoreContext()) { var album = context.Albums.First(); Assert.Equal("Updated", album.Name); Assert.Equal("Updated", album.Description); } } }
public ActionResult PartiallyUpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] JsonPatchDocument <AlbumForUpdatingDto> patchDocument) { if (!_repository.BandExists(bandId)) { return(NotFound()); } var albumFromRepo = _repository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { var albumDto = new AlbumForUpdatingDto(); patchDocument.ApplyTo(albumDto); var albumToAdd = _mapper.Map <Album>(albumDto); albumToAdd.Id = albumId; _repository.AddAlbum(bandId, albumToAdd); _repository.Save(); var albumToReturn = _mapper.Map <AlbumDto>(albumToAdd); return(CreatedAtRoute("GetAlbum", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn)); } var albumToPatch = _mapper.Map <AlbumForUpdatingDto>(albumFromRepo); patchDocument.ApplyTo(albumToPatch); if (!TryValidateModel(albumToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(albumToPatch, albumFromRepo); _repository.UpdateAlbum(albumFromRepo); _repository.Save(); return(NoContent()); }
public async Task <ActionResult <AlbumDto> > UpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] AlbumForUpdatingDto album) { if (!await _bandAlbumRepository.BandExists(bandId)) { return(NotFound()); } //if (!await _bandAlbumRepository.AlbumExists(albumId)) // return NotFound(); var albumFromRepo = await _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { var albumToAdd = _mapper.Map <Album>(album); albumToAdd.Id = albumId; _bandAlbumRepository.AddAlbum(bandId, albumToAdd); await _bandAlbumRepository.Save(); var upsertingAlbumToReturn = _mapper.Map <AlbumDto>(albumToAdd); return(CreatedAtRoute( "GetAlbumForBand", new { bandId = bandId, albumId = upsertingAlbumToReturn.Id }, upsertingAlbumToReturn )); } //var albumEntity = _mapper.Map<Album>(album); _mapper.Map(album, albumFromRepo); // replace the albumFromRepo by album _bandAlbumRepository.UpdateAlbum(albumFromRepo); await _bandAlbumRepository.Save(); var albumToReturn = _mapper.Map <AlbumDto>(albumFromRepo); return(CreatedAtRoute( "GetAlbumForBand", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn )); }
public async Task <ActionResult> PartiallyUpdateAlbumForBand(Guid bandId, Guid albumId, [FromBody] JsonPatchDocument <AlbumForUpdatingDto> patchDocument) { if (!await _bandAlbumRepository.BandExists(bandId)) { return(NotFound()); } var albumFromRepo = await _bandAlbumRepository.GetAlbum(bandId, albumId); if (albumFromRepo == null) { var albumDto = new AlbumForUpdatingDto(); patchDocument.ApplyTo(albumDto, ModelState); // Aplly to Dto so we can use the restriction set in Dto var albumToAdd = _mapper.Map <Album>(albumDto); albumToAdd.Id = albumId; _bandAlbumRepository.AddAlbum(bandId, albumToAdd); await _bandAlbumRepository.Save(); var upsertingAlbumToReturn = _mapper.Map <AlbumDto>(albumToAdd); return(CreatedAtRoute( "GetAlbumForBand", new { bandId = bandId, albumId = upsertingAlbumToReturn.Id }, upsertingAlbumToReturn )); } /* * The Strategy doesn't override the current from repo directly. * 1. Get the CurrentData * 2. Transform CurrentData to Dto * 3. Overriding the Dto (Since the Dto has updating restriction) * 4. Using the Dto to override the CurrentData in the DB * 5. Save the Changes */ var albumToPatch = _mapper.Map <AlbumForUpdatingDto>(albumFromRepo); // Firstly, transform the one in DB to the Dto patchDocument.ApplyTo(albumToPatch, ModelState); // Then we can apply Changes to current Dto if (!TryValidateModel(albumToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(albumToPatch, albumFromRepo); // Using the updatedDto to override the current from repo _bandAlbumRepository.UpdateAlbum(albumFromRepo); await _bandAlbumRepository.Save(); //return NoContent(); var albumToReturn = _mapper.Map <AlbumDto>(albumFromRepo); return(CreatedAtRoute( "GetAlbumForBand", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn )); }