@vitormnm/node-red-simple-opcua 1.7.0 → 1.8.1

package/server/lib/opcua-config.js

@@ -737,22 +737,39 @@ class OpcUaServerConfigParser {
     }
 
     coerceValue(value, type) {
-        if (Array.isArray(value)) {
-            return value.map((item) => this.coerceScalarValue(item, type));
-        }
+        const recursiveMap = (val, fn) => {
+            if (Array.isArray(val)) {
+                if ((type === "Int64" || type === "UInt64") && val.length === 2 && typeof val[0] === "number" && typeof val[1] === "number") {
+                    return fn(val);
+                }
+                return val.map(item => recursiveMap(item, fn));
+            }
+            return fn(val);
+        };
 
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (Array.isArray(parsed)) {
-                        return parsed.map((item) => this.coerceScalarValue(item, type));
+        const extractArray = (val) => {
+            if (Array.isArray(val)) {
+                return val;
+            }
+            if (typeof val === "string") {
+                const trimmed = val.trim();
+                if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (Array.isArray(parsed)) {
+                            return parsed;
+                        }
+                    } catch (error) {
+                        throw new Error("Invalid array value for type " + type + ": " + error.message);
                     }
-                } catch (error) {
-                    throw new Error("Invalid array value for type " + type + ": " + error.message);
                 }
             }
+            return null;
+        };
+
+        const items = extractArray(value);
+        if (items) {
+            return recursiveMap(items, (item) => this.coerceScalarValue(item, type));
         }
 
         return this.coerceScalarValue(value, type);

package/server/lib/opcua-server-events-child.js

@@ -110,10 +110,36 @@ function flushQueue(node, nodeId) {
 
 
 function upsertEvent(map, event) {
-    const key = String(event.nodeID || "").trim();
-    if (!key) return;
-
-    map.set(key, event); // sobrescreve automaticamente
+    const nodeKey = String(event.nodeID || "").trim();
+    if (!nodeKey) return;
+
+    // Key by nodeID only so the same variable is merged into one entry
+    const key = nodeKey;
+    const existing = map.get(key);
+
+    if (!existing) {
+        // First access for this variable in this interval — store a copy
+        map.set(key, Object.assign({}, event, { users: Array.isArray(event.users) ? [...event.users] : [] }));
+    } else {
+        // Variable already seen — update value and merge any new users
+        existing.value = event.value;
+        if (event.message !== undefined) existing.message = event.message;
+        if (event.severity !== undefined) existing.severity = event.severity;
+        if (event.retain !== undefined) existing.retain = event.retain;
+        if (event.activeState !== undefined) existing.activeState = event.activeState;
+        if (event.sourceName !== undefined) existing.sourceName = event.sourceName;
+        if (event.conditionName !== undefined) existing.conditionName = event.conditionName;
+        if (event.ConfirmedState !== undefined) existing.ConfirmedState = event.ConfirmedState;
+        if (event.ackedState !== undefined) existing.ackedState = event.ackedState;
+        if (event.alarmNode !== undefined) existing.alarmNode = event.alarmNode;
+        const existingNames = new Set((existing.users || []).map(u => u.name));
+        for (const user of (event.users || [])) {
+            if (!existingNames.has(user.name)) {
+                existing.users.push(user);
+                existingNames.add(user.name);
+            }
+        }
+    }
 }
 
 function matchesServer(serverRef, event) {

package/server/lib/opcua-server-runtime-child.js

@@ -398,6 +398,14 @@ class OpcUaServerProcess {
             const target = msg && msg.opcuaServerIo ? msg.opcuaServerIo : {};
             const identifierType = this.resolveIdentifierType(target);
 
+            let isSingleTag = false;
+            try {
+                this.resolveIdentifier(target);
+                isSingleTag = true;
+            } catch (e) {
+                // not a single tag
+            }
+
             // Buffer serializado pelo IPC
             if (
                 payload &&
@@ -464,7 +472,7 @@ class OpcUaServerProcess {
             }
 
             // Array de objetos
-            else if (Array.isArray(payload)) {
+            else if (Array.isArray(payload) && (!isSingleTag || this.isBatchWritePayload(payload))) {
 
                 if (!payload.length) {
                     throw new Error("msg.payload array does not contain any items");
@@ -617,6 +625,18 @@ class OpcUaServerProcess {
         }
     }
 
+    isBatchWritePayload(payload) {
+        if (!Array.isArray(payload) || payload.length === 0) {
+            return false;
+        }
+        return payload.every(item => 
+            item && 
+            typeof item === "object" && 
+            !Array.isArray(item) && 
+            (item.path !== undefined || item.nodeId !== undefined || item.identifier !== undefined)
+        );
+    }
+
     resolveIdentifierType(target) {
         return target && target.identifierType === "nodeId" ? "nodeId" : "path";
     }
@@ -885,10 +905,12 @@ class OpcUaServerProcess {
 
     readActiveAlarms(msg, nodeId) {
         try {
-            var result = registry.getActiveAlarms(this.node)
-            const msg2 = {
-                payload: result
-            }
+            const result = registry.getActiveAlarms(this.node);
+            const safeResult = Array.isArray(result) ? result : [];
+
+            const msg2 = Object.assign({}, msg || {}, {
+                payload: safeResult
+            });
 
             process.send({
                 type: "send",
@@ -901,12 +923,16 @@ class OpcUaServerProcess {
                 data: {
                     fill: "green",
                     shape: "dot",
-                    text: result.paths.length > 1 ? "read " + result.paths.length + " tags" : "read " + result.paths[0]
+                    text: safeResult.length + " active alarm" + (safeResult.length !== 1 ? "s" : "")
                 },
                 nodeId: nodeId
             });
-        } catch {
-
+        } catch (error) {
+            process.send({
+                type: "error",
+                data: error.message,
+                nodeId: nodeId
+            });
         }
     }
 
@@ -1049,6 +1075,105 @@ class OpcUaServerProcess {
         }
     }
 
+    async validateLogin(msg, nodeId) {
+        try {
+            await this.ensureReady();
+            const runtime = this.runtime;
+            if (!runtime) {
+                throw new Error("OPC UA server is not available");
+            }
+
+            const payload = msg && msg.payload ? msg.payload : {};
+            const username = typeof payload.userName === "string" ? payload.userName : (typeof payload.username === "string" ? payload.username : "");
+            const password = typeof payload.password === "string" ? payload.password : "";
+
+            const normalizedUserName = username.trim();
+            const users = Array.isArray(runtime.users) ? runtime.users : [];
+            const user = users.find((entry) => entry && entry.username === normalizedUserName);
+
+            let isValid = false;
+            if (user) {
+                if (user.password && user.password === password) {
+                    isValid = true;
+                } else if (user.passwordHash) {
+                    let bcrypt = null;
+                    try {
+                        bcrypt = require("bcryptjs");
+                    } catch (e) {
+                        bcrypt = null;
+                    }
+                    if (bcrypt) {
+                        try {
+                            isValid = bcrypt.compareSync(password, user.passwordHash);
+                        } catch (err) {
+                            // ignore comparison error
+                        }
+                    }
+                }
+            }
+
+            let result;
+            if (isValid) {
+                const groups = typeof user.group === "string"
+                    ? user.group.split(",").map(g => g.trim()).filter(Boolean)
+                    : Array.isArray(user.group)
+                        ? user.group
+                        : [];
+
+                result = {
+                    status: "Good",
+                    username: user.username,
+                    group: user.group,
+                    groups: groups
+                };
+            } else {
+                result = {
+                    status: "erro",
+                    message: "Invalid username or password"
+                };
+            }
+
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = result;
+
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
+
+            process.send({
+                type: "status",
+                data: {
+                    fill: isValid ? "green" : "yellow",
+                    shape: "dot",
+                    text: isValid ? "Login: Good" : "Login: erro"
+                },
+                nodeId: nodeId
+            });
+        } catch (error) {
+            if (msg) {
+                const outMsg = Object.assign({}, msg);
+                outMsg.payload = {
+                    status: "erro",
+                    message: error.message
+                };
+                process.send({
+                    type: "send",
+                    data: outMsg,
+                    nodeId: nodeId
+                });
+            }
+            process.send({
+                type: "status",
+                data: { fill: "red", shape: "ring", text: "Login error: " + error.message },
+                nodeId: nodeId
+            });
+        }
+    }
+
 }
 
 /**
@@ -1205,6 +1330,9 @@ process.on("message", async (msg) => {
             case "deleteActiveSessions":
                 await serverProcess.deleteActiveSessions(msg.msg, msg.nodeId);
                 break;
+            case "validateLogin":
+                await serverProcess.validateLogin(msg.msg, msg.nodeId);
+                break;
 
 
 
@@ -1242,4 +1370,8 @@ process.on("unhandledRejection", (reason) => {
         data: "Unhandled Rejection: " + (reason?.message || reason),
         nodeId: serverProcess.node.id
     });
-});
+});
+
+if (require.main !== module) {
+    module.exports = { OpcUaServerProcess };
+}

package/server/lib/opcua-server-runtime.js

@@ -160,6 +160,9 @@ class OpcUaServerRuntime {
         this.ensureReady();
         this.syncNamespaces(treeConfig);
         this.treeConfig = treeConfig;
+        // Refresh the user list in the builder so newly added/removed users are
+        // recognised in access events without requiring a full server restart.
+        this.addressSpaceBuilder.updateUsers(this.users);
         this.addressSpaceBuilder.sync(treeConfig);
     }
 

package/server/lib/opcua-server-status-child.js

@@ -99,10 +99,41 @@ function buildServerSnapshot(serverNode) {
         },
         endpoints: Array.isArray(server.endpoints)
             ? server.endpoints.map((endpoint) => buildEndpointSnapshot(endpoint))
-            : []
+            : [],
+        users: buildUsersSnapshot(serverNode),
+        groups: buildGroupsSnapshot(serverNode)
     };
 }
 
+function buildUsersSnapshot(serverNode) {
+    const rawUsers = Array.isArray(serverNode.users) ? serverNode.users : [];
+    const allowAnonymous = Boolean(serverNode.allowAnonymous);
+
+    const result = rawUsers.map((user) => ({
+        name: extractText(user && user.username),
+        groups: resolveUserGroups(user, serverNode.groups)
+    }));
+
+    if (allowAnonymous) {
+        result.unshift({ name: "anonymous", groups: [] });
+    }
+
+    return result;
+}
+
+function buildGroupsSnapshot(serverNode) {
+    const rawGroups = Array.isArray(serverNode.groups) ? serverNode.groups : [];
+    return rawGroups.map((g) => extractText(g && (g.name || g))).filter(Boolean);
+}
+
+function resolveUserGroups(user, rawGroups) {
+    if (!user) return [];
+    // normalizeUser stores groups as user.group (comma-separated string)
+    const groupsStr = extractText(user.group);
+    if (!groupsStr) return [];
+    return groupsStr.split(",").map((g) => g.trim()).filter(Boolean);
+}
+
 function buildEndpointSnapshot(endpoint) {
     const descriptions = typeof endpoint.endpointDescriptions === "function"
         ? endpoint.endpointDescriptions()

package/server/opcua-server-io.html

@@ -172,6 +172,7 @@
             <option value="activeAlarms">Active Alarms</option>
             <option value="getSessions">Get Sessions</option>
             <option value="deleteSessions">Delete Sessions</option>
+            <option value="validateLogin">Validate Login</option>
             <option value="method-input">Method Input</option>
             <option value="method-output">Method Output</option>
         </select>
@@ -410,14 +411,29 @@ msg.payload = [
     "error": "cannot find session …"
   }
 ]</code></pre>
-    <p>Possible <code>status</code> values:</p>
     <ul>
         <li><b>deleted</b> — session was found and successfully closed with reason <code>Forcing</code>.</li>
         <li><b>not_found</b> — no active session with that <code>sessionId</code> exists.</li>
-        <li><b>error</b> — the session was found but <code>engine.closeSession()</code> threw; the
-        <code>error</code> field contains the message.</li>
+        <li><b>error</b> — the session was found but <code>engine.closeSession()</code> threw; the <code>error</code> field contains the message.</li>
     </ul>
 
-
-
+    <h3>Validate Login</h3>
+    <p>Validates a user's credentials against the OPC UA server's configured user database.</p>
+    <p><b>Input</b>: <code>msg.payload</code> must be a JSON object containing <code>userName</code> (or <code>username</code>) and <code>password</code>:</p>
+    <pre><code>{
+  "userName": "admin",
+  "password": "123"
+}</code></pre>
+    <p><b>Output</b>: <code>msg.payload</code> contains the status of validation and user groups (excluding password hashes):</p>
+    <pre><code>{
+  "status": "Good",
+  "username": "admin",
+  "group": "admin,operator",
+  "groups": ["admin", "operator"]
+}</code></pre>
+    <p>If authentication fails or the user is not found, the response contains:</p>
+    <pre><code>{
+  "status": "erro",
+  "message": "Invalid username or password"
+}</code></pre>
 </script>

package/server/opcua-server-io.js

@@ -119,6 +119,13 @@ module.exports = function (RED) {
                         node._pendingDoneCallbacks.delete(msg._msgid);
                     }
                 }
+                else if (node.mode === "validateLogin") {
+                    await handleValidateLogin(node, msg, { waitForServer: true, timeoutMs: 5000 });
+                    done();
+                    if (msg && msg._msgid) {
+                        node._pendingDoneCallbacks.delete(msg._msgid);
+                    }
+                }
 
             } catch (error) {
                 node.status({ fill: "red", shape: "ring", text: node.mode + " failed" });
@@ -255,7 +262,8 @@ module.exports = function (RED) {
                     opcua: {
                         server: msg.data.serverName,
                         method: msg.data.methodName,
-                        data: msg.data
+                        data: msg.data,
+                        users: Array.isArray(msg.data.users) ? msg.data.users : []
                     },
                     _callId: msg.data.callId
                 });
@@ -286,7 +294,8 @@ module.exports = function (RED) {
                     opcua: {
                         server: msg.data.serverName,
                         method: msg.data.methodName,
-                        data: msg.data
+                        data: msg.data,
+                        users: Array.isArray(msg.data.users) ? msg.data.users : []
                     },
                     _callId: msg.data.callId
                 });
@@ -345,6 +354,14 @@ module.exports = function (RED) {
         }, options);
     }
 
+    async function handleValidateLogin(node, msg, options) {
+        return sendToChild(node, {
+            type: "validateLogin",
+            msg: msg,
+            nodeId: node.id
+        }, options);
+    }
+
 
     async function handleWrite(node, msg) {
 
@@ -474,6 +491,10 @@ module.exports = function (RED) {
             registerMethodInput(node);
         }
 
+        if (node.mode === "events") {
+            registerEvents(node, { throwOnError: false, silentOnError: true });
+        }
+
         return true;
     }
 

package/server/opcua-server-registry.js

@@ -216,8 +216,14 @@ function getActiveAlarms(node) {
                 conditionName: ConditionName,
                 ConfirmedState: ConfirmedState,
                 ackedState: isAcked,
-                alarmNode: alarmNode,
-
+                alarmNode: {
+                    nodeId: alarmNode.nodeId,
+                    browseName: alarmNode.browseName,
+                    displayName: alarmNode.displayName,
+                    description: alarmNode.description,
+                    nodeClass: alarmNode.nodeClass,
+                    typeDefinition: alarmNode.typeDefinition
+                }
             })
         });
 

package/server/opcua-server.css

@@ -315,3 +315,15 @@
     width: auto !important;
     display: inline-block;
 }
+
+/* Drag and Drop styling for visual tree rows */
+.opcua-tree-row.is-dragging {
+    opacity: 0.4;
+    border: 1px dashed var(--red-ui-form-input-border-color, #999);
+}
+
+.opcua-tree-row.drag-over {
+    background-color: var(--red-ui-list-item-background-hover, #f3f7fd) !important;
+    box-shadow: inset 0 0 0 2px var(--red-ui-form-input-border-color-selected, #2196F3);
+}
+

package/server/opcua-server.html

@@ -211,6 +211,8 @@
                     <a href="#" data-action="add-method"><i class="fa fa-plus"></i> Add Method</a>
                     <a href="#" data-action="edit"><i class="fa fa-pencil"></i> Edit</a>
                     <a href="#" data-action="remove"><i class="fa fa-trash"></i> Remove</a>
+                    <a href="#" data-action="expand-all-below"><i class="fa fa-angle-double-down"></i> Expand All Below</a>
+                    <a href="#" data-action="collapse-all-below"><i class="fa fa-angle-double-up"></i> Collapse All Below</a>
                 </div>
             </div>
         </div>

package/server/view/opcua-server.css

@@ -576,4 +576,15 @@ body.opcua-tree-modal-open {
 .opcua-config-input[type="checkbox"] {
     width: auto !important;
     display: inline-block;
+}
+
+/* Drag and Drop styling for visual tree rows */
+.opcua-tree-row.is-dragging {
+    opacity: 0.4;
+    border: 1px dashed var(--red-ui-form-input-border-color, #999);
+}
+
+.opcua-tree-row.drag-over {
+    background-color: var(--red-ui-list-item-background-hover, #f3f7fd) !important;
+    box-shadow: inset 0 0 0 2px var(--red-ui-form-input-border-color-selected, #2196F3);
 }