@5minds/node-red-contrib-processcube 1.5.6-feature-aa14a2-m3pntyi8 → 1.5.7-develop-41d845-m3q6c4hg

package/endevent-finished-listener.js

@@ -4,13 +4,6 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
-        const eventEmitter = node.engine.eventEmitter;
-
-        eventEmitter.on('engine-client-changed', () => {
-            node.log('new engineClient received');
-            register();
-        });
-
         const register = async () => {
             const client = node.engine.engineClient;
 
@@ -18,7 +11,7 @@ module.exports = function (RED) {
                 node.error('No engine configured.');
                 return;
             }
-
+    
             let currentIdentity = node.engine.identity;
 
             let subscription = null;
@@ -30,23 +23,24 @@ module.exports = function (RED) {
                             payload: endEventFinished,
                         });
                     },
-                    { identity: currentIdentity }
+                    { identity: currentIdentity },
                 );
 
                 node.engine.registerOnIdentityChanged(async (identity) => {
                     client.events.removeSubscription(subscription, currentIdentity);
-
+                    
                     currentIdentity = identity;
 
                     subscription = await client.events.onEndEventFinished(
                         (endEventFinished) => {
                             node.send({
-                                payload: endEventFinished,
+                                payload: endEventFinished
                             });
                         },
-                        { identity: currentIdentity }
+                        { identity: currentIdentity },
                     );
                 });
+
             } catch (error) {
                 node.error(error);
             }

package/externaltask-event-listener.js

@@ -4,13 +4,6 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
-        const eventEmitter = node.engine.eventEmitter;
-
-        eventEmitter.on('engine-client-changed', () => {
-            node.log('new engineClient received');
-            register();
-        });
-
         const register = async () => {
             let currentIdentity = node.engine.identity;
 

package/externaltask-input.html

@@ -58,11 +58,26 @@
 Waiting for external tasks that correspond to the `Topic` configured in
 the connected ProcessCube Engine for processing.
 
+## Configs
+
+: name (string) : The name of the node
+: engine (string) : The ProcessCube Engine to connect to
+: topic (string) : The topic of the external task
+: workerConfig (object) : The configuration for the worker
+
+### workerConfig
+
+- workerId (string): The id of the worker
+- lockDuration (number): The duration in milliseconds the external task is locked for execution
+- maxTasks (number): The maximum number of tasks that can be fetched at once
+- longpollingTimeout (number): The duration in milliseconds the external task is locked for execution
+- payloadFilter (Req-Expression): The filter for the payload of the external task
+
 ## Outputs
 
 : payload (string) : The payload the external task was started with.
 : task (object) : The external task object
-: flowNodeInstanceId : The unique identifier of the external task, which is needed to complete the task
+: flowNodeInstanceId (string) : The unique identifier of the external task, which is needed to complete the task
 
 ### Details
 

package/externaltask-input.js

@@ -32,149 +32,135 @@ module.exports = function (RED) {
             eventEmitter = flowContext.get('emitter');
         }
 
-        const engineEventEmitter = node.engine.eventEmitter;
+        const etwCallback = async (payload, externalTask) => {
+            const saveHandleCallback = (data, callback) => {
+                try {
+                    callback(data);
+                } catch (error) {
+                    node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
+                }
+            };
 
-        engineEventEmitter.on('engine-client-changed', () => {
-            node.log('new engineClient received');
-            register();
-        });
+            return await new Promise((resolve, reject) => {
+                const handleFinishTask = (msg) => {
+                    let result = RED.util.encodeObject(msg.payload);
 
-        const register = async () => {
-            const etwCallback = async (payload, externalTask) => {
-                const saveHandleCallback = (data, callback) => {
-                    try {
-                        callback(data);
-                    } catch (error) {
-                        node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
+                    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];
                     }
-                };
 
-                return await new Promise((resolve, reject) => {
-                    const handleFinishTask = (msg) => {
-                        let result = RED.util.encodeObject(msg.payload);
+                    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}.`
-                        );
+                    //resolve(result);
+                    saveHandleCallback(result, resolve);
+                };
 
-                        if (externalTask.flowNodeInstanceId) {
-                            delete started_external_tasks[externalTask.flowNodeInstanceId];
-                        }
+                const handleErrorTask = (msg) => {
+                    node.log(
+                        `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`
+                    );
 
-                        showStatus(node, Object.keys(started_external_tasks).length);
+                    if (externalTask.flowNodeInstanceId) {
+                        delete started_external_tasks[externalTask.flowNodeInstanceId];
+                    }
 
-                        //resolve(result);
-                        saveHandleCallback(result, resolve);
-                    };
+                    showStatus(node, Object.keys(started_external_tasks).length);
 
-                    const handleErrorTask = (msg) => {
-                        node.log(
-                            `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`
-                        );
+                    // 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 (externalTask.flowNodeInstanceId) {
-                            delete started_external_tasks[externalTask.flowNodeInstanceId];
-                        }
+                    if (isError) {
+                        handleErrorTask(msg);
+                    } else {
+                        handleFinishTask(msg);
+                    }
+                });
 
-                        showStatus(node, Object.keys(started_external_tasks).length);
+                started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
 
-                        // 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}'`
-                        );
+                let msg = {
+                    _msgid: RED.util.generateId(),
+                    task: RED.util.encodeObject(externalTask),
+                    payload: payload,
+                    flowNodeInstanceId: externalTask.flowNodeInstanceId,
+                    processInstanceId: externalTask.processInstanceId,
+                };
 
-                        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);
+            });
+        };
 
-                    showStatus(node, Object.keys(started_external_tasks).length);
+        let options = RED.util.evaluateNodeProperty(config.workerConfig, 'json', node);
 
-                    let msg = {
-                        _msgid: RED.util.generateId(),
-                        task: RED.util.encodeObject(externalTask),
-                        payload: payload,
-                        flowNodeInstanceId: externalTask.flowNodeInstanceId,
-                        processInstanceId: externalTask.processInstanceId,
-                    };
+        client.externalTasks
+            .subscribeToExternalTaskTopic(config.topic, etwCallback, options)
+            .then(async (externalTaskWorker) => {
+                node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
 
-                    node.log(
-                        `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`
-                    );
+                externalTaskWorker.identity = engine.identity;
+                engine.registerOnIdentityChanged((identity) => {
+                    externalTaskWorker.identity = identity;
+                });
 
-                    node.send(msg);
+                // 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:
+                            // reduce noise error logs
+                            // node.error(`Worker error ${errorType}: ${error.message}`);
+                            break;
+                    }
                 });
-            };
 
-            client.externalTasks
-                .subscribeToExternalTaskTopic(
-                    config.topic,
-                    etwCallback,
-                    RED.util.evaluateNodeProperty(config.workerConfig, 'json', node)
-                )
-                .then(async (externalTaskWorker) => {
-                    node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
-
-                    externalTaskWorker.identity = engine.identity;
-                    engine.registerOnIdentityChanged((identity) => {
-                        externalTaskWorker.identity = identity;
-                    });
-
-                    // 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;
-                        }
-                    });
+                try {
+                    externalTaskWorker.start();
+                } catch (error) {
+                    node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
+                }
 
+                node.on('close', () => {
                     try {
-                        externalTaskWorker.start();
-                    } catch (error) {
-                        node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
+                        externalTaskWorker.stop();
+                    } catch {
+                        node.error('Client close failed');
                     }
-
-                    node.on('close', () => {
-                        try {
-                            externalTaskWorker.stop();
-                        } catch {
-                            node.error('Client close failed');
-                        }
-                    });
-                })
-                .catch((error) => {
-                    node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
                 });
-        };
-
-        if (node.engine) {
-            register();
-        }
+            })
+            .catch((error) => {
+                node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
+            });
     }
 
     RED.nodes.registerType('externaltask-input', ExternalTaskInput);

package/nodered/flows.json

@@ -71,6 +71,22 @@
         "info": "",
         "env": []
     },
+    {
+        "id": "76c047e0d8770a20",
+        "type": "tab",
+        "label": "Other Events",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
+    {
+        "id": "2766c40d84283368",
+        "type": "tab",
+        "label": "Placeholder",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
     {
         "id": "4c59118134081e05",
         "type": "group",
@@ -481,6 +497,7 @@
             "color": "#a4a4a4"
         },
         "nodes": [
+
             "2fadb4c4667ecaf2",
             "93331783b7ef3fc5",
             "bc26f9821540f097",
@@ -1485,7 +1502,7 @@
         "g": "a71a168415778e2c",
         "name": "",
         "engine": "42e6796dddd9d4db",
-        "query": "{\"includeXml\":false}",
+        "query": "{\"includeXml\":false,\"processDefinitionId\":\"External-Task-Sample_Definition\"}",
         "query_type": "json",
         "x": 320,
         "y": 140,
@@ -2094,5 +2111,95 @@
         "x": 760,
         "y": 60,
         "wires": []
+    },
+    {
+        "id": "930624edc6169c55",
+        "type": "process-event-listener",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "processmodel": "External-Task-Sample_Process",
+        "eventtype": "starting",
+        "query": "{}",
+        "query_type": "json",
+        "x": 160,
+        "y": 140,
+        "wires": [
+            [
+                "2f2ec1cc0213eab5"
+            ]
+        ]
+    },
+    {
+        "id": "2f2ec1cc0213eab5",
+        "type": "debug",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "debug 34",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "false",
+        "statusVal": "",
+        "statusType": "auto",
+        "x": 430,
+        "y": 140,
+        "wires": []
+    },
+    {
+        "id": "bde205e77cd20558",
+        "type": "comment",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "Hört auf die Events der Processe",
+        "info": "",
+        "x": 190,
+        "y": 80,
+        "wires": []
+    },
+    {
+        "id": "03ac7bc273197c45",
+        "type": "process-terminate",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "x": 170,
+        "y": 140,
+        "wires": [
+            [
+                "bb734a85d4b37728"
+            ]
+        ]
+    },
+    {
+        "id": "bb734a85d4b37728",
+        "type": "debug",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "debug 35",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "false",
+        "statusVal": "",
+        "statusType": "auto",
+        "x": 370,
+        "y": 140,
+        "wires": []
+    },
+    {
+        "id": "3d03550f7d93bfd3",
+        "type": "comment",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "Event for Terminating a Process",
+        "info": "",
+        "x": 210,
+        "y": 80,
+        "wires": []
     }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.5.6-feature-aa14a2-m3pntyi8",
+    "version": "1.5.7-develop-41d845-m3q6c4hg",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {

package/process-event-listener.js

@@ -4,13 +4,6 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
-        const eventEmitter = node.engine.eventEmitter;
-
-        eventEmitter.on('engine-client-changed', () => {
-            node.log('new engineClient received');
-            register();
-        });
-
         const register = async () => {
             const client = node.engine.engineClient;
 
@@ -31,8 +24,7 @@ module.exports = function (RED) {
                             async (processNotification) => {
                                 if (
                                     config.processmodel != '' &&
-                                    config.processmodel != processNotification.processModelId
-                                ) {
+                                    config.processmodel != processNotification.processModelId) {
                                     return;
                                 }
 
@@ -73,8 +65,7 @@ module.exports = function (RED) {
                             async (processNotification) => {
                                 if (
                                     config.processmodel != '' &&
-                                    config.processmodel != processNotification.processModelId
-                                ) {
+                                    config.processmodel != processNotification.processModelId) {
                                     return;
                                 }
 
@@ -442,6 +433,7 @@ module.exports = function (RED) {
                     },
                     { identity: currentIdentity }
                 );
+
             });
 
             node.on('close', () => {

package/process-terminate.html

@@ -29,9 +29,10 @@
 <script type="text/markdown" data-help-name="process-terminate">
 Terminate an instance of a process model in the ProcessCube.
 
-## Inputs
+## Configs
 
-: payload (string): The id of the processinstance that is going to be terminated.
+: name (string): name of the node
+: engine (string): the engine to connect to
 
 ## Outputs
 

package/processcube-engine-config.js

@@ -1,4 +1,3 @@
-const EventEmitter = require('node:events');
 const engine_client = require('@5minds/processcube_engine_client');
 const jwt = require('jwt-decode');
 const oidc = require('openid-client');
@@ -13,8 +12,7 @@ module.exports = function (RED) {
         this.credentials.clientId = RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node);
         this.credentials.clientSecret = RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node);
 
-        node.eventEmitter = new EventEmitter();
-
+        // known issue: kann bei falschem timing zu laufzeitfehlern führen (absprache MM)
         // set the engine url
         const stopRefreshing = periodicallyRefreshEngineClient(this, n, 10000);
 
@@ -43,7 +41,7 @@ module.exports = function (RED) {
             function refreshUrl() {
                 const newUrl = RED.util.evaluateNodeProperty(n.url, n.urlType, node);
 
-                if (node.url === newUrl) {
+                if (node.url == newUrl) {
                     return;
                 }
 
@@ -55,15 +53,11 @@ module.exports = function (RED) {
                     node.engineClient = new engine_client.EngineClient(node.url, () =>
                         getFreshIdentity(node.url, node)
                     );
-
-                    node.eventEmitter.emit('engine-client-changed');
                 } else {
                     if (this.engineClient) {
                         this.engineClient.dispose();
                     }
                     node.engineClient = new engine_client.EngineClient(node.url);
-
-                    node.eventEmitter.emit('engine-client-changed');
                 }
             }