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

package/client/lib/opcua-client-browser.js

@@ -0,0 +1,291 @@
+"use strict";
+
+const {
+    AttributeIds,
+    BrowseDirection,
+    DataType,
+    NodeClass,
+    coerceNodeId,
+    makeNodeId
+} = require("node-opcua");
+
+async function browseNode(session, root) {
+    const nodeID = normalizeNodeId(root.nodeID || root.nodeId || ROOT_NODE_ID);
+    const result = {
+        name: root.name || await readBrowseName(session, nodeID, "RootFolder"),
+        nodeID,
+        browse: []
+    };
+
+    const browseResult = await session.browse({
+        nodeId: nodeID,
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        resultMask: 63
+    });
+
+    const references = browseResult && Array.isArray(browseResult.references)
+        ? browseResult.references
+        : [];
+
+    for (const reference of references) {
+        result.browse.push(await mapReference(session, reference));
+    }
+
+    return result;
+}
+
+function normalizeBrowseRoots(payload) {
+    if (payload === undefined || payload === null) {
+        return [{ name: "RootFolder", nodeID: ROOT_NODE_ID }];
+    }
+
+    if (!Array.isArray(payload)) {
+        throw new Error("OPC UA browse expects msg.payload as an array");
+    }
+
+    if (!payload.length) {
+        return [{ name: "RootFolder", nodeID: ROOT_NODE_ID }];
+    }
+
+    return payload.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new Error("Each browse item must be an object");
+        }
+
+        return {
+            name: typeof item.name === "string" && item.name.trim() ? item.name.trim() : "",
+            nodeID: normalizeNodeId(item.nodeID || item.nodeId)
+        };
+    });
+}
+
+async function mapReference(session, reference) {
+    const childNodeId = normalizeNodeId(reference.nodeId);
+    const nodeClass = resolveNodeClassName(reference.nodeClass);
+    const browseName = extractBrowseName(reference.browseName, childNodeId);
+    const item = {
+        nodeID: childNodeId,
+        nodeClass,
+        browseName,
+        displayName: extractDisplayName(reference.displayName, browseName),
+        description: await readDescription(session, childNodeId)
+    };
+
+    const hasTypeDefinition = await readHasTypeDefinition(session, childNodeId);
+    if (hasTypeDefinition) {
+        item.hasTypeDefinition = hasTypeDefinition;
+    }
+
+    if (nodeClass === "Variable") {
+        item.value = await readValue(session, childNodeId);
+        item.dataType = await readDataType(session, childNodeId);
+        return item;
+    }
+
+    if (nodeClass === "Method") {
+        const definition = await readMethodArguments(session, childNodeId);
+        item.inputArguments = definition.inputArguments;
+        item.outputArguments = definition.outputArguments;
+        return item;
+    }
+
+    return item;
+}
+
+async function readHasTypeDefinition(session, nodeId) {
+    try {
+        const browseResult = await session.browse({
+            nodeId,
+            browseDirection: BrowseDirection.Forward,
+            referenceTypeId: makeNodeId(40, 0), // HasTypeDefinition
+            includeSubtypes: false,
+            resultMask: 63
+        });
+        const references = browseResult && Array.isArray(browseResult.references)
+            ? browseResult.references
+            : [];
+        if (!references.length) {
+            return null;
+        }
+
+        const reference = references[0];
+        const typeNodeId = normalizeNodeId(reference.nodeId);
+        return {
+            nodeID: typeNodeId,
+            browseName: extractBrowseName(reference.browseName, typeNodeId),
+            displayName: extractDisplayName(reference.displayName, typeNodeId)
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
+async function readBrowseName(session, nodeId, fallback) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.BrowseName
+        });
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+        if (value && value.name) {
+            return String(value.name);
+        }
+    } catch (error) {
+        // Use fallback below.
+    }
+
+    return String(fallback || nodeId);
+}
+
+async function readDescription(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.Description
+        });
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+
+        if (typeof value === "string") {
+            return value;
+        }
+
+        if (value && typeof value.text === "string") {
+            return value.text;
+        }
+    } catch (error) {
+        // Return empty description when unavailable.
+    }
+
+    return "";
+}
+
+async function readValue(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.Value
+        });
+
+        if (!dataValue || !dataValue.value) {
+            return "";
+        }
+
+        const value = dataValue.value.value;
+        return value === undefined || value === null ? "" : value;
+    } catch (error) {
+        return "";
+    }
+}
+
+async function readDataType(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.DataType
+        });
+
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+        if (!value) {
+            return "";
+        }
+
+        if (value.namespace === 0 && typeof value.value === "number") {
+            return DataType[value.value] || value.toString();
+        }
+
+        return value.toString();
+    } catch (error) {
+        return "";
+    }
+}
+
+async function readMethodArguments(session, nodeId) {
+    try {
+        const definition = await session.getArgumentDefinition(nodeId);
+        return {
+            inputArguments: normalizeMethodArguments(definition && definition.inputArguments),
+            outputArguments: normalizeMethodArguments(definition && definition.outputArguments)
+        };
+    } catch (error) {
+        return {
+            inputArguments: [],
+            outputArguments: []
+        };
+    }
+}
+
+function normalizeNodeId(nodeId) {
+    return coerceNodeId(nodeId).toString();
+}
+
+function resolveNodeClassName(nodeClass) {
+    if (!nodeClass && nodeClass !== 0) {
+        return "";
+    }
+
+    if (typeof nodeClass === "object" && typeof nodeClass.key === "string") {
+        return nodeClass.key;
+    }
+
+    if (typeof nodeClass === "string") {
+        return nodeClass;
+    }
+
+    return NodeClass[nodeClass] || String(nodeClass);
+}
+
+function extractBrowseName(browseName, fallback) {
+    if (browseName && typeof browseName.name === "string" && browseName.name) {
+        return browseName.name;
+    }
+
+    return String(fallback || "");
+}
+
+function extractDisplayName(displayName, fallback) {
+    if (displayName && typeof displayName.text === "string" && displayName.text) {
+        return displayName.text;
+    }
+
+    if (typeof displayName === "string" && displayName) {
+        return displayName;
+    }
+
+    return String(fallback || "");
+}
+
+function normalizeMethodArguments(argumentsList) {
+    if (!Array.isArray(argumentsList)) {
+        return [];
+    }
+
+    return argumentsList.map((argument, index) => ({
+        name: argument && argument.name ? String(argument.name) : "arg" + (index + 1),
+        dataType: resolveArgumentDataType(argument && argument.dataType),
+        description: argument && argument.description && typeof argument.description.text === "string"
+            ? argument.description.text
+            : ""
+    }));
+}
+
+function resolveArgumentDataType(dataType) {
+    if (!dataType) {
+        return "";
+    }
+
+    if (dataType.namespace === 0 && typeof dataType.value === "number") {
+        return DataType[dataType.value] || dataType.toString();
+    }
+
+    return dataType.toString();
+}
+
+const ROOT_NODE_ID = "i=84";
+
+module.exports = {
+    browseNode,
+    normalizeBrowseRoots,
+    normalizeNodeId,
+    ROOT_NODE_ID
+};

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

@@ -0,0 +1,16 @@
+"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
+};

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

@@ -0,0 +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
+};

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

@@ -0,0 +1,171 @@
+"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
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+
+const { DataType, coerceNodeId } = require("node-opcua");
+const {
+    buildVariantFromItem,
+    dataValueToItemResult,
+    normalizeTypeName,
+    resolveNodeId,
+    statusCodeToString
+} = require("../opcua-client-utils");
+
+class OpcUaClientWriteService {
+    async execute(node, msg, session, itemsResolver) {
+        const items = itemsResolver.ensureWriteItems(node, msg);
+        const results = [];
+
+        for (const item of items) {
+            const nodeId = resolveNodeId(item);
+
+            try {
+                const explicitType = normalizeTypeName(item.type);
+                const builtInType = await session.getBuiltInDataType(coerceNodeId(nodeId));
+                const typeName = explicitType || DataType[builtInType];
+                const variant = buildVariantFromItem(item, typeName);
+                const statusCode = await session.writeSingleNode(nodeId, variant);
+                const dataValue = await session.readVariableValue(nodeId);
+                const result = dataValueToItemResult(item, dataValue);
+
+                if (statusCode && statusCode.name && statusCode.name !== "Good") {
+                    result.status = statusCodeToString(statusCode);
+                }
+
+                results.push(result);
+            } catch (itemError) {
+                results.push({
+                    name: item.name || nodeId,
+                    nodeID: nodeId,
+                    value: item.value,
+                    type: normalizeTypeName(item.type) || null,
+                    status: itemError.message,
+                    sourceTimestamp: null,
+                    serverTimestamp: null
+                });
+            }
+        }
+
+        return results;
+    }
+}
+
+module.exports = {
+    OpcUaClientWriteService
+};

package/client/opcua-client-config.html

@@ -0,0 +1,80 @@
+<script type="text/javascript">
+    (function () {
+        function toggleCredentials() {
+            var authType = $("#node-config-input-authType").val();
+            $(".opcua-client-auth-row").toggle(authType === "username");
+        }
+
+        RED.nodes.registerType("opcua-client-config", {
+            category: "config",
+            defaults: {
+                name: { value: "" },
+                endpoint: { value: "opc.tcp://localhost:4840", required: true },
+                securityPolicy: { value: "None", required: true },
+                securityMode: { value: "None", required: true },
+                authType: { value: "anonymous", required: true }
+            },
+            credentials: {
+                username: { type: "text" },
+                password: { type: "password" }
+            },
+            label: function () {
+                return this.name || this.endpoint || "opcua-client-config";
+            },
+            oneditprepare: function () {
+                $("#node-config-input-authType").on("change", toggleCredentials);
+                toggleCredentials();
+            }
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="opcua-client-config">
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" placeholder="OPC UA Client">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-endpoint"><i class="fa fa-plug"></i> Endpoint</label>
+        <input type="text" id="node-config-input-endpoint" placeholder="opc.tcp://localhost:4840">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-securityPolicy"><i class="fa fa-lock"></i> Security Policy</label>
+        <select id="node-config-input-securityPolicy">
+            <option value="None">None</option>
+            <option value="Basic128Rsa15">Basic128Rsa15</option>
+            <option value="Basic256">Basic256</option>
+            <option value="Basic256Sha256">Basic256Sha256</option>
+            <option value="Aes128_Sha256_RsaOaep">Aes128_Sha256_RsaOaep</option>
+            <option value="Aes256_Sha256_RsaPss">Aes256_Sha256_RsaPss</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-securityMode"><i class="fa fa-shield"></i> Security Mode</label>
+        <select id="node-config-input-securityMode">
+            <option value="None">None</option>
+            <option value="Sign">Sign</option>
+            <option value="SignAndEncrypt">SignAndEncrypt</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-authType"><i class="fa fa-user"></i> Auth</label>
+        <select id="node-config-input-authType">
+            <option value="anonymous">Anonymous</option>
+            <option value="username">Username/Password</option>
+        </select>
+    </div>
+    <div class="form-row opcua-client-auth-row">
+        <label for="node-config-input-username"><i class="fa fa-user-circle"></i> Username</label>
+        <input type="text" id="node-config-input-username">
+    </div>
+    <div class="form-row opcua-client-auth-row">
+        <label for="node-config-input-password"><i class="fa fa-key"></i> Password</label>
+        <input type="password" id="node-config-input-password">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="opcua-client-config">
+    <p>Shared OPC UA client connection for read, write and method nodes.</p>
+    <p>This is a Node-RED configuration node, using <code>category: "config"</code> and the <code>node-config-input-*</code> field pattern described in the official docs.</p>
+</script>