@bldgblocks/node-red-contrib-control 0.1.32 → 0.1.34

package/nodes/network-point-registry.js

@@ -0,0 +1,90 @@
+module.exports = function(RED) {
+    function NetworkPointRegistryNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // The Map: { 101: { nodeId: "abc.123", writable: true, ... } }
+        node.points = new Map();
+
+        node.register = function(pointId, meta) {
+            const pid = parseInt(pointId);
+            if (isNaN(pid)) return false;
+
+            if (node.points.has(pid)) {
+                const existing = node.points.get(pid);
+                // Allow update if it's the same node
+                if (existing.nodeId !== meta.nodeId) {
+                    return false;
+                }
+                // Merge updates
+                meta = Object.assign({}, existing, meta);
+            }
+            node.points.set(pid, meta);
+            return true;
+        };
+
+        node.unregister = function(pointId, nodeId) {
+            const pid = parseInt(pointId);
+            if (node.points.has(pid) && node.points.get(pid).nodeId === nodeId) {
+                node.points.delete(pid);
+            }
+        };
+
+        node.lookup = function(pointId) {
+            return node.points.get(parseInt(pointId));
+        };
+    }
+    RED.nodes.registerType("network-point-registry", NetworkPointRegistryNode);
+
+    // --- HTTP Endpoint for Editor Validation ---
+    // Route: /network-point-registry/check/<RegistryID>/<PointID>/<CurrentNodeID>
+    RED.httpAdmin.get('/network-point-registry/check/:registryId/:pointId/:nodeId', RED.auth.needsPermission('network-point-registry.read'), function(req, res) {
+        const registryId = req.params.registryId;
+        const checkId = parseInt(req.params.pointId);
+        const checkNodeId = req.params.nodeId;
+        
+        // Find the specific Registry Config Node
+        const regNode = RED.nodes.getNode(registryId);
+
+        let entry = null;
+        let result = "unavailable";
+        let collision = false;
+
+        if (!regNode) {
+            // Registry exists in editor but not deployed yet, or doesn't exist
+            return res.json({ status: result, warning: "Registry not deployed" });
+        }
+
+        // Check that specific registry for the ID
+        if (regNode.points.has(checkId)) {
+            entry = regNode.points.get(checkId);
+            // Collision if ID exists AND belongs to a different node
+            if (entry.nodeId !== checkNodeId) {
+                collision = true;
+            }
+        }
+
+        if (collision) {
+            result = "collision";
+        } else if (!collision && entry) {
+            result = "assigned";
+        } else{
+            result = "available";
+        }
+
+        res.json({ status: result, details: entry });
+    });
+
+
+    RED.httpAdmin.get('/network-point-registry/list/:registryId', RED.auth.needsPermission('network-point-registry.read'), function(req, res) {
+        const reg = RED.nodes.getNode(req.params.registryId);
+        if (!reg) return res.status(404).json({error:'not found'});
+
+        // Convert Map to array
+        const arr = [];
+        for (const [pid, meta] of reg.points.entries()) {
+            arr.push({ id: pid, ...meta });
+        }
+        res.json(arr);
+    });
+};

package/nodes/network-read.html

@@ -0,0 +1,56 @@
+<script type="text/html" data-template-name="network-read">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-registry"><i class="fa fa-book"></i> Registry</label>
+        <input type="text" id="node-input-registry">
+    </div>
+    
+    <div class="form-tips">
+        <b>Input Payload Format:</b><br>
+        <pre>
+        {
+            "action": "read",
+            "pointId": 101
+        }
+        </pre>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('network-read', {
+        category: 'bldgblocks network',
+        color: '#3090C7',
+        defaults: {
+            name: { value: "" },
+            registry: { value: "", type: "network-point-registry", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-database",
+        label: function() {
+            return "network read";
+        },
+        paletteLabel: "network read",
+        oneditprepare: function() {
+            const nodeId = this.id;
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="network-read">
+Reads a network point by pointId.
+
+### Input
+  : action (string) : Not used by the node, used for routing to the correct node over the network when received.
+  : pointId (number) : The integer ID of the point.
+
+### Output
+: payload (object) : Global data object
+
+### Details
+
+</script>

package/nodes/network-read.js

@@ -0,0 +1,57 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+    function NetworkReadNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.registry = RED.nodes.getNode(config.registry);
+
+        node.on("input", async function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            
+            try {
+                if (!node.registry) {
+                    node.status({ fill: "red", shape: "ring", text: "Registry missing" });
+                    if (done) done();
+                    return;
+                }
+
+                const currentEntry = node.registry.lookup(msg.pointId);
+                if (!currentEntry) {
+                    return utils.sendError(node, msg, done, `Not Registered: ${msg.pointId}`, msg.pointId);
+                }
+                
+                const currentPath = currentEntry.path;
+                const currentStore = currentEntry.store || "default";
+
+                // Async Get
+                let globalData = await utils.getGlobalState(node, currentPath, currentStore);
+
+                if (!globalData || Object.keys(globalData).length === 0) { 
+                    return utils.sendError(node, msg, done, `Global Data Empty: ${msg.pointId}`, msg.pointId);
+                }
+
+                msg = { ...globalData };
+                
+                const ptName = msg.metadata?.name ?? "Unknown";
+                const ptVal = msg.value !== undefined ? msg.value : "No Value";
+                const ptId = msg.network?.pointId ?? msg.pointId;
+
+                const msgText = `Data Found. pointId: ${ptId} value: ${ptVal}`;
+                
+                utils.sendSuccess(node, msg, done, msgText, ptId, "ring");
+
+            } catch (err) {
+                node.error(err);
+                utils.sendError(node, msg, done, `Internal Error: ${err.message}`, msg?.pointId);
+            }
+        });
+
+        node.on('close', function(removed, done) {
+            if (removed && node.registry) {
+                node.registry.unregister(node.pointId, node.id);
+            }
+            done();
+        });
+    }
+    RED.nodes.registerType("network-read", NetworkReadNode);
+}

package/nodes/network-register.html

@@ -0,0 +1,110 @@
+<script type="text/html" data-template-name="network-register">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-registry" title="A group of id's for assignment organization"><i class="fa fa-book"></i> Registry</label>
+        <input type="text" id="node-input-registry">
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-pointId" title="Simple, stable, and unique lookup id for network users."><i class="fa fa-hashtag"></i> Point ID</label>
+        <div style="display: inline-block; width: 70%;">
+            <input type="number" id="node-input-pointId" placeholder="e.g. 101" style="width: 100px;">
+            <span id="point-id-status" style="margin-left: 10px; display: none;"></span>
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-writable"><i class="fa fa-pencil"></i> Writable</label>
+        <input type="checkbox" id="node-input-writable" style="display: inline-block; width: auto; vertical-align: top;">
+        <span style="color: #666;"> Allow network to write to this point?</span>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('network-register', {
+        category: 'bldgblocks network',
+        color: '#3090C7',
+        defaults: {
+            name: { value: "" },
+            registry: { value: "", type: "network-point-registry", required: true },
+            pointId: { value: null, required: true, validate: RED.validators.number() },
+            writable: { value: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-book",
+        label: function() {
+            const id = this.pointId || "?";
+            return `(id:${id}) ${this.name || "network register"}`;
+        },
+        paletteLabel: "network register",
+        oneditprepare: function() {
+            const nodeId = this.id;
+            const statusSpan = $("#point-id-status");
+            const idInput = $("#node-input-pointId");
+            const regInput = $("#node-input-registry");
+
+            let timer = null;
+
+            function checkId() {
+                const node = this;
+                const pid = idInput.val();
+                const rid = regInput.val();
+
+                statusSpan.hide();
+                idInput.removeClass("input-error");
+                
+                if (timer) clearTimeout(timer);
+
+                // Need both ID and Registry selected to validate
+                if (pid && rid && rid !== "_ADD_") {
+                    timer = setTimeout(() => {
+                        // Pass Registry ID in URL
+                        $.getJSON(`network-point-registry/check/${rid}/${pid}/${nodeId}`, function(data) {
+                            if (data.warning) {
+                                // Registry exists in config but not deployed
+                                statusSpan.html(`<i class="fa fa-question-circle" style="color: orange;" title="${data.warning}"></i> Not Deployed`).show();
+                            } else if (data.status === "collision") {
+                                // Conflict
+                                statusSpan.html('<i class="fa fa-exclamation-triangle" style="color: red;"></i> ID Taken').show();
+                                idInput.addClass("input-error");
+                            } else if (data.status === "assigned") {
+                                // Assigned here
+                                statusSpan.html('<i class="fa fa-check" style="color: green;"></i> Assigned').show();
+                            } else {
+                                // Available
+                                statusSpan.html('<i class="fa fa-check" style="color: green;"></i> Available').show();
+                            }
+                        });
+                    }, 500);
+                }
+            }
+
+            function loadNextFreeId(registry) {
+                if (!registry || registry === "_ADD_") { return; }
+                $.getJSON(`/network-point-registry/list/${registry}`, function (data) {
+                    const next = data.reduce((max, pt) => Math.max(max, pt.id), 0) + 1;        
+                    idInput.val(next);
+                }).fail(function () {
+                    statusSpan.html('<i class="fa fa-exclamation-triangle" style="color:red;"></i> Cannot fetch points').show();
+                });
+            }
+
+            // Trigger check on ID type or Registry Change
+            idInput.on("input", checkId);
+            regInput.on("change", function () {
+                checkId();
+                if (idInput.val().trim() === "") {
+                    loadNextFreeId(regInput.val());
+                }
+            });
+            
+            if (idInput.val().trim() === "") {
+                loadNextFreeId(regInput.val());
+            }
+        }
+    });
+</script>

package/nodes/network-register.js

@@ -0,0 +1,112 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+    function NetworkRegisterNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.registry = RED.nodes.getNode(config.registry);
+        node.pointId = parseInt(config.pointId);
+        node.writable = !!config.writable;
+        node.isRegistered = false;
+
+        // Initial Registration
+        if (node.registry && !isNaN(node.pointId)) {
+            const success = node.registry.register(node.pointId, {
+                nodeId: node.id, 
+                writable: node.writable,
+                path: "not ready",
+                store: "not ready"
+            });
+
+            if (success) {
+                node.isRegistered = true;
+                node.status({ fill: "yellow", shape: "ring", text: `ID: ${node.pointId} (Waiting)` });
+            } else {
+                node.error(`Point ID ${node.pointId} is already in use.`);
+                node.status({ fill: "red", shape: "dot", text: "ID Conflict" });
+            }
+        }
+
+        node.on("input", async function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            try {
+                // Pre-flight
+                if (!node.isRegistered) return utils.sendError(node, null, done, "Node not registered");
+                if (!msg || typeof msg !== "object") return utils.sendError(node, null, done, "Invalid msg object");
+                if (!node.registry) return utils.sendError(node, msg, done, "Registry config missing", node.pointId);
+
+                // Validate Fields
+                if (!msg.activePriority || !msg.metadata?.path || !msg.metadata?.store) {
+                     return utils.sendError(node, msg, done, "Missing required fields (metadata.path/store, activePriority)", node.pointId);
+                }
+
+                // Logic & State Update
+                let pointData = node.registry.lookup(node.pointId);
+
+                const incoming = {
+                    writable: node.writable,
+                    path: msg.metadata.path,
+                    store: msg.metadata.store
+                };
+
+                const needsUpdate = !pointData 
+                    || pointData.nodeId !== node.id 
+                    || pointData.writable !== incoming.writable 
+                    || pointData.path !== incoming.path 
+                    || pointData.store !== incoming.store;
+
+                if (needsUpdate) {
+                    node.registry.register(node.pointId, {
+                        nodeId: node.id, 
+                        writable: node.writable,
+                        path: incoming.path,
+                        store: incoming.store
+                    });
+                    
+                    pointData = node.registry.lookup(node.pointId);
+                    const currentStore = pointData.store || "default";
+
+                    // Async Get
+                    const globalData = await utils.getGlobalState(node, pointData.path, currentStore);
+
+                    if (!globalData || Object.keys(globalData).length === 0) { 
+                        return utils.sendError(node, msg, done, `Global missing: (${currentStore})::${pointData.path}`, node.pointId);
+                    }
+
+                    const networkObject = { 
+                        ...globalData, 
+                        network: {
+                            registry: node.registry.name,
+                            pointId: node.pointId,
+                            writable: node.writable
+                        }
+                    };
+                    
+                    // Async Set
+                    await utils.setGlobalState(node, pointData.path, currentStore, networkObject);
+
+                    const statusText = `Registered: (${currentStore})::${pointData.path}::${node.pointId}`;
+                    return utils.sendSuccess(node, networkObject, done, statusText, node.pointId, "dot");
+                }
+
+                // Passthrough
+                const prefix = msg.activePriority === 'default' ? '' : 'P';
+                const statusText = `Passthrough: ${prefix}${msg.activePriority}:${msg.value}${msg.units}`;
+                utils.sendSuccess(node, msg, done, statusText, node.pointId, "ring");
+
+            } catch (err) {
+                node.error(err);
+                utils.sendError(node, msg, done, `Internal Error: ${err.message}`, node.pointId);
+            }
+        });
+
+        node.on('close', function(removed, done) {
+            if (removed && node.registry && node.isRegistered) {
+                node.registry.unregister(node.pointId, node.pointId);
+            }
+            done();
+        });
+    }
+    RED.nodes.registerType("network-register", NetworkRegisterNode);
+}

package/nodes/network-write.html

@@ -0,0 +1,65 @@
+<script type="text/html" data-template-name="network-write">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-registry"><i class="fa fa-book"></i> Registry</label>
+        <input type="text" id="node-input-registry">
+    </div>
+    
+    <div class="form-tips">
+        <b>Input Payload Format:</b><br>
+        <pre>
+        {
+            "action": "write",
+            "pointId": 101,
+            "priority": 8,
+            "value": 75.5  // or null || "null" to release
+        }
+        </pre>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('network-write', {
+        category: 'bldgblocks network',
+        color: '#3090C7',
+        defaults: {
+            name: { value: "" },
+            registry: { value: "", type: "network-point-registry", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-list-ol", 
+        label: function() {
+            return this.name || "network write";
+        },
+        paletteLabel: "network write",
+        oneditprepare: function() {
+            
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="network-write">
+Writes network commands to Global Variables using the Priority Array logic.
+
+### Input
+: payload (object) : A command object containing
+  * `action` (string): Not used by the node, used for routing to the correct node over the network when received.
+  * `pointId` (number): The integer ID of the point.
+  * `priority` (number): The priority level (1-16) to write to.
+  * `value` (any): The value to set. Send `null` to relinquish (clear) this priority level.
+
+### Output
+: payload (object) : Confirmation object containing status, pointId, and the new calculated "Winner" value.
+
+### Details
+This node acts as the inbound gateway. 
+1. It looks up the `pointId` in the selected **Registry** to find the corresponding Global Variable path.
+2. It fetches the current State Object.
+3. It updates the specific slot in the `priority` array based on the command.
+4. It recalculates the "Present Value" (highest priority active).
+5. It saves the Global Variable and emits an update event, triggering any reactive Getters immediately.
+</script>

package/nodes/network-write.js

@@ -0,0 +1,83 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+    function NetworkWriteNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.registry = RED.nodes.getNode(config.registry);
+
+        node.on("input", async function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            try {
+                // Validation
+                if (!msg || !msg.pointId || !msg.priority || msg.value === undefined) {
+                    return utils.sendError(node, msg, done, "Invalid msg properties", msg?.pointId);
+                }
+
+                // Registry Lookup
+                const entry = node.registry.lookup(msg.pointId);
+                if (!entry?.path) {
+                    const store = entry?.store ?? "unknown";
+                    return utils.sendError(node, msg, done, `Unknown ID: (${store})::${msg.pointId}`, msg.pointId);
+                }
+
+                const { store = "default", path, writable } = entry;
+
+                if (!writable) {
+                    return utils.sendError(node, msg, done, `Not Writable: (${store})::${path}::${msg.pointId}`, msg.pointId);
+                }
+
+                // Get State (Async)
+                let state = await utils.getGlobalState(node, path, store);
+
+                if (!state || !state.priority) {
+                    return utils.sendError(node, msg, done, `Point Not Found: (${store})::${path}`, msg.pointId);
+                }
+
+                // Type Check
+                let newValue = msg.value === "null" || msg.value === null ? null : msg.value;
+                if (newValue !== null) {
+                    const dataType = state.metadata?.type;
+                    if (dataType && typeof newValue !== dataType) {
+                        return utils.sendError(node, msg, done, `Type Mismatch: Expected ${dataType}`, msg.pointId);
+                    }
+                }
+
+                // Update Priority Logic
+                if (msg.priority === 'default') {
+                    state.defaultValue = newValue ?? state.defaultValue;
+                } else {
+                    const priority = parseInt(msg.priority, 10);
+                    if (isNaN(priority) || priority < 1 || priority > 16) {
+                        return utils.sendError(node, msg, done, `Invalid Priority: ${msg.priority}`, msg.pointId);
+                    }
+                    state.priority[msg.priority] = newValue;
+                }
+
+                // Calculate Winner
+                const result = utils.getHighestPriority(state);
+                state.value = result.value;
+                state.activePriority = result.priority;
+                state.metadata.lastSet = new Date().toISOString();
+
+                // Save (Async) & Emit
+                await utils.setGlobalState(node, path, store, state);
+
+                const prefixReq = msg.priority === 'default' ? '' : 'P';
+                const prefixAct = state.activePriority === 'default' ? '' : 'P';
+                const statusMsg = `Wrote: ${prefixReq}${msg.priority}:${newValue} > Active: ${prefixAct}${state.activePriority}:${state.value}`;
+
+                msg = { ...state, status: null }; 
+                
+                RED.events.emit("bldgblocks-global-update", { key: path, store: store, data: state });
+
+                utils.sendSuccess(node, msg, done, statusMsg, msg.pointId, "ring");
+
+            } catch (err) {
+                node.error(err);
+                utils.sendError(node, msg, done, `Internal Error: ${err.message}`, msg?.pointId);
+            }
+        });
+    }
+    RED.nodes.registerType("network-write", NetworkWriteNode);
+}

package/nodes/nullify-block.html

@@ -11,7 +11,7 @@
 
 <script type="text/javascript">
     RED.nodes.registerType("nullify-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },

package/nodes/on-change-block.html

@@ -14,7 +14,7 @@
 <!-- JavaScript Section -->
 <script type="text/javascript">
     RED.nodes.registerType("on-change-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },

package/nodes/oneshot-block.html

@@ -26,7 +26,7 @@
 <!-- JavaScript Section -->
 <script type="text/javascript">
     RED.nodes.registerType("oneshot-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },

package/nodes/or-block.html

@@ -11,7 +11,7 @@
 
 <script type="text/javascript">
     RED.nodes.registerType("or-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },

package/nodes/pid-block.html

@@ -65,7 +65,7 @@
 <!-- JavaScript Section -->
 <script type="text/javascript">
     RED.nodes.registerType("pid-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },

package/nodes/priority-block.html

@@ -9,7 +9,7 @@
 <!-- JavaScript Section: Registers the node and handles editor logic -->
 <script type="text/javascript">
     RED.nodes.registerType("priority-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" }

package/nodes/rate-limit-block.html

@@ -29,7 +29,7 @@
 <!-- JavaScript Section -->
 <script type="text/javascript">
     RED.nodes.registerType("rate-limit-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },
@@ -42,7 +42,7 @@
         outputs: 1,
         inputLabels: ["value"],
         outputLabels: ["processed value"],
-        icon: "font-awesome/fa-tachometer-alt",
+        icon: "font-awesome/fa-circle-up",
         paletteLabel: "rate limit",
         label: function() {
             return this.name || this.mode || "rate limit";

package/nodes/rate-of-change-block.html

@@ -29,7 +29,7 @@
 
 <script type="text/javascript">
     RED.nodes.registerType("rate-of-change-block", {
-        category: "control",
+        category: "bldgblocks control",
         color: "#301934",
         defaults: {
             name: { value: "" },