LogEvent.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Persistence.Attributes;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.EventLog
{
    public class LogEvent : ActionNode
    {
        private Message message;
        private Object @object;
        private Actor actor;
        private EventId eventId;
        private Module module;
        private Facility facility;
        private Tag[] tags;
 
        public LogEvent()
            : base()
        {
        }
 
        public Message Message => this.message;
 
        public Object Object => this.@object;
 
        public Actor Actor => this.actor;
 
        public EventId EventId => this.eventId;
 
        public Module Module => this.module;
 
        public Facility Facility => this.facility;
 
        public Tag[] Tags => this.tags;
 
        [DefaultValue(EventType.Informational)]
        public EventType Type { get; set; }
 
        [DefaultValue(EventLevel.Minor)]
        public EventLevel Level { get; set; }
 
        public override string LocalName => nameof(LogEvent);
 
        public override IStateMachineNode Create()
        {
            return new LogEvent();
        }
 
        public override async Task Parse(XmlElement Xml)
        {
            this.Type = XML.Attribute(Xml, "type", EventType.Informational);
            this.Level = XML.Attribute(Xml, "level", EventLevel.Minor);
 
            await base.Parse(Xml);
 
            this.ConvertValueAttributesToElements(Xml,
                new Type[]
                {
                    typeof(Message),
                    typeof(Object),
                    typeof(Actor),
                    typeof(EventId),
                    typeof(Module),
                    typeof(Facility)
                },
                new bool[]
                {
                    true,
                    false,
                    false,
                    false,
                    false,
                    false
                });
        }
 
        protected override void OnChildNodesUpdated()
        {
            base.OnChildNodesUpdated();
 
            this.message = this.GetValueElement<Message>();
            this.@object = this.GetValueElement<Object>();
            this.actor = this.GetValueElement<Actor>();
            this.eventId = this.GetValueElement<EventId>();
            this.module = this.GetValueElement<Module>();
            this.facility = this.GetValueElement<Facility>();
            this.tags = this.GetChildElements<Tag>();
        }
 
        public override async Task Execute(EvaluationArguments Arguments)
        {
            string Message = (await this.message.Evaluate(Arguments))?.ToString();
            string Object = this.@object is null ? string.Empty : (await this.@object.Evaluate(Arguments))?.ToString();
            string Actor = this.actor is null ? string.Empty : (await this.actor.Evaluate(Arguments))?.ToString();
            string EventId = this.eventId is null ? string.Empty : (await this.eventId.Evaluate(Arguments))?.ToString();
            string Module = this.module is null ? string.Empty : (await this.module.Evaluate(Arguments))?.ToString();
            string Facility = this.facility is null ? string.Empty : (await this.facility.Evaluate(Arguments))?.ToString();
            List<KeyValuePair<string, object>> Tags = new List<KeyValuePair<string, object>>();
 
            foreach (Tag Tag in this.tags)
            {
                Tags.Add(new KeyValuePair<string, object>(
                    (await Tag.Key.Evaluate(Arguments))?.ToString(),
                    await Tag.Value.Evaluate(Arguments)));
            }
 
            Log.Event(new Event(DateTime.Now, this.Type, Message, Object, Actor, EventId,
                this.Level, Facility, Module, string.Empty, Tags.ToArray()));
        }
    }
}