public async Task <IActionResult> Create(MovieCreateInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var actors = this.Request.Form["actorName"];
var genres = this.Request.Form["genreName"];
var directors = this.Request.Form["directorName"];
var movie = await this.moviesService.CreaterMovieAsync(new CreateMovieServiceInputModel
{
Name = input.Name,
Rating = input.Rating,
IMDBLink = input.IMDBLink,
TrailerLink = input.TrailerLink,
Summary = input.Summary,
Length = input.Length,
Language = input.Language,
ReleaseDate = input.ReleaseDate,
PosterUrl = input.PosterUrl,
Actors = actors,
Genres = genres,
Directors = directors,
});
this.TempData["CreateMovieTemp"] = "You have added a new movie to the database.";
return(this.RedirectToAction(nameof(this.Details), new { id = movie }));
}
public IActionResult Create([FromBody] MovieCreateInputModel inputModel)
{
if (inputModel == null)
{
return(BadRequest());
}
var entity = new Movie
{
Title = inputModel.Title,
ReleaseYear = inputModel.ReleaseYear,
Summary = inputModel.Summary
};
this.context.Movies.Add(entity);
this.context.SaveChanges();
var outputModel = new
{
entity.Id,
entity.Title,
entity.ReleaseYear,
entity.Summary
};
return(CreatedAtRoute("GetMovie", new { id = outputModel.Id }, outputModel));
}
public async Task TestAddingMovieWithMissingDirector()
{
this.SeedDatabase();
var model = new MovieCreateInputModel
{
Name = this.firstMovie.Name,
DateOfRelease = this.firstMovie.DateOfRelease,
Resolution = this.firstMovie.Resolution,
Rating = this.firstMovie.Rating,
Description = this.firstMovie.Description,
Language = this.firstMovie.Language,
CinemaCategory = this.firstMovie.CinemaCategory.ToString(),
TrailerPath = this.firstMovie.TrailerPath,
IMDBLink = this.firstMovie.IMDBLink,
Length = this.firstMovie.Length,
DirectorId = 2,
SelectedGenres = new List <int> {
1
},
SelectedCountries = new List <int> {
1
},
};
var exception = await Assert
.ThrowsAsync <NullReferenceException>(async() => await this.moviesService.CreateAsync(model));
Assert.Equal(string.Format(ExceptionMessages.DirectorNotFound, model.DirectorId), exception.Message);
}
public async Task TestAddingMovieWithInvalidCinemaCategory()
{
this.SeedDatabase();
var model = new MovieCreateInputModel
{
Name = this.firstMovie.Name,
DateOfRelease = this.firstMovie.DateOfRelease,
Resolution = this.firstMovie.Resolution,
Rating = this.firstMovie.Rating,
Description = this.firstMovie.Description,
Language = this.firstMovie.Language,
CinemaCategory = "Invalid category",
TrailerPath = this.firstMovie.TrailerPath,
IMDBLink = this.firstMovie.IMDBLink,
Length = this.firstMovie.Length,
DirectorId = this.firstMovie.DirectorId,
SelectedGenres = new List <int> {
1
},
SelectedCountries = new List <int> {
1
},
};
var exception = await Assert
.ThrowsAsync <ArgumentException>(async() => await this.moviesService.CreateAsync(model));
Assert.Equal(string.Format(ExceptionMessages.InvalidCinemaCategoryType, model.CinemaCategory), exception.Message);
}
public async Task CheckIfAddingMovieReturnsViewModel()
{
this.SeedDatabase();
MovieDetailsViewModel movieDetailsViewModel;
using (var stream = File.OpenRead(TestImagePath))
{
var file = new FormFile(stream, 0, stream.Length, null, Path.GetFileName(stream.Name))
{
Headers = new HeaderDictionary(),
ContentType = TestImageContentType,
};
var model = new MovieCreateInputModel
{
Name = "Titanic",
DateOfRelease = DateTime.UtcNow,
Resolution = "HD",
Rating = 7.80m,
Description = "Test description here",
Language = "English",
CinemaCategory = CinemaCategory.B.ToString(),
TrailerPath = "test trailer path",
CoverImage = file,
Wallpaper = file,
IMDBLink = "test imdb link",
Length = 190,
DirectorId = 1,
SelectedGenres = new List <int> {
1
},
SelectedCountries = new List <int> {
1
},
};
movieDetailsViewModel = await this.moviesService.CreateAsync(model);
}
await this.cloudinaryService.DeleteImage(this.cloudinary, movieDetailsViewModel.Name);
await this.cloudinaryService.DeleteImage(this.cloudinary, movieDetailsViewModel.Name + Suffixes.WallpaperSuffix);
var movie = await this.moviesRepository.All().FirstOrDefaultAsync();
Assert.Equal("Titanic", movie.Name);
Assert.Equal("HD", movie.Resolution);
Assert.Equal(7.80m, movie.Rating);
Assert.Equal("Test description here", movie.Description);
Assert.Equal("English", movie.Language);
Assert.Equal("B", movie.CinemaCategory.ToString());
Assert.Equal("test trailer path", movie.TrailerPath);
Assert.Equal("test imdb link", movie.IMDBLink);
Assert.Equal(190, movie.Length);
Assert.Equal(1, movie.DirectorId);
}
public IActionResult Create([FromBody] MovieCreateInputModel inputModel)
{
if (inputModel == null)
{
return(BadRequest());
}
using (var transaction = this.context.Database.BeginTransaction())
{
try
{
var entity = new Movie
{
Title = inputModel.Title,
ReleaseYear = inputModel.ReleaseYear,
Summary = inputModel.Summary,
DirectorId = inputModel.DirectorId
};
this.context.Movies.Add(entity);
this.context.SaveChanges();
foreach (var actor in inputModel.Actors)
{
this.context.MovieActors.Add(new MovieActor
{
MovieId = entity.Id,
ActorId = actor.ActorId,
Role = actor.Role
});
}
this.context.SaveChanges();
transaction.Commit();
var outputModel = new
{
entity.Id,
entity.Title,
entity.ReleaseYear,
entity.Summary,
entity.DirectorId
};
return(CreatedAtRoute("GetMovie", new { id = outputModel.Id }, outputModel));
}
catch (System.Exception ex)
{
transaction.Rollback();
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
}
public IActionResult Create()
{
var viewModel = new MovieCreateInputModel
{
Actors = this.actorsService.GetAll <MovieActorsCreateViewModel>(),
Genres = this.genresService.GetAll <MovieGenresCreateViewModel>(),
Directors = this.directorsService.GetAll <MovieDirectorsCreateViewModel>(),
};
if (viewModel == null)
{
return(this.NotFound());
}
return(this.View(viewModel));
}
public async Task <IActionResult> Create()
{
var directors = await this.directorsService
.GetAllDirectorsAsync <DirectorDetailsViewModel>();
var genres = await this.genresService
.GetAllGenresAsync <GenreDetailsViewModel>();
var countries = await this.countriesService
.GetAllCountriesAsync <CountryDetailsViewModel>();
var model = new MovieCreateInputModel
{
Directors = directors,
Genres = genres,
Countries = countries,
};
return(this.View(model));
}
public async Task TestAddingAlreadyExistingMovie()
{
this.SeedDatabase();
await this.SeedMovies();
using (var stream = File.OpenRead(TestImagePath))
{
var file = new FormFile(stream, 0, stream.Length, null, Path.GetFileName(stream.Name))
{
Headers = new HeaderDictionary(),
ContentType = TestImageContentType,
};
var model = new MovieCreateInputModel
{
Name = "Titanic",
DateOfRelease = DateTime.UtcNow,
Resolution = "HD",
Rating = 7.80m,
Description = "Test description here",
Language = "English",
CinemaCategory = CinemaCategory.B.ToString(),
TrailerPath = "test trailer path",
CoverImage = file,
Wallpaper = file,
IMDBLink = "test imdb link",
Length = 120,
DirectorId = 1,
};
var exception = await Assert
.ThrowsAsync <ArgumentException>(async() => await this.moviesService.CreateAsync(model));
await this.cloudinaryService.DeleteImage(this.cloudinary, model.Name);
await this.cloudinaryService.DeleteImage(this.cloudinary, model.Name + Suffixes.WallpaperSuffix);
Assert.Equal(string.Format(ExceptionMessages.MovieAlreadyExists, model.Name), exception.Message);
}
}
public async Task <IActionResult> Create(MovieCreateInputModel movieCreateInputModel)
{
if (!this.ModelState.IsValid)
{
var directors = await this.directorsService
.GetAllDirectorsAsync <DirectorDetailsViewModel>();
var genres = await this.genresService
.GetAllGenresAsync <GenreDetailsViewModel>();
var countries = await this.countriesService
.GetAllCountriesAsync <CountryDetailsViewModel>();
movieCreateInputModel.Directors = directors;
movieCreateInputModel.Genres = genres;
movieCreateInputModel.Countries = countries;
return(this.View(movieCreateInputModel));
}
await this.moviesService.CreateAsync(movieCreateInputModel);
return(this.RedirectToAction("GetAll", "Movies", new { area = "Administration" }));
}
public async Task <MovieDetailsViewModel> CreateAsync(MovieCreateInputModel movieCreateInputModel)
{
if (!Enum.TryParse(movieCreateInputModel.CinemaCategory, true, out CinemaCategory cinemaCategory))
{
throw new ArgumentException(
string.Format(ExceptionMessages.InvalidCinemaCategoryType, movieCreateInputModel.CinemaCategory));
}
var director = await this.directorsRepository
.All()
.FirstOrDefaultAsync(d => d.Id == movieCreateInputModel.DirectorId);
if (director == null)
{
throw new NullReferenceException(
string.Format(ExceptionMessages.DirectorNotFound, movieCreateInputModel.DirectorId));
}
var coverUrl = await this.cloudinaryService
.UploadAsync(movieCreateInputModel.CoverImage, movieCreateInputModel.Name);
var wallpaperUrl = await this.cloudinaryService
.UploadAsync(movieCreateInputModel.Wallpaper, movieCreateInputModel.Name + Suffixes.WallpaperSuffix);
var movie = new Movie
{
Name = movieCreateInputModel.Name,
DateOfRelease = movieCreateInputModel.DateOfRelease,
Resolution = movieCreateInputModel.Resolution,
Rating = movieCreateInputModel.Rating,
Description = movieCreateInputModel.Description,
Language = movieCreateInputModel.Language,
CinemaCategory = cinemaCategory,
TrailerPath = movieCreateInputModel.TrailerPath,
CoverPath = coverUrl,
WallpaperPath = wallpaperUrl,
IMDBLink = movieCreateInputModel.IMDBLink,
Length = movieCreateInputModel.Length,
Director = director,
};
bool doesMovieExist = await this.moviesRepository.All().AnyAsync(x => x.Name == movieCreateInputModel.Name);
if (doesMovieExist)
{
throw new ArgumentException(
string.Format(ExceptionMessages.MovieAlreadyExists, movieCreateInputModel.Name));
}
foreach (var genreId in movieCreateInputModel.SelectedGenres)
{
var movieGenre = new MovieGenre
{
MovieId = movie.Id,
GenreId = genreId,
};
await this.movieGenresRepository.AddAsync(movieGenre);
movie.MovieGenres.Add(movieGenre);
}
foreach (var countryId in movieCreateInputModel.SelectedCountries)
{
var movieCountry = new MovieCountry
{
MovieId = movie.Id,
CountryId = countryId,
};
await this.movieCountriesRepository.AddAsync(movieCountry);
movie.MovieCountries.Add(movieCountry);
}
await this.moviesRepository.AddAsync(movie);
await this.moviesRepository.SaveChangesAsync();
await this.movieGenresRepository.SaveChangesAsync();
await this.movieCountriesRepository.SaveChangesAsync();
var viewModel = await this.GetViewModelByIdAsync <MovieDetailsViewModel>(movie.Id);
return(viewModel);
}
