/// <summary>
        /// Executes a node.
        /// </summary>
        /// <param name="Variables">Set of variables for the activity.</param>
        /// <returns>Next node of execution, if different from the default, otherwise null (for default).</returns>
        public override Task <LinkedListNode <IActivityNode> > Execute(Variables Variables)
        {
            if (!Variables.TryGetVariable(this.eventArgs, out Variable v) ||
                !(v.ValueObject is SensorDataServerRequest e))
            {
                throw new Exception("Sensor data event arguments not found.");
            }

            LinkedList <Field> Fields = new LinkedList <Field>();

            foreach (FieldNode Field in this.fields)
            {
                try
                {
                    Field.AddFields(Fields, Variables);
                }
                catch (Exception ex)
                {
                    ex = Log.UnnestException(ex);
                    e.ReportErrors(false, new ThingError(Field.ThingReference, DateTime.Now, ex.Message));
                }
            }

            e.ReportFields(!this.more, Fields);

            return(Task.FromResult <LinkedListNode <IActivityNode> >(null));
        }
        /// <summary>
        /// Executes a node.
        /// </summary>
        /// <param name="Variables">Set of variables for the activity.</param>
        /// <returns>Next node of execution, if different from the default, otherwise null (for default).</returns>
        public override Task <LinkedListNode <IActivityNode> > Execute(Variables Variables)
        {
            if (!Variables.TryGetVariable(this.sensor, out Variable v))
            {
                throw new Exception("Sensor not found: " + this.sensor);
            }

            if (!(v.ValueObject is SensorServer Sensor))
            {
                throw new Exception("Not a sensor server object: " + this.sensor);
            }

            Dictionary <ThingReference, LinkedList <Field> > FieldsByThing = new Dictionary <ThingReference, LinkedList <Field> >();
            ThingReference Ref;

            foreach (FieldNode Field in this.fields)
            {
                Ref = Field.ThingReference;
                if (!FieldsByThing.TryGetValue(Ref, out LinkedList <Field> Fields))
                {
                    Fields             = new LinkedList <Field>();
                    FieldsByThing[Ref] = Fields;
                }

                try
                {
                    Field.AddFields(Fields, Variables);
                }
                catch (Exception ex)
                {
                    Log.Critical(ex);
                }
            }

            foreach (KeyValuePair <ThingReference, LinkedList <Field> > P in FieldsByThing)
            {
                LinkedList <Field>     Fields = P.Value;
                LinkedListNode <Field> Loop   = Fields.First;
                LinkedListNode <Field> Next;
                bool Found = false;

                while (Loop != null)
                {
                    Next = Loop.Next;
                    if (Loop.Value.Type.HasFlag(Waher.Things.SensorData.FieldType.Momentary))
                    {
                        Found = true;
                    }
                    else
                    {
                        Fields.Remove(Loop);
                    }

                    Loop = Next;
                }

                if (Found)
                {
                    Sensor.NewMomentaryValues(P.Key, Fields);

                    if (Sensor.Client.TryGetExtension(typeof(PepClient), out IXmppExtension Extension) &&
                        Extension is PepClient PepClient)
                    {
                        PepClient.Publish(new SensorData(Fields), null, null);
                    }
                }
            }

            return(Task.FromResult <LinkedListNode <IActivityNode> >(null));
        }