@steedos-labs/plugin-workflow 3.0.100 → 3.0.102

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

@@ -1,5 +1,5 @@
 waitForThing(window, 'antd').then(function(){
-    var v = '3.0.100';
+    var v = '3.0.102';
     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/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/main/default/test/test_webhook_error_message.js

@@ -0,0 +1,37 @@
+const assert = require('assert');
+const { getWebhookErrorMessage } = require('../../../src/webhook_error');
+
+console.log('[webhook-error-message] running tests...');
+
+assert.strictEqual(
+	getWebhookErrorMessage({
+		message: 'Request failed with status code 500',
+		response: { data: 'name is required' }
+	}),
+	'name is required'
+);
+
+assert.strictEqual(
+	getWebhookErrorMessage({ response: { data: { errcode: 400, message: '参数错误' } } }),
+	'{"errcode":400,"message":"参数错误"}'
+);
+
+assert.strictEqual(
+	getWebhookErrorMessage(new Error('connect ECONNREFUSED')),
+	'connect ECONNREFUSED'
+);
+
+const circularResponse = {};
+circularResponse.self = circularResponse;
+assert.strictEqual(
+	getWebhookErrorMessage({
+		message: 'Request failed with circular response data',
+		response: { data: circularResponse }
+	}),
+	'Request failed with circular response data'
+);
+
+assert.strictEqual(getWebhookErrorMessage('network error'), 'network error');
+assert.strictEqual(getWebhookErrorMessage(null), 'Unknown webhook error');
+
+console.log('[webhook-error-message] all tests passed');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.100",
+  "version": "3.0.102",
   "main": "package.service.js",
   "license": "MIT",
   "files": [
@@ -26,8 +26,10 @@
     "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:flow-validator": "node main/default/test/test_flow_validator.js",
-    "test:ajax-error-message": "node main/default/test/test_ajax_error_message.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"
   },
   "dependencies": {
     "graphql-parse-resolve-info": "^4.12.3",

package/src/webhook_error.js

@@ -0,0 +1,36 @@
+/*
+ * Convert Axios and generic errors to a MongoDB-safe string while preserving
+ * the downstream response body whenever one is available.
+ */
+const getWebhookErrorMessage = function (error) {
+	const responseData = error && error.response && error.response.data;
+
+	if (responseData !== undefined && responseData !== null && responseData !== '') {
+		if (typeof responseData === 'string') {
+			return responseData;
+		}
+
+		try {
+			const serializedResponse = JSON.stringify(responseData);
+			if (typeof serializedResponse === 'string') {
+				return serializedResponse;
+			}
+		} catch (stringifyError) {
+			// Fall through to the regular error message for circular response data.
+		}
+	}
+
+	if (error && error.message) {
+		return String(error.message);
+	}
+
+	if (responseData !== undefined && responseData !== null) {
+		return String(responseData);
+	}
+
+	return error ? String(error) : 'Unknown webhook error';
+};
+
+module.exports = {
+	getWebhookErrorMessage
+};

package/src/webhook_queue.js

@@ -10,6 +10,7 @@ const _ = require("lodash");
 const axios = require('axios');
 
 const { getCollection } = require("../main/default/utils/collection");
+const { getWebhookErrorMessage } = require('./webhook_error');
 
 const WebhookQueue = {};
 
@@ -123,13 +124,14 @@ WebhookQueue.Configure = async function (options) {
 
 			}
 		} catch (error) {
-			console.error(error);
+			const errMsg = getWebhookErrorMessage(error);
+			console.error('WebhookQueue: Error while sending:', errMsg);
 			await WebhookQueue.collection.updateOne({
 				_id: webhook._id
 			}, {
 				$set: {
 					// error message
-					errMsg: error
+					errMsg: errMsg
 				}
 			});
 		}
@@ -280,4 +282,4 @@ WebhookQueue.Configure = async function (options) {
 
 };
 
-module.exports = WebhookQueue;
+module.exports = WebhookQueue;