Foxnouns.NET/migrators/NetImporter/ImportUser.cs

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using Foxnouns.Backend.Database;
using Foxnouns.Backend.Database.Models;
using Microsoft.EntityFrameworkCore;
using NodaTime;
using NodaTime.Extensions;
using Serilog;

namespace NetImporter;

public static class Users
{
    public static async Task ImportUsers(string filename)
    {
        await using var db = await NetImporter.GetContextAsync();
        await db.Database.ExecuteSqlRawAsync("SELECT 1");

        var stopwatch = new Stopwatch();
        stopwatch.Start();

        var users = NetImporter
            .ReadFromFile<ImportUser>(filename)
            .Output.Select(ConvertUser)
            .ToList();
        db.AddRange(users);
        await db.SaveChangesAsync();

        stopwatch.Stop();
        Log.Information(
            "Imported {Count} users in {Duration}",
            users.Count,
            stopwatch.ElapsedDuration()
        );
    }

    private static User ConvertUser(ImportUser oldUser)
    {
        var user = new User
        {
            Id = oldUser.Id,
            Username = oldUser.Username,
            DisplayName = oldUser.DisplayName,
            Bio = oldUser.Bio,
            MemberTitle = oldUser.MemberTitle,
            LastActive = oldUser.LastActive.ToInstant(),
            Avatar = oldUser.AvatarHash,
            Links = oldUser.Links ?? [],

            Role = oldUser.ParseRole(),
            Deleted = oldUser.Deleted,
            DeletedAt = oldUser.DeletedAt?.ToInstant(),
            DeletedBy = null,
        };

        if (oldUser is { DiscordId: not null, DiscordUsername: not null })
        {
            user.AuthMethods.Add(
                new AuthMethod
                {
                    Id = SnowflakeGenerator.Instance.GenerateSnowflake(),
                    AuthType = AuthType.Discord,
                    RemoteId = oldUser.DiscordId,
                    RemoteUsername = oldUser.DiscordUsername,
                }
            );
        }

        if (oldUser is { TumblrId: not null, TumblrUsername: not null })
        {
            user.AuthMethods.Add(
                new AuthMethod
                {
                    Id = SnowflakeGenerator.Instance.GenerateSnowflake(),
                    AuthType = AuthType.Tumblr,
                    RemoteId = oldUser.TumblrId,
                    RemoteUsername = oldUser.TumblrUsername,
                }
            );
        }

        if (oldUser is { GoogleId: not null, GoogleUsername: not null })
        {
            user.AuthMethods.Add(
                new AuthMethod
                {
                    Id = SnowflakeGenerator.Instance.GenerateSnowflake(),
                    AuthType = AuthType.Google,
                    RemoteId = oldUser.GoogleId,
                    RemoteUsername = oldUser.GoogleUsername,
                }
            );
        }

        // Convert all custom preference UUIDs to snowflakes
        var prefMapping = new Dictionary<string, Snowflake>();
        foreach (var (key, value) in oldUser.CustomPreferences)
        {
            var newKey = SnowflakeGenerator.Instance.GenerateSnowflake();
            prefMapping[key] = newKey;
            user.CustomPreferences[newKey] = value;
        }

        foreach (var name in oldUser.Names ?? [])
        {
            user.Names.Add(
                new FieldEntry
                {
                    Value = name.Value,
                    Status = prefMapping.TryGetValue(name.Status, out var newStatus)
                        ? newStatus.ToString()
                        : name.Status,
                }
            );
        }

        foreach (var pronoun in oldUser.Pronouns ?? [])
        {
            user.Pronouns.Add(
                new Pronoun
                {
                    Value = pronoun.Value,
                    DisplayText = pronoun.DisplayText,
                    Status = prefMapping.TryGetValue(pronoun.Status, out var newStatus)
                        ? newStatus.ToString()
                        : pronoun.Status,
                }
            );
        }

        foreach (var field in oldUser.Fields ?? [])
        {
            var entries = field
                .Entries.Select(entry => new FieldEntry
                {
                    Value = entry.Value,
                    Status = prefMapping.TryGetValue(entry.Status, out var newStatus)
                        ? newStatus.ToString()
                        : entry.Status,
                })
                .ToList();

            user.Fields.Add(new Field { Name = field.Name, Entries = entries.ToArray() });
        }

        Log.Debug("Converted user {UserId}", oldUser.Id);

        return user;
    }

    [SuppressMessage("ReSharper", "ClassNeverInstantiated.Local")]
    private record ImportUser(
        Snowflake Id,
        string Sid,
        string Username,
        string? DisplayName,
        string? Bio,
        string? MemberTitle,
        OffsetDateTime LastActive,
        string? AvatarHash,
        string[]? Links,
        FieldEntry[]? Names,
        Pronoun[]? Pronouns,
        Field[]? Fields,
        string? DiscordId,
        string? DiscordUsername,
        string? FediverseId,
        string? FediverseUsername,
        long? FediverseAppId,
        string? TumblrId,
        string? TumblrUsername,
        string? GoogleId,
        string? GoogleUsername,
        bool MemberListHidden,
        string? Timezone,
        string Role,
        bool Deleted,
        OffsetDateTime? DeletedAt,
        string? DeleteReason,
        Dictionary<string, User.CustomPreference> CustomPreferences
    )
    {
        public UserRole ParseRole() =>
            Role switch
            {
                "USER" => UserRole.User,
                "MODERATOR" => UserRole.Moderator,
                "ADMIN" => UserRole.Admin,
                _ => UserRole.User,
            };
    }
}