MqttTopicNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Runtime.Language;
using Waher.Persistence.Attributes;
using Waher.Things.Attributes;
using Waher.Things.ControlParameters;
using Waher.Things.DisplayableParameters;
using Waher.Things.Metering;
using Waher.Things.Mqtt.Model;
using Waher.Things.Virtual;
 
namespace Waher.Things.Mqtt
{
    public class MqttTopicNode : VirtualNode, ISensor, IActuator, IMqttTopicNode
    {
        private string localTopic = string.Empty;
 
        public MqttTopicNode()
            : base()
        {
        }
 
        [Page(2, "MQTT")]
        [Header(22, "Local Topic:")]
        [ToolTip(23, "Local topic, unique among siblings.")]
        [DefaultValueStringEmpty]
        public string LocalTopic
        {
            get => this.localTopic;
            set => this.localTopic = value;
        }
 
        public override string LocalId => this.localTopic;
 
        public async Task<string> GetFullTopic()
        {
            string Result = this.localTopic;
 
            IMqttTopicNode Loop = await this.GetParent() as IMqttTopicNode;
            while (!(Loop is null))
            {
                Result = Loop.LocalTopic + "/" + Result;
                Loop = await Loop.GetParent() as IMqttTopicNode;
            }
 
            return Result;
        }
 
        public async Task<MqttBrokerNode> GetBroker()
        {
            INode Parent = await this.GetParent();
 
            while (!(Parent is null))
            {
                if (Parent is MqttBrokerNode Broker)
                    return Broker;
                else if (Parent is MeteringNode MeteringNode)
                    Parent = await MeteringNode.GetParent();
                else
                    Parent = Parent.Parent;
            }
 
            return null;
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is IMqttTopicNode);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is IMqttTopicNode || Parent is MqttBrokerNode);
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(IMqttTopicNode), 24, "Topic");
        }
 
        public async Task<MqttTopic> GetTopic()
        {
            MqttBrokerNode BrokerNode = await this.GetBroker();
            MqttBroker Broker = await BrokerNode.GetBroker();
            if (Broker is null)
                return null;
            else
                return await Broker.GetTopic(await this.GetFullTopic(), false, false);
        }
 
        public override async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = (LinkedList<Parameter>)await base.GetDisplayableParametersAsync(Language, Caller);
            MqttTopic Topic = await this.GetTopic();
 
            if (!(Topic is null))
                await Topic.GetDisplayableParametersAsync(Parameters, Language, Caller);
 
            return Parameters;
        }
 
        public async override Task<bool> RemoveAsync(INode Child)
        {
            if (Child is IMqttTopicNode Topic)
                (await this.GetTopic())?.Remove(Topic.LocalTopic);
 
            return await base.RemoveAsync(Child);
        }
 
        public override bool IsControllable
        {
            get
            {
                if (this.Disabled)
                    return false;
 
                if (base.IsControllable)
                    return true;
 
                return this.GetTopic().Result?.IsControllable ?? false;
            }
        }
 
        public override async Task<ControlParameter[]> GetControlParameters()
        {
            List<ControlParameter> Parameters = new List<ControlParameter>();
            Parameters.AddRange(await base.GetControlParameters());
 
            if ((await this.GetTopic())?.GetControlParameters() is ControlParameter[] P)
                Parameters.AddRange(P);
 
            return Parameters.ToArray();
        }
 
        public override bool IsReadable => !this.Disabled;
 
        public override async Task StartReadout(ISensorReadout Request, bool DoneAfter)
        {
            try
            {
                MqttTopic Topic = await this.GetTopic();
 
                await base.StartReadout(Request, (Topic is null) && DoneAfter);
 
                if (!(Topic is null))
                    await Topic.StartReadout(Request, DoneAfter);
            }
            catch (Exception ex)
            {
                await Request.ReportErrors(true, new ThingError(this, ex.Message));
            }
        }
 
        public virtual Grade Supports(MqttTopicRepresentation Topic)
        {
            return Grade.Barely;
        }
 
        public virtual async Task<IMqttTopicNode> CreateNew(MqttTopicRepresentation Topic)
        {
            return new MqttTopicNode()
            {
                NodeId = await GetUniqueNodeId(Topic.CurrentSegment),
                LocalTopic = Topic.CurrentSegment
            };
        }
 
        public virtual Task<IMqttData> GetDefaultDataObject()
        {
            return Task.FromResult<IMqttData>(null);
        }
 
    }
}