@5minds/node-red-contrib-processcube 1.16.1-develop-136f5e-mh90amev → 1.16.1-feature-5e019f-mhojvcvu

package/externaltask-error.js

@@ -3,10 +3,10 @@ module.exports = function (RED) {
         RED.nodes.createNode(this, config);
         var node = this;
 
-        node.on('input', function (msg) {            
+        node.on('input', function (msg) {
             const flowNodeInstanceId = msg.flowNodeInstanceId;
             const etw_input_node_id = msg.etw_input_node_id;
-           
+
             if (!etw_input_node_id) {
                 node.error('Error: The message did not contain the required etw_input_node_id.');
             } else {
@@ -24,7 +24,7 @@ module.exports = function (RED) {
                         if (msgError.code) {
                             errorCode = msgError.code;
                             errorMessage = msgError.message;
-                        } 
+                        }
                     } else if (msg.errorCode) {
                         errorCode = msg.errorCode;
                         errorMessage = msg.errorMessage;

package/externaltask-inject.html

@@ -0,0 +1,123 @@
+<script type="text/javascript">
+    RED.nodes.registerType('externaltask-inject', {
+        category: 'ProcessCube',
+        color: '#02AFD6',
+        defaults: {
+            name: { value: '' },
+            payloadType: { value: 'json' },
+            payload: { value: '{}' },
+            taskType: { value: 'json' },
+            task: { value: '{}' }
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: 'inject.svg',
+        label: function () {
+            return this.name || 'externaltask-inject';
+        },
+        button: {
+            onclick: function() {
+                var node = this;
+
+                $.ajax({
+                    type: "POST",
+                    url: "externaltask-inject/trigger/" + node.id,
+                    success: function(resp) {
+                        RED.notify("Message injected", "success");
+                    },
+                    error: function(xhr, status, err) {
+                        RED.notify("Error injecting message: " + err, "error");
+                    }
+                });
+            }
+        },
+        oneditprepare: function () {
+            // Initialize the typed input for payload
+            $('#node-input-payload').typedInput({
+                default: 'json',
+                types: ['str', 'num', 'bool', 'json', 'jsonata', 'flow', 'global']
+            });
+            // Restore the saved type for payload from hidden input
+            var payloadType = $('#node-input-payloadType').val();
+            if (payloadType) {
+                $('#node-input-payload').typedInput('type', payloadType);
+            }
+
+            // Initialize the typed input for task
+            $('#node-input-task').typedInput({
+                default: 'json',
+                types: ['str', 'num', 'bool', 'json', 'jsonata', 'flow', 'global']
+            });
+            // Restore the saved type for task from hidden input
+            var taskType = $('#node-input-taskType').val();
+            if (taskType) {
+                $('#node-input-task').typedInput('type', taskType);
+            }
+        },
+        oneditsave: function () {
+            var payloadValue = $('#node-input-payload').typedInput('value');
+            var payloadType = $('#node-input-payload').typedInput('type');
+            this.payload = payloadValue;
+            this.payloadType = payloadType;
+            // Persist type to hidden input field
+            $('#node-input-payloadType').val(payloadType);
+
+            var taskValue = $('#node-input-task').typedInput('value');
+            var taskType = $('#node-input-task').typedInput('type');
+            this.task = taskValue;
+            this.taskType = taskType;
+            // Persist type to hidden input field
+            $('#node-input-taskType').val(taskType);
+        }
+     });
+</script>
+
+<script type="text/html" data-template-name="externaltask-inject">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-payload">msg.payload</label>
+        <input type="hidden" id="node-input-payloadType">
+        <input type="text" id="node-input-payload" style="width: 70%;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-task">msg.task</label>
+        <input type="hidden" id="node-input-taskType">
+        <input type="text" id="node-input-task" style="width: 70%;">
+    </div>
+</script>
+
+<script type="text/markdown" data-help-name="externaltask-inject">
+A lightweight alternative to the standard Node-RED inject node for testing external task workflows. Use this node to inject test messages directly into an external task workflow without needing a real external task from the ProcessCube engine.
+
+This node is ideal for small-scale testing and debugging of external task workflows. For larger-scale testing with test cases or CI/CD integration, use the **externaltask-testing** node instead.
+
+## Features
+
+- Injects messages with configurable payload and task metadata
+- Automatically generates `flowNodeInstanceId` and `processInstanceId` if not provided
+- Sets required fields for compatibility with externaltask-output and externaltask-error nodes
+- Supports multiple value types (JSON, string, number, boolean, JSONata, flow/global context)
+
+## Configs
+
+: name (string) : The name of the node
+: payload (string | {}) : The payload to inject into the workflow
+: task (string | {}) : The task object to inject
+
+## Outputs
+
+: payload (string | {}) : The injected payload with metadata (flowNodeInstanceId, processInstanceId, task)
+: task (object) : The injected task object
+: flowNodeInstanceId (string) : Unique identifier for the external task
+: processInstanceId (string) : Reference to the process instance
+: etw_input_node_id (string) : Reference to the injecting node
+: etw_started_at (string) : ISO timestamp of when the task was injected
+
+## References
+
+-   [The ProcessCube&copy; Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
+-   [ProcessCube&copy; LowCode Integration](https://processcube.io/docs/node-red) - LowCode integration in ProcessCube&copy;
+</script>

package/externaltask-inject.js

@@ -0,0 +1,98 @@
+const { v4: uuidv4 } = require('uuid');
+const EventEmitter = require('node:events');
+
+module.exports = function (RED) {
+    function ExternalTaskInject(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+        node.config = config;
+        node.eventEmitter = new EventEmitter();
+
+        node.on('input', function (msg, send, done) {
+            msg.flowNodeInstanceId = msg.flowNodeInstanceId ?? uuidv4();
+            msg.processInstanceId = msg.processInstanceId ?? uuidv4();
+
+            if (!msg.task) {
+                // Use configured task if available, otherwise create default
+                if (config.task) {
+                    msg.task = config.task;
+                } else {
+                    msg.task = {
+                        flowNodeInstanceId: msg.flowNodeInstanceId,
+                        processInstanceId: msg.processInstanceId,
+                        task: {}
+                    }
+                }
+            }
+            msg.etw_started_at = new Date().toISOString();
+            msg.etw_input_node_id = node.id;
+
+            send(msg);
+            if (done) done();
+        });
+
+    }
+
+    RED.nodes.registerType('externaltask-inject', ExternalTaskInject);
+
+    // Helper function to parse typed values
+    function parseTypedValue(value, type) {
+        switch(type) {
+            case 'str':
+                return value || '';
+            case 'num':
+                return Number(value) || 0;
+            case 'bool':
+                return value === 'true' || value === true;
+            case 'json':
+                try {
+                    return JSON.parse(value || '{}');
+                } catch(parseErr) {
+                    console.error("Invalid JSON: " + parseErr.message);
+                    return {};
+                }
+            case 'jsonata':
+                // JSONata expressions would need to be evaluated in Node-RED context
+                // For now, treat as string
+                return value || '';
+            case 'flow':
+            case 'global':
+                // These are context references - store as string for now
+                return value || '';
+            default:
+                return value || '';
+        }
+    }
+
+    // HTTP endpoint to handle button clicks
+    RED.httpAdmin.post('/externaltask-inject/trigger/:id', function(req, res) {
+        var node = RED.nodes.getNode(req.params.id);
+        if (node !== null && typeof node !== 'undefined') {
+            try {
+                var payloadValue = node.config.payload;
+                var payloadType = node.config.payloadType || 'json';
+                var payloadData = parseTypedValue(payloadValue, payloadType);
+
+                var taskValue = node.config.task;
+                var taskType = node.config.taskType || 'json';
+                var taskData = parseTypedValue(taskValue, taskType);
+
+                // Create a message with the configured payload and task
+                var msg = {
+                    payload: payloadData,
+                    task: taskData,
+                    _msgid: uuidv4()
+                };
+
+                // Trigger the node's input handler with the configured message
+                node.receive(msg);
+                res.sendStatus(200);
+            } catch(err) {
+                res.sendStatus(500);
+                node.error("Error injecting message: " + err.message);
+            }
+        } else {
+            res.sendStatus(404);
+        }
+    });
+};

package/externaltask-input.js

@@ -29,15 +29,15 @@ module.exports = function (RED) {
         }
 
         if (!options['lockDuration'] && (process.env.NODE_RED_ETW_LOCK_DURATION || process.env.NODERED_ETW_LOCK_DURATION)) {
-            options['lockDuration'] = parseInt(process.env.NODE_RED_ETW_LOCK_DURATION) || parseInt(process.env.NODERED_ETW_LOCK_DURATION) || undefined;
+            options['lockDuration'] = parseInt(process.env.NODE_RED_ETW_LOCK_DURATION || process.env.NODERED_ETW_LOCK_DURATION) || undefined;
         }
 
         if (!options['longpollingTimeout']) {
-            options['longpollingTimeout'] = parseInt(process.env.NODE_RED_ETW_LONGPOLLING_TIMEOUT) || parseInt(process.env.NODERED_ETW_LONGPOLLING_TIMEOUT) || undefined;
+            options['longpollingTimeout'] = parseInt(process.env.NODE_RED_ETW_LONGPOLLING_TIMEOUT || process.env.NODERED_ETW_LONGPOLLING_TIMEOUT) || undefined;
         }
 
         if (!options['idleTimeout']) {
-            options['idleTimeout'] = parseInt(process.env.NODE_RED_ETW_IDLE_TIMEOUT) || parseInt(process.env.NODERED_ETW_IDLE_TIMEOUT) || undefined;
+            options['idleTimeout'] = parseInt(process.env.NODE_RED_ETW_IDLE_TIMEOUT || process.env.NODERED_ETW_IDLE_TIMEOUT) || undefined;
         }
 
         node._subscribed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.16.1-develop-136f5e-mh90amev",
+    "version": "1.16.1-feature-5e019f-mhojvcvu",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {
@@ -39,6 +39,7 @@
             "DataobjectInstanceQuery": "dataobject-instance-query.js",
             "EndEventFinishedListener": "endevent-finished-listener.js",
             "externaltaskInput": "externaltask-input.js",
+            "externaltaskInject": "externaltask-inject.js",
             "externaltaskOutput": "externaltask-output.js",
             "externaltaskError": "externaltask-error.js",
             "externaltaskEventListener": "externaltask-event-listener.js",