@bldgblocks/node-red-contrib-control 0.1.33 → 0.1.36

package/nodes/global-getter.js

@@ -1,9 +1,11 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function GlobalGetterNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
         node.targetNodeId = config.targetNode;
         node.outputProperty = config.outputProperty || "payload";
+        node.dropdownPath = config.dropdownPath || "";
         node.updates = config.updates;
         node.detail = config.detail;
         
@@ -15,148 +17,153 @@ module.exports = function(RED) {
         const retryDelays = [0, 100, 500, 1000, 2000, 4000, 8000, 16000];
         const maxRetries = retryDelays.length - 1;
         
-        // --- Process Wrapper and Send Msg ---
-        function sendValue(storedObject, msgToReuse) {
-            const msg = msgToReuse || {}; 
+        // --- Output Helper ---
+        function sendValue(storedObject, msgToReuse, done) {
+            const msg = RED.util.cloneMessage(msgToReuse) || {};
 
             if (storedObject !== undefined && storedObject !== null) {
-                
-                // CHECK: Is this our Wrapper Format? (Created by Global Setter)
+                // Check if this is our custom wrapper object
                 if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value')) {                    
-
-                    // Merge all attributes onto the msg root
-                    // This automatically handles priority, units, metadata, and any future fields
                     if (node.detail === "getObject") {
                         Object.assign(msg, storedObject);
                     }
-
-                    // Set the Main Output (e.g. msg.payload = 75)
-                    RED.util.setMessageProperty(msg, node.outputProperty, storedObject.value);
-
+                    if (config.outputPropertyType === "flow" || config.outputPropertyType === "dropdown") {
+                        if (config.outputProperty === "sourceToFlow") {
+                            node.context().flow.set(node.dropdownPath, storedObject.value);
+                        } else {
+                            node.context().flow.set(node.outputProperty, storedObject.value);
+                        }
+                    } else {
+                        RED.util.setMessageProperty(msg, node.outputProperty, storedObject.value);
+                    }
                 } else {
-                    // Handle Legacy/Raw values (not created by Setter)
-                    RED.util.setMessageProperty(msg, node.outputProperty, storedObject);
+                    // Legacy/Raw values
+                    if (config.outputPropertyType === "flow" || config.outputPropertyType === "dropdown") {
+                        if (config.outputProperty === "sourceToFlow") {
+                            node.context().flow.set(node.dropdownPath, storedObject);
+                        } else {
+                            node.context().flow.set(node.outputProperty, storedObject);
+                        }
+                    } else {
+                        RED.util.setMessageProperty(msg, node.outputProperty, storedObject);
+                    }
                     msg.metadata = { path: setterNode ? setterNode.varName : "unknown", legacy: true };
                 }
                 
-                // Update Status
-                let valDisplay = RED.util.getMessageProperty(msg, node.outputProperty);
-                valDisplay = typeof valDisplay === "number" ? valDisplay : valDisplay;
-                node.status({ fill: "blue", shape: "dot", text: `get: ${valDisplay}` });
+                let valDisplay = storedObject.value;
+                if (valDisplay === null) valDisplay = "null";
+                else if (valDisplay === undefined) valDisplay = "undefined";
+                else if (typeof valDisplay === "object") valDisplay = JSON.stringify(valDisplay);
+                else valDisplay = typeof valDisplay === "number" ? valDisplay : valDisplay;
                 
-                node.send(msg);
-
+                // Trim to 64 characters with ellipsis
+                if (valDisplay.length > 64) {
+                    valDisplay = valDisplay.substring(0, 64) + "...";
+                }
+                
+                utils.sendSuccess(node, msg, done, `get: ${valDisplay}`, null, "dot");
             } else {
-                node.status({ fill: "red", shape: "ring", text: "global variable undefined" });
+                utils.sendError(node, msg, done, "global variable undefined");
             }
         }
 
-        // --- Manage Event Subscription ---
+        // --- Connection Logic ---
         function establishListener() {
-            // Look for source node
             setterNode = RED.nodes.getNode(node.targetNodeId);
             
-            // If found, subscribe
             if (setterNode && setterNode.varName && node.updates === 'always') {
                 if (updateListener) {
-                    // Remove existing listener if we're retrying
-                    RED.events.removeListener("bldgblocks-global-update", updateListener);
+                    RED.events.removeListener("bldgblocks:global:value-changed", updateListener);
                 }
                 
                 updateListener = function(evt) {
                     if (evt.key === setterNode.varName && evt.store === setterNode.storeName) {
-                        sendValue(evt.data, {}); 
+                        // Event Trigger: Pass null for done, as it's not a node input
+                        sendValue(evt.data, {}, null); 
                     }
                 };
                 
-                RED.events.on("bldgblocks-global-update", updateListener);
+                RED.events.on("bldgblocks:global:value-changed", updateListener);
                 
-                // Clear retry interval once successful
                 if (retryAction) {
                     clearInterval(retryAction);
                     retryAction = null;
                 }
                 
-                node.status({ fill: "green", shape: "dot", text: "Connected" });
+                utils.setStatusOK(node, "Connected");
                 return true;
             }
             return false;
         }
 
-        // --- Maintain event subscription ---
         function startHealthCheck() {
-            const healthCheckAction = () => {
-                const listeners = RED.events.listeners("bldgblocks-global-update");
+            const check = () => {
+                const listeners = RED.events.listeners("bldgblocks:global:value-changed");
                 const hasOurListener = listeners.includes(updateListener);
-                
                 if (!hasOurListener) {
                     node.warn("Event listener lost, reconnecting...");
                     if (establishListener()) {
-                        node.status({ fill: "green", shape: "dot", text: "Reconnected" });
+                        utils.setStatusOK(node, "Reconnected");
                     }
                 }
-                
-                // Schedule next health check regardless of outcome
-                setTimeout(healthCheckAction, 30000);
+                setTimeout(check, 30000);
             };
-            // Inital start
-            setTimeout(healthCheckAction, 30000);
+            setTimeout(check, 30000);
         }
 
         function subscribeWithRetry() {
-            // Recursive retry
             retryAction = () => {
                 if (retryCount >= maxRetries) {
-                    node.error("Failed to connect to setter node after multiple attempts");
-                    node.status({ fill: "red", shape: "ring", text: "Connection failed" });
+                    utils.sendError(node, null, null, "Connection failed");
                     return;
                 }
-                
                 if (establishListener()) {
                     retryCount = 0;
-                    return; // Success
+                    return; 
                 }
-                
                 retryCount++;
                 setTimeout(retryAction, retryDelays[Math.min(retryCount, maxRetries - 1)]);
             };
-            
             setTimeout(retryAction, retryDelays[0]);
         }
 
-        // --- HANDLE MANUAL INPUT ---
-        node.on('input', function(msg, send, done) {
+        // --- INPUT HANDLER ---
+        node.on('input', async function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
-            setterNode ??= RED.nodes.getNode(node.targetNodeId);
+            try {
+                setterNode ??= RED.nodes.getNode(node.targetNodeId);
 
-            if (setterNode && setterNode.varName) {
-                const storedObject = node.context().global.get(setterNode.varName, setterNode.storeName);
-                sendValue(storedObject, msg);
-            } else {
-                node.warn("Source node not found or not configured.");
-                node.status({ fill: "red", shape: "ring", text: "Source node not found" });
+                if (setterNode && setterNode.varName) {
+                    // Async Get - required default store to keep values in memory for polled getter nodes. 
+                    // 'persistent' for cross reboot storage.
+                    let storedObject = await utils.getGlobalState(node, setterNode.varName, 'default');
+                    if (!storedObject) {
+                        // Fallback to persistent store if not found in default. Should not happen normally.
+                        storedObject = await utils.getGlobalState(node, setterNode.varName, setterNode.storeName);
+                    }
+                    sendValue(storedObject, msg, done);
+                } else {
+                    node.warn("Source node not found or not configured.");
+                    utils.sendError(node, msg, done, "Source node not found");
+                }
+            } catch (err) {
+                node.error(err);
+                utils.sendError(node, msg, done, `Internal Error: ${err.message}`);
             }
-            
-            if (done) done();
         });
 
-        // --- HANDLE REACTIVE UPDATES ---
+        // --- INIT ---
         if (node.updates === 'always') {
             subscribeWithRetry();
             startHealthCheck();        
         }
 
-        // --- CLEANUP ---
         node.on('close', function(removed, done) {
-            if (healthCheckAction) {
-                clearInterval(healthCheckAction);
-            }
-            if (retryAction) {
-                clearInterval(retryAction);
-            }
+            if (healthCheckAction) clearInterval(healthCheckAction);
+            if (retryAction) clearInterval(retryAction);
             if (removed && updateListener) {
-                RED.events.removeListener("bldgblocks-global-update", updateListener);
+                RED.events.removeListener("bldgblocks:global:value-changed", updateListener);
             }
             done();
         });

package/nodes/global-setter.html

@@ -5,7 +5,7 @@
     </div>
     <div class="form-row">
         <label for="node-input-path"><i class="fa fa-sitemap"></i> Global Path</label>
-        <input type="text" id="node-input-path" style="width: 70%;" placeholder="furnace/outputs/heat">
+        <input type="text" id="node-input-path" placeholder="furnace/outputs/heat">
     </div>
     <div class="form-row">
         <label for="node-input-property"><i class="fa fa-ellipsis-h"></i> Input</label>