@5minds/node-red-contrib-processcube 0.15.0-fix-error-in-process-instance-query-8fa811-lz054xqa → 1.0.0-develop-243715-lz1qpiwj

package/examples/User-Task-Sample.json

@@ -0,0 +1,231 @@
+[
+    {
+        "id": "fd3c725340de4f74",
+        "type": "tab",
+        "label": "UserTasks",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
+    {
+        "id": "887f3fb69ad1d1fb",
+        "type": "group",
+        "z": "fd3c725340de4f74",
+        "style": {
+            "stroke": "#999999",
+            "stroke-opacity": "1",
+            "fill": "none",
+            "fill-opacity": "1",
+            "label": true,
+            "label-position": "nw",
+            "color": "#a4a4a4"
+        },
+        "nodes": [
+            "f7a9604a17188737",
+            "020d34cd4ab43900",
+            "1db0ae57c1b8486b",
+            "127bc6e092c5724e"
+        ],
+        "x": 34,
+        "y": 19,
+        "w": 452,
+        "h": 202
+    },
+    {
+        "id": "72d3db13edc2486b",
+        "type": "group",
+        "z": "fd3c725340de4f74",
+        "style": {
+            "stroke": "#999999",
+            "stroke-opacity": "1",
+            "fill": "none",
+            "fill-opacity": "1",
+            "label": true,
+            "label-position": "nw",
+            "color": "#a4a4a4"
+        },
+        "nodes": [
+            "ae0583e83c762956",
+            "f7c7682e3a6adaaa",
+            "a2fb6369b16c12fa",
+            "8ef39e83173d41e3",
+            "f524b8cc35d56849",
+            "9fb4017c1d0ac7c9"
+        ],
+        "x": 34,
+        "y": 259,
+        "w": 652,
+        "h": 262
+    },
+    {
+        "id": "f7a9604a17188737",
+        "type": "usertask-new-listener",
+        "z": "fd3c725340de4f74",
+        "d": true,
+        "g": "887f3fb69ad1d1fb",
+        "name": "New User Task",
+        "engine": "42e6796dddd9d4db",
+        "multisend": false,
+        "x": 160,
+        "y": 120,
+        "wires": [
+            [
+                "020d34cd4ab43900"
+            ]
+        ]
+    },
+    {
+        "id": "020d34cd4ab43900",
+        "type": "debug",
+        "z": "fd3c725340de4f74",
+        "g": "887f3fb69ad1d1fb",
+        "name": "Show User Task",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "statusVal": "",
+        "statusType": "auto",
+        "x": 360,
+        "y": 120,
+        "wires": []
+    },
+    {
+        "id": "1db0ae57c1b8486b",
+        "type": "usertask-finished-listener",
+        "z": "fd3c725340de4f74",
+        "g": "887f3fb69ad1d1fb",
+        "name": "Finished User Task",
+        "engine": "42e6796dddd9d4db",
+        "multisend": false,
+        "x": 150,
+        "y": 180,
+        "wires": [
+            [
+                "020d34cd4ab43900"
+            ]
+        ]
+    },
+    {
+        "id": "127bc6e092c5724e",
+        "type": "comment",
+        "z": "fd3c725340de4f74",
+        "g": "887f3fb69ad1d1fb",
+        "name": "User Task Events",
+        "info": "",
+        "x": 140,
+        "y": 60,
+        "wires": []
+    },
+    {
+        "id": "ae0583e83c762956",
+        "type": "usertask-new-listener",
+        "z": "fd3c725340de4f74",
+        "d": true,
+        "g": "72d3db13edc2486b",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "multisend": true,
+        "x": 160,
+        "y": 360,
+        "wires": [
+            [
+                "a2fb6369b16c12fa"
+            ]
+        ]
+    },
+    {
+        "id": "f7c7682e3a6adaaa",
+        "type": "usertask-input",
+        "z": "fd3c725340de4f74",
+        "g": "72d3db13edc2486b",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "query": "payload",
+        "query_type": "msg",
+        "force_send_array": false,
+        "multisend": false,
+        "x": 380,
+        "y": 420,
+        "wires": [
+            [
+                "8ef39e83173d41e3"
+            ]
+        ]
+    },
+    {
+        "id": "a2fb6369b16c12fa",
+        "type": "function",
+        "z": "fd3c725340de4f74",
+        "g": "72d3db13edc2486b",
+        "name": "query",
+        "func": "msg.payload = {\n    flowNodeInstanceId: msg.payload.flowNodeInstanceId,\n    flowNodeId: \"user_task\"\n};\n\nreturn msg;",
+        "outputs": 1,
+        "timeout": 0,
+        "noerr": 0,
+        "initialize": "",
+        "finalize": "",
+        "libs": [],
+        "x": 210,
+        "y": 420,
+        "wires": [
+            [
+                "f7c7682e3a6adaaa"
+            ]
+        ]
+    },
+    {
+        "id": "8ef39e83173d41e3",
+        "type": "function",
+        "z": "fd3c725340de4f74",
+        "g": "72d3db13edc2486b",
+        "name": "build result",
+        "func": "msg.payload.result = {\n    \"field_01\": \"value 01\",\n    \"field_02\": \"value 02\"\n}\nreturn msg;",
+        "outputs": 1,
+        "timeout": 0,
+        "noerr": 0,
+        "initialize": "",
+        "finalize": "",
+        "libs": [],
+        "x": 390,
+        "y": 480,
+        "wires": [
+            [
+                "f524b8cc35d56849"
+            ]
+        ]
+    },
+    {
+        "id": "f524b8cc35d56849",
+        "type": "usertask-output",
+        "z": "fd3c725340de4f74",
+        "g": "72d3db13edc2486b",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "result": "payload.result",
+        "result_type": "msg",
+        "x": 580,
+        "y": 480,
+        "wires": [
+            []
+        ]
+    },
+    {
+        "id": "9fb4017c1d0ac7c9",
+        "type": "comment",
+        "z": "fd3c725340de4f74",
+        "g": "72d3db13edc2486b",
+        "name": "Demo to listen on a new usertask an finish them",
+        "info": "",
+        "x": 240,
+        "y": 300,
+        "wires": []
+    },
+    {
+        "id": "42e6796dddd9d4db",
+        "type": "processcube-engine-config",
+        "url": "http://engine:8000"
+    }
+]

package/externaltask-error.html

@@ -27,19 +27,19 @@
 </script>
 
 <script type="text/markdown" data-help-name="externaltask-error">
-Used for reporting errors in the processing of external tasks. The error 
-code `Error` in the configuration is forwarded to the ProcessCube engine for 
-handling within *Error-Boundary-Events*.
+Used for reporting errors in the processing of external tasks. The error
+code `Error` in the configuration is forwarded to the ProcessCube engine for
+handling within _Error-Boundary-Events_.
 
 ## Inputs
 
-: msg (Object)        : Passed as `ErrorDetails` to the engine
-: Error (string)      : From the configuration
-: Message (string)    : The caught exception message
+: msg (Object) : Passed as `ErrorDetails` to the engine
+: Error (string) : From the configuration
+: Message (string) : The caught exception message
 : StackTrace (string) : The stack trace of the exception
 
 ### References
 
-- [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
-- [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
+-   [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
+-   [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
 </script>

package/externaltask-error.js

@@ -12,7 +12,7 @@ module.exports = function (RED) {
             let msgError = msg.error;
 
             if (msgError === undefined) {
-                msgError.message = "An error occurred";
+                msgError.message = 'An error occurred';
             }
 
             const error = new Error(msgError.message);
@@ -23,7 +23,7 @@ module.exports = function (RED) {
             msg.errorMessage = msgError.message;
 
             eventEmitter.emit(`handle-${flowNodeInstanceId}`, error, true);
-            
+
             node.send(msg);
         });
     }

package/externaltask-input.html

@@ -32,22 +32,22 @@
 </script>
 
 <script type="text/markdown" data-help-name="externaltask-input">
-Waiting for external tasks that correspond to the `Topic` configured in 
+Waiting for external tasks that correspond to the `Topic` configured in
 the connected ProcessCube Engine for processing.
 
 ## Outputs
 
-: payload (string)   : Defines the input of the external task token
-: task (object)      : The external task object
+: payload (string) : Defines the input of the external task token
+: task (object) : The external task object
 : flowNodeInstanceId : The Id of the external task, which is needed to complete the task
 
 ### Details
 
-- To finish the external task the `externaltask-output` node is required.
-- For handling a error while executing a flow as external task the `externaltask-error` node is required.
+-   To finish the external task the `externaltask-output` node is required.
+-   For handling a error while executing a flow as external task the `externaltask-error` node is required.
 
 ### References
 
-- [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; Plattform
-- [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED Integration in ProcessCube&copy;
+-   [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; Plattform
+-   [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED Integration in ProcessCube&copy;
 </script>

package/externaltask-input.js

@@ -2,9 +2,9 @@ const EventEmitter = require('node:events');
 
 function showStatus(node, msgCounter) {
     if (msgCounter >= 1) {
-        node.status({ fill: 'blue', shape: 'dot', text: `handling tasks ${msgCounter}` });
+        node.status({ fill: 'blue', shape: 'dot', text: `handling tasks ${msgCounter}.` });
     } else {
-        node.status({ fill: 'blue', shape: 'ring', text: `subcribed ${msgCounter}` });
+        node.status({ fill: 'blue', shape: 'ring', text: `subcribed.` });
     }
 }
 
@@ -16,9 +16,14 @@ module.exports = function (RED) {
         var node = this;
         var flowContext = node.context().flow;
 
-        this.engine = this.server = RED.nodes.getNode(config.engine);
+        const engine =  RED.nodes.getNode(config.engine);
 
-        const client = this.engine.getEngineClient();
+        const client = engine.engineClient;
+
+        if (!client) {
+            node.error('No engine configured.');
+            return;
+        }
 
         var eventEmitter = flowContext.get('emitter');
 
@@ -27,121 +32,130 @@ module.exports = function (RED) {
             eventEmitter = flowContext.get('emitter');
         }
 
-        client.externalTasks.subscribeToExternalTaskTopic(config.topic, async (payload, externalTask) => {
-
-            const saveHandleCallback = (data, callback) => {
-                try {
-                    callback(data);
-                } catch (error) {
-                    node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
-                }
-            };
-
-            return await new Promise((resolve, reject) => {
-
-                const handleFinishTask = (msg) => {
-                    let result = RED.util.encodeObject(msg.payload);
-
-                    node.log(`handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* ${externalTask.processInstanceId} with result ${result} on msg._msgid ${msg._msgid}.`);
-
-                    if (externalTask.flowNodeInstanceId) {
-                        delete started_external_tasks[externalTask.flowNodeInstanceId];
+        client.externalTasks
+            .subscribeToExternalTaskTopic(config.topic, async (payload, externalTask) => {
+                const saveHandleCallback = (data, callback) => {
+                    try {
+                        callback(data);
+                    } catch (error) {
+                        node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
                     }
-
-                    showStatus(node, Object.keys(started_external_tasks).length);
-
-
-                    //resolve(result);
-                    saveHandleCallback(result, resolve)
                 };
 
-                const handleErrorTask = (msg) => {
-
-                    node.log(`handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`);
+                return await new Promise((resolve, reject) => {
+                    const handleFinishTask = (msg) => {
+                        let result = RED.util.encodeObject(msg.payload);
 
-                    if (externalTask.flowNodeInstanceId) {
-                        delete started_external_tasks[externalTask.flowNodeInstanceId];
-                    }
-
-                    showStatus(node, Object.keys(started_external_tasks).length);
+                        node.log(
+                            `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* ${externalTask.processInstanceId} with result ${result} on msg._msgid ${msg._msgid}.`,
+                        );
 
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
 
-                    // TODO: with reject, the default error handling is proceed 
-                    // SEE: https://github.com/5minds/ProcessCube.Engine.Client.ts/blob/develop/src/ExternalTaskWorker.ts#L180
-                    // reject(result);
-                    //resolve(msg);
-                    saveHandleCallback(msg, resolve);
-                };
+                        showStatus(node, Object.keys(started_external_tasks).length);
 
-                eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
-                    node.log(`handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}' and *isError* '${isError}'`);
+                        //resolve(result);
+                        saveHandleCallback(result, resolve);
+                    };
 
-                    if (isError) {
-                        handleErrorTask(msg);
-                    } else {
-                        handleFinishTask(msg);
-                    }
-                });
+                    const handleErrorTask = (msg) => {
+                        node.log(
+                            `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`,
+                        );
 
-                started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
 
-                showStatus(node, Object.keys(started_external_tasks).length);
+                        showStatus(node, Object.keys(started_external_tasks).length);
 
-                let msg = {
-                    _msgid: RED.util.generateId(),
-                    task: RED.util.encodeObject(externalTask),
-                    payload: payload,
-                    flowNodeInstanceId: externalTask.flowNodeInstanceId
-                };
+                        // TODO: with reject, the default error handling is proceed
+                        // SEE: https://github.com/5minds/ProcessCube.Engine.Client.ts/blob/develop/src/ExternalTaskWorker.ts#L180
+                        // reject(result);
+                        //resolve(msg);
+                        saveHandleCallback(msg, resolve);
+                    };
+
+                    eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
+                        node.log(
+                            `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}' and *isError* '${isError}'`,
+                        );
+
+                        if (isError) {
+                            handleErrorTask(msg);
+                        } else {
+                            handleFinishTask(msg);
+                        }
+                    });
 
-                node.log(`Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`);
+                    started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
 
-                node.send(msg);
-            });
-        })
-        .then(async (externalTaskWorker) => {
-            node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
+                    showStatus(node, Object.keys(started_external_tasks).length);
 
-            externalTaskWorker.identity = node.server.identity;
-            node.server.registerOnIdentityChanged((identity) => {
-                externalTaskWorker.identity = identity;
-            });
+                    let msg = {
+                        _msgid: RED.util.generateId(),
+                        task: RED.util.encodeObject(externalTask),
+                        payload: payload,
+                        flowNodeInstanceId: externalTask.flowNodeInstanceId,
+                    };
 
-            // export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
-            externalTaskWorker.onWorkerError((errorType, error, externalTask) => {
-                switch (errorType) {
-                    case 'extendLock':
-                    case 'finishExternalTask':
-                    case 'processExternalTask':
-                        node.error(`Worker error ${errorType} for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}': ${error.message}`);
+                    node.log(
+                        `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`,
+                    );
 
-                        if (externalTask) {
-                            delete started_external_tasks[externalTask.flowNodeInstanceId];
-                        }
+                    node.send(msg);
+                });
+            })
+            .then(async (externalTaskWorker) => {
+                node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
 
-                        showStatus(node, Object.keys(started_external_tasks).length);
-                        break;
-                    default:
-                        node.error(`Worker error ${errorType}: ${error.message}`);
-                        break;
-                }
-            });
+                externalTaskWorker.identity = engine.identity;
+                engine.registerOnIdentityChanged((identity) => {
+                    externalTaskWorker.identity = identity;
+                });
 
-            try {
-                externalTaskWorker.start();
-            } catch (error) {
-                node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
-            }
+                // export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
+                externalTaskWorker.onWorkerError((errorType, error, externalTask) => {
+                    switch (errorType) {
+                        case 'extendLock':
+                        case 'finishExternalTask':
+                        case 'processExternalTask':
+                            node.error(
+                                `Worker error ${errorType} for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}': ${error.message}`
+                            );
+
+                            if (externalTask) {
+                                delete started_external_tasks[externalTask.flowNodeInstanceId];
+                            }
+
+                            showStatus(node, Object.keys(started_external_tasks).length);
+                            break;
+                        default:
+                            node.error(`Worker error ${errorType}: ${error.message}`);
+                            break;
+                    }
+                });
 
-            node.on("close", () => {
                 try {
-                    externalTaskWorker.stop();
-                } catch {
-                    node.error('Client close failed');
+                    externalTaskWorker.start();
+                } catch (error) {
+                    node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
                 }
+
+                node.on('close', () => {
+                    try {
+                        externalTaskWorker.stop();
+                    } catch {
+                        node.error('Client close failed');
+                    }
+                });
+            })
+            .catch((error) => {
+                node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
             });
-        });
     }
 
-    RED.nodes.registerType("externaltask-input", ExternalTaskInput);
-}
+    RED.nodes.registerType('externaltask-input', ExternalTaskInput);
+};

package/externaltask-output.html

@@ -22,7 +22,7 @@
 </script>
 
 <script type="text/markdown" data-help-name="externaltask-output">
-Used to complete the external task. The `msg.payload` is returned to the ProcessCube 
+Used to complete the external task. The `msg.payload` is returned to the ProcessCube
 engine as the result of the external task.
 
 ## Inputs
@@ -31,6 +31,6 @@ engine as the result of the external task.
 
 ### References
 
-- [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
-- [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
+-   [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
+-   [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
 </script>

package/externaltask-output.js

@@ -6,16 +6,15 @@ module.exports = function (RED) {
         var flowContext = node.context().flow;
         var eventEmitter = flowContext.get('emitter');
 
-        node.on('input', function(msg) {
-            
+        node.on('input', function (msg) {
             const flowNodeInstanceId = msg.flowNodeInstanceId;
 
             if (!flowNodeInstanceId) {
-               node.error('Error: The message did not contain the required external task id.', msg);
-            }  
+                node.error('Error: The message did not contain the required external task id.', msg);
+            }
 
             eventEmitter.emit(`handle-${flowNodeInstanceId}`, msg, false);
-        });     
+        });
     }
     RED.nodes.registerType('externaltask-output', ExternalTaskOutput);
 };

package/message-event-trigger.html

@@ -36,6 +36,18 @@
     </div>
 </script>
 
-<script type="text/html" data-help-name="externaltask-input">
-    <p>A node which emmits an message event to the Engine.</p>
+<script type="text/markdown" data-help-name="externaltask-input">
+A Message event to an intermediate message event can be triggert.
+
+From the config the `messagename` and the `processInstanceId` must be set.
+
+## Inputs
+
+: payload (Object) : Will sent to the event and used an new token payload.
+
+### References
+
+-   [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
+-   [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
+    
 </script>

package/message-event-trigger.js

@@ -3,16 +3,21 @@ module.exports = function (RED) {
         RED.nodes.createNode(this, config);
         var node = this;
 
-        this.engine = this.server = RED.nodes.getNode(config.engine);
+        node.on('input', function (msg) {
 
-        const client = this.engine.getEngineClient();
+            const engine = RED.nodes.getNode(config.engine);
+            const client = engine.engineClient;
 
-        node.on('input', function (msg) {
-            client.events
+            if (!client) {
+                node.error('No engine configured.');
+                return;
+            }
+
+            engine.engineClient.events
                 .triggerMessageEvent(config.messagename, {
                     processInstanceId: config.processinstanceid,
                     payload: msg.payload,
-                    identity: node.server.identity,
+                    identity: engine.identity,
                 })
                 .then((result) => {
                     msg.payload = result;