@vitormnm/node-red-simple-opcua 1.0.2 → 1.1.0

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

@@ -0,0 +1,140 @@
+"use strict";
+
+
+const registry = require("../opcua-server-registry");
+const { resolveRegisteredServer } = require("./server-node-utils");
+
+
+
+
+function eventsServer(node, rootNode, nodeId) {
+
+
+
+    // 🔥 ALTERADO: usar Map para garantir unicidade por nodeID
+    node.queue = {
+        read: new Map(),
+        write: new Map(),
+        alarm: new Map()
+    };
+
+    if (node.flushTimer) {
+        clearInterval(node.flushTimer);
+        node.flushTimer = null;
+    }
+
+
+    node.flushTimer = setInterval(() => {
+        flushQueue(node, nodeId);
+
+    }, rootNode.intervalMs);
+
+    ///rootNode.intervalMs
+    node.enqueueAccessEvent = function (event) {
+        if (!matchesServer(node.serverRef, event)) {
+
+        }
+
+        if (event.operation === "read") {
+            upsertEvent(node.queue.read, event);
+
+        }
+
+        if (event.operation === "write") {
+            upsertEvent(node.queue.write, event);
+        }
+
+        if (event.operation === "alarm") {
+            upsertEvent(node.queue.alarm, event);
+        }
+    };
+
+    registry.registerAccessListener(node.id, node);
+}
+
+
+
+
+
+function flushQueue(node, nodeId) {
+
+
+
+    // ALTERADO: usar size (Map)
+    if (!node.queue.read.size && !node.queue.write.size) {
+
+    }
+
+
+    const payload = {
+        serverRef: node.serverRef || "",
+        intervalMs: node.intervalMs,
+        timestamp: new Date().toISOString(),
+
+        // 🔥 ALTERADO: converter Map -> Array
+        read: Array.from(node.queue.read.values()),
+        write: Array.from(node.queue.write.values()),
+        alarm: Array.from(node.queue.alarm.values())
+    };
+
+    // ALTERADO: limpar Maps
+    node.queue.read.clear();
+    node.queue.write.clear();
+    node.queue.alarm.clear();
+
+    process.send({
+        type: "send",
+        data: {
+            payload,
+            opcua: {
+                server: payload.serverRef
+            }
+        },
+        nodeId: nodeId
+    });
+
+    process.send({
+        type: "status",
+        data: {
+            fill: "green",
+            shape: "dot",
+            text: "read " + payload.read.length + " write " + payload.write.length
+        },
+        nodeId: nodeId
+    });
+
+
+
+
+}
+
+
+function upsertEvent(map, event) {
+    const key = String(event.nodeID || "").trim();
+    if (!key) return;
+
+    map.set(key, event); // sobrescreve automaticamente
+}
+
+function matchesServer(serverRef, event) {
+    if (!serverRef) {
+        return true;
+    }
+
+    const normalizedRef = String(serverRef).trim();
+    return normalizedRef === String(event.serverId || "").trim()
+        || normalizedRef === String(event.serverNodeName || "").trim()
+        || normalizedRef === String(event.serverName || "").trim();
+}
+
+function normalizeInterval(value) {
+    const interval = Number(value);
+    if (!Number.isFinite(interval) || interval <= 0) {
+        return 500;
+    }
+
+    return Math.trunc(interval);
+}
+module.exports = {
+    "eventsServer": eventsServer
+}

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

@@ -0,0 +1,198 @@
+"use strict";
+
+const {
+    DATA_TYPE_MAP,
+    StatusCodes,
+    Variant,
+    VariantArrayType,
+    sanitizeNodeIdPath,
+    DataType,
+    coerceNodeId
+} = require("./opcua-constants");
+
+
+const { OpcUaAddressSpaceAlarm } = require("./opcua-address-space-alarm")
+
+
+class OpcUaServerMethods {
+
+    constructor(options) {
+        this.addressSpace = options.addressSpace
+        this.node = options.addressSpace
+        this.registry = options.registry
+
+
+        //Use OpcUaAddressSpaceAlarm to set an alarm message to be stored in the history.
+        this.addressSpaceAlarm = new OpcUaAddressSpaceAlarm({
+            registry: this.registry,
+            node: this.node
+        })
+
+
+    }
+
+
+    start() {
+        this.acknowledgeTypeMethod()
+        this.confirmTypeMethod()
+        this.conditionRefreshMethod()
+        this.addCommentMethod()
+    }
+
+    confirmTypeMethod() {
+        const confirmTypeMethod = this.addressSpace.findNode("ns=0;i=9113");
+        confirmTypeMethod.bindMethod(
+            (inputArguments, context, callback) => {
+                const eventId = inputArguments[0].value;
+                const comment = inputArguments[1].value;
+                const alarm = context.object;
+
+                // severity atual
+                const severity = alarm.severity.readValue().value.value;
+
+                // message atual
+                const message = alarm.message.readValue().value.value.text;
+
+
+                if (alarm.activeState.getValue()) {
+
+                    alarm.confirmedState.setValue(true);
+
+
+                    this.addressSpaceAlarm.raiseNewConditionAlarm(alarm, message, severity, true)
+                    alarm.raiseNewCondition({
+                        message: message,
+                        severity: severity,
+                        retain: true
+                    });
+
+
+                } else {
+                    alarm.confirmedState.setValue(true);
+                    this.addressSpaceAlarm.raiseNewConditionAlarm(alarm, message, severity, false)
+                }
+
+
+
+
+                callback(null, {
+                    statusCode: StatusCodes.Good,
+                    outputArguments: []
+                });
+            }
+        );
+
+    }
+
+    addCommentMethod() {
+        const addCommentMethod = this.addressSpace.findNode("ns=0;i=9029");
+        addCommentMethod.bindMethod(
+            (inputArguments, context, callback) => {
+                const eventId = inputArguments[0].value;
+                const comment = inputArguments[1].value;
+                const alarm = context.object;
+
+                // alarm.addComment(eventId, comment, context.session);
+                alarm.comment.setValueFromSource({
+                    value: comment,
+                    dataType: DataType.LocalizedText
+                });
+                callback(null, {
+                    statusCode: StatusCodes.Good,
+                    outputArguments: []
+                });
+            }
+        );
+    }
+
+    acknowledgeTypeMethod() {
+        const acknowledgeTypeMethod = this.addressSpace.findNode("ns=0;i=9111");
+
+        acknowledgeTypeMethod.bindMethod(
+            (inputArguments, context, callback) => {
+                const eventId = inputArguments[0].value;
+                const comment = inputArguments[1].value;
+                
+                const alarm = context.object;
+                // severity atual
+                const severity = alarm.severity.readValue().value.value;
+
+                // message atual
+                const message = alarm.message.readValue().value.value.text;
+
+                alarm.ackedState.setValue(true);
+
+
+                alarm.confirmedState.setValue(false);
+                // IMPORTANTE: Para o cliente "ver", o alarme precisa gerar um evento de mudança
+
+
+
+
+                this.addressSpaceAlarm.raiseNewConditionAlarm(alarm, message, severity, true)
+
+                callback(null, {
+                    statusCode: StatusCodes.Good,
+                    outputArguments: []
+                });
+            }
+        );
+
+    }
+
+
+    conditionRefreshMethod() {
+        const conditionType = this.addressSpace.findObjectType("ConditionType");
+
+        const conditionRefreshMethod = conditionType.getMethodByName("ConditionRefresh");
+
+        conditionRefreshMethod.bindMethod(
+            (inputArguments, context, callback) => {
+
+                const subscriptionId = inputArguments[0].value;
+
+                var ActiveAlarms = this.registry.getActiveAlarms(this.node)
+
+
+                ActiveAlarms.forEach(element => {
+                    const alarmNode = element.alarmNode
+
+                    alarmNode.raiseNewCondition({
+                        message: element.message,
+                        severity: element.severity,
+                        retain: element.retain
+                    });
+
+                });
+                
+
+                // for (const [, state] of retainedAlarms) {
+                //     const alarm = state.alarm;
+
+                //     alarm.raiseNewCondition({
+                //         message: state.message,
+                //         severity: state.severity,
+                //         retain: state.retain
+                //     });
+                // }
+
+                callback(null, {
+                    statusCode: StatusCodes.Good,
+                    outputArguments: [{
+                        dataType: DataType.String,
+                        value: JSON.stringify(ActiveAlarms)
+                    }]
+                });
+
+
+                // reenviar alarmes ativos
+                // aqui você percorre seus alarmes e dispara eventos novamente
+
+            }
+        );
+    }
+
+
+}
+
+module.exports = { OpcUaServerMethods }