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.Model.Actions.Outbound;
using Waher.Things.SensorData;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Runtime
{
    public class PersistVariable : ActionNode
    {
        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 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");
 
            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 override async Task Execute(EvaluationArguments Arguments)
        {
            object Value = await this.value.Evaluate(Arguments);
            bool OnlyIfChanged;
            ProfilerThread Thread;
 
            if (this.onlyIfChanged is null)
                OnlyIfChanged = false;
            else if (await this.onlyIfChanged.Evaluate(Arguments) is bool b)
                OnlyIfChanged = b;
            else
                throw new Exception("OnlyIfChanged must be a boolean value.");
 
            string Name = this.Name;
 
            if (string.IsNullOrEmpty(Name))
            {
                if (this.variableName is null)
                    throw new Exception("Variable name not defined.");
 
                Name = (await this.variableName.Evaluate(Arguments))?.ToString();
                if (string.IsNullOrEmpty(Name))
                    throw new Exception("Variable name not defined.");
            }
 
            if (OnlyIfChanged &&
                Arguments.Variables.TryGetVariable(Name, out Waher.Script.Variable Current) &&
                !((Value is null) ^ (Current.ValueObject is null)) &&
                (Value?.Equals(Current.ValueObject) ?? true))
            {
                return;
            }
 
            Arguments.UpdateVariable(Name, Value);
 
            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);
                    Thread.NewSample(Sample);
                }
                else if (Value is IPhysicalQuantity PQ)
                {
                    PhysicalQuantity Q = PQ.ToPhysicalQuantity();
                    Thread = Arguments.Profiler.GetThread(Name + " " + Q.Unit.ToString(), ProfilerThreadType.Analog);
                    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.ToString(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;
            }
        }
    }
}