public async Task FiltrarPorCampoIncorrectoDevuelvePeliculas()
{
var nameDb = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDb);
//var mock = new Mock<ILogger<PeliculasController>>();
var controller = new MoviesController(context, mapper, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new MovieFilterDTO()
{
FieldToSort = "abc",
AscendingOrder = false
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
var contexto2 = BuildContext(nameDb);
var moviesDb = contexto2.Movies.ToList();
Assert.AreEqual(moviesDb.Count, movies.Count);
// Assert.AreEqual(1, Mock.Invocations.Count);
}
public async Task FiltrarPorTitulo()
{
var nameDb = CreateDataTest();
var context = BuildContext(nameDb);
var mapper = ConfigurationAutoMapper();
var controller = new MoviesController(context, mapper, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var titleMovie = "Movie 1";
var filterDTO = new MovieFilterDTO()
{
Title = titleMovie,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual(titleMovie, movies[0].Title);
}
public async Task FiltrarTituloDescendente()
{
var nameDb = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDb);
var controller = new MoviesController(context, mapper, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new MovieFilterDTO()
{
FieldToSort = "title",
AscendingOrder = true
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
var contexto2 = BuildContext(nameDb);
var moviesDb = contexto2.Movies.OrderByDescending(x => x.Title).ToList();
Assert.AreEqual(moviesDb.Count, movies.Count);
for (int i = 0; i < moviesDb.Count; i++)
{
var movieOfController = movies[i];
var movieDb = moviesDb[i];
Assert.AreEqual(movieDb.Id, movieOfController.Id);
}
}
public async Task <SearchContainer <SearchMovie> > SearchMovie(MovieFilterDTO movieFilter)
{
if (!string.IsNullOrEmpty(movieFilter.Name))
{
return(await SearchByMovieName(movieFilter));
}
return(await SearchMovieByPersonAndReleasedDate(movieFilter));
}
public IHttpActionResult GetMovies(MovieFilterDTO param)
{
if (param == null || param.IsEmpty())
{
return(BadRequest()); // 400
}
var movies = this._movieService.GetMovies(param);
if (movies == null || movies.Count < 1)
{
return(NotFound()); // 404
}
return(Ok(movies));
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] MovieFilterDTO movieFilterDto)
{
try
{
var moviesDbQueryable = this.context.Movies.AsQueryable();
if (movieFilterDto == null)
{
return(BadRequest());
}
if (!string.IsNullOrWhiteSpace(movieFilterDto.Title))
{
movieFilterDto.Title = movieFilterDto.Title.ToUpper();
moviesDbQueryable = moviesDbQueryable.Where(x => x.Title.ToUpper().Contains(movieFilterDto.Title));
}
if (movieFilterDto.InTheaters)
{
moviesDbQueryable = moviesDbQueryable.Where(x => x.InTheaters);
}
if (movieFilterDto.NextReleases)
{
var today = DateTime.Today;
moviesDbQueryable = moviesDbQueryable.Where(x => x.PremiereDate > today);
}
if (movieFilterDto.GenderId != 0)
{
moviesDbQueryable = moviesDbQueryable.Where(x => x.MoviesGenders.Select(y => y.GenderId).Contains(movieFilterDto.GenderId));
}
if (!string.IsNullOrWhiteSpace(movieFilterDto.FieldToSort))
{
var order = movieFilterDto.AscendingOrder ? "ascending" : "descending";
moviesDbQueryable = moviesDbQueryable.OrderBy($"{movieFilterDto.FieldToSort} {order}");
}
await HttpContext.InsertParametersPagination(moviesDbQueryable, movieFilterDto.RecordsPerPage);
var movies = await moviesDbQueryable.Paginate(movieFilterDto.Pagination).ToListAsync();
return(this.mapper.Map <List <MovieDTO> >(movies));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
/// <summary>
/// Get list of movies based on the param
/// </summary>
/// <param name="param">Filters</param>
/// <returns>List of MovieDTO</returns>
public List <MovieDTO> GetMovies(MovieFilterDTO param)
{
IEnumerable <MovieDTO> filterdMovies = this.Movies;
if (!string.IsNullOrEmpty(param.Title))
{
filterdMovies = filterdMovies.Where(x => x.Title == param.Title);
}
if (!string.IsNullOrEmpty(param.Genres))
{
filterdMovies = filterdMovies.Where(x => x.Genres == param.Genres);
}
if (param.YearOfRelease != null)
{
filterdMovies = filterdMovies.Where(x => x.YearOfRelease == param.YearOfRelease);
}
return(filterdMovies.OrderByDescending(x => x.YearOfRelease).ToList());
}
public async Task FilterInCinemas()
{
var nameDb = CreateDataTest();
var context = BuildContext(nameDb);
var mapper = ConfigurationAutoMapper();
var controller = new MoviesController(context, mapper, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new MovieFilterDTO()
{
InTheaters = true
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Movie in theaters", movies[0].Title);
}
public async Task FilterByGender()
{
var nameDb = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDb);
var controller = new MoviesController(context, mapper, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var genderId = context.Genders.Select(x => x.Id).First();
var filterDTO = new MovieFilterDTO()
{
GenderId = genderId
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Movie with Gender", movies[0].Title);
}
private async Task <SearchContainer <SearchMovie> > SearchMovieByPersonAndReleasedDate(MovieFilterDTO movieFilter)
{
var discoverQuery = _client.DiscoverMoviesAsync();
if (!string.IsNullOrEmpty(movieFilter.Persons))
{
var personIds = movieFilter.Persons.Split(',')
.Select(int.Parse)
.ToList();
discoverQuery.IncludeWithAllOfPeople(personIds);
}
if (movieFilter.ReleaseDateAfter != null)
{
discoverQuery.WherePrimaryReleaseDateIsAfter(movieFilter.ReleaseDateAfter.Value);
}
if (movieFilter.ReleaseDateBefore != null)
{
discoverQuery.WherePrimaryReleaseDateIsBefore(movieFilter.ReleaseDateBefore.Value);
}
var result = await discoverQuery.Query(movieFilter.NumberPage.Value);
return(result);
}
private async Task <SearchContainer <SearchMovie> > SearchByMovieName(MovieFilterDTO movieFilter)
{
return(await _client.SearchMovieAsync(movieFilter.Name));
}
public async Task <ActionResult <SearchContainer <SearchMovie> > > SearchMovie([FromBody] MovieFilterDTO filter)
{
return(Ok(await _movieRepository.SearchMovie(filter)));
}
