GetNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Things;
using Waher.Things.Metering;
 
namespace Waher.IoTGateway.ScriptExtensions.Functions
{
    public class GetNode : FunctionMultiVariate
    {
        public GetNode(ScriptNode NodeId, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { NodeId }, argumentTypes1Scalar, Start, Length, Expression)
        {
        }
 
        public GetNode(ScriptNode NodeId, ScriptNode SourceId, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { NodeId, SourceId }, argumentTypes2Scalar, Start, Length, Expression)
        {
        }
 
        public GetNode(ScriptNode NodeId, ScriptNode SourceId, ScriptNode Partition, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { NodeId, SourceId, Partition }, argumentTypes3Scalar, Start, Length, Expression)
        {
        }
 
        public GetNode(ScriptNode NodeId, ScriptNode SourceId, ScriptNode Partition, ScriptNode Jid, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { NodeId, SourceId, Partition, Jid }, argumentTypes4Scalar, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(GetNode);
 
        public override string[] DefaultArgumentNames => new string[] { "NodeId", "SourceId", "Partition", "JID" };
 
        public override bool IsAsynchronous => true;
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            return this.EvaluateAsync(Arguments, Variables).Result;
        }
 
        public override async Task<IElement> EvaluateAsync(IElement[] Arguments, Variables Variables)
        {
            INode Result;
            int c = Arguments.Length;
 
            if (c == 0)
                return ObjectValue.Null;
            else
            {
                object Arg0 = Arguments[0].AssociatedObjectValue;
                IDataSource Source;
                string SourceId;
 
                if (c == 1)
                {
                    if (Arg0 is IThingReference ThingReference)
                    {
                        if (!TryGetDataSource(ThingReference.SourceId, out Source))
                            return ObjectValue.Null;
 
                        Result = await Source.GetNodeAsync(ThingReference);
                    }
                    else
                    {
                        SourceId = MeteringTopology.SourceID;
                        if (!TryGetDataSource(SourceId, out Source))
                            return ObjectValue.Null;
 
                        Result = await Source.GetNodeAsync(new ThingReference(Arg0?.ToString() ?? string.Empty, SourceId));
                    }
                }
                else
                {
                    string NodeId = Arg0?.ToString() ?? string.Empty;
                    object Arg1 = Arguments[1].AssociatedObjectValue;
 
                    SourceId = Arg1?.ToString() ?? string.Empty;
 
                    if (c == 2)
                    {
                        if (!TryGetDataSource(SourceId, out Source))
                            return ObjectValue.Null;
 
                        Result = await Source.GetNodeAsync(new ThingReference(NodeId, SourceId));
                    }
                    else
                    {
                        object Arg2 = Arguments[2].AssociatedObjectValue;
                        string PartitionId = Arg2?.ToString() ?? string.Empty;
 
                        if (c == 3)
                        {
                            if (!TryGetDataSource(SourceId, out Source))
                                return ObjectValue.Null;
 
                            Result = await Source.GetNodeAsync(new ThingReference(NodeId, SourceId, PartitionId));
                        }
                        else
                        {
                            object Arg3 = Arguments[3].AssociatedObjectValue;
                            string Jid = Arg3?.ToString().Trim() ?? string.Empty;
 
                            if (string.Compare(Gateway.XmppClient.BareJID, Jid, true) == 0)
                            {
                                if (!TryGetDataSource(SourceId, out Source))
                                    return ObjectValue.Null;
 
                                Result = await Source.GetNodeAsync(new ThingReference(NodeId, SourceId, PartitionId));
                            }
                            else
                                Result = new ExternalNode(NodeId, SourceId, PartitionId, Jid);
                        }
                    }
                }
            }
 
            if (Result is null)
                return ObjectValue.Null;
            else
            {
                RequestOrigin Origin = await GetOriginOfRequest(Variables);
 
                if (!await Result.CanViewAsync(Origin))
                    throw new UnauthorizedAccessException("Access to node denied.");
 
                return new ObjectValue(Result);
            }
        }
 
        public static Task<RequestOrigin> GetOriginOfRequest(Variables Variables)
        {
            if (Variables.TryGetVariable("this", out Variable v) && v.ValueObject is IRequestOrigin Origin)
                return Origin.GetOrigin();
            else if (Variables.TryGetVariable("QuickLoginUser", out v) && v.ValueObject is IRequestOrigin Origin2)
                return Origin2.GetOrigin();
            else if (Variables.TryGetVariable("User", out v) && v.ValueObject is IRequestOrigin Origin3)
                return Origin3.GetOrigin();
            else
                return Task.FromResult(new RequestOrigin(Gateway.XmppClient.BareJID, null, null, null));
        }
 
        public static bool TryGetDataSource(string SourceId, out IDataSource Source)
        {
            if (!Types.TryGetModuleParameter("Sources", out object Obj) || !(Obj is IDataSource[] Sources))
            {
                Source = null;
                return false;
            }
 
            if (Sources != sources)
            {
                Dictionary<string, IDataSource> SourceById = new Dictionary<string, IDataSource>();
                Add(SourceById, Sources);
                sourceById = SourceById;
                sources = Sources;
            }
 
            return sourceById.TryGetValue(SourceId, out Source);
        }
 
        private static void Add(Dictionary<string, IDataSource> SourceById, IEnumerable<IDataSource> Sources)
        {
            foreach (IDataSource Source in Sources)
            {
                SourceById[Source.SourceID] = Source;
 
                if (Source.HasChildren)
                    Add(SourceById, Source.ChildSources);
            }
        }
 
        private static IDataSource[] sources = null;
        private static Dictionary<string, IDataSource> sourceById = null;
    }
}