node-red-contrib-uos-nats 0.1.0

package/nodes/datahub-input.html

@@ -0,0 +1,157 @@
+<script type="text/javascript">
+(function() {
+  function fetchProviders(configId) {
+    if (!configId) return Promise.resolve([]);
+    return $.getJSON(`uos/providers/${configId}`);
+  }
+  function fetchVariables(configId, providerId) {
+    if (!configId || !providerId) return Promise.resolve([]);
+    return $.getJSON(`uos/providers/${configId}/${providerId}/variables`);
+  }
+
+  RED.nodes.registerType('datahub-input', {
+    category: 'input',
+    color: '#ff9f43',
+    defaults: {
+      name: { value: '' },
+      connection: { type: 'uos-config', required: true },
+      providerId: { value: '', required: true },
+      variableMode: { value: 'all' },
+      variables: { value: '[]' }
+    },
+    inputs: 0,
+    outputs: 1,
+    icon: 'white/datahub-input.svg',
+    label: function() {
+      return this.name || `DataHub Input ${this.providerId || ''}`;
+    },
+    labelStyle: function() {
+      return this.name ? 'node_label_italic' : '';
+    },
+    oneditprepare: function() {
+      const providerField = $('#node-input-providerId');
+      const modeField = $('#node-input-variableMode');
+      const singleField = $('#node-input-variableSingle');
+      const multiField = $('#node-input-variableMulti');
+      const multiContainer = $('#node-input-variableMulti-container');
+      const singleContainer = $('#node-input-variableSingle-container');
+      const configField = $('#node-input-connection');
+      let cachedVariables = [];
+
+      function applyMode() {
+        const mode = modeField.val();
+        if (mode === 'single') {
+          singleContainer.show();
+          multiContainer.hide();
+        } else if (mode === 'multi') {
+          singleContainer.hide();
+          multiContainer.show();
+        } else {
+          singleContainer.hide();
+          multiContainer.hide();
+        }
+      }
+
+      function populateVariables(list) {
+        cachedVariables = list;
+        singleField.empty();
+        multiField.empty();
+        list.forEach(v => {
+          $('<option>').val(v.key).text(v.key).appendTo(singleField);
+          $('<option>').val(v.key).text(v.key).appendTo(multiField);
+        });
+        const stored = [];
+        try { stored.push(...JSON.parse($('#node-input-variables').val() || '[]')); } catch(e) {}
+        if (stored.length) {
+          singleField.val(stored[0] || '');
+          multiField.val(stored);
+        }
+      }
+
+      function loadVariables() {
+        const cfg = configField.val();
+        const provider = providerField.val();
+        if (!cfg || !provider) {
+          populateVariables([]);
+          return;
+        }
+        fetchVariables(cfg, provider).then((vars) => {
+          const normalized = (vars || []).map(v => ({ key: v.key || v.id }));
+          populateVariables(normalized);
+        }).catch(() => populateVariables([]));
+      }
+
+      function loadProviders() {
+        const node = this;
+        const cfg = configField.val();
+        providerField.empty();
+        if (!cfg) {
+          providerField.append('<option value="">-- select config first --</option>');
+          return;
+        }
+        fetchProviders(cfg).then((providers) => {
+          providerField.append('<option value="">-- choose provider --</option>');
+          (providers || []).forEach((p) => {
+            $('<option>').val(p.id).text(p.id).appendTo(providerField);
+          });
+          if (node.providerId) {
+            providerField.val(node.providerId);
+          }
+          loadVariables();
+        }).catch(() => {
+          providerField.append('<option value="">(error loading providers)</option>');
+        });
+      }
+
+      modeField.on('change', applyMode);
+      providerField.on('change', loadVariables);
+      configField.on('change', loadProviders.bind(this));
+
+      applyMode();
+      loadProviders.call(this);
+    },
+    oneditsave: function() {
+      const mode = $('#node-input-variableMode').val();
+      let selected = [];
+      if (mode === 'single') {
+        const val = $('#node-input-variableSingle').val();
+        if (val) selected = [val];
+      } else if (mode === 'multi') {
+        selected = $('#node-input-variableMulti').val() || [];
+      }
+      $('#node-input-variables').val(JSON.stringify(selected));
+    }
+  });
+})();
+</script>
+
+<input type="hidden" id="node-input-variables">
+<div class="form-row">
+  <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+  <input type="text" id="node-input-name">
+</div>
+<div class="form-row">
+  <label for="node-input-connection"><i class="fa fa-cube"></i> u-OS Config</label>
+  <input type="text" id="node-input-connection">
+</div>
+<div class="form-row">
+  <label for="node-input-providerId"><i class="fa fa-list"></i> Provider</label>
+  <select id="node-input-providerId"></select>
+</div>
+<div class="form-row">
+  <label for="node-input-variableMode"><i class="fa fa-filter"></i> Variables</label>
+  <select id="node-input-variableMode">
+    <option value="all">All variables</option>
+    <option value="single">Single variable</option>
+    <option value="multi">Multi selection</option>
+  </select>
+</div>
+<div class="form-row" id="node-input-variableSingle-container" style="display:none;">
+  <label><i class="fa fa-bullseye"></i> Variable</label>
+  <select id="node-input-variableSingle" style="width:100%"></select>
+</div>
+<div class="form-row" id="node-input-variableMulti-container" style="display:none;">
+  <label><i class="fa fa-list-ul"></i> Variables</label>
+  <select id="node-input-variableMulti" multiple size="8" style="width:100%"> </select>
+</div>
+<p>Outputs messages with <code>{{payload.type}}</code> = <code>snapshot</code> or <code>change</code> and a <code>variables</code> array containing the selected Data Hub values.</p>

package/nodes/datahub-input.js

@@ -0,0 +1,129 @@
+const path = require('path');
+const { pathToFileURL } = require('url');
+const flatbuffers = require('flatbuffers');
+
+const payloadModuleUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'payloads.js')).href;
+const subjectsModuleUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'subjects.js')).href;
+const readResponseUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'fbs', 'weidmueller', 'ucontrol', 'hub', 'read-variables-query-response.js')).href;
+const changeEventUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'fbs', 'weidmueller', 'ucontrol', 'hub', 'variables-changed-event.js')).href;
+
+const loadModules = () => Promise.all([
+  import(payloadModuleUrl),
+  import(subjectsModuleUrl),
+  import(readResponseUrl),
+  import(changeEventUrl),
+]);
+
+const normalizeKey = (key) => (key ? String(key).trim() : '');
+
+module.exports = function (RED) {
+  function DataHubInputNode(config) {
+    RED.nodes.createNode(this, config);
+    const connection = RED.nodes.getNode(config.connection);
+    if (!connection) {
+      this.status({ fill: 'red', shape: 'ring', text: 'missing config' });
+      this.error('Please select a u-OS config node.');
+      return;
+    }
+
+    this.providerId = config.providerId || 'sampleprovider';
+    this.variableMode = config.variableMode || 'all';
+    try {
+      this.variables = JSON.parse(config.variables || '[]').map(normalizeKey).filter((k) => k);
+    }
+    catch (err) {
+      this.variables = [];
+    }
+
+    let nc;
+    let sub;
+    let closed = false;
+    const defMap = new Map();
+
+    const shouldInclude = (key) => {
+      if (this.variableMode === 'all' || !this.variables.length) {
+        return true;
+      }
+      const needle = normalizeKey(key);
+      if (this.variableMode === 'single') {
+        return needle === this.variables[0];
+      }
+      return this.variables.includes(needle);
+    };
+
+    const processStates = (states) => {
+      return states
+        .map((state) => ({
+        providerId: this.providerId,
+        id: state.id,
+        key: defMap.get(state.id)?.key || state.id,
+        value: state.value,
+        quality: state.quality,
+        timestampNs: state.timestampNs,
+      }))
+        .filter((state) => shouldInclude(state.key));
+    };
+
+    const start = async () => {
+      try {
+        this.status({ fill: 'yellow', shape: 'ring', text: 'connecting…' });
+        const [payloads, subjects, readRespMod, changeEventMod] = await loadModules();
+        const { ReadVariablesQueryResponse } = readRespMod;
+        const { VariablesChangedEvent } = changeEventMod;
+        const definitions = await connection.fetchProviderVariables(this.providerId);
+        definitions.forEach((def) => defMap.set(def.id, def));
+        nc = await connection.acquire();
+        this.status({ fill: 'green', shape: 'dot', text: 'connected' });
+
+        const snapshotMsg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(), { timeout: 2000 });
+        const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
+        const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
+        const states = payloads.decodeVariableList(snapshotObj.variables());
+        const filteredSnapshot = processStates(states);
+        if (filteredSnapshot.length) {
+          this.send({ payload: { type: 'snapshot', variables: filteredSnapshot } });
+        }
+
+        sub = nc.subscribe(subjects.varsChangedEvent(this.providerId));
+        (async () => {
+          for await (const msg of sub) {
+            const eventBB = new flatbuffers.ByteBuffer(msg.data);
+            const event = VariablesChangedEvent.getRootAsVariablesChangedEvent(eventBB);
+            const changeStates = payloads.decodeVariableList(event.changedVariables());
+            const filtered = processStates(changeStates);
+            if (filtered.length === 0) {
+              continue;
+            }
+            this.send({ payload: { type: 'change', variables: filtered } });
+          }
+        })().catch((err) => this.warn(`subscription error: ${err.message}`));
+      }
+      catch (err) {
+        this.status({ fill: 'red', shape: 'ring', text: 'error' });
+        this.error(err.message);
+      }
+    };
+
+    start();
+
+    this.on('close', async (done) => {
+      if (closed) {
+        done();
+        return;
+      }
+      closed = true;
+      try {
+        if (sub) {
+          await sub.drain();
+        }
+        await connection.release();
+      }
+      catch (err) {
+        this.warn(`closing error: ${err.message}`);
+      }
+      done();
+    });
+  }
+
+  RED.nodes.registerType('datahub-input', DataHubInputNode);
+};

package/nodes/datahub-output.html

@@ -0,0 +1,36 @@
+<script type="text/javascript">
+(function() {
+  RED.nodes.registerType('datahub-output', {
+    category: 'output',
+    color: '#ff9f43',
+    defaults: {
+      name: { value: '' },
+      connection: { type: 'uos-config', required: true },
+      providerId: { value: 'nodered', required: true }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'white/datahub-output.svg',
+    label: function() {
+      return this.name || `DataHub Output ${this.providerId || ''}`;
+    },
+    labelStyle: function() {
+      return this.name ? 'node_label_italic' : '';
+    }
+  });
+})();
+</script>
+
+<div class="form-row">
+  <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+  <input type="text" id="node-input-name">
+</div>
+<div class="form-row">
+  <label for="node-input-connection"><i class="fa fa-cube"></i> u-OS Config</label>
+  <input type="text" id="node-input-connection">
+</div>
+<div class="form-row">
+  <label for="node-input-providerId"><i class="fa fa-id-badge"></i> Provider ID</label>
+  <input type="text" id="node-input-providerId" placeholder="nodered">
+</div>
+<p>Send JSON payloads (including nested structures). The node auto-registers variables based on the object keys and publishes them to the configured provider. Nested objects become dot-separated keys (e.g. <code>folder.status</code>).</p>

package/nodes/datahub-output.js

@@ -0,0 +1,189 @@
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+const payloadModuleUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'payloads.js')).href;
+const subjectsModuleUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'subjects.js')).href;
+
+const loadModules = () => Promise.all([
+  import(payloadModuleUrl),
+  import(subjectsModuleUrl),
+]);
+
+const inferType = (value) => {
+  if (typeof value === 'boolean') return 'BOOLEAN';
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? 'INT64' : 'FLOAT64';
+  }
+  return 'STRING';
+};
+
+const defaultValue = (type) => {
+  switch (type) {
+    case 'BOOLEAN':
+      return false;
+    case 'INT64':
+    case 'FLOAT64':
+      return 0;
+    case 'STRING':
+    default:
+      return '';
+  }
+};
+
+const flattenPayload = (value, prefix = '') => {
+  const entries = [];
+  const path = (key) => (prefix ? `${prefix}.${key}` : key);
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    Object.entries(value).forEach(([key, val]) => {
+      entries.push(...flattenPayload(val, path(key)));
+    });
+  }
+  else if (Array.isArray(value)) {
+    value.forEach((val, idx) => {
+      entries.push(...flattenPayload(val, prefix ? `${prefix}[${idx}]` : `[${idx}]`));
+    });
+  }
+  else {
+    const keyName = prefix || 'value';
+    entries.push({ key: keyName, value });
+  }
+  return entries;
+};
+
+module.exports = function (RED) {
+  function DataHubOutputNode(config) {
+    RED.nodes.createNode(this, config);
+    const connection = RED.nodes.getNode(config.connection);
+    if (!connection) {
+      this.status({ fill: 'red', shape: 'ring', text: 'missing config' });
+      this.error('Please select a u-OS config node.');
+      return;
+    }
+    this.providerId = config.providerId || 'nodered';
+
+    const defMap = new Map();
+    const definitions = [];
+    const stateMap = new Map();
+    let nextId = 0;
+    let fingerprint = 0;
+    let nc;
+    let sub;
+
+    const ensureDefinition = (key, dataType) => {
+      const normalized = key.trim();
+      if (defMap.has(normalized)) {
+        return { def: defMap.get(normalized), created: false };
+      }
+      const def = {
+        id: nextId += 1,
+        key: normalized,
+        dataType,
+        access: 'READ_WRITE',
+      };
+      defMap.set(normalized, def);
+      definitions.push(def);
+      stateMap.set(def.id, {
+        id: def.id,
+        value: defaultValue(dataType),
+        timestampNs: Date.now() * 1_000_000,
+        quality: 'GOOD',
+      });
+      return { def, created: true };
+    };
+
+    const sendDefinitionUpdate = async (payloads, subjects) => {
+      const { payload, fingerprint: fp } = payloads.buildProviderDefinitionEvent(definitions);
+      fingerprint = fp;
+      await nc.publish(subjects.providerDefinitionChanged(this.providerId), payload);
+    };
+
+    const handleRead = async (payloads, msg) => {
+      if (!msg.reply)
+        return;
+      const snapshot = Array.from(stateMap.values());
+      const response = payloads.buildReadVariablesResponse(definitions, snapshot, fingerprint);
+      await nc.publish(msg.reply, response);
+    };
+
+    const start = async () => {
+      try {
+        this.status({ fill: 'yellow', shape: 'ring', text: 'connecting…' });
+        const [payloads, subjects] = await loadModules();
+        nc = await connection.acquire();
+        await sendDefinitionUpdate(payloads, subjects);
+        sub = nc.subscribe(subjects.readVariablesQuery(this.providerId), {
+          callback: (err, msg) => {
+            if (err) {
+              this.warn(`Read request error: ${err.message}`);
+              return;
+            }
+            handleRead(payloads, msg).catch((error) => this.warn(error.message));
+          },
+        });
+        this.status({ fill: 'green', shape: 'dot', text: 'ready' });
+
+        this.on('input', async (msg, send, done) => {
+          try {
+            if (!msg || !msg.payload || typeof msg.payload !== 'object') {
+              done(new Error('Payload must be an object describing your structure.'));
+              return;
+            }
+            const entries = flattenPayload(msg.payload);
+            if (!entries.length) {
+              done();
+              return;
+            }
+            const [payloadsMod, subjectsMod] = await loadModules();
+            let definitionsChanged = false;
+            const states = [];
+            entries.forEach(({ key, value }) => {
+              const { def, created } = ensureDefinition(key, inferType(value));
+              if (created) {
+                definitionsChanged = true;
+              }
+              const state = {
+                id: def.id,
+                value,
+                timestampNs: Date.now() * 1_000_000,
+                quality: 'GOOD',
+              };
+              states.push(state);
+              stateMap.set(def.id, state);
+            });
+            if (definitionsChanged) {
+              await sendDefinitionUpdate(payloadsMod, subjectsMod);
+            }
+            const payload = payloadsMod.buildVariablesChangedEvent(definitions, states, fingerprint);
+            await nc.publish(subjectsMod.varsChangedEvent(this.providerId), payload);
+            send(msg);
+            done();
+          }
+          catch (err) {
+            done(err);
+          }
+        });
+      }
+      catch (err) {
+        this.status({ fill: 'red', shape: 'ring', text: 'error' });
+        this.error(err.message);
+      }
+    };
+
+    start();
+
+    this.on('close', async (done) => {
+      try {
+        if (sub) {
+          await sub.drain();
+        }
+        await connection.release();
+      }
+      catch (err) {
+        this.warn(`closing error: ${err.message}`);
+      }
+      done();
+    });
+  }
+
+  RED.nodes.registerType('datahub-output', DataHubOutputNode);
+};

package/nodes/uos-config.html

@@ -0,0 +1,48 @@
+<script type="text/javascript">
+  RED.nodes.registerType('uos-config', {
+    category: 'config',
+    defaults: {
+      host: { value: '192.168.10.100', required: true },
+      port: { value: 49360, required: true, validate: RED.validators.number() },
+      clientName: { value: 'nodered', required: true },
+      tokenEndpoint: { value: '', required: false },
+      scope: { value: 'hub.variables.provide hub.variables.readwrite', required: true },
+    },
+    credentials: {
+      clientId: { type: 'text', required: true },
+      clientSecret: { type: 'password', required: true },
+    },
+    label: function () {
+      return this.clientName ? `u-OS ${this.clientName}` : 'u-OS NATS';
+    },
+  });
+</script>
+
+<div class="form-row">
+  <label for="node-config-input-host"><i class="fa fa-globe"></i> Host</label>
+  <input type="text" id="node-config-input-host" placeholder="127.0.0.1">
+</div>
+<div class="form-row">
+  <label for="node-config-input-port"><i class="fa fa-plug"></i> Port</label>
+  <input type="number" id="node-config-input-port">
+</div>
+<div class="form-row">
+  <label for="node-config-input-clientName"><i class="fa fa-user"></i> Client Name</label>
+  <input type="text" id="node-config-input-clientName" placeholder="nodered">
+</div>
+<div class="form-row">
+  <label for="node-config-input-clientId"><i class="fa fa-id-card"></i> Client ID</label>
+  <input type="text" id="node-config-input-clientId">
+</div>
+<div class="form-row">
+  <label for="node-config-input-clientSecret"><i class="fa fa-key"></i> Client Secret</label>
+  <input type="password" id="node-config-input-clientSecret">
+</div>
+<div class="form-row">
+  <label for="node-config-input-tokenEndpoint"><i class="fa fa-lock"></i> Token URL</label>
+  <input type="text" id="node-config-input-tokenEndpoint" placeholder="https://HOST/oauth2/token">
+</div>
+<div class="form-row">
+  <label for="node-config-input-scope"><i class="fa fa-list"></i> Scope</label>
+  <input type="text" id="node-config-input-scope">
+</div>