public int GetRuntimeAverage(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return((int)db.Movies.WhereUser(UserId)
.Where(binding)
.Average(x => x.Runtime));
}
}
public int GetSum(MovieGetBinding binding, Func <Model.Database.Main.User.Movie, int> selector)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.Sum(selector));
}
}
public int Count(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.Count());
}
}
public double GetRatingAverage(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
var userMovies = db.Movies.WhereUser(UserId)
.Where(binding);
return(Round((double)userMovies.Average(x => x.Rating), 1));
}
}
public PagedView <View.Movie> Get(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.OrderBy(binding)
.Select(x => new View.Movie(x))
.ToPagedView(binding));
}
}
public IEnumerable <KeyValuePair <string, int> > CountByRuntime(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => x.Runtime - (x.Runtime % 10) + 10)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <string, int>($"~{x.Key}min", x.Count()))
.ToList());
}
}
public IEnumerable <KeyValuePair <short, int> > CountByMovieYear(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => x.Year)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <short, int>(x.Key, x.Count()))
.ToList());
}
}
public IEnumerable <KeyValuePair <string, int> > CountByMovieDecade(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => x.Year - x.Year % 10)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <string, int>($"{x.Key}'s", x.Count()))
.ToList());
}
}
public IEnumerable <KeyValuePair <DateTime, int> > CountByDay(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => x.Timestamp.Date)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <DateTime, int>(x.Key, x.Count()))
.ToList());
}
}
public IEnumerable <KeyValuePair <int, int> > CountByDayOfWeek(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => ((int)EF.Functions.DateDiffDay((DateTime?)FirstSunday, (DateTime?)x.Timestamp) - 1) % 7)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <int, int>(x.Key, x.Count()))
.ToList());
}
}
public double GetMyRatingAverage(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
var userMovies = db.Movies.WhereUser(UserId)
.Where(binding);
double average = (double)userMovies.Sum(x => x.MyRating) / userMovies.Count();
return(Round(average, 1));
}
}
public IEnumerable <GroupedByMonth <int> > CountByMonthOfYear(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => new { x.Timestamp.Year, x.Timestamp.Month })
.OrderBy(x => x.Key.Year)
.ThenBy(x => x.Key.Month)
.Select(x => new GroupedByMonth <int>(x.Count(), x.Key.Year, x.Key.Month))
.ToList());
}
}
public async Task <GoogleCloudDialogflowV2WebhookResponse> GetMovieCount(GoogleCloudDialogflowV2WebhookRequest request)
{
var filteredBinding = request.ToFilteredBinding();
var movieGetBinding = new MovieGetBinding()
{
From = filteredBinding.From,
To = filteredBinding.To
};
int movieCount = _movieHandler.Count(movieGetBinding);
return(new GoogleCloudDialogflowV2WebhookResponse()
{
FulfillmentText = $"You've watched {movieCount} movies."
});
}
public static IQueryable <Movie> Where(this IQueryable <Movie> movies, MovieGetBinding binding)
{
var days = binding.Day?.Select(x => (int)x).ToList();
return(movies.WhereTimestampInclusive(binding)
.WhereIf(binding.RatingHigher.HasValue, x => x.Rating > binding.RatingHigher.Value)
.WhereIf(binding.RatingLower.HasValue, x => x.Rating < binding.RatingLower.Value)
.WhereIf(binding.RuntimeLonger.HasValue, x => x.Runtime > binding.RuntimeLonger.Value)
.WhereIf(binding.RuntimeShorter.HasValue, x => x.Runtime < binding.RuntimeShorter.Value)
.WhereIf(!string.IsNullOrEmpty(binding.Title), x => x.Title.Contains(binding.Title))
.WhereIf(!binding.MyRating.IsNullOrEmpty(), x => binding.MyRating.Contains(x.MyRating))
.WhereIf(!binding.Year.IsNullOrEmpty(), x => binding.Year.Contains(x.Year))
.WhereIf(!binding.YearWatched.IsNullOrEmpty(), x => binding.YearWatched.Contains(x.Timestamp.Year))
.WhereIf(days, x => days.Contains(((int)EF.Functions.DateDiffDay((DateTime?)FirstSunday, (DateTime?)x.Timestamp)) % 7)));
}
public int GetAverage([FromQuery] MovieGetBinding binding) => _movieHandler.GetRuntimeAverage(binding);
public int GetSum([FromQuery] MovieGetBinding binding) => _movieHandler.GetSum(binding, x => x.Runtime);
public int GetCount([FromQuery] MovieGetBinding binding) => _movieHandler.Count(binding);
public PagedView <View.Movie> Get([FromQuery] MovieGetBinding binding) => _movieHandler.Get(binding);
public IActionResult GetCountByYear([FromQuery] MovieGetBinding binding) => Ok(_movieHandler.CountByYear(binding));
public double GetAverage([FromQuery] MovieGetBinding binding) => _movieHandler.GetMyRatingAverage(binding);
public async Task <IActionResult> GetAveragerByYear([FromQuery] MovieGetBinding binding) => Ok(await _movieHandler.GetMyRatingAverageByYear(binding));
public static IOrderedQueryable <Movie> OrderBy(this IQueryable <Movie> movies, MovieGetBinding binding)
{
if (binding.OrderBy == MovieSort.MyRating)
{
return(movies.OrderBy(binding.OrderAscending, x => x.MyRating));
}
else if (binding.OrderBy == MovieSort.MyRatingDifference)
{
return(movies.OrderBy(binding.OrderAscending, x => x.MyRating - x.Rating));
}
else if (binding.OrderBy == MovieSort.Year)
{
return(movies.OrderBy(binding.OrderAscending, x => x.Year));
}
else if (binding.OrderBy == MovieSort.Title)
{
return(movies.OrderBy(binding.OrderAscending, x => x.Title));
}
else if (binding.OrderBy == MovieSort.Rating)
{
return(movies.OrderBy(binding.OrderAscending, x => x.Rating));
}
else if (binding.OrderBy == MovieSort.Runtime)
{
return(movies.OrderBy(binding.OrderAscending, x => x.Runtime));
}
else
{
return(movies.OrderBy(binding.OrderAscending, x => x.Timestamp));
}
}
public async Task <IEnumerable <KeyValuePair <int, decimal> > > GetRatingAverageByYear(MovieGetBinding binding)
{
using (var db = GetMainContext())
{
return(await db.Movies.WhereUser(UserId)
.Where(binding)
.GroupBy(x => x.Timestamp.Year)
.OrderBy(x => x.Key)
.Select(x => new KeyValuePair <int, decimal>(x.Key, Round(x.Average(y => y.Rating), 1)))
.ToListAsync());
}
}
