ConfigurationNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.GatewayConfig
{
    public abstract class ConfigurationNode : INode
    {
        private readonly List<ConfigurationNode> children = new List<ConfigurationNode>();
        private GatewayConfigSource source;
        private ConfigurationNode parent;
 
        public ConfigurationNode()
        {
            this.source = null;
            this.parent = null;
        }
 
        public ConfigurationNode(GatewayConfigSource Source, ConfigurationNode Parent)
        {
            this.source = Source;
            this.parent = Parent;
        }
 
        public GatewayConfigSource Source => this.source;
 
        public abstract string NodeId { get; }
 
        public string SourceId => GatewayConfigSource.SourceID;
 
        public string Partition => string.Empty;
 
        public virtual string LocalId => this.NodeId;
 
        public string LogId => this.NodeId;
 
        public abstract Task<string> GetTypeNameAsync(Language Language);
 
        public virtual bool HasChildren
        {
            get
            {
                lock (this.children)
                {
                    return this.children.Count > 0;
                }
            }
        }
 
        public virtual bool ChildrenOrdered => false;
 
        public bool IsReadable => false;
 
        public bool IsControllable => false;
 
        public virtual bool HasCommands => false;
 
        public virtual INode Parent => this.parent;
 
        public DateTime LastChanged => GatewayConfigSource.nodesTimestamp;
 
        public NodeState State => NodeState.None;
 
        public virtual Task<IEnumerable<INode>> ChildNodes => Task.FromResult<IEnumerable<INode>>(this.children);
 
        internal ConfigurationNode[] Children
        {
            get
            {
                lock (this.children)
                {
                    return this.children.ToArray();
                }
            }
        }
 
        internal IEnumerable<ConfigurationNode> Siblings => this.parent?.children;
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + GatewayConfigSource.SourceID + ".Node.View"));
        }
 
        public virtual Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + GatewayConfigSource.SourceID + ".Node.Edit"));
        }
 
        public virtual Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + GatewayConfigSource.SourceID + ".Node.Add"));
        }
 
        public virtual Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + GatewayConfigSource.SourceID + ".Node.Destroy"));
        }
 
        public virtual Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Parameter>>(Array.Empty<Parameter>());
        }
 
        public virtual Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller) => Task.FromResult<IEnumerable<Message>>(null);
 
        public virtual Task<bool> MoveUpAsync(RequestOrigin Caller)
        {
            if (this.parent is null || !this.parent.ChildrenOrdered)
                Task.FromResult(false);
 
            lock (this.parent.children)
            {
                int i = this.parent.children.IndexOf(this);
                if (i <= 0)
                    return Task.FromResult(false);
 
                this.parent.children.RemoveAt(i);
                this.parent.children.Insert(i - 1, this);
 
                return Task.FromResult(true);
            }
        }
 
        public virtual Task<bool> MoveDownAsync(RequestOrigin Caller)
        {
            if (this.parent is null || !this.parent.ChildrenOrdered)
                Task.FromResult(false);
 
            lock (this.parent.children)
            {
                int i = this.parent.children.IndexOf(this);
                if (i < 0 || i >= this.parent.children.Count - 1)
                    return Task.FromResult(false);
 
                this.parent.children.RemoveAt(i);
                this.parent.children.Insert(i + 1, this);
 
                return Task.FromResult(true);
            }
        }
 
        public virtual Task<bool> AcceptsParentAsync(INode Parent) => Task.FromResult(false);
 
        public virtual Task<bool> AcceptsChildAsync(INode Child) => Task.FromResult(false);
 
        public virtual Task AddAsync(INode Child)
        {
            if (!(Child is ConfigurationNode ConfigurationNode))
                throw new InvalidOperationException("Incompatible type.");
 
            this.AddInternal(ConfigurationNode);
            
            return this.source?.NodeAdded(Child, false) ?? Task.CompletedTask;
        }
 
        internal void AddInternal(ConfigurationNode Child)
        {
            lock (this.children)
            {
                this.children.Add(Child);
            }
 
            Child.source = this.source;
            Child.parent = this;
        }
 
        public virtual Task UpdateAsync() => this.source?.NodeUpdated(this, false) ?? Task.CompletedTask;
 
        public virtual Task<bool> RemoveAsync(INode Child)
        {
            if (!(Child is ConfigurationNode ConfigurationNode))
                return Task.FromResult(false);
 
            lock (this.children)
            {
                return Task.FromResult(this.children.Remove(ConfigurationNode));
            }
        }
 
        public virtual Task DestroyAsync() => this.source?.NodeDeleted(this, false) ?? Task.CompletedTask;
 
        public virtual Task<IEnumerable<ICommand>> Commands => Task.FromResult<IEnumerable<ICommand>>(null);
    }
}