public async Task <Result <Exception, Unit> > Handle(MovieUpdateCommand request, CancellationToken cancellationToken) { var findMovieCallback = await _movieRepository.GetById(request.Id); if (findMovieCallback.IsFailure) { return(findMovieCallback.Failure); } var movie = findMovieCallback.Success; _mapper.Map(request, movie); var findGenreCallback = await _genreRepository.GetById(movie.GenreId); if (findGenreCallback.IsFailure) { return(findGenreCallback.Failure); } movie.SetGenre(findGenreCallback.Success); movie.SetLastModification(); var updateGenreCallback = await _movieRepository.UpdateAsync(movie); if (updateGenreCallback.IsFailure) { return(updateGenreCallback.Failure); } return(Unit.Successful); }
public async Task ExecuteAsync(MovieUpdateCommand command) { var item = await MovieRepository.FindAsync(command.Input.Id); if (item == null) { throw new KeyNotFoundException(); } var dto = command.Input; item.Title = dto.Title ?? string.Empty; item.ForeignName = dto.ForeignName ?? string.Empty; item.ReleaseDate = dto.ReleaseDate; item.Minutes = dto.Minutes; item.ReleaseRegion = dto.ReleaseRegion ?? string.Empty; item.SpaceType = dto.SpaceType; item.Actors = dto.Actors; item.CoverUri = dto.CoverUri ?? string.Empty; item.Images = dto.Images; item.Description = dto.Description ?? string.Empty; item.Categorys = dto.Categorys; item.Tags = dto.Tags; item.Ratings = dto.Ratings; item.Language = dto.Language ?? string.Empty; await MovieRepository.UpdateAsync(item); }
public async Task <Response <Exception, Movie> > Handle(MovieUpdateCommand request, CancellationToken cancellationToken) { var movieCallback = await _movieRepository.GetByIdAsync(request.Id); if (movieCallback.HasError) { return(movieCallback.Error); } // Verifica se o genero enviado existe na base var genreCallback = await _genreRepository.GetByIdAsync(request.GenreId); if (genreCallback.HasError) { return(genreCallback.Error); } var movieMap = Mapper.Map(request, movieCallback.Success); var newMovieCallback = await _movieRepository.UpdateAsync(movieMap); if (newMovieCallback.HasError) { return(newMovieCallback.Error); } return(newMovieCallback.Success); }
public IHttpActionResult Update(MovieUpdateCommand movie) { var validator = movie.Validation(); if (!validator.IsValid) { return(HandleValidationFailure(validator.Errors)); } return(HandleCallback(() => MovieAppService.Update(movie))); }
public IHttpActionResult Update(MovieUpdateCommand command) { var validator = command.Validate(_service); if (!validator.IsValid) { return(HandleValidationFailure(validator.Errors)); } return(HandleCallback(_service.Update(command))); }
public bool Update(MovieUpdateCommand movie) { var movieDb = MovieRepository.GetById(movie.Id); if (movieDb == null) { throw new NotFoundException("Registro não encontrado!"); } var movieEdit = Mapper.Map(movie, movieDb); return(MovieRepository.Update(movieEdit)); }
private MovieUpdateCommand MovieUpdateCommandData() { var movieUpdateCommand = new MovieUpdateCommand() { MovieIdentity = Guid.Parse("CAD67740-C13D-4E74-9DF2-9233B4C59390"), Title = "Who am I", ReleaseDate = new System.DateTime(1995, 1, 1), AggregateId = Guid.Parse("94A1AAB9-1FC2-4EFC-9CFC-12AD6BB1480B"), StateId = Guid.NewGuid() }; return(movieUpdateCommand); }
public async Task <bool> UpdateAsync(MovieUpdateCommand command) { var movie = await _repository.SingleOrDefaultAsync(x => x.ID == command.ID, tracking : false); Guard.Against(movie, ErrorType.NotFound); var moviesCountByName = await _repository.CountAsync(x => x.Title.Equals(command.Title) && x.ID != command.ID); Guard.Against(moviesCountByName > 0, ErrorType.Duplicating); movie = _mapper.Map <Movie>(command); _repository.Update(movie); return(await CommitAsync() > 0); }
public async Task <IActionResult> Edit(string id, [Bind("Id,Title,Director,Actors,Image, Year")] MovieViewModel movie, CancellationToken cancellationToken = default) { if (id != movie.Id) { return(NotFound()); } if (ModelState.IsValid) { // TODO handle concurrency errors var request = new MovieUpdateCommand { MovieViewModel = movie, Id = id }; var updateResult = await _mediator.Send(request, cancellationToken); return(RedirectToAction(nameof(Index))); } return(View(movie)); }
public MovieUpdateCommandHandlerTests() { _fixture = new Fixture(); _fixture.Behaviors.Add(new OmitOnRecursionBehavior()); _context = InitializeDatabase(); _testCommand = CreateTestCommand( Guid.NewGuid(), CompletionStatusReference.Completed, false, false, 1, Guid.NewGuid()); var checkout = _fixture .Build <CheckoutRecord>() .With(c => c.ModifiedOn, DateTimeOffset.UtcNow) .Create(); var itemStorage = _fixture .Build <ItemStorageRecord>() .With(a => a.ModifiedOn, DateTimeOffset.UtcNow) .Create(); _testMovie = _fixture .Build <MovieRecord>() .With(a => a.Id, _testCommand.MovieId) .With(a => a.Checkout, checkout) .With(a => a.UpdatedOn, DateTimeOffset.UtcNow) .With(a => a.ItemStorage, itemStorage) .With(a => a.TimesCompleted, 1) .With(a => a.Title, _testCommand.Title) .With(a => a.Type, _testCommand.Type) .With(a => a.User, _testCommand.User) .With(a => a.UserId, _testCommand.User.Id) .Create(); _handler = new MovieUpdateCommandHandler(_context); }
public async Task <IActionResult> UpdateAsync(MovieUpdateCommand command) { return(Ok(await _movieService.UpdateAsync(command))); }
public Task ExecuteAsync(MovieUpdateCommand command) { MovieRepository.Update(command.AggregateRoot); return(Task.FromResult(1)); }
public void Execute(MovieUpdateCommand command) { MovieRepository.Update(command.AggregateRoot); }
public Task <IActionResult> UpdateMovieAsync( [FromBody] MovieUpdateCommand command, [FromServices] IMovieUpdateApiCommandHandler movieUpdateApiCommandHandler ) => movieUpdateApiCommandHandler.HandleAsync(this, command);
public async Task <IActionResult> PutAsync([FromBody] MovieUpdateCommand command) { return(HandleCommand(await _mediator.Send(command))); }
async Task <object> ICommandHandler <MovieUpdateCommand, object> .HandleAsync(MovieUpdateCommand command) { try { // Subscribe Data Event Store. movieUpdateRepository.DataEventStoreHandler += MovieUpdateRepository_DataEventStoreHandler; // Call update Repository var repositoryResponse = await movieUpdateRepository?.UpdateAsync(this.mapper.Map <MovieModel>(command)); if (repositoryResponse == false) { return(await base.MovieExistMessageAsync()); } return(repositoryResponse); } catch { throw; } finally { movieUpdateRepository.DataEventStoreHandler -= MovieUpdateRepository_DataEventStoreHandler; } }
async Task <IActionResult> IApiCommandHandler <MovieUpdateCommand> .HandleAsync(ControllerBase controllerBase, MovieUpdateCommand command) { try { if (command == null) { return(controllerBase?.BadRequest()); } return(controllerBase?.Ok(await movieUpdateCommandHandler?.HandleAsync(command))); } catch { throw; } }