@steedos-labs/plugin-workflow 3.0.106 → 3.0.107

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

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

package/main/default/manager/uuflow_manager.js

@@ -2044,6 +2044,28 @@ UUFlowManager.handleSkipProcessed = async function (instance_id, flow, maxDepth
                 return;
             }
 
+            // 滑步派发由服务端直接解析处理人，绕过了 nextStepUsers router 的
+            // user_accepted 过滤；此处补齐同口径过滤，已停用账号不派发待办。
+            // 若过滤后无人，走下方既有的「无处理人 → 中止滑步」兜底。
+            const spaceUsersCollection = await getCollection('space_users');
+            if (next_step_users && next_step_users.length > 0) {
+                const nextStepSpaceUsers = await spaceUsersCollection.find(
+                    { space: space_id, user: { $in: next_step_users } },
+                    { projection: { user: 1, user_accepted: 1 } }
+                ).toArray();
+                const acceptedUserIds = [];
+                for (const su of nextStepSpaceUsers) {
+                    if (su.user_accepted) {
+                        acceptedUserIds.push(su.user);
+                    }
+                }
+                const deactivatedUserIds = next_step_users.filter(u => !acceptedUserIds.includes(u));
+                if (deactivatedUserIds.length > 0) {
+                    console.log(`[workflow/engine] [handleSkipProcessed] Filtered ${deactivatedUserIds.length} handler(s) without accepted space_users record (user_accepted=false or missing) for next step "${next_step.name}": ${deactivatedUserIds.join(', ')}`);
+                    next_step_users = next_step_users.filter(u => acceptedUserIds.includes(u));
+                }
+            }
+
             if (!next_step_users || next_step_users.length === 0) {
                 console.warn('[workflow/engine] [handleSkipProcessed] No handlers found for next step after skip');
                 return;
@@ -2068,7 +2090,6 @@ UUFlowManager.handleSkipProcessed = async function (instance_id, flow, maxDepth
             };
 
             const usersCollection = await getCollection('users');
-            const spaceUsersCollection = await getCollection('space_users');
             const updatedValues = await UUFlowManager.getUpdatedValues(instance);
 
             const traceUserIds = [];

package/main/default/test/test_handleSkipProcessed_userAccepted.js

@@ -0,0 +1,243 @@
+/**
+ * 回归测试：滑步（handleSkipProcessed）派发下一步处理人时，
+ * 必须过滤 user_accepted=false 的已停用账号。
+ *
+ * 背景（DEFECT D-1(d)，集团IT需求及立项审批申请 9d861de0f5a17e422b03bb0e）：
+ *  - 正常派发走 nextStepUsers router，router 里有 `if (su.user_accepted)` 过滤；
+ *  - 滑步派发由服务端自行调用 HandlersManager.getHandlers 解析处理人，
+ *    完全绕开 router 过滤 → 已停用账号（user_accepted=false）被派成真实待办。
+ *    实测：specifyOrg 8 人部门中 3 个停用账号被派发（正常路径 5 人 / 滑步 8 人）。
+ *
+ * 期望（修复后）：
+ *  - 滑步派发前按 space + user 查 space_users，只保留 user_accepted 为真的处理人；
+ *  - 过滤后无人 → 复用既有「无处理人 → 中止滑步」兜底，实例停留在当前步骤；
+ *  - 非 counterSign 步骤取"过滤后"的第一个处理人（停用账号不能占首位）。
+ *
+ * 用法：
+ *   node main/default/test/test_handleSkipProcessed_userAccepted.js
+ *   或 npm run test:skip-user-accepted
+ */
+
+const assert = require('assert');
+
+// uuflow_manager 依赖运行时全局 `_`（lodash，由 Steedos server 注入），
+// 独立跑测试时手动补上。
+global._ = global._ || require('lodash');
+
+// 滑步开关不受本机 shell 环境影响
+delete process.env.WORKFLOW_SKIP_PROCESSED_ENABLED;
+delete process.env.STEEDOS_WORKFLOW_SKIP_CONSECUTIVE_ONLY;
+
+// ---- 注入假 getCollection（姿势同 test_handleSkipProcessed_handlerError.js）----
+const state = {
+    updateCalls: [],
+    pushedTraces: [],
+    spaceUsersDocs: [], // 每个用例自行设置
+};
+
+function resetState() {
+    state.updateCalls = [];
+    state.pushedTraces = [];
+    state.spaceUsersDocs = [];
+}
+
+let idSeq = 0;
+const fakeCollections = {
+    instances: {
+        updateOne: async function (query, update) {
+            state.updateCalls.push(update);
+            if (update.$push && update.$push.traces) {
+                state.pushedTraces.push(update.$push.traces);
+            }
+            return { modifiedCount: 1 };
+        },
+        findOne: async function () { return null; },
+        find: function () { return { toArray: async () => [] }; },
+    },
+    space_users: {
+        find: function (query) {
+            // 红线：查 space_users 必须带 space 过滤
+            assert.strictEqual(query.space, 'space1', 'space_users 查询必须带 space 过滤');
+            const ids = (query.user && query.user.$in) || [];
+            return { toArray: async () => state.spaceUsersDocs.filter(d => ids.includes(d.user)) };
+        },
+        findOne: async function () { return null; },
+    },
+    users: {
+        findOne: async function (query) { return { _id: query._id, name: 'name_' + query._id }; },
+    },
+    __default: {
+        updateOne: async function () { return { modifiedCount: 1 }; },
+        findOne: async function () { return null; },
+        find: function () { return { toArray: async () => [] }; },
+    },
+};
+
+const collectionPath = require.resolve('../utils/collection.js');
+require.cache[collectionPath] = {
+    id: collectionPath,
+    filename: collectionPath,
+    loaded: true,
+    exports: {
+        getCollection: async (name) => fakeCollections[name] || fakeCollections.__default,
+        _makeNewID: () => 'fake_id_' + (++idSeq),
+    },
+};
+
+// instance_tasks 写库与本测试无关，桩成 noop
+const tasksPath = require.resolve('../manager/instance_tasks_manager.js');
+require.cache[tasksPath] = {
+    id: tasksPath,
+    filename: tasksPath,
+    loaded: true,
+    exports: {
+        insert_instance_tasks: async () => {},
+        insert_many_instance_tasks: async () => {},
+        update_instance_tasks: async () => {},
+        update_many_instance_tasks: async () => {},
+        remove_many_instance_tasks: async () => {},
+    },
+};
+
+const UUFlowManager = require('../manager/uuflow_manager.js');
+const HandlersManager = require('../manager/handlers_manager.js');
+
+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++;
+    }
+}
+
+const APPLICANT = 'user_applicant';
+
+function buildFakeInstance() {
+    return {
+        _id: 'ins1',
+        state: 'pending',
+        space: 'space1',
+        applicant: APPLICANT,
+        // 与 next_step.name 相同 → 绕开 getObject('instances') 的台账同步写入
+        current_step_name: 'Step2',
+        processed_user_ids: [APPLICANT],
+        traces: [
+            {
+                _id: 'trace1',
+                step: 'step1',
+                is_finished: false,
+                previous_trace_ids: [],
+                approves: [
+                    { _id: 'app1', user: APPLICANT, handler: APPLICANT },
+                ],
+            },
+        ],
+    };
+}
+
+// 每个用例：step1（处理人=申请人，触发整步滑步）→ step2（滑步派发目标）
+function setupCase(nextStepType, handlers, spaceUsersDocs) {
+    resetState();
+    state.spaceUsersDocs = spaceUsersDocs;
+
+    const fakeInstance = buildFakeInstance();
+    let getInstanceCalls = 0;
+    UUFlowManager.getInstance = async function () {
+        getInstanceCalls++;
+        if (getInstanceCalls === 1) return fakeInstance;
+        // 递归第二次进入时返回"已结束"的 trace，终止递归
+        return Object.assign({}, fakeInstance, { traces: [{ _id: 'trace2', is_finished: true }] });
+    };
+    UUFlowManager.getStep = function (instance, flow, stepId) {
+        if (stepId === 'step1') {
+            return {
+                _id: 'step1', name: 'Step1', step_type: 'sign',
+                skip_enabled: true,
+                lines: [{ state: 'approved', to_step: 'step2' }],
+            };
+        }
+        if (stepId === 'step2') {
+            return { _id: 'step2', name: 'Step2', step_type: nextStepType };
+        }
+        throw new Error('unexpected step ' + stepId);
+    };
+    UUFlowManager.getAgent = async function () { return null; };
+    UUFlowManager.getDueDate = async function () { return null; };
+    UUFlowManager.getUpdatedValues = async function () { return {}; };
+    UUFlowManager.setRemindInfo = function () {};
+    HandlersManager.getHandlers = async function () { return handlers.slice(); };
+}
+
+(async () => {
+    console.log('UUFlowManager.handleSkipProcessed 滑步派发过滤 user_accepted=false');
+
+    await run('counterSign：8 人含停用 → 只给在职账号建 approve，停用账号不进 inbox', async () => {
+        setupCase('counterSign', ['uA', 'uB', 'uC'], [
+            { user: 'uA', user_accepted: true },
+            { user: 'uB', user_accepted: false }, // 已停用
+            { user: 'uC', user_accepted: true },
+        ]);
+
+        await UUFlowManager.handleSkipProcessed('ins1', { _id: 'flow1' });
+
+        assert.strictEqual(state.pushedTraces.length, 1, '应派发出一条新 trace');
+        const approveUsers = state.pushedTraces[0].approves.map(a => a.user);
+        assert.deepStrictEqual(approveUsers, ['uA', 'uC'],
+            '停用账号 uB 不应获得 approve');
+        const inboxSet = state.updateCalls
+            .map(u => u.$set && u.$set.inbox_users)
+            .filter(Boolean)[0];
+        assert.deepStrictEqual(inboxSet, ['uA', 'uC'],
+            '停用账号 uB 不应进入 inbox_users');
+    });
+
+    await run('全员停用 → 中止滑步，实例停留在当前步骤（零写库）', async () => {
+        setupCase('counterSign', ['uB'], [
+            { user: 'uB', user_accepted: false },
+        ]);
+
+        await UUFlowManager.handleSkipProcessed('ins1', { _id: 'flow1' });
+
+        assert.strictEqual(state.updateCalls.length, 0,
+            '过滤后无人应中止滑步，不得改动实例');
+        assert.strictEqual(state.pushedTraces.length, 0, '不应派发新 trace');
+    });
+
+    await run('sign：首位处理人已停用 → 取过滤后的第一个在职账号', async () => {
+        setupCase('sign', ['uB', 'uA'], [
+            { user: 'uB', user_accepted: false }, // 停用账号占首位
+            { user: 'uA', user_accepted: true },
+        ]);
+
+        await UUFlowManager.handleSkipProcessed('ins1', { _id: 'flow1' });
+
+        assert.strictEqual(state.pushedTraces.length, 1, '应派发出一条新 trace');
+        const approveUsers = state.pushedTraces[0].approves.map(a => a.user);
+        assert.deepStrictEqual(approveUsers, ['uA'],
+            'sign 步应取过滤后的第一个在职处理人，而不是停用的 uB');
+    });
+
+    await run('无 space_users 记录的处理人视同停用（与 router 口径一致）', async () => {
+        setupCase('counterSign', ['uA', 'uX'], [
+            { user: 'uA', user_accepted: true },
+            // uX 在本 space 无 space_users 记录
+        ]);
+
+        await UUFlowManager.handleSkipProcessed('ins1', { _id: 'flow1' });
+
+        assert.strictEqual(state.pushedTraces.length, 1);
+        const approveUsers = state.pushedTraces[0].approves.map(a => a.user);
+        assert.deepStrictEqual(approveUsers, ['uA'],
+            '本 space 无 space_users 记录的 uX 不应获得 approve');
+    });
+
+    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.106",
+  "version": "3.0.107",
   "main": "package.service.js",
   "license": "MIT",
   "files": [
@@ -26,6 +26,7 @@
     "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:skip-user-accepted": "node main/default/test/test_handleSkipProcessed_userAccepted.js",
     "test:return-after-skip": "node main/default/test/test_return_after_skip.js",
     "test:retrieve-guards": "node main/default/test/test_retrieve_guards.js",
     "test:remove-guards": "node main/default/test/test_remove_guards.js",