Merge pull request #602 from osu-tournament-rating/feature/ef-naming-…

…conventions

Snake case by default database refactor

API/Configurations/MapperProfile.cs

@@ -14,7 +14,7 @@ public MapperProfile()
         CreateMap<AdminNoteEntityBase, AdminNoteDTO>();
 
         CreateMap<Beatmap, BeatmapDTO>();
-        CreateMap<BeatmapSet, BeatmapSetCompactDTO>();
+        CreateMap<Beatmapset, BeatmapsetCompactDTO>();
         CreateMap<BeatmapAttributes, BeatmapAttributesDTO>();
 
         CreateMap<Game, GameDTO>()

API/DTOs/BeatmapDTO.cs

@@ -58,12 +58,12 @@ public class BeatmapDTO
     /// <summary>
     /// Beatmapset id
     /// </summary>
-    public int? BeatmapSetId { get; set; }
+    public int? BeatmapsetId { get; set; }
 
     /// <summary>
     /// Beatmapset
     /// </summary>
-    public BeatmapSetCompactDTO? BeatmapSet { get; init; }
+    public BeatmapsetCompactDTO? Beatmapset { get; init; }
 
     /// <summary>
     /// Beatmap attributes

API/DTOs/BeatmapSetCompactDTO.cs

@@ -6,7 +6,7 @@ namespace API.DTOs;
 /// <summary>
 /// Represents a compact version of a beatmapset
 /// </summary>
-public class BeatmapSetCompactDTO
+public class BeatmapsetCompactDTO
 {
     /// <summary>
     /// Beatmapset id

API/DTOs/BeatmapSetDTO.cs

@@ -3,7 +3,7 @@ namespace API.DTOs;
 /// <summary>
 /// A beatmapset with beatmaps included
 /// </summary>
-public class BeatmapSetDTO : BeatmapSetCompactDTO
+public class BeatmapsetDTO : BeatmapsetCompactDTO
 {
     /// <summary>
     /// Beatmaps which are part of this set

API/Program.cs

@@ -556,7 +556,8 @@ await context.HttpContext.Response.WriteAsync(
 {
     options
         .UseNpgsql(builder.Configuration.BindAndValidate<ConnectionStringsConfiguration>(ConnectionStringsConfiguration.Position).DefaultConnection)
-        .AddInterceptors(services.GetRequiredService<AuditBlamingInterceptor>());
+        .AddInterceptors(services.GetRequiredService<AuditBlamingInterceptor>())
+        .UseSnakeCaseNamingConvention();
 });
 
 // The Redis cache is registered as a singleton because it is meant to be re-used across instances

API/Services/Implementations/PlayerStatsService.cs

@@ -114,7 +114,7 @@ await matchStatsRepository.OpponentStatsAsync(playerId, opponentId, ruleset, dat
             return null;
         }
 
-        ruleset ??= player.User?.Settings.DefaultRuleset ?? player.Ruleset;
+        ruleset ??= player.User?.Settings.DefaultRuleset ?? player.DefaultRuleset;
 
         PlayerCompactDTO playerInfo = mapper.Map<PlayerCompactDTO>(player);
 

API/Services/Implementations/SearchService.cs

@@ -72,7 +72,7 @@ private async Task<IEnumerable<PlayerSearchResultDTO>> SearchPlayersByNameAsync(
             .Select(player =>
             {
                 PlayerRating? stats = player.Ratings
-                    .FirstOrDefault(r => r.Ruleset == (player.User?.Settings.DefaultRuleset ?? player.Ruleset));
+                    .FirstOrDefault(r => r.Ruleset == (player.User?.Settings.DefaultRuleset ?? player.DefaultRuleset));
                 return new PlayerSearchResultDTO
                 {
                     Id = player.Id,

API/Services/Implementations/UserSettingsService.cs

@@ -32,7 +32,7 @@ public async Task<bool> SyncRulesetAsync(int userId)
             return false;
         }
 
-        user.Settings.DefaultRuleset = user.Player!.Ruleset;
+        user.Settings.DefaultRuleset = user.Player!.DefaultRuleset;
         user.Settings.DefaultRulesetIsControlled = false;
         await userRepository.UpdateAsync(user);
 

DataWorkerService/Program.cs

@@ -93,7 +93,8 @@
             )
             .DefaultConnection
     )
-    .AddInterceptors(new AuditingInterceptor());
+    .AddInterceptors(new AuditingInterceptor())
+    .UseSnakeCaseNamingConvention();
 });
 
 AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);

DataWorkerService/Services/Implementations/OsuApiDataParserService.cs

@@ -10,6 +10,7 @@
 using ApiScore = OsuApiClient.Domain.Osu.Multiplayer.GameScore;
 using ApiUser = OsuApiClient.Domain.Osu.Users.User;
 using Beatmap = Database.Entities.Beatmap;
+using Beatmapset = Database.Entities.Beatmapset;
 using GameScore = Database.Entities.GameScore;
 
 namespace DataWorkerService.Services.Implementations;
@@ -20,7 +21,7 @@ public class OsuApiDataParserService(
     IOsuClient osuClient
 ) : IOsuApiDataParserService
 {
-    private readonly Dictionary<long, BeatmapSet> _beatmapSetCache = [];
+    private readonly Dictionary<long, Beatmapset> _beatmapSetCache = [];
     private readonly Dictionary<long, Beatmap> _beatmapCache = [];
     private readonly Dictionary<long, Player> _playerCache = [];
 
@@ -143,7 +144,7 @@ public async Task ProcessBeatmapsAsync(IEnumerable<long> beatmapOsuIds)
 
             // Test database
             Beatmap? beatmap = await context.Beatmaps
-                .Include(b => b.BeatmapSet)
+                .Include(b => b.Beatmapset)
                 .ThenInclude(bs => bs!.Creator)
                 .Include(b => b.Creators)
                 .FirstOrDefaultAsync(b => b.OsuId == beatmapOsuId);
@@ -153,12 +154,12 @@ public async Task ProcessBeatmapsAsync(IEnumerable<long> beatmapOsuIds)
             {
                 _beatmapCache.TryAdd(beatmap.OsuId, beatmap);
                 beatmap.Creators.ToList().ForEach(p => _playerCache.TryAdd(p.OsuId, p));
-                if (beatmap.BeatmapSet is not null)
+                if (beatmap.Beatmapset is not null)
                 {
-                    _beatmapSetCache.TryAdd(beatmap.BeatmapSet.OsuId, beatmap.BeatmapSet);
-                    if (beatmap.BeatmapSet.Creator is not null)
+                    _beatmapSetCache.TryAdd(beatmap.Beatmapset.OsuId, beatmap.Beatmapset);
+                    if (beatmap.Beatmapset.Creator is not null)
                     {
-                        _playerCache.TryAdd(beatmap.BeatmapSet.Creator.OsuId, beatmap.BeatmapSet.Creator);
+                        _playerCache.TryAdd(beatmap.Beatmapset.Creator.OsuId, beatmap.Beatmapset.Creator);
                     }
                 }
             }
@@ -170,7 +171,7 @@ public async Task ProcessBeatmapsAsync(IEnumerable<long> beatmapOsuIds)
                 _beatmapCache.TryAdd(beatmap.OsuId, beatmap);
             }
 
-            if (beatmap.BeatmapSet is not null || beatmap.HasData)
+            if (beatmap.Beatmapset is not null || beatmap.HasData)
             {
                 continue;
             }
@@ -183,11 +184,11 @@ public async Task ProcessBeatmapsAsync(IEnumerable<long> beatmapOsuIds)
                 continue;
             }
 
-            await ProcessBeatmapSetAsync(apiBeatmap.BeatmapsetId);
+            await ProcessBeatmapsetAsync(apiBeatmap.BeatmapsetId);
         }
     }
 
-    private async Task ProcessBeatmapSetAsync(long beatmapSetOsuId)
+    private async Task ProcessBeatmapsetAsync(long beatmapSetOsuId)
     {
         // Test cache
         if (_beatmapSetCache.ContainsKey(beatmapSetOsuId))
@@ -196,7 +197,7 @@ private async Task ProcessBeatmapSetAsync(long beatmapSetOsuId)
         }
 
         // Test database
-        BeatmapSet? beatmapSet = await context.BeatmapSets
+        Beatmapset? beatmapSet = await context.Beatmapsets
             .AsSplitQuery()
             .Include(bs => bs.Creator)
             .Include(bs => bs.Beatmaps)
@@ -221,14 +222,14 @@ private async Task ProcessBeatmapSetAsync(long beatmapSetOsuId)
             return;
         }
 
-        BeatmapsetExtended? apiBeatmapSet = await osuClient.GetBeatmapsetAsync(beatmapSetOsuId);
+        BeatmapsetExtended? apiBeatmapset = await osuClient.GetBeatmapsetAsync(beatmapSetOsuId);
 
         // Could not fetch the set, create an empty entity
-        if (apiBeatmapSet is null)
+        if (apiBeatmapset is null)
         {
-            beatmapSet = new BeatmapSet { OsuId = beatmapSetOsuId };
+            beatmapSet = new Beatmapset { OsuId = beatmapSetOsuId };
 
-            context.BeatmapSets.Add(beatmapSet);
+            context.Beatmapsets.Add(beatmapSet);
             _beatmapSetCache.TryAdd(beatmapSet.OsuId, beatmapSet);
 
             return;
@@ -237,31 +238,31 @@ private async Task ProcessBeatmapSetAsync(long beatmapSetOsuId)
         // Now we parse
         // Load players
         // Filtering because this collection also contains beatmap nominators, etc. and we only want to target mappers
-        await LoadPlayersAsync(apiBeatmapSet.RelatedUsers.Where(u =>
-            u.Id == apiBeatmapSet.CreatorId || apiBeatmapSet.Beatmaps
+        await LoadPlayersAsync(apiBeatmapset.RelatedUsers.Where(u =>
+            u.Id == apiBeatmapset.CreatorId || apiBeatmapset.Beatmaps
                 .SelectMany(b => b.Owners)
                 .Any(o => o.Id == u.Id))
         );
 
         // Create new set
-        beatmapSet = new BeatmapSet
+        beatmapSet = new Beatmapset
         {
             OsuId = beatmapSetOsuId,
-            Artist = apiBeatmapSet.Artist,
-            Title = apiBeatmapSet.Title,
-            RankedStatus = apiBeatmapSet.RankedStatus,
-            RankedDate = apiBeatmapSet.RankedDate,
-            SubmittedDate = apiBeatmapSet.SubmittedDate,
+            Artist = apiBeatmapset.Artist,
+            Title = apiBeatmapset.Title,
+            RankedStatus = apiBeatmapset.RankedStatus,
+            RankedDate = apiBeatmapset.RankedDate,
+            SubmittedDate = apiBeatmapset.SubmittedDate,
         };
 
         // Assign set creator if possible
-        if (apiBeatmapSet.CreatorId is not null && _playerCache.TryGetValue(apiBeatmapSet.CreatorId.Value, out Player? setCreator))
+        if (apiBeatmapset.CreatorId is not null && _playerCache.TryGetValue(apiBeatmapset.CreatorId.Value, out Player? setCreator))
         {
             beatmapSet.Creator = setCreator;
         }
 
         // Parse maps
-        foreach (BeatmapExtended apiBeatmap in apiBeatmapSet.Beatmaps)
+        foreach (BeatmapExtended apiBeatmap in apiBeatmapset.Beatmaps)
         {
             // Test cache
             _beatmapCache.TryGetValue(apiBeatmap.Id, out Beatmap? beatmap);
@@ -304,7 +305,7 @@ await LoadPlayersAsync(apiBeatmapSet.RelatedUsers.Where(u =>
         }
 
         _beatmapSetCache.TryAdd(beatmapSet.OsuId, beatmapSet);
-        context.BeatmapSets.Add(beatmapSet);
+        context.Beatmapsets.Add(beatmapSet);
     }
 
     private async Task LoadPlayersAsync(IEnumerable<ApiUser> apiUsers)

DataWorkerService/Services/Implementations/PlayersService.cs

@@ -74,7 +74,7 @@ public async Task UpdateFromOsuApiAsync(Player player)
             {
                 player.Username = result.Username;
                 player.Country = result.CountryCode;
-                player.Ruleset = result.Ruleset;
+                player.DefaultRuleset = result.Ruleset;
 
                 if (player.User?.Settings is { DefaultRulesetIsControlled: false })
                 {

Database/Database.csproj

@@ -15,6 +15,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="EFCore.NamingConventions" Version="9.0.0" />
     <PackageReference Include="JetBrains.Annotations" Version="2024.3.0"/>
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0"/>
     <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.0"/>

Database/Entities/AdminNoteEntityBase.cs

@@ -8,13 +8,10 @@ namespace Database.Entities;
 /// </summary>
 public abstract class AdminNoteEntityBase : UpdateableEntityBase, IAdminNoteEntity
 {
-    [Column("note")]
     public string Note { get; set; } = string.Empty;
 
-    [Column("ref_id")]
     public int ReferenceId { get; set; }
 
-    [Column("admin_user_id")]
     public int AdminUserId { get; set; }
 
     public User AdminUser { get; } = null!;

Database/Entities/AuditEntityBase.cs

@@ -21,26 +21,19 @@ public abstract class AuditEntityBase<TAuditable, TAudit> : IAuditEntity
     where TAudit : IAuditEntity
 {
     [Key]
-    [Column("id")]
     [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
     public int Id { get; }
 
-    [Column("created")]
     public DateTime Created { get; }
 
-    [Column("ref_id_lock")]
     public int ReferenceIdLock { get; private set; }
 
-    [Column("ref_id")]
     public int? ReferenceId { get; private set; }
 
-    [Column("action_user_id")]
     public int? ActionUserId { get; set; }
 
-    [Column("action_type")]
     public AuditActionType ActionType { get; private set; }
 
-    [Column("changes", TypeName = "jsonb")]
     public IDictionary<string, AuditChangelogEntry> Changes { get; } = new Dictionary<string, AuditChangelogEntry>();
 
     public virtual bool GenerateAudit(EntityEntry origEntityEntry)