feat: Refactor player intelligence data handling and improve AJAX response structure

Author: frasermolyneux

src/XtremeIdiots.Portal.Web.Tests/ApiControllers/DataControllerTests.cs

@@ -81,21 +81,6 @@ public void Constructor_WithNullConfiguration_ThrowsArgumentNullException()
                 null!));
     }
 
-    [Fact]
-    public async Task GetPlayersAjax_WithEmptyBody_ReturnsBadRequest()
-    {
-        // Arrange - empty body causes deserialization to return null model,
-        // which triggers BadRequest from the null model guard
-        var sut = CreateSut();
-        sut.HttpContext.Request.Body = new MemoryStream();
-
-        // Act
-        var result = await sut.GetPlayersAjax(null, null);
-
-        // Assert
-        Assert.IsType<BadRequestResult>(result);
-    }
-
     [Fact]
     public async Task GetMapListAjax_WithEmptyBody_ReturnsBadRequest()
     {

src/XtremeIdiots.Portal.Web/ApiControllers/DataController.cs

@@ -36,20 +36,6 @@ public class DataController(
     IConfiguration configuration) : BaseApiController(telemetryClient, logger, configuration)
 {
 
-    /// <summary>
-    /// Retrieves players data for DataTables AJAX requests with username and GUID filtering
-    /// </summary>
-    /// <param name="id">Optional game type to filter players by</param>
-    /// <param name="cancellationToken">Cancellation token for the async operation</param>
-    /// <returns>DataTables-compatible JSON response with player data</returns>
-    [HttpPost("Players/GetPlayersAjax")]
-    [Authorize(Policy = AuthPolicies.AccessPlayers)]
-    public async Task<IActionResult> GetPlayersAjax(GameType? id, [FromQuery] PlayersFilter? playersFilter, CancellationToken cancellationToken = default)
-    {
-        var filter = playersFilter ?? PlayersFilter.UsernameAndGuid;
-        return await GetPlayersAjaxPrivate(filter, id, cancellationToken).ConfigureAwait(false);
-    }
-
     /// <summary>
     /// Retrieves maps data for DataTables AJAX requests with sorting and filtering support
     /// </summary>
@@ -176,69 +162,4 @@ public async Task<IActionResult> GetUsersAjax(CancellationToken cancellationToke
         }, nameof(GetUsersAjax)).ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// Private helper method to handle different types of player AJAX requests with filtering and sorting
-    /// </summary>
-    /// <param name="filter">The filter type to apply to player queries</param>
-    /// <param name="gameType">Optional game type to filter players by</param>
-    /// <param name="cancellationToken">Cancellation token for the async operation</param>
-    /// <returns>DataTables-compatible JSON response with filtered player data</returns>
-    private async Task<IActionResult> GetPlayersAjaxPrivate(PlayersFilter filter, GameType? gameType, CancellationToken cancellationToken = default)
-    {
-        return await ExecuteWithErrorHandlingAsync(async () =>
-        {
-            var reader = new StreamReader(Request.Body);
-            var requestBody = await reader.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
-
-            var model = JsonConvert.DeserializeObject<DataTableAjaxPostModel>(requestBody);
-
-            if (model is null)
-            {
-                Logger.LogWarning("Invalid request model for players AJAX from user {UserId}", User.XtremeIdiotsId());
-                return BadRequest();
-            }
-
-            var order = PlayersOrder.LastSeenDesc;
-
-            if (model.Order?.Count > 0)
-            {
-                var orderColumn = model.Columns[model.Order.First().Column].Name;
-                var searchOrder = model.Order.First().Dir;
-
-                order = orderColumn switch
-                {
-                    "username" => searchOrder == "asc" ? PlayersOrder.UsernameAsc : PlayersOrder.UsernameDesc,
-                    "gameType" => searchOrder == "asc" ? PlayersOrder.GameTypeAsc : PlayersOrder.GameTypeDesc,
-                    "firstSeen" => searchOrder == "asc" ? PlayersOrder.FirstSeenAsc : PlayersOrder.FirstSeenDesc,
-                    "lastSeen" => searchOrder == "asc" ? PlayersOrder.LastSeenAsc : PlayersOrder.LastSeenDesc,
-                    _ => order
-                };
-            }
-
-            var playersApiResponse = await repositoryApiClient.Players.V1.GetPlayers(
-                gameType, filter, model.Search?.Value, model.Start, model.Length, order, PlayerEntityOptions.None).ConfigureAwait(false);
-
-            if (!playersApiResponse.IsSuccess || playersApiResponse.Result?.Data is null)
-            {
-                Logger.LogError("Failed to retrieve players for user {UserId} with filter {Filter}",
-                    User.XtremeIdiotsId(), filter);
-                return StatusCode(500, "Failed to retrieve players data");
-            }
-
-            TrackSuccessTelemetry("PlayersListLoaded", nameof(GetPlayersAjax), new Dictionary<string, string>
-            {
-                { "Filter", filter.ToString() },
-                { "GameType", gameType?.ToString() ?? "All" },
-                { "ResultCount", playersApiResponse.Result.Data.Items?.Count().ToString() ?? "0" }
-            });
-
-            return Ok(new
-            {
-                model.Draw,
-                recordsTotal = playersApiResponse.Result?.Pagination?.TotalCount,
-                recordsFiltered = playersApiResponse.Result?.Pagination?.FilteredCount,
-                data = playersApiResponse?.Result?.Data?.Items
-            });
-        }, nameof(GetPlayersAjax), $"filter: {filter}, gameType: {gameType}").ConfigureAwait(false);
-    }
 }

src/XtremeIdiots.Portal.Web/ApiControllers/PlayersController.cs

@@ -65,23 +65,27 @@ public async Task<IActionResult> GetPlayersAjax(GameType? id, [FromQuery] Player
                 return StatusCode(500, "Failed to retrieve players data");
             }
 
-            var enrichedPlayers = await playerCollectionApiResponse.Result.Data.Items
-                .EnrichWithIntelligenceDataAsync(geoLocationClient, Logger, cancellationToken).ConfigureAwait(false);
+            var intelligenceData = await playerCollectionApiResponse.Result.Data.Items
+                .GetIntelligenceDataAsync(geoLocationClient, Logger, cancellationToken).ConfigureAwait(false);
 
-            var playerData = enrichedPlayers.Select(player => new
+            var playerData = playerCollectionApiResponse.Result.Data.Items.Select(player =>
             {
-                player.PlayerId,
-                player.GameType,
-                player.Username,
-                player.Guid,
-                player.IpAddress,
-                player.FirstSeen,
-                player.LastSeen,
-                ProxyCheckRiskScore = player.ProxyCheckRiskScore(),
-                IsProxy = player.IsProxy(),
-                IsVpn = player.IsVpn(),
-                ProxyType = player.ProxyType(),
-                CountryCode = player.CountryCode()
+                var intel = intelligenceData.TryGetValue(player.PlayerId, out var d) ? d : new PlayerIntelligenceData();
+                return new
+                {
+                    player.PlayerId,
+                    player.GameType,
+                    player.Username,
+                    player.Guid,
+                    player.IpAddress,
+                    player.FirstSeen,
+                    player.LastSeen,
+                    intel.ProxyCheckRiskScore,
+                    intel.IsProxy,
+                    intel.IsVpn,
+                    intel.ProxyType,
+                    intel.CountryCode
+                };
             }).ToList();
 
             TrackSuccessTelemetry("PlayersDataLoaded", nameof(GetPlayersAjax), new Dictionary<string, string>

src/XtremeIdiots.Portal.Web/Extensions/IPAddressExtensions.cs

@@ -1,7 +1,5 @@
 using Microsoft.AspNetCore.Html;
 using System.Text;
-using XtremeIdiots.Portal.Repository.Abstractions.Models.V1.Players;
-using XtremeIdiots.Portal.Web.Models;
 
 namespace XtremeIdiots.Portal.Web.Extensions;
 
@@ -65,23 +63,6 @@ public static HtmlString FormatIPAddress(
         return new HtmlString(sb.ToString());
     }
 
-    public static HtmlString FormatIPAddress(
-        this PlayerDto player,
-        string? countryCode = null,
-        bool linkToDetails = true)
-    {
-        return player is null || string.IsNullOrEmpty(player.IpAddress)
-            ? HtmlString.Empty
-            : FormatIPAddress(
-            player.IpAddress,
-            countryCode ?? player.CountryCode(),
-            player.ProxyCheckRiskScore(),
-            player.IsProxy(),
-            player.IsVpn(),
-            player.ProxyType(),
-            linkToDetails);
-    }
-
     public static string GetRiskClass(int riskScore)
     {
         return riskScore switch

src/XtremeIdiots.Portal.Web/Extensions/PlayerEnrichmentExtensions.cs

@@ -7,62 +7,66 @@ namespace XtremeIdiots.Portal.Web.Extensions;
 
 public static class PlayerEnrichmentExtensions
 {
-    public async static Task<PlayerDto> EnrichWithIntelligenceDataAsync(
+    public async static Task<PlayerIntelligenceData> GetIntelligenceDataAsync(
         this PlayerDto playerDto,
         IGeoLocationApiClient geoLocationClient,
         ILogger logger,
         CancellationToken cancellationToken = default)
     {
-        if (playerDto is null)
-            return playerDto!;
-
-        if (string.IsNullOrEmpty(playerDto.IpAddress))
-            return playerDto;
+        if (playerDto is null || string.IsNullOrEmpty(playerDto.IpAddress))
+            return new PlayerIntelligenceData();
 
         try
         {
             var result = await geoLocationClient.GeoLookup.V1_1.GetIpIntelligence(playerDto.IpAddress, cancellationToken).ConfigureAwait(false);
             if (result.IsSuccess && result.Result?.Data is not null)
             {
                 var intelligence = result.Result.Data;
-
-                if (!string.IsNullOrWhiteSpace(intelligence.CountryCode))
-                {
-                    playerDto.SetCountryCode(intelligence.CountryCode);
-                }
+                var countryCode = !string.IsNullOrWhiteSpace(intelligence.CountryCode) ? intelligence.CountryCode : string.Empty;
 
                 if (intelligence.ProxyCheckStatus == SourceStatus.Success && intelligence.ProxyCheck is not null)
                 {
-                    playerDto.SetProxyCheckRiskScore(intelligence.ProxyCheck.RiskScore);
-                    playerDto.SetIsProxy(intelligence.ProxyCheck.IsProxy);
-                    playerDto.SetIsVpn(intelligence.ProxyCheck.IsVpn);
-                    playerDto.SetProxyType(intelligence.ProxyCheck.ProxyType);
+                    return new PlayerIntelligenceData
+                    {
+                        CountryCode = countryCode,
+                        ProxyCheckRiskScore = intelligence.ProxyCheck.RiskScore,
+                        IsProxy = intelligence.ProxyCheck.IsProxy,
+                        IsVpn = intelligence.ProxyCheck.IsVpn,
+                        ProxyType = intelligence.ProxyCheck.ProxyType
+                    };
                 }
+
+                return new PlayerIntelligenceData { CountryCode = countryCode };
             }
         }
         catch (Exception ex)
         {
             logger.LogWarning(ex, "Failed to enrich player DTO with intelligence data for IP {IpAddress}", playerDto.IpAddress);
         }
 
-        return playerDto;
+        return new PlayerIntelligenceData();
     }
 
-    public async static Task<IEnumerable<PlayerDto>> EnrichWithIntelligenceDataAsync(
+    public async static Task<Dictionary<Guid, PlayerIntelligenceData>> GetIntelligenceDataAsync(
         this IEnumerable<PlayerDto> playerDtos,
         IGeoLocationApiClient geoLocationClient,
         ILogger logger,
         CancellationToken cancellationToken = default)
     {
+        var result = new Dictionary<Guid, PlayerIntelligenceData>();
+
         if (playerDtos is null)
-            return [];
+            return result;
 
-        var players = playerDtos.ToList();
+        var players = playerDtos.Where(p => p != null).ToList();
+        var bag = new System.Collections.Concurrent.ConcurrentDictionary<Guid, PlayerIntelligenceData>();
 
-        await Parallel.ForEachAsync(players.Where(p => p != null), cancellationToken, async (player, ct) =>
-            await player.EnrichWithIntelligenceDataAsync(geoLocationClient, logger, ct).ConfigureAwait(false))
-            .ConfigureAwait(false);
+        await Parallel.ForEachAsync(players, cancellationToken, async (player, ct) =>
+        {
+            var data = await player.GetIntelligenceDataAsync(geoLocationClient, logger, ct).ConfigureAwait(false);
+            bag[player.PlayerId] = data;
+        }).ConfigureAwait(false);
 
-        return players;
+        return new Dictionary<Guid, PlayerIntelligenceData>(bag);
     }
 }