@vitormnm/node-red-simple-opcua 1.6.3 → 1.8.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) {
@@ -94,6 +90,7 @@ class OpcUaAddressSpaceAlarm {
                 value: sourceName
             });
 
+            alarmNode.alarmConfig = alarmConfig;
             return alarmNode;
         } catch (error) {
             console.error("createAlarm");
@@ -101,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;
 
@@ -128,38 +125,41 @@ class OpcUaAddressSpaceAlarm {
         let lastMessage = null;
         let message = null;
 
+        const sendValue = alarmConfig.sendValue !== false;
+
         if (variableValue >= highHighSp && enabled) {
-            message = alarmConfig.highHighMessage + ": " + variableValue;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            message = sendValue ? (alarmConfig.highHighMessage + ": " + variableValue) : alarmConfig.highHighMessage;
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue >= highSp && enabled) {
-            message = alarmConfig.highMessage + ": " + variableValue;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            message = sendValue ? (alarmConfig.highMessage + ": " + variableValue) : alarmConfig.highMessage;
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue <= lowLowSp && enabled) {
-            message = alarmConfig.lowLowMessage + ": " + variableValue;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            message = sendValue ? (alarmConfig.lowLowMessage + ": " + variableValue) : alarmConfig.lowLowMessage;
+            this.raiseAlarm(alarmNode, message, alarmConfig.severity, true, context);
             lastMessage = message;
         } else if (variableValue <= lowSp && enabled) {
-            message = alarmConfig.lowMessage + ": " + variableValue;
-            this.raiseAlarm(alarmNode, message, alarmConfig.severity);
+            message = sendValue ? (alarmConfig.lowMessage + ": " + variableValue) : alarmConfig.lowMessage;
+            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);
@@ -181,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, {
@@ -199,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,
@@ -222,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) {
@@ -244,20 +244,83 @@ class OpcUaAddressSpaceAlarm {
         }
 
         alarmNode.activeState.setValue(true);
-        this.raiseNewConditionAlarm(alarmNode, message, severity, retain);
+        this.raiseNewConditionAlarm(alarmNode, message, severity, retain, context);
+    }
+
+    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) {
+    raiseNewConditionAlarm(alarmNode, message, severity, retain, context = null) {
         alarmNode.raiseNewCondition({ message, severity, retain });
 
         this.registry.registerActiveAlarms(alarmNode, message, severity, retain, this.node);
 
+        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: "highHighSp"
+            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
+            }
         });
     }