Fix Arsene dragon stories not unlocked on receipt

DragaliaAPI/DragaliaAPI.Integration.Test/Features/Reward/RewardServiceTest.cs

@@ -1,6 +1,9 @@
 using DragaliaAPI.Database.Entities;
 using DragaliaAPI.Features.Shared.Reward.Handlers;
 using DragaliaAPI.Shared.Definitions.Enums.Summon;
+using DragaliaAPI.Shared.MasterAsset;
+using DragaliaAPI.Shared.MasterAsset.Models.Story;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DragaliaAPI.Integration.Test.Features.Reward;
@@ -99,4 +102,57 @@ public void NoDuplicateSupportedTypes()
 
         supportedTypes.Should().OnlyHaveUniqueItems();
     }
+
+    [Fact]
+    public async Task GrantArsene_AddsDragonStories()
+    {
+        (
+            await this.ApiContext.PlayerStoryState.CountAsync(
+                x => x.StoryType == StoryTypes.Dragon,
+                cancellationToken: TestContext.Current.CancellationToken
+            )
+        )
+            .Should()
+            .Be(0);
+
+        DbPlayerPresent present = new()
+        {
+            EntityType = EntityTypes.Dragon,
+            EntityQuantity = 1,
+            EntityId = (int)DragonId.Arsene,
+        };
+
+        await this.AddToDatabase(present);
+
+        await this.Client.PostMsgpack(
+            "/present/receive",
+            new PresentReceiveRequest() { PresentIdList = [(ulong)present.PresentId] },
+            cancellationToken: TestContext.Current.CancellationToken
+        );
+
+        StoryData arseneStories = MasterAsset.DragonStories[(int)DragonId.Arsene];
+
+        List<DbPlayerStoryState> dragonStories = await this
+            .ApiContext.PlayerStoryState.Where(x => x.StoryType == StoryTypes.Dragon)
+            .ToListAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        dragonStories
+            .Should()
+            .BeEquivalentTo([
+                new DbPlayerStoryState()
+                {
+                    ViewerId = this.ViewerId,
+                    StoryType = StoryTypes.Dragon,
+                    State = 0,
+                    StoryId = arseneStories.StoryIds[0],
+                },
+                new DbPlayerStoryState()
+                {
+                    ViewerId = this.ViewerId,
+                    StoryType = StoryTypes.Dragon,
+                    State = 0,
+                    StoryId = arseneStories.StoryIds[1],
+                },
+            ]);
+    }
 }

DragaliaAPI/DragaliaAPI.Integration.Test/Features/SavefileUpdate/ISavefileUpdateTest.cs

@@ -17,7 +17,7 @@ public ISavefileUpdateTest(CustomWebApplicationFactory factory, ITestOutputHelpe
     public void ISavefileUpdate_HasExpectedCount()
     {
         // Update this test when adding a new update.
-        this.updates.Should().HaveCount(27);
+        this.updates.Should().HaveCount(28);
     }
 
     [Fact]

DragaliaAPI/DragaliaAPI.Integration.Test/Features/SavefileUpdate/V28UpdateTest.cs

@@ -0,0 +1,100 @@
+using DragaliaAPI.Database.Entities;
+using DragaliaAPI.Shared.MasterAsset;
+using DragaliaAPI.Shared.MasterAsset.Models.Story;
+
+namespace DragaliaAPI.Integration.Test.Features.SavefileUpdate;
+
+public class V28UpdateTest : SavefileUpdateTestFixture
+{
+    protected override int StartingVersion => 27;
+
+    public V28UpdateTest(CustomWebApplicationFactory factory, ITestOutputHelper outputHelper)
+        : base(factory, outputHelper) { }
+
+    [Fact]
+    public async Task V28Update_UnlocksBothStoriesForDragonAtLevel30()
+    {
+        this.ApiContext.PlayerStoryState.Count(x => x.StoryType == StoryTypes.Dragon)
+            .Should()
+            .Be(0);
+
+        await this.AddRangeToDatabase([
+            new DbPlayerDragonReliability() { DragonId = DragonId.Arsene, Level = 30 },
+        ]);
+
+        StoryData arseneStories = MasterAsset.DragonStories[(int)DragonId.Arsene];
+
+        this.ApiContext.ChangeTracker.Clear();
+
+        await this.LoadIndex();
+
+        List<DbPlayerStoryState> dragonStories = ApiContext
+            .PlayerStoryState.Where(x => x.StoryType == StoryTypes.Dragon)
+            .ToList();
+
+        dragonStories
+            .Should()
+            .Contain(x => x.StoryId == arseneStories.StoryIds[0])
+            .Which.Should()
+            .BeEquivalentTo(
+                new DbPlayerStoryState()
+                {
+                    ViewerId = this.ViewerId,
+                    StoryId = arseneStories.StoryIds[0],
+                    StoryType = StoryTypes.Dragon,
+                    State = StoryState.Unlocked,
+                }
+            );
+
+        dragonStories
+            .Should()
+            .Contain(x => x.StoryId == arseneStories.StoryIds[1])
+            .Which.Should()
+            .BeEquivalentTo(
+                new DbPlayerStoryState()
+                {
+                    ViewerId = this.ViewerId,
+                    StoryId = arseneStories.StoryIds[1],
+                    StoryType = StoryTypes.Dragon,
+                    State = StoryState.Unlocked,
+                }
+            );
+    }
+
+    [Fact]
+    public async Task V28Update_DoesNotDuplicateExistingStories()
+    {
+        await this.AddRangeToDatabase([
+            new DbPlayerDragonReliability() { DragonId = DragonId.Arsene, Level = 30 },
+        ]);
+
+        StoryData arseneStories = MasterAsset.DragonStories[(int)DragonId.Arsene];
+
+        await this.AddRangeToDatabase([
+            new DbPlayerStoryState()
+            {
+                StoryId = arseneStories.StoryIds[0],
+                StoryType = StoryTypes.Dragon,
+            },
+            new DbPlayerStoryState()
+            {
+                StoryId = arseneStories.StoryIds[1],
+                StoryType = StoryTypes.Dragon,
+            },
+        ]);
+
+        this.ApiContext.ChangeTracker.Clear();
+
+        await this.LoadIndex();
+
+        ApiContext
+            .PlayerStoryState.Where(x =>
+                x.StoryType == StoryTypes.Dragon
+                && (
+                    x.StoryId == arseneStories.StoryIds[0] || x.StoryId == arseneStories.StoryIds[1]
+                )
+            )
+            .Should()
+            .HaveCount(2);
+    }
+}

DragaliaAPI/DragaliaAPI/Features/Login/SavefileUpdate/V28Update.cs

@@ -0,0 +1,67 @@
+using DragaliaAPI.Database;
+using DragaliaAPI.Database.Entities;
+using DragaliaAPI.Shared.Definitions.Enums;
+using DragaliaAPI.Shared.MasterAsset;
+using DragaliaAPI.Shared.MasterAsset.Models.Story;
+using DragaliaAPI.Shared.PlayerDetails;
+using LinqToDB;
+using Microsoft.EntityFrameworkCore;
+
+namespace DragaliaAPI.Features.Login.SavefileUpdate;
+
+/// <summary>
+/// Fixes missing dragon stories for Arsene, whose default reliability level of 30 meant that
+/// stories were not unlocked on receipt (unlike level-up, which is handled by <see cref="V25Update"/>).
+/// </summary>
+public partial class V28Update(
+    ApiContext apiContext,
+    IPlayerIdentityService playerIdentityService,
+    ILogger<V28Update> logger
+) : ISavefileUpdate
+{
+    public int SavefileVersion => 28;
+
+    public async Task Apply()
+    {
+        DbPlayerDragonReliability? arsene =
+            await apiContext.PlayerDragonReliability.FirstOrDefaultAsync(x =>
+                x.DragonId == DragonId.Arsene
+            );
+
+        if (
+            arsene is null
+            || !MasterAsset.DragonStories.TryGetValue((int)DragonId.Arsene, out StoryData? data)
+        )
+        {
+            Log.AddedNewStories(logger, 0);
+            return;
+        }
+
+        // Arsene's default reliability level is 30, so any existing reliability entry implies
+        // both stories should be unlocked -- there is no need to check the level.
+        List<DbPlayerStoryState> intendedStoryStates = data
+            .StoryIds.Select(storyId => new DbPlayerStoryState()
+            {
+                ViewerId = playerIdentityService.ViewerId,
+                StoryId = storyId,
+                State = StoryState.Unlocked,
+                StoryType = StoryTypes.Dragon,
+            })
+            .ToList();
+
+        int rowsAffected = await apiContext
+            .PlayerStoryState.Merge()
+            .Using(intendedStoryStates)
+            .OnTargetKey()
+            .InsertWhenNotMatched()
+            .MergeAsync();
+
+        Log.AddedNewStories(logger, rowsAffected);
+    }
+
+    private static partial class Log
+    {
+        [LoggerMessage(LogLevel.Information, "V28Update added {Count} missing dragon stories")]
+        public static partial void AddedNewStories(ILogger logger, int count);
+    }
+}

DragaliaAPI/DragaliaAPI/Features/Shared/Reward/Handlers/DragonHandler.cs

@@ -1,5 +1,9 @@
+using System.Diagnostics;
 using DragaliaAPI.Database;
+using DragaliaAPI.Database.Entities;
 using DragaliaAPI.Shared.Definitions.Enums;
+using DragaliaAPI.Shared.MasterAsset;
+using DragaliaAPI.Shared.MasterAsset.Models.Story;
 using DragaliaAPI.Shared.PlayerDetails;
 using Microsoft.EntityFrameworkCore;
 
@@ -47,7 +51,9 @@ public async Task<GrantReturn> Grant(Entity entity)
             && !await apiContext.PlayerDragonReliability.AnyAsync(x => x.DragonId == dragon)
         )
         {
-            apiContext.PlayerDragonReliability.Add(new(playerIdentityService.ViewerId, dragon));
+            DbPlayerDragonReliability reliability = new(playerIdentityService.ViewerId, dragon);
+            apiContext.PlayerDragonReliability.Add(reliability);
+            this.AddDefaultLevelStories(dragon, reliability.Level);
         }
 
         return GrantReturn.Added();
@@ -99,8 +105,10 @@ IDictionary<TKey, Entity> entities
                 && !apiContext.PlayerDragonReliability.Local.Any(x => x.DragonId == dragon)
             )
             {
-                apiContext.PlayerDragonReliability.Add(new(playerIdentityService.ViewerId, dragon));
+                DbPlayerDragonReliability reliability = new(playerIdentityService.ViewerId, dragon);
+                apiContext.PlayerDragonReliability.Add(reliability);
                 ownedReliabilities.Add(dragon);
+                this.AddDefaultLevelStories(dragon, reliability.Level);
             }
 
             resultDict.Add(key, GrantReturn.Added());
@@ -110,6 +118,36 @@ IDictionary<TKey, Entity> entities
         return resultDict;
     }
 
+    private void AddDefaultLevelStories(DragonId dragon, int reliabilityLevel)
+    {
+        if (
+            reliabilityLevel < 5
+            || !MasterAsset.DragonStories.TryGetValue((int)dragon, out StoryData? storyData)
+        )
+        {
+            return;
+        }
+
+        Debug.Assert(
+            storyData.StoryIds.Length == 2,
+            "Expected all dragons to have exactly two stories"
+        );
+
+        int storiesToUnlock = reliabilityLevel >= 15 ? 2 : 1;
+
+        for (int i = 0; i < storiesToUnlock; i++)
+        {
+            apiContext.PlayerStoryState.Add(
+                new DbPlayerStoryState()
+                {
+                    ViewerId = playerIdentityService.ViewerId,
+                    StoryType = StoryTypes.Dragon,
+                    StoryId = storyData.StoryIds[i],
+                }
+            );
+        }
+    }
+
     private static partial class Log
     {
         [LoggerMessage(