NumericalParameter.cs

using System;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Content.Markdown.Model;
using Waher.Content.Xml;
using Waher.Persistence.Attributes;
using Waher.Runtime.Profiling;
using Waher.Script;
using Waher.Service.IoTBroker.Legal.HumanReadable;
 
namespace Waher.Service.IoTBroker.Legal.Contracts
{
    public class NumericalParameter : Parameter
    {
        private decimal? value;
        private decimal? min = null;
        private decimal? max = null;
        private bool minIncluded = true;
        private bool maxIncluded = true;
 
        public decimal? Value
        {
            get => this.@value;
            set
            {
                this.@value = value;
                this.ProtectedValue = null;
            }
        }
 
        [DefaultValueNull]
        public decimal? Min
        {
            get => this.min;
            set => this.min = value;
        }
 
        [DefaultValueNull]
        public decimal? Max
        {
            get => this.max;
            set => this.max = value;
        }
 
        [DefaultValue(true)]
        public bool MinIncluded
        {
            get => this.minIncluded;
            set => this.minIncluded = value;
        }
 
        [DefaultValue(true)]
        public bool MaxIncluded
        {
            get => this.maxIncluded;
            set => this.maxIncluded = value;
        }
 
        public override object ObjectValue => this.@value;
 
        public override string StringValue
        {
            get => this.Value.HasValue ? CommonTypes.Encode(this.Value.Value) : string.Empty;
            set
            {
                if (CommonTypes.TryParse(value, out decimal d))
                    this.Value = d;
                else
                    this.Value = null;
            }
        }
 
        public override void ClearValue()
        {
            this.@value = default;
        }
 
        public override Task ToMarkdown(MarkdownOutput Markdown, MarkdownOutputState State)
        {
            Markdown.Append(MarkdownDocument.Encode(this.@value?.ToString() ?? string.Empty));
            return Task.CompletedTask;
        }
 
        public override void Serialize(StringBuilder Xml)
        {
            Xml.Append("<numericalParameter");
 
            if (!string.IsNullOrEmpty(this.Expression))
            {
                Xml.Append(" exp=\"");
                Xml.Append(XML.Encode(this.Expression.Normalize(NormalizationForm.FormC)));
                Xml.Append('"');
            }
 
            if (!string.IsNullOrEmpty(this.Guide))
            {
                Xml.Append(" guide=\"");
                Xml.Append(XML.Encode(this.Guide.Normalize(NormalizationForm.FormC)));
                Xml.Append('"');
            }
 
            if (this.max.HasValue)
            {
                Xml.Append(" max=\"");
                Xml.Append(CommonTypes.Encode(this.max.Value));
                Xml.Append("\" maxIncluded=\"");
                Xml.Append(XML.Encode(CommonTypes.Encode(this.maxIncluded)));
                Xml.Append('"');
            }
 
            if (this.min.HasValue)
            {
                Xml.Append(" min=\"");
                Xml.Append(CommonTypes.Encode(this.min.Value));
                Xml.Append("\" minIncluded=\"");
                Xml.Append(XML.Encode(CommonTypes.Encode(this.minIncluded)));
                Xml.Append('"');
            }
 
            Xml.Append(" name=\"");
            Xml.Append(XML.Encode(this.Name.Value.Normalize(NormalizationForm.FormC)));
            Xml.Append('"');
 
            if (this.CanSerializeProtectedValue)
            {
                Xml.Append(" protected=\"");
                Xml.Append(Convert.ToBase64String(this.ProtectedValue));
                Xml.Append('"');
            }
 
            if (this.Protection != ProtectionLevel.Normal)
            {
                Xml.Append(" protection=\"");
                Xml.Append(this.Protection.ToString());
                Xml.Append('"');
            }
 
            if (this.@value.HasValue && this.CanSerializeValue)
            {
                Xml.Append(" value=\"");
                Xml.Append(CommonTypes.Encode(this.@value.Value));
                Xml.Append('"');
            }
            
            if (this.Descriptions is null || this.Descriptions.Length == 0)
                Xml.Append("/>");
            else
            {
                Xml.Append('>');
 
                foreach (HumanReadableText Description in this.Descriptions)
                    Description.Serialize(Xml, "description", null);
 
                Xml.Append("</numericalParameter>");
            }
        }
 
        public override Task<string> IsParameterValid(Variables Variables, 
            LegalComponent Legal, ProfilerThread Profiler)
        {
            decimal Diff;
 
            if (!this.@value.HasValue)
                return Task.FromResult("Value missing.");
 
            if (this.min.HasValue)
            {
                Diff = this.@value.Value - this.min.Value;
 
                if (Diff < 0 || (Diff == 0 && !this.minIncluded))
                    return Task.FromResult("Value below minimum permitted.");
            }
 
            if (this.max.HasValue)
            {
                Diff = this.@value.Value - this.max.Value;
 
                if (Diff > 0 || (Diff == 0 && !this.maxIncluded))
                    return Task.FromResult("Value above maximum permitted.");
            }
 
            return base.IsParameterValid(Variables, Legal, Profiler);
        }
 
        public override void Populate(Variables Variables, ProfilerThread Profiler)
        {
            Variables[this.Name] = this.@value;
        }
 
        public override bool UpdateRequiresReview(Parameter UpdatedParameter)
        {
            return !(UpdatedParameter is NumericalParameter UpdatedNumericalParameter) ||
                this.min != UpdatedNumericalParameter.min ||
                this.max != UpdatedNumericalParameter.max ||
                this.minIncluded != UpdatedNumericalParameter.minIncluded ||
                this.maxIncluded != UpdatedNumericalParameter.maxIncluded ||
                base.UpdateRequiresReview(UpdatedParameter);
        }
 
        public override Parameter TryCreateNew(object NewValue)
        {
            if (!(NewValue is decimal D))
            {
                if (NewValue is double Dbl)
                    D = (decimal)Dbl;
                else if (NewValue is float F)
                    D = (decimal)F;
                else if (NewValue is sbyte i8)
                    D = i8;
                else if (NewValue is short i16)
                    D = i16;
                else if (NewValue is int i32)
                    D = i32;
                else if (NewValue is long i64)
                    D = i64;
                else if (NewValue is byte ui8)
                    D = ui8;
                else if (NewValue is ushort ui16)
                    D = ui16;
                else if (NewValue is uint ui32)
                    D = ui32;
                else if (NewValue is ulong ui64)
                    D = ui64;
                else if (NewValue is string s && CommonTypes.TryParse(s, out decimal D2))
                    D = D2;
                else
                    return null;
            }
 
            if (this.min.HasValue && (D < this.min.Value || D == this.min.Value && !this.minIncluded))
                return null;
 
            if (this.max.HasValue && (D > this.max.Value || D == this.max.Value && !this.maxIncluded))
                return null;
 
            return new NumericalParameter()
            {
                Descriptions = this.Descriptions,
                Expression = this.Expression,
                Guide = this.Guide,
                Name = this.Name,
                Value = D,
                Max = this.Max,
                MaxIncluded = this.MaxIncluded,
                Min = this.Min,
                MinIncluded = this.MinIncluded,
                Protection = this.Protection
            };
        }
 
        public override Task<bool> Import(XmlElement Xml)
        {
            this.Value = Xml.HasAttribute("value") ? XML.Attribute(Xml, "value", 0.0m) : (decimal?)null;
            this.Min = Xml.HasAttribute("min") ? XML.Attribute(Xml, "min", 0.0m) : (decimal?)null;
            this.MinIncluded = XML.Attribute(Xml, "minIncluded", true);
            this.Max = Xml.HasAttribute("max") ? XML.Attribute(Xml, "max", 0.0m) : (decimal?)null;
            this.MaxIncluded = XML.Attribute(Xml, "maxIncluded", true);
 
            return base.Import(Xml);
        }
 
        public override TextAlignment CellAlignment => TextAlignment.Right;
 
        public override bool CopyValidationRules(Parameter From)
        {
            if (!(From is NumericalParameter Typed))
                return false;
 
            this.min = Typed.min;
            this.max = Typed.max;
            this.minIncluded = Typed.minIncluded;
            this.maxIncluded = Typed.maxIncluded;
 
            return base.CopyValidationRules(From);
        }
 
        public override void ClearValidationRules()
        {
            this.min = null;
            this.max = null;
 
            base.ClearValidationRules();
        }
    }
}