HandlerNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.ObjectModel;
using TAG.Simulator.ObjectModel.Actors;
using TAG.Simulator.ObjectModel.Events;
using TAG.Simulator.XMPP.Actors;
using Waher.Content.Xml;
using Waher.Networking.XMPP;
using Waher.Script;
 
namespace TAG.Simulator.XMPP.Events
{
    public abstract class HandlerNode : SimulationNode, IExternalEvent
    {
        private IEvent @event;
        private IActor actor;
        private string name;
        private string @namespace;
        private string eventId;
        private string actorName;
        private string eventArgs;
 
        public HandlerNode(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public IEvent Event => this.@event;
 
        public string Name => this.name;
 
        public string HandlerNamespace => this.@namespace;
 
        public string EventId => this.eventId;
 
        public string ActorName => this.actorName;
 
        public IActor Actor => this.actor;
 
        public IExternalEventsNode Events => this.actor;
 
        public string EventArgs => this.eventArgs;
 
        public override string SchemaResource => XmppActor.XmppSchema;
 
        public override string Namespace => XmppActor.XmppNamespace;
 
        public override Task FromXml(XmlElement Definition)
        {
            this.name = XML.Attribute(Definition, "name");
            this.@namespace = XML.Attribute(Definition, "namespace");
            this.eventId = XML.Attribute(Definition, "event");
            this.actorName = XML.Attribute(Definition, "actorName");
            this.eventArgs = XML.Attribute(Definition, "eventArgs");
 
            return Task.CompletedTask;
        }
 
        public override Task Initialize()
        {
            this.actor = this.Parent as IActor;
            if (!(this.actor is null))
                this.actor.Register(this);
            else
                throw new Exception("External event registered on a node that is not an actor.");
 
            return base.Initialize();
        }
 
        public override Task Start()
        {
            if (!this.Model.TryGetEvent(this.eventId, out this.@event))
                throw new Exception("Event not found: " + this.eventId);
 
            this.@event.Register(this);
 
            return base.Start();
        }
 
        public virtual void Trigger(IActor Source, params KeyValuePair<string, object>[] Arguments)
        {
            Variables Variables = this.Model.GetEventVariables(Source);
 
            if (!string.IsNullOrEmpty(this.actorName))
                Variables[this.actorName] = Source.ActivityObject;
 
            if (!(Arguments is null))
            {
                foreach (KeyValuePair<string, object> Argument in Arguments)
                    Variables[Argument.Key] = Argument.Value;
            }
 
            this.@event?.Trigger(Variables);
        }
 
        public IEnumerable<Parameter> Parameters
        {
            get
            {
                return new Parameter[] { new Parameter(this, this.Model, "e", string.IsNullOrEmpty(this.eventArgs) ? "e" : this.eventArgs) };
            }
        }
 
        public abstract void RegisterHandlers(IActor Actor, XmppClient Client);
    }
}