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

package/client/lib/opcua-client-method-service.js

@@ -1,88 +1,88 @@
-"use strict";
-
-const { dataValueToItemResult, ensureArrayPayload, resolveNodeId, resolveMethodObjectId, buildVariantFromItem, callResultToItemResult } = require("../opcua-client-utils");
-
-class OpcUaClientMethodService {
-    async execute(node, msg, session, itemsResolver) {
-
-        // const items = ensureArrayPayload(msg, "OPC UA method call");
-        const items = itemsResolver.ensureMethodItems(node, msg, "OPC UA method");
-        const payload = [];
-
-
-
-        for (const item of items) {
-            const methodNodeId = this.resolveMethodId(item);
-
-            try {
-                const objectId = this.resolveMethodObjectIdFromItem(item) || await resolveMethodObjectId(
-                    session,
-                    methodNodeId,
-                    node.connection.methodObjectIdCache
-                );
-                const argumentDefinition = await this.safeGetMethodArgumentDefinition(
-                    session,
-                    methodNodeId,
-                    node.connection.methodDefinitionCache
-                );
-                const callRequest = {
-                    objectId,
-                    methodId: methodNodeId
-                };
-
-                if (Array.isArray(item.inputs) && item.inputs.length > 0) {
-                    callRequest.inputArguments = item.inputs.map((input) => buildVariantFromItem(input, input.type));
-                }
-
-                const callResult = await session.call(callRequest);
-                payload.push(callResultToItemResult(item, callResult, argumentDefinition));
-            } catch (itemError) {
-                payload.push({
-                    name: item.name || methodNodeId,
-                    nodeID: methodNodeId,
-                    status: itemError.message,
-                    outputs: []
-                });
-            }
-        }
-
-        return payload;
-    }
-
-
-
-    resolveMethodId(item) {
-        const methodId = item && (item.methodID || item.methodId || item.nodeID || item.nodeId);
-        if (!methodId || !String(methodId).trim()) {
-            throw new Error("Each method item must contain methodId or nodeID");
-        }
-
-        return String(methodId).trim();
-    }
-
-
-    resolveMethodObjectIdFromItem(item) {
-        const objectId = item && (item.objectID || item.objectId);
-        if (!objectId || !String(objectId).trim()) {
-            return "";
-        }
-
-        return String(objectId).trim();
-    }
-
-    async safeGetMethodArgumentDefinition(session, methodNodeId, cache) {
-        try {
-            return await getMethodArgumentDefinition(session, methodNodeId, cache);
-        } catch (error) {
-            return {
-                inputArguments: [],
-                outputArguments: []
-            };
-        }
-    }
-
-}
-
-module.exports = {
-    OpcUaClientMethodService
-};
+"use strict";
+
+const { dataValueToItemResult, ensureArrayPayload, resolveNodeId, resolveMethodObjectId, buildVariantFromItem, callResultToItemResult } = require("../opcua-client-utils");
+
+class OpcUaClientMethodService {
+    async execute(node, msg, session, itemsResolver) {
+
+        // const items = ensureArrayPayload(msg, "OPC UA method call");
+        const items = itemsResolver.ensureMethodItems(node, msg, "OPC UA method");
+        const payload = [];
+
+
+
+        for (const item of items) {
+            const methodNodeId = this.resolveMethodId(item);
+
+            try {
+                const objectId = this.resolveMethodObjectIdFromItem(item) || await resolveMethodObjectId(
+                    session,
+                    methodNodeId,
+                    node.connection.methodObjectIdCache
+                );
+                const argumentDefinition = await this.safeGetMethodArgumentDefinition(
+                    session,
+                    methodNodeId,
+                    node.connection.methodDefinitionCache
+                );
+                const callRequest = {
+                    objectId,
+                    methodId: methodNodeId
+                };
+
+                if (Array.isArray(item.inputs) && item.inputs.length > 0) {
+                    callRequest.inputArguments = item.inputs.map((input) => buildVariantFromItem(input, input.type));
+                }
+
+                const callResult = await session.call(callRequest);
+                payload.push(callResultToItemResult(item, callResult, argumentDefinition));
+            } catch (itemError) {
+                payload.push({
+                    name: item.name || methodNodeId,
+                    nodeID: methodNodeId,
+                    status: itemError.message,
+                    outputs: []
+                });
+            }
+        }
+
+        return payload;
+    }
+
+
+
+    resolveMethodId(item) {
+        const methodId = item && (item.methodID || item.methodId || item.nodeID || item.nodeId);
+        if (!methodId || !String(methodId).trim()) {
+            throw new Error("Each method item must contain methodId or nodeID");
+        }
+
+        return String(methodId).trim();
+    }
+
+
+    resolveMethodObjectIdFromItem(item) {
+        const objectId = item && (item.objectID || item.objectId);
+        if (!objectId || !String(objectId).trim()) {
+            return "";
+        }
+
+        return String(objectId).trim();
+    }
+
+    async safeGetMethodArgumentDefinition(session, methodNodeId, cache) {
+        try {
+            return await getMethodArgumentDefinition(session, methodNodeId, cache);
+        } catch (error) {
+            return {
+                inputArguments: [],
+                outputArguments: []
+            };
+        }
+    }
+
+}
+
+module.exports = {
+    OpcUaClientMethodService
+};

package/client/lib/opcua-client-read-service.js

@@ -1,16 +1,28 @@
-"use strict";
-
-const { dataValueToItemResult, resolveNodeId } = require("../opcua-client-utils");
-
-class OpcUaClientReadService {
-    async execute(node, msg, session, itemsResolver) {
-        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA read");
-        const nodeIds = items.map((item) => resolveNodeId(item));
-        const values = await session.readVariableValue(nodeIds);
-        return values.map((dataValue, index) => dataValueToItemResult(items[index], dataValue));
-    }
-}
-
-module.exports = {
-    OpcUaClientReadService
+"use strict";
+
+const { dataValueToItemResult, resolveNodeId, enrichItemResultWithEnumeration } = require("../opcua-client-utils");
+
+class OpcUaClientReadService {
+    async execute(node, msg, session, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA read");
+        const nodeIds = items.map((item) => resolveNodeId(item));
+        const values = await session.readVariableValue(nodeIds);
+        
+        const cache = new Map();
+        const results = [];
+        
+        for (let index = 0; index < values.length; index++) {
+            const dataValue = values[index];
+            const item = items[index];
+            let result = dataValueToItemResult(item, dataValue);
+            result = await enrichItemResultWithEnumeration(result, session, cache, nodeIds[index]);
+            results.push(result);
+        }
+        
+        return results;
+    }
+}
+
+module.exports = {
+    OpcUaClientReadService
 };

package/client/lib/opcua-client-subscription-id-service.js

@@ -1,25 +1,25 @@
-"use strict";
-
-const { ClientSubscription } = require("node-opcua");
-
-class OpcUaClientSubscriptionIdService {
-    async execute(node) {
-        const session = await node.connection.getSession();
-        const subscription = ClientSubscription.create(session, {
-            requestedPublishingInterval: 1000,
-            requestedLifetimeCount: 100,
-            requestedMaxKeepAliveCount: 10,
-            maxNotificationsPerPublish: 100,
-            publishingEnabled: true,
-            priority: 10
-        });
-
-        const subscriptionId = subscription.subscriptionId;
-        await subscription.terminate();
-        return subscriptionId;
-    }
-}
-
-module.exports = {
-    OpcUaClientSubscriptionIdService
+"use strict";
+
+const { ClientSubscription } = require("node-opcua");
+
+class OpcUaClientSubscriptionIdService {
+    async execute(node) {
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: 1000,
+            requestedLifetimeCount: 100,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 10
+        });
+
+        const subscriptionId = subscription.subscriptionId;
+        await subscription.terminate();
+        return subscriptionId;
+    }
+}
+
+module.exports = {
+    OpcUaClientSubscriptionIdService
 };

package/client/lib/opcua-client-subscription-service.js

@@ -1,171 +1,176 @@
-"use strict";
-
-const {
-    ClientMonitoredItem,
-    ClientSubscription,
-    TimestampsToReturn,
-    AttributeIds,
-    constructEventFilter
-} = require("node-opcua");
-
-const {
-    dataValueToItemResult,
-    dataValueToItemResultEvent,
-    resolveName,
-    resolveNodeId,
-    statusCodeToString
-} = require("../opcua-client-utils");
-
-class OpcUaClientSubscriptionService {
-    async startDataSubscription(node, msg, itemsResolver) {
-        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
-        await this.stop(node);
-
-        const session = await node.connection.getSession();
-        const subscription = ClientSubscription.create(session, {
-            requestedPublishingInterval: node.publishingInterval,
-            requestedLifetimeCount: 60,
-            requestedMaxKeepAliveCount: 10,
-            maxNotificationsPerPublish: 100,
-            publishingEnabled: true,
-            priority: 1
-        });
-
-        subscription.on("error", (error) => {
-            node.status({ fill: "red", shape: "ring", text: "subscription error" });
-            node.error(error);
-        });
-
-        node.subscription = subscription;
-        node.monitoredItems = items.map((item) => {
-            const monitoredItem = ClientMonitoredItem.create(
-                subscription,
-                { nodeId: resolveNodeId(item) },
-                {
-                    samplingInterval: node.samplingInterval,
-                    discardOldest: true,
-                    queueSize: 1
-                },
-                TimestampsToReturn.Both
-            );
-
-            monitoredItem.on("changed", (dataValue) => {
-                const payload = dataValueToItemResult(item, dataValue);
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: resolveName(item, payload.nodeID) + " changed"
-                });
-                node.send({
-                    topic: payload.name,
-                    payload,
-                    opcua: {
-                        mode: "subscription",
-                        nodeID: payload.nodeID,
-                        status: payload.status
-                    }
-                });
-            });
-
-            monitoredItem.on("err", (message) => {
-                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
-            });
-
-            return monitoredItem;
-        });
-
-        return items;
-    }
-
-    async startEventSubscription(node, msg, itemsResolver) {
-        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
-        await this.stop(node);
-
-        const session = await node.connection.getSession();
-        const subscription = ClientSubscription.create(session, {
-            requestedPublishingInterval: node.publishingInterval,
-            requestedLifetimeCount: 60,
-            requestedMaxKeepAliveCount: 10,
-            maxNotificationsPerPublish: 100,
-            publishingEnabled: true,
-            priority: 2
-        });
-
-        subscription.on("error", (error) => {
-            node.status({ fill: "red", shape: "ring", text: "subscription error" });
-            node.error(error);
-        });
-
-        node.subscription = subscription;
-
-        const eventFilter = constructEventFilter([
-            "EventId",
-            "EventType",
-            "SourceName",
-            "SourceNode",
-            "Message",
-            "Severity",
-            "ActiveState",
-            "AckedState",
-            "ConfirmedState",
-            "Time"
-        ]);
-
-        node.monitoredItems = items.map((item) => {
-            const monitoredItem = ClientMonitoredItem.create(
-                subscription,
-                {
-                    nodeId: resolveNodeId(item),
-                    attributeId: AttributeIds.EventNotifier
-                },
-                {
-                    samplingInterval: 0,
-                    queueSize: 100,
-                    discardOldest: true,
-                    filter: eventFilter
-                },
-                TimestampsToReturn.Both
-            );
-
-            monitoredItem.on("changed", async (eventFields) => {
-                const payload = await dataValueToItemResultEvent(item, eventFields, session);
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: resolveName(item, payload.nodeID) + " changed"
-                });
-                node.send({
-                    topic: payload.name,
-                    payload,
-                    opcua: {
-                        mode: "subscription",
-                        nodeID: payload.nodeID,
-                        status: payload.status
-                    }
-                });
-            });
-
-            monitoredItem.on("err", (message) => {
-                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
-            });
-
-            return monitoredItem;
-        });
-
-        return items;
-    }
-
-    async stop(node) {
-        const subscription = node.subscription;
-        node.monitoredItems = [];
-        node.subscription = null;
-
-        if (subscription) {
-            await subscription.terminate();
-        }
-    }
-}
-
-module.exports = {
-    OpcUaClientSubscriptionService
+"use strict";
+
+const {
+    ClientMonitoredItem,
+    ClientSubscription,
+    TimestampsToReturn,
+    AttributeIds,
+    constructEventFilter
+} = require("node-opcua");
+
+const {
+    dataValueToItemResult,
+    dataValueToItemResultEvent,
+    enrichItemResultWithEnumeration,
+    resolveName,
+    resolveNodeId,
+    statusCodeToString
+} = require("../opcua-client-utils");
+
+class OpcUaClientSubscriptionService {
+    async startDataSubscription(node, msg, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
+        await this.stop(node);
+
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: node.publishingInterval,
+            requestedLifetimeCount: 60,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 1
+        });
+
+        subscription.on("error", (error) => {
+            node.status({ fill: "red", shape: "ring", text: "subscription error" });
+            node.error(error);
+        });
+
+        node.subscription = subscription;
+        node.monitoredItems = items.map((item) => {
+            const monitoredItem = ClientMonitoredItem.create(
+                subscription,
+                { nodeId: resolveNodeId(item) },
+                {
+                    samplingInterval: node.samplingInterval,
+                    discardOldest: true,
+                    queueSize: 1
+                },
+                TimestampsToReturn.Both
+            );
+
+            const cache = new Map();
+            monitoredItem.on("changed", async (dataValue) => {
+                let payload = dataValueToItemResult(item, dataValue);
+                payload = await enrichItemResultWithEnumeration(payload, session, cache, resolveNodeId(item));
+                
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: resolveName(item, payload.nodeID) + " changed"
+                });
+                node.send({
+                    topic: payload.name,
+                    payload,
+                    opcua: {
+                        mode: "subscription",
+                        nodeID: payload.nodeID,
+                        status: payload.status
+                    }
+                });
+            });
+
+            monitoredItem.on("err", (message) => {
+                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
+            });
+
+            return monitoredItem;
+        });
+
+        return items;
+    }
+
+    async startEventSubscription(node, msg, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
+        await this.stop(node);
+
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: node.publishingInterval,
+            requestedLifetimeCount: 60,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 2
+        });
+
+        subscription.on("error", (error) => {
+            node.status({ fill: "red", shape: "ring", text: "subscription error" });
+            node.error(error);
+        });
+
+        node.subscription = subscription;
+
+        const eventFilter = constructEventFilter([
+            "EventId",
+            "EventType",
+            "SourceName",
+            "SourceNode",
+            "Message",
+            "Severity",
+            "ActiveState",
+            "AckedState",
+            "ConfirmedState",
+            "Time",
+            "ConditionId"
+        ]);
+
+        node.monitoredItems = items.map((item) => {
+            const monitoredItem = ClientMonitoredItem.create(
+                subscription,
+                {
+                    nodeId: resolveNodeId(item),
+                    attributeId: AttributeIds.EventNotifier
+                },
+                {
+                    samplingInterval: 0,
+                    queueSize: 100,
+                    discardOldest: true,
+                    filter: eventFilter
+                },
+                TimestampsToReturn.Both
+            );
+
+            monitoredItem.on("changed", async (eventFields) => {
+                const payload = await dataValueToItemResultEvent(item, eventFields, session);
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: resolveName(item, payload.nodeID) + " changed"
+                });
+                node.send({
+                    topic: payload.name,
+                    payload,
+                    opcua: {
+                        mode: "subscription",
+                        nodeID: payload.nodeID,
+                        status: payload.status
+                    }
+                });
+            });
+
+            monitoredItem.on("err", (message) => {
+                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
+            });
+
+            return monitoredItem;
+        });
+
+        return items;
+    }
+
+    async stop(node) {
+        const subscription = node.subscription;
+        node.monitoredItems = [];
+        node.subscription = null;
+
+        if (subscription) {
+            await subscription.terminate();
+        }
+    }
+}
+
+module.exports = {
+    OpcUaClientSubscriptionService
 };