IfHash.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.HashStore;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
using Waher.Service.IoTBroker.StateMachines.Model.Actions.Runtime;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Conditional
{
    public class IfHash : ActionNode
    {
        private Hash hash;
        private Realm realm;
        private Then then;
        private Else @else;
 
        public IfHash()
            : base()
        {
        }
 
        public Hash Hash => this.hash;
 
        public Realm Realm => this.realm;
 
        public Then Then => this.then;
 
        public Else Else => this.@else;
 
        [DefaultValueNull]
        public string ObjectVariable { get; set; }
 
        public override string LocalName => nameof(IfHash);
 
        public override IStateMachineNode Create()
        {
            return new IfHash();
        }
 
        public override async Task Parse(XmlElement Xml)
        {
            this.ObjectVariable = XML.Attribute(Xml, "objectVariable");
 
            await base.Parse(Xml);
 
            this.ConvertValueAttributesToElements(Xml,
                new Type[]
                {
                    typeof(Hash),
                    typeof(Realm)
                },
                new bool[]
                {
                    true,
                    false
                });
        }
 
        protected override void OnChildNodesUpdated()
        {
            base.OnChildNodesUpdated();
 
            this.hash = this.GetValueElement<Hash>();
            this.realm = this.GetValueElement<Realm>();
            this.then = this.GetChildElement<Then>(true);
            this.@else = this.GetChildElement<Else>(false);
        }
 
        public override async Task Execute(EvaluationArguments Arguments)
        {
            object HashValue = await this.hash.Evaluate(Arguments);
            object RealmValue = this.realm is null ? null : await this.realm.Evaluate(Arguments);
            string Realm;
            bool Exists;
 
            if (!(HashValue is byte[] Hash))
                throw new StateMachineException(Arguments.Machine, "Hash digest must be an array of bytes.");
 
            if (RealmValue is null)
                Realm = null;
            else if (RealmValue is string s)
                Realm = s;
            else if (RealmValue is CaseInsensitiveString cis)
                Realm = cis.Value;
            else
                throw new StateMachineException(Arguments.Machine, "Realm must be a string value.");
 
            Realm ??= string.Empty;
 
            if (string.IsNullOrEmpty(this.ObjectVariable))
                Exists = await PersistedHashes.VerifyHash(Realm, Hash);
            else
            {
                object Obj = await PersistedHashes.TryGetAssociatedObject(Realm, Hash);
                if (Obj is null)
                    Exists = await PersistedHashes.VerifyHash(Realm, Hash);
                else
                    Exists = true;
 
                if (Exists)
                    Arguments.Variables[this.ObjectVariable] = Obj;
                else
                    Arguments.Variables[this.ObjectVariable] = null;
            }
 
            if (Exists)
                await this.then.Execute(Arguments);
            else if (!(this.@else is null))
                await this.@else.Execute(Arguments);
        }
    }
}