@vitormnm/node-red-simple-opcua 1.4.0 → 1.4.2

package/client/opcua-client.js

@@ -20,18 +20,25 @@ const {
 
 const { OpcUaClientReadService } = require("./lib/opcua-client-read-service");
 const { OpcUaClientWriteService } = require("./lib/opcua-client-write-service");
+const { OpcUaClientMethodService } = require("./lib/opcua-client-method-service");
 const { OpcUaClientSubscriptionService } = require("./lib/opcua-client-subscription-service");
 const { OpcUaClientSubscriptionIdService } = require("./lib/opcua-client-subscription-id-service");
+const path = require("path");
+
+
 
 module.exports = function (RED) {
     function OpcUaClientNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
+      
+
         node.name = (config.name || "").trim();
         node.connection = RED.nodes.getNode(config.connection);
         node.mode = config.mode || "read";
         node.selectedItems = parseConfiguredItems(config.selectedItems);
+        node.methodItems = parseConfiguredMethodsItems(config.selectedItems);
         node.valueProperty = (config.valueProperty || "payload").trim();
         node.valuePropertyType = config.valuePropertyType || "msg";
         node.samplingInterval = Math.max(Number(config.samplingInterval) || 250, 50);
@@ -42,6 +49,7 @@ module.exports = function (RED) {
         const itemsResolver = createItemsResolver(RED);
         const readService = new OpcUaClientReadService();
         const writeService = new OpcUaClientWriteService();
+        const methodService = new OpcUaClientMethodService();
         const subscriptionService = new OpcUaClientSubscriptionService();
         const subscriptionIdService = new OpcUaClientSubscriptionIdService();
 
@@ -70,19 +78,24 @@ module.exports = function (RED) {
                 }
 
                 const session = await node.connection.getSession();
+
                 let payload;
 
                 if (node.mode === "read") {
+                   
                     payload = await readService.execute(node, msg, session, itemsResolver);
                     node.status({ fill: "green", shape: "dot", text: "read " + payload.length + " nodes" });
                 } else if (node.mode === "write") {
+                    
                     payload = await writeService.execute(node, msg, session, itemsResolver);
                     node.status({ fill: "green", shape: "dot", text: "write " + payload.length + " nodes" });
                 } else if (node.mode === "browse") {
                     payload = await executeBrowse(node, msg, session);
                     node.status({ fill: "green", shape: "dot", text: "browsed " + payload.length + " nodes" });
                 } else if (node.mode === "method") {
-                    payload = await executeMethod(node, msg, session);
+                    //payload = await executeMethod(node, msg, session);
+
+                    payload = await methodService.execute(node, msg, session, itemsResolver);
                     node.status({ fill: "green", shape: "dot", text: "called " + payload.length + " methods" });
                 } else if (node.mode === "getSubscriptionId") {
                     payload = await subscriptionIdService.execute(node);
@@ -121,63 +134,14 @@ module.exports = function (RED) {
         return payload;
     }
 
-    async function executeMethod(node, msg, session) {
-        const items = ensureArrayPayload(msg, "OPC UA method call");
-        const payload = [];
-
-        for (const item of items) {
-            const methodNodeId = resolveMethodId(item);
-
-            try {
-                const objectId = resolveMethodObjectIdFromItem(item) || await resolveMethodObjectId(
-                    session,
-                    methodNodeId,
-                    node.connection.methodObjectIdCache
-                );
-                const argumentDefinition = await 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;
-    }
 
-    async function safeGetMethodArgumentDefinition(session, methodNodeId, cache) {
-        try {
-            return await getMethodArgumentDefinition(session, methodNodeId, cache);
-        } catch (error) {
-            return {
-                inputArguments: [],
-                outputArguments: []
-            };
-        }
-    }
 
     function createItemsResolver(REDRuntime) {
         return {
             ensureClientItems,
-            ensureWriteItems
+            ensureWriteItems,
+            ensureMethodItems
         };
 
         function ensureClientItems(node, msg, contextName) {
@@ -206,13 +170,49 @@ module.exports = function (RED) {
                 return node.selectedItems.map((item, index) => ({
                     name: item.name,
                     nodeID: item.nodeID,
-                    type: item.type,
+                    type: item.dataType,
                     value: resolveWriteValueForItem(node, msg, item, index, configuredValue, REDRuntime)
                 }));
             }
 
             return ensureArrayPayload(msg, "OPC UA write");
         }
+
+        function ensureMethodItems(node, msg) {
+            const payload = msg ? msg.payload : undefined;
+
+            if (Array.isArray(payload) && payload.length > 0) {
+                return payload;
+            }
+
+            if (node.methodItems?.length > 0) {
+                return node.methodItems.map(item => ({
+                    name: item.name,
+                    nodeID: item.nodeID,
+                    objectID: item.objectId,
+                    inputs: item.inputs.map(input => {
+                        const value = resolveConfiguredWriteValue(
+                            {
+                                ...node,
+                                valueProperty: input.valueProperty,
+                                valuePropertyType: input.valuePropertyType
+                            },
+                            msg,
+                            REDRuntime
+                        );
+
+                        return {
+                            name: input.name,
+                            type: input.dataType,
+                            value
+                        };
+                    }),
+                    outputs: item.outputs || []
+                }));
+            }
+
+            return ensureArrayPayload(msg, "OPC UA method");
+        }
     }
 
     function normalizeBrowseRoots(node, payload) {
@@ -268,6 +268,25 @@ module.exports = function (RED) {
         return String(methodId).trim();
     }
 
+    function parseConfiguredMethodsItems(rawValue) {
+        try {
+            if (!rawValue || typeof rawValue !== "string") {
+                return [];
+            }
+
+
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+
+            return parsed
+
+        } catch (error) {
+            return [];
+        }
+    }
+
     function parseConfiguredItems(rawValue) {
         if (!rawValue || typeof rawValue !== "string") {
             return [];
@@ -344,6 +363,25 @@ module.exports = function (RED) {
         return REDRuntime.util.getMessageProperty(msg, property);
     }
 
+    function resolveConfiguredMethodValue(node, msg, REDRuntime) {
+        const property = node.valueProperty || "payload";
+        const type = node.valuePropertyType || "msg";
+
+        if (type === "msg") {
+            return REDRuntime.util.getMessageProperty(msg, property);
+        }
+
+        if (type === "flow") {
+            return node.context().flow.get(property);
+        }
+
+        if (type === "global") {
+            return node.context().global.get(property);
+        }
+
+        return REDRuntime.util.getMessageProperty(msg, property);
+    }
+
     function selectWriteValueForItem(configuredValue, item, index) {
         if (Array.isArray(configuredValue)) {
             const byName = item && item.name ? configuredValue.find((entry) => entry && entry.name === item.name) : undefined;
@@ -376,5 +414,16 @@ module.exports = function (RED) {
         return configuredValue;
     }
 
+    RED.httpAdmin.get("/opcua-client-resource/style.css", function (req, res) {
+        const cssPath = path.join(__dirname, "view", "opcua-client.css");
+        res.sendFile(cssPath);
+    });
+
+    RED.httpAdmin.get("/opcua-client-resource/script.js", function (req, res) {
+        const jsPath = path.join(__dirname, "view", "opcua-client.js");
+        res.sendFile(jsPath);
+    });
+
+
     RED.nodes.registerType("opcua-client", OpcUaClientNode);
 };

package/client/view/opcua-client.css

@@ -0,0 +1,411 @@
+
+    body.opcua-tree-modal-open {
+        overflow: hidden;
+    }
+
+    .opcua-tree-editor {
+        width: 100%;
+        min-height: 120px;
+        border: 1px solid var(--red-ui-form-input-border-color, #d9d9d9);
+        background: var(--red-ui-form-input-background, #fff);
+        border-radius: 4px;
+        overflow: auto;
+    }
+
+    .opcua-tree-row {
+        display: flex;
+        align-items: center;
+        gap: 5px;
+        min-height: 24px;
+        padding: 2px 6px;
+        font-size: 12px;
+        border-bottom: 1px solid transparent;
+    }
+
+    .opcua-tree-row:hover {
+        background: var(--red-ui-list-item-background-hover, #f3f7fd);
+    }
+
+    .opcua-tree-row.is-selected {
+        background: var(--red-ui-list-item-background-selected, #d9ecff);
+        color: var(--red-ui-list-item-color-selected, inherit);
+    }
+
+    .opcua-tree-indent {
+        flex: 0 0 auto;
+        width: 14px;
+    }
+
+    .opcua-tree-twisty {
+        width: 16px;
+        text-align: center;
+        color: #777;
+        flex: 0 0 16px;
+        cursor: pointer;
+    }
+
+    .opcua-tree-icon {
+        width: 14px;
+        text-align: center;
+        color: #777;
+        flex: 0 0 14px;
+    }
+
+    .opcua-tree-label {
+        flex: 1 1 auto;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+
+    .opcua-tree-type {
+        color: #777;
+        font-size: 11px;
+        flex: 0 0 auto;
+    }
+
+    .opcua-tree-title {
+        min-width: 100px;
+        font-weight: 600;
+        color: #444;
+    }
+
+    .opcua-client-nodeid-label {
+        margin-left: auto;
+        text-align: right;
+        word-break: break-all;
+        max-width: 320px;
+        color: #777;
+        font-size: 12px;
+    }
+
+    .opcua-tree-actions {
+        margin-left: auto;
+        display: flex;
+        gap: 6px;
+        align-items: center;
+    }
+
+    .opcua-tree-empty {
+        padding: 14px;
+        border: 1px dashed #d9d9d9;
+        border-radius: 4px;
+        background: #fafafa;
+        color: #777;
+        text-align: center;
+    }
+
+    .opcua-client-json {
+        width: 100%;
+        box-sizing: border-box;
+    }
+
+    .opcua-client-tag-box {
+        width: 100%;
+        min-height: 70px;
+    }
+
+    .opcua-client-tag-chip {
+        display: grid;
+        grid-template-columns: 18px 1fr auto;
+        grid-template-areas:
+            "icon name name"
+            "icon write right";
+        column-gap: 8px;
+        row-gap: 6px;
+        align-items: center;
+        border: 1px solid #d9d9d9;
+        border-radius: 4px;
+        background: #fafafa;
+        padding: 6px 8px;
+        margin-bottom: 6px;
+    }
+
+    .opcua-client-tag-chip .opcua-tree-icon {
+        grid-area: icon;
+    }
+
+    .opcua-client-tag-chip .opcua-tree-title {
+        grid-area: name;
+        min-width: 0;
+    }
+
+    .opcua-client-tag-right {
+        grid-area: right;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .opcua-client-tag-right .opcua-client-nodeid-label {
+        margin: 0;
+        max-width: 320px;
+    }
+
+    .opcua-client-tag-right .opcua-tree-actions {
+        margin: 0;
+    }
+
+    .opcua-client-tag-chip-meta,
+    .opcua-client-description {
+        color: #777;
+        font-size: 12px;
+    }
+
+    .opcua-client-tag-write {
+        display: flex;
+        gap: 8px;
+        align-items: center;
+        width: 100%;
+        margin-top: 0;
+        margin-left: 0;
+        grid-area: write;
+    }
+
+    .opcua-client-tag-write input {
+        font-size: 12px;
+    }
+
+    .opcua-client-tag-write input {
+        flex: 1 1 auto;
+        min-width: 120px;
+    }
+
+    .opcua-client-tag-write .red-ui-typedInput-container {
+        flex: 1 1 auto;
+        min-width: 220px;
+        width: 100% !important;
+    }
+
+    .opcua-client-tag-write .red-ui-typedInput-container input.red-ui-typedInput-input {
+        width: calc(100% - 92px);
+        min-width: 120px;
+    }
+
+    .opcua-client-load-row {
+        display: flex;
+        gap: 8px;
+        align-items: center;
+    }
+
+    .opcua-client-load-row input {
+        flex: 1 1 auto;
+    }
+
+    .opcua-tree-search {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        width: 100%;
+        padding: 6px 10px;
+        border: 1px solid #d9d9d9;
+        border-radius: 6px;
+        background: #fafafa;
+    }
+
+    .opcua-tree-search input {
+        flex: 1 1 auto;
+        min-width: 120px;
+        border: 0;
+        outline: 0;
+        background: transparent;
+        box-shadow: none;
+        margin: 0;
+    }
+
+    .opcua-tree-modal {
+        position: fixed;
+        inset: 0;
+        z-index: 2000;
+        background: rgba(0, 0, 0, 0.45);
+        padding: 24px;
+        box-sizing: border-box;
+    }
+
+    .opcua-tree-modal__dialog {
+        display: flex;
+        flex-direction: column;
+        width: 100%;
+        height: 100%;
+        background: #f3f3f3;
+        border-radius: 8px;
+        overflow: hidden;
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.2);
+    }
+
+    .opcua-tree-modal__header,
+    .opcua-tree-modal__toolbar {
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 10px;
+        padding: 14px 18px;
+        background: #fff;
+        border-bottom: 1px solid #d9d9d9;
+    }
+
+    .opcua-tree-modal__title {
+        font-size: 18px;
+        font-weight: 600;
+        color: #333;
+    }
+
+    .opcua-tree-modal__header .editor-button-small {
+        margin-left: auto;
+    }
+
+    .opcua-tree-modal__body {
+        flex: 1 1 auto;
+        overflow: auto;
+        padding: 18px;
+    }
+
+    .opcua-tree-context-menu {
+        position: fixed;
+        z-index: 2200;
+        min-width: 170px;
+        background: #fff;
+        border: 1px solid #d9d9d9;
+        border-radius: 6px;
+        box-shadow: 0 6px 18px rgba(0, 0, 0, 0.18);
+        padding: 6px 0;
+    }
+
+    .opcua-tree-context-menu a {
+        display: block;
+        padding: 7px 12px;
+        color: #333;
+        text-decoration: none;
+        font-size: 12px;
+    }
+
+    .opcua-tree-context-menu a:hover {
+        background: #f3f7fd;
+    }
+
+    /* ── Method mode ── */
+
+    .opcua-client-method-chip {
+        border: 1px solid #d9d9d9;
+        border-radius: 4px;
+        background: #fafafa;
+        padding: 6px 8px;
+        margin-bottom: 6px;
+    }
+
+    .opcua-client-method-header {
+        display: grid;
+        grid-template-columns: 18px 1fr auto auto;
+        column-gap: 8px;
+        align-items: center;
+        margin-bottom: 2px;
+    }
+
+    .opcua-client-method-header .opcua-tree-icon {
+        grid-column: 1;
+    }
+
+    .opcua-client-method-title {
+        font-weight: 600;
+        font-size: 12px;
+        min-width: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+
+    .opcua-client-method-header .opcua-client-nodeid-label {
+        font-size: 11px;
+        color: #777;
+        margin: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+        max-width: 260px;
+    }
+
+    .opcua-client-method-section-label {
+        font-size: 11px;
+        font-weight: 600;
+        color: #555;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+        margin: 6px 0 3px 26px;
+    }
+
+    .opcua-client-method-inp-chip {
+        display: grid;
+        grid-template-columns: 18px 1fr auto;
+        grid-template-areas:
+            "icon name name"
+            "icon write right";
+        column-gap: 8px;
+        row-gap: 4px;
+        align-items: center;
+        border: 1px solid #e8e8e8;
+        border-radius: 4px;
+        background: #fff;
+        padding: 4px 8px;
+        margin-bottom: 4px;
+        font-size: 12px;
+    }
+
+    .opcua-client-method-inp-chip .opcua-tree-icon {
+        grid-area: icon;
+        color: #aaa;
+    }
+
+    .opcua-client-method-inp-chip .opcua-tree-title {
+        grid-area: name;
+        min-width: 0;
+        font-weight: normal;
+    }
+
+    .opcua-client-method-inp-chip .opcua-client-tag-write {
+        grid-area: write;
+    }
+
+    .opcua-client-method-inp-chip .opcua-client-tag-right {
+        grid-area: right;
+    }
+
+    .opcua-client-method-out-chip {
+        display: grid;
+        grid-template-columns: 18px 1fr auto;
+        grid-template-areas: "icon name right";
+        column-gap: 8px;
+        align-items: center;
+        border: 1px solid #e8e8e8;
+        border-radius: 4px;
+        background: #f7f7f7;
+        padding: 4px 8px;
+        margin-bottom: 4px;
+        font-size: 12px;
+        color: #999;
+    }
+
+    .opcua-client-method-out-chip .opcua-tree-icon {
+        grid-area: icon;
+        color: #ccc;
+    }
+
+    .opcua-client-method-out-chip .opcua-tree-title {
+        grid-area: name;
+        min-width: 0;
+        font-weight: normal;
+    }
+
+    .opcua-client-method-out-chip .opcua-client-tag-right {
+        grid-area: right;
+    }
+
+    .opcua-method-section-row {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 4px 0 2px 26px;
+    }
+
+    .opcua-method-section-row a {
+        flex-shrink: 0;
+    }