public async Task <IActionResult> CreateMovie([FromBody] MovieCreateDto movieCreateDto)
{
if (movieCreateDto == null)
{
return(BadRequest());
}
var movieExist = await _movieService.MovieExistById(movieCreateDto.ImdbId);
if (movieExist)
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var movie = _mapper.Map <MovieCreateDto, Movie>(movieCreateDto);
var success = await _movieService.AddMovie(movie);
if (!success)
{
// Throw code 500 instead of 4xx when saving changes failed because it is a server side issue
throw new Exception($"Failed to save the user to the database with the id {movie.Id}");
}
var movieToReturn = _mapper.Map <Movie, MovieGetDto>(movie);
var routeValue = new { id = movie.Id };
return(CreatedAtRoute(GetMovieByIdRoute, routeValue, movieToReturn));
}
public IHttpActionResult Post([FromBody] MovieCreateDto movie)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Movie newMovie = new Movie
{
DirectorID = movie.DirectorID,
Title = movie.Title,
GenreID = movie.GenreID,
Description = movie.Description,
ReleaseDate = movie.ReleaseDate
};
movieService.Add(newMovie);
movieService.Save();
var dtoMovie = new MovieDto(newMovie);
return(Ok(dtoMovie));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult AddMovie([FromBody] MovieCreateDto movie)
{
if (movie == null)
{
return(BadRequest());
}
if (string.Equals(movie.Title, movie.Description))
{
ModelState.AddModelError("Description", "Description and title cannot be the same.");
}
if (_moviesRepository.MovieExists(movie.Title))
{
ModelState.AddModelError("Title", "Movie by that title already exists.");
}
if (!ModelState.IsValid)
{
return(BadRequest(movie));
}
var newMovie = Mapper.Map <Movie>(movie);
_moviesRepository.AddMovie(newMovie);
if (!_moviesRepository.Save())
{
return(StatusCode(500, "Issue adding movie to collection. Please try again."));
}
var movieToReturn = Mapper.Map <MovieDto>(newMovie);
return(CreatedAtRoute("GetMovie", new { id = movieToReturn.Id }, movieToReturn));
}
public async Task <ActionResult <MovieReadDto> > Create(MovieCreateDto movieCreateDto)
{
var movie = _mapper.Map <Movie>(movieCreateDto);
await _dbContext.CreateAsync(_collectionName, movie);
var movieReadDto = _mapper.Map <MovieReadDto>(movie);
return(CreatedAtRoute(nameof(GetMovieById), new { id = movie.Id.ToString() }, movieReadDto));
}
public async Task <IActionResult> CreateMovie(MovieCreateDto movieCreateDto)
{
var movie = _mapper.Map <Movie>(movieCreateDto);
_movieRepository.CreateMovie(movie);
await _movieRepository.SaveChangesAsync();
await _movieRepository.GetMovieAsyncr(movie.Id);
return(CreatedAtRoute("GetMovie", new { id = movie.Id }, movie));
}
public async Task <ActionResult> Edit(int id, MovieCreateDto value)
{
if (!TryValidateModel(value))
{
return(View(value));
}
await CommandBus.SendAsync(new MovieUpdateCommand()
{
AggregateRoot = value.Convert()
});
return(RedirectToAction("Index"));
}
public IHttpActionResult Create(MovieCreateDto movie)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var mov = _mapper.Map <MovieCreateDto, Movie>(movie);
mov.AddedDate = DateTime.Now;
_context.Movies.Add(mov);
_context.SaveChanges();
return(Created(Request.RequestUri + "/" + mov.Id, _mapper.Map <MovieDto>(mov)));
}
public IHttpActionResult Update(int id, MovieCreateDto movie)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var mov = _context.Movies.FirstOrDefault(x => x.Id == id);
if (mov == null)
{
return(NotFound());
}
_mapper.Map(movie, mov);
_context.SaveChanges();
return(Ok(_mapper.Map <Movie, MovieDto>(mov)));
}
public Movie Create(MovieCreateDto dto)
{
string imageName = fileService.Save(dto.Upload);
var entity = new Movie
{
Title = dto.Title,
Content = dto.Content,
Tags = dto.Tags != null?string.Join(',', dto.Tags) : null,
Img = imageName,
CategoryId = dto.CategoryId,
Length = dto.Length,
CreatedAt = System.DateTime.Now,
Released = dateTimeUtils.Parse(dto.Released)
};
return(repository.Add(entity));
}
public ActionResult <MovieReadDto> CreateMovie(MovieCreateDto movieCreateDto)
{
if (movieCreateDto.GenreId <= 0)
{
return(BadRequest(new { Message = "GenreId was not supplied in request body" }));
}
var movieModel = this.mapper.Map <Movie>(movieCreateDto);
var createdMovieModel = this.movieRepo.Create(movieModel);
if (movieModel == null)
{
return(StatusCode(500));
}
else
{
var movieReadDto = this.mapper.Map <MovieReadDto>(createdMovieModel);
return(CreatedAtRoute(nameof(GetMovieById), new { id = movieReadDto.Id }, movieReadDto));
}
}
public void Execute(MovieCreateDto request)
{
_validator.ValidateAndThrow(request);
var movie = _mapper.Map <Movie>(request);
foreach (var md in request.Directors)
{
movie.MovieDirectors.Add(new MovieDirector
{
Movie = movie,
DirectorID = md
});
}
_context.Movies.Add(movie);
_context.SaveChanges();
}
public IActionResult CreateMovie([FromForm] MovieCreateDto movieCreateDto)
{
if (movieCreateDto == null)
{
return(BadRequest(ModelState));
}
if (_movieRepo.MovieExists(movieCreateDto.Name))
{
ModelState.AddModelError("", "La pelicula ya existe.");
return(StatusCode(404, ModelState));
}
// Subida de archivos
var file = movieCreateDto.Image;
var mainRoute = _hostEnvironment.WebRootPath;
var files = HttpContext.Request.Form.Files;
if (file.Length > 0) // existe la imagen?
{
// Nueva imagen
var photoName = Guid.NewGuid().ToString();
var folder = Path.Combine(mainRoute, @"photos");
var extension = Path.GetExtension(files[0].FileName);
using (var fileStream = new FileStream(Path.Combine(folder, photoName + extension), FileMode.Create))
{
files[0].CopyTo(fileStream);
}
movieCreateDto.ImageRout = @"\photos\" + photoName + extension;
}
var movie = _mapper.Map <Movie>(movieCreateDto);
if (!_movieRepo.CreateMovie(movie))
{
ModelState.AddModelError("", $"Algo salió mal gurdando la pelicula {movie.Name}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetMovie", new { id = movie.Id }, movie));
}
public virtual Task <MovieDto> CreateAsync(MovieCreateDto input)
{
return(_movieAppService.CreateAsync(input));
}
public IActionResult Post([FromBody] MovieCreateDto dto, [FromServices] ICreateMovieCommand command)
{
_executor.ExecuteCommand(command, dto);
return(Ok("uneot"));
}
