/// <summary>
/// <para>Load all data required for calculating the statistics from the database.</para>
/// <para>Must be called prior to <see cref="Calculate"/> if lazy loading is disabled!</para>
/// </summary>
/// <param name="dbContext">Database context from EntityFramework.</param>
/// <param name="force">Force loading data again even if IsDataLoaded is true.</param>
public virtual async Task LoadRequiredDataAsync(LeagueDbContext dbContext, bool force = false)
{
if (DriverStatistic == null || DriverStatistic.Count == 0)
{
await dbContext.Entry(this)
.Collection(x => x.DriverStatistic)
.LoadAsync();
var memberIds = DriverStatistic.Select(x => x.MemberId);
var sessionIds = DriverStatistic
.SelectMany(x => new long?[] { x.FirstSessionId, x.LastSessionId, x.FirstRaceId, x.LastRaceId })
.Where(x => x != null)
.Select(x => x.Value);
var resultRowIds = DriverStatistic
.SelectMany(x => new long?[] { x.FirstResultRowId, x.LastResultRowId })
.Where(x => x != null)
.Select(x => x.Value);
await dbContext.Set <LeagueMemberEntity>()
.Where(x => memberIds.Contains(x.MemberId))
.LoadAsync();
await dbContext.Set <SessionBaseEntity>()
.Where(x => sessionIds.Contains(x.SessionId))
.LoadAsync();
await dbContext.Set <ResultRowEntity>()
.Where(x => resultRowIds.Contains(x.ResultRowId))
.LoadAsync();
dbContext.ChangeTracker.DetectChanges();
}
}
private static async Task Tick(string leagueDbName)
{
// Load statistic sets and check for recalculation interval
using (var dbContext = new LeagueDbContext(leagueDbName))
{
var statisticSets = dbContext.Set <StatisticSetEntity>().ToList();
var checkStatisticSets = statisticSets.Where(x => IsDueTick(x.UpdateTime, TimeSpanConverter.Convert(x.UpdateInterval))).OrderBy(x => GetTypePriority(x));
dbContext.Configuration.LazyLoadingEnabled = false;
foreach (var statisticSet in checkStatisticSets)
{
await statisticSet.CheckRequireRecalculationAsync(dbContext);
if (statisticSet.RequiresRecalculation)
{
await statisticSet.LoadRequiredDataAsync(dbContext);
statisticSet.Calculate(dbContext);
}
}
dbContext.Configuration.LazyLoadingEnabled = true;
dbContext.SaveChanges();
}
GC.Collect();
}
static void Main(string[] args)
{
// Create season statistic set
//using (var dbContext = new LeagueDbContext("SkippyCup_leagueDb"))
//{
// var season = dbContext.Seasons.Find(1);
// var seasonStatistics = new SeasonStatisticSetEntity();
// season.SeasonStatistics.Add(seasonStatistics);
// var sprintScoring = dbContext.Set<ScoringEntity>().Find(7);
// var enduranceScoring = dbContext.Set<ScoringEntity>().Find(8);
// seasonStatistics.Scorings.Add(sprintScoring);
// seasonStatistics.Scorings.Add(enduranceScoring);
// dbContext.SaveChanges();
//}
// Calculate season statistics
using (var dbContext = new LeagueDbContext("SkippyCup_leagueDb"))
{
var seasonStatistics = dbContext.Set <SeasonStatisticSetEntity>().ToList();
dbContext.Configuration.LazyLoadingEnabled = false;
seasonStatistics.ForEach(x => x.LoadRequiredDataAsync(dbContext).Wait());
seasonStatistics.ForEach(x => x.Calculate(dbContext));
dbContext.SaveChanges();
}
// Create league statistic set
//using (var dbContext = new LeagueDbContext("SkippyCup_leagueDb"))
//{
// var leagueStatistic = new LeagueStatisticSetEntity();
// dbContext.LeagueStatistics.Add(leagueStatistic);
// leagueStatistic.StatisticSets.Add(dbContext.Seasons.First().SeasonStatistics.First());
// leagueStatistic.StatisticSets.Add(dbContext.Seasons.First().SeasonStatistics.Last());
// dbContext.SaveChanges();
//}
// Calculate league statistics
using (var dbContext = new LeagueDbContext("SkippyCup_leagueDb"))
{
var leagueStatistic = dbContext.Set <LeagueStatisticSetEntity>().First();
dbContext.Configuration.LazyLoadingEnabled = false;
leagueStatistic.LoadRequiredDataAsync(dbContext).Wait();
leagueStatistic.Calculate(dbContext);
dbContext.SaveChanges();
}
//Console.Read();
}
public override void Delete(LeagueDbContext dbContext)
{
AddPenalty?.Delete(dbContext);
ReviewPenalties?.ToList().ForEach(x => x.Delete(dbContext));
dbContext.Set <DriverStatisticRowEntity>()
.Where(x => x.LastResultRowId == ScoredResultRowId || x.FirstResultRowId == ScoredResultRowId)
.Load();
base.Delete(dbContext);
}
public TResult Execute <TSet, TResult>(IQuery <TSet, TResult> query) where TSet : class
{
if (query is null)
{
throw new System.ArgumentNullException(nameof(query));
}
var set = db.Set <TSet>();
return(query.Execute(set));
}
public virtual void Delete(LeagueDbContext dbContext)
{
dbContext.Set(this.GetType()).Remove(this);
}
public override async Task LoadRequiredDataAsync(LeagueDbContext dbContext, bool force = false)
{
if (IsDataLoaded && force == false)
{
return;
}
await base.LoadRequiredDataAsync(dbContext, force);
if (Season == null)
{
await dbContext.Entry(this)
.Reference(x => x.Season)
.LoadAsync();
}
//if (DriverStatistic == null || DriverStatistic.Count == 0)
//{
// await dbContext.Entry(this)
// .Collection(x => x.DriverStatistic)
// .LoadAsync();
//}
if (ScoringTableId == null || ScoringTableId == 0)
{
return;
}
var scoringTable = dbContext.Set <ScoringTableEntity>()
.Where(x => x.ScoringTableId == ScoringTableId)
.Include(x => x.Scorings.Select(y => y.ExtScoringSource))
//.Include(x => x.Scorings.Select(y => y.Sessions.Select(z => z.SessionResult)))
//.Include(x => x.Scorings.Select(y => y.ScoredResults.Select(z => z.FinalResults.Select(q => q.ResultRow.Member))))
//.Include(x => x.Scorings.Select(y => y.ExtScoringSource.ScoredResults.Select(z => z.FinalResults.Select(q => q.ResultRow.Member))))
.FirstOrDefault();
var loadScoringEntityIds = dbContext.Set <ScoringEntity>().Local.Select(y => y.ScoringId);
if (loadScoringEntityIds.Count() > 0)
{
var loadScorings = dbContext.Set <ScoringEntity>()
.Where(x => loadScoringEntityIds.Contains(x.ScoringId))
.Include(x => x.Sessions.Select(y => y.SessionResult))
.ToList();
var loadScoredResults = dbContext.Set <ScoredResultEntity>()
.Where(x => loadScoringEntityIds.Contains(x.ScoringId))
.Include(x => x.FinalResults.Select(y => y.ResultRow.Member))
.Include(x => x.CleanestDrivers)
.Include(x => x.HardChargers)
.ToList();
}
var scorings = scoringTable.Scorings;
foreach (var scoring in scorings)
{
await dbContext.Entry(scoring)
.Reference(x => x.ConnectedSchedule)
.Query()
.Include(x => x.Sessions)
.LoadAsync();
await dbContext.Entry(scoring)
.Collection(x => x.Sessions)
.LoadAsync();
scoring.GetAllSessions();
}
var scoringIds = scorings.Select(y => y.ScoringId);
await dbContext.Set <ScoredResultEntity>()
.Where(x => scoringIds.Contains(x.ScoringId))
.Include(x => x.FinalResults.Select(y => y.AddPenalty))
.Include(x => x.FinalResults.Select(y => y.ReviewPenalties))
.LoadAsync();
var resultIds = scorings.SelectMany(x => x.ScoredResults.Select(y => y.ResultId));
await dbContext.Set <ResultEntity>()
.Where(x => resultIds.Contains(x.ResultId))
.Include(x => x.RawResults.Select(y => y.Member.Team))
.Include(x => x.IRSimSessionDetails)
.Include(x => x.Session.Reviews.Select(y => y.AcceptedReviewVotes.Select(z => z.CustomVoteCat)))
.LoadAsync();
dbContext.ChangeTracker.DetectChanges();
IsDataLoaded = true;
}
