@5minds/node-red-contrib-processcube 1.5.12 → 1.6.0-develop-dc8225-m4wqtshx

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.5.12",
+    "version": "1.6.0-develop-dc8225-m4wqtshx",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {

package/processinstance-delete.html

@@ -7,7 +7,7 @@
             engine: { value: '', type: 'processcube-engine-config' },
             modelid: { value: '' },
             duration: { value: '', type: 'number' },
-            time_unit: { value: 'hours' },
+            time_type: { value: '' },
             batch_size: { value: '100', type: 'number' },
         },
         inputs: 1,
@@ -37,8 +37,8 @@
         <input type="text" id="node-input-duration" />
     </div>
     <div class="form-row">
-        <label for="node-input-time_unit"><i class="fa fa-sliders"></i> Time Unit</label>
-        <select id="node-input-time_unit" style="width: 70%;">
+        <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>
@@ -55,7 +55,7 @@ Delete old instances of a process model in the ProcessCube.
 ## Inputs
 
 : payload.duration (number): The number of given time periods.
-: payload.time_unit ('hours' | 'days'): The type of time period to use.
+: 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

package/processinstance-delete.js

@@ -1,72 +1,100 @@
 module.exports = function (RED) {
     function ProcessInstanceDelete(config) {
         RED.nodes.createNode(this, config);
-        var node = this;
+        const node = this;
 
         node.on('input', async function (msg) {
             node.engine = RED.nodes.getNode(config.engine);
-            const client = node.engine.engineClient;
+            const client = node.engine ? node.engine.engineClient : null;
 
-            if (!client) {
-                node.error('No engine configured.');
+            if (!client || !client.processInstances) {
+                node.error('No engine or processInstances API configured.');
                 return;
             }
 
-            let timeMultiplier;
-            if (msg.payload.time_unit) {
-                timeMultiplier = msg.payload.time_unit == 'hours' ? 1 : 24;
-            } else {
-                timeMultiplier = config.time_unit == 'hours' ? 1 : 24;
+            const timeToUse = msg.payload.duration || config.duration;
+            if (!timeToUse || isNaN(timeToUse) || timeToUse <= 0) {
+                node.error('Invalid duration: must be a positive number.');
+                return;
             }
 
-            const timeToUse = msg.payload.duration ? msg.payload.duration : config.duration;
-            const modelId = msg.payload.processModelId
-                ? msg.payload.processModelId != ''
-                    ? msg.payload.processModelId
-                    : undefined
-                : config.modelid != ''
-                ? config.modelid
-                : undefined;
+            // 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();
 
-            const batchSize = config.batch_size || 100; // Konfigurierbare Batchgröße, Standardwert 100
+            // time_type validieren
+            if (!timeType || !validTimeTypes.includes(timeType)) {
+                node.error(`Invalid time_type provided: ${timeType}. Allowed values are 'days' or 'hours'.`);
+                return;
+            }
 
-            try {
-                const result = await client.processInstances.query({
-                    processModelId: modelId
-                }, { identity: node.engine.identity });
+            // 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.');
+                return;
+            }
 
-                let allInstances = result.processInstances.filter((instance) => instance.state != 'suspended' && instance.state != 'running');
+            // 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.`);
+                return;
+            }
+            batchSize = Math.min(batchSize, 1000); // Sicherstellen, dass der Wert 1000 nicht überschreitet
 
-                const today = new Date();
+            try {
+                msg.payload = { successfulDeletions: [], failedDeletions: [] };
 
-                const oldTasks = allInstances.filter((instance) => {
-                    const finishedDate = new Date(instance.finishedAt);
-                    const diffInHours = (today - finishedDate) / (1000 * 60 * 60);
-                    return diffInHours > Number(timeToUse) * timeMultiplier;
-                });
+                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 }
+                    );
 
-                const ids = oldTasks.map((obj) => obj.processInstanceId);
+                    const processInstances = result.processInstances || [];
+                    if (processInstances.length === 0) {
+                        node.log(`No more process instances to delete for Model-ID: ${modelId} with Date: ${deletionDate.toISOString()}`);
+                        hasMoreResults = false;
+                        continue;
+                    }
 
-                msg.payload = {
-                    successfulDeletions: [],
-                    failedDeletions: []
-                };
+                    const ids = processInstances.map((obj) => obj.processInstanceId);
 
-                for (let i = 0; i < ids.length; i += batchSize) {
-                    const batch = ids.slice(i, i + batchSize);
                     try {
-                        await client.processInstances.deleteProcessInstances(batch, true, engine.identity);
-                        msg.payload.successfulDeletions.push(...batch); // Erfolgreiche IDs hinzufügen
+                        await client.processInstances.deleteProcessInstances(ids, true);
+                        msg.payload.successfulDeletions.push(...ids);
+                        sumSuccessful += ids.length;                         
                     } catch (deleteError) {
-                        batch.forEach(id => {
-                            msg.payload.failedDeletions.push({ id, error: deleteError.message }); // Fehler protokollieren
+                        var message = JSON.stringify(deleteError);
+                        sumFailed += ids.length;
+                        ids.forEach((id) => {
+                            msg.payload.failedDeletions.push({ id, error: message });
                         });
-                        node.warn(`Failed to delete process instances in batch: ${batch.join(', ')}. Error: ${deleteError.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}.`);
+
+
                 node.send(msg);
             } catch (queryError) {
-                node.error(`Failed to query process instances: ${queryError.message}`);
+                node.error(`Failed to query process instances for Model-ID: ${modelId}. Error: ${queryError.message}`);
             }
         });
     }