@steedos-labs/plugin-workflow 3.0.95 → 3.0.97

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

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

package/main/default/manager/import.js

@@ -1,6 +1,7 @@
 const objectql = require("@steedos/objectql");
 const _ = require('underscore');
 const { _makeNewID, getCollection } = require('../utils/collection');
+const { validateFlowSteps } = require('../utils/flowValidator');
 
 const steedosImport = {};
 
@@ -244,11 +245,12 @@ async function upgradeFlow(flowCome, userId, flowId) {
     updateObj.$set.name = flowCome['name'];
     updateObj.$set.name_formula = '';
     updateObj.$set.code_formula = '';
-    updateObj.$set.is_valid = flowCome['is_valid'];
+    const flowValidation = validateFlowSteps(flowCome['current']['steps']);
+    updateObj.$set.is_valid = flowValidation.isValid;
     updateObj.$set.flowtype = flowCome['flowtype'];
     updateObj.$set.help_text = flowCome['help_text'];
     updateObj.$set.decription = flowCome['descriptions'];
-    updateObj.$set.error_message = flowCome['error_message'];
+    updateObj.$set.error_message = flowValidation.errorMessage;
     updateObj.$set.modified = now;
     updateObj.$set.modified_by = userId;
     updateObj.$set.events = flowCome['events'] || '';

package/main/default/manager/uuflow_manager.js

@@ -1676,8 +1676,23 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     const t8 = Date.now();
     // Update instance
     const t8_1 = Date.now();
+    // 当步骤发生流转时，current_step_name 的变更必须经由 objectql 写入，
+    // 以触发 instances 的 afterUpdate（uuflowManager.triggerRecordInstanceQueue），
+    // 否则 instance_record_queue 不会生成同步记录。
+    // 这里先把 current_step_name 从原子 raw 写入中剥离（保留 $push traces 等原子性），
+    // raw 写入后 DB 仍保留旧的 current_step_name，再由 objectql 单独应用新步骤名，
+    // 使 afterUpdate 检测到 current_step_name 变化并触发同步。
+    const nextStepNameForQueue = updateObj.$set ? updateObj.$set.current_step_name : undefined;
+    const prevStepNameForQueue = updatedInstance.current_step_name;
+    const stepNameChangedForQueue = nextStepNameForQueue !== undefined && nextStepNameForQueue !== prevStepNameForQueue;
+    if (stepNameChangedForQueue) {
+        delete updateObj.$set.current_step_name;
+    }
     const instancesCollection = await getCollection('instances');
     await instancesCollection.updateOne({ _id: instance_id }, updateObj);
+    if (stepNameChangedForQueue) {
+        await getObject('instances').update(instance_id, { current_step_name: nextStepNameForQueue });
+    }
     console.log(`[workflow/engine] [workflow_engine] second updateOne took ${Date.now() - t8_1}ms`);
 
     // Insert new instance tasks if needed

package/main/default/objects/flows/flows.object.yml

@@ -829,8 +829,32 @@ actions:
             navigate(0)
           },
           error: function (XMLHttpRequest, textStatus, errorThrown) {
+            var getAjaxErrorMessage = function (xhr, textStatus, errorThrown) {
+              var responseJSON = xhr && xhr.responseJSON;
+              if (typeof responseJSON === 'string' && responseJSON) {
+                return responseJSON;
+              }
+              if (responseJSON && typeof responseJSON === 'object') {
+                if (responseJSON.message) {
+                  return responseJSON.message;
+                }
+                if (responseJSON.error) {
+                  return responseJSON.error;
+                }
+              }
+              if (xhr && xhr.responseText) {
+                return xhr.responseText;
+              }
+              if (errorThrown) {
+                return errorThrown;
+              }
+              if (textStatus && textStatus !== 'error') {
+                return textStatus;
+              }
+              return '操作失败';
+            };
             SteedosUI.notification.error({
-                message: XMLHttpRequest.responseJSON
+                message: getAjaxErrorMessage(XMLHttpRequest, textStatus, errorThrown)
             });
           }
         });
@@ -869,8 +893,32 @@ actions:
             navigate(0)
           },
           error: function (XMLHttpRequest, textStatus, errorThrown) {
+            var getAjaxErrorMessage = function (xhr, textStatus, errorThrown) {
+              var responseJSON = xhr && xhr.responseJSON;
+              if (typeof responseJSON === 'string' && responseJSON) {
+                return responseJSON;
+              }
+              if (responseJSON && typeof responseJSON === 'object') {
+                if (responseJSON.message) {
+                  return responseJSON.message;
+                }
+                if (responseJSON.error) {
+                  return responseJSON.error;
+                }
+              }
+              if (xhr && xhr.responseText) {
+                return xhr.responseText;
+              }
+              if (errorThrown) {
+                return errorThrown;
+              }
+              if (textStatus && textStatus !== 'error') {
+                return textStatus;
+              }
+              return '操作失败';
+            };
             SteedosUI.notification.error({
-                message: XMLHttpRequest.responseJSON
+                message: getAjaxErrorMessage(XMLHttpRequest, textStatus, errorThrown)
             });
           }
         });

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

@@ -5,6 +5,7 @@ const bodyParser = require('body-parser');
 const steedosI18n = require("@steedos/i18n");
 const lodash = require('lodash');
 const { _makeNewID, getCollection } = require('../utils/collection');
+const { validateFlowSteps } = require('../utils/flowValidator');
 
 const designerManager = require('../utils/designerManager');
 
@@ -589,11 +590,12 @@ router.put('/am/flows', async function (req, res) {
             updateObj.$set.name = flowCome['name'];
             updateObj.$set.name_formula = '';
             updateObj.$set.code_formula = '';
-            updateObj.$set.is_valid = flowCome['is_valid'];
+            const flowValidation = validateFlowSteps(flowCome['current']['steps']);
+            updateObj.$set.is_valid = flowValidation.isValid;
             updateObj.$set.flowtype = flowCome['flowtype'];
             updateObj.$set.help_text = flowCome['help_text'];
             updateObj.$set.description = flowCome['descriptions'];
-            updateObj.$set.error_message = flowCome['error_message'];
+            updateObj.$set.error_message = flowValidation.errorMessage;
             updateObj.$set.modified = now;
             updateObj.$set.modified_by = userId;
 
@@ -695,11 +697,11 @@ router.put('/am/flows/state', async function (req, res) {
             if (state === 'enabled') {
                 // 流程启用前，校验其“指定历史步骤”属性中被引用的步骤是否存在且能被找到（仅限于流程的最新版）
                 let checkStepIds = [];
-                _.each(flow.current.steps, function (step) {
+                _.each(flow.current.steps || [], function (step) {
                     checkStepIds.push(step._id);
                 })
 
-                _.each(flow.current.steps, function (step) {
+                _.each(flow.current.steps || [], function (step) {
                     if (step.deal_type === 'specifyStepUser' || step.deal_type === 'specifyStepRole') {
                         if (!step.approver_step || !checkStepIds.includes(step.approver_step)) {
                             throw new Error('流程中的指定步骤不存在');
@@ -707,6 +709,19 @@ router.put('/am/flows/state', async function (req, res) {
                     }
                 })
 
+                const flowValidation = validateFlowSteps(flow.current.steps);
+                if (!flowValidation.isValid) {
+                    await flowCollection.updateOne({_id: flowId}, {
+                        $set: {
+                            is_valid: false,
+                            error_message: flowValidation.errorMessage,
+                            modified: now,
+                            modified_by: userId
+                        }
+                    });
+                    throw new Error(flowValidation.errorMessage || '流程不合法');
+                }
+
                 // 如果 流程对应表单 是停用的 则启用
                 if (form.state === 'disabled') {
                     let formUpdateObj = {
@@ -721,9 +736,6 @@ router.put('/am/flows/state', async function (req, res) {
                     updatedForms.push(await formCollection.findOne({_id: formId}));
                 }
 
-                if (!flow.is_valid) {
-                    throw new Error('流程不合法');
-                }
                 if (!['new', 'modify', 'delete'].includes(flow.flowtype)) {
                     throw new Error('FlowType值必须是new、modify、delete其中之一');
                 }
@@ -732,6 +744,8 @@ router.put('/am/flows/state', async function (req, res) {
                 }
 
                 flowUpdateObj.$set['state'] = 'enabled';
+                flowUpdateObj.$set['is_valid'] = true;
+                flowUpdateObj.$set['error_message'] = '';
                 flowUpdateObj.$set['current.modified'] = now;
                 flowUpdateObj.$set['current.start_date'] = now;
                 flowUpdateObj.$set['current.modified_by'] = userId;
@@ -1221,4 +1235,4 @@ router.post('/am/forms/addFieldsFromObject', async function (req, res) {
     }
 })
 
-exports.default = router;
+exports.default = router;

package/main/default/test/test_ajax_error_message.js

@@ -0,0 +1,36 @@
+const assert = require('assert');
+const { getAjaxErrorMessage } = require('../utils/ajaxErrorMessage');
+
+console.log('[ajax-error-message] running tests...');
+
+assert.strictEqual(
+    getAjaxErrorMessage({ responseText: '流程不合法' }, 'error', 'Internal Server Error'),
+    '流程不合法'
+);
+
+assert.strictEqual(
+    getAjaxErrorMessage({ responseJSON: { message: '具体错误' }, responseText: 'fallback' }, 'error', 'Internal Server Error'),
+    '具体错误'
+);
+
+assert.strictEqual(
+    getAjaxErrorMessage({ responseJSON: { error: '错误字段' } }, 'error', 'Internal Server Error'),
+    '错误字段'
+);
+
+assert.strictEqual(
+    getAjaxErrorMessage({ responseJSON: '字符串错误' }, 'error', 'Internal Server Error'),
+    '字符串错误'
+);
+
+assert.strictEqual(
+    getAjaxErrorMessage({}, 'error', 'Internal Server Error'),
+    'Internal Server Error'
+);
+
+assert.strictEqual(
+    getAjaxErrorMessage({}, 'error', ''),
+    '操作失败'
+);
+
+console.log('[ajax-error-message] all tests passed');

package/main/default/test/test_flow_validator.js

@@ -0,0 +1,73 @@
+const assert = require('assert');
+const { validateFlowSteps } = require('../utils/flowValidator');
+
+function validSteps() {
+    return [
+        {
+            _id: 'start',
+            name: '开始',
+            step_type: 'start',
+            lines: [{ _id: 'l1', state: 'submitted', to_step: 'approve' }]
+        },
+        {
+            _id: 'approve',
+            name: '审批',
+            step_type: 'sign',
+            deal_type: 'pickupAtRuntime',
+            lines: [{ _id: 'l2', state: 'approved', to_step: 'end' }]
+        },
+        {
+            _id: 'end',
+            name: '结束',
+            step_type: 'end',
+            lines: []
+        }
+    ];
+}
+
+function assertInvalid(steps, expectedText) {
+    const result = validateFlowSteps(steps);
+    assert.strictEqual(result.isValid, false);
+    assert.ok(result.errorMessage.includes(expectedText), result.errorMessage);
+}
+
+console.log('[flow-validator] running tests...');
+
+let result = validateFlowSteps(validSteps());
+assert.deepStrictEqual(result, {
+    isValid: true,
+    errorMessage: '',
+    errors: []
+});
+
+const noOutLine = validSteps();
+noOutLine[1].lines = [];
+assertInvalid(noOutLine, '审批：没有出线');
+
+const missingTarget = validSteps();
+missingTarget[1].lines[0].to_step = 'missing';
+assertInvalid(missingTarget, '审批：连线目标步骤不存在');
+
+const duplicateName = validSteps();
+duplicateName[2].name = '审批';
+assertInvalid(duplicateName, '步骤名称重复');
+
+const conditionMissingExpression = validSteps();
+conditionMissingExpression.splice(1, 0, {
+    _id: 'condition',
+    name: '条件',
+    step_type: 'condition',
+    lines: [
+        { _id: 'c1', state: 'approved', to_step: 'approve', condition: '' },
+        { _id: 'c2', state: 'approved', to_step: 'end', condition: 'true' }
+    ]
+});
+conditionMissingExpression[0].lines[0].to_step = 'condition';
+assertInvalid(conditionMissingExpression, '条件：到「审批」的出线未设置条件');
+
+const specifyStepMissing = validSteps();
+specifyStepMissing[1].deal_type = 'specifyStepUser';
+specifyStepMissing[1].approver_step = 'missing';
+assertInvalid(specifyStepMissing, '审批：指定历史步骤不存在');
+
+console.log('[flow-validator] all tests passed');

package/main/default/utils/ajaxErrorMessage.js

@@ -0,0 +1,28 @@
+function getAjaxErrorMessage(xhr, textStatus, errorThrown) {
+    const responseJSON = xhr && xhr.responseJSON;
+    if (typeof responseJSON === 'string' && responseJSON) {
+        return responseJSON;
+    }
+    if (responseJSON && typeof responseJSON === 'object') {
+        if (responseJSON.message) {
+            return responseJSON.message;
+        }
+        if (responseJSON.error) {
+            return responseJSON.error;
+        }
+    }
+    if (xhr && xhr.responseText) {
+        return xhr.responseText;
+    }
+    if (errorThrown) {
+        return errorThrown;
+    }
+    if (textStatus && textStatus !== 'error') {
+        return textStatus;
+    }
+    return '操作失败';
+}
+
+module.exports = {
+    getAjaxErrorMessage
+};

package/main/default/utils/flowValidator.js

@@ -0,0 +1,162 @@
+const _ = require('underscore');
+
+const STEP_TYPES_NEED_DEAL_TYPE = ['submit', 'sign', 'counterSign', 'notify'];
+
+function getStepId(step) {
+    return step && (step._id || step.id);
+}
+
+function getStepName(step) {
+    const name = step && step.name;
+    return typeof name === 'string' && name.trim() ? name.trim() : getStepId(step) || '未命名步骤';
+}
+
+function getLines(step) {
+    return Array.isArray(step && step.lines) ? step.lines : [];
+}
+
+function pushError(errors, step, field, message, extra) {
+    errors.push(Object.assign({
+        stepId: getStepId(step),
+        stepName: getStepName(step),
+        field,
+        message: `${getStepName(step)}：${message}`
+    }, extra || {}));
+}
+
+function validateDealType(errors, step, stepIds) {
+    const stepType = step.step_type || 'sign';
+    const dealType = step.deal_type || '';
+
+    if (STEP_TYPES_NEED_DEAL_TYPE.includes(stepType) && !dealType) {
+        pushError(errors, step, 'deal_type', '未选择处理人身份');
+        return;
+    }
+
+    if (dealType === 'specifyUser' && _.isEmpty(step.approver_users)) {
+        pushError(errors, step, 'approver_users', '指定人员不能为空');
+    }
+    if (dealType === 'specifyOrg' && _.isEmpty(step.approver_orgs)) {
+        pushError(errors, step, 'approver_orgs', '指定部门不能为空');
+    }
+    if ((dealType === 'applicantRole' || dealType === 'userFieldRole' || dealType === 'orgFieldRole' || dealType === 'specifyStepRole') && _.isEmpty(step.approver_roles)) {
+        pushError(errors, step, 'approver_roles', '指定审批岗位不能为空');
+    }
+    if (dealType === 'hrRole' && _.isEmpty(step.approver_hr_roles)) {
+        pushError(errors, step, 'approver_hr_roles', '指定角色不能为空');
+    }
+    if ((dealType === 'userField' || dealType === 'userFieldRole') && !step.approver_user_field) {
+        pushError(errors, step, 'approver_user_field', '指定人员字段不能为空');
+    }
+    if ((dealType === 'orgField' || dealType === 'orgFieldRole') && !step.approver_org_field) {
+        pushError(errors, step, 'approver_org_field', '指定部门字段不能为空');
+    }
+    if ((dealType === 'specifyStepUser' || dealType === 'specifyStepRole') && (!step.approver_step || !stepIds.has(step.approver_step))) {
+        pushError(errors, step, 'approver_step', '指定历史步骤不存在');
+    }
+}
+
+function validateFlowSteps(steps) {
+    const errors = [];
+
+    if (!Array.isArray(steps) || steps.length === 0) {
+        return {
+            isValid: false,
+            errorMessage: '流程的步骤不能为空',
+            errors: [{
+                field: 'steps',
+                message: '流程的步骤不能为空'
+            }]
+        };
+    }
+
+    const stepIds = new Set();
+    const nameMap = new Map();
+    const incomingMap = new Map();
+
+    steps.forEach(function (step) {
+        const stepId = getStepId(step);
+        const stepName = getStepName(step);
+        if (!stepId) {
+            pushError(errors, step, '_id', '步骤ID不能为空');
+        } else if (stepIds.has(stepId)) {
+            pushError(errors, step, '_id', '步骤ID重复');
+        } else {
+            stepIds.add(stepId);
+        }
+
+        if (!step.name || !String(step.name).trim()) {
+            pushError(errors, step, 'name', '步骤名称不能为空');
+        }
+        nameMap.set(stepName, (nameMap.get(stepName) || 0) + 1);
+    });
+
+    steps.forEach(function (step) {
+        const stepId = getStepId(step);
+        getLines(step).forEach(function (line) {
+            if (line && line.to_step) {
+                incomingMap.set(line.to_step, (incomingMap.get(line.to_step) || 0) + 1);
+            }
+            if (!line || !line.to_step || !stepIds.has(line.to_step)) {
+                pushError(errors, step, 'lines', '连线目标步骤不存在', { lineId: line && (line._id || line.id) });
+            }
+            if (line && line.to_step === stepId) {
+                pushError(errors, step, 'lines', '不能连接到自身', { lineId: line && (line._id || line.id) });
+            }
+            if (line && !line.state) {
+                pushError(errors, step, 'state', '连线类型不能为空', { lineId: line && (line._id || line.id) });
+            }
+        });
+    });
+
+    nameMap.forEach(function (count, name) {
+        if (count > 1) {
+            errors.push({
+                field: 'name',
+                stepName: name,
+                message: `步骤名称重复：${name}`
+            });
+        }
+    });
+
+    steps.forEach(function (step) {
+        const stepType = step.step_type || 'sign';
+        const lines = getLines(step);
+        const incomingCount = incomingMap.get(getStepId(step)) || 0;
+
+        if (stepType !== 'end' && lines.length === 0) {
+            pushError(errors, step, 'lines', '没有出线');
+        }
+        if (stepType === 'end' && lines.length > 0) {
+            pushError(errors, step, 'lines', '结束节点不能有出线');
+        }
+        if (stepType !== 'start' && incomingCount === 0) {
+            pushError(errors, step, 'lines', '没有入线');
+        }
+        if (stepType === 'condition') {
+            if (lines.length < 2) {
+                pushError(errors, step, 'condition_lines', '条件节点至少需要两条出线');
+            }
+            lines.forEach(function (line) {
+                if (!String((line && line.condition) || '').trim()) {
+                    const target = steps.find(function (item) {
+                        return getStepId(item) === line.to_step;
+                    });
+                    pushError(errors, step, 'condition_lines', `到「${target ? getStepName(target) : line.to_step || '未知节点'}」的出线未设置条件`, { lineId: line && (line._id || line.id) });
+                }
+            });
+        }
+
+        validateDealType(errors, step, stepIds);
+    });
+
+    return {
+        isValid: errors.length === 0,
+        errorMessage: errors.map(function (error) { return error.message; }).join('\n'),
+        errors
+    };
+}
+
+module.exports = {
+    validateFlowSteps
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.95",
+  "version": "3.0.97",
   "main": "package.service.js",
   "license": "MIT",
   "files": [
@@ -25,7 +25,9 @@
     "convert-templates": "node convert-templates.js",
     "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-handler-error": "node main/default/test/test_handleSkipProcessed_handlerError.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"
   },
   "dependencies": {
     "graphql-parse-resolve-info": "^4.12.3",