public async Task <Response <Exception, Movie> > Handle(MovieCreateCommand request, CancellationToken cancellationToken)
{
// Verifica se o genero enviado existe na base
var genreCallback = await _genreRepository.GetByIdAsync(request.GenreId);
if (genreCallback.HasError)
{
return(genreCallback.Error);
}
// Checa se o gênero escolhido está inativo
if (!genreCallback.Success.Active)
{
return(new InactiveEntityException("Gênero"));
}
// Faz o mapeamento do command para a entidade
var movieMap = Mapper.Map <MovieCreateCommand, Movie>(request);
// Cria o filme
var newMovieCallback = await _movieRepository.CreateAsync(movieMap);
// Verifica algum erro
if (newMovieCallback.HasError)
{
return(newMovieCallback.Error);
}
// Retorna o filme criado
return(newMovieCallback.Success);
}
private MovieCreateCommand MovieCreateCommandData()
{
var movieCreateCommand = new MovieCreateCommand()
{
Title = "X-Men",
ReleaseDate = new DateTime(2020, 10, 1)
};
return(movieCreateCommand);
}
// Generate Json for Testing Api on Postman
public MovieCreateCommand MovieCreateCommandData()
{
var movieCreateCommand = new MovieCreateCommand()
{
Title = "Hacker",
ReleaseDate = new System.DateTime(1995, 1, 1),
AggregateId = Guid.NewGuid(),
StateId = Guid.NewGuid()
};
return(movieCreateCommand);
}
public async Task <int> CreateAsync(MovieCreateCommand command)
{
var moviesCountByName = await _repository.CountAsync(x => x.Title.Equals(command.Title));
Guard.Against(moviesCountByName > 0, ErrorType.Duplicating);
var movie = _mapper.Map <Movie>(command);
movie.ImagePath = $"{Environment.CurrentDirectory}\\wwwroot\\movies-imgs\\default.png";
var createdMovie = await _repository.CreateAsync(movie);
return(await CommitAsync() > 0 ? createdMovie.ID : 0);
}
public async Task <IActionResult> Create([Bind("Id,Title,Director,Actors,Image, Year")] MovieViewModel movie, CancellationToken cancellationToken = default)
{
if (ModelState.IsValid)
{
var request = new MovieCreateCommand {
MovieViewModel = movie
};
var createdMovie = await _mediator.Send(request, cancellationToken);
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
async Task <IActionResult> IApiCommandHandler <MovieCreateCommand> .HandleAsync(ControllerBase controllerBase, MovieCreateCommand command)
{
try
{
if (command == null)
{
return(controllerBase.BadRequest());
}
return(controllerBase.Ok(await movieCreateCommandHandler?.HandleAsync(command)));
}
catch
{
throw;
}
}
public async Task <IActionResult> CreateAsync(MovieCreateCommand command)
{
return(Ok(await _movieService.CreateAsync(command)));
}
public async Task <Object> OnMovieCreateAsync([FromBody] MovieCreateCommand movieCreateCommand) => await mediator.Send <Object>(movieCreateCommand);
public Task <IActionResult> CreateMovieAsync(
[FromBody] MovieCreateCommand command,
[FromServices] IMovieCreateApiCommandHandler movieCreateApiCommandHandler
) => movieCreateApiCommandHandler.HandleAsync(this, command);
public async Task <IActionResult> Create([FromBody] MovieCreateCommand movieCreateCommand)
{
return(HandleCommand(await _mediator.Send(movieCreateCommand)));
}
async Task <object> ICommandHandler <MovieCreateCommand, object> .HandleAsync(MovieCreateCommand command)
{
try
{
movieCreateRepository.DataEventStoreHandler += MovieCreateRepository_DataEventStoreHandler;
var repositoryResponse = await movieCreateRepository?.CreateAsync(mapper.Map <MovieModel>(command));
if (repositoryResponse == false)
{
return(await base.MovieExistMessageAsync());
}
return(repositoryResponse);
}
catch
{
throw;
}
finally
{
movieCreateRepository.DataEventStoreHandler -= MovieCreateRepository_DataEventStoreHandler;
}
}
