PersistVariable.cs

using System;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Profiling;
using Waher.Script;
using Waher.Script.Objects;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
using Waher.Service.IoTBroker.StateMachines.Model.Actions.Outbound;
using Waher.Service.IoTBroker.StateMachines.Model.Attributes;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Runtime
{
    public class PersistVariable : ActionNode
    {
        private ScriptableBooleanAttribute suppressSample;
        private Name variableName;
        private HeaderValue value;
        private OnlyIfChanged onlyIfChanged;
 
        public PersistVariable()
            : base()
        {
        }
 
        public Name VariableName => this.variableName;
 
        public HeaderValue Value => this.value;
 
        public OnlyIfChanged OnlyIfChanged => this.onlyIfChanged;
 
        [DefaultValueNull]
        public string SuppressSampleDefinition
        {
            get => this.suppressSample?.Definition;
            set => this.suppressSample = new ScriptableBooleanAttribute(value, this);
        }
 
        [DefaultValueNull]
        public string Name { get; set; }
 
        public override string LocalName => nameof(PersistVariable);
 
        public override IStateMachineNode Create()
        {
            return new PersistVariable();
        }
 
        public override async Task Parse(XmlElement Xml)
        {
            this.Name = XML.Attribute(Xml, "name");
            this.suppressSample = new ScriptableBooleanAttribute(XML.Attribute(Xml, "suppressSample"), this);
 
            await base.Parse(Xml);
 
            if (string.IsNullOrEmpty(this.Name))
                this.ConvertValueAttributeToElement<Name>(Xml, true);
 
            this.ConvertValueAttributeToElement<HeaderValue>(Xml, true);
            this.ConvertValueAttributeToElement<OnlyIfChanged>(Xml, false);
        }
 
        protected override void OnChildNodesUpdated()
        {
            base.OnChildNodesUpdated();
 
            if (string.IsNullOrEmpty(this.Name))
                this.variableName = this.GetValueElement<Name>();
 
            this.value = this.GetValueElement<HeaderValue>();
            this.onlyIfChanged = this.GetValueElement<OnlyIfChanged>();
        }
 
        public async Task<bool> GetSuppressSample(EvaluationArguments Arguments)
        {
            if (this.suppressSample?.IsEmpty ?? true)
                return false;
 
            return await this.suppressSample.Evaluate(Arguments.Variables);
        }
 
        public override async Task Execute(EvaluationArguments Arguments)
        {
            object Value = await this.value.Evaluate(Arguments);
            bool OnlyIfChanged;
            bool SuppressSample;
            ProfilerThread Thread;
 
            if (this.onlyIfChanged is null)
                OnlyIfChanged = false;
            else if (await this.onlyIfChanged.Evaluate(Arguments) is bool b)
                OnlyIfChanged = b;
            else
                throw new StateMachineException(Arguments.Machine, "OnlyIfChanged must be a boolean value.");
 
            SuppressSample = await this.GetSuppressSample(Arguments);
 
            string Name = this.Name;
 
            if (string.IsNullOrEmpty(Name))
            {
                if (this.variableName is null)
                    throw new StateMachineException(Arguments.Machine, "Variable name not defined.");
 
                Name = (await this.variableName.Evaluate(Arguments))?.ToString();
                if (string.IsNullOrEmpty(Name))
                    throw new StateMachineException(Arguments.Machine, "Variable name not defined.");
            }
 
            if (!Arguments.Variables.TryGetVariable(Name, out Waher.Script.Variable Current))
                Current = null;
 
            if (OnlyIfChanged &&
                !((Value is null) ^ (Current?.ValueObject is null)) &&
                (Value?.Equals(Current?.ValueObject) ?? true))
            {
                return;
            }
 
            Arguments.UpdateVariable(Name, Value);
 
            if (!SuppressSample)
            {
                await Database.Insert(new StateMachineSample()
                {
                    Variable = Name,
                    Timestamp = DateTime.UtcNow,
                    Value = Value,
                    StateMachineId = Arguments.Machine.StateMachineId,
                    Expires = Arguments.Machine.Expires,
                    ArchiveOptional = Arguments.Machine.ArchiveOptional,
                    ArchiveRequired = Arguments.Machine.ArchiveRequired
                });
 
                if (!(Arguments.Profiler is null))
                {
                    if (IsSample(Value, out double Sample))
                    {
                        Thread = Arguments.Profiler.GetThread(Name, ProfilerThreadType.Analog);
 
                        if (IsSample(Current?.ValueObject, out double Prev))
                            Thread.NewSample(Prev);
 
                        Thread.NewSample(Sample);
                    }
                    else if (Value is IPhysicalQuantity PQ)
                    {
                        PhysicalQuantity Q = PQ.ToPhysicalQuantity();
                        Thread = Arguments.Profiler.GetThread(Name + " " + Q.Unit.ToString(), ProfilerThreadType.Analog);
 
                        if (Current?.ValueObject is IPhysicalQuantity Prev)
                        {
                            PhysicalQuantity PrevQ = Prev.ToPhysicalQuantity();
 
                            if (PrevQ.Unit.Equals(Q.Unit))
                                Thread.NewSample(PrevQ.Magnitude);
                        }
 
                        Thread.NewSample(Q.Magnitude);
                    }
                    else
                    {
                        Thread = Arguments.Profiler.GetThread(Name, ProfilerThreadType.Sequential);
 
                        if (Value is null)
                            Thread.Idle();
                        else
                        {
                            Type T = Value?.GetType() ?? typeof(object);
                            string Label;
                            int NoteIndex;
 
                            if (T.IsValueType)
                            {
                                Label = Expression.ToExpressionString(Value);
 
                                if (Label.Length > 10)
                                {
                                    NoteIndex = Thread.Profiler.AddNote(Label);
                                    Label = "Note" + NoteIndex.ToString();
                                }
                            }
                            else if (Value is string s)
                            {
                                if (s.Length > 10)
                                {
                                    NoteIndex = Thread.Profiler.AddNote(s);
                                    Label = "Note" + NoteIndex.ToString();
                                }
                                else
                                    Label = s.Replace('"', '\'');
                            }
                            else
                            {
                                StringBuilder sb = new StringBuilder();
 
                                sb.AppendLine("@startjson");
                                sb.AppendLine(JSON.Encode(Value, true));
                                sb.Append("@endjson");
 
                                NoteIndex = Thread.Profiler.AddNote(sb.ToString());
                                Label = "Note" + NoteIndex.ToString();
                            }
 
                            Thread.NewState(Label);
                        }
                    }
                }
            }
        }
 
        private static bool IsSample(object Value, out double Sample)
        {
            if (Value is null)
            {
                Sample = 0;
                return false;
            }
            else if (Value is double d)
            {
                Sample = d;
                return true;
            }
            else if (Value is decimal dec)
            {
                Sample = (double)dec;
                return true;
            }
            else if (Value is float fl)
            {
                Sample = fl;
                return true;
            }
            else if (Value is sbyte i8)
            {
                Sample = i8;
                return true;
            }
            else if (Value is short i16)
            {
                Sample = i16;
                return true;
            }
            else if (Value is int i32)
            {
                Sample = i32;
                return true;
            }
            else if (Value is long i64)
            {
                Sample = i64;
                return true;
            }
            else if (Value is byte ui8)
            {
                Sample = ui8;
                return true;
            }
            else if (Value is ushort ui16)
            {
                Sample = ui16;
                return true;
            }
            else if (Value is uint ui32)
            {
                Sample = ui32;
                return true;
            }
            else if (Value is ulong ui64)
            {
                Sample = ui64;
                return true;
            }
            else
            {
                Sample = 0;
                return false;
            }
        }
    }
}