@5minds/node-red-contrib-processcube 0.14.0-feature-7cec87-lyytfjz9 → 0.14.0-feature-197b34-lyzwc8zw

package/message-event-trigger.js

@@ -1,45 +1,37 @@
-const process = require('process');
+const process = require("process");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function MessageEventTrigger(config) {
         RED.nodes.createNode(this, config);
         var node = this;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        } 
-
-        node.on('input', function(msg) {
-
-            client.events.triggerMessageEvent(
-                config.messagename,
-                {
-                  processInstanceId: config.processinstanceid,
-                  payload: msg.payload,
-                  identity: node.server.identity
-                }
-            
-            ).then((result) => {
-
-                msg.payload = result;
-            
-                node.send(msg);
-                node.status({fill: "blue", shape: "dot", text: `message event triggered`});
-            
-            }).catch((error) => {
-                node.error(error);
-            });
+        const client = this.engine.getEngineClient();
+
+        node.on("input", function (msg) {
+            client.events
+                .triggerMessageEvent(config.messagename, {
+                    processInstanceId: config.processinstanceid,
+                    payload: msg.payload,
+                    identity: node.server.identity,
+                })
+                .then((result) => {
+                    msg.payload = result;
+
+                    node.send(msg);
+                    node.status({
+                        fill: "blue",
+                        shape: "dot",
+                        text: `message event triggered`,
+                    });
+                })
+                .catch((error) => {
+                    node.error(error);
+                });
         });
     }
     RED.nodes.registerType("message-event-trigger", MessageEventTrigger);
-}
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "0.14.0-feature-7cec87-lyytfjz9",
+    "version": "0.14.0-feature-197b34-lyzwc8zw",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "authors": [

package/process-start.js

@@ -1,43 +1,38 @@
-const process = require('process');
-const engine_client = require('@5minds/processcube_engine_client');
+const process = require("process");
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function ProcessStart(config) {
-        RED.nodes.createNode(this,config);
+        RED.nodes.createNode(this, config);
         var node = this;
-        var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }   
-
-        node.on('input', function(msg) {
+        const client = this.engine.getEngineClient();
 
+        node.on("input", function (msg) {
             const startParameters = {
                 processModelId: msg.processModelId || config.processmodel,
                 startEventId: msg.startEventId || config.startevent,
-                initialToken: msg.payload
+                initialToken: msg.payload,
             };
 
-            client.processDefinitions.startProcessInstance(startParameters, node.engine.identity).then((result) => {
-
-                msg.payload = result;
-            
-                node.send(msg);
-                node.status({fill: "blue", shape: "dot", text: `started ${result.processInstanceId}`});
-            
-            }).catch((error) => {
-                node.error(error);
-            });
+            client.processDefinitions
+                .startProcessInstance(startParameters, node.engine.identity)
+                .then((result) => {
+                    msg.payload = result;
+
+                    node.send(msg);
+                    node.status({
+                        fill: "blue",
+                        shape: "dot",
+                        text: `started ${result.processInstanceId}`,
+                    });
+                })
+                .catch((error) => {
+                    node.error(error);
+                });
         });
     }
     RED.nodes.registerType("process-start", ProcessStart);
-}
+};

package/processdefinition-query.js

@@ -1,31 +1,23 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function ProcessdefinitionQuery(config) {
-        RED.nodes.createNode(this,config);
+        RED.nodes.createNode(this, config);
         var node = this;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
+        const client = this.engine.getEngineClient();
 
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
-
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
 
         node.on("close", async () => {
@@ -33,38 +25,48 @@ module.exports = function(RED) {
             client = null;
         });
 
-        node.on('input', function(msg) {
-            let query = RED.util.evaluateNodeProperty(config.query, config.query_type, node, msg)
+        node.on("input", function (msg) {
+            let query = RED.util.evaluateNodeProperty(
+                config.query,
+                config.query_type,
+                node,
+                msg
+            );
             query = {
                 ...query,
-                identity: node.server.identity
+                identity: node.server.identity,
             };
-            
-            client.processDefinitions.getAll(query).then((matchingProcessDefinitions) => {
-
-    
-                if (config.models_only && matchingProcessDefinitions.totalCount > 0) {
-                    let models = [];
-
-                    matchingProcessDefinitions.processDefinitions.forEach(processDefinition => {
-                        processDefinition.processModels.forEach(model => {
-                            models.push(model);
-                        });
-                    });
-
-                    msg.payload = {
-                        models: models,
-                        totalCount: models.length
-                    };
-
-                } else {
-                    msg.payload = matchingProcessDefinitions;
-                }
-
 
-                node.send(msg);
-            });
+            client.processDefinitions
+                .getAll(query)
+                .then((matchingProcessDefinitions) => {
+                    if (
+                        config.models_only &&
+                        matchingProcessDefinitions.totalCount > 0
+                    ) {
+                        let models = [];
+
+                        matchingProcessDefinitions.processDefinitions.forEach(
+                            (processDefinition) => {
+                                processDefinition.processModels.forEach(
+                                    (model) => {
+                                        models.push(model);
+                                    }
+                                );
+                            }
+                        );
+
+                        msg.payload = {
+                            models: models,
+                            totalCount: models.length,
+                        };
+                    } else {
+                        msg.payload = matchingProcessDefinitions;
+                    }
+
+                    node.send(msg);
+                });
         });
     }
     RED.nodes.registerType("processdefinition-query", ProcessdefinitionQuery);
-}
+};

package/processinstance-query.js

@@ -1,31 +1,23 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function ProcessinstanceQuery(config) {
-        RED.nodes.createNode(this,config);
+        RED.nodes.createNode(this, config);
         var node = this;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
+        const client = this.engine.getEngineClient();
 
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
-
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
 
         node.on("close", async () => {
@@ -33,16 +25,22 @@ module.exports = function(RED) {
             client = null;
         });
 
-        node.on('input', function(msg) {
-            let query = RED.util.evaluateNodeProperty(config.query, config.query_type, node, msg)
-
-            client.processInstances.query(query, { identity: node.server.identity }).then((matchingInstances) => {
-
-                msg.payload = matchingInstances;
-
-                node.send(msg);
-            });
+        node.on("input", function (msg) {
+            let query = RED.util.evaluateNodeProperty(
+                config.query,
+                config.query_type,
+                node,
+                msg
+            );
+
+            client.processInstances
+                .query(query, { identity: node.server.identity })
+                .then((matchingInstances) => {
+                    msg.payload = matchingInstances;
+
+                    node.send(msg);
+                });
         });
     }
     RED.nodes.registerType("processinstance-query", ProcessinstanceQuery);
-}
+};

package/signal-event-trigger.js

@@ -1,45 +1,37 @@
-const process = require('process');
+const process = require("process");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function SignalEventTrigger(config) {
         RED.nodes.createNode(this, config);
         var node = this;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        } 
-
-        node.on('input', function(msg) {
-
-            client.events.triggerSignalEvent(
-                config.signalname,
-                {
-                  processInstanceId: config.processinstanceid,
-                  payload: msg.payload,
-                  identity: node.server.identity
-                }
-            
-            ).then((result) => {
-
-                msg.payload = result;
-            
-                node.send(msg);
-                node.status({fill: "blue", shape: "dot", text: `signal event triggered`});
-            
-            }).catch((error) => {
-                node.error(error);
-            });
+        const client = this.engine.getEngineClient();
+
+        node.on("input", function (msg) {
+            client.events
+                .triggerSignalEvent(config.signalname, {
+                    processInstanceId: config.processinstanceid,
+                    payload: msg.payload,
+                    identity: node.server.identity,
+                })
+                .then((result) => {
+                    msg.payload = result;
+
+                    node.send(msg);
+                    node.status({
+                        fill: "blue",
+                        shape: "dot",
+                        text: `signal event triggered`,
+                    });
+                })
+                .catch((error) => {
+                    node.error(error);
+                });
         });
     }
     RED.nodes.registerType("signal-event-trigger", SignalEventTrigger);
-}
+};

package/usertask-finished-listener.js

@@ -1,58 +1,79 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function UserTaskFinishedListener(config) {
         RED.nodes.createNode(this, config);
         var node = this;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
+        const client = this.engine.getEngineClient();
 
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }   
-
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
 
         const register = async () => {
             let currentIdentity = node.server.identity;
-            let subscription = await client.userTasks.onUserTaskFinished((userTaskFinishedNotification) => {
-                node.send({ payload: { flowNodeInstanceId: userTaskFinishedNotification.flowNodeInstanceId, action: "finished", type: "usertask" } });
-            }, { identity: currentIdentity });
-            
-            node.server.registerOnIdentityChanged(async (identity) => {  
-                client.userTasks.removeSubscription(subscription, currentIdentity);
+            let subscription = await client.userTasks.onUserTaskFinished(
+                (userTaskFinishedNotification) => {
+                    node.send({
+                        payload: {
+                            flowNodeInstanceId:
+                                userTaskFinishedNotification.flowNodeInstanceId,
+                            action: "finished",
+                            type: "usertask",
+                        },
+                    });
+                },
+                { identity: currentIdentity }
+            );
+
+            node.server.registerOnIdentityChanged(async (identity) => {
+                client.userTasks.removeSubscription(
+                    subscription,
+                    currentIdentity
+                );
                 currentIdentity = identity;
-    
-                subscription = await client.userTasks.onUserTaskFinished((userTaskFinishedNotification) => {
-                    node.send({ payload: { flowNodeInstanceId: userTaskFinishedNotification.flowNodeInstanceId, action: "finished", type: "usertask" } });
-                }, { identity: currentIdentity });
+
+                subscription = await client.userTasks.onUserTaskFinished(
+                    (userTaskFinishedNotification) => {
+                        node.send({
+                            payload: {
+                                flowNodeInstanceId:
+                                    userTaskFinishedNotification.flowNodeInstanceId,
+                                action: "finished",
+                                type: "usertask",
+                            },
+                        });
+                    },
+                    { identity: currentIdentity }
+                );
             });
-    
+
             node.on("close", async () => {
-                client.userTasks.removeSubscription(subscription, currentIdentity);
+                client.userTasks.removeSubscription(
+                    subscription,
+                    currentIdentity
+                );
                 client.dispose();
                 client = null;
             });
-        } 
+        };
 
         if (node.server) {
             register();
         }
     }
-    RED.nodes.registerType("usertask-finished-listener", UserTaskFinishedListener);
-}
+    RED.nodes.registerType(
+        "usertask-finished-listener",
+        UserTaskFinishedListener
+    );
+};

package/usertask-input.js

@@ -1,40 +1,40 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
 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 ${msgCounter}`,
+        });
     }
 }
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function UserTaskInput(config) {
-        RED.nodes.createNode(this,config);
+        RED.nodes.createNode(this, config);
         var node = this;
         var msgCounter = 0;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
+        const client = this.engine.getEngineClient();
 
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
 
         node.on("close", async () => {
@@ -42,40 +42,54 @@ module.exports = function(RED) {
             client = null;
         });
 
-        node.on('input', function(msg) {
-            let query = RED.util.evaluateNodeProperty(config.query, config.query_type, node, msg)
+        node.on("input", function (msg) {
+            let query = RED.util.evaluateNodeProperty(
+                config.query,
+                config.query_type,
+                node,
+                msg
+            );
             query = {
                 ...query,
-                identity: node.server.identity
-            }
+                identity: node.server.identity,
+            };
             client.userTasks.query(query).then((matchingFlowNodes) => {
-
-                if (!config.force_send_array && matchingFlowNodes && matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                if (
+                    !config.force_send_array &&
+                    matchingFlowNodes &&
+                    matchingFlowNodes.userTasks &&
+                    matchingFlowNodes.userTasks.length == 1
+                ) {
                     userTask = matchingFlowNodes.userTasks[0];
 
                     msg.payload = { userTask: userTask };
                     node.send(msg);
                 } else {
                     if (!config.force_send_array) {
-                        if (config.multisend && matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length > 1) {
+                        if (
+                            config.multisend &&
+                            matchingFlowNodes.userTasks &&
+                            matchingFlowNodes.userTasks.length > 1
+                        ) {
                             matchingFlowNodes.userTasks.forEach((userTask) => {
-                                
-                                msg.payload = { userTask: userTask } ;
+                                msg.payload = { userTask: userTask };
                                 node.send(msg);
                             });
                         } else {
-
-                            msg.payload = { userTasks: matchingFlowNodes.userTasks };
+                            msg.payload = {
+                                userTasks: matchingFlowNodes.userTasks,
+                            };
                             node.send(msg);
                         }
                     } else {
-                        
-                        msg.payload = { userTasks: matchingFlowNodes.userTasks || [] };
+                        msg.payload = {
+                            userTasks: matchingFlowNodes.userTasks || [],
+                        };
                         node.send(msg);
                     }
-                 }
+                }
             });
         });
     }
     RED.nodes.registerType("usertask-input", UserTaskInput);
-}
+};

package/usertask-new-listener.js

@@ -1,59 +1,76 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function UserTaskNewListener(config) {
         RED.nodes.createNode(this, config);
         var node = this;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
+        const client = this.engine.getEngineClient();
 
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }   
-
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
-        
+
         const register = async () => {
             let currentIdentity = node.server.identity;
-            let subscription = await client.userTasks.onUserTaskWaiting((userTaskWaitingNotification) => {
-                node.send({ payload: { flowNodeInstanceId: userTaskWaitingNotification.flowNodeInstanceId, action: "new", type: "usertask"  } });
-            }, { identity: currentIdentity });
-            
-            node.server.registerOnIdentityChanged(async (identity) => {  
-                client.userTasks.removeSubscription(subscription, currentIdentity);
+            let subscription = await client.userTasks.onUserTaskWaiting(
+                (userTaskWaitingNotification) => {
+                    node.send({
+                        payload: {
+                            flowNodeInstanceId:
+                                userTaskWaitingNotification.flowNodeInstanceId,
+                            action: "new",
+                            type: "usertask",
+                        },
+                    });
+                },
+                { identity: currentIdentity }
+            );
+
+            node.server.registerOnIdentityChanged(async (identity) => {
+                client.userTasks.removeSubscription(
+                    subscription,
+                    currentIdentity
+                );
                 currentIdentity = identity;
-    
-                subscription = await client.userTasks.onUserTaskWaiting((userTaskWaitingNotification) => {
-                    node.send({ payload: { flowNodeInstanceId: userTaskWaitingNotification.flowNodeInstanceId, action: "new", type: "usertask"  } });
-                }, { identity: currentIdentity });
+
+                subscription = await client.userTasks.onUserTaskWaiting(
+                    (userTaskWaitingNotification) => {
+                        node.send({
+                            payload: {
+                                flowNodeInstanceId:
+                                    userTaskWaitingNotification.flowNodeInstanceId,
+                                action: "new",
+                                type: "usertask",
+                            },
+                        });
+                    },
+                    { identity: currentIdentity }
+                );
             });
-    
+
             node.on("close", async () => {
-                client.userTasks.removeSubscription(subscription, currentIdentity);
+                client.userTasks.removeSubscription(
+                    subscription,
+                    currentIdentity
+                );
                 client.dispose();
                 client = null;
             });
-        } 
+        };
 
         if (node.server) {
             register();
         }
-
     }
     RED.nodes.registerType("usertask-new-listener", UserTaskNewListener);
-}
+};

package/usertask-output.js

@@ -1,53 +1,57 @@
-const process = require('process');
-const EventEmitter = require('node:events');
+const process = require("process");
+const EventEmitter = require("node:events");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
-module.exports = function(RED) {
+module.exports = function (RED) {
     function UserTaskOutput(config) {
-
         RED.nodes.createNode(this, config);
 
         var node = this;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
+        const client = this.engine.getEngineClient();
 
-        var eventEmitter = flowContext.get('emitter');
+        var eventEmitter = flowContext.get("emitter");
 
         if (!eventEmitter) {
-            flowContext.set('emitter', new EventEmitter());
-            eventEmitter = flowContext.get('emitter');
+            flowContext.set("emitter", new EventEmitter());
+            eventEmitter = flowContext.get("emitter");
         }
 
-        node.on('input', function(msg) {
+        node.on("input", function (msg) {
             if (msg.payload.userTask) {
-
-                const flowNodeInstanceId = msg.payload.userTask.flowNodeInstanceId;
-
-                const userTaskResult = RED.util.evaluateNodeProperty(config.result, config.result_type, node, msg);
-
-                client.userTasks.finishUserTask(flowNodeInstanceId, userTaskResult, node.server.identity).then(() => {
-
-                    node.send(msg);
-                }).catch(error => {
-                    node.error(error);
-                });
+                const flowNodeInstanceId =
+                    msg.payload.userTask.flowNodeInstanceId;
+
+                const userTaskResult = RED.util.evaluateNodeProperty(
+                    config.result,
+                    config.result_type,
+                    node,
+                    msg
+                );
+
+                client.userTasks
+                    .finishUserTask(
+                        flowNodeInstanceId,
+                        userTaskResult,
+                        node.server.identity
+                    )
+                    .then(() => {
+                        node.send(msg);
+                    })
+                    .catch((error) => {
+                        node.error(error);
+                    });
             } else {
-                node.error(`No UserTask found in message: ${JSON.stringify(msg.payload)}`);
+                node.error(
+                    `No UserTask found in message: ${JSON.stringify(msg.payload)}`
+                );
             }
         });
     }
 
     RED.nodes.registerType("usertask-output", UserTaskOutput);
-}
+};