npm - @steedos-labs/plugin-workflow - Versions diffs - 3.0.36 → 3.0.37 - Mend

@steedos-labs/plugin-workflow 3.0.36 → 3.0.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/designer/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/api/workflow/designer-v2/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>designer</title>
-    <script type="module" crossorigin src="/api/workflow/designer-v2/assets/index-r2EtJdFh.js"></script>
-    <link rel="stylesheet" crossorigin href="/api/workflow/designer-v2/assets/index-CzP9-MzW.css">
+    <script type="module" crossorigin src="/api/workflow/designer-v2/assets/index-DkVFo_s4.js"></script>
+    <link rel="stylesheet" crossorigin href="/api/workflow/designer-v2/assets/index-BVsRCpLO.css">
   </head>
   <body>
     <div id="root"></div>

package/main/default/manager/uuflow_manager.js CHANGED Viewed

@@ -1496,6 +1496,41 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     }
     console.log(`[workflow/engine] [workflow_engine] update instance(second part) took ${Date.now() - t8}ms`);
+    // Skip Processed: Update processed_user_ids based on step type and judge
+    const t8_skip = Date.now();
+    if (step_type === 'sign' && judge === 'approved') {
+        // Sign node approval - add current user to processed set
+        await instancesCollection.updateOne(
+            { _id: instance_id },
+            { $addToSet: { processed_user_ids: current_user } }
+        );
+    } else if (step_type === 'sign' && judge === 'rejected') {
+        // Sign node rejection - reset processed set to applicant only
+        await instancesCollection.updateOne(
+            { _id: instance_id },
+            { $set: { processed_user_ids: [updatedInstance.applicant] } }
+        );
+    } else if (step_type === 'counterSign') {
+        // Check if the counterSign trace is now fully finished
+        const csInstance = await UUFlowManager.getInstance(instance_id);
+        const csTrace = _.find(csInstance.traces, t => t._id === trace_id);
+        if (csTrace && csTrace.is_finished) {
+            // All finished - add all non-cc/distribute approved users to processed set
+            const approvedUsers = csTrace.approves
+                .filter(a => isNormalApprove(a) && a.is_finished && a.judge !== 'skipped')
+                .map(a => a.user);
+            if (approvedUsers.length > 0) {
+                await instancesCollection.updateOne(
+                    { _id: instance_id },
+                    { $addToSet: { processed_user_ids: { $each: approvedUsers } } }
+                );
+            }
+        }
+    }
+    // Skip Processed: Check if next step should be auto-skipped
+    await UUFlowManager.handleSkipProcessed(instance_id, flow);
+    console.log(`[workflow/engine] [workflow_engine] handleSkipProcessed took ${Date.now() - t8_skip}ms`);
     const t9 = Date.now();
     // Get final updated instance
     const finalInstance = await UUFlowManager.getInstance(instance_id);
@@ -1549,6 +1584,360 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     return finalInstance;
 };
+// Skip processed constants and helpers
+const SKIP_DESCRIPTION = '滑步跳过：已在之前步骤处理过';
+function isNormalApprove(approve) {
+    return !approve.type || approve.type === 'draft' || approve.type === 'reassign';
+}
+/**
+ * Handle skip processed (滑步) logic for workflow instances.
+ * When a new trace is created for the next step, check if the handlers
+ * should be automatically skipped because they are already in the processed_user_ids set.
+ *
+ * @param {String} instance_id - Instance ID
+ * @param {Object} flow - Flow object
+ * @param {Number} maxDepth - Maximum recursion depth to prevent infinite loops.
+ *   Default 20 is generous since typical workflows have fewer than 20 sequential steps.
+ *   This prevents infinite loops caused by circular flow definitions.
+ */
+UUFlowManager.handleSkipProcessed = async function (instance_id, flow, maxDepth = 20) {
+    if (maxDepth <= 0) {
+        console.warn('[workflow/engine] [handleSkipProcessed] Max recursion depth reached');
+        return;
+    }
+    const instancesCollection = await getCollection('instances');
+    const instance = await UUFlowManager.getInstance(instance_id);
+    // Only process pending instances
+    if (instance.state !== 'pending') return;
+    const processedUserIds = instance.processed_user_ids || [];
+    if (processedUserIds.length === 0) return;
+    // Get the last trace (the one just created for the next step)
+    const lastTrace = _.last(instance.traces);
+    if (!lastTrace || lastTrace.is_finished) return;
+    // Get the step definition for this trace
+    let step;
+    try {
+        step = UUFlowManager.getStep(instance, flow, lastTrace.step);
+    } catch (e) {
+        return;
+    }
+    // Only skip for sign and counterSign nodes
+    if (!['sign', 'counterSign'].includes(step.step_type)) return;
+    // Check if skip_enabled (default true)
+    if (step.skip_enabled === false) return;
+    // Get non-cc/distribute approves
+    const normalApproves = lastTrace.approves.filter(isNormalApprove);
+    if (normalApproves.length === 0) return;
+    // Check which users should be skipped
+    const shouldSkipApproves = normalApproves.filter(a => processedUserIds.includes(a.user));
+    if (shouldSkipApproves.length === 0) return;
+    const now = new Date();
+    const traceIdx = instance.traces.length - 1;
+    if (shouldSkipApproves.length === normalApproves.length) {
+        // All users should be skipped - skip entire node
+        console.log(`[workflow/engine] [handleSkipProcessed] Skipping entire step "${step.name}" - all handlers already processed`);
+        // Determine the next step from this skipped step
+        // For sign: use "approved" lines; for counterSign: use "submitted" lines
+        const lineState = step.step_type === 'sign' ? 'approved' : 'submitted';
+        const lines = (step.lines || []).filter(l => l.state === lineState);
+        if (lines.length === 0) {
+            console.warn('[workflow/engine] [handleSkipProcessed] No outgoing lines found for skipped step');
+            return;
+        }
+        const next_step_id = lines[0].to_step;
+        let next_step;
+        try {
+            next_step = UUFlowManager.getStep(instance, flow, next_step_id);
+        } catch (e) {
+            return;
+        }
+        // Mark current trace as finished with all approves as skipped
+        const setObj = {};
+        setObj[`traces.${traceIdx}.is_finished`] = true;
+        setObj[`traces.${traceIdx}.finish_date`] = now;
+        setObj[`traces.${traceIdx}.judge`] = 'skipped';
+        for (let h = 0; h < lastTrace.approves.length; h++) {
+            const approve = lastTrace.approves[h];
+            if (isNormalApprove(approve)) {
+                setObj[`traces.${traceIdx}.approves.${h}.is_finished`] = true;
+                setObj[`traces.${traceIdx}.approves.${h}.finish_date`] = now;
+                setObj[`traces.${traceIdx}.approves.${h}.judge`] = 'skipped';
+                setObj[`traces.${traceIdx}.approves.${h}.is_read`] = true;
+                setObj[`traces.${traceIdx}.approves.${h}.read_date`] = now;
+                setObj[`traces.${traceIdx}.approves.${h}.cost_time`] = 0;
+                setObj[`traces.${traceIdx}.approves.${h}.description`] = SKIP_DESCRIPTION;
+            }
+        }
+        // Collect skipped user IDs to add to processed set
+        const skippedUserIds = shouldSkipApproves.map(a => a.user);
+        const skippedHandlers = shouldSkipApproves.map(a => a.handler);
+        if (next_step.step_type === 'end') {
+            // Flow ends
+            const newEndTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [lastTrace._id],
+                is_finished: true,
+                step: next_step_id,
+                name: next_step.name,
+                start_date: now,
+                finish_date: now
+            };
+            setObj.state = 'completed';
+            setObj.finish_date = now;
+            setObj.inbox_users = [];
+            setObj.current_step_name = next_step.name;
+            setObj.final_decision = 'approved';
+            setObj.current_step_auto_submit = false;
+            setObj.modified = now;
+            // Split into two updates to avoid MongoDB conflict on 'traces' path
+            // 1) $set trace sub-paths (traces.X.Y)
+            const traceSetObj1 = {};
+            const otherSetObj1 = {};
+            for (const key of Object.keys(setObj)) {
+                if (key.startsWith('traces.')) {
+                    traceSetObj1[key] = setObj[key];
+                } else {
+                    otherSetObj1[key] = setObj[key];
+                }
+            }
+            if (Object.keys(traceSetObj1).length > 0) {
+                await instancesCollection.updateOne(
+                    { _id: instance_id },
+                    { $set: traceSetObj1 }
+                );
+            }
+            // 2) $push new trace + $set non-trace fields + $addToSet
+            await instancesCollection.updateOne(
+                { _id: instance_id },
+                {
+                    $set: otherSetObj1,
+                    $push: { traces: newEndTrace },
+                    $addToSet: {
+                        processed_user_ids: { $each: skippedUserIds },
+                        outbox_users: { $each: skippedHandlers }
+                    }
+                }
+            );
+            // Update instance tasks for skipped approves
+            for (const approve of shouldSkipApproves) {
+                await update_instance_tasks(instance_id, lastTrace._id, approve._id);
+            }
+        } else {
+            // Create new trace for the next step
+            const space_id = instance.space;
+            const next_step_users = await HandlersManager.getHandlers(instance_id, next_step_id, instance.applicant);
+            if (!next_step_users || next_step_users.length === 0) {
+                console.warn('[workflow/engine] [handleSkipProcessed] No handlers found for next step after skip');
+                return;
+            }
+            // For non-counterSign steps, use only the first handler
+            let usersForTrace = next_step_users.slice();
+            if (next_step.step_type !== 'counterSign' && usersForTrace.length > 1) {
+                usersForTrace = [usersForTrace[0]];
+            }
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [lastTrace._id],
+                is_finished: false,
+                step: next_step_id,
+                name: next_step.name,
+                start_date: now,
+                due_date: UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+                approves: []
+            };
+            const usersCollection = await getCollection('users');
+            const spaceUsersCollection = await getCollection('space_users');
+            const updatedValues = await UUFlowManager.getUpdatedValues(instance);
+            const traceUserIds = [];
+            for (let idx = 0; idx < usersForTrace.length; idx++) {
+                const next_step_user_id = usersForTrace[idx];
+                const user_info = await usersCollection.findOne(
+                    { _id: next_step_user_id },
+                    { projection: { name: 1 } }
+                );
+                if (!user_info) continue;
+                const newApprove = {
+                    _id: _makeNewID(),
+                    instance: instance_id,
+                    trace: newTrace._id,
+                    is_finished: false,
+                    user: next_step_user_id,
+                    user_name: user_info.name
+                };
+                let handler_id = next_step_user_id;
+                let handler_info = user_info;
+                const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+                if (agent) {
+                    usersForTrace[idx] = agent;
+                    handler_id = agent;
+                    handler_info = await usersCollection.findOne(
+                        { _id: agent },
+                        { projection: { name: 1 } }
+                    );
+                    newApprove.agent = agent;
+                }
+                newApprove.handler = handler_id;
+                newApprove.handler_name = handler_info.name;
+                const next_step_space_user = await spaceUsersCollection.findOne({
+                    space: space_id,
+                    user: handler_id
+                });
+                if (next_step_space_user) {
+                    const org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                    newApprove.handler_organization = org_info.organization;
+                    newApprove.handler_organization_name = org_info.organization_name;
+                    newApprove.handler_organization_fullname = org_info.organization_fullname;
+                }
+                newApprove.start_date = now;
+                newApprove.due_date = newTrace.due_date;
+                newApprove.is_read = false;
+                newApprove.is_error = false;
+                newApprove.values = {};
+                UUFlowManager.setRemindInfo(updatedValues, newApprove);
+                newTrace.approves.push(newApprove);
+                traceUserIds.push(handler_id);
+            }
+            if (newTrace.approves.length === 0) {
+                console.warn('[workflow/engine] [handleSkipProcessed] No valid approves created for next step');
+                return;
+            }
+            setObj.inbox_users = traceUserIds;
+            setObj.current_step_name = next_step.name;
+            setObj.modified = now;
+            // Split into two updates to avoid MongoDB conflict on 'traces' path
+            // 1) $set trace sub-paths (traces.X.Y)
+            const traceSetObj2 = {};
+            const otherSetObj2 = {};
+            for (const key of Object.keys(setObj)) {
+                if (key.startsWith('traces.')) {
+                    traceSetObj2[key] = setObj[key];
+                } else {
+                    otherSetObj2[key] = setObj[key];
+                }
+            }
+            if (Object.keys(traceSetObj2).length > 0) {
+                await instancesCollection.updateOne(
+                    { _id: instance_id },
+                    { $set: traceSetObj2 }
+                );
+            }
+            // 2) $push new trace + $set non-trace fields + $addToSet
+            await instancesCollection.updateOne(
+                { _id: instance_id },
+                {
+                    $set: otherSetObj2,
+                    $push: { traces: newTrace },
+                    $addToSet: {
+                        processed_user_ids: { $each: skippedUserIds },
+                        outbox_users: { $each: skippedHandlers }
+                    }
+                }
+            );
+            // Update instance tasks for skipped approves
+            for (const approve of shouldSkipApproves) {
+                await update_instance_tasks(instance_id, lastTrace._id, approve._id);
+            }
+            // Insert tasks for new trace
+            const approveIds = newTrace.approves.map(a => a._id);
+            await insert_many_instance_tasks(instance_id, newTrace._id, approveIds);
+            // Recursively check if the new trace should also be skipped
+            await UUFlowManager.handleSkipProcessed(instance_id, flow, maxDepth - 1);
+        }
+    } else {
+        // Partial skip (counterSign) - mark skipped users' approves as finished
+        console.log(`[workflow/engine] [handleSkipProcessed] Partial skip in counterSign step "${step.name}" - ${shouldSkipApproves.length}/${normalApproves.length} handlers already processed`);
+        const setObj = {};
+        for (let h = 0; h < lastTrace.approves.length; h++) {
+            const approve = lastTrace.approves[h];
+            if (processedUserIds.includes(approve.user) && isNormalApprove(approve)) {
+                setObj[`traces.${traceIdx}.approves.${h}.is_finished`] = true;
+                setObj[`traces.${traceIdx}.approves.${h}.finish_date`] = now;
+                setObj[`traces.${traceIdx}.approves.${h}.judge`] = 'skipped';
+                setObj[`traces.${traceIdx}.approves.${h}.is_read`] = true;
+                setObj[`traces.${traceIdx}.approves.${h}.read_date`] = now;
+                setObj[`traces.${traceIdx}.approves.${h}.cost_time`] = 0;
+                setObj[`traces.${traceIdx}.approves.${h}.description`] = SKIP_DESCRIPTION;
+            }
+        }
+        // Remove skipped users from inbox_users
+        const skippedHandlers = shouldSkipApproves.map(a => a.handler);
+        const newInboxUsers = (instance.inbox_users || []).filter(u => !skippedHandlers.includes(u));
+        setObj.inbox_users = newInboxUsers;
+        const skippedUserIds = shouldSkipApproves.map(a => a.user);
+        await instancesCollection.updateOne(
+            { _id: instance_id },
+            {
+                $set: setObj,
+                $addToSet: {
+                    processed_user_ids: { $each: skippedUserIds },
+                    outbox_users: { $each: skippedHandlers }
+                }
+            }
+        );
+        // Update instance tasks for skipped approves
+        for (const approve of shouldSkipApproves) {
+            await update_instance_tasks(instance_id, lastTrace._id, approve._id);
+        }
+    }
+};
 /**
  * Handle workflow engine for start/submit/condition steps
  * @param {String} instance_id - Instance ID
@@ -3155,6 +3544,18 @@ UUFlowManager.submit_instance = async function (instance_from_client, user_info)
         await insert_many_instance_tasks(instance_id, nextTrace._id, approveIds);
     }
+    // Skip Processed: Initialize processed_user_ids with applicant
+    const instancesCollectionForSkip = await getCollection('instances');
+    await instancesCollectionForSkip.updateOne(
+        { _id: instance_id },
+        { $set: { processed_user_ids: [applicant_id] } }
+    );
+    // Skip Processed: Check if next step should be auto-skipped
+    if (next_step.step_type !== "end") {
+        await UUFlowManager.handleSkipProcessed(instance_id, flow);
+    }
     if (next_step.step_type !== "end") {
         const finalInstance = await UUFlowManager.getInstance(instance_id);
         // 发送短消息给申请人

package/main/default/objects/instances/buttons/instance_save.button.yml CHANGED Viewed

@@ -17,7 +17,7 @@ amis_schema: |-
                                       "url": "/api/workflow/v2/instance/save",
                                       "method": "post",
                                       "sendOn": "",
-                                      "requestAdaptor": "var _SteedosUI$getRef$get, _approveValues$next_s;\nconst formValues = context._scoped.getComponentById(\"instance_form\").getValues();const _formValues = JSON.parse(JSON.stringify(formValues)); if(_formValues){delete _formValues.__applicant} \nconst approveValues = (_SteedosUI$getRef$get = context._scoped.getComponentById(\"instance_approval\")) === null || _SteedosUI$getRef$get === void 0 ? void 0 : _SteedosUI$getRef$get.getValues();\nlet nextUsers = approveValues === null || approveValues === void 0 ? void 0 : approveValues.next_users;\nif (_.isString(nextUsers)) {\n  nextUsers = [approveValues.next_users];\n}\nconst instance = context.record;\nconst body = {\n  instance: {\n    _id: instance._id,\n    applicant: formValues.applicant.user,\n    submitter: formValues.submitter,\n    traces: [{\n      _id: instance.trace._id,\n      step: instance.step._id,\n      approves: [{\n        _id: instance.approve._id,\n        next_steps: [{\n          step: approveValues === null || approveValues === void 0 || (_approveValues$next_s = approveValues.next_step) === null || _approveValues$next_s === void 0 ? void 0 : _approveValues$next_s._id,\n          users: nextUsers\n        }],\n        description: approveValues === null || approveValues === void 0 ? void 0 : approveValues.suggestion,\n        values: _formValues\n      }]\n    }]\n  }\n};\napi.data = body;\nreturn api;",
+                                      "requestAdaptor": "var _SteedosUI$getRef$get, _approveValues$next_s;\nconst formValues = context._scoped.getComponentById(\"instance_form\").getValues();const _formValues = JSON.parse(JSON.stringify(formValues)); if(_formValues){delete _formValues.__applicant} \nconst approveValues = (_SteedosUI$getRef$get = context._scoped.getComponentById(\"instance_approval\")) === null || _SteedosUI$getRef$get === void 0 ? void 0 : _SteedosUI$getRef$get.getValues();\nlet nextUsers = approveValues === null || approveValues === void 0 ? void 0 : approveValues.next_users;\nif (_.isString(nextUsers)) {\n  nextUsers = [approveValues.next_users];\n}\nconst instance = context.record;\nconst body = {\n  instance: {\n    _id: instance._id,\n    applicant: formValues.__applicant || formValues.applicant.user,\n    submitter: formValues.submitter,\n    traces: [{\n      _id: instance.trace._id,\n      step: instance.step._id,\n      approves: [{\n        _id: instance.approve._id,\n        next_steps: [{\n          step: approveValues === null || approveValues === void 0 || (_approveValues$next_s = approveValues.next_step) === null || _approveValues$next_s === void 0 ? void 0 : _approveValues$next_s._id,\n          users: nextUsers\n        }],\n        description: approveValues === null || approveValues === void 0 ? void 0 : approveValues.suggestion,\n        values: _formValues\n      }]\n    }]\n  }\n};\napi.data = body;\nreturn api;",
                                       "adaptor": "window.SteedosWorkflow.Instance.changed = false; if (payload.instance == \"upgraded\") { window.setTimeout(function(){ $('.steedos-workflow-reload-btn').trigger('click'); }, 2000); return {...payload, status: 1, msg: t('instance_action_instance_save_msg_upgraded')}; } \n return payload.instance != false ? {data: payload, status: 0, msg: t('instance_action_instance_save_msg_success')} : {...payload, status: 1, msg: t('instance_action_instance_save_msg_failed')};",
                                       "data": {
                                           "&": "$$"

package/main/default/objects/workflow_designer_backups.object.yml ADDED Viewed

@@ -0,0 +1,62 @@
+name: workflow_designer_backups
+label: Designer Backups
+icon: backup
+hidden: true
+enable_dataloader: false
+fields:
+  name:
+    type: text
+    label: Name
+    required: true
+    name: name
+  form_id:
+    type: text
+    label: Form ID
+    required: true
+    name: form_id
+    index: true
+  flow_id:
+    type: text
+    label: Flow ID
+    name: flow_id
+  backup_type:
+    type: select
+    label: Backup Type
+    options:
+      - label: AI Upgrade
+        value: ai_upgrade
+      - label: Import
+        value: import
+    name: backup_type
+  form_snapshot:
+    type: textarea
+    label: Form Snapshot
+    name: form_snapshot
+    is_wide: true
+  flow_snapshot:
+    type: textarea
+    label: Flow Snapshot
+    name: flow_snapshot
+    is_wide: true
+list_views:
+  all:
+    label: All
+    columns:
+      - name
+      - form_id
+      - backup_type
+      - created
+    sort:
+      - - created
+        - desc
+permission_set:
+  user:
+    allowCreate: true
+    allowRead: true
+    allowEdit: true
+    allowDelete: true
+  admin:
+    allowCreate: true
+    allowRead: true
+    allowEdit: true
+    allowDelete: true

package/main/default/routes/api_workflow_instance_return.router.js CHANGED Viewed

@@ -171,6 +171,13 @@ router.post('/api/workflow/v2/instance/return', requireAuthentication, async fun
         });
         // 生成新记录
         await insert_instance_tasks(instance_id, newTrace._id, newTrace.approves[0]._id)
+        // Skip Processed: Reset processed_user_ids to applicant only on return/rejection
+        await instancesCollection.updateOne(
+            { _id: instance_id },
+            { $set: { processed_user_ids: [ins.applicant] } }
+        );
         if (r && b) {
             await pushManager.send_message_to_specifyUser("current_user", current_user);
             instance = await UUFlowManager.getInstance(instance_id);

package/main/default/utils/designerManager.js CHANGED Viewed

@@ -267,6 +267,8 @@ async function updateForm(formId, form, forms, flows, currentUserId) {
     current.viewMode = form["current"]["viewMode"];
     current.tableColumns = form["current"]["tableColumns"];
+    current.events = form["current"]["events"];
     formUpdateObj.$set = {
         'current': current,
         'name': form["name"],

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.36",
+  "version": "3.0.37",
   "main": "package.service.js",
   "license": "MIT",
   "files": [