MeteringNode.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Runtime.Language;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
using Waher.Things.Metering.Commands;
using Waher.Things.SensorData;
using Waher.Things.SourceEvents;
 
namespace Waher.Things.Metering
{
    [CollectionName("MeteringTopology")]
    [TypeName(TypeNameSerialization.FullName)]
    [ArchivingTime]
    [Index("NodeId")]
    [Index("ParentId", "NodeId")]
    public abstract class MeteringNode : IMeteringNode
    {
        private Guid objectId = Guid.Empty;
        private Guid parentId = Guid.Empty;
        private MeteringNode parent = null;
        private string nodeId = string.Empty;
        private string oldId = null;
        private NodeState state = NodeState.None;
        private List<MeteringNode> children = null;
        private bool childrenLoaded = false;
        private readonly object synchObject = new object();
        private DateTime created = DateTime.Now;
        private DateTime updated = DateTime.MinValue;
        private ThingReference thingReference = null;
 
        public MeteringNode()
        {
        }
 
        public static implicit operator ThingReference(MeteringNode Node)
        {
            if (Node.thingReference is null)
                Node.thingReference = new ThingReference(Node.nodeId, Node.SourceId, Node.Partition);
 
            return Node.thingReference;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is IThingReference Ref))
                return false;
            else
                return this.nodeId == Ref.NodeId && this.SourceId == Ref.SourceId && this.Partition == Ref.Partition;
        }
 
        public override int GetHashCode()
        {
            return this.nodeId.GetHashCode() ^
                this.SourceId.GetHashCode() ^
                this.Partition.GetHashCode();
        }
 
        [ObjectId]
        public Guid ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public Guid ParentId
        {
            get => this.parentId;
            set => this.parentId = value;
        }
 
        public DateTime Created
        {
            get => this.created;
            set => this.created = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime Updated
        {
            get => this.updated;
            set => this.updated = value;
        }
 
        [Header(15, "ID:", 0)]
        [Page(16, "Identity", 0)]
        [ToolTip(17, "Node identity on the network.")]
        [Required]
        public string NodeId
        {
            get => this.nodeId;
            set
            {
                this.nodeId = value;
                this.thingReference = null;
 
                if (this.oldId is null && !string.IsNullOrEmpty(value))
                    this.oldId = value;
            }
        }
 
        [IgnoreMember]
        public string SourceId => MeteringTopology.SourceID;
 
        [IgnoreMember]
        public string Partition => string.Empty;
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            Language Language = Translator.GetDefaultLanguageAsync().Result;
 
            sb.Append(this.nodeId);
            sb.Append(" (");
            sb.Append(this.GetTypeNameAsync(Language).Result);
            sb.Append(")");
 
            foreach (Parameter P in this.GetDisplayableParametersAsync(Language, RequestOrigin.Empty).Result)
            {
                sb.Append(", ");
                sb.Append(P.Name);
                sb.Append("=");
                sb.Append(P.StringValue);
            }
 
            return sb.ToString();
        }
 
        public virtual Task LogErrorAsync(string Body)
        {
            return this.LogMessageAsync(MessageType.Error, string.Empty, Body);
        }
 
        public virtual Task LogErrorAsync(string EventId, string Body)
        {
            return this.LogMessageAsync(MessageType.Error, EventId, Body);
        }
 
        public virtual Task LogWarningAsync(string Body)
        {
            return this.LogMessageAsync(MessageType.Warning, string.Empty, Body);
        }
 
        public virtual Task LogWarningAsync(string EventId, string Body)
        {
            return this.LogMessageAsync(MessageType.Warning, EventId, Body);
        }
 
        public virtual Task LogInformationAsync(string Body)
        {
            return this.LogMessageAsync(MessageType.Information, string.Empty, Body);
        }
 
        public virtual Task LogInformationAsync(string EventId, string Body)
        {
            return this.LogMessageAsync(MessageType.Information, EventId, Body);
        }
 
        public virtual Task LogMessageAsync(MessageType Type, string Body)
        {
            return this.LogMessageAsync(Type, string.Empty, Body);
        }
 
        public virtual async Task LogMessageAsync(MessageType Type, string EventId, string Body)
        {
            if (this.objectId == Guid.Empty)
                return;
 
            bool Updated = false;
 
            foreach (MeteringMessage Message in await Database.Find<MeteringMessage>(new FilterAnd(
                new FilterFieldEqualTo("NodeId", this.objectId),
                new FilterFieldEqualTo("Type", Type),
                new FilterFieldEqualTo("EventId", EventId),
                new FilterFieldEqualTo("Body", Body))))
            {
                Message.Updated = DateTime.Now;
                Message.Count++;
 
                await Database.Update(Message);
                Updated = true;
 
                break;
            }
 
            if (!Updated)
            {
                MeteringMessage Msg = new MeteringMessage(this.objectId, DateTime.Now, Type, EventId, Body)
                {
                    NodeId = this.objectId
                };
 
                await Database.InsertLazy(Msg);
            }
 
            switch (Type)
            {
                case MessageType.Error:
                    if (this.state < NodeState.ErrorUnsigned)
                    {
                        this.state = NodeState.ErrorUnsigned;
                        await Database.Update(this);
                        await this.RaiseUpdate();
                    }
                    break;
 
                case MessageType.Warning:
                    if (this.state < NodeState.WarningUnsigned)
                    {
                        this.state = NodeState.WarningUnsigned;
                        await Database.Update(this);
                        await this.RaiseUpdate();
                    }
                    break;
 
                case MessageType.Information:
                    if (this.state < NodeState.Information)
                    {
                        this.state = NodeState.Information;
                        await Database.Update(this);
                        await this.RaiseUpdate();
                    }
                    break;
            }
 
            switch (Type)
            {
                case MessageType.Information:
                    Log.Informational(Body, this.nodeId, string.Empty, EventId, EventLevel.Minor);
                    break;
 
                case MessageType.Warning:
                    Log.Warning(Body, this.nodeId, string.Empty, EventId, EventLevel.Minor);
                    break;
 
                case MessageType.Error:
                    Log.Error(Body, this.nodeId, string.Empty, EventId, EventLevel.Minor);
                    break;
            }
 
            await this.NodeStateChanged();
        }
 
        internal async Task NodeStateChanged()
        {
            await MeteringTopology.NewEvent(new NodeStatusChanged()
            {
                Messages = await this.GetMessageArrayAsync(RequestOrigin.Empty),
                State = this.state,
                NodeId = this.NodeId,
                Partition = this.Partition,
                SourceId = this.SourceId,
                Timestamp = DateTime.Now
            });
        }
 
        public virtual Task<bool> RemoveErrorAsync()
        {
            return this.RemoveMessageAsync(MessageType.Error, string.Empty);
        }
 
        public virtual Task<bool> RemoveErrorAsync(string EventId)
        {
            return this.RemoveMessageAsync(MessageType.Error, EventId);
        }
 
        public virtual Task<bool> RemoveWarningAsync()
        {
            return this.RemoveMessageAsync(MessageType.Warning, string.Empty);
        }
 
        public virtual Task<bool> RemoveWarningAsync(string EventId)
        {
            return this.RemoveMessageAsync(MessageType.Warning, EventId);
        }
 
        public virtual Task<bool> RemoveInformationAsync()
        {
            return this.RemoveMessageAsync(MessageType.Information, string.Empty);
        }
 
        public virtual Task<bool> RemoveInformationAsync(string EventId)
        {
            return this.RemoveMessageAsync(MessageType.Information, EventId);
        }
 
        public virtual Task<bool> RemoveMessageAsync(MessageType Type)
        {
            return this.RemoveMessageAsync(Type, string.Empty);
        }
 
        public virtual async Task<bool> RemoveMessageAsync(MessageType Type, string EventId)
        {
            if (this.objectId == Guid.Empty)
                return false;
 
            bool Removed = false;
 
            foreach (MeteringMessage Message in await Database.FindDelete<MeteringMessage>(new FilterAnd(
                new FilterFieldEqualTo("NodeId", this.objectId),
                new FilterFieldEqualTo("Type", Type),
                new FilterFieldEqualTo("EventId", EventId))))
            {
                Removed = true;
 
                switch (Type)
                {
                    case MessageType.Error:
                        Log.Informational("Error removed: " + Message.Body, this.nodeId, string.Empty, string.Empty, EventLevel.Minor);
                        break;
 
                    case MessageType.Warning:
                        Log.Informational("Warning removed: " + Message.Body, this.nodeId, string.Empty, string.Empty, EventLevel.Minor);
                        break;
                }
            }
 
            if (Removed)
            {
                bool ErrorsFound = false;
                bool WarningsFound = false;
                bool InformationFound = false;
 
                foreach (MeteringMessage Message in await Database.Find<MeteringMessage>(new FilterFieldEqualTo("NodeId", this.objectId)))
                {
                    switch (Type)
                    {
                        case MessageType.Error:
                            ErrorsFound = true;
                            break;
 
                        case MessageType.Warning:
                            WarningsFound = true;
                            break;
 
                        case MessageType.Information:
                            InformationFound = true;
                            break;
                    }
                }
 
                NodeState NewStateSigned;
                NodeState NewStateUnsigned;
 
                if (ErrorsFound)
                {
                    NewStateSigned = NodeState.ErrorSigned;
                    NewStateUnsigned = NodeState.ErrorUnsigned;
                }
                else if (WarningsFound)
                {
                    NewStateSigned = NodeState.WarningSigned;
                    NewStateUnsigned = NodeState.WarningUnsigned;
                }
                else if (InformationFound)
                {
                    NewStateSigned = NodeState.Information;
                    NewStateUnsigned = NodeState.Information;
                }
                else 
                {
                    NewStateSigned = NodeState.None;
                    NewStateUnsigned = NodeState.None;
                }
 
                switch (this.state)
                {
                    case NodeState.ErrorSigned:
                    case NodeState.WarningSigned:
                        if (this.state != NewStateSigned)
                        {
                            this.state = NewStateSigned;
                            await Database.Update(this);
                            await this.RaiseUpdate();
                        }
                        break;
 
                    default:
                        if (this.state != NewStateUnsigned)
                        {
                            this.state = NewStateUnsigned;
                            await Database.Update(this);
                            await this.RaiseUpdate();
                        }
                        break;
                }
 
                await this.NodeStateChanged();
            }
 
            return Removed;
        }
 
        public event EventHandlerAsync OnUpdate = null;
 
        internal Task RaiseUpdate()
        {
            return this.OnUpdate.Raise(this, EventArgs.Empty);
        }
 
        public static async Task<string> GetUniqueNodeId(string NodeId)
        {
            string Suffix = string.Empty;
            int i = 1;
            bool Found;
 
            while (true)
            {
                Found = false;
 
                foreach (MeteringNode Node in await Database.Find<MeteringNode>(0, 1, new FilterFieldEqualTo("NodeId", NodeId + Suffix)))
                {
                    Found = true;
                    break;
                }
 
                if (!Found)
                    return NodeId + Suffix;
 
                i++;
                Suffix = " (" + i.ToString() + ")";
            }
        }
 
        #region INode
 
        [IgnoreMember]
        public virtual string LocalId => this.NodeId;
 
        [IgnoreMember]
        public virtual string LogId => this.NodeId;
 
        public abstract Task<string> GetTypeNameAsync(Language Language);
 
        [IgnoreMember]
        public bool HasChildren
        {
            get
            {
                if (!this.childrenLoaded)
                    this.LoadChildren().Wait();
 
                return !(this.children is null) && this.children.Count > 0;
            }
        }
 
        public virtual bool ChildrenOrdered => false;
 
        [IgnoreMember]
        public virtual bool IsReadable => this is ISensor;
 
        [IgnoreMember]
        public virtual bool IsControllable => this is IActuator;
 
        [IgnoreMember]
        public virtual bool HasCommands => true;
 
        [IgnoreMember]
        [Obsolete("Use the asynchronous GetParent() method instead.")]
        public INode Parent => this.GetParent().Result;
 
        public async Task<INode> GetParent()
        {
            if (!(this.parent is null))
                return this.parent;
 
            if (this.parentId == Guid.Empty)
                return null;
 
            this.parent = await this.LoadParent();
            if (this.parent is null)
                throw new Exception("Parent not found.");
 
            return this.parent;
        }
 
        public async Task<T> GetAncestor<T>()
            where T : INode
        {
            INode Loop = await this.GetParent();
 
            while (!(Loop is null))
            {
                if (Loop is T Ancestor)
                    return Ancestor;
                else if (Loop is MeteringNode MeteringNode)
                    Loop = await MeteringNode.GetParent();
                else
                    Loop = Loop.Parent;
            }
 
            return default;
        }
 
        [IgnoreMember]
        public DateTime LastChanged
        {
            get
            {
                if (this.updated == DateTime.MinValue)
                    return this.created;
                else
                    return this.updated;
            }
        }
 
        [DefaultValue(NodeState.None)]
        public NodeState State
        {
            get => this.state;
            set => this.state = value;
        }
 
        [IgnoreMember]
        public Task<IEnumerable<INode>> ChildNodes
        {
            get
            {
                return this.GetChildNodes();
            }
        }
 
        private async Task<IEnumerable<INode>> GetChildNodes()
        {
            if (!this.childrenLoaded)
                await this.LoadChildren();
 
            lock (this.synchObject)
            {
                if (this.children is null)
                    return new INode[0];
                else
                    return this.children.ToArray();
            }
        }
 
        private async Task LoadChildren()
        {
            IEnumerable<MeteringNode> Children = await Database.Find<MeteringNode>(new FilterFieldEqualTo("ParentId", this.objectId));
            LinkedList<MeteringNode> Children2 = new LinkedList<MeteringNode>();
 
            foreach (MeteringNode Node in Children)
                Children2.AddLast(MeteringTopology.RegisterNode(Node));
 
            lock (this.synchObject)
            {
                this.children = null;
 
                foreach (MeteringNode Child in Children2)
                {
                    if (this.children is null)
                        this.children = new List<MeteringNode>();
 
                    this.children.Add(Child);
                    Child.parent = this;
                }
 
                this.SortChildrenAfterLoadLocked(this.children);
                this.childrenLoaded = true;
            }
        }
 
        protected virtual void SortChildrenAfterLoadLocked(List<MeteringNode> Children)
        {
            // Do nothing by default.
        }
 
        internal async Task<MeteringNode> LoadParent()
        {
            if (!(this.parent is null))
                return this.parent;
 
            if (this.parentId == Guid.Empty)
                return null;
 
            this.parent = await Database.LoadObject<MeteringNode>(this.parentId);
            MeteringTopology.RegisterNode(this.parent);
 
            return this.parent;
        }
 
        public virtual Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);     // TODO: Check user privileges
        }
 
        public virtual Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);     // TODO: Check user privileges
        }
 
        public virtual Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);     // TODO: Check user privileges
        }
 
        public virtual Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);     // TODO: Check user privileges
        }
 
        public virtual async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            Namespace Namespace = await Language.GetNamespaceAsync(typeof(MeteringNode).Namespace)
                ?? await Language.CreateNamespaceAsync(typeof(MeteringNode).Namespace);
 
            LinkedList<Parameter> Result = new LinkedList<Parameter>();
            string s;
 
            Result.AddLast(new StringParameter("NodeId", await Namespace.GetStringAsync(1, "Node ID"), this.nodeId));
            Result.AddLast(new StringParameter("Type", await Namespace.GetStringAsync(4, "Type"), await this.GetTypeNameAsync(Language)));
 
            if (!(this.parent is null))
                Result.AddLast(new StringParameter("ParentId", await Namespace.GetStringAsync(2, "Parent ID"), this.parent.nodeId));
 
            if (!this.childrenLoaded)
                await this.LoadChildren();
 
            if (!(this.children is null))
            {
                int i;
 
                lock (this.synchObject)
                {
                    i = this.children.Count;
                }
 
                Result.AddLast(new Int32Parameter("NrChildren", await Namespace.GetStringAsync(3, "#Children"), i));
            }
 
            switch (this.state)
            {
                case NodeState.Information:
                    s = await Namespace.GetStringAsync(8, "Information");
                    break;
 
                case NodeState.WarningUnsigned:
                    s = await Namespace.GetStringAsync(9, "Unsigned Warning");
                    break;
 
                case NodeState.WarningSigned:
                    s = await Namespace.GetStringAsync(10, "Warning");
                    break;
 
                case NodeState.ErrorUnsigned:
                    s = await Namespace.GetStringAsync(11, "Unsigned Error");
                    break;
 
                case NodeState.ErrorSigned:
                    s = await Namespace.GetStringAsync(12, "Error");
                    break;
 
                case NodeState.None:
                default:
                    s = null;
                    break;
            }
 
            if (!string.IsNullOrEmpty(s))
                Result.AddLast(new StringParameter("State", await Namespace.GetStringAsync(5, "State"), s));
 
            Result.AddLast(new DateTimeParameter("Created", await Namespace.GetStringAsync(6, "Created"), this.created));
 
            if (this.updated != DateTime.MinValue)
                Result.AddLast(new DateTimeParameter("Updated", await Namespace.GetStringAsync(7, "Updated"), this.updated));
 
            return Result;
        }
 
        public async Task<Parameter[]> GetDisplayableParameterAraryAsync(Language Language, RequestOrigin Caller)
        {
            List<Parameter> Result = new List<Parameter>();
 
            foreach (Parameter P in await this.GetDisplayableParametersAsync(Language, Caller))
                Result.Add(P);
 
            return Result.ToArray();
        }
 
        public virtual async Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            IEnumerable<MeteringMessage> Messages = await Database.Find<MeteringMessage>(
                new FilterFieldEqualTo("NodeId", this.objectId), "Created");
            LinkedList<Message> Result = new LinkedList<Message>();
 
            foreach (MeteringMessage Msg in Messages)
                Result.AddLast(new Message(Msg.Created, Msg.Type, Msg.EventId, Msg.Body));  // TODO: Include Updated & Count also.
 
            return Result;
        }
 
        public async Task<Message[]> GetMessageArrayAsync(RequestOrigin Caller)
        {
            List<Message> Result = new List<Message>();
 
            foreach (Message Msg in await this.GetMessagesAsync(Caller))
                Result.Add(Msg);
 
            return Result.ToArray();
        }
 
        public virtual async Task<bool> MoveUpAsync(RequestOrigin Caller)
        {
            if (!(await this.GetParent() is MeteringNode Parent))
                return false;
            else
                return await Parent.MoveUpAsync(this, Caller);
        }
 
        public virtual async Task<bool> MoveDownAsync(RequestOrigin Caller)
        {
            if (!(await this.GetParent() is MeteringNode Parent))
                return false;
            else
                return await Parent.MoveDownAsync(this, Caller);
        }
 
        public virtual async Task<bool> MoveUpAsync(MeteringNode Child, RequestOrigin Caller)
        {
            if (!this.ChildrenOrdered || this.children is null)
                return false;
 
            if (!await this.CanEditAsync(Caller) || !await Child.CanEditAsync(Caller))
                return false;
 
            lock (this.children)
            {
                int i = this.children.IndexOf(Child);
                if (i <= 0)
                    return false;
 
                this.children.RemoveAt(i);
                this.children.Insert(i - 1, Child);
            }
 
            await MeteringTopology.NewEvent(new NodeMovedUp()
            {
                NodeId = Child.NodeId,
                Partition = Child.Partition,
                SourceId = Child.SourceId,
                Timestamp = DateTime.Now
            });
 
            return true;
        }
 
        public virtual async Task<bool> MoveDownAsync(MeteringNode Child, RequestOrigin Caller)
        {
            if (!this.ChildrenOrdered || this.children is null)
                return false;
 
            if (!await this.CanEditAsync(Caller) || !await Child.CanEditAsync(Caller))
                return false;
 
            lock (this.children)
            {
                int c = this.children.Count;
                int i = this.children.IndexOf(Child);
                if (i < 0 || i + 1 >= c)
                    return false;
 
                this.children.RemoveAt(i);
                this.children.Insert(i + 1, Child);
            }
 
            await MeteringTopology.NewEvent(new NodeMovedDown()
            {
                NodeId = Child.NodeId,
                Partition = Child.Partition,
                SourceId = Child.SourceId,
                Timestamp = DateTime.Now
            });
 
            return true;
        }
 
        public abstract Task<bool> AcceptsParentAsync(INode Parent);
 
        public abstract Task<bool> AcceptsChildAsync(INode Child);
 
        public virtual async Task AddAsync(INode Child)
        {
            if (!(Child is MeteringNode Node))
                throw new Exception("Child must be a metering node.");
 
            if (this.objectId == Guid.Empty)
                throw new Exception("Parent node must be persisted before you can add nodes to it.");
 
            if (!this.childrenLoaded)
                await this.LoadChildren();
 
            Node.parentId = this.objectId;
 
            MeteringNode After = null;
            int c;
 
            lock (this.synchObject)
            {
                if (this.children is null)
                    this.children = new List<MeteringNode>();
                else if ((c = this.children.Count) > 0)
                    After = this.children[c - 1];
 
                this.children.Add(Node);
                Node.parent = this;
            }
 
            if (Node.objectId == Guid.Empty)
            {
                await Database.Insert(Node);
                MeteringTopology.RegisterNode(Node);
 
                Language Language = await Translator.GetDefaultLanguageAsync();
                NodeAdded Event = new NodeAdded()
                {
                    Parameters = await Node.GetDisplayableParameterAraryAsync(Language, RequestOrigin.Empty),
                    NodeType = Node.GetType().FullName,
                    Sniffable = Node is ICommunicationLayer,
                    DisplayName = await Node.GetTypeNameAsync(Language),
                    HasChildren = Node.HasChildren,
                    ChildrenOrdered = Node.ChildrenOrdered,
                    IsReadable = Node.IsReadable,
                    IsControllable = Node.IsControllable,
                    HasCommands = Node.HasCommands,
                    ParentId = this.NodeId,
                    ParentPartition = this.Partition,
                    Updated = Node.Updated,
                    State = Node.State,
                    NodeId = Node.NodeId,
                    Partition = Node.Partition,
                    LogId = NodeAdded.EmptyIfSame(Node.LogId, Node.NodeId),
                    LocalId = NodeAdded.EmptyIfSame(Node.LocalId, Node.NodeId),
                    SourceId = Node.SourceId,
                    Timestamp = DateTime.Now
                };
 
                if (this.ChildrenOrdered && !(After is null))
                {
                    Event.AfterNodeId = After.nodeId;
                    Event.AfterPartition = After.Partition;
                }
 
                await MeteringTopology.NewEvent(Event);
            }
            else
                await Node.NodeUpdated();
 
            await this.RaiseUpdate();
        }
 
        protected virtual async Task NodeUpdated()
        {
            this.updated = DateTime.Now;
            await Database.Update(this);
 
            await MeteringTopology.NewEvent(new NodeUpdated()
            {
                Parameters = await this.GetDisplayableParameterAraryAsync(await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty),
                HasChildren = this.HasChildren,
                ChildrenOrdered = this.ChildrenOrdered,
                IsReadable = this.IsReadable,
                IsControllable = this.IsControllable,
                HasCommands = this.HasCommands,
                ParentId = this.NodeId,
                ParentPartition = this.Partition,
                Updated = this.Updated,
                State = this.State,
                NodeId = this.NodeId,
                OldId = this.oldId,
                Partition = this.Partition,
                LogId = NodeAdded.EmptyIfSame(this.LogId, this.NodeId),
                LocalId = NodeAdded.EmptyIfSame(this.LocalId, this.NodeId),
                SourceId = this.SourceId,
                Timestamp = DateTime.Now
            });
 
            if (this.oldId != this.nodeId)
            {
                MeteringTopology.RegisterNewNodeId(this, this.oldId);
                this.oldId = this.nodeId;
            }
        }
 
        public virtual async Task UpdateAsync()
        {
            if (this.objectId != Guid.Empty)
                await this.NodeUpdated();
 
            await this.RaiseUpdate();
        }
 
        public virtual async Task<bool> RemoveAsync(INode Child)
        {
            if (!(Child is MeteringNode Node))
                throw new Exception("Child must be a metering node.");
 
            if (!this.childrenLoaded)
                await this.LoadChildren();
 
            int i;
 
            lock (this.synchObject)
            {
                if (!(this.children is null))
                {
                    i = this.children.IndexOf(Node);
                    if (i >= 0)
                    {
                        this.children.RemoveAt(i);
                        if (i == 0 && this.children.Count == 0)
                            this.children = null;
                    }
                }
                else
                    i = -1;
            }
 
            Node.parentId = Guid.Empty;
            Node.parent = null;
 
            if (Node.objectId != Guid.Empty)
            {
                await Database.Update(Child);
                await this.RaiseUpdate();
 
                await MeteringTopology.NewEvent(new NodeRemoved()
                {
                    NodeId = Node.NodeId,
                    Partition = Node.Partition,
                    SourceId = Node.SourceId,
                    Timestamp = DateTime.Now
                });
            }
 
            return i >= 0;
        }
 
        public async virtual Task DestroyAsync()
        {
            if (!(await this.GetParent() is null))
            {
                if (this.parent.childrenLoaded)
                {
                    lock (this.parent.synchObject)
                    {
                        if (!(this.parent.children is null))
                        {
                            this.parent.children.Remove(this);
                            if (this.parent.children.Count == 0)
                                this.parent.children = null;
                        }
                    }
                }
            }
 
            if (!this.childrenLoaded)
                await this.LoadChildren();
 
            if (!(this.children is null))
            {
                foreach (MeteringNode Child in this.children)
                {
                    Child.parent = null;
                    Child.parentId = Guid.Empty;
 
                    await Child.DestroyAsync();
                }
 
                this.children = null;
            }
 
            if (this.objectId != Guid.Empty)
            {
                await Database.Delete(this);
                this.objectId = Guid.Empty;
            }
 
            MeteringTopology.UnregisterNode(this);
        }
 
        [IgnoreMember]
        public virtual Task<IEnumerable<ICommand>> Commands
        {
            get
            {
                return Task.FromResult<IEnumerable<ICommand>>(new ICommand[]
                {
                    new ClearMessages(this),
                    new LogMessage(this)
                });
            }
        }
 
        public static async Task<IEnumerable<ICommand>> Join(Task<IEnumerable<ICommand>> Commands, params ICommand[] Commands2)
        {
            IEnumerable<ICommand> Commands1 = await Commands;
 
            if (Commands1 is null)
                return Commands2;
 
            if (!(Commands1 is List<ICommand> Result))
            {
                Result = new List<ICommand>();
 
                foreach (ICommand Cmd in Commands1)
                    Result.Add(Cmd);
            }
 
            Result.AddRange(Commands2);
 
            return Result;
        }
 
        #endregion
 
        #region ILifeCycleManagement
 
        public virtual bool IsProvisioned => false;
 
        public virtual string Owner => string.Empty;
 
        public virtual bool IsPublic => false;
 
        public virtual Task<KeyValuePair<string, object>[]> GetMetaData()
        {
            return Task.FromResult<KeyValuePair<string, object>[]>(new KeyValuePair<string, object>[0]);
        }
 
        public virtual Task Claimed(string Owner, bool IsPublic)
        {
            throw new NotSupportedException();
        }
 
        public virtual Task Disowned()
        {
            throw new NotSupportedException();
        }
 
        public virtual Task Removed()
        {
            throw new NotSupportedException();
        }
 
        #endregion
 
        #region Momentary values
 
        public void NewMomentaryValues(params Field[] Values)
        {
            MeteringTopology.NewMomentaryValues(this, Values);
        }
 
        public void NewMomentaryValues(IEnumerable<Field> Values)
        {
            MeteringTopology.NewMomentaryValues(this, Values);
        }
 
        #endregion
 
    }
}