public async Task <ActionResult <List <Movie> > > Filter(FilterMoviesDTO filterMoviesDTO)
{
var paginatedResponse = await moviesRepository.GetMoviesFiltered(filterMoviesDTO);
HttpContext.InsertPaginationParametersInResponse(paginatedResponse.TotalAmountPages);
return(paginatedResponse.Response);
}
public async Task FilterByGenre()
{
var databaseName = CreateTestData();
var mapper = BuildMap();
var context = BuildContext(databaseName);
var genreId = context.Genres.Select(x => x.Id).First();
var context2 = BuildContext(databaseName);
var controller = new MoviesController(context2, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
GenreId = genreId,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Movie With Genre", movies[0].Title);
}
public async Task FilterTitle()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var titleMovie = "Película 1";
var filterDTO = new FilterMoviesDTO()
{
Title = titleMovie,
RecordsPage = 10
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual(titleMovie, movies[0].Title);
}
public async Task FilterOrderByTitleDescending()
{
var databaseName = CreateTestData();
var mapper = BuildMap();
var context = BuildContext(databaseName);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
OrderingField = "title",
AscendingOrder = false,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
var context2 = BuildContext(databaseName);
var moviesFromDb = context2.Movies.OrderByDescending(x => x.Title).ToList();
Assert.AreEqual(moviesFromDb.Count, movies.Count);
for (int i = 0; i < moviesFromDb.Count; i++)
{
var movieFromController = movies[i];
var movieFromDb = moviesFromDb[i];
Assert.AreEqual(movieFromDb.Id, movieFromController.Id);
}
}
public async Task <PaginatedResponse <List <Movie> > > GetMoviesFiltered(FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable
.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheater);
}
if (filterMoviesDTO.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
var movies = await moviesQueryable.GetPaginatedResponseAsync(filterMoviesDTO.Pagination);
return(movies);
}
public async Task FilterIncorrectField()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var mock = new Mock <ILogger <MoviesController> >();
var controller = new MoviesController(context, mapper, null, mock.Object);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
FieldOrder = "abc",
OrderAscending = true
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
var context2 = BuildContext(nameDB);
var moviesDB = context2.Movies.ToList();
Assert.AreEqual(moviesDB.Count, movies.Count);
Assert.AreEqual(1, mock.Invocations.Count);
}
public async Task FilterOrderByWrongFieldStillReturnsMovies()
{
var databaseName = CreateTestData();
var mapper = BuildMap();
var context = BuildContext(databaseName);
var mock = new Mock <ILogger <MoviesController> >();
var controller = new MoviesController(context, mapper, null, mock.Object);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
OrderingField = "abcd",
AscendingOrder = false,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
var context2 = BuildContext(databaseName);
var moviesFromDb = context2.Movies.ToList();
Assert.AreEqual(moviesFromDb.Count, movies.Count);
Assert.AreEqual(1, mock.Invocations.Count);
}
public async Task <ActionResult <List <Movie> > > Filter(FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable
.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
await HttpContext.InsertPaginationParametersInResponse(moviesQueryable,
filterMoviesDTO.RecordsPerPage);
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(movies);
}
public async Task FilterTitleDescending()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
FieldOrder = "Title",
OrderAscending = false
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
var context2 = BuildContext(nameDB);
var moviesDB = context2.Movies.OrderByDescending(x => x.Title).ToList();
Assert.AreEqual(moviesDB.Count, movies.Count);
for (int i = 0; i < moviesDB.Count; i++)
{
var movieController = movies[i];
var movieDB = moviesDB[i];
Assert.AreEqual(movieDB.Id, movieController.Id);
}
}
public async Task <ActionResult <List <Movie> > > Filter(FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = _context.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable
//.Where(x => x.Title.Contains(filterMoviesDTO.Title, StringComparison.InvariantCultureIgnoreCase));
.Where(x => x.Title.ToLower().Contains(filterMoviesDTO.Title.ToLower()));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > DateTime.Today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId).Contains(filterMoviesDTO.GenreId));
}
// Compute the Total Number of Pages and add as a Response Header
await HttpContext.InsertPaginationParametersInResponse(moviesQueryable, filterMoviesDTO.RecordsPerPage);
// Execute Query with Skip and Take based on Pagination param
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(movies);
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrEmpty(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
await HttpContext.InsertParametersPaginationInHeader(moviesQueryable);
var movies = await moviesQueryable.OrderBy(x => x.Title).Paginate(filterMoviesDTO.PaginationDTO)
.ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
//allows us to build the query line by line
var moviesQueryable = dbContext.Movies.AsQueryable();
//so if the object being passed in does NOT have a empty value for title then make the queryable value equal to the corresonding movie in the DB with tthe matching title.
if (!string.IsNullOrEmpty(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
await HttpContext.InsertParametersPaginationInHeader(moviesQueryable);
var movies = await moviesQueryable.OrderBy(x => x.Title).Paginate(filterMoviesDTO.PaginationDTO)
.ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <MovieDTO> > > Filters([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = _context.Movies.AsQueryable();
if (!string.IsNullOrEmpty(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(m => m.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(m => m.InTheaters);
}
else
//moviesQueryable = moviesQueryable.Where(m => m.InTheaters == false);
if (filterMoviesDTO.NextPremieres)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(m => m.PremireDate > today);
}
if (filterMoviesDTO.GenderId != 0)
{
moviesQueryable = moviesQueryable
.Where(m => m.MoviesGenders
.Select(mg => mg.GenderId)
.Contains(filterMoviesDTO.GenderId));
}
if (!string.IsNullOrEmpty(filterMoviesDTO.FieldOrder))
{
//if(filterMoviesDTO.FieldOrder == "Title")
//{
// if (filterMoviesDTO.OrderAscendant)
// moviesQueryable.OrderBy(x => x.Title);
// else
// moviesQueryable.OrderByDescending(x => x.Title);
//}
var typeOrder = (filterMoviesDTO.OrderAscending) ? "ascending" : "descending";
try
{
moviesQueryable = moviesQueryable.OrderBy($"{filterMoviesDTO.FieldOrder} {typeOrder}");
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
}
await HttpContext.InsertParametersPagination(moviesQueryable, filterMoviesDTO.RecordsPage);
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(_mapper.Map <List <MovieDTO> >(movies));
}
public async Task<PaginatedResponse<List<Movie>>> GetMoviesFiltered(FilterMoviesDTO filterMoviesDTO)
{
var responseHTTP = await httpService.Post<FilterMoviesDTO, List<Movie>>($"{url}/filter", filterMoviesDTO, includeToken: false);
var totalAmountPages = int.Parse(responseHTTP.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse<List<Movie>>()
{
Response = responseHTTP.Response,
TotalAmountPages = totalAmountPages
};
return paginatedResponse;
}
public async Task <PaginatedResponse <List <Movie> > > GetMoviesFiltered(FilterMoviesDTO filterMoviesDTO)
{
var httpResponse = await _httpService.Post <FilterMoviesDTO, List <Movie> >($"{url}/filter", filterMoviesDTO);
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <List <Movie> >()
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages
};
return(paginatedResponse);
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDTO.ThisYearReleases)
{
var thisYear = DateTime.Today.Year;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate.Year == thisYear);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
if (!string.IsNullOrEmpty(filterMoviesDTO.OrderingField))
{
try
{
moviesQueryable = moviesQueryable
.OrderBy(
$"{filterMoviesDTO.OrderingField} {(filterMoviesDTO.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
//log this
logger.LogWarning("Could not order by field: " + filterMoviesDTO.OrderingField);
}
}
//why HttpContext not HttpContextExtension???
await HttpContext
.InsertPaginationParametersInResponse(moviesQueryable, filterMoviesDTO.RecordsPerPage);
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrEmpty(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(r => r.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(r => r.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(r => r.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId > 0)
{
moviesQueryable = moviesQueryable
.Where(r => r.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
if (!string.IsNullOrEmpty(filterMoviesDTO.OrderingField))
{
try
{
moviesQueryable = moviesQueryable
.OrderBy($"{filterMoviesDTO.OrderingField} {(filterMoviesDTO.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
logger.LogWarning($"could not order by field {filterMoviesDTO.OrderingField}");
}
}
await HttpContext.InsertPaginationParametersInResponse(moviesQueryable,
filterMoviesDTO.RecordsPerPage);
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <MovieDTO> > > FilterMovies([FromQuery] FilterMoviesDTO filter)
{
var moviesQueryable = _context.Movies.AsQueryable();
if (!string.IsNullOrEmpty(filter.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filter.Title));
}
if (filter.InTheather)
{
moviesQueryable = moviesQueryable.Where(x => x.IsInTheater);
}
if (filter.Next)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.DateIssued > today);
}
if (!string.IsNullOrEmpty(filter.Gender))
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenders
.Select(y => y.Gender.Name)
.Contains(filter.Gender));
}
if (!string.IsNullOrWhiteSpace(filter.FieldOrderBy))
{
var asc = filter.AscOrderBy ? "ascending" : "descending";
try
{
moviesQueryable = moviesQueryable.OrderBy($"{filter.FieldOrderBy} {asc}");
}
catch (Exception ex)
{
logger.LogError(ex.Message, ex);
}
}
await HttpContext.InsertPaginationParams(moviesQueryable, filter.PaginationDTO.QuantityRegistersPerPage);
var movies = await moviesQueryable.Paginate(filter.PaginationDTO).ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <Movie> > > Filter(FilterMoviesDTO filterMoviesDto)
{
var moviesQueryable = _dbContext.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDto.Title))
{
moviesQueryable = moviesQueryable
.Where(x => x.Title.Contains(filterMoviesDto.Title));
}
if (filterMoviesDto.InTheaters)
{
moviesQueryable = moviesQueryable.Where(x => x.InTheaters);
}
if (filterMoviesDto.UpcomingReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDto.OrderByVotes)
{
var movieRatings = _dbContext.MovieRatings.AsQueryable();
moviesQueryable = moviesQueryable.OrderBy(x =>
movieRatings.Where(y => y.MovieId == x.Id).Average(z => z.Rate)
);
}
if (filterMoviesDto.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDto.GenreId));
}
await HttpContext.InsertPaginationParamatersInResponse(moviesQueryable, filterMoviesDto.RecordsPerPage);
var movies = await moviesQueryable.Paginate(filterMoviesDto.Pagination).ToListAsync();
return(movies);
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = dbContext.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(m => m.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheaters)
{
moviesQueryable = moviesQueryable.Where(m => m.InTheaters);
}
if (filterMoviesDTO.UpcomingReleases)
{
moviesQueryable = moviesQueryable.Where(m => m.ReleaseDate > DateTime.Today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable.Where(m => m.Genres.Select(x => x.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.OrderingField))
{
try
{
moviesQueryable = moviesQueryable
.OrderBy($"{filterMoviesDTO.OrderingField} {(filterMoviesDTO.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
}
}
await HttpContext.InsertPaginationParametersInResponse(moviesQueryable, filterMoviesDTO.RecordsPerPage);
var movies = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(mapper.Map <List <MovieDTO> >(movies));
}
public async Task <ActionResult <List <MoviesDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = context.Movies.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.InTheator)
{
moviesQueryable = moviesQueryable.Where(x => x.IsShowing);
}
if (filterMoviesDTO.UpCommingReleases)
{
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > DateTime.Today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable.Where(x => x.MovieGenres.Select(y => y.GenreId).Contains(filterMoviesDTO.GenreId));
}
if (!string.IsNullOrWhiteSpace(filterMoviesDTO.OrderBy))
{
try
{
moviesQueryable = moviesQueryable.OrderBy($"{filterMoviesDTO.OrderBy} {(filterMoviesDTO.Ascending ? "ascending" : "descending")}");
}
catch (Exception e)
{
// throw;
logger.LogWarning("Error Detected", e.Message);
}
}
await HttpContext.InsertPaginationParametersInResponse(moviesQueryable, filterMoviesDTO.RecordsPerPage);
var moviesList = await moviesQueryable.Paginate(filterMoviesDTO.Pagination).ToListAsync();
return(mapper.Map <List <MoviesDTO> >(moviesList));
}
public async Task FilterMovies()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
InTheaters = true
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Película en Cines", movies[0].Title);
}
public async Task FilterByInTheaters()
{
var databaseName = CreateTestData();
var mapper = BuildMap();
var context = BuildContext(databaseName);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
InTheaters = true,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("In Theaters Movie", movies[0].Title);
}
public async Task FilterGender()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var genderId = context.Genders.Select(x => x.Id).First();
var filterDTO = new FilterMoviesDTO()
{
GenderId = genderId
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Película con Género", movies[0].Title);
}
public async Task <ActionResult <List <MovieDTO> > > Filter([FromQuery] FilterMoviesDTO filterMoviesDTO)
{
var moviesQueryable = _context.Movies.AsQueryable();
if (!string.IsNullOrEmpty(filterMoviesDTO.Title))
{
moviesQueryable = moviesQueryable.Where(x => x.Title.Contains(filterMoviesDTO.Title));
}
if (filterMoviesDTO.OnCinemas)
{
moviesQueryable = moviesQueryable.Where(x => x.OnCinemas);
}
if (filterMoviesDTO.FutureReleases)
{
var today = DateTime.Today;
moviesQueryable = moviesQueryable.Where(x => x.ReleaseDate > today);
}
if (filterMoviesDTO.GenreId != 0)
{
moviesQueryable = moviesQueryable
.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filterMoviesDTO.GenreId));
}
if (!string.IsNullOrEmpty(filterMoviesDTO.SortField))
{
var orderType = filterMoviesDTO.AscendingOrder ? "ascending" : "descending";
try
{
// String Interpolation
moviesQueryable = moviesQueryable.OrderBy($"{filterMoviesDTO.SortField} {orderType}");
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
#region OrderBy with if
//if (filterMoviesDTO.SortField == "title")
//{
// if (filterMoviesDTO.AscendingOrder)
// {
// moviesQueryable = moviesQueryable.OrderBy(x => x.Title);
// }
// else
// {
// moviesQueryable = moviesQueryable.OrderByDescending(x => x.Title);
// }
//}
#endregion
}
await HttpContext.InsertPaginationParameters(moviesQueryable,
filterMoviesDTO.recordsQuantityPerPage);
var movies = await moviesQueryable
.Paginate(filterMoviesDTO.Pagination)
.ToListAsync();
return(_mapper.Map <List <MovieDTO> >(movies));
}
public Task <PaginatedResponse <List <Movie> > > GetMoviesFiletered(FilterMoviesDTO filterMoviesDTO)
{
throw new NotImplementedException();
}
