OnTime.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Persistence.Attributes;
using Waher.Service.IoTBroker.StateMachines.Model.Attributes;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Events
{
    public class OnTime : TimedEventNode
    {
        private ScriptableTimeSpanAttribute value;
        private ScriptableStringAttribute timeCoordinates;
 
        public OnTime()
            : base()
        {
        }
 
        [DefaultValueNull]
        public string ValueDefinition
        {
            get => this.value?.Definition;
            set => this.value = new ScriptableTimeSpanAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string TimeCoordinatesDefinition
        {
            get => this.timeCoordinates?.Definition;
            set => this.timeCoordinates = new ScriptableStringAttribute(value, this);
        }
 
        public override string LocalName => nameof(OnTime);
 
        public override IStateMachineNode Create()
        {
            return new OnTime();
        }
 
        public override Task Parse(XmlElement Xml)
        {
            this.value = new ScriptableTimeSpanAttribute(Xml.InnerText, this);
            this.timeCoordinates = new ScriptableStringAttribute(XML.Attribute(Xml, "timeCoordinates"), this);
 
            return base.Parse(Xml);
        }
 
        public override async Task<EventTimepointUtc> GetEventTimepointUtc(EvaluationArguments Arguments)
        {
            if (this.value is null)
                return new EventTimepointUtc();
            else
            {
                TimeSpan TS = await this.value.Evaluate(Arguments.Variables);
                string TimeCoordinates = await this.timeCoordinates.Evaluate(Arguments.Variables);
                DateTime UtcNow = DateTime.UtcNow;
                DateTime Value;
 
                if (string.IsNullOrEmpty(TimeCoordinates) ||
                    string.Equals(TimeCoordinates, "Local", StringComparison.OrdinalIgnoreCase))
                {
                    Value = DateTime.Today.Add(TS);
                }
                else if (string.Equals(TimeCoordinates, "UTC", StringComparison.OrdinalIgnoreCase))
                {
                    Value = UtcNow.Date.Add(TS);
                }
                else if (TimeCoordinates.StartsWith('-') &&
                    TimeSpan.TryParse(TimeCoordinates[1..], out TimeSpan TS2))
                {
                    Value = UtcNow.Date.Add(TS).Add(TS2);
                }
                else if ((TimeCoordinates.StartsWith('+') &&
                    TimeSpan.TryParse(TimeCoordinates[1..], out TS2)) ||
                    TimeSpan.TryParse(TimeCoordinates, out TS2))
                {
                    Value = UtcNow.Date.Add(TS).Subtract(TS2);
                }
                else
                {
                    Value = DateTime.Today.Add(TS);
 
                    Log.Error("Invalid Time Coordinates in State Machine OnTime event definition: " + TimeCoordinates,
                        Arguments.CurrentState.StateMachineId.Value);
                }
 
                Value = Value.ToUniversalTime();
 
                if (Value < UtcNow)
                    Value = Value.AddDays(Math.Ceiling(UtcNow.Subtract(Value).TotalDays));
 
                return new EventTimepointUtc(UtcNow, Value, everyDay);
            }
        }
 
        private static readonly Duration everyDay = Duration.FromDays(1);
 
        public override string Label => this.value.Definition;
    }
}