@steedos-labs/plugin-workflow 3.0.101 → 3.0.103

package/main/default/client/flow2_render.client.js

@@ -1,5 +1,5 @@
 waitForThing(window, 'antd').then(function(){
-    var v = '3.0.101';
+    var v = '3.0.103';
     loadJs('/amis-renderer/amis-renderer.js?v=' + v);
     loadCss('/amis-renderer/amis-renderer.css?v=' + v)
 })

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

@@ -44,12 +44,23 @@ router.post('/api/workflow/v2/instance/return', requireAuthentication, async fun
             throw new Error("不符合退回条件：当前为第一步，无法退回");
         }
         flow = await UUFlowManager.getFlow(ins.flow);
-        pre_trace = ins.traces[ins.traces.length - 2];
+        last_trace = _.last(ins.traces);
+        // 滑步处理：如果上一步是被跳过的(skipped)，沿 previous_trace_ids 向前回溯，
+        // 退回到用户实际处理过的那个 trace（与取回 api_workflow_retrieve.router.js 的回溯逻辑一致），
+        // 否则 skipped approves 会被下方 new_inbox_users 过滤条件排除，导致"未找到下一步处理人"
+        var pre_trace_id = last_trace.previous_trace_ids && last_trace.previous_trace_ids[0];
+        pre_trace = (pre_trace_id && _.find(ins.traces, function (t) { return t._id === pre_trace_id; })) || ins.traces[ins.traces.length - 2];
+        while (pre_trace && pre_trace.judge === 'skipped' && pre_trace.previous_trace_ids && pre_trace.previous_trace_ids.length > 0) {
+            const skipped_prev_id = pre_trace.previous_trace_ids[0];
+            pre_trace = _.find(ins.traces, function (t) { return t._id === skipped_prev_id; });
+        }
+        if (!pre_trace) {
+            throw new Error("不符合退回条件：未找到可退回的上一步骤");
+        }
         pre_step = await UUFlowManager.getStep(ins, flow, pre_trace.step);
         if (pre_step.step_type === "counterSign") {
             throw new Error("不符合退回条件：上一步为会签步骤，不允许退回");
         }
-        last_trace = _.last(ins.traces);
         current_step = await UUFlowManager.getStep(ins, flow, last_trace.step);
         if (current_step.step_type !== "submit" && current_step.step_type !== "sign" && current_step.step_type !== "counterSign") {
             throw new Error("不符合退回条件：当前步骤类型（" + current_step.step_type + "）不支持退回操作");

package/main/default/routes/api_workflow_next_step_users.router.js

@@ -291,10 +291,12 @@ router.post('/api/workflow/v2/nextStepUsersValue', requireAuthentication, async
             for (let i = traces.length - 1; i >= 0; i--) {
                 const trace = traces[i];
                 if (trace.step === nextStepId && trace.approves && trace.approves.length > 0) {
-                    // 排除非实际处理人的 approve
+                    // 排除非实际处理人的 approve；传阅/分发的 approve 不是本步骤处理人
                     const excludedApproveJudges = ['returned', 'relocated', 'terminated', 'retrieved'];
+                    const excludedApproveTypes = ['cc', 'distribute'];
                     newNextUsers = trace.approves
-                        .filter(approve => !excludedApproveJudges.includes(approve.judge))
+                        .filter(approve => !excludedApproveJudges.includes(approve.judge)
+                            && !excludedApproveTypes.includes(approve.type))
                         .map(approve => approve.handler);
                     break;
                 }

package/main/default/test/test_next_step_users_value_cc.js

@@ -0,0 +1,212 @@
+/**
+ * 回归测试：/api/workflow/v2/nextStepUsersValue 的 traces 回退逻辑
+ * 不能把传阅（type='cc'）/分发（type='distribute'）的 approve 算作下一步处理人。
+ *
+ * 背景（线上现象）：
+ *  - 步骤A的审批人传阅给用户X → 步骤A当前 trace 里 push 一条
+ *    {type:'cc', handler:X} 的 approve（未读时无 judge，提交意见后 judge='submitted'）。
+ *  - 审批人驳回到上一步 → 上一步待办点提交时，提交对话框通过本接口预填
+ *    下一步（=步骤A）处理人。
+ *  - 回退逻辑只按 judge 排除（returned/relocated/terminated/retrieved），
+ *    cc approve 的 judge 不在排除表 → 被传阅用户X被预填为步骤A处理人。
+ *
+ * 期望（修复后）：
+ *  - traces 回退取处理人时排除 type='cc' 与 type='distribute' 的 approve，
+ *    与引擎其他取实际处理人处（uuflow_manager L1139/L3086/L4862）口径一致。
+ *  - 正常（无传阅）驳回场景行为不变。
+ *
+ * 用法：
+ *   node main/default/test/test_next_step_users_value_cc.js
+ *   或 npm run test:next-step-users-cc
+ */
+
+const assert = require('assert');
+const Module = require('module');
+
+// ---- 伪造无法在独立环境 resolve 的外部依赖（express / @steedos/*） ----
+const capturedRoutes = {};
+const fakeModules = {
+    'express': {
+        Router: function () {
+            return {
+                post: function (path) {
+                    capturedRoutes[path] = arguments[arguments.length - 1];
+                },
+            };
+        },
+    },
+    '@steedos/auth': {
+        requireAuthentication: function (req, res, next) { next(); },
+    },
+    '@steedos/objectql': {
+        getObject: function (name) {
+            return {
+                // space_users 校验：认为查询到的用户都在职，原样回显
+                find: async function (query) {
+                    const inFilter = (query.filters || []).find(f => f[1] === 'in');
+                    const userIds = inFilter ? inFilter[2] : [];
+                    return userIds.map(u => ({ user: u, name: 'name_of_' + u }));
+                },
+            };
+        },
+    },
+    '@steedos/i18n': {
+        t: function (key) { return key; },
+    },
+};
+const origResolve = Module._resolveFilename;
+Module._resolveFilename = function (request) {
+    if (fakeModules[request]) return 'fake:' + request;
+    return origResolve.apply(this, arguments);
+};
+Object.keys(fakeModules).forEach(function (name) {
+    require.cache['fake:' + name] = {
+        id: 'fake:' + name,
+        filename: 'fake:' + name,
+        loaded: true,
+        exports: fakeModules[name],
+    };
+});
+
+// ---- 伪造插件内部依赖 ----
+function seedCache(relPath, exportsObj) {
+    const p = require.resolve(relPath);
+    require.cache[p] = { id: p, filename: p, loaded: true, exports: exportsObj };
+}
+seedCache('../utils/trigger.js', {
+    excuteTriggers: async function () { },
+});
+seedCache('../manager/workflow_manager.js', {});
+let fakeInstance = null;
+seedCache('../manager/uuflow_manager.js', {
+    getInstance: async function () { return fakeInstance; },
+});
+
+require('../routes/api_workflow_next_step_users.router.js');
+const handler = capturedRoutes['/api/workflow/v2/nextStepUsersValue'];
+assert.ok(handler, '未捕获到 nextStepUsersValue 路由 handler');
+
+// ---- 构造实例：submit → 步骤P(已审) → 步骤A(传阅X后驳回) → 步骤P(当前待办) ----
+function buildInstance(opts) {
+    opts = opts || {};
+    const stepATrace = {
+        _id: 't3', step: 'step_A', name: '步骤A', is_finished: true, judge: 'rejected',
+        approves: [
+            { _id: 'a3', user: 'user_a', handler: 'user_a', judge: 'rejected', is_finished: true },
+        ],
+    };
+    if (opts.ccUnread) {
+        stepATrace.approves.push({
+            _id: 'cc1', user: 'user_x', handler: 'user_x', type: 'cc', is_finished: false, is_read: false,
+        });
+    }
+    if (opts.ccSubmitted) {
+        stepATrace.approves.push({
+            _id: 'cc2', user: 'user_y', handler: 'user_y', type: 'cc', is_finished: true, judge: 'submitted',
+        });
+    }
+    if (opts.distribute) {
+        stepATrace.approves.push({
+            _id: 'd1', user: 'user_d', handler: 'user_d', type: 'distribute', is_finished: false,
+        });
+    }
+    if (opts.returnedApprove) {
+        stepATrace.approves.push({
+            _id: 'r1', user: 'user_r', handler: 'user_r', judge: 'returned', is_finished: true,
+        });
+    }
+    return {
+        _id: 'ins1', space: 'space1', state: 'pending', applicant: 'user_p', submitter: 'user_p',
+        flow: 'flow1', form: 'form1', form_version: 'fv1',
+        step_approve: {},
+        traces: [
+            {
+                _id: 't1', step: 'step_start', name: '填写申请单', is_finished: true, judge: 'submitted',
+                approves: [{ _id: 'a1', user: 'user_p', handler: 'user_p', type: 'draft', judge: 'submitted' }],
+            },
+            {
+                _id: 't2', step: 'step_P', name: '步骤P', is_finished: true, judge: 'approved',
+                approves: [{ _id: 'a2', user: 'user_p', handler: 'user_p', judge: 'approved' }],
+            },
+            stepATrace,
+            {
+                _id: 't4', step: 'step_P', name: '步骤P', is_finished: false,
+                approves: [{ _id: 'a4', user: 'user_p', handler: 'user_p', is_finished: false }],
+            },
+        ],
+    };
+}
+
+async function callValue(nextStepId) {
+    const req = {
+        user: { userId: 'user_p', spaceId: 'space1' },
+        body: { instanceId: 'ins1', nextStepId: nextStepId },
+    };
+    const res = {
+        statusCode: null, body: null,
+        status: function (c) { this.statusCode = c; return this; },
+        send: function (b) { this.body = b; return this; },
+    };
+    await handler(req, res);
+    return res;
+}
+
+let passed = 0;
+let failed = 0;
+async function run(name, fn) {
+    try {
+        await fn();
+        console.log(`  ✓ ${name}`);
+        passed++;
+    } catch (e) {
+        console.log(`  ✗ ${name}`);
+        console.log(`    ${e.message}`);
+        failed++;
+    }
+}
+
+(async () => {
+    console.log('nextStepUsersValue 回退取人排除传阅/分发 approve');
+
+    await run('传阅（未读，无 judge）后驳回 → 预填处理人不含被传阅用户', async () => {
+        fakeInstance = buildInstance({ ccUnread: true });
+        const res = await callValue('step_A');
+        assert.strictEqual(res.statusCode, 200);
+        assert.deepStrictEqual(res.body.value, ['user_a'],
+            '应只含原审批人，实际：' + JSON.stringify(res.body.value));
+    });
+
+    await run('传阅（已提交意见，judge=submitted）后驳回 → 预填处理人不含被传阅用户', async () => {
+        fakeInstance = buildInstance({ ccSubmitted: true });
+        const res = await callValue('step_A');
+        assert.strictEqual(res.statusCode, 200);
+        assert.deepStrictEqual(res.body.value, ['user_a'],
+            '应只含原审批人，实际：' + JSON.stringify(res.body.value));
+    });
+
+    await run('分发（type=distribute）approve 同样被排除', async () => {
+        fakeInstance = buildInstance({ distribute: true });
+        const res = await callValue('step_A');
+        assert.strictEqual(res.statusCode, 200);
+        assert.deepStrictEqual(res.body.value, ['user_a'],
+            '应只含原审批人，实际：' + JSON.stringify(res.body.value));
+    });
+
+    await run('judge 排除表行为不变（returned 仍被排除）', async () => {
+        fakeInstance = buildInstance({ returnedApprove: true });
+        const res = await callValue('step_A');
+        assert.strictEqual(res.statusCode, 200);
+        assert.deepStrictEqual(res.body.value, ['user_a'],
+            '应只含原审批人，实际：' + JSON.stringify(res.body.value));
+    });
+
+    await run('正常（无传阅）驳回场景行为不变', async () => {
+        fakeInstance = buildInstance();
+        const res = await callValue('step_A');
+        assert.strictEqual(res.statusCode, 200);
+        assert.deepStrictEqual(res.body.value, ['user_a']);
+    });
+
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();

package/main/default/test/test_return_after_skip.js

@@ -0,0 +1,226 @@
+/**
+ * 回归测试：滑步（skip processed）之后点退回，不能再报
+ * 500「未找到下一步处理人，退回失败」。
+ *
+ * 背景（线上现象）：
+ *  - 滑步把被跳过 trace 及其所有 approves 的 judge 写成 'skipped'
+ *    （uuflow_manager.handleSkipProcessed）。
+ *  - 退回路由取上一条 trace 的 approves 筛选退回对象，过滤条件只认
+ *    judge ∈ (空/submitted/approved/rejected)，'skipped' 被排除 →
+ *    候选人为空 → throw「未找到下一步处理人，退回失败」→ 500。
+ *
+ * 期望（修复后）：
+ *  - 与取回（api_workflow_retrieve.router.js）一致：沿 previous_trace_ids
+ *    回溯跳过所有 judge='skipped' 的 trace，退回到用户实际处理过的步骤。
+ *  - 会签拦截检查作用于回溯后的真实目标步骤。
+ *  - 正常（无滑步）退回行为不变。
+ *
+ * 用法：
+ *   node main/default/test/test_return_after_skip.js
+ *   或 npm run test:return-after-skip
+ */
+
+const assert = require('assert');
+const Module = require('module');
+
+// ---- 伪造无法在独立环境 resolve 的外部依赖（express / @steedos/*） ----
+// 路由文件加载时即 require 这些包；用 _resolveFilename 钩子把它们指到
+// 预先塞进 require.cache 的假模块上。
+const capturedRoutes = {};
+const objectqlUpdates = [];
+const fakeModules = {
+    'express': {
+        Router: function () {
+            return {
+                post: function (path) {
+                    // (path, requireAuthentication, handler) → 取最后一个参数为业务 handler
+                    capturedRoutes[path] = arguments[arguments.length - 1];
+                },
+            };
+        },
+    },
+    '@steedos/auth': {
+        requireAuthentication: function (req, res, next) { next(); },
+    },
+    '@steedos/objectql': {
+        getObject: function (name) {
+            return {
+                update: async function (id, doc) { objectqlUpdates.push({ name, id, doc }); return doc; },
+            };
+        },
+    },
+};
+const origResolve = Module._resolveFilename;
+Module._resolveFilename = function (request) {
+    if (fakeModules[request]) return 'fake:' + request;
+    return origResolve.apply(this, arguments);
+};
+Object.keys(fakeModules).forEach(function (name) {
+    require.cache['fake:' + name] = {
+        id: 'fake:' + name,
+        filename: 'fake:' + name,
+        loaded: true,
+        exports: fakeModules[name],
+    };
+});
+
+// ---- 伪造插件内部依赖 ----
+let instanceUpdateCalls = [];
+const dummyInstancesCollection = {
+    updateOne: async function (selector, modifier) {
+        instanceUpdateCalls.push({ selector: selector, modifier: modifier });
+        return { modifiedCount: 1 };
+    },
+};
+const dummyUsersCollection = {
+    findOne: async function (selector) { return { _id: selector._id, name: 'name_of_' + selector._id }; },
+};
+function seedCache(relPath, exportsObj) {
+    const p = require.resolve(relPath);
+    require.cache[p] = { id: p, filename: p, loaded: true, exports: exportsObj };
+}
+seedCache('../utils/collection.js', {
+    getCollection: async function (name) {
+        return name === 'instances' ? dummyInstancesCollection : dummyUsersCollection;
+    },
+    _makeNewID: (function () { let n = 0; return function () { return 'new_id_' + (++n); }; })(),
+});
+seedCache('../manager/push_manager.js', {
+    send_message_to_specifyUser: async function () { },
+    send_instance_notification: async function () { },
+    triggerWebhook: async function () { },
+});
+seedCache('../manager/instance_tasks_manager.js', {
+    update_instance_tasks: async function () { },
+    insert_instance_tasks: async function () { },
+});
+
+let fakeInstance = null;
+let stepTypes = {};
+seedCache('../manager/uuflow_manager.js', {
+    getInstance: async function () { return fakeInstance; },
+    getFlow: async function () { return { _id: 'flow1' }; },
+    getStep: function (ins, flow, stepId) {
+        return { _id: stepId, name: 'name_' + stepId, step_type: stepTypes[stepId] || 'sign' };
+    },
+    getApproveValues: async function (values) { return values || {}; },
+    getDueDate: async function () { return null; },
+    getAgent: async function () { return null; },
+    getSpaceUser: async function () { return {}; },
+    getSpaceUserOrgInfo: async function () {
+        return { organization: 'org1', organization_name: 'org', organization_fullname: 'org' };
+    },
+    setRemindInfo: async function () { },
+});
+
+require('../routes/api_workflow_instance_return.router.js');
+const handler = capturedRoutes['/api/workflow/v2/instance/return'];
+assert.ok(handler, '未捕获到退回路由 handler');
+
+// ---- 构造实例：submit → sign(已审批) → sign(被滑步跳过) → sign(当前待审) ----
+function buildInstance(opts) {
+    opts = opts || {};
+    const traces = [
+        {
+            _id: 't1', step: 'step_start', name: '填写申请单', is_finished: true, judge: 'submitted',
+            approves: [{ _id: 'a1', user: 'user_a', handler: 'user_a', type: 'draft', judge: 'submitted' }],
+        },
+        {
+            _id: 't2', step: 'step_real', name: '实际审批步骤', is_finished: true, judge: 'approved',
+            previous_trace_ids: ['t1'],
+            approves: [{ _id: 'a2', user: 'user_a', handler: 'user_a', judge: 'approved' }],
+        },
+        {
+            _id: 't3', step: 'step_skipped', name: '被滑步跳过的步骤', is_finished: true, judge: 'skipped',
+            previous_trace_ids: ['t2'],
+            approves: [{ _id: 'a3', user: 'user_a', handler: 'user_a', judge: 'skipped' }],
+        },
+        {
+            _id: 't4', step: 'step_current', name: '当前步骤', is_finished: false,
+            previous_trace_ids: ['t3'],
+            approves: [{ _id: 'a4', user: 'user_c', handler: 'user_c', is_finished: false, start_date: new Date() }],
+        },
+    ];
+    if (opts.noSkip) {
+        traces.splice(2, 1); // 去掉滑步 trace，t4 直接跟在 t2 后
+        traces[2].previous_trace_ids = ['t2'];
+    }
+    return {
+        _id: 'ins1', space: 'space1', state: 'pending', applicant: 'user_a', submitter: 'user_a',
+        flow: 'flow1', form: 'form1', form_version: 'fv1',
+        inbox_users: ['user_c'], outbox_users: ['user_a'], cc_users: [],
+        values: {}, current_step_name: '当前步骤',
+        traces: traces,
+    };
+}
+
+async function callReturn() {
+    instanceUpdateCalls = [];
+    objectqlUpdates.length = 0;
+    const req = {
+        user: { userId: 'user_c' },
+        body: { approve: { _id: 'a4', instance: 'ins1', trace: 't4', values: {} }, reason: '退回测试' },
+    };
+    const res = {
+        statusCode: null, body: null,
+        status: function (c) { this.statusCode = c; return this; },
+        send: function (b) { this.body = b; return this; },
+    };
+    await handler(req, res);
+    return res;
+}
+
+let passed = 0;
+let failed = 0;
+async function run(name, fn) {
+    try {
+        await fn();
+        console.log(`  ✓ ${name}`);
+        passed++;
+    } catch (e) {
+        console.log(`  ✗ ${name}`);
+        console.log(`    ${e.message}`);
+        failed++;
+    }
+}
+
+(async () => {
+    console.log('退回接口滑步回溯（return after skip）');
+
+    await run('上一步被滑步跳过 → 回溯退回到实际处理过的步骤，不报 500', async () => {
+        stepTypes = {};
+        fakeInstance = buildInstance();
+        const res = await callReturn();
+        assert.strictEqual(res.statusCode, 200, '应返回 200，实际 ' + res.statusCode + '：' + (res.body && res.body.msg));
+        assert.strictEqual(res.body.status, 0);
+        // 新 trace 落在实际处理过的 step_real，而不是被跳过的 step_skipped
+        const pushCall = instanceUpdateCalls.find(c => c.modifier.$push && c.modifier.$push.traces);
+        assert.ok(pushCall, '未创建退回目标新 trace');
+        const newTrace = pushCall.modifier.$push.traces;
+        assert.strictEqual(newTrace.step, 'step_real');
+        assert.strictEqual(newTrace.approves[0].user, 'user_a');
+        // 退回后的待办人是实际处理人
+        const setCall = instanceUpdateCalls.find(c => c.modifier.$set && c.modifier.$set.inbox_users);
+        assert.deepStrictEqual(setCall.modifier.$set.inbox_users, ['user_a']);
+    });
+
+    await run('会签拦截作用于回溯后的真实目标步骤', async () => {
+        stepTypes = { step_real: 'counterSign' };
+        fakeInstance = buildInstance();
+        const res = await callReturn();
+        assert.strictEqual(res.statusCode, 500);
+        assert.ok(/会签/.test(res.body.msg), '应报会签不允许退回，实际：' + res.body.msg);
+    });
+
+    await run('正常（无滑步）退回行为不变', async () => {
+        stepTypes = {};
+        fakeInstance = buildInstance({ noSkip: true });
+        const res = await callReturn();
+        assert.strictEqual(res.statusCode, 200, '应返回 200，实际 ' + res.statusCode + '：' + (res.body && res.body.msg));
+        const pushCall = instanceUpdateCalls.find(c => c.modifier.$push && c.modifier.$push.traces);
+        assert.strictEqual(pushCall.modifier.$push.traces.step, 'step_real');
+    });
+
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.101",
+  "version": "3.0.103",
   "main": "package.service.js",
   "license": "MIT",
   "files": [
@@ -26,6 +26,8 @@
     "test:formula-compat": "node main/default/test/test_formula_compat.js",
     "test:approve-values": "node main/default/test/test_getApproveValues.js",
     "test:skip-handler-error": "node main/default/test/test_handleSkipProcessed_handlerError.js",
+    "test:return-after-skip": "node main/default/test/test_return_after_skip.js",
+    "test:next-step-users-cc": "node main/default/test/test_next_step_users_value_cc.js",
     "test:flow-validator": "node main/default/test/test_flow_validator.js",
     "test:ajax-error-message": "node main/default/test/test_ajax_error_message.js",
     "test:webhook-error-message": "node main/default/test/test_webhook_error_message.js"