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

package/client/view/opcua-client.js

@@ -657,7 +657,7 @@
         }).fail(function (xhr) {
             var message = xhr && xhr.responseJSON && xhr.responseJSON.error
                 ? xhr.responseJSON.error
-                : "Falha ao navegar no servidor OPC UA.";
+                : "Failed to browse the OPC UA server.";
             browseState = null;
             container.html('<div class="opcua-tree-empty">' + escapeHtml(message) + '</div>');
             RED.notify(message, "error");
@@ -675,6 +675,7 @@
         contextMenuPath = path || "";
         $("#node-input-browse-context-refresh").toggle(!!item && !isVariable(item));
         $("#node-input-browse-context-copy-nodeid").toggle(!!nodeIdOf(item));
+        $("#node-input-browse-context-read-value").toggle(!!item && isVariable(item) && !!nodeIdOf(item));
         menu.css({ left: x + "px", top: y + "px" }).show();
     }
 
@@ -682,15 +683,15 @@
         var item = getItemAtPath(path);
         var nodeId = nodeIdOf(item);
         if (!nodeId) {
-            RED.notify("NodeID nao encontrado para o item selecionado.", "warning");
+            RED.notify("NodeID not found for the selected item.", "warning");
             return;
         }
 
         if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
             navigator.clipboard.writeText(nodeId).then(function () {
-                RED.notify("NodeID copiado.", "success");
+                RED.notify("NodeID copied.", "success");
             }).catch(function () {
-                RED.notify("Falha ao copiar NodeID.", "error");
+                RED.notify("Failed to copy NodeID.", "error");
             });
             return;
         }
@@ -704,13 +705,48 @@
         input[0].select();
         try {
             document.execCommand("copy");
-            RED.notify("NodeID copiado.", "success");
+            RED.notify("NodeID copied.", "success");
         } catch (error) {
-            RED.notify("Falha ao copiar NodeID.", "error");
+            RED.notify("Failed to copy NodeID.", "error");
         }
         input.remove();
     }
 
+    function readValueFromPath(path) {
+        var item = getItemAtPath(path);
+        var nodeId = nodeIdOf(item);
+        if (!nodeId) {
+            RED.notify("NodeID not found for the selected item.", "warning");
+            return;
+        }
+
+        var connectionId = $("#node-input-connection").val();
+        if (!connectionId) {
+            RED.notify("Select an OPC UA connection before reading.", "warning");
+            return;
+        }
+
+        $.getJSON("opcua-client-config/" + encodeURIComponent(connectionId) + "/read", {
+            nodeId: nodeId
+        }).done(function (payload) {
+            if (payload && payload.error) {
+                RED.notify("Read failed: " + payload.error, "error");
+            } else if (payload) {
+                var valueText = (payload.valueEnumeration !== undefined && payload.valueEnumeration !== null)
+                    ? payload.valueEnumeration + " (" + payload.value + ")"
+                    : (payload.value !== undefined ? String(payload.value) : "undefined");
+                RED.notify("Variable value: " + valueText, "success");
+            } else {
+                RED.notify("No value returned from the server.", "warning");
+            }
+        }).fail(function (xhr) {
+            var message = xhr && xhr.responseJSON && xhr.responseJSON.error
+                ? xhr.responseJSON.error
+                : "Failed to read variable value.";
+            RED.notify(message, "error");
+        });
+    }
+
     function setBrowseSelectedPath(path) {
         browseSelectedPath = path || "";
         $(".opcua-tree-row").removeClass("is-selected");
@@ -759,20 +795,51 @@
         renderBrowseTree();
         var browseNodeId = item.nodeID || item.nodeId;
         loadBrowse(browseNodeId).done(function (payload) {
-
-            
-
-            item.browse = Array.isArray(payload.browse) ? payload.browse : [];
-            saveBrowseSession();
-            renderBrowseTree();
+            try {
+                if (!payload) {
+                    console.error("Browse returned empty payload for node " + browseNodeId);
+                    RED.notify("Browse returned empty payload.", "error");
+                    item.browse = [];
+                } else if (payload.error) {
+                    console.error("Browse returned error for node " + browseNodeId + ":", payload.error);
+                    RED.notify(payload.error, "error");
+                    item.browse = [];
+                } else {
+                    item.browse = Array.isArray(payload.browse) ? payload.browse : [];
+                }
+                saveBrowseSession();
+                renderBrowseTree();
+                triggerChildrenExpansion(item.browse, path);
+            } catch (err) {
+                console.error("Error handling browse payload for node " + browseNodeId + ":", err);
+                RED.notify("Error handling browse response: " + err.message, "error");
+                expansionState[path] = false;
+                saveBrowseSession();
+                renderBrowseTree();
+            }
         }).fail(function (xhr) {
             expansionState[path] = false;
             saveBrowseSession();
             renderBrowseTree();
             var message = xhr && xhr.responseJSON && xhr.responseJSON.error
                 ? xhr.responseJSON.error
-                : "Falha ao expandir o node.";
+                : "Failed to expand the node.";
             RED.notify(message, "error");
+            console.error("Browse request failed for node " + browseNodeId + ":", xhr);
+        });
+    }
+
+    function triggerChildrenExpansion(children, parentPath) {
+        if (!Array.isArray(children)) return;
+        children.forEach(function (child, index) {
+            var childPath = parentPath + ".browse." + index;
+            if (isExpanded(childPath, false)) {
+                if (!Array.isArray(child.browse)) {
+                    expandNode(childPath);
+                } else {
+                    triggerChildrenExpansion(child.browse, childPath);
+                }
+            }
         });
     }
 
@@ -1057,7 +1124,24 @@
         if ($(event.target).closest(".opcua-client-toggle-tree, .opcua-client-toggle-tag, .opcua-tree-actions, #node-input-browse-context-menu").length) {
             return;
         }
-        setBrowseSelectedPath($(this).attr("data-path"));
+        var path = $(this).attr("data-path");
+        setBrowseSelectedPath(path);
+
+        if (event.ctrlKey || event.metaKey) {
+            event.preventDefault();
+            if ($("#node-input-mode").val() === "method") {
+                var item = getItemAtPath(path);
+                if (item && item.nodeClass === "Method") {
+                    var parentPath = path.split(".");
+                    parentPath.splice(parentPath.length - 2, 2);
+                    parentPath = parentPath.join(".");
+                    var parentItem = getItemAtPath(parentPath);
+                    addMethodFromTree(item, parentItem);
+                    return;
+                }
+            }
+            toggleSelectedNode(path);
+        }
     });
 
     $(document).on("contextmenu", ".opcua-tree-row", function (event) {
@@ -1091,6 +1175,14 @@
         copyNodeIdFromPath(path);
     });
 
+    $(document).on("click", "#node-input-browse-context-read-value", function (event) {
+        event.preventDefault();
+        var highlightedPath = $(".opcua-tree-row.is-selected").first().attr("data-path") || "";
+        var path = contextMenuPath || browseSelectedPath || highlightedPath || "";
+        hideTreeContextMenu();
+        readValueFromPath(path);
+    });
+
     $(document).on("click", function (event) {
         if (!$(event.target).closest("#node-input-browse-context-menu").length) {
             hideTreeContextMenu();

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@vitormnm/node-red-simple-opcua",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Custom Node-RED OPC UA server and client node powered by node-opcua",
+  "description": "OPC UA server and client nodes with a graphical interface, powered by node-opcua",
   "main": "server/opcua-server.js",
   "node-red": {
     "version": ">=3.0.0",

package/server/lib/opcua-address-space-alarm.js

@@ -15,18 +15,14 @@ class OpcUaAddressSpaceAlarm {
     }
 
     emitTagAccess(operation, details) {
-        this.registry.emitTagAccess({
+        this.registry.emitTagAccess(Object.assign({
             operation,
             serverId: this.node.id,
             serverNodeName: this.node.name || "",
             serverName: this.serverName,
             timestamp: new Date().toISOString(),
-            path: details.path,
-            nodeID: details.nodeID,
-            browseName: details.browseName,
-            dataType: details.dataType,
-            value: details.value
-        });
+            users: []
+        }, details));
     }
 
     createAlarm(namespace, browseName, parentNode, inputNode, conditionName, nodeId, sourceName, alarmConfig) {
@@ -102,21 +98,21 @@ class OpcUaAddressSpaceAlarm {
         }
     }
 
-    checkAlarm(alarm, variableValue) {
+    checkAlarm(alarm, variableValue, context = null) {
         if (alarm) {
             const alarmConfig = alarm.alarmConfig;
             const type = alarmConfig.type;
 
             if (type === "levelAlarm") {
-                this.levelAlarm(alarm, variableValue);
+                this.levelAlarm(alarm, variableValue, context);
             }
             if (type === "digitalAlarm") {
-                this.digitalAlarm(alarm, variableValue);
+                this.digitalAlarm(alarm, variableValue, context);
             }
         }
     }
 
-    levelAlarm(alarm, variableValue) {
+    levelAlarm(alarm, variableValue, context = null) {
         const alarmNode = alarm.node;
         const alarmConfig = alarm.alarmConfig;
 
@@ -133,36 +129,37 @@ class OpcUaAddressSpaceAlarm {
 
         if (variableValue >= highHighSp && enabled) {
             message = sendValue ? (alarmConfig.highHighMessage + ": " + variableValue) : alarmConfig.highHighMessage;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue >= highSp && enabled) {
             message = sendValue ? (alarmConfig.highMessage + ": " + variableValue) : alarmConfig.highMessage;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue <= lowLowSp && enabled) {
             message = sendValue ? (alarmConfig.lowLowMessage + ": " + variableValue) : alarmConfig.lowLowMessage;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue <= lowSp && enabled) {
             message = sendValue ? (alarmConfig.lowMessage + ": " + variableValue) : alarmConfig.lowMessage;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (isActive) {
-            this.clearAlarm(alarmNode, lastMessage, alarmConfig.severity);
+            message = sendValue ? (alarmConfig.normalMessage + ": " + variableValue) : alarmConfig.normalMessage;
+            this.clearAlarm(alarmNode, lastMessage || message, alarmConfig.severity, context);
         }
 
         this.alarmMethods(alarmNode);
     }
 
-    digitalAlarm(alarm, variableValue) {
+    digitalAlarm(alarm, variableValue, context = null) {
         const alarmNode = alarm.node;
         const alarmConfig = alarm.alarmConfig;
         const enabled = alarmNode.getPropertyByName("enabled").readValue().value.value;
 
         if (variableValue && enabled) {
-            this.raiseAlarm(alarmNode, alarmConfig.digitalMessage, alarmConfig.severity);
+            this.raiseAlarm(alarmNode, alarmConfig.digitalMessage, alarmConfig.severity, true, context);
         } else {
-            this.clearAlarm(alarmNode, alarmConfig.digitalMessage, alarmConfig.severity);
+            this.clearAlarm(alarmNode, alarmConfig.digitalMessage, alarmConfig.severity, context);
         }
 
         this.alarmMethods(alarmNode);
@@ -184,9 +181,9 @@ class OpcUaAddressSpaceAlarm {
                     retain: false
                 });
 
-                this.raiseNewConditionAlarm(alarm, message, severity, false);
+                this.raiseNewConditionAlarm(alarm, message, severity, false, context);
             } else {
-                this.raiseNewConditionAlarm(alarm, message, severity, true);
+                this.raiseNewConditionAlarm(alarm, message, severity, true, context);
             }
 
             callback(null, {
@@ -202,7 +199,7 @@ class OpcUaAddressSpaceAlarm {
             alarm.ackedState.setValue(true);
             alarm.confirmedState.setValue(false);
 
-            this.raiseNewConditionAlarm(alarm, message, severity, true);
+            this.raiseNewConditionAlarm(alarm, message, severity, true, context);
 
             callback(null, {
                 statusCode: StatusCodes.Good,
@@ -225,16 +222,16 @@ class OpcUaAddressSpaceAlarm {
         });
     }
 
-    clearAlarm(alarmNode, message, severity) {
+    clearAlarm(alarmNode, message, severity, context = null) {
         const isAcked = !alarmNode.ackedState.id.readValue().value.value;
 
         alarmNode.activeState.setValue(false);
         alarmNode.raiseNewCondition({ message, severity: severity, isAcked });
 
-        this.raiseNewConditionAlarm(alarmNode, message, severity, isAcked);
+        this.raiseNewConditionAlarm(alarmNode, message, severity, isAcked, context);
     }
 
-    raiseAlarm(alarmNode, message, severity, retain = true) {
+    raiseAlarm(alarmNode, message, severity, retain = true, context = null) {
         const isActive = alarmNode.activeState.id.readValue().value.value;
         const isAcked = alarmNode.ackedState.id.readValue().value.value;
         if (isActive && isAcked) {
@@ -247,10 +244,27 @@ class OpcUaAddressSpaceAlarm {
         }
 
         alarmNode.activeState.setValue(true);
-        this.raiseNewConditionAlarm(alarmNode, message, severity, retain);
+        this.raiseNewConditionAlarm(alarmNode, message, severity, retain, context);
     }
 
-    raiseNewConditionAlarm(alarmNode, message, severity, retain) {
+    getUserGroups(username) {
+        const normalized = String(username || "").trim();
+        if (!normalized || normalized.toLowerCase() === "anonymous") {
+            return [];
+        }
+        const users = (this.node && this.node.runtime && this.node.runtime.users) || [];
+        const user = users.find(u => u && u.username === normalized);
+        if (!user) {
+            return [];
+        }
+        return typeof user.group === "string"
+            ? user.group.split(",").map(g => g.trim()).filter(Boolean)
+            : Array.isArray(user.group)
+                ? user.group
+                : [];
+    }
+
+    raiseNewConditionAlarm(alarmNode, message, severity, retain, context = null) {
         alarmNode.raiseNewCondition({ message, severity, retain });
 
         this.registry.registerActiveAlarms(alarmNode, message, severity, retain, this.node);
@@ -258,12 +272,55 @@ class OpcUaAddressSpaceAlarm {
         const alarmConfig = alarmNode.alarmConfig || {};
         const sendValue = alarmConfig.sendValue !== false;
 
+        const ConditionName = alarmNode.getPropertyByName("ConditionName").readValue().value.value;
+        const SourceName = alarmNode.getPropertyByName("SourceName").readValue().value.value;
+        const isActive = alarmNode.activeState.id.readValue().value.value;
+        const isAcked = alarmNode.ackedState.id.readValue().value.value;
+        const ConfirmedState = alarmNode.confirmedState.id.readValue().value.value;
+
+        const activeContext = context || this.registry.activeWriteContext;
+
+        const users = [];
+        if (activeContext && activeContext.session) {
+            const session = activeContext.session;
+            const username = (session.userIdentityToken && session.userIdentityToken.userName)
+                ? session.userIdentityToken.userName
+                : "anonymous";
+            const groups = this.getUserGroups(username);
+            users.push({
+                name: username,
+                groups: groups
+            });
+        } else {
+            users.push({
+                name: "anonymous",
+                groups: []
+            });
+        }
+
         this.emitTagAccess("alarm", {
+            path: alarmNode.path || alarmNode.browseName.name,
+            nodeID: alarmNode.nodeId.toString(),
+            browseName: alarmNode.browseName.name,
             message: message,
             severity: severity,
             retain: retain,
             dataType: "alarm",
-            value: sendValue ? "highHighSp" : null
+            value: sendValue ? "highHighSp" : null,
+            activeState: isActive,
+            sourceName: SourceName,
+            conditionName: ConditionName,
+            ConfirmedState: ConfirmedState,
+            ackedState: isAcked,
+            users: users,
+            alarmNode: {
+                nodeId: alarmNode.nodeId,
+                browseName: alarmNode.browseName,
+                displayName: alarmNode.displayName,
+                description: alarmNode.description,
+                nodeClass: alarmNode.nodeClass,
+                typeDefinition: alarmNode.typeDefinition
+            }
         });
     }