@5minds/node-red-contrib-processcube 1.1.4-feature-80090b-m06aaj19 → 1.1.4-feature-285569-m0c23so4

package/externaltask-event-listener.html

@@ -0,0 +1,52 @@
+<script type="text/javascript">
+    RED.nodes.registerType('externaltask-event-listener', {
+        category: 'ProcessCube Events',
+        color: '#02AFD6',
+        defaults: {
+            name: { value: '' },
+            engine: { value: '', type: 'processcube-engine-config' },
+            externaltask: { value: '', required: false },
+            eventtype: { value: '', required: true },
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: 'font-awesome/fa-sign-in',
+        label: function () {
+            return this.name || 'externaltask-event-listener';
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="externaltask-event-listener">
+    <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-engine"><i class="fa fa-tag"></i> Engine-URL</label>
+        <input type="text" id="node-input-engine" placeholder="http://engine:8000" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-externaltask"><i class="fa fa-tag"></i> Externaltask</label>
+        <input type="text" id="node-input-externaltask" placeholder="ID of Externaltask" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-eventtype"><i class="fa fa-sliders"></i> Event</label>
+        <select id="node-input-eventtype" style="width: 70%;">
+            <option value="created">created</option>
+            <option value="locked">locked</option>
+            <option value="unlocked">unlocked</option>
+        </select>
+    </div>
+</script>
+
+<script type="text/markdown" data-help-name="externaltask-event-listener">
+A node which listens for events triggered by externaltasks
+
+## Outputs
+
+### 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/externaltask-event-listener.js

@@ -0,0 +1,108 @@
+module.exports = function (RED) {
+    function ExternalTaskEventListener(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+        node.engine = RED.nodes.getNode(config.engine);
+
+        const register = async () => {
+            let currentIdentity = node.engine.identity;
+
+            const client = node.engine.engineClient;
+
+            if (!client) {
+                node.error('No engine configured.');
+                return;
+            }
+
+            let subscription;
+
+            async function subscribe() {
+                switch (config.eventtype) {
+                    case 'created':
+                        return await client.notification.onExternalTaskCreated(
+                            (externalTaskNotification) => {
+                                if (
+                                    config.externaltask != '' &&
+                                    config.externaltask != externalTaskNotification.flowNodeId
+                                )
+                                    return;
+                                node.send({
+                                    payload: {
+                                        flowNodeInstanceId: externalTaskNotification.flowNodeInstanceId,
+                                        externalTaskEvent: externalTaskNotification,
+                                        action: 'created',
+                                        type: 'externaltask',
+                                    },
+                                });
+                            },
+                            { identity: currentIdentity }
+                        );
+                    case 'locked':
+                        return await client.notification.onExternalTaskLocked(
+                            (externalTaskNotification) => {
+                                if (
+                                    config.externaltask != '' &&
+                                    config.externaltask != externalTaskNotification.flowNodeId
+                                )
+                                    return;
+                                node.send({
+                                    payload: {
+                                        flowNodeInstanceId: externalTaskNotification.flowNodeInstanceId,
+                                        externalTaskEvent: externalTaskNotification,
+                                        action: 'locked',
+                                        type: 'externaltask',
+                                    },
+                                });
+                            },
+                            { identity: currentIdentity }
+                        );
+                    case 'unlocked':
+                        return await client.notification.onExternalTaskUnlocked(
+                            (externalTaskNotification) => {
+                                if (
+                                    config.externaltask != '' &&
+                                    config.externaltask != externalTaskNotification.flowNodeId
+                                )
+                                    return;
+                                node.send({
+                                    payload: {
+                                        flowNodeInstanceId: externalTaskNotification.flowNodeInstanceId,
+                                        externalTaskEvent: externalTaskNotification,
+                                        action: 'unlocked',
+                                        type: 'externaltask',
+                                    },
+                                });
+                            },
+                            { identity: currentIdentity }
+                        );
+                    default:
+                        console.error('no such event: ' + config.eventtype);
+                }
+            }
+
+            if (node.engine.isIdentityReady()) {
+                subscription = subscribe();
+            }
+
+            node.engine.registerOnIdentityChanged(async (identity) => {
+                if (subscription) {
+                    client.notification.removeSubscription(subscription, currentIdentity);
+                }
+                currentIdentity = identity;
+
+                subscription = subscribe();
+            });
+
+            node.on('close', async () => {
+                if (node.engine && node.engine.engineClient && client) {
+                    client.notification.removeSubscription(subscription, currentIdentity);
+                }
+            });
+        };
+
+        if (node.engine) {
+            register();
+        }
+    }
+    RED.nodes.registerType('externaltask-event-listener', ExternalTaskEventListener);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.1.4-feature-80090b-m06aaj19",
+    "version": "1.1.4-feature-285569-m0c23so4",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {
@@ -39,14 +39,15 @@
             "externaltaskInput": "externaltask-input.js",
             "externaltaskOutput": "externaltask-output.js",
             "externaltaskError": "externaltask-error.js",
+            "externaltaskEventListener": "externaltask-event-listener.js",
             "processStart": "process-start.js",
-            "processTerminate": "process-terminate.js",
             "processEventListener": "process-event-listener.js",
             "processcubeEngineConfig": "processcube-engine-config.js",
             "ProcessinstanceQuery": "processinstance-query.js",
             "ProcessdefinitionQuery": "processdefinition-query.js",
             "messageEventTrigger": "message-event-trigger.js",
             "signalEventTrigger": "signal-event-trigger.js",
+            "userTaskEventListener": "usertask-event-listener.js",
             "UserTaskNewListener": "usertask-new-listener.js",
             "UserTaskFinishedListener": "usertask-finished-listener.js",
             "UserTaskInput": "usertask-input.js",

package/usertask-event-listener.html

@@ -0,0 +1,75 @@
+<script type="text/javascript">
+    RED.nodes.registerType('usertask-event-listener', {
+        category: 'ProcessCube Events',
+        color: '#02AFD6',
+        defaults: {
+            name: { value: '' },
+            engine: { value: '', type: 'processcube-engine-config' },
+            usertask: { value: '', required: false },
+            eventtype: { value: '', required: true },
+            query: { value: '{}' },
+            query_type: { value: 'json' },
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: 'font-awesome/fa-sign-in',
+        label: function () {
+            return this.name || 'usertask-event-listener';
+        },
+        oneditprepare: function () {
+            $('#node-input-query').typedInput({
+                default: 'json',
+                types: ['json'],
+            });
+
+            $('#node-input-query').typedInput('value', this.query);
+            $('#node-input-query').typedInput('type', this.query_type);
+        },
+        oneditsave: function () {
+            if ($('#node-input-query').typedInput('value') == '') {
+                $('#node-input-query').typedInput('value', '{}') 
+            }
+            (this.query = $('#node-input-query').typedInput('value')),
+                (this.query_type = $('#node-input-query').typedInput('type'));
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="usertask-event-listener">
+    <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-engine"><i class="fa fa-tag"></i> Engine-URL</label>
+        <input type="text" id="node-input-engine" placeholder="http://engine:8000" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-usertask"><i class="fa fa-tag"></i> Usertask</label>
+        <input type="text" id="node-input-usertask" placeholder="ID of Usertask" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-eventtype"><i class="fa fa-sliders"></i> Event</label>
+        <select id="node-input-eventtype" style="width: 70%;">
+            <option value="new">new</option>
+            <option value="finished">finished</option>
+            <option value="reserved">reserved</option>
+            <option value="reservation-canceled">reservation-canceled</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-query"><i class="fa fa-tag"></i> Query</label>
+        <input type="text" id="node-input-query" />
+    </div>
+</script>
+
+<script type="text/markdown" data-help-name="usertask-event-listener">
+A node which listens for events triggered by usertasks
+
+## Outputs
+
+### 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/usertask-event-listener.js

@@ -0,0 +1,187 @@
+module.exports = function (RED) {
+    function UserTaskEventListener(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+        node.engine = RED.nodes.getNode(config.engine);
+
+        const register = async () => {
+            let currentIdentity = node.engine.identity;
+
+            const client = node.engine.engineClient;
+
+            if (!client) {
+                node.error('No engine configured.');
+                return;
+            }
+
+            let subscription;
+            const query = RED.util.evaluateNodeProperty(config.query, config.query_type, node);
+
+            async function filterAndSend(query) {
+                const newQuery = {
+                    flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                    ...query,
+                };
+
+                const matchingFlowNodes = await client.userTasks.query(newQuery, {
+                    identity: currentIdentity,
+                });
+
+                if (matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                    const userTask = matchingFlowNodes.userTasks[0];
+
+                    node.send({
+                        payload: { userTask: userTask },
+                    });
+                }
+            }
+
+            async function subscribe() {
+                switch (config.eventtype) {
+                    case 'new':
+                        return await client.userTasks.onUserTaskWaiting(
+                            async (userTaskNotification) => {
+                                if (config.usertask != '' && config.usertask != userTaskNotification.flowNodeId) return;
+                                const newQuery = {
+                                    flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                    ...query,
+                                };
+
+                                const matchingFlowNodes = await client.userTasks.query(newQuery, {
+                                    identity: currentIdentity,
+                                });
+
+                                if (matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                                    const userTask = matchingFlowNodes.userTasks[0];
+
+                                    node.send({
+                                        payload: {
+                                            flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                            userTaskEvent: userTaskNotification,
+                                            userTask: userTask,
+                                            action: 'new',
+                                            type: 'usertask',
+                                        },
+                                    });
+                                }
+                            },
+                            { identity: currentIdentity }
+                        );
+                    case 'finished':
+                        return await client.userTasks.onUserTaskFinished(
+                            async (userTaskNotification) => {
+                                if (config.usertask != '' && config.usertask != userTaskNotification.flowNodeId) return;
+                                const newQuery = {
+                                    flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                    ...query,
+                                };
+
+                                const matchingFlowNodes = await client.userTasks.query(newQuery, {
+                                    identity: currentIdentity,
+                                });
+
+                                if (matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                                    const userTask = matchingFlowNodes.userTasks[0];
+
+                                    node.send({
+                                        payload: {
+                                            flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                            userTaskEvent: userTaskNotification,
+                                            userTask: userTask,
+                                            action: 'finished',
+                                            type: 'usertask',
+                                        },
+                                    });
+                                }
+                            },
+                            { identity: currentIdentity }
+                        );
+                    case 'reserved':
+                        return await client.userTasks.onUserTaskReserved(
+                            async (userTaskNotification) => {
+                                if (config.usertask != '' && config.usertask != userTaskNotification.flowNodeId) return;
+                                const newQuery = {
+                                    flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                    ...query,
+                                };
+
+                                const matchingFlowNodes = await client.userTasks.query(newQuery, {
+                                    identity: currentIdentity,
+                                });
+
+                                if (matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                                    const userTask = matchingFlowNodes.userTasks[0];
+
+                                    node.send({
+                                        payload: {
+                                            flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                            userTaskEvent: userTaskNotification,
+                                            userTask: userTask,
+                                            action: 'reserved',
+                                            type: 'usertask',
+                                        },
+                                    });
+                                }
+                            },
+                            { identity: currentIdentity }
+                        );
+                    case 'reservation-canceled':
+                        return await client.userTasks.onUserTaskReservationCanceled(
+                            async (userTaskNotification) => {
+                                if (config.usertask != '' && config.usertask != userTaskNotification.flowNodeId) return;
+                                const newQuery = {
+                                    flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                    ...query,
+                                };
+
+                                const matchingFlowNodes = await client.userTasks.query(newQuery, {
+                                    identity: currentIdentity,
+                                });
+
+                                if (matchingFlowNodes.userTasks && matchingFlowNodes.userTasks.length == 1) {
+                                    const userTask = matchingFlowNodes.userTasks[0];
+
+                                    node.send({
+                                        payload: {
+                                            flowNodeInstanceId: userTaskNotification.flowNodeInstanceId,
+                                            userTaskEvent: userTaskNotification,
+                                            userTask: userTask,
+                                            action: 'reservation-canceled',
+                                            type: 'usertask',
+                                        },
+                                    });
+                                }
+                            },
+                            { identity: currentIdentity }
+                        );
+                    default:
+                        console.error('no such event: ' + config.eventtype);
+                }
+            }
+
+            if (node.engine.isIdentityReady()) {
+                subscription = subscribe();
+            }
+
+            node.engine.registerOnIdentityChanged(async (identity) => {
+                if (subscription) {
+                    client.userTasks.removeSubscription(subscription, currentIdentity);
+                }
+                currentIdentity = identity;
+
+                subscription = subscribe();
+            });
+
+            node.on('close', async () => {
+                if (node.engine && node.engine.engineClient && client) {
+                    client.userTasks.removeSubscription(subscription, currentIdentity);
+                }
+            });
+        };
+
+        if (node.engine) {
+            register();
+        }
+    }
+    RED.nodes.registerType('usertask-event-listener', UserTaskEventListener);
+};

package/process-terminate.html

@@ -1,37 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('process-terminate', {
-        category: 'ProcessCube',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            engine: { value: '', type: 'processcube-engine-config' },
-        },
-        inputs: 1,
-        outputs: 1,
-        icon: 'font-awesome/fa-sign-in',
-        label: function () {
-            return this.name || 'process-terminate';
-        },
-    });
-</script>
-
-<script type="text/html" data-template-name="process-terminate">
-    <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-engine"><i class="fa fa-tag"></i> Engine-URL</label>
-        <input type="text" id="node-input-engine" placeholder="Engine-URL" />
-    </div>
-</script>
-
-<script type="text/markdown" data-help-name="process-terminate">
-Terminate an instance of a process model in the ProcessCube.
-
-### 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/process-terminate.js

@@ -1,27 +0,0 @@
-module.exports = function (RED) {
-    function ProcessTerminate(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
-
-        node.on('input', function (msg) {
-            const engine = RED.nodes.getNode(config.engine);
-            const client = engine.engineClient;
-
-            if (!client) {
-                node.error('No engine configured.');
-                return;
-            }
-
-            client.processInstances
-                .terminateProcessInstance(msg.payload, engine.identity)
-                .then(() => {
-                    node.send(msg);
-                })
-                .catch((error) => {
-                    node.error(error);
-                });
-        });
-    }
-
-    RED.nodes.registerType('process-terminate', ProcessTerminate);
-};

package/usertask-finished-listener.html

@@ -1,45 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('usertask-finished-listener', {
-        category: 'ProcessCube Events',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            engine: { value: '', type: 'processcube-engine-config' },
-            multisend: { value: false },
-        },
-        inputs: 0,
-        outputs: 1,
-        icon: 'font-awesome/fa-envelope',
-        label: function () {
-            return this.name || 'usertask-finished-listener';
-        },
-    });
-</script>
-
-<script type="text/html" data-template-name="usertask-finished-listener">
-    <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-engine"><i class="fa fa-tag"></i> Engine-URL</label>
-        <input type="text" id="node-input-engine" placeholder="http://engine:8000" />
-    </div>
-</script>
-
-<script type="text/markdown" data-help-name="usertask-finished-listener">
-A node which listens for finished usertasks in the ProcessCube.
-
-## Outputs
-
-: flowNodeInstanceId (string): The flow node instance id of the finished usertask.
-: userTaskEvent (object): The user task event object.
-: action (string): The action of the event.
-: type (string): The type of the event.
-
-### 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/usertask-finished-listener.js

@@ -1,68 +0,0 @@
-module.exports = function (RED) {
-    function UserTaskFinishedListener(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
-        node.engine = RED.nodes.getNode(config.engine);
-
-        const register = async () => {
-            let currentIdentity = node.engine.identity;
-
-            const client = node.engine.engineClient;
-    
-            if (!client) {
-                node.error('No engine configured.');
-                return;
-            }
-
-            let subscription;
-
-            if (node.engine.isIdentityReady()) {
-                subscription = await client.userTasks.onUserTaskFinished(
-                    (userTaskFinishedNotification) => {
-                        node.send({
-                            payload: {
-                                flowNodeInstanceId: userTaskFinishedNotification.flowNodeInstanceId,
-                                userTaskEvent: userTaskFinishedNotification,
-                                action: 'finished',
-                                type: 'usertask',
-                            },
-                        });
-                    },
-                    { identity: currentIdentity },
-                );
-            }
-            
-            node.engine.registerOnIdentityChanged(async (identity) => {
-                if (subscription) {
-                    client.userTasks.removeSubscription(subscription, currentIdentity);
-                }
-                currentIdentity = identity;
-
-                subscription = await client.userTasks.onUserTaskFinished(
-                    (userTaskFinishedNotification) => {
-                        node.send({
-                            payload: {
-                                flowNodeInstanceId: userTaskFinishedNotification.flowNodeInstanceId,
-                                userTaskEvent: userTaskFinishedNotification,
-                                action: 'finished',
-                                type: 'usertask',
-                            },
-                        });
-                    },
-                    { identity: currentIdentity },
-                );
-            });
-
-            node.on('close', async () => {
-                if (node.engine && node.engine.engineClient && client) {
-                    client.userTasks.removeSubscription(subscription, currentIdentity);
-                }
-            });
-        };
-
-        if (node.engine) {
-            register();
-        }
-    }
-    RED.nodes.registerType('usertask-finished-listener', UserTaskFinishedListener);
-};

package/usertask-new-listener.html

@@ -1,45 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('usertask-new-listener', {
-        category: 'ProcessCube Events',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            engine: { value: '', type: 'processcube-engine-config' },
-            multisend: { value: false },
-        },
-        inputs: 0,
-        outputs: 1,
-        icon: 'font-awesome/fa-envelope-open',
-        label: function () {
-            return this.name || 'usertask-new-listener';
-        },
-    });
-</script>
-
-<script type="text/html" data-template-name="usertask-new-listener">
-    <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-engine"><i class="fa fa-tag"></i> Engine-URL</label>
-        <input type="text" id="node-input-engine" placeholder="http://engine:8000" />
-    </div>
-</script>
-
-<script type="text/markdown" data-help-name="usertask-new-listener">
-A node which listens for new usertasks in the ProcessCube.
-
-## Outputs
-
-: flowNodeInstanceId (string): The flow node instance id of the new usertask.
-: userTaskEvent (string) : The user task event object.
-: action (string) : The action of the event.
-: type (string) : The type of the event.
-
-### 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/usertask-new-listener.js

@@ -1,69 +0,0 @@
-module.exports = function (RED) {
-    function UserTaskNewListener(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
-        node.engine = RED.nodes.getNode(config.engine);
-
-        const register = async () => {
-            const client = node.engine.engineClient;
-
-            if (!client) {
-                node.error('No engine configured.');
-                return;
-            }
-                
-            let currentIdentity = node.engine.identity;
-
-            let subscription;
-            
-            if (node.engine.isIdentityReady()) {
-                subscription = await client.userTasks.onUserTaskWaiting(
-                    (userTaskWaitingNotification) => {
-                        node.send({
-                            payload: {
-                                flowNodeInstanceId: userTaskWaitingNotification.flowNodeInstanceId,
-                                userTaskEvent: userTaskWaitingNotification,
-                                action: 'new',  
-                                type: 'usertask',
-                            },
-                        });
-                    },
-                    { identity: currentIdentity },
-                );
-            }
-
-            node.engine.registerOnIdentityChanged(async (identity) => {
-                if (subscription) {
-                    client.userTasks.removeSubscription(subscription, currentIdentity);
-                }
-
-                currentIdentity = identity;
-
-                subscription = await client.userTasks.onUserTaskWaiting(
-                    (userTaskWaitingNotification) => {
-                        node.send({
-                            payload: {
-                                flowNodeInstanceId: userTaskWaitingNotification.flowNodeInstanceId,
-                                userTaskEvent: userTaskWaitingNotification,
-                                action: 'new',
-                                type: 'usertask',
-                            },
-                        });
-                    },
-                    { identity: currentIdentity },
-                );
-            });
-
-            node.on('close', () => {
-                if (node.engine && node.engine.engineClient && client) {
-                    client.userTasks.removeSubscription(subscription, currentIdentity);
-                }
-            });
-        };
-
-        if (node.engine) {
-            register();
-        }
-    }
-    RED.nodes.registerType('usertask-new-listener', UserTaskNewListener);
-};