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

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

@@ -196,7 +196,7 @@ class OpcUaAddressSpaceBuilder {
         const path = this.buildObjectTypePath(config.name);
         desiredEntries.set(path, this.buildEntryDefinition("objectTypeDefinition", config, path, "", "typeDefinition"));
         this.collectBranchChildren(desiredEntries, config, path, "componentOf", objectTypeConfigs, {
-            skipAlarms: false,
+            skipAlarms: true,
             preserveCollectionNames: true,
             typeRootPath: path
         });
@@ -835,6 +835,9 @@ class OpcUaAddressSpaceBuilder {
             throw new Error("Object type is not available for instance " + instanceConfig.name + ": " + instanceConfig.objectsType);
         }
 
+        const addressSpace = this.server.engine.addressSpace;
+        const serverNode = addressSpace.rootFolder.objects.server;
+
         const objectName = instanceConfig.name;
         const nextPath = pathOverride || this.buildPath(parentPath, objectName);
         const namespace = this.getNamespaceForConfig(instanceConfig);
@@ -846,7 +849,8 @@ class OpcUaAddressSpaceBuilder {
             nodeId: this.resolveNodeId(instanceConfig, nextPath, namespace),
             rolePermissions: this.buildRolePermissions("objectTypeInstance", instanceConfig),
             typeDefinition: objectTypeEntry.node.nodeId,
-            eventNotifier: 1
+            eventNotifier: 1,
+            eventSourceOf: serverNode
         };
 
         if (relationship === "organizedBy") {
@@ -881,24 +885,55 @@ class OpcUaAddressSpaceBuilder {
     }
 
     extractNodeIdStringValue(nodeId) {
-        const m = String(nodeId || "").match(/(?:^|;)s=(.+)$/);
+        const m = String(nodeId || "").match(/(?:^|;)[si]=(.+)$/);
         return m ? m[1] : "";
     }
 
     rewriteInheritedNodeId(nodeId, typePrefix, instancePrefix) {
         if (!nodeId || !typePrefix || !instancePrefix) return nodeId;
-        const m = String(nodeId).match(/^(ns=\d+;s=)([\s\S]*)$/);
+        const m = String(nodeId).match(/^(ns=\d+;[si]=)([\s\S]*)$/);
         if (m && m[2].startsWith(typePrefix)) {
             return m[1] + instancePrefix + m[2].slice(typePrefix.length);
         }
         return nodeId;
     }
 
+    /**
+     * Rewrites an alarm variableNodeId from the type to the instance.
+     * Handles three formats:
+     *   1. Full nodeId: "ns=2;s=motor.status" → "ns=2;s=myserver.motor01.status"
+     *   2. Plain type-relative path: "motor.status" → resolved to instance variable path
+     *   3. Bare variable name: "status" → resolved relative to instance path
+     */
+    rewriteInheritedAlarmVariableRef(variableRef, typePrefix, instancePrefix, instancePath) {
+        if (!variableRef) return variableRef;
+        const ref = String(variableRef).trim();
+
+        // Try full nodeId rewrite first (ns=X;s=...)
+        const rewritten = this.rewriteInheritedNodeId(ref, typePrefix, instancePrefix);
+        if (rewritten !== ref) {
+            return rewritten;
+        }
+
+        // Plain path starting with typePrefix (e.g. "motor.status" → "myserver.motor01.status")
+        if (typePrefix && instancePrefix && ref.startsWith(typePrefix)) {
+            return instancePrefix + ref.slice(typePrefix.length);
+        }
+
+        // Bare variable name (e.g. "status") → resolve relative to instance path
+        if (ref.indexOf(".") === -1 && instancePath) {
+            return this.buildPath(instancePath, ref);
+        }
+
+        return ref;
+    }
+
     createInheritedBranchChildren(typeConfig, parentOpcNode, parentPath, typePrefix, instancePrefix) {
         const variables = Array.isArray(typeConfig.variables) ? typeConfig.variables : [];
         const methods = Array.isArray(typeConfig.methods) ? typeConfig.methods : [];
         const folders = Array.isArray(typeConfig.folders) ? typeConfig.folders : [];
         const objects = Array.isArray(typeConfig.objects) ? typeConfig.objects : [];
+        const alarms = Array.isArray(typeConfig.alarms) ? typeConfig.alarms : [];
 
         variables.forEach((varConfig) => {
             const childPath = this.buildPath(parentPath, varConfig.name);
@@ -939,6 +974,17 @@ class OpcUaAddressSpaceBuilder {
                 this.createInheritedBranchChildren(objectConfig, childNode, childPath, typePrefix, instancePrefix);
             }
         });
+
+        alarms.forEach((alarmConfig) => {
+            const childPath = this.buildPath(parentPath, alarmConfig.name);
+            const rewrittenConfig = Object.assign({}, alarmConfig, {
+                nodeId: this.rewriteInheritedNodeId(alarmConfig.nodeId, typePrefix, instancePrefix),
+                variableNodeId: this.rewriteInheritedAlarmVariableRef(
+                    alarmConfig.variableNodeId, typePrefix, instancePrefix, parentPath
+                )
+            });
+            this.addAlarm(parentOpcNode, rewrittenConfig, parentPath, "componentOf", childPath);
+        });
     }
 
     addAlarm(parentNode, alarmConfig, parentPath, relationship, pathOverride) {
@@ -1103,11 +1149,15 @@ class OpcUaAddressSpaceBuilder {
         const path = pathOverride || this.buildPath(parentPath, name);
         const nodeId = this.resolveNodeId(variableConfig, path, namespace);
         const browseName = variableConfig.displayName || name;
+        let initialValue = variableConfig.value;
+        if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+            initialValue = this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate;
+        }
         const state = {
             type,
             access,
-            isArray: this.isArrayValue(variableConfig.value),
-            currentValue: this.coerceValue(variableConfig.value, type, this.isArrayValue(variableConfig.value))
+            isArray: this.isArrayValue(initialValue),
+            currentValue: this.coerceValue(initialValue, type, this.isArrayValue(initialValue))
         };
 
         const variableNode = namespace.addVariable({
@@ -1125,6 +1175,9 @@ class OpcUaAddressSpaceBuilder {
             minimumSamplingInterval: 500,
             value: {
                 get: () => {
+                    if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+                        state.currentValue = this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate;
+                    }
                     this.emitTagAccess("read", {
                         path,
                         nodeID: nodeId,
@@ -1186,11 +1239,15 @@ class OpcUaAddressSpaceBuilder {
                             value: state.currentValue
                         });
 
+                        if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+                            this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate = !!state.currentValue;
+                            console.log(`AcceptAllCertificates updated by client to: ${state.currentValue}`);
+                            console.log(`Server Certificate Manager automaticallyAcceptUnknownCertificate is now: ${this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate}`);
+                        }
+
                         const alarm = this.variableStore.get(path).alarm
                         this.addressSpaceAlarm.checkAlarm(alarm, variant.value)
 
-
-
                         return StatusCodes.Good;
                     } catch (error) {
                         console.error("addVariable")
@@ -1425,13 +1482,6 @@ class OpcUaAddressSpaceBuilder {
 
         if (reference.indexOf(".") === 0) {
             const relativeReference = this.resolveObjectTypeRelativeReference(parentPath, reference);
-
-            //not work
-            var corrente = parentNode.getComponentByName("corrent")
-
-            return {
-                node: corrente
-            }
             if (this.variableStore.has(relativeReference)) {
                 return this.variableStore.get(relativeReference);
             }

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,30 +667,72 @@ 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;
+    }
+
+    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"];
 
-        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;
+        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);
+        }
 
-        if (securityMode === MessageSecurityMode.None) {
-            securityPolicy = SecurityPolicy.None;
-            if (rawPolicy !== "None") {
-                this.node.warn("Security policy adjusted to None because security mode is 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
         };
     }
 

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 = {