diff --git a/Directory.Build.props b/Directory.Build.props
index 6f1b404c..9f7d3707 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -5,10 +5,10 @@
1
0
- 8
- 5
- 7
- 10
+ 9
+ 6
+ 8
+ 11
$(DsstatsVersionMajor).$(DsstatsParserLine)
$(DsstatsVersionBase).$(DsstatsParserPatch)
diff --git a/src/common/dsstats.weblib/Replays/ReplaysComponent.razor b/src/common/dsstats.weblib/Replays/ReplaysComponent.razor
index df4244a0..1a2ac9a7 100644
--- a/src/common/dsstats.weblib/Replays/ReplaysComponent.razor
+++ b/src/common/dsstats.weblib/Replays/ReplaysComponent.razor
@@ -183,7 +183,8 @@
{
SetReplayUserRatingRequestOptions();
replaysCount = await ReplayRepository.GetReplaysCount(ReplaysRequest);
- ReplaysRequest.Page = 1;
+ var totalPages = Math.Max(1, (int)Math.Ceiling((double)replaysCount / ReplaysRequest.PageSize));
+ ReplaysRequest.Page = Math.Clamp(ReplaysRequest.Page, 1, totalPages);
if (virtualizeComponent != null && replaysCount > 0)
{
await virtualizeComponent.RefreshDataAsync();
@@ -199,13 +200,20 @@
private async ValueTask> LoadReplays(ItemsProviderRequest request)
{
- var numReplays = Math.Min(request.Count, replaysCount - request.StartIndex);
+ var pageCount = Math.Min(ReplaysRequest.PageSize,
+ Math.Max(0, replaysCount - (ReplaysRequest.Page - 1) * ReplaysRequest.PageSize));
+ var numReplays = Math.Min(request.Count, Math.Max(0, pageCount - request.StartIndex));
+ if (numReplays == 0)
+ {
+ latestResponse = [];
+ return new ItemsProviderResult([], pageCount);
+ }
ReplaysRequest.Skip = request.StartIndex;
ReplaysRequest.Take = numReplays;
SetReplayUserRatingRequestOptions();
var replays = await ReplayRepository.GetReplays(ReplaysRequest, request.CancellationToken);
latestResponse = replays;
- return new ItemsProviderResult(replays, Math.Min(replaysCount, ReplaysRequest.PageSize));
+ return new ItemsProviderResult(replays, pageCount);
}
private async Task SortList(MouseEventArgs e, string column)
@@ -234,6 +242,7 @@
Ascending = exOrder == null ? false : !exOrder.Ascending
});
}
+ ReplaysRequest.Page = 1;
await Reload();
}
diff --git a/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor b/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor
index fb29fb55..a3b2c997 100644
--- a/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor
+++ b/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor
@@ -153,18 +153,21 @@
private void FieldChanged(object? sender, FieldChangedEventArgs e)
{
+ Request.Page = 1;
OnRequestChanged.InvokeAsync();
}
private void ClearCommanders()
{
Request.Commander = string.Empty;
+ Request.Page = 1;
OnRequestChanged.InvokeAsync();
}
private void ClearNames()
{
Request.Name = string.Empty;
+ Request.Page = 1;
OnRequestChanged.InvokeAsync();
}
@@ -175,6 +178,7 @@
Request.LinkCommanders = false;
replayFiliterModal?.filter.Reset();
Request.Filter = null;
+ Request.Page = 1;
OnRequestChanged.InvokeAsync();
}
@@ -247,6 +251,7 @@
private void FilterRequest(ReplaysFilter? filter)
{
Request.Filter = filter;
+ Request.Page = 1;
OnRequestChanged.InvokeAsync();
}
diff --git a/src/server/dsstats.api/Services/TransitionService.cs b/src/server/dsstats.api/Services/TransitionService.cs
index 41751479..067f405e 100644
--- a/src/server/dsstats.api/Services/TransitionService.cs
+++ b/src/server/dsstats.api/Services/TransitionService.cs
@@ -162,6 +162,8 @@ private async Task DeleteReplay(string replayHash, DsstatsContext context)
{
return;
}
+ // The optional upgrade relationship otherwise leaves rows with a null ReplayPlayerId.
+ context.PlayerUpgrades.RemoveRange(replay.Players.SelectMany(player => player.Upgrades));
context.Replays.Remove(replay);
await context.SaveChangesAsync();
logger.LogWarning($"Deleted replay {replayHash}");
diff --git a/src/server/dsstats.dbServices/ImportService.Duplicates.cs b/src/server/dsstats.dbServices/ImportService.Duplicates.cs
index c061a956..01206f29 100644
--- a/src/server/dsstats.dbServices/ImportService.Duplicates.cs
+++ b/src/server/dsstats.dbServices/ImportService.Duplicates.cs
@@ -120,6 +120,8 @@ private static async Task DeleteReplay(string replayHash, DsstatsContext context
if (replay is not null)
{
+ // The optional upgrade relationship otherwise leaves rows with a null ReplayPlayerId.
+ context.PlayerUpgrades.RemoveRange(replay.Players.SelectMany(player => player.Upgrades));
context.Replays.Remove(replay);
await context.SaveChangesAsync();
}
diff --git a/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs b/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs
new file mode 100644
index 00000000..82d6e75d
--- /dev/null
+++ b/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs
@@ -0,0 +1,206 @@
+using dsstats.api.Services;
+using dsstats.db;
+using dsstats.dbServices;
+using dsstats.shared;
+using dsstats.shared.Interfaces;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+
+namespace dsstats.tests;
+
+[TestClass]
+public sealed class ImportServiceDuplicatesTests
+{
+ [TestMethod]
+ public async Task LongerReplayReplacementDeletesOldUpgradesAndPreservesOtherReplays()
+ {
+ await using var fixture = await Fixture.Create();
+ var original = CreateReplay("Direct Strike", 800, 100);
+ var unrelated = CreateReplay("Another match", 900, 300, dayOffset: 1);
+ await fixture.Importer.InsertReplays([original, unrelated]);
+ var oldUpgrades = await fixture.Upgrades(original.ComputeHash());
+ var unrelatedUpgrades = await fixture.Upgrades(unrelated.ComputeHash());
+
+ var replacement = CreateReplay("Direct Strike", 900, 200);
+ await fixture.Importer.InsertReplays([replacement]);
+
+ await fixture.AssertDeleted(oldUpgrades);
+ CollectionAssert.AreEqual(unrelatedUpgrades, await fixture.Upgrades(unrelated.ComputeHash()));
+ var replacementUpgrades = await fixture.Upgrades(replacement.ComputeHash());
+ CollectionAssert.AreEquivalent(new[] { 201, 202, 203, 204, 301, 302, 303, 304 },
+ replacementUpgrades.Select(x => x.Gameloop).ToArray());
+ await fixture.AssertIntact(replays: 2, upgrades: 16);
+ }
+
+ [TestMethod]
+ public async Task CandidateDeduplicationDeletesOnlyDiscardedReplaysUpgrades()
+ {
+ await using var fixture = await Fixture.Create();
+ var keeper = CreateReplay("Keeper", 900, 200);
+ var duplicate = CreateReplay("Duplicate", 800, 100);
+ var unrelated = CreateReplay("Another match", 900, 300, dayOffset: 1);
+ await fixture.Importer.InsertReplays([keeper, duplicate, unrelated]);
+ var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash());
+ var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash());
+ var unrelatedUpgrades = await fixture.Upgrades(unrelated.ComputeHash());
+
+ await fixture.Importer.CheckDuplicateCandidates();
+ await fixture.Importer.CheckDuplicateCandidates();
+
+ await fixture.AssertDeleted(duplicateUpgrades);
+ CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(keeper.ComputeHash()));
+ CollectionAssert.AreEqual(unrelatedUpgrades, await fixture.Upgrades(unrelated.ComputeHash()));
+ await fixture.AssertIntact(replays: 2, upgrades: 16);
+ }
+
+ [TestMethod]
+ [DataRow(800)]
+ [DataRow(900)]
+ public async Task IgnoredDuplicatePreservesStoredUpgrades(int incomingDuration)
+ {
+ await using var fixture = await Fixture.Create();
+ var keeper = CreateReplay("Direct Strike", 900, 200);
+ await fixture.Importer.InsertReplays([keeper]);
+ var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash());
+
+ await fixture.Importer.InsertReplays([CreateReplay("Direct Strike", incomingDuration, 100)]);
+
+ CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(keeper.ComputeHash()));
+ await fixture.AssertIntact(replays: 1, upgrades: 8);
+ }
+
+ [TestMethod]
+ public async Task HashTransitionDeduplicationDeletesDiscardedUpgrades()
+ {
+ await using var fixture = await Fixture.Create();
+ var keeper = CreateReplay(string.Empty, 900, 200);
+ var duplicate = CreateReplay("Legacy title", 800, 100);
+ await fixture.Importer.InsertReplays([keeper, duplicate]);
+ var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash());
+ var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash());
+ var transition = new TransitionService(fixture.Factory, NullLogger.Instance);
+
+ await transition.FixHashes();
+
+ await fixture.AssertDeleted(duplicateUpgrades);
+ // Hash repair can also rename the keeper's hash; its owned rows must remain unchanged.
+ await using var context = await fixture.Factory.CreateDbContextAsync();
+ var survivor = await context.Replays.SingleAsync();
+ Assert.AreEqual(900, survivor.Duration);
+ CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(survivor.ReplayHash));
+ await fixture.AssertIntact(replays: 1, upgrades: 8);
+ }
+
+ [TestMethod]
+ public async Task FailedReplayDeletionRollsBackUpgradeDeletion()
+ {
+ await using var fixture = await Fixture.Create();
+ var keeper = CreateReplay("Keeper", 900, 200);
+ var duplicate = CreateReplay("Duplicate", 800, 100);
+ await fixture.Importer.InsertReplays([keeper, duplicate]);
+ var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash());
+ await using (var context = await fixture.Factory.CreateDbContextAsync())
+ {
+ await context.Database.ExecuteSqlRawAsync("""
+ CREATE TRIGGER BlockReplayDeletion BEFORE DELETE ON Replays
+ BEGIN SELECT RAISE(ABORT, 'Deletion blocked for rollback test'); END;
+ """);
+ }
+
+ await Assert.ThrowsExactlyAsync(() => fixture.Importer.CheckDuplicateCandidates());
+
+ CollectionAssert.AreEqual(duplicateUpgrades, await fixture.Upgrades(duplicate.ComputeHash()));
+ await fixture.AssertIntact(replays: 2, upgrades: 16);
+ }
+
+ private sealed record UpgradeSnapshot(int Id, int? ReplayPlayerId, int UpgradeId, int Gameloop);
+
+ private sealed class Fixture(SqliteConnection connection, ServiceProvider services) : IAsyncDisposable
+ {
+ public IDbContextFactory Factory { get; } = services.GetRequiredService>();
+ public IImportService Importer { get; } = services.GetRequiredService();
+
+ public static async Task Create()
+ {
+ var connection = new SqliteConnection("Filename=:memory:");
+ await connection.OpenAsync();
+ var services = new ServiceCollection().AddLogging()
+ .AddDbContextFactory(o => o.UseSqlite(connection,
+ options => options.MigrationsAssembly("dsstats.migrations.sqlite")))
+ .AddSingleton(Mock.Of())
+ .AddSingleton()
+ .BuildServiceProvider();
+ var fixture = new Fixture(connection, services);
+ await using var context = await fixture.Factory.CreateDbContextAsync();
+ await context.Database.MigrateAsync();
+ return fixture;
+ }
+
+ public async Task Upgrades(string replayHash)
+ {
+ await using var context = await Factory.CreateDbContextAsync();
+ var upgrades = await context.ReplayPlayers.Where(p => p.Replay!.ReplayHash == replayHash)
+ .SelectMany(p => p.Upgrades).OrderBy(u => u.PlayerUpgradeId)
+ .Select(u => new UpgradeSnapshot(u.PlayerUpgradeId, EF.Property(u, "ReplayPlayerId"), u.UpgradeId, u.Gameloop))
+ .ToArrayAsync();
+ Assert.HasCount(8, upgrades);
+ return upgrades;
+ }
+
+ public async Task AssertDeleted(UpgradeSnapshot[] deleted)
+ {
+ await using var context = await Factory.CreateDbContextAsync();
+ var ids = deleted.Select(x => x.Id).ToArray();
+ Assert.AreEqual(0, await context.PlayerUpgrades.CountAsync(u => ids.Contains(u.PlayerUpgradeId)),
+ "Discarded upgrades must be deleted, not detached from their replay players.");
+ }
+
+ public async Task AssertIntact(int replays, int upgrades)
+ {
+ await using var context = await Factory.CreateDbContextAsync();
+ Assert.AreEqual(replays, await context.Replays.CountAsync());
+ Assert.AreEqual(replays * 4, await context.ReplayPlayers.CountAsync());
+ Assert.AreEqual(upgrades, await context.PlayerUpgrades.CountAsync());
+ Assert.AreEqual(0, await context.PlayerUpgrades.CountAsync(u =>
+ !context.ReplayPlayers.Any(p => p.ReplayPlayerId == EF.Property(u, "ReplayPlayerId"))),
+ "Every surviving upgrade must still belong to a replay player.");
+ Assert.AreEqual(2, await context.Upgrades.CountAsync(), "Shared upgrade definitions must survive deduplication.");
+ }
+
+ public async ValueTask DisposeAsync()
+ {
+ await services.DisposeAsync();
+ await connection.DisposeAsync();
+ }
+ }
+
+ private static ReplayDto CreateReplay(string title, int duration, int upgradeGameloop, int dayOffset = 0) => new()
+ {
+ Title = title,
+ Version = "5.0.14",
+ GameMode = GameMode.Standard,
+ RegionId = 1,
+ Gametime = new DateTime(2026, 5, 23, 12, 0, 0, DateTimeKind.Utc).AddDays(dayOffset),
+ Duration = duration,
+ WinnerTeam = 1,
+ Players = Enumerable.Range(1, 4).Select(pos => new ReplayPlayerDto
+ {
+ Name = $"Player{pos}",
+ Race = Commander.Terran,
+ SelectedRace = Commander.Terran,
+ GamePos = pos,
+ TeamId = pos <= 2 ? 1 : 2,
+ Result = pos <= 2 ? PlayerResult.Win : PlayerResult.Los,
+ Duration = duration,
+ Player = new() { Name = $"Player{pos}", ToonId = new() { Region = 1, Realm = 1, Id = pos } },
+ Upgrades =
+ [
+ new() { Name = "TerranInfantryWeaponsLevel1", Gameloop = upgradeGameloop + pos },
+ new() { Name = "TerranInfantryArmorsLevel1", Gameloop = upgradeGameloop + pos + 100 }
+ ]
+ }).ToList()
+ };
+}
diff --git a/src/tests/dsstats.tests/ReplayPagination.Tests.cs b/src/tests/dsstats.tests/ReplayPagination.Tests.cs
new file mode 100644
index 00000000..90afd9f4
--- /dev/null
+++ b/src/tests/dsstats.tests/ReplayPagination.Tests.cs
@@ -0,0 +1,154 @@
+using dsstats.shared;
+using dsstats.shared.Interfaces;
+using dsstats.weblib.Replays;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.AspNetCore.Components.Web.Virtualization;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.JSInterop;
+using Moq;
+
+namespace dsstats.tests;
+
+[TestClass]
+public class ReplayPaginationTests
+{
+ [TestMethod]
+ public async Task PageChangeSurvivesReloadAndLoadsDifferentReplays()
+ {
+ await using var fixture = new Fixture();
+ await fixture.Render();
+ var first = await fixture.Load(0, 50);
+
+ fixture.Request.Page = 2;
+ await fixture.Reload();
+ var second = await fixture.Load(0, 50);
+
+ Assert.AreEqual(2, fixture.Request.Page);
+ Assert.AreEqual(10, second.TotalItemCount);
+ Assert.HasCount(10, second.Items);
+ Assert.AreEqual("replay-0", first.Items.First().ReplayHash);
+ Assert.AreEqual("replay-10", second.Items.First().ReplayHash);
+ Assert.AreEqual((2, 0, 10), fixture.Reads.Last());
+
+ fixture.Request.Page = 1;
+ await fixture.Reload();
+ Assert.AreEqual("replay-0", (await fixture.Load(0, 50)).Items.First().ReplayHash);
+ }
+
+ [TestMethod]
+ public async Task LastPageUsesRemainingCountAndDoesNotReadPastItsEnd()
+ {
+ await using var fixture = new Fixture();
+ await fixture.Render();
+ fixture.Request.Page = 3;
+ await fixture.Reload();
+
+ var remaining = await fixture.Load(1, 50);
+ Assert.AreEqual(3, remaining.TotalItemCount);
+ CollectionAssert.AreEqual(new[] { "replay-21", "replay-22" },
+ remaining.Items.Select(x => x.ReplayHash).ToArray());
+ Assert.AreEqual((3, 1, 2), fixture.Reads.Single());
+
+ var pastEnd = await fixture.Load(10, 50);
+ Assert.AreEqual(3, pastEnd.TotalItemCount);
+ Assert.IsEmpty(pastEnd.Items);
+ Assert.HasCount(1, fixture.Reads);
+ }
+
+ [TestMethod]
+ [DataRow(12, 2)]
+ [DataRow(0, 1)]
+ public async Task ReloadClampsPageWhenReplaysAreRemoved(int count, int expectedPage)
+ {
+ await using var fixture = new Fixture();
+ await fixture.Render();
+ fixture.Request.Page = 3;
+ fixture.Count = count;
+
+ await fixture.Reload();
+
+ Assert.AreEqual(expectedPage, fixture.Request.Page);
+ }
+
+#pragma warning disable BL0006 // Inspect the real callbacks while omitting modal/JS rendering, as in the lifecycle tests.
+ private sealed class Fixture : IAsyncDisposable
+ {
+ private readonly ServiceProvider services;
+ private readonly PaginationRenderer renderer;
+ public ReplaysRequest Request { get; } = new() { PageSize = 10 };
+ public int Count { get; set; } = 23;
+ public List<(int Page, int Skip, int Take)> Reads { get; } = [];
+
+ public Fixture()
+ {
+ var repository = new Mock();
+ repository.Setup(x => x.GetReplaysCount(It.IsAny(), It.IsAny()))
+ .ReturnsAsync(() => Count);
+ repository.Setup(x => x.GetReplays(It.IsAny(), It.IsAny()))
+ .ReturnsAsync((ReplaysRequest request, CancellationToken _) =>
+ {
+ Reads.Add((request.Page, request.Skip, request.Take));
+ int offset = (request.Page - 1) * request.PageSize + request.Skip;
+ return Enumerable.Range(offset, Math.Max(0, Math.Min(request.Take, Count - offset)))
+ .Select(i => new ReplayListDto { ReplayHash = $"replay-{i}" }).ToList();
+ });
+ services = new ServiceCollection().AddLogging().AddOptions()
+ .AddSingleton(repository.Object).AddSingleton(Mock.Of()).BuildServiceProvider();
+ renderer = new PaginationRenderer(services);
+ }
+
+ public Task Render() => renderer.Dispatcher.InvokeAsync(() => renderer.Render(Request));
+ public Task Reload() => renderer.Dispatcher.InvokeAsync(() => renderer.Component.Reload.InvokeAsync());
+ public Task> Load(int start, int count) =>
+ renderer.Dispatcher.InvokeAsync(() => renderer.Component.Provider!(new(start, count, default)).AsTask());
+
+ public async ValueTask DisposeAsync()
+ {
+ await renderer.DisposeAsync();
+ await services.DisposeAsync();
+ }
+ }
+
+ public sealed class HeadlessReplays : ReplaysComponent
+ {
+ public EventCallback Reload { get; private set; }
+ public ItemsProviderDelegate? Provider { get; private set; }
+
+ protected override void BuildRenderTree(RenderTreeBuilder builder)
+ {
+ using var tree = new RenderTreeBuilder();
+ base.BuildRenderTree(tree);
+ var frames = tree.GetFrames();
+ for (int i = 0; i < frames.Count; i++)
+ {
+ var frame = frames.Array[i];
+ if (frame.FrameType != RenderTreeFrameType.Attribute) continue;
+ if (frame.AttributeName == nameof(ReplaysRequestComponent.OnRequestChanged))
+ Reload = (EventCallback)frame.AttributeValue;
+ if (frame.AttributeName == "ItemsProvider")
+ Provider = (ItemsProviderDelegate)frame.AttributeValue;
+ }
+ }
+ }
+
+ private sealed class PaginationRenderer : Renderer
+ {
+ private readonly int componentId;
+ public HeadlessReplays Component { get; }
+ public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
+ public PaginationRenderer(IServiceProvider services) : base(services, services.GetRequiredService())
+ {
+ Component = (HeadlessReplays)InstantiateComponent(typeof(HeadlessReplays));
+ componentId = AssignRootComponentId(Component);
+ }
+
+ public Task Render(ReplaysRequest request) => RenderRootComponentAsync(componentId,
+ ParameterView.FromDictionary(new Dictionary { [nameof(ReplaysComponent.ReplaysRequest)] = request }));
+ protected override void HandleException(Exception exception) => throw new InvalidOperationException("Replay rendering failed.", exception);
+ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch) => Task.CompletedTask;
+ }
+#pragma warning restore BL0006
+}