Score rank caching (#1041)

Introduces caching the ranks of level high-scores in the database using
`GameScore.Rank`. This way the ranks won't have to be recalculated every
time a leaderboard page is requested, instead they are only recalculated
every time a new score is added or deleted.

This is mostly to prepare a future implementation of
#45, in order to avoid
various issues there.

Scores which are no longer the high-score of their publisher have their
rank set to 0, which allows filtering such scores to be more optimal now
(only need to use `Where()` instead of `DistinctBy()`).

Also, `ApiGameScoreResponse` now contains a `Rank` attribute,
`GameScore`s with the same exact score will now share a rank, and
`RefreshContext` was moved to `Refresh.Common` so logging methods could
use its values from anywhere.

Author: Toastbrot236

Refresh.Core/RefreshContext.cs Refresh.Common/RefreshContext.csRefresh.Core/RefreshContext.cs renamed to Refresh.Common/RefreshContext.cs

@@ -1,4 +1,4 @@
-namespace Refresh.Core;
+namespace Refresh.Common;
 
 public enum RefreshContext
 {

Refresh.Core/Services/AipiService.cs

@@ -3,6 +3,7 @@
 using Bunkum.Core.Services;
 using JetBrains.Annotations;
 using NotEnoughLogs;
+using Refresh.Common;
 using Refresh.Core.Configuration;
 using Refresh.Core.Importing;
 using Refresh.Core.Types.Data;

Refresh.Core/Services/DiscordStaffService.cs

@@ -2,6 +2,7 @@
 using Discord;
 using Discord.Webhook;
 using NotEnoughLogs;
+using Refresh.Common;
 using Refresh.Core.Configuration;
 using Refresh.Database.Models.Users;
 using GameAsset = Refresh.Database.Models.Assets.GameAsset;

Refresh.Core/Services/PlayNowService.cs

@@ -1,6 +1,7 @@
 using Bunkum.Core.Services;
 using MongoDB.Bson;
 using NotEnoughLogs;
+using Refresh.Common;
 using Refresh.Database;
 using Refresh.Database.Models.Authentication;
 using Refresh.Database.Models.Levels;

Refresh.Core/Services/PresenceService.cs

@@ -1,6 +1,7 @@
 using System.Net.Http.Headers;
 using Bunkum.Core.Services;
 using NotEnoughLogs;
+using Refresh.Common;
 using Refresh.Core.Configuration;
 using Refresh.Database.Models.Users;
 

Refresh.Database/GameDatabaseContext.Activity.cs

@@ -152,4 +152,7 @@ public DatabaseActivityPage GetRecentActivityFromUser(ActivityQueryParameters pa
     }
 
     public int GetTotalEventCount() => this.Events.Count();
+
+    public int GetTotalEventsByUserForDataType(GameUser user, EventDataType dataType) 
+        => this.Events.Count(e => e.UserId == user.UserId && e.StoredDataType == dataType);
 }

Refresh.Database/GameDatabaseContext.Leaderboard.cs

@@ -53,11 +53,13 @@ public GameScore SubmitScore(ISerializedScore score, GameUser user, GameLevel le
             && currentFirstPlace.Score < score.Score 
             && currentFirstPlace.PublisherId != user.UserId;
 
-        this.Write(() =>
+        this.WriteEnsuringStatistics(level, () =>
         {
             this.GameScores.Add(newScore);
+            level.Statistics!.CompletionCount++;
         });
 
+        this.RecalculateScoreStatistics(level.LevelId, score.ScoreType);
         this.CreateLevelScoreEvent(user, newScore);
 
         // Notify the last #1 users that they've been overtaken
@@ -101,12 +103,12 @@ public DatabaseScoreList GetTopScoresForLevel(GameLevel level, int count, int sk
             scores = scores.Where(s => s.ScoreType == scoreType);
 
         if (!showDuplicates)
-            scores = scores.DistinctBy(s => s.PublisherId);
+            scores = scores.Where(s => s.Rank != 0);
 
         if (minAge != null)
             scores = scores.Where(s => s.ScoreSubmitted >= minAge);
 
-        return new(scores.ToArray().Select((s, i) => new ScoreWithRank(s, i + 1)), skip, count, user);
+        return new(scores.ToArray().Select(s => new ScoreWithRank(s, s.Rank)), skip, count, user);
     }
 
     public DatabaseScoreList GetRankedScoresAroundScore(GameScore score, int count, GameUser? user = null)
@@ -118,13 +120,12 @@ public DatabaseScoreList GetRankedScoresAroundScore(GameScore score, int count,
         List<GameScore> scores = this.GameScoresIncluded
             .Where(s => s.ScoreType == score.ScoreType && s.LevelId == score.LevelId)
             .OrderByDescending(s => s.Score)
-            .ToArray()
-            .DistinctBy(s => s.PublisherId)
+            .Where(s => s.Rank != 0)
             .ToList();
 
         return new
         (
-            scores.Select((s, i) => new ScoreWithRank(s, i + 1)),
+            scores.Select(s => new ScoreWithRank(s, s.Rank)),
             Math.Min(scores.Count, scores.IndexOf(score) - count / 2), // center user's score around other scores
             count, user
         );
@@ -140,18 +141,16 @@ public DatabaseScoreList GetLevelTopScoresByFriends(GameUser user, GameLevel lev
         IEnumerable<GameScore> scores = this.GameScoresIncluded
             .Where(s => s.LevelId == level.LevelId)
             .OrderByDescending(s => s.Score)
-            .ToArray()
-            .DistinctBy(s => s.PublisherId)
-            //TODO: THIS CALL IS EXTREMELY INEFFECIENT!!! once we are in postgres land, figure out a way to do this effeciently
-            .Where(s => s.PlayerIds.Any(p => mutuals.Contains(p)));
+            .Where(s => s.Rank != 0)
+            .Where(s => mutuals.Contains(s.PublisherId));
 
         if (scoreType != 0)
             scores = scores.Where(s => s.ScoreType == scoreType);
 
         if (minAge != null)
             scores = scores.Where(s => s.ScoreSubmitted >= minAge);
 
-        return new(scores.Select((s, i) => new ScoreWithRank(s, i + 1)), skip, count, user);
+        return new(scores.ToArray().Select(s => new ScoreWithRank(s, s.Rank)), skip, count, user);
     }
 
     [Pure]
@@ -178,35 +177,35 @@ public void DeleteScore(GameScore score)
         IQueryable<Event> scoreEvents = this.Events
             .Where(e => e.StoredDataType == EventDataType.Score && e.StoredObjectId == score.ScoreId);
 
-        this.Write(() =>
-        {
-            this.Events.RemoveRange(scoreEvents);
-            this.GameScores.Remove(score);
-        });
+        this.Events.RemoveRange(scoreEvents);
+        this.GameScores.Remove(score);
+        this.SaveChanges();
+
+        // Only recalculate ranks if the score was a high-score.
+        // Also, separate write transaction because otherwise recalculation would still include the unwanted scores.
+        if (score.Rank != 0)
+            this.RecalculateScoreStatistics(score.LevelId, score.ScoreType, true);
     }
 
     public void DeleteScoresSetByUser(GameUser user)
     {
+        // Find out which leaderboards we will have to recalculate the ranks of.
+        // Only need high-scores for this, as the other, overtaken scores should not affect ranking at all,
+        // and additionally, this way we will always have not more than 1 score per level/score type,
+        // avoiding recalculation of the same leaderboards multiple times.
         IEnumerable<GameScore> scores = this.GameScores
-            // FIXME: Realm (ahem, I mean the atlas device sdk *rolls eyes*) is a fucking joke.
-            // Realm doesn't support .Contains on IList<T>. Yes, really.
-            // This means we are forced to iterate over EVERY SCORE.
-            // I can't wait for Postgres.
-            .AsEnumerableIfRealm()
-            .Where(s => s.PlayerIdsRaw.Contains(user.UserId.ToString()))
-            .ToArrayIfPostgres();
-        
-        this.Write(() =>
+            .Where(s => s.PublisherId == user.UserId && s.Rank != 0)
+            .ToArray();
+
+        this.GameScores.RemoveRange(s => s.PublisherId == user.UserId);
+        this.Events.RemoveRange(s => s.StoredDataType == EventDataType.Score && s.UserId == user.UserId);
+        this.SaveChanges();
+
+        foreach (GameScore score in scores)
         {
-            foreach (GameScore score in scores)
-            {
-                IQueryable<Event> scoreEvents = this.Events
-                    .Where(e => e.StoredDataType == EventDataType.Score && e.StoredObjectId == score.ScoreId);
-                
-                this.Events.RemoveRange(scoreEvents);
-                this.GameScores.Remove(score);
-            }
-        });
+            this.RecalculateScoreStatistics(score.LevelId, score.ScoreType, false);
+        }
+        this.SaveChanges();
     }
 
     public IEnumerable<GameUser> GetPlayersFromScore(GameScore score)

Refresh.Database/GameDatabaseContext.Statistics.cs

@@ -1,8 +1,10 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using Refresh.Common;
 using Refresh.Common.Constants;
 using Refresh.Database.Models.Comments;
 using Refresh.Database.Models.Levels;
+using Refresh.Database.Models.Levels.Scores;
 using Refresh.Database.Models.Playlists;
 using Refresh.Database.Models.Statistics;
 using Refresh.Database.Models.Users;
@@ -214,6 +216,50 @@ private void MarkLevelStatisticsDirty(GameLevel level)
     }
     #endregion
 
+    #region Level Scores
+
+    public void RecalculateScoreStatistics(int levelId, byte scoreType, bool saveChanges = true)
+    {
+        List<GameScore> scores = this.GameScores
+            .Where(s => s.LevelId == levelId && s.ScoreType == scoreType)
+            .OrderByDescending(s => s.Score)
+            .ToList();
+        
+        // Step 1: Reset all ranks
+        foreach (GameScore score in scores)
+        {
+            score.Rank = 0;
+        }
+        
+        // Step 2: Assign ranks to high scores
+        // Exclude all scores which are not high scores now
+        int rank = 1;
+        int? previousScore = null;
+        foreach (GameScore score in scores.DistinctBy(s => s.PublisherId).ToList())
+        {
+            // Scores with the same value should have the same rank.
+            // Increment rank if there was a previous score and it was higher.
+            if (previousScore != null && previousScore > score.Score)
+                rank++;
+
+            score.Rank = rank;
+            previousScore = score.Score;
+        }
+
+        if (saveChanges) this.SaveChanges();
+    }
+
+    public void RecalculateScoreStatistics(GameLevel level, bool saveChanges = true)
+    {
+        this.RecalculateScoreStatistics(level.LevelId, 1, false);
+        this.RecalculateScoreStatistics(level.LevelId, 2, false);
+        this.RecalculateScoreStatistics(level.LevelId, 3, false);
+        this.RecalculateScoreStatistics(level.LevelId, 4, false);
+        if (saveChanges) this.SaveChanges();
+    }
+    
+    #endregion
+
     #region Users
 
     internal const int UserStatisticsVersion = 2;

Refresh.Database/Migrations/20260306091826_CacheScoreRanks.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Refresh.Database.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(GameDatabaseContext))]
+    [Migration("20260306091826_CacheScoreRanks")]
+    public partial class CacheScoreRanks : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "Rank",
+                table: "GameScores",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Rank",
+                table: "GameScores");
+        }
+    }
+}

Refresh.Database/Migrations/GameDatabaseContextModelSnapshot.cs

@@ -578,6 +578,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<int>("Rank")
+                        .HasColumnType("integer");
+
                     b.Property<int>("Score")
                         .HasColumnType("integer");