@5minds/node-red-contrib-processcube 2.0.0-feature-629c78-m2dq1ygt → 7.6.0-develop-51b534-mjy3s4sm

package/processdefinition-query.html

@@ -44,19 +44,10 @@
         <label for="node-input-query"><i class="fa fa-tag"></i> Query</label>
         <input type="text" id="node-input-query" />
     </div>
-    <div class="form-row" style="display:flex; margin-bottom: 3px;">
-        <label for="node-input-models_only" style="vertical-align:top"
-            ><i class="fa fa-list-alt"></i> Models Only</label
-        >
-        <div>
-            <input
-                type="checkbox"
-                checked
-                id="node-input-models_only"
-                style="display: inline-block; width: auto; margin: 0px 0px 0px 4px;"
-            />
-            <label style="width:auto" for="node-input-models_only">Only send models as result.</label>
-        </div>
+
+    <div class="form-row" style="margin-bottom: 3px;">
+      <input type="checkbox" checked id="node-input-models_only" style="display: inline-block; width: auto; vertical-align: top; margin-left: 30px; margin-right: 5px;">
+      <label style="width:auto" for="node-input-models_only">Only send models as result</label>
     </div>
 </script>
 
@@ -76,6 +67,20 @@ Only models can be queried by setting the `models_only` flag.
 : processDefinitions / models (Array) : The processDefinitions / models that matched the query.
 : totalCount (number) : The number of matches.
 
+
+### Query fields
+
+**Summary**: 
+
+**Description**: Filter result for &#39;ProcessDefinitions Query&#39;
+
+#### Parameters:
+- Name: `offset` Required: `false`
+  - Type: number
+  - Description: The index of the first ProcessDefinition to include.
+- Name: `limit` Required: `false`
+  - Type: number
+  - Description: The maximum number of ProcessDefinitions to include.  
 ### References
 
 -  [The ProcessCube&copy; Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform

package/processdefinition-query.js

@@ -4,43 +4,45 @@ module.exports = function (RED) {
         var node = this;
 
         node.on('input', function (msg) {
-
-            const engine = RED.nodes.getNode(config.engine);
-            const client = engine.engineClient;
+            node.engine = RED.nodes.getNode(config.engine);
+            const client = node.engine.engineClient;
 
             if (!client) {
-                node.error('No engine configured.');
+                node.error('No engine configured.', msg);
                 return;
             }
 
             let query = RED.util.evaluateNodeProperty(config.query, config.query_type, node, msg);
-            
-            query = {
-                ...query,
-                identity: engine.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);
-            });
+
+            if (typeof query !== 'object' || Array.isArray(query) || query === null) {
+                query = {};
+            }
+
+            node.log(`Querying process definitions with query: ${JSON.stringify(query)}`);
+
+            const isUser = !!msg._client?.user && !!msg._client.user.accessToken;
+            const identity = isUser ? { userId: msg._client.user.id, token: msg._client.user.accessToken } : null;
+            query.identity = identity;
+
+            client.processDefinitions
+                .getAll(query)
+                .then((matchingProcessDefinitions) => {
+                    if (config.models_only) {
+                        const models = matchingProcessDefinitions.processDefinitions.flatMap(processDefinition => processDefinition.processModels);
+
+                        msg.payload = {
+                            models: models,
+                            totalCount: models.length,
+                        };
+                    } else {
+                        msg.payload = matchingProcessDefinitions;
+                    }
+
+                    node.send(msg);
+                })
+                .catch((error) => {
+                    node.error(error, msg);
+                });
         });
     }
     RED.nodes.registerType('processdefinition-query', ProcessdefinitionQuery);

package/processinstance-delete-advanced.html

@@ -0,0 +1,82 @@
+<script type="text/javascript">
+    RED.nodes.registerType('processinstance-delete-advanced', {
+        category: 'ProcessCube DevOps',
+        color: '#02AFD6',
+        defaults: {
+            name: { value: '' },
+            engine: { value: '', type: 'processcube-engine-config' },
+            query: { value: 'payload' },
+            query_type: { value: 'msg' },
+            delete_releated: { value: false },
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'font-awesome/fa-sign-in',
+        label: function () {
+            return this.name || 'processinstance-delete-advanced';
+        },
+        oneditprepare: function () {
+            $('#node-input-query').typedInput({
+                default: 'msg',
+                types: ['msg', 'json'],
+            });
+
+            $('#node-input-query').typedInput('value', this.query);
+            $('#node-input-query').typedInput('type', this.query_type);
+        },
+        oneditsave: function () {
+            (this.query = $('#node-input-query').typedInput('value')),
+                (this.query_type = $('#node-input-query').typedInput('type'));
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="processinstance-delete-advanced">
+    <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-link"></i> Engine-URL</label>
+        <input type="text" id="node-input-engine" placeholder="Engine-URL" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-query"><i class="fa fa-search"></i> Query</label>
+        <input type="text" id="node-input-query" />
+    </div>
+    <div class="form-row" style="margin-bottom: 3px;">
+        <label style="width:auto" for="node-input-delete_releated"><i class="fa fa-trash"></i> Related Data</label>
+        <input
+            type="checkbox"
+            checked
+            id="node-input-delete_releated"
+            style="display: inline-block; width: auto; vertical-align: top; margin-left: 5px; margin-right: 3px;"
+        />
+        <label style="width:auto"> Delete</label>
+    </div>
+</script>
+
+<script type="text/markdown" data-help-name="processinstance-delete-advanced">
+Delete outdated instances of a process model in ProcessCube.
+
+*Supported only on engines version 19 or higher.*
+
+## Inputs
+
+The node can take an input query from either a specific field on the msg object or as a json object directly in the nodes configuration.
+In both cases the node supports the following fields in the query:
+
+
+: processInstanceId (String): The IDs of the ProcessInstances to delete.
+: processModelId (String): The ID of the ProcessModel to delete the instances from.
+: finishedBefore (Datetime): The date before which the instances should be deleted.
+: finshedAfter (Datetime): The date after which the instances should be deleted.
+
+
+## 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/processinstance-delete-advanced.js

@@ -0,0 +1,33 @@
+module.exports = function (RED) {
+    function ProcessInstanceDeleteAdvanced(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.on('input', async function (msg) {
+            node.engine = RED.nodes.getNode(config.engine);
+            const client = node.engine ? node.engine.engineClient : null;
+
+            let query = RED.util.evaluateNodeProperty(config.query, config.query_type, node, msg);
+
+            const isUser = !!msg._client?.user && !!msg._client.user.accessToken;
+            const userIdentity = isUser ? { userId: msg._client.user.id, token: msg._client.user.accessToken } : null;
+
+            if (!client || !client.processInstances) {
+                node.error('No engine or processInstances API configured.', msg);
+                return;
+            }
+
+            try {
+                const result = await client.processInstances.delete(query, config.delete_releated, userIdentity)
+
+                msg.payload = result
+
+                node.send(msg);
+            } catch (queryError) {
+                node.error(`Failed to delete process instances Error: ${queryError.message}`, msg);
+            }
+        });
+    }
+
+    RED.nodes.registerType('processinstance-delete-advanced', ProcessInstanceDeleteAdvanced);
+};

package/processinstance-delete.html

@@ -5,8 +5,10 @@
         defaults: {
             name: { value: '' },
             engine: { value: '', type: 'processcube-engine-config' },
-            time: { value: '', type: 'number' },
-            time_type: { value: 'hours' },
+            modelid: { value: '' },
+            duration: { value: '', type: 'number' },
+            time_type: { value: '' },
+            batch_size: { value: '100', type: 'number' },
         },
         inputs: 1,
         outputs: 1,
@@ -27,29 +29,79 @@
         <input type="text" id="node-input-engine" placeholder="Engine-URL" />
     </div>
     <div class="form-row">
-        <label for="node-input-time"><i class="fa fa-tag"></i> Time</label>
-        <input type="text" id="node-input-time" />
+        <label for="node-input-modelid"><i class="fa fa-tag"></i> Model-ID</label>
+        <input type="text" id="node-input-modelid" />
     </div>
     <div class="form-row">
-        <label for="node-input-time_type"><i class="fa fa-sliders"></i> Period</label>
+        <label for="node-input-duration"><i class="fa fa-tag"></i> Duration</label>
+        <input type="text" id="node-input-duration" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-time_type"><i class="fa fa-sliders"></i> Time Unit</label>
         <select id="node-input-time_type" style="width: 70%;">
             <option value="hours">Hours</option>
             <option value="days">Days</option>
         </select>
     </div>
+    <div class="form-row">
+        <label for="node-input-batch-size"><i class="fa fa-tag"></i> Batch Size</label>
+        <input type="text" id="node-input-batch_size" />
+    </div>
 </script>
 
 <script type="text/markdown" data-help-name="processinstance-delete">
-Delete old instances of a process model in the ProcessCube.
+Delete old instances of a process model in the ProcessCube. 
 
 ## Inputs
 
-: payload.time (number): The number of given time periods.
+: payload.duration (number): The number of given time periods.
 : payload.time_type ('hours' | 'days'): The type of time period to use.
+: payload.batch_size (number): The number of instances to be deleted simultaneously. (default 100)
 
 ## Outputs
 
-: payload (string[]): The ids of the processinstances that were deleted.
+: Explanation of the payload:
+
+Object
+{
+    successfulDeletions: [Array of strings],
+    failedDeletions: [Array of objects]
+}
+
+- successfulDeletions:
+    - Type: Array<String>
+    - Content: A list of successfully deleted process instance IDs.
+
+    - excample:
+        successfulDeletions: [
+        "instanceId1",
+        "instanceId2",
+        "instanceId3"
+       ]
+
+- failedDeletions:
+    - Type: Array<Object>
+    - Content: A list of objects containing details of the failed deletions.
+    - Each object has the following fields:
+        - id: The ID of the process instance that could not be deleted.
+        - error: The error message or the reason for the error.
+
+- Example of a complete output:
+    {
+        successfulDeletions: [
+            "instanceId1",
+            "instanceId2",
+            "instanceId3"
+        ],
+        failedDeletions: [
+            { id: "instanceId4", error: "Permission denied" },
+            { id: "instanceId5", error: "Instance not found" }
+        ]
+    }
+
+The node processes the IDs in configurable batches (default value: 100) and inserts successfully deleted or failed instances into the arrays accordingly.
+As processing is currently forced to batch, a detailed error output is not possible. 
+If an error occurs during the processing of a batch, all Id's of this batch are marked as faulty.
 
 ### References
 

package/processinstance-delete.js

@@ -1,52 +1,106 @@
 module.exports = function (RED) {
     function ProcessInstanceDelete(config) {
         RED.nodes.createNode(this, config);
-        var node = this;
+        const node = this;
 
         node.on('input', async function (msg) {
-            const engine = RED.nodes.getNode(config.engine);
-            const client = engine.engineClient;
+            node.engine = RED.nodes.getNode(config.engine);
+            const client = node.engine ? node.engine.engineClient : null;
 
-            if (!client) {
-                node.error('No engine configured.');
+            const isUser = !!msg._client?.user && !!msg._client.user.accessToken;
+            const userIdentity = isUser ? { userId: msg._client.user.id, token: msg._client.user.accessToken } : null;
+
+            if (!client || !client.processInstances) {
+                node.error('No engine or processInstances API configured.', msg);
+                return;
+            }
+
+            const timeToUse = msg.payload.duration || config.duration;
+            if (!timeToUse || isNaN(timeToUse) || timeToUse <= 0) {
+                node.error('Invalid duration: must be a positive number.', msg);
+                return;
+            }
+
+            // Gültige Werte für time_type
+            const validTimeTypes = ['days', 'hours'];
+            const timeType = msg.payload.time_type
+                ? msg.payload.time_type.toLowerCase()
+                : config.time_type?.toLowerCase();
+
+            // time_type validieren
+            if (!timeType || !validTimeTypes.includes(timeType)) {
+                node.error(`Invalid time_type provided: ${timeType}. Allowed values are 'days' or 'hours'.`, msg);
                 return;
             }
-            let timeMultiplier;
-            if (msg.payload.time_type) {
-                timeMultiplier = msg.payload.time_type == 'hours' ? 1 : 24;
-            } else {
-                timeMultiplier = config.time_type == 'hours' ? 1 : 24;
+
+            // Zeitmultiplikator berechnen
+            const multiplier = timeType === 'hours' ? 1 : 24;
+            node.log(`Time type: ${timeType}`);
+
+            const deletionDate = new Date(Date.now() - timeToUse * multiplier * 60 * 60 * 1000);            
+
+            const modelId = msg.payload.processModelId?.trim() || config.modelid?.trim();
+            if (!modelId) {
+                node.error('processModelId is not defined or empty.', msg);
+                return;
             }
 
-            const timeToUse = msg.payload.time ? msg.payload.time : config.time;
+            // Prüfung und Festlegung von batch_size
+            let batchSize = msg.payload.batch_size || config.batch_size || 1000;
+            if (isNaN(batchSize) || batchSize <= 0 || batchSize > 1000) {
+                node.error(`Invalid batch_size: ${batchSize}. Must be a positive number and not exceed 1000.`, msg);
+                return;
+            }
+            batchSize = Math.min(batchSize, 1000); // Sicherstellen, dass der Wert 1000 nicht überschreitet
 
             try {
-                const fetchInstancesByState = async (state) => {
-                    const result = await client.processInstances.query({ state });
-                    return result.processInstances;
-                };
+                msg.payload = { successfulDeletions: [], failedDeletions: [] };
 
-                const finishedInstances = await fetchInstancesByState('finished');
-                const terminatedInstances = await fetchInstancesByState('terminated');
-                const errorInstances = await fetchInstancesByState('error');
+                let hasMoreResults = true;
+                let sumSuccessful = 0;
+                let sumFailed = 0;
+                while (hasMoreResults) {
+                    const result = await client.processInstances.query(
+                        {
+                            processModelId: modelId,
+                            finishedBefore: deletionDate.toISOString(),
+                            state: ['finished', 'error', 'terminated'],
+                            limit: batchSize,
+                        },
+                        { 
+                            includeXml: false,
+                            identity: userIdentity
+                        }
+                    );
 
-                let allInstances = [...finishedInstances, ...terminatedInstances, ...errorInstances];
+                    const processInstances = result.processInstances || [];
+                    if (processInstances.length === 0) {
+                        node.log(`No more process instances to delete for Model-ID: ${modelId} with Date: ${deletionDate.toISOString()}`, msg);
+                        hasMoreResults = false;
+                        continue;
+                    }
 
-                const today = new Date();
+                    const ids = processInstances.map((obj) => obj.processInstanceId);
 
-                const oldTasks = allInstances.filter((instance) => {
-                    const finishedDate = new Date(instance.finishedAt);
-                    const diffInHours = (today - finishedDate) / (1000 * 60 * 60);
-                    return diffInHours > Number(timeToUse) * timeMultiplier;
-                });
+                    try {
+                        await client.processInstances.deleteProcessInstances(ids, true, userIdentity);
+                        msg.payload.successfulDeletions.push(...ids);
+                        sumSuccessful += ids.length;                         
+                    } catch (deleteError) {
+                        var message = JSON.stringify(deleteError);
+                        sumFailed += ids.length;
+                        ids.forEach((id) => {
+                            msg.payload.failedDeletions.push({ id, error: message });
+                        });
+                        node.warn(`Failed to delete some process instances for Model-ID: ${modelId}. Error: ${message}`);
+                    }
+                }
+                node.log(`Successfully deleted ${sumSuccessful} process instances and ${sumFailed} failed to delete process instances for Model-ID: ${modelId}.`);
 
-                const ids = oldTasks.map((obj) => obj.processInstanceId);
-                msg.payload = ids;
 
-                await client.processInstances.deleteProcessInstances(ids, true, engine.identity);
                 node.send(msg);
-            } catch (error) {
-                node.error(error);
+            } catch (queryError) {
+                node.error(`Failed to query process instances for Model-ID: ${modelId}. Error: ${queryError.message}`, msg);
             }
         });
     }