Base64Data.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Networking;
using Waher.Networking.MQTT;
using Waher.Runtime.Inventory;
using Waher.Runtime.Language;
using Waher.Things.ControlParameters;
using Waher.Things.SensorData;
 
namespace Waher.Things.Mqtt.Model.Encapsulations
{
    public class Base64Data : MqttData
    {
        public const string RegExString = @"^\s*(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?\s*$";
 
        public static readonly Regex RegEx = new Regex(RegExString, RegexOptions.Compiled | RegexOptions.Singleline);
 
        private byte[] value;
        private bool firstReport = true;
 
        public Base64Data()
            : base()
        {
        }
 
        public Base64Data(MqttTopic Topic, byte[] Value)
            : base(Topic)
        {
            this.value = Value;
        }
 
        public override Task<DataProcessingResult> DataReported(MqttTopic Topic, MqttContent Content)
        {
            string s = Content.DataString;
 
            if (RegEx.IsMatch(s))
            {
                try
                {
                    this.value = Convert.FromBase64String(s);
 
                    if (this.firstReport)
                        this.firstReport = false;
                    else
                    {
                        IMqttData Processor = Topic.FindDataType(Content);
                        if (!(Processor is Base64Data))
                            return Task.FromResult(DataProcessingResult.Incompatible);
                    }
 
                    this.Timestamp = DateTime.UtcNow;
                    this.QoS = Content.Header.QualityOfService;
                    this.Retain = Content.Header.Retain;
                    return Task.FromResult(DataProcessingResult.Processed);
                }
                catch (Exception)
                {
                    return Task.FromResult(DataProcessingResult.Incompatible);
                }
            }
            else
                return Task.FromResult(DataProcessingResult.Incompatible);
        }
 
        public override Task<string> GetTypeName(Language Language)
        {
            return Language.GetStringAsync(typeof(MqttTopicNode), 42, "BASE-64");
        }
 
        public override Task StartReadout(ThingReference ThingReference, ISensorReadout Request, string Prefix, bool Last)
        {
            List<Field> Data = new List<Field>()
            {
                new Int32Field(ThingReference, this.Timestamp, this.Append(Prefix, "#Bytes"),
                    this.value.Length, FieldType.Momentary, FieldQoS.AutomaticReadout)
            };
 
            if (!(this.value is null) && this.value.Length <= 256)
            {
                Data.Add(new StringField(ThingReference, this.Timestamp, "Raw",
                    Convert.ToBase64String(this.value), FieldType.Momentary, FieldQoS.AutomaticReadout));
            }
 
            Request.ReportFields(Last, Data);
        
            return Task.CompletedTask;
        }
 
        public override bool IsControllable => true;
 
        public override ControlParameter[] GetControlParameters()
        {
            return new ControlParameter[]
            {
                new StringControlParameter("Value", "Publish", "Value:", "BASE-64 value of topic.", RegExString,
                    (n) => Task.FromResult<string>(Convert.ToBase64String(this.value)),
                    (n, v) =>
                    {
                        this.value = Convert.FromBase64String(v);
                        this.Topic.MqttClient.PUBLISH(this.Topic.FullTopic, this.QoS, this.Retain, Encoding.UTF8.GetBytes(v));
                        return Task.CompletedTask;
                    })
            };
        }
 
        public override void SnifferOutput(ICommunicationLayer Output)
        {
            if (this.value is null)
                this.Information(Output, "NULL");
            else if (this.value.Length == 1)
                this.Information(Output, "1 byte.");
            else
                this.Information(Output, this.value.Length.ToString() + " bytes.");
        }
 
        public override Grade DefaultSupport => Grade.Excellent;
 
        public override IMqttData CreateNew(MqttTopic Topic, MqttContent Content)
        {
            IMqttData Result = new Base64Data(Topic, default);
            Result.DataReported(Topic, Content);
            return Result;
        }
    }
}