NodeAdded.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Things.SourceEvents
{
    public class NodeAdded : NodeParametersEvent
    {
        private string afterNodeId = string.Empty;
        private string afterPartition = string.Empty;
        private string displayName = string.Empty;
        private string nodeType = string.Empty;
        private bool sniffable = false;
 
        public NodeAdded()
            : base()
        {
        }
 
        public static Task<NodeAdded> FromNode(INode Node, Language Language, RequestOrigin Caller, bool Sniffable)
        {
            return FromNode(Node, Language, Caller, Sniffable, null);
        }
 
        public static async Task<NodeAdded> FromNode(INode Node, Language Language, RequestOrigin Caller, bool Sniffable,
            params Parameter[] AdditionalParameters)
        {
            List<Parameter> Parameters = new List<Parameter>();
 
            foreach (Parameter P in await Node.GetDisplayableParametersAsync(Language, Caller))
                Parameters.Add(P);
 
            if (!(AdditionalParameters is null))
            {
                foreach (Parameter P in AdditionalParameters)
                    Parameters.Add(P);
            }
 
            return new NodeAdded()
            {
                Parameters = Parameters.ToArray(),
                NodeType = Node.GetType().FullName,
                Sniffable = Sniffable,
                DisplayName = await Node.GetTypeNameAsync(Language),
                HasChildren = Node.HasChildren,
                ChildrenOrdered = Node.ChildrenOrdered,
                IsReadable = Node.IsReadable,
                IsControllable = Node.IsControllable,
                HasCommands = Node.HasCommands,
                ParentId = Node.Parent?.NodeId ?? string.Empty,
                ParentPartition = Node.Parent?.Partition ?? string.Empty,
                Updated = DateTime.MinValue,
                State = Node.State,
                NodeId = Node.NodeId,
                Partition = Node.Partition,
                LogId = EmptyIfSame(Node.LogId, Node.NodeId),
                LocalId = EmptyIfSame(Node.LocalId, Node.NodeId),
                SourceId = Node.SourceId,
                Timestamp = DateTime.Now
            };
        }
 
        public static string EmptyIfSame(string Id1, string Id2)
        {
            return Id1 == Id2 ? string.Empty : Id1;
        }
 
        [DefaultValueStringEmpty]
        public string AfterNodeId
        {
            get => this.afterNodeId;
            set => this.afterNodeId = value;
        }
 
        [DefaultValueStringEmpty]
        public string AfterPartition
        {
            get => this.afterPartition;
            set => this.afterPartition = value;
        }
 
        [DefaultValueStringEmpty]
        public string DisplayName
        {
            get => this.displayName;
            set => this.displayName = value;
        }
 
        [DefaultValueStringEmpty]
        public string NodeType
        {
            get => this.nodeType;
            set => this.nodeType = value;
        }
 
        [DefaultValue(false)]
        public bool Sniffable
        {
            get => this.sniffable;
            set => this.sniffable = value;
        }
 
        public override SourceEventType EventType
        {
            get { return SourceEventType.NodeAdded; }
        }
    }
}