Merge pull request #568 from osu-tournament-rating/feature/missing-ru…

…leset-col

Fix stats & add missing ruleset column to `rating_adjustments` table

API.Tests/Services/LeaderboardServiceTests.cs

@@ -3,7 +3,9 @@
 using API.Services.Implementations;
 using API.Utilities;
 using APITests.MockRepositories;
+using AutoMapper;
 using Database.Enums;
+using MapperProfile = OsuApiClient.Configurations.MapperProfile;
 
 namespace APITests.Services;
 
@@ -44,7 +46,8 @@ public LeaderboardServiceTests()
             playerRatingsRepository.Object,
             matchStatsRepository.Object,
             playerRepository.Object,
-            tournamentsService
+            tournamentsService,
+            new Mapper(new MapperConfiguration(configuration => configuration.AddProfile(new MapperProfile())))
         );
 
         _leaderboardService = new LeaderboardService(

API/DTOs/PlayerRatingChartDataPointDTO.cs

@@ -1,3 +1,5 @@
+using Database.Enums;
+
 namespace API.DTOs;
 
 /// <summary>
@@ -6,62 +8,67 @@ namespace API.DTOs;
 public class PlayerRatingChartDataPointDTO
 {
     /// <summary>
-    /// Match name
+    /// Match name, if applicable
     /// </summary>
-    public string Name { get; set; } = string.Empty;
+    public string? Name { get; init; }
 
     /// <summary>
-    /// Match id
+    /// Match id, if applicable
     /// </summary>
-    public int? MatchId { get; set; }
+    public int? MatchId { get; init; }
 
     /// <summary>
-    /// osu! match id
+    /// osu! match id, if applicable
     /// </summary>
-    public long? MatchOsuId { get; set; }
+    public long? MatchOsuId { get; init; }
 
     /// <summary>
-    /// Match cost of the player
+    /// Match cost of the player, if applicable
     /// </summary>
-    public double? MatchCost { get; set; }
+    public double? MatchCost { get; init; }
 
     /// <summary>
-    /// Rating of the player before this match occurred
+    /// Rating of the player before the adjustment
     /// </summary>
-    public double RatingBefore { get; set; }
+    public double RatingBefore { get; init; }
 
     /// <summary>
-    /// Rating of the player after this match occurred
+    /// Rating of the player after the adjustment
     /// </summary>
-    public double RatingAfter { get; set; }
+    public double RatingAfter { get; init; }
 
     /// <summary>
     /// Volatility of the player before this match occurred
     /// </summary>
-    public double VolatilityBefore { get; set; }
+    public double VolatilityBefore { get; init; }
 
     /// <summary>
-    /// Volatility of the player after this match occurred
+    /// Volatility of the player after this adjustment
     /// </summary>
-    public double VolatilityAfter { get; set; }
+    public double VolatilityAfter { get; init; }
 
     /// <summary>
-    /// Difference in rating for the player after this match occurred
+    /// Difference in rating between now and the previous adjustment
     /// </summary>
     public double RatingChange => RatingAfter - RatingBefore;
 
     /// <summary>
-    /// Difference in volatility for the player after this match occurred
+    /// Difference in volatility between now and the previous adjustment
     /// </summary>
     public double VolatilityChange => VolatilityAfter - VolatilityBefore;
 
     /// <summary>
-    /// Indicates whether this data point is from a rating change that occurred outside of a match (i.e. decay)
+    /// Ruleset of the adjustment
+    /// </summary>
+    public Ruleset Ruleset { get; init; }
+
+    /// <summary>
+    /// Adjustment type
     /// </summary>
-    public bool IsAdjustment { get; set; }
+    public RatingAdjustmentType RatingAdjustmentType { get; init; }
 
     /// <summary>
     /// Match start time
     /// </summary>
-    public DateTime? Timestamp { get; set; }
+    public DateTime? Timestamp { get; init; }
 }

API/Repositories/Implementations/ApiMatchRatingStatsRepository.cs

@@ -3,85 +3,64 @@
 using Database;
 using Database.Enums;
 using Database.Repositories.Implementations;
+using Microsoft.EntityFrameworkCore;
 
 namespace API.Repositories.Implementations;
 
-public class ApiMatchRatingStatsRepository(OtrContext context) : MatchRatingStatsRepository(context), IApiMatchRatingStatsRepository
+public class ApiMatchRatingStatsRepository(OtrContext context)
+    : MatchRatingStatsRepository(context), IApiMatchRatingStatsRepository
 {
-    public Task<PlayerRatingChartDTO> GetRatingChartAsync(
+    private readonly OtrContext _context = context;
+
+    public async Task<PlayerRatingChartDTO> GetRatingChartAsync(
         int playerId,
         Ruleset ruleset,
         DateTime? dateMin = null,
         DateTime? dateMax = null
     )
     {
-        // TODO: Rewrite this
-        // // Default date range to min and max values if not provided
-        // dateMin ??= DateTime.MinValue;
-        // dateMax ??= DateTime.MaxValue;
-        //
-        // // Fetch Match Rating Stats and group by Match.StartTime.Date
-        // var matchRatingStats = await _context
-        //     .MatchRatingStats.Where(mrs =>
-        //         mrs.PlayerId == playerId
-        //         && mrs.Match.Tournament.Ruleset == (Ruleset)ruleset
-        //         && mrs.Match.StartTime >= dateMin
-        //         && mrs.Match.StartTime <= dateMax
-        //     )
-        //     .Select(mrs => new
-        //     {
-        //         mrs.Match.StartTime,
-        //         DataPoint = new PlayerRatingChartDataPointDTO
-        //         {
-        //             Name = mrs.Match.Name ?? "<Unknown>",
-        //             MatchId = mrs.MatchId,
-        //             MatchOsuId = mrs.Match.OsuId,
-        //             // MatchCost = mrs.MatchCost,
-        //             RatingBefore = mrs.RatingBefore,
-        //             RatingAfter = mrs.RatingAfter,
-        //             VolatilityBefore = mrs.VolatilityBefore,
-        //             VolatilityAfter = mrs.VolatilityAfter,
-        //             IsAdjustment = false,
-        //             Timestamp = mrs.Match.StartTime
-        //         }
-        //     })
-        //     .ToListAsync();
-        //
-        // // Assuming RatingAdjustments should be grouped by their own timestamp since they may not have a Match.StartTime
-        // var ratingAdjustments = await _context
-        //     .RatingAdjustments
-        //     .Where(ra =>
-        //         ra.PlayerId == playerId
-        //         && ra.Ruleset == (Ruleset)ruleset
-        //         && ra.Timestamp >= dateMin
-        //         && ra.Timestamp <= dateMax
-        //     )
-        //     .Select(ra => new
-        //     {
-        //         ra.Timestamp, // Use Timestamp for grouping as fallback
-        //         DataPoint = new PlayerRatingChartDataPointDTO
-        //         {
-        //             Name = ra.RatingAdjustmentType == 0 ? "Decay" : "Adjustment",
-        //             RatingBefore = ra.RatingBefore,
-        //             RatingAfter = ra.RatingAfter,
-        //             VolatilityBefore = ra.VolatilityBefore,
-        //             VolatilityAfter = ra.VolatilityAfter,
-        //             IsAdjustment = true,
-        //             Timestamp = ra.Timestamp
-        //         }
-        //     })
-        //     .ToListAsync();
-        //
-        // // Combine data points, converting Match.StartTime and RatingAdjustment.Timestamp to Date for grouping
-        // var combinedDataPoints = matchRatingStats
-        //     .Select(mrs => new { mrs.StartTime.Date, mrs.DataPoint })
-        //     .Concat(ratingAdjustments.Select(ra => new { ra.Timestamp.Date, ra.DataPoint }))
-        //     .GroupBy(x => x.Date)
-        //     .OrderBy(g => g.Key)
-        //     .Select(g => g.Select(x => x.DataPoint).ToList())
-        //     .ToList();
+        // Default date range to min and max values if not provided
+        dateMin ??= DateTime.MinValue;
+        dateMax ??= DateTime.MaxValue;
+
+        // Fetch Match Rating Stats and group by Match.StartTime.Date
+        List<IGrouping<DateTime?, PlayerRatingChartDataPointDTO>> chartPoints = await _context
+            .RatingAdjustments
+            .Include(ra => ra.Match)
+            .Where(ra =>
+                ra.PlayerId == playerId
+                && ra.Ruleset == ruleset
+                && ra.Timestamp >= dateMin
+                && ra.Timestamp <= dateMax
+            )
+            .Select(ra =>
+            new PlayerRatingChartDataPointDTO
+            {
+                Name = ra.Match == null
+                    ? null
+                    : ra.Match.Name,
+                MatchId = ra.MatchId,
+                MatchOsuId = ra.Match == null
+                    ? null
+                    : ra.Match.OsuId,
+                MatchCost = _context.PlayerMatchStats
+                    .Where(pms => pms.PlayerId == ra.PlayerId &&
+                                  pms.MatchId == ra.MatchId)
+                    .Select(pms => pms.MatchCost)
+                    .FirstOrDefault(),
+                RatingBefore = ra.RatingBefore,
+                RatingAfter = ra.RatingAfter,
+                VolatilityBefore = ra.VolatilityBefore,
+                VolatilityAfter = ra.VolatilityAfter,
+                Ruleset = ra.Ruleset,
+                RatingAdjustmentType = ra.AdjustmentType,
+                Timestamp = ra.Timestamp
+            })
+            .OrderBy(ra => ra.Timestamp)
+            .GroupBy(ra => ra.Timestamp)
+            .ToListAsync();
 
-        // Prepare and return the DTO
-        return Task.FromResult(new PlayerRatingChartDTO { ChartData = new List<List<PlayerRatingChartDataPointDTO>>() });
+        // Combine data points, converting Match.StartTime and RatingAdjustment.Timestamp to Date for grouping
+        return new PlayerRatingChartDTO { ChartData = chartPoints };
     }
 }

API/Services/Implementations/PlayerRatingsService.cs

@@ -3,6 +3,7 @@
 using API.Repositories.Interfaces;
 using API.Services.Interfaces;
 using API.Utilities;
+using AutoMapper;
 using Database.Entities.Processor;
 using Database.Enums;
 using Database.Repositories.Interfaces;
@@ -13,7 +14,8 @@ public class PlayerRatingsService(
     IApiPlayerRatingsRepository playerRatingsRepository,
     IPlayerMatchStatsRepository matchStatsRepository,
     IPlayersRepository playerRepository,
-    ITournamentsService tournamentsService
+    ITournamentsService tournamentsService,
+    IMapper mapper
 ) : IPlayerRatingsService
 {
     public async Task<IEnumerable<PlayerRatingStatsDTO?>> GetAsync(long osuPlayerId)
@@ -72,7 +74,8 @@ ITournamentsService tournamentsService
             Volatility = currentStats.Volatility,
             WinRate = winRate,
             TournamentsPlayed = tournamentsPlayed,
-            RankProgress = rankProgress
+            RankProgress = rankProgress,
+            Adjustments = mapper.Map<ICollection<RatingAdjustmentDTO>>(currentStats.Adjustments.OrderBy(a => a.Timestamp))
         };
     }
 

API/Services/Implementations/PlayerStatsService.cs

@@ -173,8 +173,7 @@ public async Task<double> GetPeakRatingAsync(int playerId, Ruleset ruleset, Date
         DateTime? dateMax = null)
     {
         return (await ratingStatsRepository.GetForPlayerAsync(playerId, ruleset, dateMin, dateMax))
-            .SelectMany(x => x)
-            .Max(x => x.RatingAfter);
+            .Max(ra => ra.RatingAfter);
     }
 
     private async Task<PlayerRatingStatsDTO?> GetCurrentAsync(int playerId, Ruleset ruleset)
@@ -260,35 +259,44 @@ DateTime dateMax
         var matchStats = (await matchStatsRepository.GetForPlayerAsync(id, ruleset, dateMin, dateMax)).ToList();
         var adjustments =
             (await ratingStatsRepository.GetForPlayerAsync(id, ruleset, dateMin, dateMax))
-            .ToList()
-            .SelectMany(x => x)
+            .GroupBy(ra => ra.Timestamp)
+            .SelectMany(ra => ra)
             .ToList();
 
-        if (matchStats.Count == 0)
+        if (matchStats.Count == 0 || adjustments.Count == 0)
         {
             return new AggregatePlayerMatchStatsDTO();
         }
 
+        /**
+         * If the adjustments list contains an initial rating, we need to subtract the
+         * rating gained value by the initial rating. Essentially we are displaying
+         * the net gain in rating without considering the initial rating.
+         */
+        var initialRatingValue = adjustments
+            .FirstOrDefault(ra => ra.AdjustmentType == RatingAdjustmentType.Initial)?.RatingAfter
+            ?? 0;
+
         return new AggregatePlayerMatchStatsDTO
         {
             // TODO: Different way of calcing this
             // AverageMatchCostAggregate = ratingStats.Average(x => x.MatchCost),
-            HighestRating = adjustments.Max(x => x.RatingAfter),
-            RatingGained = adjustments.Last().RatingAfter - adjustments.First().RatingAfter,
-            GamesWon = matchStats.Sum(x => x.GamesWon),
-            GamesLost = matchStats.Sum(x => x.GamesLost),
-            GamesPlayed = matchStats.Sum(x => x.GamesPlayed),
-            MatchesWon = matchStats.Count(x => x.Won),
-            MatchesLost = matchStats.Count(x => !x.Won),
+            HighestRating = adjustments.Max(ra => ra.RatingAfter),
+            RatingGained = adjustments.Sum(ra => ra.RatingDelta) - initialRatingValue,
+            GamesWon = matchStats.Sum(ra => ra.GamesWon),
+            GamesLost = matchStats.Sum(ra => ra.GamesLost),
+            GamesPlayed = matchStats.Sum(ra => ra.GamesPlayed),
+            MatchesWon = matchStats.Count(ra => ra.Won),
+            MatchesLost = matchStats.Count(ra => !ra.Won),
             // TODO: Different way of calcing this
             // AverageTeammateRating = ratingStats.Average(x => x.AverageTeammateRating),
             // AverageOpponentRating = ratingStats.Average(x => x.AverageOpponentRating),
             BestWinStreak = GetHighestWinStreak(matchStats),
-            MatchAverageScoreAggregate = matchStats.Average(x => x.AverageScore),
-            MatchAverageAccuracyAggregate = matchStats.Average(x => x.AverageAccuracy),
-            MatchAverageMissesAggregate = matchStats.Average(x => x.AverageMisses),
-            AverageGamesPlayedAggregate = matchStats.Average(x => x.GamesPlayed),
-            AveragePlacingAggregate = matchStats.Average(x => x.AveragePlacement),
+            MatchAverageScoreAggregate = matchStats.Average(pms => pms.AverageScore),
+            MatchAverageAccuracyAggregate = matchStats.Average(pms => pms.AverageAccuracy),
+            MatchAverageMissesAggregate = matchStats.Average(pms => pms.AverageMisses),
+            AverageGamesPlayedAggregate = matchStats.Average(pms => pms.GamesPlayed),
+            AveragePlacingAggregate = matchStats.Average(pms => pms.AveragePlacement),
             PeriodStart = dateMin,
             PeriodEnd = dateMax
         };

Database/Entities/Processor/PlayerRating.cs

@@ -72,5 +72,5 @@ public class PlayerRating : EntityBase
     /// A collection of <see cref="RatingAdjustment"/>s that represent
     /// the individual changes to the <see cref="PlayerRating"/> over time
     /// </summary>
-    public ICollection<RatingAdjustment> Adjustments { get; init; } = [];
+    public ICollection<RatingAdjustment> Adjustments { get; set; } = [];
 }

Database/Entities/Processor/RatingAdjustment.cs

@@ -22,11 +22,17 @@ namespace Database.Entities.Processor;
 public class RatingAdjustment : EntityBase
 {
     /// <summary>
-    /// The <see cref="RatingAdjustmentType"/> of the adjustment
+    /// The <see cref="RatingAdjustmentType"/>
     /// </summary>
     [Column("adjustment_type")]
     public RatingAdjustmentType AdjustmentType { get; init; }
 
+    /// <summary>
+    ///     The <see cref="Ruleset" />
+    /// </summary>
+    [Column("ruleset")]
+    public Ruleset Ruleset { get; set; }
+
     /// <summary>
     /// Timestamp for when the adjustment was applied
     /// </summary>