node-red-contrib-uos-nats 0.2.97 → 0.2.99

package/lib/payloads.js

@@ -130,22 +130,31 @@ export function encodeWriteVariablesCommand(variables) {
         // If targetType is provided, force specific flatbuffer encoding
         if (targetType) {
             targetType = String(targetType).toUpperCase();
-            if (targetType === 'BOOLEAN') {
+
+            if (targetType === 'BOOLEAN' || targetType === 'BOOL') {
                 const boolVal = new VariableValueBooleanT();
                 boolVal.value = Boolean(val);
                 varT.value = boolVal;
                 varT.valueType = VariableValue.Boolean;
-            } else if (targetType === 'INT64') {
+            }
+            else if (['INT8', 'INT16', 'INT32', 'INT64', 'UINT8', 'UINT16', 'UINT32', 'UINT64', 'BYTE', 'SINT', 'USINT', 'INT', 'DINT', 'LINT', 'UDINT', 'ULINT', 'WORD', 'DWORD', 'LWORD'].some(t => targetType.includes(t))) {
                 const intVal = new VariableValueInt64T();
-                intVal.value = BigInt(parseInt(val) || 0); // Ensure BigInt
+                // Handle BigInt for large values, fallback to parseInt
+                try {
+                    intVal.value = BigInt(val);
+                } catch {
+                    intVal.value = BigInt(parseInt(val) || 0);
+                }
                 varT.value = intVal;
                 varT.valueType = VariableValue.Int64;
-            } else if (targetType === 'FLOAT64') {
+            }
+            else if (['FLOAT', 'DOUBLE', 'REAL', 'LREAL'].some(t => targetType.includes(t))) {
                 const floatVal = new VariableValueFloat64T();
                 floatVal.value = Number(val);
                 varT.value = floatVal;
                 varT.valueType = VariableValue.Float64;
-            } else {
+            }
+            else {
                 // STRING or default
                 const strVal = new VariableValueStringT();
                 strVal.value = (typeof val === 'object') ? JSON.stringify(val) : String(val);

package/nodes/datahub-write.html

@@ -157,12 +157,19 @@
                 const hasId = $inputId.val();
                 const hasKey = $inputKey.val();
                 if (!hasId && !hasKey) {
-                    $('#var-validation-error').show();
+                    // Valid in Batch Mode?
+                    // We can show a hint that batch mode is active if nothing selected.
+                    $('#var-validation-error').hide();
+                    $('#batch-mode-hint').show();
                 } else {
                     $('#var-validation-error').hide();
+                    $('#batch-mode-hint').hide();
                 }
             };
             $inputId.on('change keyup', validateVar);
+
+            // Initial check
+            validateVar();
         },
         oneditsave: function () {
             // Nothing special to save, inputs are handled automatically
@@ -219,7 +226,12 @@
     <input type="hidden" id="node-input-variableKey">
 
     <div id="var-validation-error" class="form-tips" style="display:none; color:#c00; margin-top:10px;">
-        <i class="fa fa-warning"></i> <b>Please select a variable from the list.</b>
+        <i class="fa fa-warning"></i> <b>Please select a variable (or rely on Batch Mode via JSON).</b>
+    </div>
+    
+    <div id="batch-mode-hint" class="form-tips" style="display:none; color:#666; margin-top:10px;">
+        <i class="fa fa-info-circle"></i> <b>No variable selected.</b> Node enters <b>Batch Mode</b>.<br>
+        Send a JSON object (<code>{"key": value}</code>) to write variables dynamically.
     </div>
 
     <div class="form-tips" style="margin-top:10px;">
@@ -244,24 +256,29 @@
     <p>The target provider to write to (e.g., <code>u_os_adm</code>, <code>u_os_sbm</code>).</p>
     <p><b>Find it:</b> u-OS Web UI → Data Hub → Providers</p>
 
-    <h4>Select Variable</h4>
-    <p>Click <b>Load Variables</b> to browse the provider's writable variables.</p>
-    <p>Select a variable from the list to automatically target it.</p>
+    <h4>Select Variable (Single Mode)</h4>
+    <p>Click <b>Load Variables</b> to browse. Select a variable to target it specifically.</p>
+    <p>If selected, <code>msg.payload</code> is written as the value.</p>
+    
+    <h4>Batch Mode (Dynamic)</h4>
+    <p>If <b>NO variable is selected</b>, you can write multiple variables by sending a JSON object:</p>
+    <pre><code>msg.payload = {
+  "machine.status": true,
+  "machine.speed": 100
+};</code></pre>
+    <p>The node resolves keys to IDs automatically.</p>
 
     <h3>Input Format</h3>
     <p>Send the new value as <code>msg.payload</code>:</p>
 
-    <h4>Example: Toggle Boolean</h4>
-    <pre><code>msg.payload = false;
-return msg;</code></pre>
-
-    <h4>Example: Update Number</h4>
-    <pre><code>msg.payload = 42.5;
-return msg;</code></pre>
+    <h4>Example: Single Write</h4>
+    <pre><code>msg.payload = false;</code></pre>
 
-    <h4>Example: Change String</h4>
-    <pre><code>msg.payload = "stopped";
-return msg;</code></pre>
+    <h4>Example: Batch Write (JSON)</h4>
+    <pre><code>msg.payload = {
+  "channel_0.do": true,
+  "channel_1.do": false
+};</code></pre>
 
     <h3>Output</h3>
     <p>Outputs a confirmation message when the write command is sent:</p>

package/nodes/datahub-write.js

@@ -125,9 +125,9 @@ module.exports = function (RED) {
 
         // Handle incoming messages
         node.on('input', async function (msg) {
-            const value = msg.payload;
+            const rawPayload = msg.payload;
 
-            if (value === undefined || value === null) {
+            if (rawPayload === undefined || rawPayload === null) {
                 node.warn('msg.payload is empty, nothing to write');
                 return;
             }
@@ -146,44 +146,128 @@ module.exports = function (RED) {
                     return;
                 }
 
-                // Resolve variable ID if needed
-                let varId = node.resolvedId;
-                let varType = node.resolvedDataType;
+                // Prepare list of variables to write
+                let varsToWrite = [];
+
+                // MODE 1: Batch Write (Object or Array) AND no configured single variable
+                // If the user configured a Provider but NOT a Variable ID/Key, we assume Dynamic Mode.
+                // OR if the user configured a Variable, we strictly use that (Single Mode).
+                const isSingleMode = (node.variableId !== null || !!node.variableKey);
+
+                if (!isSingleMode && typeof rawPayload === 'object' && !Buffer.isBuffer(rawPayload)) {
+                    // Normalize input to Array of { key/id, value }
+                    let items = [];
+                    if (Array.isArray(rawPayload)) {
+                        // Array: [{id:1, value:val}, {key:'k', value:val}]
+                        items = rawPayload;
+                    } else {
+                        // Object: { "key": val, "id:1": val }
+                        items = Object.entries(rawPayload).map(([k, v]) => {
+                            // Detect if key is actually an ID (e.g. "5" or "id:5")? 
+                            // Easier: treat all keys as Keys, unless user passes explicit Array.
+                            // But user map might be { "1": val, "machine.temp": val }.
+                            // We can check if k is Int.
+                            const asInt = parseInt(k, 10);
+                            if (!isNaN(asInt) && String(asInt) === k) {
+                                return { id: asInt, value: v };
+                            }
+                            return { key: k, value: v };
+                        });
+                    }
 
-                if (!varId && node.variableKey) {
-                    node.status({ fill: 'yellow', shape: 'dot', text: 'resolving key...' });
-                    const resolved = await resolveVariableKey(nc, node.providerId, node.variableKey, node, node.payloads);
-                    varId = resolved.id;
-                    varType = resolved.dataType; // Store resolved type
+                    // Process Items
+                    for (const item of items) {
+                        let targetId = item.id;
+                        let targetType = item.dataType; // Optional explicit type
+
+                        if (targetId === undefined) {
+                            if (item.key) {
+                                // Resolve Key
+                                try {
+                                    const resolved = await resolveVariableKey(nc, node.providerId, item.key, node, node.payloads);
+                                    targetId = resolved.id;
+                                    // Use resolved type if not explicit
+                                    if (!targetType) targetType = resolved.dataType;
+                                } catch (e) {
+                                    node.warn(`Skipping key '${item.key}': ${e.message}`);
+                                    continue;
+                                }
+                            } else {
+                                node.warn(`Skipping item without id or key: ${JSON.stringify(item)}`);
+                                continue;
+                            }
+                        }
+
+                        varsToWrite.push({
+                            id: targetId,
+                            value: item.value,
+                            dataType: targetType
+                        });
+                    }
 
-                    node.resolvedId = varId;
-                    node.resolvedDataType = varType;
-                    node.status({ fill: 'green', shape: 'ring', text: 'ready' });
-                }
+                    if (varsToWrite.length === 0) {
+                        node.warn("No valid variables found in batch payload");
+                        return;
+                    }
 
-                // Build write command
-                const writeCommand = node.payloads.encodeWriteVariablesCommand([
-                    {
-                        id: varId,
-                        value: value,
-                        dataType: varType // Pass dataType for strict encoding
+                } else {
+                    // MODE 2: Single Mode (Configured in Node or Primitive Payload)
+                    // If Single Mode is active, we IGNORE the structure of obj/array and write the WHOLE msg.payload 
+                    // to the configured target variable. (e.g. payload IS the value).
+                    // UNLESS strict check? No, standard behavior is payload=value.
+
+                    if (!isSingleMode) {
+                        // No variable configured and primitive payload? Error.
+                        node.error("Configuration Error: No Variable configured and payload is not a batch object.");
+                        return;
+                    }
+
+                    // Resolve variable ID if needed
+                    let varId = node.resolvedId;
+                    let varType = node.resolvedDataType;
+
+                    if (!varId && node.variableKey) {
+                        node.status({ fill: 'yellow', shape: 'dot', text: 'resolving key...' });
+                        const resolved = await resolveVariableKey(nc, node.providerId, node.variableKey, node, node.payloads);
+                        varId = resolved.id;
+                        varType = resolved.dataType;
+                        node.resolvedId = varId;
+                        node.resolvedDataType = varType;
+                        node.status({ fill: 'green', shape: 'ring', text: 'ready' });
                     }
-                ]);
+
+                    varsToWrite.push({
+                        id: varId,
+                        value: rawPayload,
+                        dataType: varType
+                    });
+                }
+
+                // Build write command (Flatbuffer)
+                // varsToWrite: [{id, value, dataType}]
+                const writeCommand = node.payloads.encodeWriteVariablesCommand(varsToWrite);
 
                 // Publish write command
                 const subject = `v1.loc.${node.providerId}.vars.cmd.write`;
                 nc.publish(subject, writeCommand);
 
-                node.status({ fill: 'green', shape: 'dot', text: `wrote: ${value}` });
+                const count = varsToWrite.length;
+                node.status({ fill: 'green', shape: 'dot', text: `wrote ${count} var(s)` });
 
                 // Output confirmation
                 msg.payload = {
                     success: true,
                     providerId: node.providerId,
-                    variableId: varId,
-                    variableKey: node.variableKey || null,
-                    value: value
+                    count: count,
+                    firstValue: varsToWrite[0].value
                 };
+                // If single write, maintain legacy output structure for compatibility?
+                if (isSingleMode) {
+                    msg.payload.variableId = varsToWrite[0].id;
+                    msg.payload.variableKey = node.variableKey || null;
+                    msg.payload.value = varsToWrite[0].value;
+                }
+
                 node.send(msg);
 
             } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-uos-nats",
-  "version": "0.2.97",
+  "version": "0.2.99",
   "description": "Node-RED nodes for Weidmüller u-OS Data Hub. Read, write, and provide variables via NATS protocol with OAuth2 authentication. Features: Variable Key resolution, custom icons, example flows, and provider definition caching.",
   "author": {
     "name": "IoTUeli",