Feat: Admin configuration UI

Directory.Packages.props

@@ -10,6 +10,8 @@
     <PackageVersion Include="Ical.Net" Version="4.3.1" />
     <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.20" />
     <PackageVersion Include="Microsoft.AspNetCore.SpaProxy" Version="8.0.20" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.20" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.20" />
     <PackageVersion Include="Microsoft.Extensions.ApiDescription.Client" Version="8.0.20" />
     <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
     <PackageVersion Include="Microsoft.Extensions.Http" Version="8.0.1" />

ImmichFrame.Core.Tests/Logic/ReloadingImmichFrameLogicTests.cs

@@ -0,0 +1,125 @@
+using ImmichFrame.Core.Interfaces;
+using ImmichFrame.Core.Logic;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using NUnit.Framework;
+
+namespace ImmichFrame.Core.Tests.Logic;
+
+[TestFixture]
+public class ReloadingImmichFrameLogicTests
+{
+    private class FakeSettingsProvider : ISettingsProvider
+    {
+        public IServerSettings Current { get; set; } = Mock.Of<IServerSettings>();
+        public event EventHandler<SettingsChangedEventArgs>? SettingsChanged;
+
+        public void Raise(bool accountsChanged) => SettingsChanged?.Invoke(this, new SettingsChangedEventArgs
+        {
+            NewSettings = Current,
+            AccountsChanged = accountsChanged,
+            GeneralChanged = true
+        });
+    }
+
+    private class DisposableLogicMock : Mock<IImmichFrameLogic>
+    {
+        public DisposableLogicMock() : base(MockBehavior.Loose)
+        {
+            As<IDisposable>();
+        }
+
+        public bool IsDisposed
+        {
+            get
+            {
+                try
+                {
+                    As<IDisposable>().Verify(d => d.Dispose(), Times.AtLeastOnce);
+                    return true;
+                }
+                catch (MockException)
+                {
+                    return false;
+                }
+            }
+        }
+    }
+
+    private FakeSettingsProvider _provider;
+    private List<DisposableLogicMock> _created;
+    private ReloadingImmichFrameLogic _logic;
+
+    [SetUp]
+    public void Setup()
+    {
+        _provider = new FakeSettingsProvider();
+        _created = new List<DisposableLogicMock>();
+        _logic = new ReloadingImmichFrameLogic(_provider, () =>
+        {
+            var mock = new DisposableLogicMock();
+            _created.Add(mock);
+            return mock.Object;
+        }, NullLogger<ReloadingImmichFrameLogic>.Instance, disposeGraceDelay: TimeSpan.Zero);
+    }
+
+    [TearDown]
+    public void TearDown() => _logic.Dispose();
+
+    [Test]
+    public void Constructor_BuildsInnerOnce()
+    {
+        Assert.That(_created, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task AccountsChanged_SwapsInnerAndDisposesOld()
+    {
+        _provider.Raise(accountsChanged: true);
+
+        Assert.That(_created, Has.Count.EqualTo(2));
+
+        await _logic.GetTotalAssets();
+        _created[0].Verify(l => l.GetTotalAssets(), Times.Never);
+        _created[1].Verify(l => l.GetTotalAssets(), Times.Once);
+
+        // Old instance is disposed after the (zero) grace delay
+        await WaitUntil(() => _created[0].IsDisposed);
+    }
+
+    [Test]
+    public async Task GeneralOnlyChange_KeepsInner()
+    {
+        _provider.Raise(accountsChanged: false);
+
+        Assert.That(_created, Has.Count.EqualTo(1));
+        await _logic.GetTotalAssets();
+        _created[0].Verify(l => l.GetTotalAssets(), Times.Once);
+    }
+
+    [Test]
+    public void Dispose_DisposesCurrentInnerAndUnsubscribes()
+    {
+        _logic.Dispose();
+
+        Assert.That(_created[0].IsDisposed, Is.True);
+
+        // Raising after dispose must not rebuild
+        _provider.Raise(accountsChanged: true);
+        Assert.That(_created, Has.Count.EqualTo(1));
+    }
+
+    private static async Task WaitUntil(Func<bool> condition, int timeoutMs = 2000)
+    {
+        var start = DateTime.UtcNow;
+        while (!condition())
+        {
+            if ((DateTime.UtcNow - start).TotalMilliseconds > timeoutMs)
+            {
+                Assert.Fail("Condition was not met in time");
+            }
+
+            await Task.Delay(10);
+        }
+    }
+}

ImmichFrame.Core/Interfaces/IServerBehaviorSettings.cs

@@ -9,5 +9,6 @@ public interface IServerBehaviorSettings
         public string? UnitSystem { get; }
         public string? Webhook { get; }
         public string? AuthenticationSecret { get; }
+        public string? AdminPassword { get; }
     }
 }

ImmichFrame.Core/Interfaces/ISettingsProvider.cs

@@ -0,0 +1,17 @@
+namespace ImmichFrame.Core.Interfaces
+{
+    public interface ISettingsProvider
+    {
+        IServerSettings Current { get; }
+        event EventHandler<SettingsChangedEventArgs>? SettingsChanged;
+    }
+
+    public class SettingsChangedEventArgs : EventArgs
+    {
+        public required IServerSettings NewSettings { get; init; }
+        // Accounts list changed or RefreshAlbumPeopleInterval changed — the account
+        // logic graph (pools, caches) must be rebuilt for these to take effect.
+        public bool AccountsChanged { get; init; }
+        public bool GeneralChanged { get; init; }
+    }
+}

ImmichFrame.Core/Logic/AccountSelection/TotalAccountImagesSelectionStrategy.cs

@@ -12,9 +12,15 @@
 {
     public async Task<(IAccountImmichFrameLogic, AssetResponseDto)?> GetNextAsset()
     {
+        if (_accounts.Count == 0)
+        {
+            _logger.LogDebug("No accounts configured, returning no asset");
+            return null;
+        }
+
         var chosen = await _accounts.ChooseOne(logic => logic.GetTotalAssets());
 
         var asset = await chosen.GetNextAsset();
         if (asset != null)
         {
             await _tracker.RecordAssetLocation(chosen, asset.Id);

ImmichFrame.Core/Logic/MultiImmichFrameLogicDelegate.cs

@@ -7,7 +7,7 @@
 
 namespace ImmichFrame.Core.Logic;
 
-public class MultiImmichFrameLogicDelegate : IImmichFrameLogic
+public class MultiImmichFrameLogicDelegate : IImmichFrameLogic, IDisposable
 {
     private readonly FrozenDictionary<IAccountSettings, IAccountImmichFrameLogic> _accountToDelegate;
     private readonly IServerSettings _serverSettings;
@@ -56,6 +56,14 @@ public async Task<long> GetTotalAssets()
 
     public Task SendWebhookNotification(IWebhookNotification notification) =>
         WebhookHelper.SendWebhookNotification(notification, _serverSettings.GeneralSettings.Webhook);
+
+    public void Dispose()
+    {
+        foreach (var accountLogic in _accountToDelegate.Values)
+        {
+            (accountLogic as IDisposable)?.Dispose();
+        }
+    }
 }
 
 public static class AccountAndAssetExtensions

ImmichFrame.Core/Logic/PooledImmichFrameLogic.cs

@@ -7,7 +7,7 @@
 
 namespace ImmichFrame.Core.Logic;
 
-public class PooledImmichFrameLogic : IAccountImmichFrameLogic
+public class PooledImmichFrameLogic : IAccountImmichFrameLogic, IDisposable
 {
     private readonly IGeneralSettings _generalSettings;
     private readonly IApiCache _apiCache;
@@ -204,4 +204,6 @@ public async Task SendWebhookNotification(IWebhookNotification notification) =>
         await WebhookHelper.SendWebhookNotification(notification, _generalSettings.Webhook);
 
     public override string ToString() => $"Account Pool [{_immichApi.BaseUrl}]";
+
+    public void Dispose() => (_apiCache as IDisposable)?.Dispose();
 }

ImmichFrame.Core/Logic/ReloadingImmichFrameLogic.cs

@@ -0,0 +1,110 @@
+using ImmichFrame.Core.Api;
+using ImmichFrame.Core.Interfaces;
+using ImmichFrame.Core.Models;
+using Microsoft.Extensions.Logging;
+
+namespace ImmichFrame.Core.Logic;
+
+/// <summary>
+/// Delegates to an inner <see cref="IImmichFrameLogic"/> that is rebuilt whenever the
+/// account settings change, so account changes apply without a restart. The previous
+/// instance is disposed after a grace delay to let in-flight requests finish.
+/// </summary>
+public class ReloadingImmichFrameLogic : IImmichFrameLogic, IDisposable
+{
+    private static readonly TimeSpan DefaultDisposeGraceDelay = TimeSpan.FromSeconds(60);
+
+    private readonly Func<IImmichFrameLogic> _innerFactory;
+    private readonly ISettingsProvider _settingsProvider;
+    private readonly ILogger<ReloadingImmichFrameLogic> _logger;
+    private readonly TimeSpan _disposeGraceDelay;
+    private readonly object _swapLock = new();
+    private volatile IImmichFrameLogic _inner;
+    private bool _disposed;
+
+    public ReloadingImmichFrameLogic(ISettingsProvider settingsProvider, Func<IImmichFrameLogic> innerFactory,
+        ILogger<ReloadingImmichFrameLogic> logger, TimeSpan? disposeGraceDelay = null)
+    {
+        _settingsProvider = settingsProvider;
+        _innerFactory = innerFactory;
+        _logger = logger;
+        _disposeGraceDelay = disposeGraceDelay ?? DefaultDisposeGraceDelay;
+        _inner = innerFactory();
+        _settingsProvider.SettingsChanged += OnSettingsChanged;
+    }
+
+    private void OnSettingsChanged(object? sender, SettingsChangedEventArgs args)
+    {
+        if (!args.AccountsChanged)
+            return;
+
+        IImmichFrameLogic? old;
+        lock (_swapLock)
+        {
+            if (_disposed)
+                return;
+
+            _logger.LogInformation("Account settings changed, rebuilding asset logic");
+            old = Interlocked.Exchange(ref _inner, _innerFactory());
+        }
+
+        if (old is IDisposable disposable)
+        {
+            var delay = _disposeGraceDelay;
+            _ = Task.Run(async () =>
+            {
+                await Task.Delay(delay);
+                DisposeInner(disposable);
+            });
+        }
+    }
+
+    private void DisposeInner(IDisposable disposable)
+    {
+        try
+        {
+            disposable.Dispose();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to dispose previous asset logic");
+        }
+    }
+
+    public Task<AssetResponseDto?> GetNextAsset() => _inner.GetNextAsset();
+
+    public Task<IEnumerable<AssetResponseDto>> GetAssets() => _inner.GetAssets();
+
+    public Task<AssetResponseDto> GetAssetInfoById(Guid assetId) => _inner.GetAssetInfoById(assetId);
+
+    public Task<IEnumerable<AssetFaceResponseDto>> GetAssetFacesById(Guid assetId) => _inner.GetAssetFacesById(assetId);
+
+    public Task<IEnumerable<AlbumResponseDto>> GetAlbumInfoById(Guid assetId) => _inner.GetAlbumInfoById(assetId);
+
+    public Task<AssetResponse> GetAsset(Guid assetId, AssetTypeEnum? assetType = null, string? rangeHeader = null)
+        => _inner.GetAsset(assetId, assetType, rangeHeader);
+
+    public Task<long> GetTotalAssets() => _inner.GetTotalAssets();
+
+    public Task SendWebhookNotification(IWebhookNotification notification) => _inner.SendWebhookNotification(notification);
+
+    public void Dispose()
+    {
+        _settingsProvider.SettingsChanged -= OnSettingsChanged;
+
+        IImmichFrameLogic? current;
+        lock (_swapLock)
+        {
+            if (_disposed)
+                return;
+
+            _disposed = true;
+            current = _inner;
+        }
+
+        if (current is IDisposable disposable)
+        {
+            DisposeInner(disposable);
+        }
+    }
+}