configuration rework

MareSynchronos/Export/MareCharaFileManager.cs

@@ -12,13 +12,13 @@ public class MareCharaFileManager
 {
     private readonly FileCacheManager _manager;
     private readonly IpcManager _ipcManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly DalamudUtil _dalamudUtil;
     private readonly MareCharaFileDataFactory _factory;
     public MareCharaFileHeader? LoadedCharaFile { get; private set; }
     public bool CurrentlyWorking { get; private set; } = false;
 
-    public MareCharaFileManager(FileCacheManager manager, IpcManager ipcManager, ConfigurationService configService, DalamudUtil dalamudUtil)
+    public MareCharaFileManager(FileCacheManager manager, IpcManager ipcManager, MareConfigService configService, DalamudUtil dalamudUtil)
     {
         _factory = new(manager);
         _manager = manager;

MareSynchronos/Factories/PairFactory.cs

@@ -6,10 +6,10 @@ namespace MareSynchronos.Factories;
 
 public class PairFactory
 {
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly ServerConfigurationManager _serverConfigurationManager;
 
-    public PairFactory(ConfigurationService configService, ServerConfigurationManager serverConfigurationManager)
+    public PairFactory(MareConfigService configService, ServerConfigurationManager serverConfigurationManager)
     {
         _configService = configService;
         _serverConfigurationManager = serverConfigurationManager;

MareSynchronos/FileCache/FileCacheManager.cs

@@ -12,14 +12,14 @@ public class FileCacheManager : IDisposable
     private const string _penumbraPrefix = "{penumbra}";
     private const string _cachePrefix = "{cache}";
     private readonly IpcManager _ipcManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly string _csvPath;
     private string CsvBakPath => _csvPath + ".bak";
     private readonly ConcurrentDictionary<string, FileCacheEntity> _fileCaches = new(StringComparer.Ordinal);
     public const string CsvSplit = "|";
     private readonly object _fileWriteLock = new();
 
-    public FileCacheManager(IpcManager ipcManager, ConfigurationService configService)
+    public FileCacheManager(IpcManager ipcManager, MareConfigService configService)
     {
         _ipcManager = ipcManager;
         _configService = configService;

MareSynchronos/FileCache/PeriodicFileScanner.cs

@@ -9,13 +9,13 @@ namespace MareSynchronos.FileCache;
 public class PeriodicFileScanner : MediatorSubscriberBase, IDisposable
 {
     private readonly IpcManager _ipcManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly FileCacheManager _fileDbManager;
     private CancellationTokenSource? _scanCancellationTokenSource;
     private Task? _fileScannerTask = null;
     public ConcurrentDictionary<string, int> haltScanLocks = new(StringComparer.Ordinal);
 
-    public PeriodicFileScanner(IpcManager ipcManager, ConfigurationService configService, FileCacheManager fileDbManager, MareMediator mediator) : base(mediator)
+    public PeriodicFileScanner(IpcManager ipcManager, MareConfigService configService, FileCacheManager fileDbManager, MareMediator mediator) : base(mediator)
     {
         Logger.Verbose("Creating " + nameof(PeriodicFileScanner));
 

MareSynchronos/Managers/NotificationService.cs

@@ -3,6 +3,7 @@ using Dalamud.Game.Text.SeStringHandling;
 using Dalamud.Interface;
 using Dalamud.Interface.Internal.Notifications;
 using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Models;
 using MareSynchronos.Mediator;
 using MareSynchronos.Utils;
 
@@ -11,9 +12,9 @@ public class NotificationService : MediatorSubscriberBase
 {
     private readonly UiBuilder _uiBuilder;
     private readonly ChatGui _chatGui;
-    private readonly ConfigurationService _configurationService;
+    private readonly MareConfigService _configurationService;
 
-    public NotificationService(MareMediator mediator, UiBuilder uiBuilder, ChatGui chatGui, ConfigurationService configurationService) : base(mediator)
+    public NotificationService(MareMediator mediator, UiBuilder uiBuilder, ChatGui chatGui, MareConfigService configurationService) : base(mediator)
     {
         _uiBuilder = uiBuilder;
         _chatGui = chatGui;

MareSynchronos/Managers/PairManager.cs

@@ -22,10 +22,10 @@ public class PairManager : MediatorSubscriberBase, IDisposable
     private readonly ConcurrentDictionary<GroupData, GroupFullInfoDto> _allGroups = new(GroupDataComparer.Instance);
     private readonly CachedPlayerFactory _cachedPlayerFactory;
     private readonly PairFactory _pairFactory;
-    private readonly ConfigurationService _configurationService;
+    private readonly MareConfigService _configurationService;
 
     public PairManager(CachedPlayerFactory cachedPlayerFactory, PairFactory pairFactory,
-        ConfigurationService configurationService, MareMediator mediator) : base(mediator)
+        MareConfigService configurationService, MareMediator mediator) : base(mediator)
     {
         _cachedPlayerFactory = cachedPlayerFactory;
         _pairFactory = pairFactory;

MareSynchronos/Managers/ServerConfigurationManager.cs

@@ -1,22 +1,40 @@
 using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Models;
 using MareSynchronos.Models;
 using MareSynchronos.Utils;
 using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Logging.Abstractions;
+using System.Diagnostics;
 
 namespace MareSynchronos.Managers;
 
 public class ServerConfigurationManager
 {
     private readonly Dictionary<JwtCache, string> _tokenDictionary = new();
-    private readonly ConfigurationService _configService;
+    private readonly ServerConfigService _configService;
+    private readonly ServerTagConfigService _serverTagConfig;
+    private readonly NotesConfigService _notesConfig;
     private readonly DalamudUtil _dalamudUtil;
 
     public string CurrentApiUrl => string.IsNullOrEmpty(_configService.Current.CurrentServer) ? ApiController.MainServiceUri : _configService.Current.CurrentServer;
     public ServerStorage? CurrentServer => (_configService.Current.ServerStorage.ContainsKey(CurrentApiUrl) ? _configService.Current.ServerStorage[CurrentApiUrl] : null);
+    private ServerTagStorage CurrentServerTagStorage()
+    {
+        TryCreateCurrentServerTagStorage();
+        return _serverTagConfig.Current.ServerTagStorage[CurrentApiUrl];
+    }
 
-    public ServerConfigurationManager(ConfigurationService configService, DalamudUtil dalamudUtil)
+    private ServerNotesStorage CurrentNotesStorage()
+    {
+        TryCreateCurrentNotesStorage();
+        return _notesConfig.Current.ServerNotes[CurrentApiUrl];
+    }
+
+    public ServerConfigurationManager(ServerConfigService configService, ServerTagConfigService serverTagConfig, NotesConfigService notesConfig, DalamudUtil dalamudUtil)
     {
         _configService = configService;
+        _serverTagConfig = serverTagConfig;
+        _notesConfig = notesConfig;
         _dalamudUtil = dalamudUtil;
     }
 
@@ -48,7 +66,7 @@ public class ServerConfigurationManager
             {
                 _configService.Current.ServerStorage.Add(_configService.Current.CurrentServer, new ServerStorage() { ServerUri = ApiController.MainServiceUri, ServerName = ApiController.MainServer });
             }
-            _configService.Save();
+            Save();
             return CurrentServer!;
         }
     }
@@ -60,6 +78,8 @@ public class ServerConfigurationManager
 
     public void Save()
     {
+        var caller = new StackTrace().GetFrame(1)?.GetMethod()?.ReflectedType?.Name ?? "Unknown";
+        Logger.Debug(caller + " Calling config save");
         _configService.Save();
     }
 
@@ -138,14 +158,14 @@ public class ServerConfigurationManager
             WorldId = _dalamudUtil.WorldId,
             SecretKeyIdx = addLastSecretKey ? server.SecretKeys.Last().Key : -1,
         });
-        _configService.Save();
+        Save();
     }
 
     internal void AddEmptyCharacterToServer(int serverSelectionIndex)
     {
         var server = GetServerByIndex(serverSelectionIndex);
         server.Authentications.Add(new Authentication());
-        _configService.Save();
+        Save();
     }
 
     internal void RemoveCharacterFromServer(int serverSelectionIndex, Authentication item)
@@ -157,11 +177,160 @@ public class ServerConfigurationManager
     internal void AddServer(ServerStorage serverStorage)
     {
         _configService.Current.ServerStorage[serverStorage.ServerUri] = serverStorage;
-        _configService.Save();
+        Save();
     }
 
     internal void DeleteServer(ServerStorage selectedServer)
     {
         _configService.Current.ServerStorage.Remove(selectedServer.ServerUri);
+        Save();
+    }
+
+    internal void AddOpenPairTag(string tag)
+    {
+        CurrentServerTagStorage().OpenPairTags.Add(tag);
+        _serverTagConfig.Save();
+    }
+
+    internal void RemoveOpenPairTag(string tag)
+    {
+        CurrentServerTagStorage().OpenPairTags.Remove(tag);
+        _serverTagConfig.Save();
+    }
+
+    internal bool ContainsOpenPairTag(string tag)
+    {
+        return CurrentServerTagStorage().OpenPairTags.Contains(tag);
+    }
+
+    internal Dictionary<string, List<string>> GetUidServerPairedUserTags()
+    {
+        return CurrentServerTagStorage().UidServerPairedUserTags;
+    }
+
+    internal HashSet<string> GetServerAvailablePairTags()
+    {
+        return CurrentServerTagStorage().ServerAvailablePairTags;
+    }
+
+    internal void AddTag(string tag)
+    {
+        CurrentServerTagStorage().ServerAvailablePairTags.Add(tag);
+        _serverTagConfig.Save();
+    }
+
+    internal void RemoveTag(string tag)
+    {
+        CurrentServerTagStorage().ServerAvailablePairTags.Remove(tag);
+        foreach (var uid in GetUidsForTag(tag))
+        {
+            RemoveTagForUid(uid, tag, false);
+        }
+        _serverTagConfig.Save();
+    }
+
+    private void TryCreateCurrentServerTagStorage()
+    {
+        if (!_serverTagConfig.Current.ServerTagStorage.ContainsKey(CurrentApiUrl))
+        {
+            _serverTagConfig.Current.ServerTagStorage[CurrentApiUrl] = new();
+        }
+    }
+
+    private void TryCreateCurrentNotesStorage()
+    {
+        if (!_notesConfig.Current.ServerNotes.ContainsKey(CurrentApiUrl))
+        {
+            _notesConfig.Current.ServerNotes[CurrentApiUrl] = new();
+        }
+    }
+
+    internal void AddTagForUid(string uid, string tagName)
+    {
+        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        {
+            tags.Add(tagName);
+        }
+        else
+        {
+            CurrentServerTagStorage().UidServerPairedUserTags[uid] = new() { tagName };
+        }
+
+        _serverTagConfig.Save();
+    }
+
+    internal void RemoveTagForUid(string uid, string tagName, bool save = true)
+    {
+        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        {
+            tags.Remove(tagName);
+            if (save)
+                _serverTagConfig.Save();
+        }
+    }
+
+    internal bool ContainsTag(string uid, string tag)
+    {
+        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        {
+            return tags.Contains(tag, StringComparer.Ordinal);
+        }
+
+        return false;
+    }
+
+    internal bool HasTags(string uid)
+    {
+        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        {
+            return tags.Any();
+        }
+
+        return false;
+    }
+
+    internal HashSet<string> GetUidsForTag(string tag)
+    {
+        return CurrentServerTagStorage().UidServerPairedUserTags.Where(p => p.Value.Contains(tag, StringComparer.Ordinal)).Select(p => p.Key).ToHashSet(StringComparer.Ordinal);
+    }
+
+    internal string? GetNoteForUid(string uid)
+    {
+        if (CurrentNotesStorage().UidServerComments.TryGetValue(uid, out var note))
+        {
+            if (string.IsNullOrEmpty(note)) return null;
+            return note;
+        }
+        return null;
+    }
+
+    internal void SetNoteForUid(string uid, string note, bool save = true)
+    {
+        CurrentNotesStorage().UidServerComments[uid] = note;
+        if (save)
+            _notesConfig.Save();
+    }
+
+    internal void SaveNotes()
+    {
+        _notesConfig.Save();
+    }
+
+    internal string? GetNoteForGid(string gID)
+    {
+        if (CurrentNotesStorage().GidServerComments.TryGetValue(gID, out var note))
+        {
+            if (string.IsNullOrEmpty(note)) return null;
+            return note;
+        }
+
+        return null;
+    }
+
+    internal void SetNoteForGid(string gid, string note, bool save = true)
+    {
+        CurrentNotesStorage().GidServerComments[gid] = note;
+        if (save)
+            _notesConfig.Save();
     }
 }

MareSynchronos/Managers/TransientResourceManager.cs

@@ -10,7 +10,7 @@ namespace MareSynchronos.Managers;
 
 public class TransientResourceManager : MediatorSubscriberBase, IDisposable
 {
-    private readonly ConfigurationService _configurationService;
+    private readonly TransientConfigService _configurationService;
     private readonly DalamudUtil _dalamudUtil;
 
     public IntPtr[] PlayerRelatedPointers = Array.Empty<IntPtr>();
@@ -19,7 +19,7 @@ public class TransientResourceManager : MediatorSubscriberBase, IDisposable
 
     private ConcurrentDictionary<IntPtr, HashSet<string>> TransientResources { get; } = new();
     private ConcurrentDictionary<ObjectKind, HashSet<string>> SemiTransientResources { get; } = new();
-    public TransientResourceManager(ConfigurationService configurationService, DalamudUtil dalamudUtil, MareMediator mediator) : base(mediator)
+    public TransientResourceManager(TransientConfigService configurationService, DalamudUtil dalamudUtil, MareMediator mediator) : base(mediator)
     {
         _configurationService = configurationService;
         _dalamudUtil = dalamudUtil;

MareSynchronos/MareConfiguration/ConfigurationExtensions.cs

@@ -1,4 +1,6 @@
-namespace MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
 
 public static class ConfigurationExtensions
 {

MareSynchronos/MareConfiguration/ConfigurationMigrator.cs

@@ -0,0 +1,89 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+using MareSynchronos.MareConfiguration.Configurations.Obsolete;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.Utils;
+using Newtonsoft.Json;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ConfigurationMigrator
+{
+    private readonly DalamudPluginInterface _pi;
+
+    public ConfigurationMigrator(DalamudPluginInterface pi)
+    {
+        _pi = pi;
+    }
+
+    public void Migrate()
+    {
+#pragma warning disable CS0618 // ignore Obsolete tag, the point of this migrator is to migrate obsolete configs to new ones
+        if (_pi.GetPluginConfig() is Configuration oldConfig)
+        {
+            Logger.Info("Migrating Configuration from old config style to 1");
+
+            var config = oldConfig.ToMareConfig();
+            File.Move(_pi.ConfigFile.FullName, _pi.ConfigFile.FullName + ".old", overwrite: true);
+            MigrateMareConfigV0ToV1(config);
+        }
+
+        var mareConfig = JsonConvert.DeserializeObject<MareConfigV0>(File.ReadAllText(ConfigurationPath(MareConfigService.ConfigName)))!;
+
+        if (mareConfig.Version == 0)
+        {
+            MigrateMareConfigV0ToV1(mareConfig);
+        }
+    }
+
+    private void MigrateMareConfigV0ToV1(MareConfigV0 mareConfigV0)
+    {
+        Logger.Info("Migrating Configuration from version 0 to 1");
+        if (File.Exists(ConfigurationPath(MareConfigService.ConfigName)))
+            File.Copy(ConfigurationPath(MareConfigService.ConfigName), ConfigurationPath(MareConfigService.ConfigName) + ".migrated." + mareConfigV0.Version + ".bak", true);
+
+        MareConfig mareConfigV1 = mareConfigV0.ToV1();
+
+        var serverConfig = new ServerConfig()
+        {
+            CurrentServer = mareConfigV0.CurrentServer,
+            ServerStorage = mareConfigV0.ServerStorage.ToDictionary(p => p.Key, p => p.Value.ToV1(), StringComparer.Ordinal)
+        };
+        var transientConfig = new TransientConfig()
+        {
+            PlayerPersistentTransientCache = mareConfigV0.PlayerPersistentTransientCache
+        };
+        var tagConfig = new ServerTagConfig()
+        {
+            ServerTagStorage = mareConfigV0.ServerStorage.ToDictionary(p => p.Key, p => new ServerTagStorage()
+            {
+                UidServerPairedUserTags = p.Value.UidServerPairedUserTags.ToDictionary(p => p.Key, p => p.Value.ToList(), StringComparer.Ordinal),
+                OpenPairTags = p.Value.OpenPairTags.ToHashSet(StringComparer.Ordinal),
+                ServerAvailablePairTags = p.Value.ServerAvailablePairTags.ToHashSet(StringComparer.Ordinal)
+            }, StringComparer.Ordinal)
+        };
+        var notesConfig = new UidNotesConfig()
+        {
+            ServerNotes = mareConfigV0.ServerStorage.ToDictionary(p => p.Key, p => new ServerNotesStorage()
+            {
+                GidServerComments = p.Value.GidServerComments,
+                UidServerComments = p.Value.UidServerComments
+            }, StringComparer.Ordinal)
+        };
+
+        SaveConfig(mareConfigV1, ConfigurationPath(MareConfigService.ConfigName));
+        SaveConfig(serverConfig, ConfigurationPath(ServerConfigService.ConfigName));
+        SaveConfig(transientConfig, ConfigurationPath(TransientConfigService.ConfigName));
+        SaveConfig(tagConfig, ConfigurationPath(ServerTagConfigService.ConfigName));
+        SaveConfig(notesConfig, ConfigurationPath(NotesConfigService.ConfigName));
+    }
+#pragma warning restore CS0618 // ignore Obsolete tag, the point of this migrator is to migrate obsolete configs to new ones
+
+    private string ConfigurationPath(string configName) => Path.Combine(_pi.ConfigDirectory.FullName, configName);
+
+
+    private void SaveConfig(IMareConfiguration config, string path)
+    {
+        File.WriteAllText(path, JsonConvert.SerializeObject(config, Formatting.Indented));
+    }
+}

MareSynchronos/MareConfiguration/ConfigurationService.cs

@@ -1,82 +0,0 @@
-using Dalamud.Plugin;
-using MareSynchronos.Utils;
-using Newtonsoft.Json;
-
-namespace MareSynchronos.MareConfiguration;
-
-public class ConfigurationService : IDisposable
-{
-    private const string _configurationName = "Config.json";
-    private string ConfigurationPath => Path.Combine(_pluginInterface.ConfigDirectory.FullName, _configurationName);
-    public string ConfigurationDirectory => _pluginInterface.ConfigDirectory.FullName;
-    private readonly DalamudPluginInterface _pluginInterface;
-    private readonly CancellationTokenSource _periodicCheckCts = new();
-    private DateTime _configLastWriteTime;
-
-    public MareConfig Current { get; private set; }
-
-    public ConfigurationService(DalamudPluginInterface pluginInterface)
-    {
-        _pluginInterface = pluginInterface;
-
-        if (pluginInterface.GetPluginConfig() is Configuration oldConfig)
-        {
-            Current = oldConfig.ToMareConfig();
-            File.Move(pluginInterface.ConfigFile.FullName, pluginInterface.ConfigFile.FullName + ".old", overwrite: true);
-        }
-        else
-        {
-            Current = LoadConfig();
-        }
-
-        Save();
-
-        Task.Run(CheckForConfigUpdatesInternal, _periodicCheckCts.Token);
-    }
-
-    private async Task CheckForConfigUpdatesInternal()
-    {
-        while (!_periodicCheckCts.IsCancellationRequested)
-        {
-            var lastWriteTime = GetConfigLastWriteTime();
-            if (lastWriteTime != _configLastWriteTime)
-            {
-                Logger.Debug("Config changed, reloading config");
-                Current = LoadConfig();
-            }
-
-            await Task.Delay(TimeSpan.FromSeconds(5), _periodicCheckCts.Token).ConfigureAwait(false);
-        }
-    }
-
-    private MareConfig LoadConfig()
-    {
-        MareConfig config;
-        if (!File.Exists(ConfigurationPath))
-        {
-            config = new();
-        }
-        else
-        {
-            config = JsonConvert.DeserializeObject<MareConfig>(File.ReadAllText(ConfigurationPath)) ?? new MareConfig();
-        }
-
-        _configLastWriteTime = GetConfigLastWriteTime();
-        return config;
-    }
-
-    private DateTime GetConfigLastWriteTime() => new FileInfo(ConfigurationPath).LastWriteTimeUtc;
-
-    public void Save()
-    {
-        File.WriteAllText(ConfigurationPath, JsonConvert.SerializeObject(Current, Formatting.Indented));
-        _configLastWriteTime = new FileInfo(ConfigurationPath).LastWriteTimeUtc;
-    }
-
-    public void Dispose()
-    {
-        Logger.Verbose($"Disposing {GetType()}");
-        Save();
-        _periodicCheckCts.Cancel();
-    }
-}

MareSynchronos/MareConfiguration/ConfigurationServiceBase.cs

@@ -0,0 +1,123 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+using MareSynchronos.Utils;
+using Newtonsoft.Json;
+
+namespace MareSynchronos.MareConfiguration;
+
+public abstract class ConfigurationServiceBase<T> : IDisposable where T : IMareConfiguration
+{
+    protected abstract string ConfigurationName { get; }
+    public string ConfigurationDirectory => _pluginInterface.ConfigDirectory.FullName;
+    public T Current => _currentConfigInternal.Value;
+
+    protected readonly DalamudPluginInterface _pluginInterface;
+    private readonly CancellationTokenSource _periodicCheckCts = new();
+    private DateTime _configLastWriteTime;
+    private bool _configIsDirty = false;
+    private Lazy<T> _currentConfigInternal;
+
+    protected string ConfigurationPath => Path.Combine(ConfigurationDirectory, ConfigurationName);
+    protected ConfigurationServiceBase(DalamudPluginInterface pluginInterface)
+    {
+        _pluginInterface = pluginInterface;
+
+        Task.Run(CheckForConfigUpdatesInternal, _periodicCheckCts.Token);
+        Task.Run(CheckForDirtyConfigInternal, _periodicCheckCts.Token);
+
+        _currentConfigInternal = LazyConfig();
+    }
+
+    private Lazy<T> LazyConfig()
+    {
+        _configLastWriteTime = GetConfigLastWriteTime();
+        return new Lazy<T>(() => LoadConfig());
+    }
+    private DateTime GetConfigLastWriteTime() => new FileInfo(ConfigurationPath).LastWriteTimeUtc;
+
+    private async Task CheckForConfigUpdatesInternal()
+    {
+        while (!_periodicCheckCts.IsCancellationRequested)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(5), _periodicCheckCts.Token).ConfigureAwait(false);
+
+            var lastWriteTime = GetConfigLastWriteTime();
+            if (lastWriteTime != _configLastWriteTime)
+            {
+                Logger.Debug($"Config {ConfigurationName} changed, reloading config");
+                _currentConfigInternal = LazyConfig();
+            }
+        }
+    }
+
+    private async Task CheckForDirtyConfigInternal()
+    {
+        while (!_periodicCheckCts.IsCancellationRequested)
+        {
+            if (_configIsDirty)
+            {
+                SaveDirtyConfig();
+            }
+
+            await Task.Delay(TimeSpan.FromSeconds(1), _periodicCheckCts.Token).ConfigureAwait(false);
+        }
+    }
+
+    protected T LoadConfig()
+    {
+        T? config;
+        if (!File.Exists(ConfigurationPath))
+        {
+            config = (T)Activator.CreateInstance(typeof(T))!;
+            Save();
+        }
+        else
+        {
+            config = JsonConvert.DeserializeObject<T>(File.ReadAllText(ConfigurationPath));
+            if (config == null)
+            {
+                config = (T)Activator.CreateInstance(typeof(T))!;
+                Save();
+            }
+        }
+
+        _configLastWriteTime = GetConfigLastWriteTime();
+        return config;
+    }
+
+    protected void SaveDirtyConfig()
+    {
+        _configIsDirty = false;
+        var existingConfigs = Directory.EnumerateFiles(ConfigurationDirectory, ConfigurationName + ".bak.*").Select(c => new FileInfo(c))
+            .OrderByDescending(c => c.LastWriteTime).ToList();
+        if (existingConfigs.Skip(10).Any())
+        {
+            foreach (var config in existingConfigs.Skip(10).ToList())
+            {
+                config.Delete();
+            }
+        }
+
+        Logger.Debug("Saving dirty config " + ConfigurationName);
+
+        try
+        {
+            File.Copy(ConfigurationPath, ConfigurationPath + ".bak." + DateTime.Now.ToString("yyyyMMddHHmmss"), true);
+        }
+        catch { }
+
+        File.WriteAllText(ConfigurationPath, JsonConvert.SerializeObject(Current, Formatting.Indented));
+        _configLastWriteTime = new FileInfo(ConfigurationPath).LastWriteTimeUtc;
+    }
+
+    public void Save()
+    {
+        _configIsDirty = true;
+    }
+
+    public void Dispose()
+    {
+        Logger.Verbose($"Disposing {GetType()}");
+        _periodicCheckCts.Cancel();
+    }
+}

MareSynchronos/MareConfiguration/Configurations/IMareConfiguration.cs

@@ -0,0 +1,6 @@
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public interface IMareConfiguration
+{
+    int Version { get; set; }
+}

MareSynchronos/MareConfiguration/Configurations/MareConfig.cs

@@ -1,17 +1,11 @@
-using Dalamud.Configuration;
+using MareSynchronos.MareConfiguration.Models;
-using MareSynchronos.WebAPI;
 
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Configurations;
 
 [Serializable]
-public class MareConfig : IPluginConfiguration
+public class MareConfig : IMareConfiguration
 {
-    public int Version { get; set; } = 0;
+    public int Version { get; set; } = 1;
-    public Dictionary<string, ServerStorage> ServerStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase)
-    {
-        { ApiController.MainServiceUri, new ServerStorage() { ServerName = ApiController.MainServer, ServerUri = ApiController.MainServiceUri } },
-    };
-    public Dictionary<string, HashSet<string>> PlayerPersistentTransientCache { get; set; } = new(StringComparer.Ordinal);
     public bool AcceptedAgreement { get; set; } = false;
     public string CacheFolder { get; set; } = string.Empty;
     public double MaxLocalCacheInGiB { get; set; } = 20;
@@ -23,7 +17,6 @@ public class MareConfig : IPluginConfiguration
     public bool OpenGposeImportOnGposeStart { get; set; } = false;
     public bool ShowTransferWindow { get; set; } = true;
     public bool OpenPopupOnAdd { get; set; } = true;
-    public string CurrentServer { get; set; } = string.Empty;
     public bool ShowOnlineNotifications { get; set; } = false;
     public bool ShowOnlineNotificationsOnlyForIndividualPairs { get; set; } = true;
     public bool ShowOnlineNotificationsOnlyForNamedPairs { get; set; } = false;

MareSynchronos/MareConfiguration/Configurations/Obsolete/Configuration.cs

@@ -1,20 +1,21 @@
 using Dalamud.Configuration;
 using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Models;
 using MareSynchronos.Utils;
 using MareSynchronos.WebAPI;
 
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Configurations.Obsolete;
 
 [Serializable]
-[Obsolete("Migrated to MareConfig")]
+[Obsolete("Deprecated, use MareConfig")]
 public class Configuration : IPluginConfiguration
 {
     public int Version { get; set; } = 6;
     [NonSerialized]
     private DalamudPluginInterface? _pluginInterface;
-    public Dictionary<string, ServerStorage> ServerStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase)
+    public Dictionary<string, ServerStorageV0> ServerStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase)
     {
-        { ApiController.MainServiceUri, new ServerStorage() { ServerName = ApiController.MainServer, ServerUri = ApiController.MainServiceUri } },
+        { ApiController.MainServiceUri, new ServerStorageV0() { ServerName = ApiController.MainServer, ServerUri = ApiController.MainServiceUri } },
     };
     public bool AcceptedAgreement { get; set; } = false;
     public string CacheFolder { get; set; } = string.Empty;
@@ -73,9 +74,9 @@ public class Configuration : IPluginConfiguration
         _pluginInterface!.SavePluginConfig(this);
     }
 
-    public MareConfig ToMareConfig()
+    public MareConfigV0 ToMareConfig()
     {
-        MareConfig newConfig = new();
+        MareConfigV0 newConfig = new();
         Logger.Info("Migrating Config to MareConfig");
 
         newConfig.AcceptedAgreement = AcceptedAgreement;
@@ -97,7 +98,7 @@ public class Configuration : IPluginConfiguration
             Logger.Debug("Migrating " + secret.Key);
             var apiuri = secret.Key;
             var secretkey = secret.Value;
-            ServerStorage toAdd = new();
+            ServerStorageV0 toAdd = new();
             if (string.Equals(apiuri, ApiController.MainServiceUri, StringComparison.OrdinalIgnoreCase))
             {
                 toAdd.ServerUri = ApiController.MainServiceUri;

MareSynchronos/MareConfiguration/Configurations/Obsolete/MareConfigV0.cs

@@ -0,0 +1,56 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations.Obsolete;
+
+[Serializable]
+[Obsolete("Deprecated, use MareConfig")]
+public class MareConfigV0 : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+    public Dictionary<string, ServerStorageV0> ServerStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public Dictionary<string, HashSet<string>> PlayerPersistentTransientCache { get; set; } = new(StringComparer.Ordinal);
+    public bool AcceptedAgreement { get; set; } = false;
+    public string CacheFolder { get; set; } = string.Empty;
+    public double MaxLocalCacheInGiB { get; set; } = 20;
+    public bool ReverseUserSort { get; set; } = false;
+    public int TimeSpanBetweenScansInSeconds { get; set; } = 30;
+    public bool FileScanPaused { get; set; } = false;
+    public bool InitialScanComplete { get; set; } = false;
+    public bool DisableOptionalPluginWarnings { get; set; } = false;
+    public bool OpenGposeImportOnGposeStart { get; set; } = false;
+    public bool ShowTransferWindow { get; set; } = true;
+    public bool OpenPopupOnAdd { get; set; } = true;
+    public string CurrentServer { get; set; } = string.Empty;
+    public bool ShowOnlineNotifications { get; set; } = false;
+    public bool ShowOnlineNotificationsOnlyForIndividualPairs { get; set; } = true;
+    public bool ShowOnlineNotificationsOnlyForNamedPairs { get; set; } = false;
+    public bool ShowCharacterNameInsteadOfNotesForVisible { get; set; } = false;
+    public NotificationLocation InfoNotification { get; set; } = NotificationLocation.Toast;
+    public NotificationLocation WarningNotification { get; set; } = NotificationLocation.Both;
+    public NotificationLocation ErrorNotification { get; set; } = NotificationLocation.Both;
+
+    public MareConfig ToV1()
+    {
+        return new MareConfig()
+        {
+            AcceptedAgreement = this.AcceptedAgreement,
+            CacheFolder = this.CacheFolder,
+            MaxLocalCacheInGiB = this.MaxLocalCacheInGiB,
+            ReverseUserSort = this.ReverseUserSort,
+            TimeSpanBetweenScansInSeconds = this.TimeSpanBetweenScansInSeconds,
+            FileScanPaused = this.FileScanPaused,
+            InitialScanComplete = this.InitialScanComplete,
+            DisableOptionalPluginWarnings = this.DisableOptionalPluginWarnings,
+            OpenGposeImportOnGposeStart = this.OpenGposeImportOnGposeStart,
+            ShowTransferWindow = this.ShowTransferWindow,
+            OpenPopupOnAdd = this.OpenPopupOnAdd,
+            ShowOnlineNotifications = this.ShowOnlineNotifications,
+            ShowOnlineNotificationsOnlyForIndividualPairs = this.ShowOnlineNotificationsOnlyForIndividualPairs,
+            ShowCharacterNameInsteadOfNotesForVisible = this.ShowCharacterNameInsteadOfNotesForVisible,
+            ShowOnlineNotificationsOnlyForNamedPairs = this.ShowOnlineNotificationsOnlyForNamedPairs,
+            ErrorNotification = this.ErrorNotification,
+            InfoNotification = this.InfoNotification,
+            WarningNotification = this.WarningNotification,
+        };
+    }
+}

MareSynchronos/MareConfiguration/Configurations/ServerConfig.cs

@@ -0,0 +1,16 @@
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.WebAPI;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class ServerConfig : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+
+    public Dictionary<string, ServerStorage> ServerStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase)
+    {
+        { ApiController.MainServiceUri, new ServerStorage() { ServerName = ApiController.MainServer, ServerUri = ApiController.MainServiceUri } },
+    };
+    public string CurrentServer { get; set; } = string.Empty;
+}

MareSynchronos/MareConfiguration/Configurations/ServerTagConfig.cs

@@ -0,0 +1,9 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class ServerTagConfig : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+    public Dictionary<string, ServerTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+}

MareSynchronos/MareConfiguration/Configurations/TransientConfig.cs

@@ -0,0 +1,9 @@
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class TransientConfig : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+
+    public Dictionary<string, HashSet<string>> PlayerPersistentTransientCache { get; set; } = new(StringComparer.Ordinal);
+
+}

MareSynchronos/MareConfiguration/Configurations/UidNotesConfig.cs

@@ -0,0 +1,9 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class UidNotesConfig : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+    public Dictionary<string, ServerNotesStorage> ServerNotes = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/MareConfigService.cs

@@ -0,0 +1,12 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class MareConfigService : ConfigurationServiceBase<MareConfig>
+{
+    public const string ConfigName = "config.json";
+    protected override string ConfigurationName => ConfigName;
+
+    public MareConfigService(DalamudPluginInterface pluginInterface) : base(pluginInterface) { }
+}

MareSynchronos/MareConfiguration/Models/Authentication.cs

@@ -1,4 +1,4 @@
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Models;
 
 [Serializable]
 public record Authentication

MareSynchronos/MareConfiguration/Models/NotificationLocation.cs

@@ -1,4 +1,4 @@
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Models;
 
 public enum NotificationLocation
 {

MareSynchronos/MareConfiguration/Models/Obsolete/ServerStorageV0.cs

@@ -1,7 +1,8 @@
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Models;
 
 [Serializable]
-public class ServerStorage
+[Obsolete("Deprecated, use ServerStorage")]
+public class ServerStorageV0
 {
     public string ServerUri { get; set; } = string.Empty;
     public string ServerName { get; set; } = string.Empty;
@@ -13,4 +14,16 @@ public class ServerStorage
     public HashSet<string> OpenPairTags { get; set; } = new(StringComparer.Ordinal);
     public Dictionary<int, SecretKey> SecretKeys { get; set; } = new();
     public bool FullPause { get; set; } = false;
+
+    public ServerStorage ToV1()
+    {
+        return new ServerStorage()
+        {
+            ServerUri = this.ServerUri,
+            ServerName = this.ServerName,
+            Authentications = this.Authentications.ToList(),
+            FullPause = this.FullPause,
+            SecretKeys = this.SecretKeys.ToDictionary(p => p.Key, p => p.Value)
+        };
+    }
 }

MareSynchronos/MareConfiguration/Models/SecretKey.cs

@@ -1,4 +1,4 @@
-namespace MareSynchronos.MareConfiguration;
+namespace MareSynchronos.MareConfiguration.Models;
 
 [Serializable]
 public class SecretKey

MareSynchronos/MareConfiguration/Models/ServerStorage.cs

@@ -0,0 +1,11 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerStorage
+{
+    public string ServerUri { get; set; } = string.Empty;
+    public string ServerName { get; set; } = string.Empty;
+    public List<Authentication> Authentications { get; set; } = new();
+    public Dictionary<int, SecretKey> SecretKeys { get; set; } = new();
+    public bool FullPause { get; set; } = false;
+}

MareSynchronos/MareConfiguration/Models/ServerTagStorage.cs

@@ -0,0 +1,9 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerTagStorage
+{
+    public Dictionary<string, List<string>> UidServerPairedUserTags = new(StringComparer.Ordinal);
+    public HashSet<string> ServerAvailablePairTags { get; set; } = new(StringComparer.Ordinal);
+    public HashSet<string> OpenPairTags { get; set; } = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/Models/UidNoteStorage.cs

@@ -0,0 +1,7 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+public class ServerNotesStorage
+{
+    public Dictionary<string, string> UidServerComments { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, string> GidServerComments { get; set; } = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/NotesConfigService.cs

@@ -0,0 +1,11 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class NotesConfigService : ConfigurationServiceBase<UidNotesConfig>
+{
+    public const string ConfigName = "notes.json";
+    protected override string ConfigurationName => ConfigName;
+    public NotesConfigService(DalamudPluginInterface pluginInterface) : base(pluginInterface) { }
+}

MareSynchronos/MareConfiguration/ServerConfigService.cs

@@ -0,0 +1,11 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ServerConfigService : ConfigurationServiceBase<ServerConfig>
+{
+    public const string ConfigName = "server.json";
+    protected override string ConfigurationName => ConfigName;
+    public ServerConfigService(DalamudPluginInterface pluginInterface) : base(pluginInterface) { }
+}

MareSynchronos/MareConfiguration/ServerTagConfigService.cs

@@ -0,0 +1,11 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ServerTagConfigService : ConfigurationServiceBase<ServerTagConfig>
+{
+    public const string ConfigName = "servertags.json";
+    protected override string ConfigurationName => ConfigName;
+    public ServerTagConfigService(DalamudPluginInterface pluginInterface) : base(pluginInterface) { }
+}

MareSynchronos/MareConfiguration/TransientConfigService.cs

@@ -0,0 +1,11 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class TransientConfigService : ConfigurationServiceBase<TransientConfig>
+{
+    public const string ConfigName = "transient.json";
+    protected override string ConfigurationName => ConfigName;
+    public TransientConfigService(DalamudPluginInterface pluginInterface) : base(pluginInterface) { }
+}

MareSynchronos/MarePlugin.cs

@@ -23,6 +23,8 @@ public class MarePlugin : MediatorSubscriberBase, IDisposable
     {
         _serviceProvider = serviceProvider;
 
+        _serviceProvider.GetRequiredService<ConfigurationMigrator>().Migrate();
+
         mediator.Subscribe<SwitchToMainUiMessage>(this, (_) => Task.Run(WaitForPlayerAndLaunchCharacterManager));
         mediator.Subscribe<DalamudLoginMessage>(this, (_) => DalamudUtilOnLogIn());
         mediator.Subscribe<DalamudLogoutMessage>(this, (_) => DalamudUtilOnLogOut());
@@ -59,7 +61,7 @@ public class MarePlugin : MediatorSubscriberBase, IDisposable
             HelpMessage = "Opens the Mare Synchronos UI",
         });
 
-        if (!_serviceProvider.GetRequiredService<ConfigurationService>().Current.HasValidSetup()
+        if (!_serviceProvider.GetRequiredService<MareConfigService>().Current.HasValidSetup()
             || !_serviceProvider.GetRequiredService<ServerConfigurationManager>().HasValidConfig())
         {
             _serviceProvider.GetRequiredService<MareMediator>().Publish(new SwitchToIntroUiMessage());
@@ -148,7 +150,7 @@ public class MarePlugin : MediatorSubscriberBase, IDisposable
     private void OpenUi()
     {
 
-        if (_serviceProvider.GetRequiredService<ConfigurationService>().Current.HasValidSetup())
+        if (_serviceProvider.GetRequiredService<MareConfigService>().Current.HasValidSetup())
             _serviceProvider.GetRequiredService<CompactUi>().Toggle();
         else
             _serviceProvider.GetRequiredService<IntroUi>().Toggle();

MareSynchronos/MareSynchronos.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Authors></Authors>
     <Company></Company>
-    <Version>0.7.17</Version>
+    <Version>0.7.18</Version>
     <Description></Description>
     <Copyright></Copyright>
     <PackageProjectUrl>https://github.com/Penumbra-Sync/client</PackageProjectUrl>

MareSynchronos/Mediator/IMediatorSubscriber.cs

@@ -0,0 +1,6 @@
+namespace MareSynchronos.Mediator;
+
+public interface IMediatorSubscriber : IDisposable
+{
+    MareMediator Mediator { get; }
+}

MareSynchronos/Mediator/MediatorSubscriberBase.cs

@@ -1,5 +1,4 @@
-using Dalamud.Interface.Windowing;
+using MareSynchronos.Utils;
-using MareSynchronos.Utils;
 
 namespace MareSynchronos.Mediator;
 
@@ -17,23 +16,3 @@ public abstract class MediatorSubscriberBase : IMediatorSubscriber
         Mediator.UnsubscribeAll(this);
     }
 }
-
-public abstract class WindowMediatorSubscriberBase : Window, IMediatorSubscriber
-{
-    public MareMediator Mediator { get; }
-    protected WindowMediatorSubscriberBase(MareMediator mediator, string name) : base(name)
-    {
-        Mediator = mediator;
-    }
-
-    public virtual void Dispose()
-    {
-        Logger.Verbose($"Disposing {GetType()}");
-        Mediator.UnsubscribeAll(this);
-    }
-}
-
-public interface IMediatorSubscriber : IDisposable
-{
-    MareMediator Mediator { get; }
-}

MareSynchronos/Mediator/WindowMediatorSubscriberBase.cs

@@ -0,0 +1,19 @@
+using Dalamud.Interface.Windowing;
+using MareSynchronos.Utils;
+
+namespace MareSynchronos.Mediator;
+
+public abstract class WindowMediatorSubscriberBase : Window, IMediatorSubscriber
+{
+    public MareMediator Mediator { get; }
+    protected WindowMediatorSubscriberBase(MareMediator mediator, string name) : base(name)
+    {
+        Mediator = mediator;
+    }
+
+    public virtual void Dispose()
+    {
+        Logger.Verbose($"Disposing {GetType()}");
+        Mediator.UnsubscribeAll(this);
+    }
+}

MareSynchronos/Models/Pair.cs

@@ -12,11 +12,11 @@ namespace MareSynchronos.Models;
 
 public class Pair
 {
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly ServerConfigurationManager _serverConfigurationManager;
     private OptionalPluginWarning? _pluginWarnings;
 
-    public Pair(ConfigurationService configService, ServerConfigurationManager serverConfigurationManager)
+    public Pair(MareConfigService configService, ServerConfigurationManager serverConfigurationManager)
     {
         _configService = configService;
         _serverConfigurationManager = serverConfigurationManager;
@@ -36,18 +36,12 @@ public class Pair
 
     public string? GetNote()
     {
-        if (_serverConfigurationManager.CurrentServer!.UidServerComments.TryGetValue(UserData.UID, out string? note))
+        return _serverConfigurationManager.GetNoteForUid(UserData.UID);
-        {
-            return string.IsNullOrEmpty(note) ? null : note;
-        }
-
-        return null;
     }
 
     public void SetNote(string note)
     {
-        _serverConfigurationManager.CurrentServer!.UidServerComments[UserData.UID] = note;
+        _serverConfigurationManager.SetNoteForUid(UserData.UID, note);
-        _serverConfigurationManager.Save();
     }
 
     public bool HasAnyConnection()

MareSynchronos/Plugin.cs

@@ -48,7 +48,12 @@ public sealed class Plugin : IDalamudPlugin
         // add mare related stuff
         collection.AddSingleton(new Dalamud.Localization("MareSynchronos.Localization.", "", useEmbedded: true));
 
-        collection.AddSingleton<ConfigurationService>();
+        collection.AddSingleton<ConfigurationMigrator>();
+        collection.AddSingleton<MareConfigService>();
+        collection.AddSingleton<ServerTagConfigService>();
+        collection.AddSingleton<TransientConfigService>();
+        collection.AddSingleton<NotesConfigService>();
+        collection.AddSingleton<ServerConfigService>();
         collection.AddSingleton<MareMediator>();
         collection.AddSingleton<DalamudUtil>();
         collection.AddSingleton<IpcManager>();

MareSynchronos/UI/CompactUI.cs

@@ -26,7 +26,7 @@ public class CompactUi : WindowMediatorSubscriberBase, IDisposable
     private readonly ApiController _apiController;
     private readonly PairManager _pairManager;
     private readonly ServerConfigurationManager _serverManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly TagHandler _tagHandler;
     public readonly Dictionary<string, bool> ShowUidForEntry = new(StringComparer.Ordinal);
     private readonly UiShared _uiShared;
@@ -56,7 +56,7 @@ public class CompactUi : WindowMediatorSubscriberBase, IDisposable
     private readonly PairGroupsUi _pairGroupsUi;
 
     public CompactUi(WindowSystem windowSystem,
-        UiShared uiShared, ConfigurationService configService, ApiController apiController, PairManager pairManager,
+        UiShared uiShared, MareConfigService configService, ApiController apiController, PairManager pairManager,
         ServerConfigurationManager serverManager, MareMediator mediator) : base(mediator, "###MareSynchronosMainUI")
     {
 
@@ -199,8 +199,7 @@ public class CompactUi : WindowMediatorSubscriberBase, IDisposable
                 ImGui.InputTextWithHint("##noteforuser", $"Note for {_lastAddedUser.UserData.AliasOrUID}", ref _lastAddedUserComment, 100);
                 if (UiShared.IconTextButton(FontAwesomeIcon.Save, "Save Note"))
                 {
-                    _serverManager.CurrentServer!.UidServerComments[_lastAddedUser.UserData.UID] = _lastAddedUserComment;
+                    _serverManager.SetNoteForUid(_lastAddedUser.UserData.UID, _lastAddedUserComment);
-                    _serverManager.Save();
                     _lastAddedUser = null;
                     _lastAddedUserComment = string.Empty;
                     _showModalForUserAddition = false;
@@ -385,7 +384,8 @@ public class CompactUi : WindowMediatorSubscriberBase, IDisposable
 
         var textIsUid = true;
         ShowUidForEntry.TryGetValue(entry.UserPair!.User.UID, out var showUidInsteadOfName);
-        if (!showUidInsteadOfName && _serverManager.CurrentServer!.UidServerComments.TryGetValue(entry.UserPair!.User.UID, out var playerText))
+        string? playerText = _serverManager.GetNoteForUid(entry.UserPair!.User.UID);
+        if (!showUidInsteadOfName && playerText != null)
         {
             if (string.IsNullOrEmpty(playerText))
             {
@@ -446,8 +446,7 @@ public class CompactUi : WindowMediatorSubscriberBase, IDisposable
             ImGui.SetNextItemWidth(UiShared.GetWindowContentRegionWidth() - ImGui.GetCursorPosX() - buttonSizes - ImGui.GetStyle().ItemSpacing.X * 2);
             if (ImGui.InputTextWithHint("", "Nick/Notes", ref EditUserComment, 255, ImGuiInputTextFlags.EnterReturnsTrue))
             {
-                _serverManager.CurrentServer!.UidServerComments[entry.UserPair!.User.UID] = EditUserComment;
+                _serverManager.SetNoteForUid(entry.UserPair!.User.UID, EditUserComment);
-                _serverManager.Save();
                 EditNickEntry = string.Empty;
             }
 

MareSynchronos/UI/DownloadUi.cs

@@ -10,7 +10,7 @@ namespace MareSynchronos.UI;
 public class DownloadUi : Window, IDisposable
 {
     private readonly WindowSystem _windowSystem;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly ApiController _apiController;
     private readonly UiShared _uiShared;
     private bool _wasOpen = false;
@@ -21,7 +21,7 @@ public class DownloadUi : Window, IDisposable
         _windowSystem.RemoveWindow(this);
     }
 
-    public DownloadUi(WindowSystem windowSystem, ConfigurationService configService, ApiController apiController, UiShared uiShared) : base("Mare Synchronos Downloads")
+    public DownloadUi(WindowSystem windowSystem, MareConfigService configService, ApiController apiController, UiShared uiShared) : base("Mare Synchronos Downloads")
     {
         Logger.Verbose("Creating " + nameof(DownloadUi));
         _windowSystem = windowSystem;

MareSynchronos/UI/GposeUi.cs

@@ -16,10 +16,10 @@ public class GposeUi : WindowMediatorSubscriberBase, IDisposable
     private readonly MareCharaFileManager _mareCharaFileManager;
     private readonly DalamudUtil _dalamudUtil;
     private readonly FileDialogManager _fileDialogManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
 
     public GposeUi(WindowSystem windowSystem, MareCharaFileManager mareCharaFileManager,
-        DalamudUtil dalamudUtil, FileDialogManager fileDialogManager, ConfigurationService configService,
+        DalamudUtil dalamudUtil, FileDialogManager fileDialogManager, MareConfigService configService,
         MareMediator mediator) : base(mediator, "Mare Synchronos Gpose Import UI###MareSynchronosGposeUI")
     {
         _windowSystem = windowSystem;

MareSynchronos/UI/GroupPanel.cs

@@ -25,7 +25,7 @@ namespace MareSynchronos.UI
         private ApiController ApiController => _uiShared.ApiController;
         private readonly PairManager _pairManager;
         private readonly ServerConfigurationManager _serverConfigurationManager;
-        private readonly ConfigurationService _configService;
+        private readonly MareConfigService _configService;
         private readonly Dictionary<string, bool> _showGidForEntry = new(StringComparer.Ordinal);
         private string _editGroupEntry = string.Empty;
         private string _editGroupComment = string.Empty;
@@ -53,7 +53,7 @@ namespace MareSynchronos.UI
         private bool _modalChangePwOpened;
         private int _bulkInviteCount = 10;
 
-        public GroupPanel(CompactUi mainUi, UiShared uiShared, PairManager pairManager, ServerConfigurationManager serverConfigurationManager, ConfigurationService configurationService)
+        public GroupPanel(CompactUi mainUi, UiShared uiShared, PairManager pairManager, ServerConfigurationManager serverConfigurationManager, MareConfigService configurationService)
         {
             _mainUi = mainUi;
             _uiShared = uiShared;
@@ -241,14 +241,12 @@ namespace MareSynchronos.UI
             }
 
             _showGidForEntry.TryGetValue(groupDto.GID, out var showGidInsteadOfName);
-            if (!showGidInsteadOfName && _serverConfigurationManager.CurrentServer!.GidServerComments.TryGetValue(groupDto.GID, out var groupComment))
+            var groupComment = _serverConfigurationManager.GetNoteForGid(groupDto.GID);
-            {
+            if (!showGidInsteadOfName && !string.IsNullOrEmpty(groupComment))
-                if (!string.IsNullOrEmpty(groupComment))
             {
                 groupName = groupComment;
                 textIsGid = false;
             }
-            }
 
             if (!string.Equals(_editGroupEntry, groupDto.GID, StringComparison.Ordinal))
             {
@@ -271,9 +269,8 @@ namespace MareSynchronos.UI
 
                 if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
                 {
-                    _serverConfigurationManager.CurrentServer!.GidServerComments[_editGroupEntry] = _editGroupComment;
+                    _serverConfigurationManager.SetNoteForGid(_editGroupEntry, _editGroupComment);
-                    _serverConfigurationManager.Save();
+                    _editGroupComment = _serverConfigurationManager.GetNoteForGid(groupDto.GID) ?? string.Empty;
-                    _editGroupComment = _serverConfigurationManager.CurrentServer!.GidServerComments.TryGetValue(groupDto.GID, out string? value) ? value : string.Empty;
                     _editGroupEntry = groupDto.GID;
                 }
             }
@@ -283,8 +280,7 @@ namespace MareSynchronos.UI
                 ImGui.SetNextItemWidth(UiShared.GetWindowContentRegionWidth() - ImGui.GetCursorPosX() - buttonSizes - ImGui.GetStyle().ItemSpacing.X * 2);
                 if (ImGui.InputTextWithHint("", "Comment/Notes", ref _editGroupComment, 255, ImGuiInputTextFlags.EnterReturnsTrue))
                 {
-                    _serverConfigurationManager.CurrentServer!.GidServerComments[groupDto.GID] = _editGroupComment;
+                    _serverConfigurationManager.SetNoteForGid(groupDto.GID, _editGroupComment);
-                    _serverConfigurationManager.Save();
                     _editGroupEntry = string.Empty;
                 }
 
@@ -820,18 +816,8 @@ namespace MareSynchronos.UI
 
             var textIsUid = true;
             _mainUi.ShowUidForEntry.TryGetValue(entry.UID, out var showUidInsteadOfName);
-            if (!showUidInsteadOfName && _serverConfigurationManager.CurrentServer!.UidServerComments.TryGetValue(entry.UID, out var playerText))
+            var playerText = _serverConfigurationManager.GetNoteForUid(entry.UID);
-            {
+            if (showUidInsteadOfName || string.IsNullOrEmpty(playerText))
-                if (string.IsNullOrEmpty(playerText))
-                {
-                    playerText = entryUID;
-                }
-                else
-                {
-                    textIsUid = false;
-                }
-            }
-            else
             {
                 playerText = entryUID;
             }
@@ -866,9 +852,8 @@ namespace MareSynchronos.UI
 
                 if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
                 {
-                    _serverConfigurationManager.CurrentServer!.UidServerComments[_mainUi.EditNickEntry] = _mainUi.EditUserComment;
+                    _serverConfigurationManager.SetNoteForUid(_mainUi.EditNickEntry, _mainUi.EditUserComment);
-                    _serverConfigurationManager.Save();
+                    _mainUi.EditUserComment = _serverConfigurationManager.GetNoteForUid(entry.UID) ?? string.Empty;
-                    _mainUi.EditUserComment = _serverConfigurationManager.CurrentServer.UidServerComments.TryGetValue(entry.UID, out string? value) ? value : string.Empty;
                     _mainUi.EditNickEntry = entry.UID;
                 }
             }
@@ -881,8 +866,7 @@ namespace MareSynchronos.UI
                 ImGui.SetNextItemWidth(UiShared.GetWindowContentRegionWidth() - ImGui.GetCursorPosX() - buttonSizes - ImGui.GetStyle().ItemSpacing.X * buttons);
                 if (ImGui.InputTextWithHint("", "Nick/Notes", ref _mainUi.EditUserComment, 255, ImGuiInputTextFlags.EnterReturnsTrue))
                 {
-                    _serverConfigurationManager.CurrentServer!.UidServerComments[entry.UID] = _mainUi.EditUserComment;
+                    _serverConfigurationManager.SetNoteForUid(entry.UID, _mainUi.EditUserComment);
-                    _serverConfigurationManager.Save();
                     _mainUi.EditNickEntry = string.Empty;
                 }
 

MareSynchronos/UI/Handlers/TagHandler.cs

@@ -1,5 +1,6 @@
 using MareSynchronos.API.Dto.User;
 using MareSynchronos.Managers;
+using MareSynchronos.Models;
 
 namespace MareSynchronos.UI.Handlers
 {
@@ -17,32 +18,25 @@ namespace MareSynchronos.UI.Handlers
 
         public void AddTag(string tag)
         {
-            GetAvailableTagsForCurrentServer().Add(tag);
+            _serverConfigurationManager.AddTag(tag);
-            _serverConfigurationManager.Save();
         }
 
         public void RemoveTag(string tag)
         {
             // First remove the tag from teh available pair tags
-            GetAvailableTagsForCurrentServer().Remove(tag);
+            _serverConfigurationManager.RemoveTag(tag);
-            // Then also clean up the tag in all the pairs
-            GetUidTagDictionaryForCurrentServer().Keys
-                .ToList()
-                .ForEach(otherUid => RemoveTagFromPairedUid(otherUid, tag));
-            _serverConfigurationManager.Save();
         }
 
         public void SetTagOpen(string tag, bool open)
         {
             if (open)
             {
-                _serverConfigurationManager.CurrentServer!.OpenPairTags.Add(tag);
+                _serverConfigurationManager.AddOpenPairTag(tag);
             }
             else
             {
-                _serverConfigurationManager.CurrentServer!.OpenPairTags.Remove(tag);
+                _serverConfigurationManager.RemoveOpenPairTag(tag);
             }
-            _serverConfigurationManager.Save();
         }
 
         /// <summary>
@@ -52,73 +46,39 @@ namespace MareSynchronos.UI.Handlers
         /// <returns>open true/false</returns>
         public bool IsTagOpen(string tag)
         {
-            return _serverConfigurationManager.CurrentServer!.OpenPairTags.Contains(tag);
+            return _serverConfigurationManager.ContainsOpenPairTag(tag);
         }
 
         public List<string> GetAllTagsSorted()
         {
-            return GetAvailableTagsForCurrentServer()
+            return _serverConfigurationManager.GetServerAvailablePairTags()
                 .OrderBy(s => s, StringComparer.OrdinalIgnoreCase)
                 .ToList();
         }
 
         public HashSet<string> GetOtherUidsForTag(string tag)
         {
-            return GetUidTagDictionaryForCurrentServer()
+            return _serverConfigurationManager.GetUidsForTag(tag);
-                .Where(pair => pair.Value.Contains(tag, StringComparer.Ordinal))
-                .Select(pair => pair.Key)
-                .ToHashSet(StringComparer.Ordinal);
         }
 
         public void AddTagToPairedUid(UserPairDto pair, string tagName)
         {
-            var tagDictionary = GetUidTagDictionaryForCurrentServer();
+            _serverConfigurationManager.AddTagForUid(pair.User.UID, tagName);
-            var tagsForPair = tagDictionary.GetValueOrDefault(pair.User.UID, new List<string>());
-            tagsForPair.Add(tagName);
-            tagDictionary[pair.User.UID] = tagsForPair;
-            _serverConfigurationManager.Save();
         }
 
         public void RemoveTagFromPairedUid(UserPairDto pair, string tagName)
         {
-            RemoveTagFromPairedUid(pair.User.UID, tagName);
+            _serverConfigurationManager.RemoveTagForUid(pair.User.UID, tagName);
-            _serverConfigurationManager.Save();
         }
 
         public bool HasTag(UserPairDto pair, string tagName)
         {
-            var tagsForPair = GetUidTagDictionaryForCurrentServer().GetValueOrDefault(pair.User.UID, new List<string>());
+            return _serverConfigurationManager.ContainsTag(pair.User.UID, tagName);
-            return tagsForPair.Contains(tagName, StringComparer.Ordinal);
         }
 
         public bool HasAnyTag(UserPairDto pair)
         {
-            return GetUidTagDictionaryForCurrentServer().ContainsKey(pair.User.UID);
+            return _serverConfigurationManager.HasTags(pair.User.UID);
-        }
-        
-        private void RemoveTagFromPairedUid(string otherUid, string tagName)
-        {
-            var tagsForPair = GetUidTagDictionaryForCurrentServer().GetValueOrDefault(otherUid, new List<string>());
-            tagsForPair.Remove(tagName);
-            if (!tagsForPair.Any())
-            {
-                // No more entries in list -> we can kick out that entry completely
-                GetUidTagDictionaryForCurrentServer().Remove(otherUid);
-            }
-            else
-            {
-                GetUidTagDictionaryForCurrentServer()[otherUid] = tagsForPair;
-            }
-        }
-
-        private Dictionary<string, List<string>> GetUidTagDictionaryForCurrentServer()
-        {
-            return _serverConfigurationManager.CurrentServer!.UidServerPairedUserTags;
-        }
-        
-        private HashSet<string> GetAvailableTagsForCurrentServer()
-        {
-            return _serverConfigurationManager.CurrentServer!.ServerAvailablePairTags;
         }
     }
 }

MareSynchronos/UI/IntroUI.cs

@@ -10,13 +10,14 @@ using Dalamud.Interface;
 using MareSynchronos.Managers;
 using MareSynchronos.MareConfiguration;
 using MareSynchronos.Mediator;
+using MareSynchronos.MareConfiguration.Models;
 
 namespace MareSynchronos.UI;
 
 internal class IntroUi : WindowMediatorSubscriberBase, IDisposable
 {
     private readonly UiShared _uiShared;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly PeriodicFileScanner _fileCacheManager;
     private readonly ServerConfigurationManager _serverConfigurationManager;
     private readonly WindowSystem _windowSystem;
@@ -36,7 +37,7 @@ internal class IntroUi : WindowMediatorSubscriberBase, IDisposable
         _windowSystem.RemoveWindow(this);
     }
 
-    public IntroUi(WindowSystem windowSystem, UiShared uiShared, ConfigurationService configService,
+    public IntroUi(WindowSystem windowSystem, UiShared uiShared, MareConfigService configService,
         PeriodicFileScanner fileCacheManager, ServerConfigurationManager serverConfigurationManager, MareMediator mareMediator) : base(mareMediator, "Mare Synchronos Setup")
     {
         Logger.Verbose("Creating " + nameof(IntroUi));

MareSynchronos/UI/SettingsUi.cs

@@ -14,12 +14,13 @@ using MareSynchronos.Managers;
 using MareSynchronos.API.Data.Comparer;
 using MareSynchronos.MareConfiguration;
 using MareSynchronos.Mediator;
+using MareSynchronos.MareConfiguration.Models;
 
 namespace MareSynchronos.UI;
 
 public class SettingsUi : WindowMediatorSubscriberBase, IDisposable
 {
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly WindowSystem _windowSystem;
     private ApiController ApiController => _uiShared.ApiController;
     private readonly MareCharaFileManager _mareCharaFileManager;
@@ -34,7 +35,7 @@ public class SettingsUi : WindowMediatorSubscriberBase, IDisposable
     private bool _wasOpen = false;
 
     public SettingsUi(WindowSystem windowSystem,
-        UiShared uiShared, ConfigurationService configService,
+        UiShared uiShared, MareConfigService configService,
         MareCharaFileManager mareCharaFileManager, PairManager pairManager,
         ServerConfigurationManager serverConfigurationManager, MareMediator mediator) : base(mediator, "Mare Synchronos Settings")
     {

MareSynchronos/UI/UIShared.cs

@@ -13,6 +13,7 @@ using MareSynchronos.FileCache;
 using MareSynchronos.Localization;
 using MareSynchronos.Managers;
 using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Models;
 using MareSynchronos.Models;
 using MareSynchronos.Utils;
 using MareSynchronos.WebAPI;
@@ -28,7 +29,7 @@ public partial class UiShared : IDisposable
     private readonly ApiController _apiController;
     private readonly PeriodicFileScanner _cacheScanner;
     public readonly FileDialogManager FileDialogManager;
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly DalamudUtil _dalamudUtil;
     private readonly DalamudPluginInterface _pluginInterface;
     private readonly Dalamud.Localization _localization;
@@ -53,7 +54,7 @@ public partial class UiShared : IDisposable
     public ApiController ApiController => _apiController;
 
     public UiShared(IpcManager ipcManager, ApiController apiController, PeriodicFileScanner cacheScanner, FileDialogManager fileDialogManager,
-        ConfigurationService configService, DalamudUtil dalamudUtil, DalamudPluginInterface pluginInterface, Dalamud.Localization localization,
+        MareConfigService configService, DalamudUtil dalamudUtil, DalamudPluginInterface pluginInterface, Dalamud.Localization localization,
         ServerConfigurationManager serverManager)
     {
         _ipcManager = ipcManager;
@@ -631,8 +632,6 @@ public partial class UiShared : IDisposable
 
         splitNotes.RemoveAll(n => string.Equals(n, _notesStart) || string.Equals(n, _notesEnd));
 
-        var comments = _serverConfigurationManager.CurrentServer!.UidServerComments;
-
         foreach (var note in splitNotes)
         {
             try
@@ -640,8 +639,8 @@ public partial class UiShared : IDisposable
                 var splittedEntry = note.Split(":", 2, StringSplitOptions.RemoveEmptyEntries);
                 var uid = splittedEntry[0];
                 var comment = splittedEntry[1].Trim('"');
-                if (comments.ContainsKey(uid) && !overwrite) continue;
+                if (_serverConfigurationManager.GetNoteForUid(uid) != null && !overwrite) continue;
-                _serverConfigurationManager.CurrentServer.UidServerComments[uid] = comment;
+                _serverConfigurationManager.SetNoteForUid(uid, comment);
             }
             catch
             {
@@ -649,7 +648,7 @@ public partial class UiShared : IDisposable
             }
         }
 
-        _serverConfigurationManager.Save();
+        _serverConfigurationManager.SaveNotes();
 
         return true;
     }

MareSynchronos/Utils/Logger.cs

@@ -31,13 +31,13 @@ internal class Logger : ILogger
     public static void Error(string? msg, Exception ex)
     {
         var caller = new StackTrace().GetFrame(1)?.GetMethod()?.ReflectedType?.Name ?? "Unknown";
-        PluginLog.Error($"[{caller}] {msg} {Environment.NewLine} Exception: {ex.Message} {Environment.NewLine} {ex.StackTrace}");
+        PluginLog.Error($"[{caller}] {msg} {Environment.NewLine} Exception: {ex?.ToString()}");
     }
 
     public static void Warn(string? msg, Exception ex)
     {
         var caller = new StackTrace().GetFrame(1)?.GetMethod()?.ReflectedType?.Name ?? "Unknown";
-        PluginLog.Warning($"[{caller}] {msg} {Environment.NewLine} Exception: {ex.Message} {Environment.NewLine} {ex.StackTrace}");
+        PluginLog.Warning($"[{caller}] {msg} {Environment.NewLine} Exception: {ex?.ToString()}");
     }
 
     public static void Error(string? msg)

MareSynchronos/WebAPI/ApIController.Functions.Files.cs

@@ -337,6 +337,7 @@ public partial class ApiController
     {
         if (!IsConnected) return;
         Logger.Debug("Sending Character data to service " + _serverManager.CurrentApiUrl);
+        visibleCharacters = visibleCharacters.ToList();
 
         CancelUpload();
         _uploadCancellationTokenSource = new CancellationTokenSource();

MareSynchronos/WebAPI/ApiController.cs

@@ -22,7 +22,7 @@ public partial class ApiController : MediatorSubscriberBase, IDisposable, IMareH
 
     public readonly int[] SupportedServerVersions = { IMareHub.ApiVersion };
 
-    private readonly ConfigurationService _configService;
+    private readonly MareConfigService _configService;
     private readonly DalamudUtil _dalamudUtil;
     private readonly FileCacheManager _fileDbManager;
     private readonly PairManager _pairManager;
@@ -45,7 +45,7 @@ public partial class ApiController : MediatorSubscriberBase, IDisposable, IMareH
 
     private HttpClient _httpClient;
 
-    public ApiController(ConfigurationService configService, DalamudUtil dalamudUtil, FileCacheManager fileDbManager,
+    public ApiController(MareConfigService configService, DalamudUtil dalamudUtil, FileCacheManager fileDbManager,
         PairManager pairManager, ServerConfigurationManager serverManager, MareMediator mediator) : base(mediator)
     {
         Logger.Verbose("Creating " + nameof(ApiController));