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

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
+: payload (object) : A command object containing
+  * `pointId` (number): The integer ID of the point.
+
+### Output
+: payload (object) : Global data object
+
+### Details
+
+</script>

package/nodes/network-read.js

@@ -0,0 +1,59 @@
+module.exports = function(RED) {
+    function NetworkReadNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.registry = RED.nodes.getNode(config.registry);
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            
+            let currentPath = null;
+            let currentStore = "default";
+
+            if (node.registry) {
+                let currentEntry = node.registry.lookup(msg.pointId);
+                
+                if (!currentEntry) {
+                    node.status({ fill: "red", shape: "ring", text: `Requested pointId not registered` });
+                    msg.status = { status: "fail", pointId: msg.pointId, error: `Point Not Registered: ${msg.pointId}` };
+                    node.send(msg);
+                    if (done) done();
+                    return;
+                }
+                
+                currentPath = currentEntry.path;
+                currentStore = currentEntry.store || "default";
+                let globalData = node.context().global.get(currentPath, currentStore) || {};
+
+                if (globalData === null || Object.keys(globalData).length === 0) { 
+                    node.status({ fill: "red", shape: "ring", text: `Global data doesn't exist, waiting...` });
+                    msg.status = { status: "fail", pointId: msg.pointId, error: `Point Not Found: ${msg.pointId}` };
+                    node.send(msg);
+                    if (done) done();
+                    return;
+                }
+
+                msg = { ...globalData };
+                node.status({ fill: "blue", shape: "ring", text: `Read (${currentStore})::${msg.metadata.name}::${msg.network.pointId} ` });
+                msg.status = { status: "ok", pointId: msg.network.pointId, message: `Data Found. pointId: ${msg.network.pointId} value: ${msg.value}` };
+                node.send(msg);
+                
+                if (done) done();
+            } else {
+                node.status({ fill: "red", shape: "ring", text: `Registry not found. Create config node.` });
+                if (done) done();
+                return;
+            }
+        });
+
+        // Cleanup
+        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,161 @@
+module.exports = function(RED) {
+    function NetworkRegisterNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Config
+        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, // for point registry collision checks
+                writable: node.writable,
+                path: "not ready",
+                store: "not ready"
+            });
+
+            if (success) {
+                node.isRegistered = true;
+                node.status({ fill: "blue", 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", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Nothing to do. Return.
+            if (!node.isRegistered) {
+                node.status({ fill: "red", shape: "ring", text: `Not registered` });
+                if (done) done();
+                return;
+            }
+
+            if (!msg || typeof msg !== "object") {
+                const message = `Invalid msg.`;
+                node.status({ fill: "red", shape: "ring", text: `${message}` });
+                if (done) done();
+                return;
+            }
+
+            if (!node.registry) {
+                const message = `Registry not found. Create config node.`;
+                node.status({ fill: "red", shape: "ring", text: `${message}` });
+                msg.status = { status: "fail", pointId: node.pointId, error: `${message}` };
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+            
+            // Message should contain data & metadata from a global setter node
+            const missingFields = [];
+
+            if (!msg.metadata) missingFields.push("metadata");
+            if (msg.value === undefined) missingFields.push("value");
+            if (msg.units === undefined) missingFields.push("units");
+            if (!msg.activePriority) missingFields.push("activePriority");
+
+            // Check nested metadata properties
+            if (msg.metadata) {
+                if (!msg.metadata.path) missingFields.push("metadata.path");
+                if (!msg.metadata.store) missingFields.push("metadata.store");
+                if (!msg.metadata.sourceId) missingFields.push("metadata.sourceId");
+            } else {
+                missingFields.push("metadata (entire object)");
+            }
+
+            if (missingFields.length > 0) {
+                const specificMessage = `Missing required fields: ${missingFields.join(', ')}`;
+                node.status({ 
+                    fill: "red", 
+                    shape: "ring", 
+                    text: `${missingFields.length} missing: ${missingFields.slice(0, 3).join(', ')}${missingFields.length > 3 ? '...' : ''}` 
+                });
+                
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+
+
+            // Lookup current registration
+            let pointData = node.registry.lookup(node.pointId);
+
+            const incoming = {
+                writable: node.writable,
+                path: msg.metadata.path,
+                store: msg.metadata.store
+            };
+
+            // Update Registry on change
+            if (!pointData 
+                || pointData.nodeId !== node.nodeId
+                || pointData.writable !== incoming.writable 
+                || pointData.path !== incoming.path 
+                || pointData.store !== incoming.store) {
+                    
+                node.registry.register(node.pointId, {
+                    nodeId: node.id, // for point registry collision checks
+                    writable: node.writable,
+                    path: msg.metadata.path,
+                    store: msg.metadata.store
+                });
+                
+                pointData = node.registry.lookup(node.pointId);
+
+                let globalData = {};
+                globalData = node.context().global.get(pointData.path, pointData.store);
+
+                if (globalData === null || Object.keys(globalData).length === 0) { 
+                    const message = `Global data doesn't exist for (${pointData.store ?? "default"})::${pointData.path}::${node.pointId}`;
+                    node.status({ fill: "red", shape: "ring", text: `${message}` });
+                    msg.status = { status: "fail", pointId: node.pointId, error: `${message}` };
+                    if (done) done();
+                    return;
+                }
+
+                let network = {
+                    registry: node.registry.name,
+                    pointId: node.pointId,
+                    writable: node.writable
+                }
+
+                const networkObject = { ...globalData, network: network};
+                const message = `Registered: (${pointData.store ?? "default"})::${pointData.path}::${node.pointId}`;
+                
+                node.context().global.set(pointData.path, networkObject, pointData.store);
+                node.status({ fill: "blue", shape: "dot", text: `${message}` });
+                msg.status = { status: "success", pointId: node.pointId, error: `${message}` };
+
+                node.send(networkObject);
+                if (done) done();
+                return;
+            }
+
+            // Make it here, then message should match global and ready to go
+            // Pass through msg
+            const prefix = msg.activePriority === 'default' ? '' : 'P';
+            const message = `Passthrough: ${prefix}${msg.activePriority}:${msg.value}${msg.units}`;
+            node.status({ fill: "blue", shape: "ring", text: message });
+            
+            node.send(msg);
+            if (done) done();
+            return;
+        });
+
+        // Cleanup
+        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,64 @@
+<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
+  * `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,126 @@
+module.exports = function(RED) {
+    function NetworkWriteNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.registry = RED.nodes.getNode(config.registry);
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Expecting: msg.payload = { pointId, priority, value }
+            if (!msg || !msg.pointId || !msg.priority || msg.value === undefined) {
+                node.status({ fill: "red", shape: "dot", text: "Invalid msg properties" });
+                msg.status = { status: "fail", pointId: msg.pointId, error: `Invalid msg properties` };
+
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+
+            // Lookup Path
+            const entry = node.registry.lookup(msg.pointId);
+            const store = entry.store ?? "default";
+            const path = entry.path;
+            if (!entry || !path) {
+                node.status({ fill: "red", shape: "dot", text: `Unknown ID: (${store})::${path}::${msg.pointId}` });
+                msg.status = { status: "fail", pointId: msg.pointId, error: `Unknown ID: (${store})::${path}::${msg.pointId}` };
+
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+            
+            // Check Writable
+            if (!entry.writable) {
+                node.status({ fill: "red", shape: "dot", text: `Not Writable: (${store})::${path}::${msg.pointId}` });
+                msg.status = { status: "fail", pointId: msg.pointId, error: `Not Writable: (${store})::${path}::${msg.pointId}` };
+
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+
+            // Get State
+            const globalContext = node.context().global;
+            let state = globalContext.get(path, store);
+
+            if (!state || !state.priority) {
+                node.status({ fill: "red", shape: "ring", text: `Point Not Found: (${store})::${path}::${msg.pointId}` });
+                msg.status = { status: "fail", pointId: msg.pointId, error: `Point Not Found: (${store})::${path}::${msg.pointId}` };
+
+                node.send(msg);
+                if (done) done();
+                return;
+            }
+
+            // Check Type
+            if (msg.value === "null" || msg.value === null) {
+                msg.value = null;
+            } else {
+                const inputType = typeof msg.value;
+                const dataType = state.metadata.type;
+                if (inputType !== dataType) {
+                    node.status({ fill: "red", shape: "ring", text: `Mismatch type error: ${store}:${path} ID: ${msg.pointId}, ${inputType} !== ${dataType}` });
+                    msg.status = { status: "fail", pointId: msg.pointId, error: `Mismatch type error: ${store}:${path} ID: ${msg.pointId}, ${inputType} !== ${dataType}` };
+
+                    node.send(msg);
+                    if (done) done();
+                    return;
+                }
+            }
+
+            // Update Priority
+            if (msg.priority === 'default') {
+                state.defaultValue = msg.value ?? state.defaultValue;
+            } else {
+                const priority = parseInt(msg.priority, 10);
+                if (isNaN(priority) || priority < 1 || priority > 16) {
+                    node.status({ fill: "red", shape: "ring", text: `Invalid priority: ${msg.priority}` });
+                    msg.status = { status: "fail", pointId: msg.pointId, error: `Invalid Priority: (${store})::${path}::${msg.pointId}` };
+
+                    node.send(msg);
+                    if (done) done();
+                    return;
+                }
+                 
+                state.priority[msg.priority] = msg.value;
+            }
+
+            // Calculate Winner (Same logic as Setter)
+            let winnerValue = state.defaultValue;
+            let winnerPriority = 'default'
+            for (let i = 1; i <= 16; i++) {
+                if (state.priority[i] !== undefined && state.priority[i] !== null) {
+                    winnerValue = state.priority[i];
+                    winnerPriority = `${i}`
+                    break;
+                }
+            }
+            state.value = winnerValue;
+            state.activePriority = winnerPriority;
+            state.metadata.lastSet = new Date().toISOString();
+
+            // Save & Emit
+            const prefix1 = msg.priority === 'default' ? '' : 'P';
+            const prefix2 = state.activePriority === 'default' ? '' : 'P';
+            const message = `Wrote: ${prefix1}${msg.priority}:${msg.value} > (${store})::${path}::${msg.pointId} Active: ${prefix2}${winnerPriority}:${winnerValue}`;
+            node.status({ fill: "blue", shape: "ring", text: message });
+
+            globalContext.set(path, state, store);
+            msg = { ...state };
+            msg.status = { status: "ok", pointId: msg.pointId, message: message };
+            
+            // Trigger global getters to update on new value
+            RED.events.emit("bldgblocks-global-update", {
+                key: path,
+                store: store,
+                data: state
+            });
+
+            node.send(msg);
+            if (done) done();
+        });
+    }
+    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: "" },