OnEvent.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence.Attributes;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines.EventHandlers;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
using Waher.Service.IoTBroker.StateMachines.Model.Actions;
using Waher.Service.IoTBroker.StateMachines.Model.Attributes;
using Waher.Service.IoTBroker.StateMachines.Model.Events;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.States
{
    public class OnEvent : ActionReference
    {
        private ScriptableStringAttribute newState;
        private ScriptableStringAttribute failureState;
        private ScriptableBooleanAttribute suppressSample;
        private EventNode @event;
 
        public OnEvent()
            : base()
        {
        }
 
        [DefaultValueNull]
        public string NewStateDefinition
        {
            get => this.newState?.Definition;
            set => this.newState = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string FailureStateDefinition
        {
            get => this.failureState?.Definition;
            set => this.failureState = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string SuppressSampleDefinition
        {
            get => this.suppressSample?.Definition;
            set => this.suppressSample = new ScriptableBooleanAttribute(value, this);
        }
 
        public EventNode Event => this.@event;
 
        public override string LocalName => nameof(OnEvent);
 
        public override IStateMachineNode Create()
        {
            return new OnEvent();
        }
 
        public override Task Parse(XmlElement Xml)
        {
            this.newState = new ScriptableStringAttribute(XML.Attribute(Xml, "newState"), this);
            this.failureState = new ScriptableStringAttribute(XML.Attribute(Xml, "failureState"), this);
            this.suppressSample = new ScriptableBooleanAttribute(XML.Attribute(Xml, "suppressSample"), this);
 
            return base.Parse(Xml);
        }
 
        protected override void OnChildNodesUpdated()
        {
            base.OnChildNodesUpdated();
 
            this.@event = this.GetChildElement<EventNode>(true);
        }
 
        public override void CheckReferences(StateMachine Machine, Token Token)
        {
            if (this.newState.IsConstant && !this.newState.IsEmpty && !Machine.TryGetState(this.newState.Definition, out _))
                throw new StateMachineException(Machine, "State not found: " + this.newState.Definition);
 
            if (this.failureState.IsConstant && !this.failureState.IsEmpty && !Machine.TryGetState(this.failureState.Definition, out _))
                throw new StateMachineException(Machine, "State not found: " + this.failureState.Definition);
 
            base.CheckReferences(Machine, Token);
        }
 
        public async Task<string> GetNewState(EvaluationArguments Arguments)
        {
            if (this.newState?.IsEmpty ?? true)
                return null;
 
            return await this.newState.Evaluate(Arguments.Variables);
        }
 
        public async Task<string> GetFailureState(EvaluationArguments Arguments)
        {
            if (this.failureState?.IsEmpty ?? true)
                return null;
 
            return await this.failureState.Evaluate(Arguments.Variables);
        }
 
        public async Task<bool> GetSuppressSample(EvaluationArguments Arguments)
        {
            if (this.suppressSample?.IsEmpty ?? true)
                return false;
 
            return await this.suppressSample.Evaluate(Arguments.Variables);
        }
 
        public bool HasNewState => !(this.newState is null) && !this.newState.IsEmpty;
 
        public bool HasNewStateConstant => this.newState?.IsConstant ?? false;
 
        public bool HasNewStateExpression => this.newState?.IsExpression ?? false;
 
        public bool HasFailureState => !(this.failureState is null) && !this.failureState.IsEmpty;
 
        public bool HasFailureStateConstant => this.failureState?.IsConstant ?? false;
 
        public bool HasFailureStateExpression => this.failureState?.IsExpression ?? false;
 
        public async Task<EventHandlerReference> Register(int EventIndex, EvaluationArguments Arguments)
        {
            if (this.@event is null)
                return null;
 
            return await this.@event.Register(EventIndex, Arguments, this);
        }
 
        public Task Unregister(int EventIndex, EvaluationArguments Arguments)
        {
            return this.@event?.Unregister(EventIndex, Arguments) ?? Task.CompletedTask;
        }
 
        public async Task<EventHandlerReference> StateUpdated(EvaluationArguments Arguments)
        {
            if (this.@event is null)
                return null;
 
            return await this.@event.StateUpdated(Arguments);
        }
 
        public virtual Task<bool> Applies(EvaluationArguments Arguments)
        {
            if (this.@event is null)
                return Task.FromResult(true);
            else
                return this.@event.Applies(Arguments);
        }
    }
}