ScriptCommandNodeBase.cs

using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Script;
using Waher.Things.Attributes;
using Waher.Things.Virtual;
 
namespace Waher.Things.Script
{
    public abstract class ScriptCommandNodeBase : VirtualNode
    {
        protected string[] script;
 
        protected Expression parsedScript;
 
        public ScriptCommandNodeBase()
            : base()
        {
        }
 
        [Page(2, "Script", 100)]
        [Header(14, "Command ID:")]
        [ToolTip(15, "ID of command, as referenced by the caller.")]
        [Required]
        public string CommandId { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(20, "Command Name:")]
        [ToolTip(21, "Displayable name of command.")]
        [Required]
        public string CommandName { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(16, "Sort Category:")]
        [ToolTip(17, "Category in which the command will be ordered.")]
        [Required]
        public string SortCategory { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(18, "Sort Key:")]
        [ToolTip(19, "Key used when ordering commands within a sort category.")]
        [Required]
        public string SortKey { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(22, "Confirmation Message:")]
        [ToolTip(23, "Optional confirmation message. If defined, it will be presented to users before executing the command.")]
        public string Confirmation { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(24, "Success Message:")]
        [ToolTip(25, "Optional success message. If defined, it will be presented to users after the successful execution of the command.")]
        public string Success { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(26, "Failure Message:")]
        [ToolTip(27, "Optional failure message. If defined, it will be presented to users after the failed execution of the command.")]
        public string Failure { get; set; }
 
        public override bool ChildrenOrdered => true;
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ScriptParameterNode);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is ScriptNode);
        }
 
        public Expression ParsedScript
        {
            get
            {
                Expression Exp = this.parsedScript;
 
                if (Exp is null)
                {
                    StringBuilder sb = new StringBuilder();
 
                    foreach (string s in this.script)
                        sb.AppendLine(s);
 
                    this.parsedScript = Exp = new Expression(sb.ToString());
                }
 
                return Exp;
            }
        }
 
 
        public async Task<ScriptParameterNode[]> GetParameters(VirtualNode Node)
        {
            List<ScriptParameterNode> Parameters = new List<ScriptParameterNode>();
 
            if (this.HasChildren)
            {
                IEnumerable<INode> Children = await this.ChildNodes;
                if (!(Children is null))
                {
                    foreach (INode Child in Children)
                    {
                        if (Child is ScriptParameterNode ParameterNode)
                            Parameters.Add(ParameterNode);
                    }
                }
            }
 
            return Parameters.ToArray();
        }
 
        public abstract Task<ICommand> GetCommand(VirtualNode Node);
    }
}