OnContractTemplateApproved.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Runtime.Collections;
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 class OnContractTemplateApproved : ContractEventNode
    {
        private ScriptableBooleanAttribute checkExisting;
 
        public OnContractTemplateApproved()
            : base()
        {
        }
 
        [DefaultValueNull]
        public string CheckExistingDefinition
        {
            get => this.checkExisting?.Definition;
            set => this.checkExisting = new ScriptableBooleanAttribute(value, this);
        }
 
        public override string LocalName => nameof(OnContractTemplateApproved);
 
        public override IStateMachineNode Create()
        {
            return new OnContractTemplateApproved();
        }
 
        public override Task Parse(XmlElement Xml)
        {
            this.checkExisting = new ScriptableBooleanAttribute(XML.Attribute(Xml, "checkExisting"), this);
 
            return base.Parse(Xml);
        }
 
        public override async Task<EventHandlerReference> Register(int EventIndex, EvaluationArguments Arguments,
            OnEvent Event)
        {
            EventHandlerReference Ref = await base.Register(EventIndex, Arguments, Event);
            if (Ref is null)
                return null;
 
            if (Ref?.EventHandler is ContractEventHandler ContractEventHandler &&
                !this.checkExisting.IsEmpty &&
                await this.checkExisting.Evaluate(Arguments.Variables))
            {
                IEnumerable<Contract> ContractTemplates;
                Filter FirstFilter = new FilterFieldEqualTo("CanActAsTemplate", true);
                ChunkedList<Filter> Filters = new ChunkedList<Filter>()
                {
                    FirstFilter
                };
 
                if (ContractEventHandler.NameType == SecondaryNameType.None)
                {
                    if (!string.IsNullOrEmpty(ContractEventHandler.Namespace))
                        Filters.Add(new FilterFieldEqualTo("ForMachinesNamespace", ContractEventHandler.Namespace));
 
                    if (!string.IsNullOrEmpty(ContractEventHandler.LocalName))
                        Filters.Add(new FilterFieldEqualTo("ForMachinesLocalName", ContractEventHandler.LocalName));
 
                    if (Filters.Count == 1)
                        ContractTemplates = await Database.Find<Contract>(FirstFilter, "-Created");
                    else
                        ContractTemplates = await Database.Find<Contract>(new FilterAnd(Filters.ToArray()), "-Created");
                }
                else
                {
                    Filters.Add(new FilterFieldEqualTo("SecondaryType", ContractEventHandler.NameType));
 
                    if (!string.IsNullOrEmpty(ContractEventHandler.Namespace))
                        Filters.Add(new FilterFieldEqualTo("SecondaryNamespace", ContractEventHandler.Namespace));
 
                    if (!string.IsNullOrEmpty(ContractEventHandler.LocalName))
                        Filters.Add(new FilterFieldEqualTo("SecondaryLocalName", ContractEventHandler.LocalName));
 
                    ContractTemplates = await Database.Find<Contract>(new FilterAnd(Filters.ToArray()), "-Created");
                }
 
                if (!(ContractTemplates is null))
                {
                    foreach (Contract Contract in ContractTemplates)
                    {
                        KeyValuePair<string, object>[] ToSet = await StateMachineProcessor.GetVariablesToSet(ContractEventHandler, Contract, null, null);
 
                        foreach (KeyValuePair<string, object> P in ToSet)
                            Arguments.Variables[P.Key] = P.Value;
 
                        try
                        {
                            if (await this.EvaluateCondition(Arguments))
                                return new ExistingTemplateFound(Ref, ToSet);
                        }
                        catch (Exception)
                        {
                            continue;
                        }
                    }
                }
 
                return Ref;
            }
 
            return Ref;
        }
 
        private class ExistingTemplateFound : EventHandlerReference
        {
            private readonly KeyValuePair<string, object>[] toSet;
            private readonly EventHandlerReference reference;
 
            public ExistingTemplateFound(EventHandlerReference Ref, 
                KeyValuePair<string, object>[] ToSet)
                : base(Ref.EventHandler, true)
            {
                this.reference = Ref;
                this.toSet = ToSet;
            }
 
            public override async Task Prepare(EvaluationArguments Arguments)
            {
                if (!(this.reference is null))
                    await this.reference.Prepare(Arguments);
 
                foreach (KeyValuePair<string, object> P in this.toSet)
                    Arguments.Variables[P.Key] = P.Value;
            }
        }
 
    }
}