public IActionResult Patch(string id, [FromBody] UpdateMovieDto model)
{
if (model == null)
{
return(BadRequest("No data"));
}
if (string.IsNullOrEmpty(model.Title))
{
return(BadRequest("No name"));
}
if (string.IsNullOrEmpty(model.Director))
{
return(BadRequest("No director"));
}
if (model.Year == 0)
{
return(BadRequest("No year"));
}
var movie = new Movies
{
Director = model.Director,
Title = model.Title,
Year = model.Year,
};
var entity = _crud.UpdateItem(id, movie);
return(Ok(new { movie = entity }));
}
public async Task UpdateExistingMovie_UpdateWasCalledAndSaved_ReturnsNoContent()
{
//Arrange
int movieId = 1;
_mockMovieRepository.Setup(x => x.GetAsync(It.Is <int>(id => id == movieId))).Returns(Task.FromResult <Movie>(new Movie()
{
Id = movieId
}));
var updateMovieDto = new UpdateMovieDto()
{
Title = "God father 2", Year = 1980, Genre = "Gangster"
};
//Act
IActionResult result = await _controller.UpdateMovie(movieId, updateMovieDto);
//Assert
_mockMovieRepository.Verify(x => x.Update(It.Is <Movie>(m => m.Id == movieId &&
m.Genre == updateMovieDto.Genre &&
m.Title == updateMovieDto.Title &&
m.Year == updateMovieDto.Year)), Times.Once());
_mockMovieRepository.Verify(x => x.SaveAsync(), Times.Once());
Assert.IsType <NoContentResult>(result);
}
public async Task <ActionResult> EditMovie(int id, UpdateMovieDto updateMovie)
{
var movieToUpdate = await context.Movies.Include(ma => ma.MovieActors).SingleOrDefaultAsync(movie => movie.Id == id);
movieToUpdate.MovieName = updateMovie.Name;
movieToUpdate.Year = updateMovie.Year;
movieToUpdate.Genre = updateMovie.Genre;
foreach (var actor in movieToUpdate.MovieActors)
{
if (!updateMovie.ActorIds.Contains(actor.ActorId))
{
context.Remove(actor);
}
}
foreach (var actorId in updateMovie.ActorIds)
{
if (!movieToUpdate.MovieActors.Any(a => a.ActorId == actorId))
{
movieToUpdate.MovieActors.Add(new MovieActor
{
ActorId = actorId,
MovieId = id
});
}
}
await context.SaveChangesAsync();
return(Ok());
}
public static Movie AsMovie(this UpdateMovieDto movie, Guid movieId)
{
return(new Movie
{
Id = movieId,
Title = movie.Title,
ReleaseDate = movie.ReleaseDate
});
}
private static Movie UpdateMovie(UpdateMovieDto dto, Movie movie, IPureMapperUpdateResolver mapper)
{
movie.ReleaseDate = dto.ReleaseDate;
movie.Title = dto.Title;
movie.Plot = dto.Plot;
movie.Duration = dto.Duration;
return(movie);
}
public IActionResult Update(UpdateMovieDto movie)
{
try
{
_service.Update(movie);
}
catch (Exception ex)
{
throw ex;
}
return(Ok());
}
public IActionResult PutMovie([FromRoute] Guid id, [FromBody] UpdateMovieDto movieUpdates)
{
var existingMovie = _movieRepository.GetMovie(id);
if (existingMovie is null)
{
return(NotFound()); // It is common to create a new movie here if it is not found
}
// _movieRepository.AddMovie(movie);
_movieRepository.UpdateMovie(movieUpdates.AsMovie(id));
return(NoContent());
}
public async Task <ActionResult <MovieDto> > UpdateMovie(long id, [FromBody] UpdateMovieDto movieDto)
{
var movie = await Context.Movies.SingleOrDefaultAsync(x => x.Id == id);
if (movie == null)
{
return(NotFound());
}
Mapper.Map(movieDto, movie);
await Context.SaveChangesAsync();
var dto = Mapper.Map <Movie, MovieMinimalDto>(movie);
return(Ok(dto));
}
public async Task <IActionResult> UpdateMovie(int movieId, UpdateMovieDto request)
{
Movie movie = await _movieRepository.GetAsync(movieId);
if (movie == null)
{
return(NotFound());
}
movie.Title = request.Title;
movie.Year = request.Year;
movie.Genre = request.Genre;
_movieRepository.Update(movie);
await _movieRepository.SaveAsync();
return(NoContent());
}
public void Execute(UpdateMovieDto request)
{
_validator.ValidateAndThrow(request);
var movie = _context.Movies.Find(request.Id);
if (movie == null)
{
throw new EntityNotFoundException(request.Id, typeof(Movie));
}
if (request.Price == null)
{
request.Price = movie.Price;
}
if (request.Oscars == null)
{
request.Oscars = movie.Oscars;
}
if (request.Quantity == null)
{
request.Quantity = movie.Quantity;
}
if (request.Year == null)
{
request.Year = movie.Year;
}
if (request.Budget == null)
{
request.Budget = movie.Budget;
}
movie.Year = (int)request.Year;
movie.Quantity = (int)request.Quantity;
movie.Price = (decimal)request.Price;
movie.Oscars = request.Oscars;
movie.Description = request.Description ?? movie.Description;
movie.Title = request.Title ?? movie.Title;
movie.Budget = (decimal)request.Budget;
_context.SaveChanges();
}
public async Task <IActionResult> UpdateMovie([FromBody] UpdateMovieDto model, string id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
var result = await _movieRepository.UpdateMovie(model, id);
return(Ok(new { result }));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(e.Message));
}
}
public async ValueTask <ActionResult> PutMovie(int id, UpdateMovieDto updateMovieDto)
{
if (_fileStorageService.IsBase64(updateMovieDto.Poster))
{
var personPicture = Convert.FromBase64String(updateMovieDto.Poster);
updateMovieDto.Poster = await _fileStorageService.SaveFile(personPicture, "jpg", "people");
}
Movie movie = _repo.GetMovieById(id);
if (movie == null)
{
return(NotFound());
}
_mapper.Map(updateMovieDto, movie);
_repo.UpdateMovie(movie);
_repo.SaveChanges();
return(NoContent());
}
public async ValueTask <ActionResult> PatchMovie(JsonPatchDocument <UpdateMovieDto> jsonDoc, int id)
{
Movie movie = _repo.GetMovieById(id);
if (movie == null)
{
return(NotFound());
}
UpdateMovieDto movieToPatch = _mapper.Map <UpdateMovieDto>(movie);
jsonDoc.ApplyTo(movieToPatch);
if (!TryValidateModel(movieToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(movieToPatch, movie);
_repo.UpdateMovie(movie);
_repo.SaveChanges();
return(NoContent());
}
public async Task <string> UpdateMovie(UpdateMovieDto model, string Id)
{
var movie = await _ctx.Movies.FirstOrDefaultAsync(x => x.MovieId == Id);
if (movie == null)
{
return("failed to update movie");
}
movie.Country = !string.IsNullOrEmpty(model.Country) ? model.Country : movie.Country;
movie.Description = !string.IsNullOrEmpty(model.Description) ? model.Description : movie.Description;
movie.Rating = movie.Rating;
movie.Name = !string.IsNullOrEmpty(model.Name) ? model.Name : movie.Name;
movie.TicketPrice = model.TicketPrice > 0 ? model.TicketPrice : movie.TicketPrice;
movie.PhotoUrl = !string.IsNullOrEmpty(model.PhotoUrl) ? model.PhotoUrl : movie.PhotoUrl;
movie.ReleaseDate = !model.ReleaseDate.Equals(movie.ReleaseDate) ? model.ReleaseDate : movie.ReleaseDate;
_ctx.Movies.Update(movie);
await _ctx.SaveChangesAsync();
return("Update done successfully");
}
public void Execute(UpdateMovieDto request)
{
var movie = context.Movies.Find(request.Id);
if (movie == null)
{
throw new EntityNotFoundException(request.Id, typeof(Movie));
}
if (request.Title != null)
{
movie.Title = request.Title;
}
if (request.Description != null)
{
movie.Description = request.Description;
}
movie.OnStock = request.OnStock;
movie.ReleaseDate = request.ReleaseDate;
movie.RuntimeMinutes = request.RuntimeMinutes;
context.SaveChanges();
}
public void Put(int id, [FromServices] IUpdateMovieCommand command, UpdateMovieDto dto)
{
dto.Id = id;
executor.ExecuteCommand(command, dto);
}
public IActionResult Put(int id, [FromBody] UpdateMovieDto dto, [FromServices] IUpdateMovieCommand command)
{
dto.Id = id;
_executor.ExecuteCommand(command, dto);
return(NoContent());
}
