public async Task <IActionResult> CreateMovie([FromBody] Models.MovieForCreation movieForCreation)
{
// model validation
if (movieForCreation == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
// return 422 - Unprocessable Entity when validation fails
return(new UnprocessableEntityObjectResult(ModelState));
}
var movieEntity = _mapper.Map <Movie>(movieForCreation);
_moviesRepository.AddMovie(movieEntity);
// save the changes
await _moviesRepository.SaveChangesAsync();
// Fetch the movie from the data store so the director is included
await _moviesRepository.GetMovieAsync(movieEntity.Id);
return(CreatedAtRoute("GetMovie", new { movieId = movieEntity.Id }, _mapper.Map <Models.Movie>(movieEntity)));
}
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 IActionResult MovieForm(Movie movie)
{
if (ModelState.IsValid)
{
_repository.AddMovie(movie);
return(View("MovieList", _repository.Movies));
}
return(View());
}
public async Task <IActionResult> CreateMovie([FromBody] MovieForCreation movie)
{
var movieEntity = _mapper.Map <Core.Entities.Movie>(movie);
_moviesRepository.AddMovie(movieEntity);
await _moviesRepository.SaveChangesAsync();
await _moviesRepository.GetMovieAsync(movieEntity.Id);
return(CreatedAtRoute("GetMovie", new { movieId = movieEntity.Id }, movieEntity));
}
public IActionResult RecommendMovie([FromBody] Movie movie)
{
try
{
repository.AddMovie(movie);
return(Ok());
}
catch (Exception ex)
{
return(Ok(Util.SendErrorResponse("Unable to update movie recommendation", ex)));
}
}
protected async Task UpdateMoviesByImdbId(MovieTmdb movieTmdb)
{
var movieOmdb = await _omdbClient.GetMovieByImdbId(movieTmdb.ImdbId);
if (movieOmdb != null)
{
var movie = _moviesMapper.Map(movieTmdb, movieOmdb);
RemoveUnkownGenres(movie);
await _moviesRepository.AddMovie(movie);
}
}
public Movie AddMovie(Movie movie)
{
string connectionString = Utility.Util.GetConnectionString(MoviesStore.Service.Common.Util.MasterDataManager.ConfigData["MoviesStoreDb"]);
string providerName = Utility.Util.GetProviderName(MoviesStore.Service.Common.Util.MasterDataManager.ConfigData["MoviesStoreDb"]);
string spName = MoviesStore.Service.Common.Util.MasterDataManager.ConfigData["AddMovie"];
try
{
return(_movieRepository.AddMovie(movie, spName, providerName, connectionString));
}
catch (Exception e)
{
throw e.InnerException;
}
}
public async Task <IActionResult> AddMovie(MovieForAddDto movieForAdd)
{
if (!_authorizer.IsAdminOrEmployee(User))
{
return(Unauthorized());
}
foreach (var entry in movieForAdd.Photos)
{
entry.MovieTitle = movieForAdd.Title;
}
var movieForAddModel = _mapper.Map <Movie>(movieForAdd);
_repo.AddMovie(movieForAddModel);
await _repo.SaveAll();
return(StatusCode(201));
}
public async Task <IActionResult> CreateMovieCollection([FromBody] IEnumerable <MovieForCreation> movieCollection)
{
var movieEntities = _mapper.Map <IEnumerable <Core.Entities.Movie> >(movieCollection);
foreach (var movieEntity in movieEntities)
{
_moviesRepository.AddMovie(movieEntity);
}
await _moviesRepository.SaveChangesAsync();
var moviesToReturn = await _moviesRepository.GetMoviesAsync(
movieEntities.Select(m => m.Id).ToList());
var movieIds = string.Join(",", moviesToReturn.Select(a => a.Id));
return(CreatedAtRoute("GetMovieCollection",
new { movieIds },
moviesToReturn));
}
public IActionResult CreateMovie([FromBody] MovieDTO movieDTOToCreate)
{
if (movieDTOToCreate == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var movieEntity = mapper.Map <Entities.Movie>(movieDTOToCreate);
moviesRepository.AddMovie(movieEntity);
moviesRepository.Save();
//to get director
moviesRepository.Get(movieEntity.ID);
return(CreatedAtRoute("GetMovie", new { movieId = movieEntity.ID }, mapper.Map <Models.Movie>(movieEntity)));
}
public async Task <MovieDto> AddMovie(CUMovieDto newMovie)
{
if (newMovie == null)
{
throw new ArgumentNullException(nameof(newMovie));
}
if (newMovie.Name.Length > 35)
{
throw new ArgumentOutOfRangeException(nameof(newMovie.Name), newMovie.Name, "Name length cannot be bigger than 35.");
}
if (newMovie.Year.ToString().Length != 4)
{
throw new ArgumentOutOfRangeException(nameof(newMovie.Year), newMovie.Year, "Year length must be 4.");
}
if (newMovie.Rating < 1 && newMovie.Rating > 5)
{
throw new ArgumentOutOfRangeException(nameof(newMovie.Rating), newMovie.Rating, "Rating must be between 1 and 5");
}
var modelDb = await _moviesRepository.AddMovie(newMovie);
return(modelDb);
}
public IActionResult AddMovie(AddMovieRequest data)
{
return(Ok(repository.AddMovie(data)));
}
public void Post([FromBody] Movie movie)
{
_repo.AddMovie(movie);
}
/// <summary>
/// Add movie to database
/// </summary>
/// <param name="movie">Movie to save to database</param>
public void AddMovie(Movie movie)
{
_moviesRepository.AddMovie(movie);
}
public void AddMovie(string Title, DateTime ReleaseDate)
{
Movie movie = new Movie(Title, ReleaseDate);
Repository.AddMovie(movie);
}
public void AddMovie([FromBody] Movie movie)
{
_moviesRepository.AddMovie(movie);
}
