DB leaderboards

ReplayBrowser/Data/Migrations/20241111013501_DbLeaderboards.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Server.Migrations
+{
+    /// <inheritdoc />
+    public partial class DbLeaderboards : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "LeaderboardDefinitions",
+                columns: table => new
+                {
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    TrackedData = table.Column<string>(type: "text", nullable: false),
+                    ExtraInfo = table.Column<string>(type: "text", nullable: true),
+                    NameColumn = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LeaderboardDefinitions", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Leaderboards",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Servers = table.Column<List<string>>(type: "text[]", nullable: false),
+                    Count = table.Column<int>(type: "integer", nullable: false),
+                    Position = table.Column<int>(type: "integer", nullable: false),
+                    PlayerGuid = table.Column<Guid>(type: "uuid", nullable: true),
+                    Username = table.Column<string>(type: "text", nullable: false),
+                    LeaderboardDefinitionName = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Leaderboards", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Leaderboards_LeaderboardDefinitions_LeaderboardDefinitionNa~",
+                        column: x => x.LeaderboardDefinitionName,
+                        principalTable: "LeaderboardDefinitions",
+                        principalColumn: "Name",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Leaderboards_LeaderboardDefinitionName",
+                table: "Leaderboards",
+                column: "LeaderboardDefinitionName");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Leaderboards");
+
+            migrationBuilder.DropTable(
+                name: "LeaderboardDefinitions");
+        }
+    }
+}

ReplayBrowser/Data/Migrations/ReplayDbContextModelSnapshot.cs

@@ -301,6 +301,63 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("JobDepartments");
                 });
 
+            modelBuilder.Entity("ReplayBrowser.Data.Models.LeaderboardDefinition", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraInfo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameColumn")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TrackedData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("LeaderboardDefinitions");
+                });
+
+            modelBuilder.Entity("ReplayBrowser.Data.Models.LeaderboardPosition", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LeaderboardDefinitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("PlayerGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<List<string>>("Servers")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LeaderboardDefinitionName");
+
+                    b.ToTable("Leaderboards");
+                });
+
             modelBuilder.Entity("ReplayBrowser.Data.Models.Notice", b =>
                 {
                     b.Property<int?>("Id")
@@ -585,6 +642,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasForeignKey("CollectedPlayerDataPlayerGuid");
                 });
 
+            modelBuilder.Entity("ReplayBrowser.Data.Models.LeaderboardPosition", b =>
+                {
+                    b.HasOne("ReplayBrowser.Data.Models.LeaderboardDefinition", "LeaderboardDefinition")
+                        .WithMany()
+                        .HasForeignKey("LeaderboardDefinitionName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LeaderboardDefinition");
+                });
+
             modelBuilder.Entity("ReplayBrowser.Data.Models.Player", b =>
                 {
                     b.HasOne("ReplayBrowser.Data.Models.JobDepartment", "EffectiveJob")

ReplayBrowser/Data/Models/LeaderboardDefinition.cs

@@ -0,0 +1,27 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ReplayBrowser.Data.Models;
+
+public class LeaderboardDefinition  : IEntityTypeConfiguration<LeaderboardDefinition>
+{
+    public required string Name { get; set; }
+
+    /// <summary>
+    /// The text that will appear for the "Count" column.
+    /// </summary>
+    public required string TrackedData { get; set; }
+
+    /// <summary>
+    /// Will be displayed in a small font below the name.
+    /// </summary>
+    public string? ExtraInfo { get; set; }
+    public string NameColumn { get; set; } = "Player Name";
+
+    public void Configure(EntityTypeBuilder<LeaderboardDefinition> builder)
+    {
+        builder.HasKey(x => x.Name);
+        builder.Property(x => x.TrackedData).IsRequired();
+        builder.Property(x => x.NameColumn).IsRequired();
+    }
+}

ReplayBrowser/Data/Models/LeaderboardPosition.cs

@@ -0,0 +1,54 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ReplayBrowser.Data.Models;
+
+public class LeaderboardPosition : IEntityTypeConfiguration<LeaderboardPosition>
+{
+    public int Id { get; set; }
+
+    /// <summary>
+    /// The servers that this position is for.
+    /// </summary>
+    public required List<string> Servers { get; set; } = null!;
+
+    /// <summary>
+    /// The number next to the position. For example "most times played" would be a count of how many times the player has played.
+    /// </summary>
+    public required int Count { get; set; }
+
+    /// <summary>
+    /// The position of the player in the leaderboard.
+    /// </summary>
+    public int Position { get; set; }
+
+    /// <summary>
+    /// The GUID of the player. If null, position is not for a player, but rather a general statistic.
+    /// </summary>
+    public Guid? PlayerGuid { get; set; }
+
+    /// <summary>
+    /// The display value of the player or statistic.
+    /// </summary>
+    public string Username { get; set; } = null!;
+
+
+    public string LeaderboardDefinitionName { get; set; } = null!;
+    public LeaderboardDefinition LeaderboardDefinition { get; set; } = null!;
+
+
+
+    public void Configure(EntityTypeBuilder<LeaderboardPosition> builder)
+    {
+        builder.HasOne(lp => lp.LeaderboardDefinition)
+            .WithMany()
+            .HasForeignKey(lp => lp.LeaderboardDefinitionName);
+
+        builder.HasKey(x => x.Id);
+        builder.Property(x => x.Servers).IsRequired();
+        builder.Property(x => x.Count).IsRequired();
+        builder.Property(x => x.Position).IsRequired();
+        builder.Property(x => x.PlayerGuid).IsRequired(false);
+        builder.Property(x => x.Username).IsRequired();
+    }
+}

ReplayBrowser/Data/ReplayDbContext.cs

@@ -49,4 +49,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
     public DbSet<ReplayParticipant> ReplayParticipants { get; set; }
 
     public DbSet<ServerToken> ServerTokens { get; set; }
+
+    public DbSet<LeaderboardPosition> Leaderboards { get; set; }
+    public DbSet<LeaderboardDefinition> LeaderboardDefinitions { get; set; }
 }

ReplayBrowser/Models/LeaderboardData.cs

@@ -3,13 +3,6 @@
 
 namespace ReplayBrowser.Models;
 
-public class LeaderboardData
-{
-    public bool IsCache { get; set; } = false;
-
-    public List<Leaderboard> Leaderboards { get; set; } = null!;
-}
-
 public class PlayerCount
 {
     public PlayerData? Player { get; set; }

ReplayBrowser/Pages/Leaderboard.razor

@@ -1,4 +1,5 @@
 @page "/leaderboard"
+@using Humanizer
 @using Microsoft.AspNetCore.Components.Authorization
 @using ReplayBrowser.Models
 @using ReplayBrowser.Services
@@ -20,6 +21,14 @@
 
 <PageTitle>Leaderboard</PageTitle>
 <h4>Leaderboards</h4>
+<em>Leaderboards update every 24 hours.</em>
+@if(LeaderboardService.IsUpdating) {
+    <div class="alert alert-warning" role="alert">
+        <p>The leaderboards are currently updating. This may take a while. Please be patient.</p>
+        <em>Update started: @LeaderboardService.UpdateStarted.Humanize(utcDate: true). Current progress: @LeaderboardService.UpdateProgress / @LeaderboardService.UpdateTotal</em>
+    </div>
+}
+
 @if(RequestedPrivate)
 {
     <div class="alert alert-danger" role="alert">
@@ -105,7 +114,14 @@ else
 
     <hr/>
 
-    @foreach (var leaderboard in LeaderboardData.Leaderboards)
+    @if(LeaderboardData.Length == 0)
+    {
+        <div class="alert alert-warning" role="alert">
+            <p>No data was found for the selected servers and time range. Data is probably still collected and calculated. Please try again later. This will take a long time.</p>
+        </div>
+    }
+
+    @foreach (var leaderboard in LeaderboardData)
     {
         <h4>@leaderboard.Name</h4>
         if (leaderboard.ExtraInfo != null)
@@ -233,7 +249,7 @@ else
 
 @code{
     private bool IsLoading { get; set; } = true;
-    private LeaderboardData? LeaderboardData { get; set; } = null;
+    private Models.Leaderboard[]? LeaderboardData { get; set; } = null;
     private bool RequestedPrivate { get; set; } = false;
 
     protected override async Task OnInitializedAsync()
@@ -267,7 +283,7 @@ else
             }
         }
 
-        LeaderboardData? leaderboard = null;
+        Models.Leaderboard[]? leaderboard = null;
         var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
         try
         {
@@ -279,7 +295,7 @@ else
             }
 
             var selectedServersArray = selectedServers.Split(',');
-            leaderboard = await LeaderboardService.GetLeaderboard(timeRangeEnum, username, selectedServersArray, authState, entries);
+            leaderboard = await LeaderboardService.GetLeaderboards(timeRangeEnum, username, selectedServersArray, authState, entries);
         }
         catch (UnauthorizedAccessException)
         {