ContractEventNode.cs

using System;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.StateMachines.EventHandlers;
using Waher.Service.IoTBroker.StateMachines.Model.Attributes;
using Waher.Service.IoTBroker.StateMachines.Model.States;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Events
{
    public abstract class ContractEventNode : EventNode
    {
        private ScriptableStringAttribute contractIdVariable;
        private ScriptableStringAttribute contractXmlVariable;
        private ScriptableStringAttribute parametersVariable;
        private ScriptableStringAttribute rolesVariable;
        private ScriptableStringAttribute machineReadableVariable;
        private ScriptableStringAttribute localName;
        private ScriptableStringAttribute @namespace;
        private ScriptableEnumAttribute<SecondaryNameType> nameType;
        private ExpressionAttribute condition;
 
        public ContractEventNode()
            : base()
        {
        }
 
        [DefaultValueNull]
        public string ContractIdVariableDefinition
        {
            get => this.contractIdVariable?.Definition;
            set => this.contractIdVariable = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string ContractXmlVariableDefinition
        {
            get => this.contractXmlVariable?.Definition;
            set => this.contractXmlVariable = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string ParametersVariableDefinition
        {
            get => this.parametersVariable?.Definition;
            set => this.parametersVariable = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string RolesVariableDefinition
        {
            get => this.rolesVariable?.Definition;
            set => this.rolesVariable = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string MachineReadableVariableDefinition
        {
            get => this.machineReadableVariable?.Definition;
            set => this.machineReadableVariable = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string Condition
        {
            get => this.condition?.Expression;
            set => this.condition = new ExpressionAttribute(value, false, this);
        }
 
        [DefaultValueNull]
        public string LocalNameDefinition
        {
            get => this.localName?.Definition;
            set => this.localName = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string NamespaceDefinition
        {
            get => this.@namespace?.Definition;
            set => this.@namespace = new ScriptableStringAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string NameTypeDefinition
        {
            get => this.nameType?.Definition;
            set => this.nameType = new ScriptableEnumAttribute<SecondaryNameType>(value, this);
        }
 
        public override Task Parse(XmlElement Xml)
        {
            this.contractIdVariable = new ScriptableStringAttribute(XML.Attribute(Xml, "contractIdVariable"), this);
            this.contractXmlVariable = new ScriptableStringAttribute(XML.Attribute(Xml, "contractXmlVariable"), this);
            this.parametersVariable = new ScriptableStringAttribute(XML.Attribute(Xml, "parametersVariable"), this);
            this.rolesVariable = new ScriptableStringAttribute(XML.Attribute(Xml, "rolesVariable"), this);
            this.machineReadableVariable = new ScriptableStringAttribute(XML.Attribute(Xml, "machineReadableVariable"), this);
            this.condition = new ExpressionAttribute(XML.Attribute(Xml, "condition"), true, this);
            this.localName = new ScriptableStringAttribute(XML.Attribute(Xml, "localName"), this);
            this.@namespace = new ScriptableStringAttribute(XML.Attribute(Xml, "namespace"), this);
            this.nameType = new ScriptableEnumAttribute<SecondaryNameType>(XML.Attribute(Xml, "nameType"), this);
 
            return base.Parse(Xml);
        }
 
        public override Task<EventHandlerReference> Register(int EventIndex, EvaluationArguments Arguments, OnEvent Event)
        {
            return this.Register(EventIndex, Arguments, null, null);
        }
 
        protected async Task<EventHandlerReference> Register(int EventIndex, EvaluationArguments Arguments, 
            string LegalIdVariable, string RoleVariable)
        {
            string ContractIdVariable = await this.contractIdVariable.Evaluate(Arguments.Variables);
            string ContractXmlVariable = await this.contractXmlVariable.Evaluate(Arguments.Variables);
            string ParametersVariable = await this.parametersVariable.Evaluate(Arguments.Variables);
            string RolesVariable = await this.rolesVariable.Evaluate(Arguments.Variables);
            string MachineReadableVariable = await this.machineReadableVariable.Evaluate(Arguments.Variables);
            string LocalName = await this.localName.Evaluate(Arguments.Variables);
            string Namespace = await this.@namespace.Evaluate(Arguments.Variables);
            SecondaryNameType NameType = this.nameType.IsEmpty ? SecondaryNameType.None : await this.nameType.Evaluate(Arguments.Variables);
 
            ContractEventHandler Handler = new ContractEventHandler(Arguments, EventIndex, 
                this, ContractIdVariable, ContractXmlVariable, ParametersVariable, 
                RolesVariable, MachineReadableVariable, LegalIdVariable, RoleVariable, 
                LocalName, Namespace, NameType);
 
            await Database.Insert(Handler);
            await Handler.AddToCache();
 
            return new EventHandlerReference(Handler);
        }
 
        public async Task<bool> EvaluateCondition(EvaluationArguments Arguments)
        {
            if (this.condition is null)
                return true;
 
            try
            {
                object Obj = await this.condition.Evaluate(Arguments.Variables);
 
                if (Obj is bool b)
                    return b;
                else
                    return false;
            }
            catch (Exception)
            {
                return false;
            }
        }
 
        public override string Label
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append(this.GetType().Name);
                sb.Append('(');
                sb.Append(this.localName.Definition);
                sb.Append(')');
 
                return sb.ToString();
            }
        }
 
        public override async Task<bool> Applies(EvaluationArguments Arguments)
        {
            if (!(this.condition?.HasExpreession ?? false))
                return true;
 
            return await this.EvaluateCondition(Arguments);
        }
    }
}