ExternalWebNode.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Language;
using Waher.Things.Metering;
using Waher.Things.SensorData;
 
namespace Waher.Things.Http
{
    public class ExternalWebNode : MeteringNode, ISensor
    {
        private static readonly Dictionary<string, KeyValuePair<Field[], ThingError[]>> sensorData = new Dictionary<string, KeyValuePair<Field[], ThingError[]>>();
 
        public ExternalWebNode()
            : base()
        {
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(LocalWebServerNode), 2, "External Web Node");
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ExternalWebNode);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is ExternalWebNode || Parent is LocalWebServerNode);
        }
 
        internal async Task NewSensorData(Field[] Fields, ThingError[] Errors)
        {
            bool PrevError;
 
            lock (sensorData)
            {
                PrevError = sensorData.TryGetValue(this.NodeId, out KeyValuePair<Field[], ThingError[]> P)
                    && (P.Value?.Length ?? 0) > 0;
 
                sensorData[this.NodeId] = new KeyValuePair<Field[], ThingError[]>(Fields, Errors);
            }
 
            if (!(Fields is null))
            {
                List<Field> MomentaryValues = null;
 
                foreach (Field Field in Fields)
                {
                    if (Field.Type.HasFlag(FieldType.Momentary))
                    {
                        MomentaryValues ??= new List<Field>();
                        MomentaryValues.Add(Field);
                    }
                }
 
                if (!(MomentaryValues is null))
                    await this.NewMomentaryValues(MomentaryValues.ToArray());
            }
 
            if (Errors is null)
            {
                if (PrevError)
                    await this.RemoveErrorAsync();
            }
            else
            {
                foreach (ThingError Error in Errors)
                    await this.LogErrorAsync(Error.ErrorMessage);
            }
        }
 
        public async Task StartReadout(ISensorReadout Request)
        {
            KeyValuePair<Field[], ThingError[]> Data;
            bool Found;
 
            lock (sensorData)
            {
                Found = sensorData.TryGetValue(this.NodeId, out Data);
            }
 
            if (Found)
            {
                if (!(Data.Key is null))
                    await Request.ReportFields(Data.Value is null, Data.Key);
 
                if (!(Data.Value is null))
                    await Request.ReportErrors(true, Data.Value);
 
                if (Data.Key is null && Data.Value is null)
                    await Request.ReportErrors(true, new ThingError(this, "No Sensor Data reported."));
            }
            else
                await Request.ReportErrors(true, new ThingError(this, "No Sensor Data reported."));
        }
    }
}