internal static MovieQuery ReadQuery()
{
//Create a query object
MovieQuery query = new MovieQuery();
Console.WriteLine("Please enter your query");
//Read the query
query.Query = Console.ReadLine();
Console.WriteLine("Do you want to specify an cast?");
string cast = Console.ReadLine();
while (!string.IsNullOrEmpty(cast))
{
query.CastFilter.Add(cast);
Console.WriteLine("Add another cast?");
cast = Console.ReadLine();
}
Console.WriteLine("Do you want to specify a genre?");
string genre = Console.ReadLine();
while (!string.IsNullOrEmpty(genre))
{
query.GenreFilter.Add(genre);
Console.WriteLine("Add another genre?");
genre = Console.ReadLine();
}
//return the query object
return(query);
}
internal ICollection <ISolrQuery> BuildFilterQueries(MovieQuery query)
{
ICollection <ISolrQuery> filters = new List <ISolrQuery>();
List <SolrQueryByField> refinersCast = new List <SolrQueryByField>();
List <SolrQueryByField> refinersGenre = new List <SolrQueryByField>();
foreach (string cast in query.CastFilter)
{
refinersCast.Add(new SolrQueryByField("cast", cast));
}
foreach (string genre in query.GenreFilter)
{
refinersGenre.Add(new SolrQueryByField("genres", genre));
}
if (refinersCast.Count > 0)
{
filters.Add(new SolrMultipleCriteriaQuery(refinersCast, "OR")); //AND
}
if (refinersGenre.Count > 0)
{
filters.Add(new SolrMultipleCriteriaQuery(refinersGenre, "OR")); //AND
}
return(filters);
}
public async Task <IActionResult> GetMovieList([FromQuery] MovieQuery query)
{
var movies = await _movieService.GetMovies(query);
Response.AddPaginationHeader(movies, nameof(GetMovieList), query, Url);
return(Ok(new MovieList(movies)));
}
public Task <IPagedCollection <MovieDetail> > GetMovies(MovieQuery query)
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
return(GetMovies());
async Task <IPagedCollection <MovieDetail> > GetMovies()
{
var filter = _filter
.WhereGenresEquals(query.Genres)
.WhereTitleEquals(query.Title)
.Filter;
var moviesFromDb = await _context
.Movies
.Where(filter)
.OrderBy(query.Order, _order)
.ToPagedCollectionAsync(query.Page, query.Limit)
.ConfigureAwait(false);
var movies = _mapper.Map <IReadOnlyList <MovieDetail> >(moviesFromDb);
return(new PagedCollection <MovieDetail>(
movies,
moviesFromDb.ItemCount,
moviesFromDb.CurrentPageNumber,
moviesFromDb.PageSize));
}
}
public async Task <IActionResult> GetAll([FromQuery] MovieQuery query)
{
var movies = await _movieRepository.GetAll(query);
var moviesJson = movies.Select(x => new MovieJson(x)).ToList();
return(Ok(moviesJson));
}
public IEnumerable <MovieDomainModel> GetAllMovies(bool?isCurrent, MovieQuery query)
{
var data = _moviesRepository.GetCurrentMovies();
if (query.ActorName != null)
{
data = data.Where(x => x.MovieActors.Any(a => a.Actor.FirstName.ToLower().Contains(query.ActorName.ToLower())));
}
if (query.Title != null)
{
data = data.Where(x => x.Title.ToLower().Contains(query.Title.ToLower()));
}
if (query.RatingLowerThan > 0)
{
data = data.Where(x => x.Rating < query.RatingLowerThan);
}
if (query.RatingBiggerThan > 0)
{
data = data.Where(x => x.Rating > query.RatingBiggerThan);
}
if (query.YearLowerThan > 0)
{
data = data.Where(x => x.Year < query.YearLowerThan);
}
if (query.YearBiggerThan > 0)
{
data = data.Where(x => x.Year > query.YearBiggerThan);
}
if (query.HasOscar != null)
{
data = data.Where(x => x.HasOscar == query.HasOscar);
}
List <MovieDomainModel> result = new List <MovieDomainModel>();
MovieDomainModel model;
foreach (var item in data)
{
model = new MovieDomainModel
{
Current = item.Current,
Id = item.Id,
Rating = item.Rating ?? 0,
Title = item.Title,
Year = item.Year,
HasOscar = item.HasOscar
};
result.Add(model);
}
return(result);
}
public async Task <IActionResult> AddToMovies([FromBody] Movie movie)
{
await Db.Connection.OpenAsync();
var query = new MovieQuery(Db);
var result = await query.addNewMovie(movie);
return(new OkObjectResult(result));
}
public async Task <IActionResult> DeleteMovieById(int id)
{
await Db.Connection.OpenAsync();
var query = new MovieQuery(Db);
var result = await query.delelteMovieById(id);
return(new OkObjectResult(result));
}
public async Task <IActionResult> Put(int id, [FromBody] Movie movie)
{
await Db.Connection.OpenAsync();
var query = new MovieQuery(Db);
var result = await query.updateMovie(id, movie);
return(new OkObjectResult(result));
}
public void ShouldGetMoviesFromService()
{
var movieQuery = new MovieQuery();
var controller = new MoviesController(_mockMovieService.Object);
controller.Get(movieQuery);
_mockMovieService.Verify(m => m.All(movieQuery), Times.Once);
}
public IActionResult Get([FromQuery] MovieQuery query)
{
try
{
return(Ok(getMovies.Execute(query)));
}
catch (Exception e)
{
return(StatusCode(500, e));
}
}
public void Post([FromBody] MovieData value)
{
try
{
var movieQuery = new MovieQuery();
movieQuery.AddMovie(value);
}
catch (Exception e)
{
throw e;
}
}
public MovieResponse All(MovieQuery query)
{
var movieResponse = new MovieResponse();
var movieDbResponse = _movieRepository.GetAll(query);
if (movieDbResponse != null && movieDbResponse.Count > 0)
{
movieResponse.Count = movieDbResponse.Count;
movieResponse.Movies = movieDbResponse.Movies.Select(m => _movieConverter.ConvertToMovie(m)).OrderBy(m => m.Title);
}
return(movieResponse);
}
// GET: Movies
public ActionResult Index([FromQuery] MovieQuery query)
{
try
{
return(View(executor.ExecuteQuery(getMovies, query)));
}
catch (Exception e)
{
TempData["error"] = e.Message;
}
return(RedirectToAction("Home", "Index"));
}
public ActionResult <CombinedData[]> stats()
{
try
{
var testingClass = new MovieQuery();
return(testingClass.MovieStats());
}
catch (Exception e)
{
throw e;
}
}
public void FilterTest()
{
var fakeRepo = new FakeMovieRepository();
var movies = fakeRepo.GetMovieList().Result;
var movieQuery = new MovieQuery {
MinYear = 2013, MaxYear = 2016, OrderBy = "Released"
};
var filteredMovies = movies.Filter(movieQuery);
Assert.True(filteredMovies.Count() == 3);
Assert.NotNull(filteredMovies.FirstOrDefault());
Assert.Equal(filteredMovies.FirstOrDefault().ImdbID, "2");
}
public async Task <ActionResult <IEnumerable <Movie> > > GetAsync([FromQuery] MovieQuery query)
{
IEnumerable <MovieDomainModel> movieDomainModels;
movieDomainModels = _movieService.GetAllMovies(true, query);
if (movieDomainModels == null)
{
movieDomainModels = new List <MovieDomainModel>();
}
return(Ok(movieDomainModels));
}
public async Task <ActionResult <IEnumerable <Movie> > > GetAsyncByTag([FromQuery] MovieQuery query)
{
IEnumerable <MovieDomainModel> movieDomainModels;
movieDomainModels = await _movieService.GetAllMoviesFilterWithNonCurrent(true, query);
if (movieDomainModels == null)
{
movieDomainModels = new List <MovieDomainModel>();
}
return(Ok(movieDomainModels));
}
public void ShouldGetMoviesFromServiceWithFilter()
{
var query = new MovieQuery
{
SearchFilter = "My Movie",
Take = 10,
Skip = 1
};
var controller = new MoviesController(_mockMovieService.Object);
controller.Get(query);
_mockMovieService.Verify(m => m.All(query), Times.Once);
}
public async Task <IActionResult> GetTop10Movies()
{
await Db.Connection.OpenAsync();
var moviesQuery = new MovieQuery(Db);
var movieImagesQuery = new MovieImageQuery(Db);
var movies = await moviesQuery.getTop10Movies();
foreach (var movie in movies)
{
movie.filmKepek = await movieImagesQuery.getMovieImagesById(movie.film_id);
}
return(new OkObjectResult(movies));
}
public async Task <IActionResult> GetMoviesByQuery([FromBody] MovieQuery query)
{
try
{
var movies = await GetMovieDataFromCache();
var filteredMovies = movies.Filter(query);
return(Ok(filteredMovies));
}
catch (Exception ex)
{
var jsonResult = new JsonResult(new { error = ex.Message });
jsonResult.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return(jsonResult);
}
}
public async Task <ActionResult> Get([FromQuery] MovieQuery query)
{
if (!query.AssertIsValid())
{
return(BadRequest());
}
var results = await _movieRepository.GetMoviesByQuery(query);
if (results.Count() == 0)
{
return(NotFound());
}
return(Ok(results));
}
public void Get_Current_Movies_Return_All()
{
//Arrange
int expectedCount = 1;
int expectedStatusCode = 200;
MovieDomainModel movieDomainModel = new MovieDomainModel
{
Id = Guid.NewGuid(),
Current = true,
HasOscar = false,
Rating = 2,
Title = "Film1",
Year = 2015
};
MovieQuery movieQuery = new MovieQuery
{
HasOscar = true
};
List <MovieDomainModel> movieDomainModels = new List <MovieDomainModel>();
movieDomainModels.Add(movieDomainModel);
IEnumerable <MovieDomainModel> movieDomainModelsIEn = movieDomainModels;
IEnumerable <MovieDomainModel> response = movieDomainModelsIEn;
_movieService = new Mock <IMovieService>();
_loggerService = new Mock <ILogger <MoviesController> >();
_movieService.Setup(x => x.GetAllMovies(It.IsAny <bool>(), It.IsAny <MovieQuery>())).Returns(response);
MoviesController moviesController = new MoviesController(_loggerService.Object, _movieService.Object);
//Act
var result = moviesController.GetAsync(movieQuery).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((OkObjectResult)result).Value;
var movieDomainModelResultList = (List <MovieDomainModel>)resultList;
//Assert
Assert.IsNotNull(resultList);
Assert.AreEqual(expectedCount, movieDomainModelResultList.Count);
Assert.AreEqual(movieDomainModel.Id, movieDomainModelResultList[0].Id);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void ShouldReturnMoviesFromController()
{
var movieQuery = new MovieQuery();
var movies = new List <Movie> {
new Movie {
Id = 1, Title = "The Movie"
}
};
var movieReponse = new MovieResponse();
movieReponse.Movies = movies;
_mockMovieService.Setup(m => m.All(movieQuery)).Returns(movieReponse);
var controller = new MoviesController(_mockMovieService.Object);
var result = controller.Get(movieQuery);
Assert.Equal(movieReponse, result);
}
public void ShouldGetMoviesFromRepositoryWithFilterAndPaging()
{
var movieQuery = new MovieQuery
{
SearchFilter = "Search",
Categories = new List <string> {
"Action"
},
Take = 10,
Skip = 5
};
var movieService = new MovieService(_mockMovieRepository.Object, _mockMovieConverter.Object);
movieService.All(movieQuery);
_mockMovieRepository.Verify(m => m.GetAll(movieQuery), Times.Once);
}
static void Main(string[] args)
{
//create a search library instance
MovieSearch searchLibrary = new MovieSearch();
MovieQuery query = new MovieQuery();
query = QueryReader.ReadQuery();
while (query.Query != Environment.NewLine)
{
QueryResponse response = searchLibrary.DoSearch(query);
PrettyPrintResults.PrintOut(response);
query = QueryReader.ReadQuery();
}
}
public QueryResponse DoSearch(MovieQuery query)
{
//Create an object to hold results
FiltersFacets filtersFacets = new FiltersFacets();
Highlights highlights = new Highlights();
ExtraParameters extraParameters = new ExtraParameters();
SolrQueryResults <Movie> solrResults;
QueryResponse queryResponse = new QueryResponse
{
//Echo back the original query
OriginalQuery = query
};
//Get a connection
ISolrOperations <Movie> solr = connection.GetSolrInstance();
QueryOptions queryOptions = new QueryOptions
{
Rows = query.Rows,
StartOrCursor = new StartOrCursor.Start(query.Start),
FilterQueries = filtersFacets.BuildFilterQueries(query),
Facet = filtersFacets.BuildFacets(),
Highlight = highlights.BuildHighlightParameters(),
ExtraParams = extraParameters.BuildExtraParameters()
};
//Execute the query
ISolrQuery solrQuery = new SolrQuery(query.Query);
solrResults = solr.Query(solrQuery, queryOptions);
//Set response
ResponseExtraction extractResponse = new ResponseExtraction();
extractResponse.SetHeader(queryResponse, solrResults);
extractResponse.SetBody(queryResponse, solrResults);
extractResponse.SetSpellcheck(queryResponse, solrResults);
extractResponse.SetFacets(queryResponse, solrResults);
//Return response;
return(queryResponse);
}
public async Task <IActionResult> Page(MovieQuery movieQuery)
{
PagedListModel <MovieViewModel> pagedListModel = new PagedListModel <MovieViewModel>();
var movies = from m in _context.Movie
select m;
if (!string.IsNullOrEmpty(movieQuery.searchString))
{
movies = movies.Where(s => s.Title.Contains(movieQuery.searchString));
}
if (!string.IsNullOrEmpty(movieQuery.movieGenre))
{
movies = movies.Where(x => x.Genre == movieQuery.movieGenre);
}
// 排序
if (!string.IsNullOrWhiteSpace(movieQuery.OrderType) && !string.IsNullOrWhiteSpace(movieQuery.OrderName))
{
IQueryable <Movie> orderByResult =
movieQuery.OrderType.ToLower() == "desc" ?
movies.ColumnOrderByDescending(movieQuery.OrderName) : movies.ColumnOrdersBy(movieQuery.OrderName);
pagedListModel.Total = orderByResult.Count(); // 查詢資料總數
pagedListModel.Items = orderByResult.ModelListConvert <MovieViewModel>()
.ToPagedList(movieQuery.Page < 1 ? 1 : movieQuery.Page, movieQuery.PageSize);
}
else
{
pagedListModel.Total = movies.Count(); // 查詢資料總數
pagedListModel.Items = movies.ModelListConvert <MovieViewModel>()
.ToPagedList(movieQuery.Page < 1 ? 1 : movieQuery.Page, movieQuery.PageSize);
}
// 重新指定排序順序
pagedListModel.OrderType = movieQuery.OrderType == "Asc" ? "Asc" : "Desc";
return(View("~/Views/Movies/_PagePartialView.cshtml", pagedListModel));
}
/// <summary>
/// Get the movie database.
/// </summary>
/// <param name="search">search criteria object</param>
/// <returns>Page List</returns>
public ListPageDto <MovieDto> Get(MovieQuery search)
{
search = search ?? new MovieQuery();
var movies = this.dataProvider.GetMovies().Select(m => Mapper.Map <MoviesLibrary.MovieData, Dto.MovieDto>(m)).ToList();
if (search.SearchCriteria != null)
{
movies = ApplyFilter(movies, search.SearchCriteria);
}
if (search.SortField != null)
{
movies = ApplySort(movies, search.SortField);
}
var listPage = ApplyPaging(movies, search.Paging);
return(listPage);
}
public void TestInitialize()
{
List <Projection> projections = new List <Projection>();
_movie = new Movie
{
Id = Guid.NewGuid(),
Current = true,
HasOscar = true,
Rating = 7,
Title = "Smekerski film",
Year = 2021,
Projections = projections
};
_movieDomainModel = new MovieDomainModel
{
Id = _movie.Id,
Current = _movie.Current,
HasOscar = _movie.HasOscar,
Rating = _movie.Rating ?? 0,
Title = _movie.Title,
Year = _movie.Year
};
List <Movie> movieModelsList = new List <Movie>();
movieModelsList.Add(_movie);
IEnumerable <Movie> movies = movieModelsList;
Task <IEnumerable <Movie> > responseTask = Task.FromResult(movies);
query = new MovieQuery
{
HasOscar = null
};
_mockMovieRepository = new Mock <IMoviesRepository>();
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockMovieRepository.Setup(x => x.GetCurrentMovies()).Returns(movieModelsList);
_mockMovieRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Returns(_movie);
_mockMovieRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(_movie);
}
