v3.18.2 (#419)

* Fix an issue that prevented bonuses from being included in 'advanced' score.

* Fix advance bonuses

* Add game cache invalidate on rerank

src/Gameboard.Api/Features/Game/GameController.cs

@@ -240,13 +240,12 @@ public async Task<ActionResult<UploadedFile>> DeleteImage([FromRoute] string id,
         [Authorize(AppConstants.AdminPolicy)]
         public async Task Rerank([FromRoute] string id, CancellationToken cancellationToken)
         {
-            AuthorizeAny(
-                () => Actor.IsDesigner
-            );
+            AuthorizeAny(() => Actor.IsDesigner);
 
             await Validate(new Entity { Id = id });
             await GameService.ReRank(id);
             await _scoreDenormalization.DenormalizeGame(id, cancellationToken);
+            await _mediator.Publish(new GameCacheInvalidateCommand(id));
         }
     }
 }

src/Gameboard.Api/Features/Game/Notifications/GameCacheInvalidateNotification.cs

@@ -0,0 +1,5 @@
+using MediatR;
+
+namespace Gameboard.Api.Features.Games;
+
+public record GameCacheInvalidateCommand(string GameId) : INotification;

src/Gameboard.Api/Features/Hubs/GameHub/GameHubService.cs

@@ -13,7 +13,7 @@
 
 namespace Gameboard.Api.Features.Games;
 
-public interface IGameHubService : INotificationHandler<GameEnrolledPlayersChangeNotification>, INotificationHandler<AppStartupNotification>
+public interface IGameHubService : INotificationHandler<GameEnrolledPlayersChangeNotification>, INotificationHandler<AppStartupNotification>, INotificationHandler<GameCacheInvalidateCommand>
 {
     // invoke functions on clients
     Task SendExternalGameChallengesDeployStart(GameStartUpdate state);
@@ -230,11 +230,14 @@ public async Task Handle(AppStartupNotification appStartupNotification, Cancella
             .ToArrayAsync(cancellationToken);
 
         foreach (var game in games)
-            await UpdateGameIdUserIdsMap(new GameEnrolledPlayersChangeNotification(new GameEnrolledPlayersChangeContext(game.Id, game.RequireSynchronizedStart)));
+            await UpdateGameIdUserIdsMap(game.Id);
     }
 
+    public Task Handle(GameCacheInvalidateCommand notification, CancellationToken cancellationToken)
+        => UpdateGameIdUserIdsMap(notification.GameId);
+
     public Task Handle(GameEnrolledPlayersChangeNotification notification, CancellationToken cancellationToken)
-        => UpdateGameIdUserIdsMap(notification);
+        => UpdateGameIdUserIdsMap(notification.Context.GameId);
 
     private IEnumerable<string> GetGameUserIds(string gameId)
     {
@@ -245,21 +248,21 @@ private IEnumerable<string> GetGameUserIds(string gameId)
         return userIds;
     }
 
-    private async Task UpdateGameIdUserIdsMap(GameEnrolledPlayersChangeNotification notification)
+    private async Task UpdateGameIdUserIdsMap(string gameId)
     {
         var gameUsers = await _store
             .WithNoTracking<Data.Player>()
             .Where(p => p.Game.GameEnd != DateTimeOffset.MinValue || p.Game.GameEnd > _now.Get())
             .Where(p => p.Game.PlayerMode == PlayerMode.Competition && p.Mode == PlayerMode.Competition)
-            .Where(p => p.GameId == notification.Context.GameId)
+            .Where(p => p.GameId == gameId)
             .Select(p => p.UserId)
             .Distinct()
             .ToArrayAsync();
 
         lock (_gameIdUserIdsMap)
         {
-            _gameIdUserIdsMap.TryRemove(notification.Context.GameId, out var existingValue);
-            _gameIdUserIdsMap.TryAdd(notification.Context.GameId, gameUsers);
+            _gameIdUserIdsMap.TryRemove(gameId, out var existingValue);
+            _gameIdUserIdsMap.TryAdd(gameId, gameUsers);
         }
     }
 }