Added groups & permissions. Fixed 7tv reconnection. Added more subcommands for refresh.

Chat/Groups/Permissions/GroupPermission.cs

@@ -0,0 +1,10 @@
+namespace TwitchChatTTS.Chat.Groups.Permissions
+{
+    public class GroupPermission
+    {
+        public string Id { get; set; }
+        public string GroupId { get; set; }
+        public string Path { get; set; }
+        public bool? Allow { get; set; }
+    }
+}

Chat/Groups/Permissions/GroupPermissionManager.cs

@@ -0,0 +1,145 @@
+using System.Collections.ObjectModel;
+using Serilog;
+
+namespace TwitchChatTTS.Chat.Groups.Permissions
+{
+    public class GroupPermissionManager : IGroupPermissionManager
+    {
+        private PermissionNode _root;
+        private ILogger _logger;
+
+
+        public GroupPermissionManager(ILogger logger)
+        {
+            _logger = logger;
+            _root = new PermissionNode(string.Empty, null, null);
+        }
+
+
+        public bool? CheckIfAllowed(string path)
+        {
+            var res = Get(path)?.Allow;
+            _logger.Debug($"Permission Node GET {path} = {res?.ToString() ?? "null"}");
+            return res;
+        }
+
+        public bool? CheckIfAllowed(IEnumerable<string> groups, string path) {
+            bool overall = false;
+            foreach (var group in groups) {
+                var result = CheckIfAllowed($"{group}.{path}");
+                if (result == false)
+                    return false;
+                if (result == true)
+                    overall = true;
+            }
+            return overall ? true : null;
+        }
+
+        public void Clear()
+        {
+            if (_root.Children != null)
+                _root.Children.Clear();
+        }
+
+        public bool Remove(string path)
+        {
+            var node = Get(path);
+            if (node == null || node.Parent == null)
+                return false;
+
+            var parts = path.Split('.');
+            var last = parts.Last();
+            if (parts.Length > 1 && parts[parts.Length - 1] == node.Parent.Name || parts.Length == 1 && node.Parent.Name == null)
+            {
+                node.Parent.Remove(last);
+                _logger.Debug($"Permission Node REMOVE priv {path}");
+                return true;
+            }
+            return false;
+        }
+
+        public void Set(string path, bool? allow)
+        {
+            var node = Get(path, true);
+            node.Allow = allow;
+            _logger.Debug($"Permission Node ADD {path} = {allow?.ToString() ?? "null"}");
+        }
+
+        private PermissionNode Get(string path, bool edit = false)
+        {
+            return Get(_root, path.ToLower(), edit);
+        }
+
+        private PermissionNode Get(PermissionNode node, string path, bool edit)
+        {
+            if (path.Length == 0)
+                return node;
+            
+            var parts = path.Split('.');
+            var name = parts.First();
+            var next = node.Children?.FirstOrDefault(n => n.Name == name);
+            if (next == null)
+            {
+                if (!edit)
+                    return node;
+
+                next = new PermissionNode(name, node, null);
+                node.Add(next);
+            }
+            return Get(next, string.Join('.', parts.Skip(1)), edit);
+        }
+    }
+
+    internal class PermissionNode
+    {
+        public string Name { get; }
+        public bool? Allow
+        {
+            get
+            {
+                var current = this;
+                while (current._allow == null && current._parent != null)
+                    current = current._parent;
+                return current._allow;
+            }
+            set => _allow = value;
+        }
+        public int Priority;
+        internal PermissionNode? Parent { get => _parent; }
+        public IList<PermissionNode>? Children { get => _children == null ? null : new ReadOnlyCollection<PermissionNode>(_children); }
+
+        private bool? _allow;
+        private PermissionNode? _parent;
+        private IList<PermissionNode>? _children;
+
+
+        public PermissionNode(string name, PermissionNode? parent, bool? allow)
+        {
+            Name = name;
+            _parent = parent;
+            _allow = allow;
+        }
+
+        internal void Add(PermissionNode child)
+        {
+            if (_children == null)
+                _children = new List<PermissionNode>();
+            _children.Add(child);
+        }
+
+        public void Remove(string name)
+        {
+            if (_children == null || !_children.Any())
+                return;
+
+            for (var i = 0; i < _children.Count; i++)
+            {
+                if (_children[i].Name == name)
+                {
+                    _children.RemoveAt(i);
+                    break;
+                }
+            }
+        }
+    }
+}

Chat/Groups/Permissions/IGroupPermissionManager.cs

@@ -0,0 +1,11 @@
+namespace TwitchChatTTS.Chat.Groups.Permissions
+{
+    public interface IGroupPermissionManager
+    {
+        void Set(string path, bool? allow);
+        bool? CheckIfAllowed(string path);
+        bool? CheckIfAllowed(IEnumerable<string> groups, string path);
+        void Clear();
+        bool Remove(string path);
+    }
+}