PalacePal/Pal.Client/Scheduled/QueuedImport.cs

using System;
using System.IO;
using System.Threading.Tasks;
using Export;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Pal.Client.Database;
using Pal.Client.DependencyInjection;
using Pal.Client.Properties;
using Pal.Client.Windows;
using Pal.Common;

namespace Pal.Client.Scheduled;

internal sealed class QueuedImport : IQueueOnFrameworkThread
{
    private ExportRoot Export { get; }
    private Guid ExportId { get; set; }
    private int ImportedTraps { get; set; }
    private int ImportedHoardCoffers { get; set; }

    public QueuedImport(string sourcePath)
    {
        using var input = File.OpenRead(sourcePath);
        Export = ExportRoot.Parser.ParseFrom(input);
    }

    internal sealed class Handler : IQueueOnFrameworkThread.Handler<QueuedImport>
    {
        private readonly IServiceScopeFactory _serviceScopeFactory;
        private readonly Chat _chat;
        private readonly ImportService _importService;
        private readonly ConfigWindow _configWindow;

        public Handler(
            ILogger<Handler> logger,
            IServiceScopeFactory serviceScopeFactory,
            Chat chat,
            ImportService importService,
            ConfigWindow configWindow)
            : base(logger)
        {
            _serviceScopeFactory = serviceScopeFactory;
            _chat = chat;
            _importService = importService;
            _configWindow = configWindow;
        }

        protected override void Run(QueuedImport import, ref bool recreateLayout)
        {
            recreateLayout = true;

            try
            {
                if (!Validate(import))
                    return;

                Task.Run(() =>
                {
                    try
                    {
                        using (var scope = _serviceScopeFactory.CreateScope())
                        {
                            using var dbContext = scope.ServiceProvider.GetRequiredService<PalClientContext>();
                            (import.ImportedTraps, import.ImportedHoardCoffers) =
                                _importService.Import(import.Export);
                        }

                        _configWindow.UpdateLastImport();

                        _logger.LogInformation(
                            "Imported {ExportId} for {Traps} traps, {Hoard} hoard coffers", import.ExportId,
                            import.ImportedTraps, import.ImportedHoardCoffers);
                        _chat.Message(string.Format(Localization.ImportCompleteStatistics, import.ImportedTraps,
                            import.ImportedHoardCoffers));
                    }
                    catch (Exception e)
                    {
                        _logger.LogError(e, "Import failed in inner task");
                        _chat.Error(string.Format(Localization.Error_ImportFailed, e));
                    }
                });
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Import failed");
                _chat.Error(string.Format(Localization.Error_ImportFailed, e));
            }
        }

        private bool Validate(QueuedImport import)
        {
            if (import.Export.ExportVersion != ExportConfig.ExportVersion)
            {
                _logger.LogError(
                    "Import: Different version in export file, {ExportVersion} != {ConfiguredVersion}",
                    import.Export.ExportVersion, ExportConfig.ExportVersion);
                _chat.Error(Localization.Error_ImportFailed_IncompatibleVersion);
                return false;
            }

            if (!Guid.TryParse(import.Export.ExportId, out Guid exportId) || exportId == Guid.Empty)
            {
                _logger.LogError("Import: Invalid export id '{Id}'", import.Export.ExportId);
                _chat.Error(Localization.Error_ImportFailed_InvalidFile);
                return false;
            }

            import.ExportId = exportId;

            if (string.IsNullOrEmpty(import.Export.ServerUrl))
            {
                // If we allow for backups as import/export, this should be removed
                _logger.LogError("Import: No server URL");
                _chat.Error(Localization.Error_ImportFailed_InvalidFile);
                return false;
            }

            return true;
        }
    }
}