public async Task OnGetAsync()
{
Filter movieFilter = null;
// Ist gar kein Filter selektiert (erster Aufruf), prüfe auf Defaultfilter und nehme diesen ggf. als Vorauswahl
//if (SelectedFilterId == null)
//{
// var defaultFilter = FilterService.GetDefault();
// if (defaultFilter != null)
// SelectedFilterId = defaultFilter.Id;
//}
// Gewählten Filter als Default speichern
if (!string.IsNullOrEmpty(SelectedFilterId))
{
await FilterService.SetDefault(SelectedFilterId);
movieFilter = FilterService.GetDefault();
}
// Defaultfilter zurücksetzen bei Auswahl von "Kein Filter"
else
{
await FilterService.ResetDefault();
}
// Die Sortierung ist im Gegensatz zum Filter nicht in der Datenbank abgelegt
// Stattdessen wird sie als SessionState solange vorgehalten, bis das Session-Timeout (default 20 Minuten) abgelaufen ist
// Um SessionState verwenden zu können, muss dieser aktiviert werden, siehe Startup
if (MovieSortOrder != MovieSortOrder.None)
{
HttpContext.Session.SetInt32("MovieSortOrder", (int)MovieSortOrder);
}
else
{
var sortOrder = HttpContext.Session.GetInt32("MovieSortOrder");
if (sortOrder > 0)
{
MovieSortOrder = (MovieSortOrder)Enum.Parse(typeof(MovieSortOrder), sortOrder.ToString());
}
}
var movies = await MovieService.GetWithGenresAndSourcesAsync(MovieSortOrder);
if (!string.IsNullOrEmpty(QuickSearch))
{
Movies = new List <MoviesItemViewModel>(movies.Where(m => m.Title.Contains(QuickSearch)).Select(m => new MoviesItemViewModel(m)));
}
else
{
Movies = new List <MoviesItemViewModel>(movies.Select(m => new MoviesItemViewModel(m)));
}
if (movieFilter != null)
{
Movies = Movies.AsQueryable().Where(FilterBuilder.FilterBuilder <MoviesItemViewModel> .Ref.BuildFilter(movieFilter)).ToList();
}
FilterList = new SelectList(await FilterService.GetAsync(), nameof(Filter.Id), nameof(Filter.Name));
}
public async Task <IList <Movie> > GetWithGenresAndSourcesAsync(MovieSortOrder sortOrder)
{
using (var context = new MoviekusDbContext())
{
var movies = await context.Movies.Include(s => s.Source).ToListAsync();
foreach (var movie in movies)
{
// Dieser Aufruf führt dazu, dass die bereits geladenen Movie-Objekte mit den MovieGenres angereichert werden
// Ein manuelles Add ist nicht erforderlich!
var movieGenres = context.MovieGenres.Where(mg => mg.Movie == movie).Include(g => g.Genre).ToList();
}
switch (sortOrder)
{
case MovieSortOrder.Title:
return(movies.OrderBy(m => m.Title).ToList());
case MovieSortOrder.LastSeen:
return(movies.OrderBy(m => m.LastSeen).ToList());
case MovieSortOrder.Rating:
return(movies.OrderByDescending(m => m.Rating).ToList());
case MovieSortOrder.ReleaseDate:
return(movies.OrderByDescending(m => m.ReleaseDate).ToList());
case MovieSortOrder.Runtime:
return(movies.OrderBy(m => m.Runtime).ToList());
case MovieSortOrder.EpisodeNumber:
return(movies.OrderBy(m => m.EpisodeNumber).ToList());
default: return(movies);
}
}
/*
* Diese Variante funktioniert nur bei kleinen Datenmengen. Danach kommt es zu folgendem, nicht näher erklärbarem Fehler:
* SQLite Error 1: 'SQL logic error'
* using (var context = new MoviekusDbContext())
* {
* switch(sortOrder)
* {
* case MovieSortOrder.Title:
* return await context.Movies.OrderBy(m => m.Title).Include(s => s.Source).Include(m => m.MovieGenres).ThenInclude(g => g.Genre).ToListAsync();
* case MovieSortOrder.LastSeen:
* return await context.Movies.OrderBy(m => m.LastSeen).Include(s => s.Source).Include(m => m.MovieGenres).ThenInclude(g => g.Genre).ToListAsync();
* case MovieSortOrder.Rating:
* return await context.Movies.OrderBy(m => m.Rating).Include(s => s.Source).Include(m => m.MovieGenres).ThenInclude(g => g.Genre).ToListAsync();
* case MovieSortOrder.ReleaseDate:
* return await context.Movies.OrderBy(m => m.ReleaseDate).Include(s => s.Source).Include(m => m.MovieGenres).ThenInclude(g => g.Genre).ToListAsync();
* case MovieSortOrder.Runtime:
* return await context.Movies.OrderBy(m => m.Runtime).Include(s => s.Source).Include(m => m.MovieGenres).ThenInclude(g => g.Genre).ToListAsync();
* default:
* return await context.Movies
* .Include(s => s.Source)
* .Include(m => m.MovieGenres)
* .ThenInclude(g => g.Genre)
* .ToListAsync();
* }
* }
*/
}
