@vitormnm/node-red-simple-opcua 1.6.3 → 1.8.0

package/server/lib/opcua-config.js

@@ -26,14 +26,18 @@ class OpcUaServerConfigParser {
             serverName: config.serverName || DEFAULT_SERVER_NAME,
             port: normalizePort(config.port),
             maxConnections: this.normalizeMaxConnections(config.maxConnections),
+            minSessionTimeout: this.normalizeSessionTimeout(config.minSessionTimeout),
+            defaultSessionTimeout: this.normalizeSessionTimeout(config.defaultSessionTimeout),
+            maxSessionTimeout: this.normalizeSessionTimeout(config.maxSessionTimeout),
             namespaceUri: config.namespaceUri || DEFAULT_NAMESPACE_URI,
             resourcePath: config.resourcePath || DEFAULT_RESOURCE_PATH,
             treeConfig: this.parseTreeConfig(config.tree),
             allowAnonymous: this.normalizeAllowAnonymous(config.allowAnonymous),
+            automaticallyAcceptUnknownCertificate: this.normalizeAutomaticallyAcceptUnknownCertificate(config.automaticallyAcceptUnknownCertificate),
             groups: auth.groups,
             users: auth.users,
-            securityPolicy: security.securityPolicy,
-            securityMode: security.securityMode
+            securityPolicies: security.securityPolicies,
+            securityModes: security.securityModes
         };
     }
 
@@ -509,17 +513,18 @@ class OpcUaServerConfigParser {
             nodeId: this.normalizeOptionalNodeId(alarmConfig.nodeId),
             namespaceId: this.normalizeNamespaceId(alarmConfig.namespaceId),
             accessPermission: this.normalizeAccessPermissions(alarmConfig.accessPermission || alarmConfig.accessPermissions),
-            enabled: typeof alarmConfig.enabled === "boolean" ? alarmConfig.enabled : true
+            enabled: typeof alarmConfig.enabled === "boolean" ? alarmConfig.enabled : true,
+            sendValue: typeof alarmConfig.sendValue === "boolean" ? alarmConfig.sendValue : true
         };
 
         if (type === "levelAlarm") {
-            base.highHighLimit = Number.isFinite(Number(alarmConfig.highHighLimit)) ? Number(alarmConfig.highHighLimit) : 100;
+            base.highHighLimit = Number.isFinite(Number(alarmConfig.highHighLimit)) ? Number(alarmConfig.highHighLimit) : 90;
             base.highHighMessage = typeof alarmConfig.highHighMessage === "string" ? alarmConfig.highHighMessage : "High High alarm";
             base.highLimit = Number.isFinite(Number(alarmConfig.highLimit)) ? Number(alarmConfig.highLimit) : 80;
             base.highMessage = typeof alarmConfig.highMessage === "string" ? alarmConfig.highMessage : "High alarm";
             base.lowLimit = Number.isFinite(Number(alarmConfig.lowLimit)) ? Number(alarmConfig.lowLimit) : 20;
             base.lowMessage = typeof alarmConfig.lowMessage === "string" ? alarmConfig.lowMessage : "Low alarm";
-            base.lowLowLimit = Number.isFinite(Number(alarmConfig.lowLowLimit)) ? Number(alarmConfig.lowLowLimit) : 0;
+            base.lowLowLimit = Number.isFinite(Number(alarmConfig.lowLowLimit)) ? Number(alarmConfig.lowLowLimit) : 10;
             base.lowLowMessage = typeof alarmConfig.lowLowMessage === "string" ? alarmConfig.lowLowMessage : "Low Low alarm";
         } else if (type === "digitalAlarm") {
             base.normalStateValue = Number.isFinite(Number(alarmConfig.normalStateValue)) ? Number(alarmConfig.normalStateValue) : 0;
@@ -643,6 +648,17 @@ class OpcUaServerConfigParser {
         return value !== false;
     }
 
+    normalizeAutomaticallyAcceptUnknownCertificate(value) {
+        if (value === undefined) {
+            return true;
+        }
+        if (typeof value === "string") {
+            return value !== "false";
+        }
+
+        return value !== false;
+    }
+
     normalizeMaxConnections(value) {
         const parsed = Number(value);
         if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -651,50 +667,109 @@ class OpcUaServerConfigParser {
         return parsed;
     }
 
-    applySecuritySettings(policy, mode) {
-        const rawPolicy = typeof policy === "string" ? policy.trim() : "None";
-        const rawMode = typeof mode === "string" ? mode.trim() : "None";
+    normalizeSessionTimeout(value) {
+        if (value === undefined || value === null || value === "") {
+            return undefined;
+        }
+        const parsed = Number(value);
+        if (!Number.isInteger(parsed) || parsed < 0) {
+            return undefined;
+        }
+        return parsed;
+    }
 
-        let securityPolicy = Object.prototype.hasOwnProperty.call(SECURITY_POLICY_MAP, rawPolicy)
-            ? SECURITY_POLICY_MAP[rawPolicy]
-            : SECURITY_POLICY_MAP.None;
-        let securityMode = Object.prototype.hasOwnProperty.call(SECURITY_MODE_MAP, rawMode)
-            ? SECURITY_MODE_MAP[rawMode]
-            : SECURITY_MODE_MAP.None;
+    applySecuritySettings(policies, modes) {
+        // policies and modes can be comma-separated strings, e.g. "None,Basic256Sha256"
+        const rawPolicies = typeof policies === "string" ? policies.split(",").map(p => p.trim()).filter(Boolean) : ["None"];
+        const rawModes = typeof modes === "string" ? modes.split(",").map(m => m.trim()).filter(Boolean) : ["None"];
 
-        if (securityMode === MessageSecurityMode.None) {
-            securityPolicy = SecurityPolicy.None;
-            if (rawPolicy !== "None") {
-                this.node.warn("Security policy adjusted to None because security mode is None");
+        let securityPolicies = [];
+        rawPolicies.forEach(policy => {
+            if (Object.prototype.hasOwnProperty.call(SECURITY_POLICY_MAP, policy)) {
+                securityPolicies.push(SECURITY_POLICY_MAP[policy]);
+            }
+        });
+        if (securityPolicies.length === 0) {
+            securityPolicies.push(SECURITY_POLICY_MAP.None);
+        }
+
+        let securityModes = [];
+        rawModes.forEach(mode => {
+            if (Object.prototype.hasOwnProperty.call(SECURITY_MODE_MAP, mode)) {
+                securityModes.push(SECURITY_MODE_MAP[mode]);
+            }
+        });
+        if (securityModes.length === 0) {
+            securityModes.push(SECURITY_MODE_MAP.None);
+        }
+
+        const hasNoneMode = securityModes.includes(MessageSecurityMode.None);
+        const hasSignedMode = securityModes.some(m => m !== MessageSecurityMode.None);
+
+        if (hasNoneMode && !hasSignedMode) {
+            // ONLY None mode is selected, so policy MUST be None
+            securityPolicies = [SecurityPolicy.None];
+        } else if (!hasNoneMode && hasSignedMode) {
+            // ONLY signed modes are selected, so policy cannot be None
+            securityPolicies = securityPolicies.filter(p => p !== SecurityPolicy.None);
+            if (securityPolicies.length === 0) {
+                securityPolicies.push(SecurityPolicy.Basic256Sha256);
+                this.node.warn("Security policy adjusted to Basic256Sha256 because signed modes require a policy");
+            }
+        } else {
+            // Both None and signed modes are selected. Policies can be a mix.
+            // If the user selected a signed mode but only selected "None" policy, we must add a default signed policy.
+            const hasSignedPolicy = securityPolicies.some(p => p !== SecurityPolicy.None);
+            if (!hasSignedPolicy) {
+                securityPolicies.push(SecurityPolicy.Basic256Sha256);
+                this.node.warn("Added default Security Policy Basic256Sha256 because signed modes require a policy");
+            }
+            // Ensure None policy is present for the None mode
+            if (!securityPolicies.includes(SecurityPolicy.None)) {
+                securityPolicies.push(SecurityPolicy.None);
             }
-        } else if (securityPolicy === SecurityPolicy.None) {
-            securityPolicy = SecurityPolicy.Basic256Sha256;
-            this.node.warn("Security policy adjusted to Basic256Sha256 because signed modes require a policy");
         }
 
         return {
-            securityPolicy,
-            securityMode
+            securityPolicies,
+            securityModes
         };
     }
 
     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

@@ -9,7 +9,7 @@ const { resolveRegisteredServer } = require("./server-node-utils");
 
 function eventsServer(node, rootNode, nodeId) {
 
-
+    node.intervalMs = rootNode.intervalMs;
 
     // 🔥 ALTERADO: usar Map para garantir unicidade por nodeID
     node.queue = {
@@ -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) {