public async Task ShouldReturn_ThreeMoviesExists_ReturnPagedListMovieViewModel()
{
var fixture = new Fixture();
var movies = fixture.Create <List <Movie> >();
var movieParameters = new MovieParameters();
var pagedListMovie = new PagedList <Movie>(movies, movies.Count, 0, 0);
var movieRepository = new Mock <IMovieRepository>();
var getAllMoviesQuery = new GetAllMovieQuery(movieParameters);
var getAllMovieQueryHandler = new GetAllMovieQueryHandler(movieRepository.Object);
movieRepository.Setup(pr => pr.GetAllAsync(movieParameters))
.Returns(pagedListMovie);
var moviesPagedList = await getAllMovieQueryHandler.Handle(getAllMoviesQuery, new System.Threading.CancellationToken());;
Assert.NotNull(moviesPagedList);
Assert.NotEmpty(moviesPagedList);
Assert.Equal(3, moviesPagedList.TotalRecords);
Assert.Equal(1, moviesPagedList.TotalPages);
Assert.Equal(50, moviesPagedList.PageSize);
Assert.IsType <PagedList <MovieViewModel> >(moviesPagedList);
movieRepository.Verify(mr => mr.GetAllAsync(movieParameters), Times.Once);
}
public void ShoulbeReturnAllMoviesWithoutFilter()
{
MovieParameters movieParameters = new MovieParameters();
var movies = movieRepository.GetAllAsync(movieParameters);
var espectedValue = 9;
Assert.NotNull(movies);
Assert.Equal(espectedValue, movies.Count());
}
public async Task <IActionResult> Get(MovieParameters parameters)
{
var getAllMovieQuery = new GetAllMovieQuery(parameters);
var movies = await _mediator.Send(getAllMovieQuery);
var metaData = new { movies.CurrentPage, movies.PageSize, movies.TotalPages, movies.TotalRecords, movies.HasNext, movies.HasPrevious };
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metaData));
return(Ok(new { movies, metaData }));
}
public void ShoulbeReturnListMovieOrderByGenreFilter()
{
MovieParameters movieParameters = new MovieParameters()
{
GenreFilter = "Terror"
};
var movies = movieRepository.GetAllAsync(movieParameters);
var espectedValue = 5;
Assert.NotNull(movies);
Assert.Equal(espectedValue, movies.Count());
}
public void ShoulbeReturnListMovieOrderByProductionCompanyFilter()
{
MovieParameters movieParameters = new MovieParameters()
{
ProductionCompanyFilter = "Netflix"
};
var movies = movieRepository.GetAllAsync(movieParameters);
var espectedValue = 1;
Assert.NotNull(movies);
Assert.Equal(espectedValue, movies.Count());
}
public async Task <MovieResults> GetMoviesAsync(MovieParameters parameters)
{
string url = GetMovieApiUrl(parameters);
var data = await _tmdbClient.GetData <MovieResults>(url);
string placeholderUrl = ImageHelper.GetPlaceholderImageUrl(new ImageSettings(_config[PLACEHOLDER_IMAGE_URL], 500, 750));
foreach (var movie in data.Results)
{
movie.Poster_Path = !string.IsNullOrEmpty(movie.Poster_Path) ? ImageHelper.GetImageUrl(new ImageSettings(_config[IMAGE_URL], PosterSizeType.W500, movie.Poster_Path)) : placeholderUrl;
}
return(data);
}
public async Task <IActionResult> GetAllMovies([FromQuery] MovieParameters movieParameters)
{
var movies = await _movieService.GetAllMovies(movieParameters);
if (!movies.Any())
{
return(NotFound("We did not find any movies"));
}
return(Ok(movies));
// System.Text.Json in .NET Core 3
// previous versions of .Net 1,2 and previous older .NET Framework Newtonsoft, 3rdy party library
// Serialization , convert your C# objects in t JSON objetcs
// De-Serialization, convert json objects to C#
}
public async Task <List <Movie> > FindAllMovies(MovieParameters parameters)
{
return(await _dbContext.Movies
.Include(m => m.Genres.OrderBy(g => g.Genre.Name)).ThenInclude(p => p.Genre)
.Include(m => m.Actors.OrderBy(a => a.People.Name)).ThenInclude(p => p.People)
.Include(m => m.Directors.OrderBy(d => d.People.Name)).ThenInclude(p => p.People)
.Include(m => m.ProductionComapanies.OrderBy(p => p.ProductionCompany.Name)).ThenInclude(p => p.ProductionCompany)
.Where(m => string.IsNullOrWhiteSpace(parameters.GenreFilter) ? true : m.Genres.Any(g => g.Genre.Name.Contains(parameters.GenreFilter)))
.Where(m => string.IsNullOrWhiteSpace(parameters.ActorFilter) ? true : m.Actors.Any(g => g.People.Name.Contains(parameters.ActorFilter)))
.Where(m => string.IsNullOrWhiteSpace(parameters.DirectorFilter) ? true : m.Directors.Any(g => g.People.Name.Contains(parameters.DirectorFilter)))
.Where(m => string.IsNullOrWhiteSpace(parameters.ProductionCompanyFilter) ? true : m.ProductionComapanies.Any(g => g.ProductionCompany.Name.Contains(parameters.ProductionCompanyFilter)))
.OrderBy(m => m.VoteAvarage)
.Skip((parameters.PageNumber - 1) * parameters.PageSize)
.Take(parameters.PageSize)
.ToListAsync());
}
public async Task <List <MovieDetailsResponseModel> > GetAllMovies(MovieParameters movieParameters)
{
var movieDetailsResponse = new List <MovieDetailsResponseModel>();
var movies = await _movieRepository.GetMovies(movieParameters);
foreach (var movie in movies)
{
var movieDetails = new MovieDetailsResponseModel
{
Id = movie.Id,
Title = movie.Title,
Overview = movie.Overview,
Tagline = movie.Tagline,
Budget = movie.Budget,
Revenue = movie.Revenue,
ImdbUrl = movie.ImdbUrl,
TmdbUrl = movie.TmdbUrl,
PosterUrl = movie.PosterUrl,
BackdropUrl = movie.BackdropUrl,
OriginalLanguage = movie.OriginalLanguage,
ReleaseDate = movie.ReleaseDate,
RunTime = movie.RunTime,
Price = movie.Price,
Genres = new List <GenreModel>(),
Casts = new List <CastResponseModel>()
};
foreach (var genre in movie.Genres)
{
movieDetails.Genres.Add(new GenreModel {
Id = genre.Id, Name = genre.Name
});
}
foreach (var cast in movie.MovieCasts)
{
movieDetails.Casts.Add(new CastResponseModel
{
Id = cast.CastId,
Character = cast.Character,
Name = cast.Cast.Name,
ProfilePath = cast.Cast.ProfilePath
});
}
movieDetailsResponse.Add(movieDetails);
}
return(movieDetailsResponse);
}
private async Task <MovieResults> FetchMovieResults()
{
var parameters = new MovieParameters
{
Page = Page,
SortOrder = SortOrder,
ReleaseYear = ReleaseYear,
Rating = Rating,
Runtime = Runtime,
FromReleaseDate = FromReleasedate,
ToReleaseDate = ToReleaseDate
};
if (SelectedGenreIds.Count() is not 0)
{
parameters.GenreIds = SelectedGenreIds;
}
if (SelectedActors.Count() is not 0)
{
foreach (var actor in SelectedActors)
{
parameters.ActorIds.Add(actor.Id);
}
}
if (SelectedDirectors.Count() is not 0)
{
foreach (var director in SelectedDirectors)
{
parameters.DirectorIds.Add(director.Id);
}
}
if (SelectedKeywords.Count() is not 0)
{
foreach (var keyword in SelectedKeywords)
{
parameters.KeywordIds.Add(keyword.Id);
}
}
var results = await DiscoverService.GetMoviesAsync(parameters);
return(results);
}
public GetAllMovieQuery(MovieParameters parameters)
{
movieParameters = parameters;
}
private string GetMovieApiUrl(MovieParameters parameters)
{
var builder = new StringBuilder($"discover/movie?api_key={_config[API_KEY]}&page={parameters.Page}");
if (!string.IsNullOrEmpty(parameters.SortOrder))
{
builder.AppendLine($"&sort_by={parameters.SortOrder}");
}
if (parameters.ReleaseYear is not 0)
{
builder.AppendLine($"&primary_release_year={parameters.ReleaseYear}");
}
if (!string.IsNullOrEmpty(parameters.FromReleaseDate))
{
builder.AppendLine($"&primary_release_date.gte={parameters.FromReleaseDate}");
}
if (!string.IsNullOrEmpty(parameters.ToReleaseDate))
{
builder.AppendLine($"&primary_release_date.lte={parameters.ToReleaseDate}");
}
if (parameters.GenreIds.Count() is not 0)
{
builder.AppendLine("&with_genres=");
foreach (var genreId in parameters.GenreIds)
{
if (genreId == parameters.GenreIds.Last())
{
builder.AppendLine($"{genreId}");
}
else
{
builder.AppendLine($"{genreId},");
}
}
}
if (parameters.ActorIds.Count() is not 0)
{
builder.AppendLine("&with_cast=");
foreach (var actorId in parameters.ActorIds)
{
if (actorId == parameters.ActorIds.Last())
{
builder.AppendLine($"{actorId}");
}
else
{
builder.AppendLine($"{actorId},");
}
}
}
if (parameters.DirectorIds.Count() is not 0)
{
builder.AppendLine("&with_crew=");
foreach (var directorId in parameters.DirectorIds)
{
if (directorId == parameters.DirectorIds.Last())
{
builder.AppendLine($"{directorId}");
}
else
{
builder.AppendLine($"{directorId},");
}
}
}
if (parameters.KeywordIds.Count() is not 0)
{
builder.AppendLine("&with_keywords=");
foreach (var keywordId in parameters.KeywordIds)
{
if (keywordId == parameters.KeywordIds.Last())
{
builder.AppendLine($"{keywordId}");
}
else
{
builder.AppendLine($"{keywordId},");
}
}
}
if (parameters.Rating > 0)
{
builder.AppendLine($"&vote_average.gte={parameters.Rating}");
}
if (parameters.Runtime > 0)
{
builder.AppendLine($"&with_runtime.gte={parameters.Runtime}");
}
builder.AppendLine("&include_adult=false");
return(builder.ToString());
}
public PagedList <Movie> GetAllAsync(MovieParameters parameters)
{
return(PagedList <Movie> .ToPagedList(FindAllMovies(parameters).Result, parameters.PageNumber, parameters.PageSize));
}
public async Task <IEnumerable <Movie> > GetMovies(MovieParameters movieParameters)
{
var movies = await _dbContext.Movies.Include(m => m.MovieCasts).ThenInclude(m => m.Cast).Include(m => m.Genres).OrderBy(on => on.Id).Skip((movieParameters.PageNumber - 1) * movieParameters.PageSize).Take(movieParameters.PageSize).ToListAsync();
return(movies);
}
