【C#/Blazor】実務Webアプリ開発編 (33)DBのSeedデータを冪等に入れる ～アプリに必要なデータと開発用データを分ける～

// 起動のたびに3件ずつ増える
db.Categories.AddRange(
    new Category("食品"),
    new Category("日用品"),
    new Category("家電"));
await db.SaveChangesAsync();

foreach (var name in new[] { "食品", "日用品", "家電" })
{
    // 名前で、もうあるかを確かめる
    if (!await db.Categories.AnyAsync(c => c.Name == name))
        db.Categories.Add(new Category(name));
}
await db.SaveChangesAsync();

modelBuilder.Entity<Category>()
    .HasIndex(c => c.Name)
    .IsUnique();

src/
├── MentorApp.Infrastructure/
│   ├── Persistence/
│   │   ├── DatabaseInitializer.cs  ← DB作成
│   │   ├── DevelopmentDataSeeder.cs  ← 開発用データ
│   │   └── InitialAdminSeeder.cs  ← 必要なデータ
│   └── InfrastructureInitialization.cs  ← 窓口
└── MentorApp.Web/
    └── Program.cs  ← 呼び分け

// …（サービスの登録など・88 行省略）
// ========================================
// フェーズ3: 起動時処理
// ========================================
try
{
    Log.Information("================================================================================");
    Log.Information($"MentorApp 起動プロセス開始({app.Environment.EnvironmentName})");
    Log.Information("================================================================================");

    // 環境に応じたDB初期化
    if (app.Environment.IsDevelopment() || app.Environment.IsProduction())
    {
        Log.Information("データベースを初期化しています");
        await InfrastructureInitialization.InitializeRequiredDataAsync(app.Services);

        if (app.Environment.IsDevelopment())
        {
            Log.Information("開発環境: サンプルデータを生成しています");
            await InfrastructureInitialization.SeedDevelopmentDataAsync(app.Services);
        }
    }
    else if (app.Environment.IsEnvironment("Testing"))
    {
        // Testing環境：DB初期化はスキップ
        // テストコード（WebApplicationFactory）が明示的にDB作成・削除を管理する
        Log.Information("Testing環境: DB初期化はテストフィクスチャーで管理されます");
    }
    else
    {
        // 想定外の環境名
        Log.Warning("未定義の環境 '{EnvironmentName}' が指定されています。DB初期化をスキップします。", app.Environment.EnvironmentName);
    }

    app.Run();
// …（例外処理・5 行省略）
finally
{
    Log.CloseAndFlush();
}

    /// <summary>
    /// データベースの作成と初期管理者のシードを実行する
    /// </summary>
    /// <remarks>
    /// Production/Development 環境の両方で実行される。
    /// - データベースの作成（マイグレーション未使用時）
    /// - 初期管理者のシード（設定されている場合）
    /// Web層（Program.cs）から明示的に呼び出す。
    /// </remarks>
    public static async Task InitializeRequiredDataAsync(IServiceProvider services)
    {
        using var scope = services.CreateScope();
        var scopedServices = scope.ServiceProvider;

        // データベース作成
        await DatabaseInitializer.EnsureCreatedAsync(scopedServices);

        // 初期管理者のシード（UoW / Repository 経由）
        var authOptions = scopedServices.GetRequiredService<IOptions<AuthenticationOptions>>().Value;
        if (authOptions.InitialAdmin.IsConfigured)
        {
            var uowFactory = scopedServices.GetRequiredService<IUnitOfWorkFactory>();
            var timeProvider = scopedServices.GetRequiredService<TimeProvider>();
            var loggerFactory = scopedServices.GetRequiredService<ILoggerFactory>();
            var logger = loggerFactory.CreateLogger(typeof(InfrastructureInitialization));

            await InitialAdminSeeder.SeedAsync(
                uowFactory,
                timeProvider,
                authOptions.InitialAdmin.ExternalId!,
                authOptions.InitialAdmin.DisplayName,
                authOptions.InitialAdmin.Email!,
                logger);
        }
    }

{
    …（DBの設定・4 行省略）
    "Authentication": {
        "Provider": "Mock",
        "InitialAdmin": {
            "ExternalId": "YOUR_ENTRA_OBJECT_ID",
            "DisplayName": "初期管理者",
            "Email": "admin@example.com"
        },
        …（認証サービス・ログの設定・20 行省略）
}

    /// <summary>
    /// 初期管理者をシードする
    /// </summary>
    /// <remarks>
    /// appsettings.jsonの設定値に基づき、指定されたExternalIdを持つ
    /// Admin権限のユーザーを作成する。本番環境でも使用する。
    /// 対象ユーザーが既に存在する場合はロールを変更しない（意図して降格した管理者を、再起動で戻さないため）。
    /// ただし管理者が1人もいない場合は、画面から回復できないため Admin に昇格する。
    /// </remarks>
    public static async Task SeedAsync(
        IUnitOfWorkFactory uowFactory,
        TimeProvider timeProvider,
        string externalId,
        string displayName,
        string email,
        ILogger logger)
    {
        if (string.IsNullOrWhiteSpace(externalId))
        {
            logger.LogWarning("初期管理者のExternalIdが設定されていません。スキップします。");
            return;
        }

        if (string.IsNullOrWhiteSpace(email))
        {
            logger.LogWarning("初期管理者のEmailが設定されていません。スキップします。");
            return;
        }

        await using var uow = await uowFactory.CreateAsync();

        var existingUser = await uow.Users.FindByExternalIdAsync(externalId);
        if (existingUser != null)
        {
            if (existingUser.Role == Role.Admin)
            {
                logger.LogInformation("初期管理者は既にAdminとして存在します: {DisplayName}", existingUser.DisplayName);
                return;
            }

            if (await uow.Users.HasAnyByRoleAsync(Role.Admin))
            {
                logger.LogInformation("初期管理者のユーザーはAdminではありませんが、ほかにAdminがいるためロールは変更しません: {DisplayName} (Role: {Role})",
                    existingUser.DisplayName, existingUser.Role);
                return;
            }

            var previousRole = existingUser.Role;
            existingUser.ChangeRole(Role.Admin);
            await uow.SaveChangesAsync();

            logger.LogWarning("管理者が1人もいないため、初期管理者のユーザーをAdminに昇格しました: {DisplayName} (ExternalId: {ExternalId}, PreviousRole: {PreviousRole})",
                existingUser.DisplayName, externalId, previousRole);
            return;
        }

        var now = timeProvider.GetUtcNow();
        var admin = new User(externalId, displayName, now, email, Role.Admin);
        await uow.Users.AddAsync(admin);
        await uow.SaveChangesAsync();

        logger.LogInformation("初期管理者を作成しました: {DisplayName} (ExternalId: {ExternalId}, Email: {Email})",
            displayName, externalId, email);
    }

    private static void ConfigureUser(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>(entity =>
        {
            // Id はアプリ側で生成されるため、ValueGeneratedNeverを指定
            entity.Property(x => x.Id).ValueGeneratedNever();

            entity.Property(e => e.ExternalId)
                .HasMaxLength(User.ExternalIdMaxLength);

            // ExternalIdはIdPが発行するユーザー識別子。
            // 同一ユーザーの二重登録を防ぐため、DB側でも一意性を保証する
            entity.HasIndex(e => e.ExternalId)
                .IsUnique();

            entity.Property(e => e.DisplayName)
                .HasMaxLength(User.DisplayNameMaxLength);

            entity.Property(e => e.Email)
                .HasMaxLength(Email.MaxLength)
                .HasConversion(
                    email => email.Value,
                    value => new Email(value));
        });
    }

    /// <summary>
    /// 開発用データをシードする
    /// </summary>
    /// <remarks>
    /// 6名のモックユーザー（admin×1, mentor×2, mentee×3）と関連データを作成する。
    /// </remarks>
    public static async Task SeedAsync(
        IUnitOfWorkFactory uowFactory,
        DateTimeOffset baseTime,
        ILogger logger)
    {
        var timeSeq = new TimeSequence(baseTime);

        var users = await SeedUsersAsync(uowFactory, timeSeq, logger);
        var mentorships = await SeedMentorshipsAsync(uowFactory, users, timeSeq, logger);
        await SeedTopicsAndMessagesAsync(uowFactory, mentorships, users, timeSeq, logger);
    }

// …（usingと定数・24 行省略）
    private static readonly DevUserDefinition[] DevelopmentUsers =
    [
        new(DevUserIds.Admin1, "管理者(ダミー)", "admin1@example.com", Role.Admin),
        new(DevUserIds.Mentor1, "メンター太郎(ダミー)", "mentor1@example.com", Role.Mentor),
        new(DevUserIds.Mentor2, "メンター次郎(ダミー)", "mentor2@example.com", Role.Mentor),
        new(DevUserIds.Mentee1, "メンティー花子(ダミー)", "mentee1@example.com", Role.Mentee),
        new(DevUserIds.Mentee2, "メンティー桜(ダミー)", "mentee2@example.com", Role.Mentee),
        new(DevUserIds.Mentee3, "メンティー梅(ダミー)", "mentee3@example.com", Role.Mentee)
    ];

    // …（メンタリング・トピックのSeedデータと処理・252 行省略）

    private static async Task<UserLookup> SeedUsersAsync(
        IUnitOfWorkFactory uowFactory,
        TimeSequence timeSeq,
        ILogger logger)
    {
        await using var uow = await uowFactory.CreateAsync();
        var addedCount = 0;
        var userDict = new Dictionary<string, User>();

        foreach (var def in DevelopmentUsers)
        {
            var existingUser = await uow.Users.FindByExternalIdAsync(def.ExternalId);
            if (existingUser != null)
            {
                userDict[def.ExternalId] = existingUser;
                logger.LogDebug("開発用ユーザーは既に存在します: {ExternalId}", def.ExternalId);
                continue;
            }

            var user = new User(def.ExternalId, def.DisplayName, timeSeq.Next(), def.Email, def.Role);
            await uow.Users.AddAsync(user);
            userDict[def.ExternalId] = user;
            addedCount++;

            logger.LogDebug("開発用ユーザーを追加しました: {DisplayName} (ExternalId: {ExternalId})",
                def.DisplayName, def.ExternalId);
        }

        if (addedCount > 0)
        {
            await uow.SaveChangesAsync();
            logger.LogInformation("開発用ユーザーをシードしました: {Count}名のユーザーを追加", addedCount);
        }
        else
        {
            logger.LogInformation("開発用ユーザーは全て存在しています。追加なし。");
        }

        return new UserLookup(userDict);
    }

    private static async Task<MentorshipLookup> SeedMentorshipsAsync(
        IUnitOfWorkFactory uowFactory,
        UserLookup users,
        TimeSequence timeSeq,
        ILogger logger)
    {
        await using var uow = await uowFactory.CreateAsync();
        var mentorshipDict = new Dictionary<(string, string), Mentorship>();
        var addedCount = 0;

        foreach (var def in DevelopmentMentorships)
        {
            var mentorId = users.GetId(def.MentorExternalId);
            var menteeId = users.GetId(def.MenteeExternalId);

            var existingMentorship = await uow.Mentorships.FindByMentorAndMenteeAsync(mentorId, menteeId);
            if (existingMentorship != null)
            {
                mentorshipDict[(def.MentorExternalId, def.MenteeExternalId)] = existingMentorship;
                logger.LogDebug("開発用 Mentorship は既に存在します: {MentorId} - {MenteeId}",
                    def.MentorExternalId, def.MenteeExternalId);
                continue;
            }

            var mentorship = new Mentorship(mentorId, menteeId, timeSeq.Next());
            await uow.Mentorships.AddAsync(mentorship);
            mentorshipDict[(def.MentorExternalId, def.MenteeExternalId)] = mentorship;
            addedCount++;

            logger.LogDebug("開発用 Mentorship を追加しました: {MentorId} - {MenteeId}",
                def.MentorExternalId, def.MenteeExternalId);
        }

        if (addedCount > 0)
        {
            await uow.SaveChangesAsync();
            logger.LogInformation("開発用 Mentorship をシードしました: {Count}件の関係を追加", addedCount);
        }
        else
        {
            logger.LogInformation("開発用 Mentorship は全て存在しています。追加なし。");
        }

        return new MentorshipLookup(mentorshipDict);
    }

    private static async Task SeedTopicsAndMessagesAsync(
        IUnitOfWorkFactory uowFactory,
        MentorshipLookup mentorships,
        UserLookup users,
        TimeSequence timeSeq,
        ILogger logger)
    {
        await using var uow = await uowFactory.CreateAsync();
        var addedCount = 0;

        foreach (var def in DevelopmentTopics)
        {
            var mentorship = mentorships.Get(def.MentorExternalId, def.MenteeExternalId);

            var existingTopic = await uow.Topics.FindByMentorshipAndTitleAsync(mentorship.Id, def.Title);
            if (existingTopic != null)
            {
                logger.LogDebug("開発用 Topic は既に存在します: {Title}", def.Title);
                continue;
            }

            var topic = new Topic(mentorship.Id, def.Title, timeSeq.Next(TopicTimeIncrement));

            foreach (var msgDef in def.Messages)
            {
                topic.PostMessage(users.GetId(msgDef.SenderExternalId), msgDef.Content, timeSeq.Next());
            }

            await uow.Topics.AddAsync(topic);
            addedCount++;

            logger.LogDebug("開発用 Topic を追加しました: {Title} ({MessageCount}件のメッセージ)",
                def.Title, topic.Messages.Count);
        }

        if (addedCount > 0)
        {
            await uow.SaveChangesAsync();
            logger.LogInformation("開発用 Topic と Message をシードしました: {Count}件のトピックを追加", addedCount);
        }
        else
        {
            logger.LogInformation("開発用 Topic は全て存在しています。追加なし。");
        }
    }

[17:35:28 INF] 初期管理者は既にAdminとして存在します: 初期管理者
[17:35:28 INF] 開発環境: サンプルデータを生成しています
[17:35:28 INF] 開発用ユーザーは全て存在しています。追加なし。
[17:35:28 INF] 開発用 Mentorship は全て存在しています。追加なし。
[17:35:28 INF] 開発用 Topic は全て存在しています。追加なし。