ExternalNode.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Sensor;
using Waher.Persistence;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.DisplayableParameters;
 
namespace Waher.IoTGateway.ScriptExtensions.Functions
{
    public class ExternalNode : INode, ISensor
    {
        private readonly string nodeId;
        private readonly string sourceId;
        private readonly string paritionId;
        private readonly CaseInsensitiveString jid;
 
        public ExternalNode(string NodeId, string SourceId, string ParitionId, CaseInsensitiveString Jid)
        {
            this.nodeId = NodeId;
            this.sourceId = SourceId;
            this.paritionId = ParitionId;
            this.jid = Jid;
        }
 
        public string LocalId => this.nodeId;
 
        public string LogId
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append(this.nodeId);
 
                if (!string.IsNullOrEmpty(this.sourceId) || !string.IsNullOrEmpty(this.paritionId))
                {
                    sb.Append('/');
                    sb.Append(this.sourceId);
 
                    if (!string.IsNullOrEmpty(this.paritionId))
                    {
                        sb.Append('/');
                        sb.Append(this.paritionId);
                    }
                }
 
                if (!CaseInsensitiveString.IsNullOrEmpty(this.jid))
                {
                    sb.Append('@');
                    sb.Append(this.jid.Value);
                }
 
                return sb.ToString();
            }
        }
 
        public bool HasChildren => false;
 
        public bool ChildrenOrdered => false;
 
        public bool IsReadable => true;
 
        public bool IsControllable => true;
 
        public bool HasCommands => false;
 
        public INode Parent => null;
 
        public DateTime LastChanged => DateTime.MinValue;
 
        public NodeState State => NodeState.None;
 
        public Task<IEnumerable<INode>> ChildNodes => Task.FromResult<IEnumerable<INode>>(null);
 
        public string NodeId => this.nodeId;
 
        public string SourceId => this.sourceId;
 
        public string Partition => this.paritionId;
 
        public CaseInsensitiveString Jid => this.jid;
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(false);
        }
 
        public Task AddAsync(INode Child)
        {
            throw new NotSupportedException("This node cannot accept child nodes.");
        }
 
        public Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);
        }
 
        public Task DestroyAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Parameter>>(new Parameter[0]);
        }
 
        public Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Message>>(new Message[0]);
        }
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<bool> MoveDownAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> MoveUpAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> RemoveAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public Task UpdateAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<IEnumerable<ICommand>> Commands => Task.FromResult<IEnumerable<ICommand>>(null);
 
        public async Task StartReadout(ISensorReadout Request)
        {
            RosterItem Item = Gateway.XmppClient[this.jid.Value];
 
            if (Item is null ||
                (Item.State != SubscriptionState.Both &&
                Item.State != SubscriptionState.To))
            {
                await Gateway.XmppClient.RequestPresenceSubscription(this.jid.Value);
                await Request.ReportErrors(true, new ThingError(this, "No presence subscription approved by " + this.jid.Value + ". New subscription request sent."));
                return;
            }
 
            if (!Item.HasLastPresence || !Item.LastPresence.IsOnline)
            {
                await Request.ReportErrors(true, new ThingError(this, "Sensor host not online: " + this.jid.Value));
                return;
            }
 
            INode[] Nodes;
 
            if (string.IsNullOrEmpty(this.nodeId))
                Nodes = null;
            else
                Nodes = new INode[] { this };
 
            SensorDataClientRequest SensorDataRequest = await Gateway.SensorClient.RequestReadout(Item.LastPresenceFullJid,
                Nodes, Request.Types, Request.FieldNames, Request.From, Request.To, Request.When, 
                Request.ServiceToken, Request.DeviceToken, Request.UserToken);
 
            SensorDataRequest.OnFieldsReceived += (sender, Fields) =>
            {
                Request.ReportFields(false, Fields);
                return Task.CompletedTask;
            };
 
            SensorDataRequest.OnErrorsReceived += (sender, Errors) =>
            {
                Request.ReportErrors(false, Errors);
                return Task.CompletedTask;
            };
 
            SensorDataRequest.OnStateChanged += (sender, State) =>
            {
                switch (State)
                {
                    case SensorDataReadoutState.Cancelled:
                        Request.ReportErrors(true, new ThingError(this, "Readout was cancelled."));
                        break;
 
                    case SensorDataReadoutState.Done:
                        Request.ReportFields(true);
                        break;
 
                    case SensorDataReadoutState.Failure:
                        Request.ReportErrors(true, new ThingError(this, "Readout failed."));
                        break;
                }
 
                return Task.CompletedTask;
            };
        }
    }
}