Added all functions required for the syncshell folder system

LightlessSync/LightlessConfiguration/Configurations/PairTagStorage.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class PairTagStorage : ILightlessConfiguration
+{
+    public Dictionary<string, Models.PairTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

LightlessSync/LightlessConfiguration/Configurations/ServerTagConfig.cs

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

LightlessSync/LightlessConfiguration/Configurations/SyncshellTagStorage.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class SyncshellTagStorage : ILightlessConfiguration
+{
+    public Dictionary<string, Models.SyncshellTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

LightlessSync/LightlessConfiguration/Models/PairTagStorage.cs

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

LightlessSync/LightlessConfiguration/Models/SyncshellTagStorage.cs

@@ -0,0 +1,9 @@
+namespace LightlessSync.LightlessConfiguration.Models;
+
+[Serializable]
+public class SyncshellTagStorage
+{
+    public HashSet<string> OpenSyncshellTags { get; set; } = new(StringComparer.Ordinal);
+    public HashSet<string> ServerAvailableSyncshellTags { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, List<string>> SyncshellPairedTags { get; set; } = new(StringComparer.Ordinal);
+}

LightlessSync/LightlessConfiguration/PairTagConfigService.cs

@@ -2,7 +2,7 @@
 
 namespace LightlessSync.LightlessConfiguration;
 
-public class PairTagConfigService : ConfigurationServiceBase<ServerTagConfig>
+public class PairTagConfigService : ConfigurationServiceBase<PairTagStorage>
 {
     public const string ConfigName = "servertags.json";
 

LightlessSync/LightlessConfiguration/SyncshellTagConfigService.cs

@@ -2,9 +2,9 @@
 
 namespace LightlessSync.LightlessConfiguration;
 
-public class SyncshellTagConfigService : ConfigurationServiceBase<ServerTagConfig>
+public class SyncshellTagConfigService : ConfigurationServiceBase<SyncshellTagStorage>
 {
-    public const string ConfigName = "serversyncshelltags.json";
+    public const string ConfigName = "syncshelltags.json";
 
     public SyncshellTagConfigService(string configDir) : base(configDir)
     {

LightlessSync/Services/ServerConfiguration/ServerConfigurationManager.cs

@@ -3,6 +3,7 @@ using LightlessSync.API.Routes;
 using LightlessSync.LightlessConfiguration;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.Services.Mediator;
+using LightlessSync.UI.Components;
 using LightlessSync.WebAPI;
 using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.Extensions.Logging;
@@ -260,7 +261,7 @@ public class ServerConfigurationManager
     {
         if (serverSelectionIndex == -1) serverSelectionIndex = CurrentServerIndex;
         var server = GetServerByIndex(serverSelectionIndex);
-        if (server.Authentications.Any(c => string.Equals(c.CharacterName, _dalamudUtil.GetPlayerNameAsync().GetAwaiter().GetResult(), StringComparison.Ordinal)
+        if (server.Authentications.Exists(c => string.Equals(c.CharacterName, _dalamudUtil.GetPlayerNameAsync().GetAwaiter().GetResult(), StringComparison.Ordinal)
                 && c.WorldId == _dalamudUtil.GetHomeWorldIdAsync().GetAwaiter().GetResult()))
             return;
 
@@ -279,17 +280,23 @@ public class ServerConfigurationManager
         var server = GetServerByIndex(serverSelectionIndex);
         server.Authentications.Add(new Authentication()
         {
-            SecretKeyIdx = server.SecretKeys.Any() ? server.SecretKeys.First().Key : -1,
+            SecretKeyIdx = server.SecretKeys.Count != 0 ? server.SecretKeys.First().Key : -1,
         });
         Save();
     }
 
     internal void AddOpenPairTag(string tag)
     {
-        CurrentServerTagStorage().OpenPairTags.Add(tag);
+        CurrentPairTagStorage().OpenPairTags.Add(tag);
         _pairTagConfig.Save();
     }
 
+    internal void AddOpenSyncshellTag(string tag)
+    {
+        CurrentSyncshellTagStorage().OpenSyncshellTags.Add(tag);
+        _syncshellTagConfig.Save();
+    }
+
     internal void AddServer(ServerStorage serverStorage)
     {
         _configService.Current.ServerStorage.Add(serverStorage);
@@ -298,41 +305,66 @@ public class ServerConfigurationManager
 
     internal void AddPairTag(string tag)
     {
-        CurrentServerTagStorage().ServerAvailablePairTags.Add(tag);
+        CurrentPairTagStorage().ServerAvailablePairTags.Add(tag);
         _pairTagConfig.Save();
         _lightlessMediator.Publish(new RefreshUiMessage());
     }
 
     internal void AddSyncshellTag(string tag)
     {
-        CurrentServerTagStorage().ServerAvailableSyncshellTags.Add(tag);
+        CurrentSyncshellTagStorage().ServerAvailableSyncshellTags.Add(tag);
-        _pairTagConfig.Save();
+        _syncshellTagConfig.Save();
         _lightlessMediator.Publish(new RefreshUiMessage());
     }
 
     internal void AddTagForUid(string uid, string tagName)
     {
-        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        if (CurrentPairTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
         {
             tags.Add(tagName);
             _lightlessMediator.Publish(new RefreshUiMessage());
         }
         else
         {
-            CurrentServerTagStorage().UidServerPairedUserTags[uid] = [tagName];
+            CurrentPairTagStorage().UidServerPairedUserTags[uid] = [tagName];
         }
 
         _pairTagConfig.Save();
     }
 
-    internal bool ContainsOpenPairTag(string tag)
+    internal void AddTagForSyncshell(string syncshellName, string tagName)
     {
-        return CurrentServerTagStorage().OpenPairTags.Contains(tag);
+        if (CurrentSyncshellTagStorage().SyncshellPairedTags.TryGetValue(syncshellName, out var tags))
+        {
+            tags.Add(tagName);
+            _lightlessMediator.Publish(new RefreshUiMessage());
+        }
+        else
+        {
+            CurrentPairTagStorage().UidServerPairedUserTags[syncshellName] = [tagName];
+        }
+
+        _syncshellTagConfig.Save();
     }
 
-    internal bool ContainsTag(string uid, string tag)
+    internal bool ContainsOpenPairTag(string tag)
     {
-        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        return CurrentPairTagStorage().OpenPairTags.Contains(tag);
+    }
+
+    internal bool ContainsPairTag(string uid, string tag)
+    {
+        if (CurrentPairTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        {
+            return tags.Contains(tag, StringComparer.Ordinal);
+        }
+
+        return false;
+    }
+
+    internal bool ContainsSyncshellTag(string name, string tag)
+    {
+        if (CurrentSyncshellTagStorage().SyncshellPairedTags.TryGetValue(name, out var tags))
         {
             return tags.Contains(tag, StringComparer.Ordinal);
         }
@@ -375,32 +407,37 @@ public class ServerConfigurationManager
 
     internal HashSet<string> GetServerAvailablePairTags()
     {
-        return CurrentServerTagStorage().ServerAvailablePairTags;
+        return CurrentPairTagStorage().ServerAvailablePairTags;
     }
 
     internal HashSet<string> GetServerAvailableSyncshellTags()
     {
-        return CurrentServerTagStorage().ServerAvailableSyncshellTags;
+        return CurrentSyncshellTagStorage().ServerAvailableSyncshellTags;
     }
 
     internal Dictionary<string, List<string>> GetUidServerPairedUserTags()
     {
-        return CurrentServerTagStorage().UidServerPairedUserTags;
+        return CurrentPairTagStorage().UidServerPairedUserTags;
     }
 
-    internal HashSet<string> GetUidsForTag(string tag)
+    internal HashSet<string> GetUidsForPairTag(string tag)
     {
-        return CurrentServerTagStorage().UidServerPairedUserTags.Where(p => p.Value.Contains(tag, StringComparer.Ordinal)).Select(p => p.Key).ToHashSet(StringComparer.Ordinal);
+        return CurrentPairTagStorage().UidServerPairedUserTags.Where(p => p.Value.Contains(tag, StringComparer.Ordinal)).Select(p => p.Key).ToHashSet(StringComparer.Ordinal);
     }
 
-    internal bool HasTags(string uid)
+    internal HashSet<string> GetNamesForSyncshellTag(string tag)
     {
-        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        return CurrentPairTagStorage().UidServerPairedUserTags.Where(p => p.Value.Contains(tag, StringComparer.Ordinal)).Select(p => p.Key).ToHashSet(StringComparer.Ordinal);
-        {
+    }
-            return tags.Any();
-        }
 
-        return false;
+    internal bool HasPairTags(string uid)
+    {
+        return CurrentPairTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags) && tags.Count != 0;
+    }
+
+    internal bool HasSyncshellTags(string name)
+    {
+        return CurrentSyncshellTagStorage().SyncshellPairedTags.TryGetValue(name, out var tags) && tags.Count != 0;
     }
 
     internal void RemoveCharacterFromServer(int serverSelectionIndex, Authentication item)
@@ -412,24 +449,42 @@ public class ServerConfigurationManager
 
     internal void RemoveOpenPairTag(string tag)
     {
-        CurrentServerTagStorage().OpenPairTags.Remove(tag);
+        CurrentPairTagStorage().OpenPairTags.Remove(tag);
         _pairTagConfig.Save();
     }
 
-    internal void RemoveTag(string tag)
+    internal void RemoveOpenSyncshellTag(string tag)
     {
-        CurrentServerTagStorage().ServerAvailablePairTags.Remove(tag);
+        CurrentSyncshellTagStorage().OpenSyncshellTags.Remove(tag);
-        foreach (var uid in GetUidsForTag(tag))
+        _syncshellTagConfig.Save();
-        {
+    }
-            RemoveTagForUid(uid, tag, save: false);
+
-        }
+    internal void RemovePairTag(string tag)
+    {
+        RemoveTag(CurrentPairTagStorage().ServerAvailablePairTags, tag);
         _pairTagConfig.Save();
         _lightlessMediator.Publish(new RefreshUiMessage());
     }
 
+    internal void RemoveSyncshellTag(string tag)
+    {
+        RemoveTag(CurrentSyncshellTagStorage().ServerAvailableSyncshellTags, tag);
+        _syncshellTagConfig.Save();
+        _lightlessMediator.Publish(new RefreshUiMessage());
+    }
+
+    internal void RemoveTag(HashSet<string> storage, string tag)
+    {
+        CurrentPairTagStorage().ServerAvailablePairTags.Remove(tag);
+        foreach (var uid in GetUidsForPairTag(tag))
+        {
+            RemoveTagForUid(uid, tag, save: false);
+        }
+    }
+
     internal void RemoveTagForUid(string uid, string tagName, bool save = true)
     {
-        if (CurrentServerTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
+        if (CurrentPairTagStorage().UidServerPairedUserTags.TryGetValue(uid, out var tags))
         {
             tags.Remove(tagName);
 
@@ -441,11 +496,35 @@ public class ServerConfigurationManager
         }
     }
 
-    internal void RenameTag(string oldName, string newName)
+    internal void RemoveTagForSyncshell(string name, string tagName, bool save = true)
     {
-        CurrentServerTagStorage().ServerAvailablePairTags.Remove(oldName);
+        if (CurrentSyncshellTagStorage().SyncshellPairedTags.TryGetValue(name, out var tags))
-        CurrentServerTagStorage().ServerAvailablePairTags.Add(newName);
+        {
-        foreach (var existingTags in CurrentServerTagStorage().UidServerPairedUserTags.Select(k => k.Value))
+            tags.Remove(tagName);
+
+            if (save)
+            {
+                _syncshellTagConfig.Save();
+                _lightlessMediator.Publish(new RefreshUiMessage());
+            }
+        }
+    }
+
+    internal void RenamePairTag(string oldName, string newName)
+    {
+        RenameTag(CurrentPairTagStorage().UidServerPairedUserTags, CurrentPairTagStorage().ServerAvailablePairTags, oldName, newName);
+    }
+
+    internal void RenameSyncshellTag(string oldName, string newName)
+    {
+        RenameTag(CurrentSyncshellTagStorage().SyncshellPairedTags, CurrentSyncshellTagStorage().ServerAvailableSyncshellTags, oldName, newName);
+    }
+
+    internal static void RenameTag(Dictionary<string, List<string>> tags, HashSet<string> storage, string oldName, string newName)
+    {
+        storage.Remove(oldName);
+        storage.Add(newName);
+        foreach (var existingTags in tags.Select(k => k.Value))
         {
             if (existingTags.Remove(oldName))
                 existingTags.Add(newName);
@@ -490,12 +569,18 @@ public class ServerConfigurationManager
         return _notesConfig.Current.ServerNotes[CurrentApiUrl];
     }
 
-    private ServerTagStorage CurrentServerTagStorage()
+    private PairTagStorage CurrentPairTagStorage()
     {
-        TryCreateCurrentServerTagStorage();
+        TryCreateCurrentPairTagStorage();
         return _pairTagConfig.Current.ServerTagStorage[CurrentApiUrl];
     }
 
+    private SyncshellTagStorage CurrentSyncshellTagStorage()
+    {
+        TryCreateCurrentSyncshellTagStorage();
+        return _syncshellTagConfig.Current.ServerTagStorage[CurrentApiUrl];
+    }
+
     private void EnsureMainExists()
     {
         if (_configService.Current.ServerStorage.Count == 0 || !string.Equals(_configService.Current.ServerStorage[0].ServerUri, ApiController.MainServiceUri, StringComparison.OrdinalIgnoreCase))
@@ -513,7 +598,7 @@ public class ServerConfigurationManager
         }
     }
 
-    private void TryCreateCurrentServerTagStorage()
+    private void TryCreateCurrentPairTagStorage()
     {
         if (!_pairTagConfig.Current.ServerTagStorage.ContainsKey(CurrentApiUrl))
         {
@@ -521,6 +606,14 @@ public class ServerConfigurationManager
         }
     }
 
+    private void TryCreateCurrentSyncshellTagStorage()
+    {
+        if (!_pairTagConfig.Current.ServerTagStorage.ContainsKey(CurrentApiUrl))
+        {
+            _syncshellTagConfig.Current.ServerTagStorage[CurrentApiUrl] = new();
+        }
+    }
+
     public async Task<Dictionary<string, string>> GetUIDsWithDiscordToken(string serverUri, string token)
     {
         try

LightlessSync/UI/CompactUI.cs

@@ -462,12 +462,14 @@ public class CompactUi : WindowMediatorSubscriberBase
         bool FilterVisibleUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
             => u.Key.IsVisible
                 && (_configService.Current.ShowSyncshellUsersInVisible || !(!_configService.Current.ShowSyncshellUsersInVisible && !u.Key.IsDirectlyPaired));
-        bool FilterTagusers(KeyValuePair<Pair, List<GroupFullInfoDto>> u, string tag)
+        bool FilterTagUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u, string tag)
-            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && _tagHandler.HasTag(u.Key.UserData.UID, tag);
+            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && _tagHandler.HasPairTag(u.Key.UserData.UID, tag);
+        bool FilterTagSyncshells(KeyValuePair<Pair, List<GroupFullInfoDto>> u, string tag)
+        => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && _tagHandler.HasSyncshellTag(u.Key.UserData.UID, tag);
         bool FilterGroupUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u, GroupFullInfoDto group)
             => u.Value.Exists(g => string.Equals(g.GID, group.GID, StringComparison.Ordinal));
         bool FilterNotTaggedUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && !_tagHandler.HasAnyTag(u.Key.UserData.UID);
+            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && !_tagHandler.HasAnyPairTag(u.Key.UserData.UID);
         bool FilterOfflineUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
             => ((u.Key.IsDirectlyPaired && _configService.Current.ShowSyncshellOfflineUsersSeparately)
                 || !_configService.Current.ShowSyncshellOfflineUsersSeparately)
@@ -521,9 +523,9 @@ public class CompactUi : WindowMediatorSubscriberBase
         foreach (var tag in tags)
         {
             var allTagPairs = ImmutablePairList(allPairs
-                .Where(u => FilterTagusers(u, tag)));
+                .Where(u => FilterTagUsers(u, tag)));
             var filteredTagPairs = BasicSortedDictionary(filteredPairs
-                .Where(u => FilterTagusers(u, tag) && FilterOnlineOrPausedSelf(u)));
+                .Where(u => FilterTagUsers(u, tag) && FilterOnlineOrPausedSelf(u)));
 
             drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(tag, filteredTagPairs, allTagPairs));
         }
@@ -533,9 +535,9 @@ public class CompactUi : WindowMediatorSubscriberBase
         foreach (var syncshelltag in syncshellTags)
         {
             var allTagPairs = ImmutablePairList(allPairs
-                .Where(u => FilterTagusers(u, syncshelltag)));
+                .Where(u => FilterTagUsers(u, syncshelltag)));
             var filteredTagPairs = BasicSortedDictionary(filteredPairs
-                .Where(u => FilterTagusers(u, syncshelltag) && FilterOnlineOrPausedSelf(u)));
+                .Where(u => FilterTagUsers(u, syncshelltag) && FilterOnlineOrPausedSelf(u)));
 
             drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(syncshelltag, filteredTagPairs, allTagPairs));
         }

LightlessSync/UI/Components/DrawFolderTag.cs

@@ -112,7 +112,7 @@ public class DrawFolderTag : DrawFolderBase
         }
         if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Delete Pair Group", menuWidth, isInPopup: true) && UiSharedService.CtrlPressed())
         {
-            _tagHandler.RemoveTag(_id);
+            _tagHandler.RemovePairTag(_id);
         }
         UiSharedService.AttachToolTip("Hold CTRL to remove this Group permanently." + Environment.NewLine +
             "Note: this will not unpair with users in this Group.");

LightlessSync/UI/Components/RenameTagUi.cs

@@ -77,7 +77,7 @@ public class RenameTagUi
     public void RenameTag(List<Pair> pairs, string oldTag, string newTag)
     {
         //Removal of old tag
-        _tagHandler.RemoveTag(oldTag);
+        _tagHandler.RemovePairTag(oldTag);
 
         //Creation of new tag and adding of old group pairs in new one.
         _tagHandler.AddPairTag(newTag);
@@ -86,7 +86,7 @@ public class RenameTagUi
             var isInTag = _peopleInGroup.Contains(pair.UserData.UID);
             if (isInTag)
             {
-                _tagHandler.AddTagToPairedUid(pair.UserData.UID, newTag);
+                _tagHandler.AddPairTagToPairedUid(pair.UserData.UID, newTag);
             }
         }
     }

LightlessSync/UI/Components/SelectPairForTagUi.cs

@@ -60,7 +60,7 @@ public class SelectPairForTagUi
                 {
                     if (isInGroup)
                     {
-                        _tagHandler.AddTagToPairedUid(item.UserData.UID, _tag);
+                        _tagHandler.AddPairTagToPairedUid(item.UserData.UID, _tag);
                         _peopleInGroup.Add(item.UserData.UID);
                     }
                     else

LightlessSync/UI/Components/SelectTagForPairUi.cs

@@ -101,13 +101,13 @@ public class SelectTagForPairUi
 
     private void DrawGroupName(Pair pair, string name)
     {
-        var hasTagBefore = _tagHandler.HasTag(pair.UserData.UID, name);
+        var hasTagBefore = _tagHandler.HasPairTag(pair.UserData.UID, name);
         var hasTag = hasTagBefore;
         if (ImGui.Checkbox(name, ref hasTag))
         {
             if (hasTag)
             {
-                _tagHandler.AddTagToPairedUid(pair.UserData.UID, name);
+                _tagHandler.AddPairTagToPairedUid(pair.UserData.UID, name);
             }
             else
             {
@@ -123,7 +123,7 @@ public class SelectTagForPairUi
             _tagHandler.AddPairTag(_tagNameToAdd);
             if (_pair != null)
             {
-                _tagHandler.AddTagToPairedUid(_pair.UserData.UID, _tagNameToAdd);
+                _tagHandler.AddPairTagToPairedUid(_pair.UserData.UID, _tagNameToAdd);
             }
             _tagNameToAdd = string.Empty;
         }

LightlessSync/UI/Handlers/IdDisplayHandler.cs

@@ -43,9 +43,9 @@ public class IdDisplayHandler
             if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
             {
                 var prevState = textIsUid;
-                if (_showIdForEntry.ContainsKey(group.GID))
+                if (_showIdForEntry.TryGetValue(group.GID, out bool value))
                 {
-                    prevState = _showIdForEntry[group.GID];
+                    prevState = value;
                 }
                 _showIdForEntry[group.GID] = !prevState;
             }

LightlessSync/UI/Handlers/TagHandler.cs

@@ -17,57 +17,146 @@ public class TagHandler
         _serverConfigurationManager = serverConfigurationManager;
     }
 
+    /// <summary>
+    /// Creation of an pair tag
+    /// </summary>
+    /// <param name="tag">Name of the tag</param>
     public void AddPairTag(string tag) => _serverConfigurationManager.AddPairTag(tag);
-    public void AddSyncshellTag(string tag) => _serverConfigurationManager.AddSyncshellTag(tag);
-    public void AddTagToPairedUid(string uid, string tagName) => _serverConfigurationManager.AddTagForUid(uid, tagName);
 
+    /// <summary>
+    /// Creation of an syncshell tag
+    /// </summary>
+    /// <param name="tag">Name of the tag</param>
+    public void AddSyncshellTag(string tag) => _serverConfigurationManager.AddSyncshellTag(tag);
+
+    /// <summary>
+    /// Add pair to tag
+    /// </summary>
+    /// <param name="uid">UID that will be added to tag/param>
+    /// <param name="tagName">Name of the tag</param>
+    public void AddPairTagToPairedUid(string uid, string tagName) => _serverConfigurationManager.AddTagForUid(uid, tagName);
+
+    /// <summary>
+    /// Add syncshell to tag
+    /// </summary>
+    /// <param name="name">Syncshell that will be added to tag/param>
+    /// <param name="tagName">Name of the tag</param>
+    public void AddTagToSyncshell(string name, string tagName) => _serverConfigurationManager.AddTagForSyncshell(name, tagName);
+
+    /// <summary>
+    /// Get all pair tags
+    /// </summary>
     public List<string> GetAllPairTagsSorted() => [
             .. _serverConfigurationManager.GetServerAvailablePairTags()
-                        .OrderBy(s => s, StringComparer.OrdinalIgnoreCase)
+                        .Order(StringComparer.OrdinalIgnoreCase)
 ,
         ];
 
+    /// <summary>
+    /// Get all syncshell tags
+    /// </summary>
     public List<string> GetAllSyncshellTagsSorted() => [
             .. _serverConfigurationManager.GetServerAvailableSyncshellTags()
-                        .OrderBy(s => s, StringComparer.OrdinalIgnoreCase)
+                        .Order(StringComparer.OrdinalIgnoreCase)
 ,
         ];
 
-    public HashSet<string> GetOtherUidsForTag(string tag)
+    /// <summary>
-    {
+    /// Get all UIDs bound to an given tag
-        return _serverConfigurationManager.GetUidsForTag(tag);
+    /// </summary>
-    }
+    /// <param name="name">Name of the tag</param>
+    public HashSet<string> GetOtherUidsForTag(string tag) => _serverConfigurationManager.GetUidsForPairTag(tag);
 
-    public bool HasAnyTag(string uid)
+    /// <summary>
-    {
+    /// Get all syncshells bound to an given tag
-        return _serverConfigurationManager.HasTags(uid);
+    /// </summary>
-    }
+    /// <param name="name">Name of the tag</param>
+    public HashSet<string> GetOtherSyncshellsForTag(string tag) => _serverConfigurationManager.GetNamesForSyncshellTag(tag);
 
-    public bool HasTag(string uid, string tagName)
+    /// <summary>
-    {
+    /// Checking if the UID is connected to any tag
-        return _serverConfigurationManager.ContainsTag(uid, tagName);
+    /// </summary>
-    }
+    /// <param name="uid">Syncshell that needs to be checked</param>
+    public bool HasAnyPairTag(string uid) => _serverConfigurationManager.HasPairTags(uid);
+
+    /// <summary>
+    /// Checking if the syncshell is connected to the tag
+    /// </summary>
+    /// <param name="name">Syncshell that needs to be checked</param>
+    public bool HasAnySyncshellTag(string name) => _serverConfigurationManager.HasSyncshellTags(name);
+
+    /// <summary>
+    /// Checking if the UID is connected to the tag
+    /// </summary>
+    /// <param name="uid">UID that needs to be checked</param>
+    /// <param name="tagName">Name of the tag</param>
+    public bool HasPairTag(string uid, string tagName) => _serverConfigurationManager.ContainsPairTag(uid, tagName);
+
+    /// <summary>
+    /// Checking if the syncshell is connected to the tag
+    /// </summary>
+    /// <param name="name">Syncshell that needs to be checked</param>
+    /// <param name="tagName">Name of the tag</param>
+    public bool HasSyncshellTag(string name, string tagName) => _serverConfigurationManager.ContainsSyncshellTag(name, tagName);
 
     /// <summary>
     /// Is this tag opened in the paired clients UI?
     /// </summary>
     /// <param name="tag">the tag</param>
     /// <returns>open true/false</returns>
-    public bool IsTagOpen(string tag)
+    public bool IsTagOpen(string tag) => _serverConfigurationManager.ContainsOpenPairTag(tag);
+
+    /// <summary>
+    /// Removal of Pair Tags from Storage
+    /// </summary>
+    /// <param name="tag">Name of the tag</param>
+    public void RemovePairTag(string tag) => _serverConfigurationManager.RemovePairTag(tag);
+
+    /// <summary>
+    /// Removal of Syncshell Tags from Storage
+    /// </summary>
+    /// <param name="tag">Name of the tag</param>
+    public void RemoveSyncshellTag(string tag) => _serverConfigurationManager.RemoveSyncshellTag(tag);
+
+    /// <summary>
+    /// Removal of UID in a Tag
+    /// </summary>
+    /// <param name="uid">UID of user thats bound to the tag</param>
+    /// <param name="tagName">Name of the tag</param>
+    public void RemoveTagFromPairedUid(string uid, string tagName) => _serverConfigurationManager.RemoveTagForUid(uid, tagName);
+
+    /// <summary>
+    /// Removal of Syncshell in a Tag
+    /// </summary>
+    /// <param name="name">Syncshell thats bound to the tag</param>
+    /// <param name="tagName">Name of the tag</param>
+    public void RemoveTagFromSyncshell(string name, string tagName) => _serverConfigurationManager.RemoveTagForSyncshell(name, tagName);
+
+    /// <summary>
+    /// Rename of a pair tag
+    /// </summary>
+    /// <param name="oldName">Old pair tag name</param>
+    /// <param name="newName">New pair tag name</param>
+    public void RenamePairTag(string oldName, string newName)
     {
-        return _serverConfigurationManager.ContainsOpenPairTag(tag);
+        _serverConfigurationManager.RenamePairTag(oldName, newName);
     }
 
-    public void RemoveTag(string tag)
+    /// <summary>
+    /// Rename of a syncshell tag
+    /// </summary>
+    /// <param name="oldName">Old syncshell tag name</param>
+    /// <param name="newName">New syncshell tag name</param>
+    public void RenameSyncshellTag(string oldName, string newName)
     {
-        _serverConfigurationManager.RemoveTag(tag);
+        _serverConfigurationManager.RenameSyncshellTag(oldName, newName);
-    }
-
-    public void RemoveTagFromPairedUid(string uid, string tagName)
-    {
-        _serverConfigurationManager.RemoveTagForUid(uid, tagName);
     }
 
+    /// <summary>
+    /// Changes the tag to open/close
+    /// </summary>
+    /// <param name="tag">The Tag that will be modified</param>
+    /// <param name="open">True/False</param>
     public void SetTagOpen(string tag, bool open)
     {
         if (open)