ActionReference.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Profiling;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
using Waher.Service.IoTBroker.StateMachines.Model.Attributes;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions
{
    public abstract class ActionReference : StateMachineNode
    {
        private ScriptableStringAttribute actionRef;
        private ExpressionAttribute beforeActionScript;
 
        public ActionReference()
            : base()
        {
        }
 
        [DefaultValueNull]
        public string ActionReferenceDefinition
        {
            get => this.actionRef?.Definition;
            set => this.actionRef = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string BeforeActionScript
        {
            get => this.beforeActionScript?.Expression;
            set => this.beforeActionScript = new ExpressionAttribute(value, false, this);
        }
 
        public bool HasActionReference => !(this.actionRef?.IsEmpty ?? true);
 
        public bool HasConstantActionReference => this.actionRef?.IsConstant ?? false;
 
        public bool HasExpressionActionReference => this.actionRef?.IsExpression ?? false;
 
        public override Task Parse(XmlElement Xml)
        {
            this.actionRef = new ScriptableStringAttribute(XML.Attribute(Xml, "actionRef"), this);
            this.beforeActionScript = new ExpressionAttribute(XML.Attribute(Xml, "beforeActionScript"), false, this);
 
            return base.Parse(Xml);
        }
 
        public override void CheckReferences(StateMachine Machine, Token Token)
        {
            if (this.actionRef.IsConstant && !this.actionRef.IsEmpty && !Machine.TryGetAction(this.actionRef.Definition, out _))
                throw new StateMachineException(Machine, "Action not found: " + this.actionRef.Definition);
 
            base.CheckReferences(Machine, Token);
        }
 
        public Task<string> GetReference(EvaluationArguments Arguments)
        {
            return this.actionRef?.Evaluate(Arguments.Variables) ?? Task.FromResult<string>(null);
        }
 
        public async Task<TimeSpan> ExecuteLog(EvaluationArguments Arguments, bool SuppressSample)
        {
            string ActionId = await this.GetReference(Arguments);
            if (string.IsNullOrEmpty(ActionId))
                return TimeSpan.Zero;
 
            DateTime Start = DateTime.UtcNow;
            await this.ExecuteNoLog(ActionId, Arguments, SuppressSample);
            TimeSpan Elapsed = DateTime.UtcNow.Subtract(Start);
 
            if (SuppressSample)
                return Elapsed;
 
            await Database.Insert(new StateMachineSample()
            {
                Variable = "<" + ActionId + ">",
                Timestamp = Start,
                Value = Elapsed,
                StateMachineId = Arguments.Machine.StateMachineId,
                Expires = Arguments.Machine.Expires,
                ArchiveOptional = Arguments.Machine.ArchiveOptional,
                ArchiveRequired = Arguments.Machine.ArchiveRequired
            });
 
            return Elapsed;
        }
 
        public async Task ExecuteNoLog(EvaluationArguments Arguments, bool SuppressProfiling)
        {
            string ActionId = await this.GetReference(Arguments);
            await this.ExecuteNoLog(ActionId, Arguments, SuppressProfiling);
        }
 
        public async Task ExecuteNoLog(string ActionId, EvaluationArguments Arguments, bool SuppressProfiling)
        {
            if (!string.IsNullOrEmpty(ActionId))
            {
                if (!Arguments.Machine.TryGetAction(ActionId, out Action Action))
                    throw new StateMachineException(Arguments.Machine, "Action not found: " + ActionId);
 
                ProfilerThread Thread = SuppressProfiling ? null : Arguments.Profiler?.GetThread(ActionId, ProfilerThreadType.Binary);
                Thread?.High();
 
                try
                {
                    if (this.beforeActionScript?.HasExpreession ?? false)
                        await this.beforeActionScript.Evaluate(Arguments.Variables);
 
                    await Action.Execute(Arguments);
                }
                finally
                {
                    Thread?.Low();
                }
            }
        }
    }
}