ScriptReferenceNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Language;
using Waher.Script;
using Waher.Things.Attributes;
using Waher.Things.Metering;
using Waher.Things.Metering.NodeTypes;
using Waher.Things.Virtual;
 
namespace Waher.Things.Script
{
    public class ScriptReferenceNode : VirtualNode, ISensor
    {
        public ScriptReferenceNode()
            : base()
        {
        }
 
        [Page(2, "Script", 100)]
        [Header(6, "Script Node:")]
        [ToolTip(7, "ID of template node that defines how the node operates.")]
        [Required]
        public string ScriptNodeId { get; set; }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ScriptNode), 8, "Script Reference Node");
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(
                Child is ScriptNode || 
                Child is ScriptReferenceNode);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(
                Parent is Root || 
                Parent is NodeCollection ||
                Parent is VirtualNode || 
                Parent is ScriptNode || 
                Parent is ScriptReferenceNode);
        }
 
        public override bool IsReadable
        {
            get
            {
                if (this.Disabled)
                    return false;
 
                if (base.IsReadable)
                    return true;
 
                if (string.IsNullOrEmpty(this.ScriptNodeId))
                    return false;
 
                return true;
            }
        }
 
        public override async Task StartReadout(ISensorReadout Request, bool DoneAfter)
        {
            try
            {
                await base.StartReadout(Request, false);
 
                if (string.IsNullOrEmpty(this.ScriptNodeId))
                    throw new Exception("Script Node ID not defined.");
 
                INode Node = await MeteringTopology.GetNode(this.ScriptNodeId)
                    ?? throw new Exception("Node not found: " + this.ScriptNodeId);
 
                if (!(Node is ScriptNode ScriptNode))
                    throw new Exception("Script Node reference does not point to a script node.");
 
                Variables v = new Variables()
                {
                    ["this"] = this
                };
 
                this.PopulateVariables(v);
 
                v.OnPreview += (Sender, e) =>
                {
                    ScriptNode.ReportFields(Request, e.Preview.AssociatedObjectValue, false);
                    return Task.CompletedTask;
                };
 
                object Obj = await ScriptNode.ParsedSensorDataScript.EvaluateAsync(v);
                ScriptNode.ReportFields(Request, Obj, DoneAfter);
 
                await this.RemoveErrorAsync("ScriptError");
            }
            catch (Exception ex)
            {
                await this.LogErrorAsync("ScriptError", ex.Message);
                await Request.ReportErrors(true, new ThingError(this, ex.Message));
            }
        }
 
        public virtual void PopulateVariables(Variables Variables)
        {
            if (!(this.MetaData is null))
            {
                foreach (MetaDataValue Tag in this.MetaData)
                    Variables[Tag.Name] = Tag.Value;
            }
        }
 
        public override Task<IEnumerable<ICommand>> Commands => this.GetCommands();
 
        internal async Task<IEnumerable<ICommand>> GetCommands()
        {
            INode Node = await MeteringTopology.GetNode(this.ScriptNodeId)
                ?? throw new Exception("Node not found: " + this.ScriptNodeId);
            
            List<ICommand> Commands = new List<ICommand>();
            Commands.AddRange(await base.Commands);
 
            if (Node.HasChildren)
            {
                IEnumerable<INode> Children = await Node.ChildNodes;
                if (!(Children is null))
                {
                    foreach (INode Child in Children)
                    {
                        if (Child is ScriptCommandNodeBase CommandNode)
                            Commands.Add(await CommandNode.GetCommand(this));
                    }
                }
            }
 
            return Commands.ToArray();
        }
    }
}