@steedos-labs/plugin-workflow 3.0.0-beta.5

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

@@ -0,0 +1,294 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-24 14:52:54
+ * @LastEditors: sunhaolin@hotoa.com
+ * @LastEditTime: 2022-12-31 11:19:56
+ * @Description: 
+ */
+'use strict';
+// @ts-check
+const express = require('express');
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require('underscore');
+const Fiber = function(fun){console.log('TODO Fiber...')}
+const {
+    insert_instance_tasks,
+    update_instance_tasks,
+    update_many_instance_tasks,
+} = require('../manager/instance_tasks_manager')
+const UUFlowManager = require('../manager/uuflow_manager');
+const pushManager = require('../manager/push_manager');
+/**
+@api {post} /api/workflow/retrieve 取回
+@apiVersion 0.0.0
+@apiName /api/workflow/retrieve
+@apiGroup service-workflow
+@apiBody {Object[]} Instances 申请单信息
+@apiSuccessExample {json} Success-Response:
+    HTTP/1.1 200 OK
+    {
+    }
+@apiErrorExample {json} Error-Response:
+    HTTP/1.1 200 OK
+    {
+      errors: [{ errorMessage: e.message }]
+    }
+ */
+router.post('/api/workflow/retrieve', requireAuthentication, async function (req, res) {
+    try {
+        let userSession = req.user;
+        const spaceId = userSession.spaceId;
+        const userId = userSession.userId;
+        const isSpaceAdmin = userSession.is_space_admin;
+        Fiber(async function () {
+            try {
+                var current_user, current_user_info, e, hashData;
+                current_user_info = Object.assign({}, userSession, { _id: userSession.userId })
+                current_user = current_user_info._id;
+                hashData = req.body;
+                _.each(hashData['Instances'], function (instance_from_client) {
+                    var cc_users, flow, handler_info, i, ins, instance, instance_id, last_trace, last_trace_id, newApprove, newTrace, now, old_inbox_users, org_info, previous_step, previous_trace, previous_trace_approves, previous_trace_id, previous_trace_name, previous_trace_step_id, r, retrieve_approve, retrieve_comment, retrieve_type, setObj, space_id, space_user, the_trace, traces;
+                    instance = UUFlowManager.getInstance(instance_from_client["_id"]);
+                    retrieve_comment = instance_from_client['retrieve_comment'];
+                    // 验证instance为审核中状态
+                    // UUFlowManager.isInstancePending(instance)
+                    // 校验申请单是当前用户已审核过的单子或者当前用户是提交人或申请人
+                    if ((!instance.outbox_users.includes(current_user)) && (instance.submitter !== current_user && instance.applicant !== current_user)) {
+                        throw new Error('当前用户不符合取回条件');
+                    }
+                    retrieve_type = "";
+                    traces = instance.traces;
+                    //获取最新的trace， 即取回步骤
+                    last_trace = _.last(traces);
+                    last_trace_id = last_trace._id;
+                    previous_trace_id = last_trace.previous_trace_ids[0];
+                    previous_trace = _.find(traces, function (t) {
+                        return t._id === previous_trace_id;
+                    });
+                    previous_trace_step_id = previous_trace.step;
+                    previous_trace_name = previous_trace.name;
+                    flow = UUFlowManager.getFlow(instance.flow);
+                    previous_step = UUFlowManager.getStep(instance, flow, previous_trace_step_id);
+                    if (previous_step.step_type === "counterSign") {
+                        throw new Error('会签不能取回');
+                    }
+                    // 取回步骤的前一个步骤处理人唯一（即排除掉传阅和转发的approve后，剩余的approve只有一个）并且是当前用户
+                    previous_trace_approves = _.filter(previous_trace.approves, function (a) {
+                        return a.type !== 'cc' && a.type !== 'distribute' && a.type !== 'forward' && ['approved', 'submitted', 'rejected'].includes(a.judge);
+                    });
+                    if (previous_trace_approves.length === 1 && (previous_trace_approves[0].user === current_user || previous_trace_approves[0].handler === current_user)) {
+                        retrieve_type = 'normal'; // 申请单正常流转的取回，即非传阅取回
+                    }
+                    i = traces.length;
+                    retrieve_approve = {};
+                    while (i > 0) {
+                        _.each(traces[i - 1].approves, function (a) {
+                            if (a.type === 'cc' && a.is_finished === true && a.user === current_user) {
+                                retrieve_type = 'cc';
+                                return retrieve_approve = a;
+                            }
+                        });
+                        if (retrieve_type === 'cc') {
+                            break;
+                        }
+                        i--;
+                    }
+                    if (retrieve_type === 'normal') {
+                        // 获取一个flow
+                        flow = UUFlowManager.getFlow(instance.flow);
+                        previous_step = UUFlowManager.getStep(instance, flow, previous_trace_step_id);
+                        space_id = instance.space;
+                        instance_id = instance._id;
+                        old_inbox_users = instance.inbox_users;
+                        setObj = new Object;
+                        now = new Date;
+                        const finishedApproveIds = []
+                        let retrieve_appr_id = ''
+                        _.each(traces, function (t) {
+                            var current_space_user, current_user_organization, retrieve_appr;
+                            if (t._id === last_trace_id) {
+                                if (!t.approves) {
+                                    t.approves = new Array;
+                                }
+                                // 更新当前trace.approve记录
+                                _.each(t.approves, function (appr) {
+                                    if (appr.is_finished === false && appr.type !== "cc") {
+                                        appr.start_date = now;
+                                        appr.finish_date = now;
+                                        appr.read_date = now;
+                                        appr.is_error = false;
+                                        appr.is_read = true;
+                                        appr.is_finished = true;
+                                        appr.judge = "terminated";
+                                        appr.cost_time = appr.finish_date - appr.start_date;
+
+                                        finishedApproveIds.push(appr._id)
+                                    }
+                                });
+                                // 在同一trace下插入取回操作者的approve记录
+                                current_space_user = UUFlowManager.getSpaceUser(space_id, current_user);
+                                current_user_organization = db.organizations.findOne(current_space_user.organization, {
+                                    fields: {
+                                        name: 1,
+                                        fullname: 1
+                                    }
+                                });
+                                retrieve_appr = new Object;
+                                retrieve_appr._id = _makeNewID();
+                                retrieve_appr.instance = instance_id;
+                                retrieve_appr.trace = t._id;
+                                retrieve_appr.is_finished = true;
+                                retrieve_appr.user = current_user;
+                                retrieve_appr.user_name = current_user_info.name;
+                                retrieve_appr.handler = current_user;
+                                retrieve_appr.handler_name = current_user_info.name;
+                                retrieve_appr.handler_organization = current_space_user.organization;
+                                retrieve_appr.handler_organization_name = current_user_organization.name;
+                                retrieve_appr.handler_organization_fullname = current_user_organization.fullname;
+                                retrieve_appr.start_date = now;
+                                retrieve_appr.finish_date = now;
+                                retrieve_appr.due_date = t.due_date;
+                                retrieve_appr.read_date = now;
+                                retrieve_appr.judge = "retrieved";
+                                retrieve_appr.is_read = true;
+                                retrieve_appr.description = retrieve_comment;
+                                retrieve_appr.is_error = false;
+                                retrieve_appr.values = new Object;
+                                retrieve_appr.cost_time = retrieve_appr.finish_date - retrieve_appr.start_date;
+                                t.approves.push(retrieve_appr);
+                                // 更新当前trace记录
+                                t.is_finished = true;
+                                t.finish_date = now;
+                                return t.judge = "retrieved";
+                            }
+                        });
+                        // 插入下一步trace记录
+                        newTrace = new Object;
+                        newTrace._id = _makeNewID();
+                        newTrace.instance = instance_id;
+                        newTrace.previous_trace_ids = [last_trace_id];
+                        newTrace.is_finished = false;
+                        newTrace.step = previous_trace_step_id;
+                        newTrace.name = previous_trace_name;
+                        newTrace.start_date = now;
+                        newTrace.due_date = UUFlowManager.getDueDate(previous_step.timeout_hours, space_id);
+                        newTrace.approves = [];
+                        // 插入下一步trace.approve记录
+                        newApprove = new Object;
+                        newApprove._id = _makeNewID();
+                        newApprove.instance = instance_id;
+                        newApprove.trace = newTrace._id;
+                        newApprove.is_finished = false;
+                        newApprove.user = current_user;
+                        handler_info = db.users.findOne(current_user, {
+                            fields: {
+                                name: 1
+                            }
+                        });
+                        newApprove.user_name = handler_info.name;
+                        newApprove.handler = current_user;
+                        newApprove.handler_name = handler_info.name;
+                        space_user = UUFlowManager.getSpaceUser(space_id, current_user);
+                        // 获取next_step_user所在的部门信息
+                        org_info = UUFlowManager.getSpaceUserOrgInfo(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 = new Object;
+                        UUFlowManager.setRemindInfo(instance.values, newApprove);
+                        newTrace.approves.push(newApprove);
+                        setObj.inbox_users = [current_user];
+                        setObj.modified = now;
+                        setObj.modified_by = current_user;
+                        traces.push(newTrace);
+                        setObj.traces = traces;
+                        setObj.state = "pending";
+                        setObj.is_archived = false;
+                        setObj.current_step_name = previous_trace_name;
+                        setObj.current_step_auto_submit = UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, previous_step.lines);
+                        r = db.instances.update({
+                            _id: instance_id
+                        }, {
+                            $set: setObj
+                        });
+
+                        // 更新被取回的approve
+                        update_many_instance_tasks(instance_id, last_trace_id, finishedApproveIds)
+                        // 插入取回操作的approve
+                        insert_instance_tasks(instance_id, last_trace_id, retrieve_appr_id)
+                        // 插入新步骤的approve
+                        insert_instance_tasks(instance_id, newTrace._id, newApprove._id)
+
+                        if (r) {
+                            // 给被删除的inbox_users 和 当前用户 发送push
+                            pushManager.send_message_current_user(current_user_info);
+                            _.each(old_inbox_users, function (user_id) {
+                                if (user_id !== current_user) {
+                                    return pushManager.send_message_to_specifyUser("current_user", user_id);
+                                }
+                            });
+                            ins = UUFlowManager.getInstance(instance_id);
+                            // 如果已经配置webhook并已激活则触发
+                            return pushManager.triggerWebhook(ins.flow, ins, {}, 'retrieve', current_user, ins.inbox_users);
+                        }
+                    } else if (retrieve_type === 'cc') {
+                        setObj = new Object;
+                        now = new Date;
+                        instance_id = instance._id;
+                        the_trace = _.find(traces, function (t) {
+                            return t._id === retrieve_approve.trace;
+                        });
+                        _.each(the_trace.approves, function (a) {
+                            if (a._id === retrieve_approve._id) {
+                                a.is_finished = false;
+                                a.finish_date = void 0;
+                                a.judge = void 0;
+                                return a.cost_time = void 0;
+                            }
+                        });
+                        cc_users = instance.cc_users;
+                        cc_users.push(current_user);
+                        setObj.modified = now;
+                        setObj.modified_by = current_user;
+                        setObj.state = "pending";
+                        setObj.is_archived = false;
+                        setObj.cc_users = cc_users;
+                        setObj['traces.$.approves'] = the_trace.approves;
+                        r = db.instances.update({
+                            _id: instance_id,
+                            'traces._id': retrieve_approve.trace
+                        }, {
+                            $set: setObj
+                        });
+
+                        update_instance_tasks(instance_id, retrieve_approve.trace, retrieve_approve._id)
+
+                        if (r) {
+                            pushManager.send_message_current_user(current_user_info);
+                        }
+                        ins = UUFlowManager.getInstance(instance_id);
+                        // 如果已经配置webhook并已激活则触发
+                        return pushManager.triggerWebhook(ins.flow, ins, {}, 'retrieve', current_user, [current_user]);
+                    }
+                });
+
+                res.status(200).send({});
+            } catch (e) {
+                console.error(e);
+                res.status(200).send({
+                    errors: [{ errorMessage: e.message }]
+                });
+            }
+        }).run()
+    } catch (e) {
+        res.status(200).send({
+            errors: [{ errorMessage: e.message }]
+        });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,72 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-24 14:56:47
+ * @LastEditors: sunhaolin@hotoa.com
+ * @LastEditTime: 2022-12-24 15:00:05
+ * @Description: 
+ */
+'use strict';
+// @ts-check
+const express = require('express');
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require('underscore');
+const Fiber = function(fun){console.log('TODO Fiber...')}
+const UUFlowManager = require('../manager/uuflow_manager');
+/**
+@api {get} /uf/space/changeset 废弃？？
+@apiVersion 0.0.0
+@apiName /uf/space/changeset
+@apiGroup service-workflow
+@apiQuery {String} auth_token auth_token
+@apiQuery {String} sync_token sync_token
+@apiQuery {String[]} formids formids
+@apiQuery {Boolean} is_admin is_admin
+@apiSuccessExample {json} Success-Response:
+    HTTP/1.1 200 OK
+    {
+        'Spaces': [],
+        ...
+    }
+@apiErrorExample {json} Error-Response:
+    HTTP/1.1 200 OK
+    {
+      errors: [{ errorMessage: e.message }]
+    }
+ */
+router.get('/uf/space/changeset', requireAuthentication, async function (req, res) {
+    try {
+        let userSession = req.user;
+        const spaceId = userSession.spaceId;
+        const userId = userSession.userId;
+        const isSpaceAdmin = userSession.is_space_admin;
+        Fiber(async function () {
+            try {
+                var auth_token, data, e, formids, is_admin, query, sync_token;
+                query = req.query;
+                auth_token = db.auth_tokens.findOne({
+                    auth_token: query.auth_token
+                });
+                if ((!auth_token) || (!auth_token.enabled)) {
+                    throw new Error(401);
+                }
+                sync_token = query["sync_token"];
+                formids = query["formids"];
+                is_admin = query["is_admin"];
+                data = UUFlowManager.get_SpaceChangeSet(formids, is_admin, sync_token);
+
+                res.status(200).send(data);
+            } catch (e) {
+                console.error(e);
+                res.status(200).send({
+                    errors: [{ errorMessage: e.message }]
+                });
+            }
+        }).run()
+    } catch (e) {
+        res.status(200).send({
+            errors: [{ errorMessage: e.message }]
+        });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,91 @@
+/*
+ * @Author: sunhaolin@hotoa.com 
+ * @Date: 2022-03-26 10:49:51 
+ * @Last Modified by: sunhaolin@hotoa.com
+ * @Last Modified time: 2022-03-26 10:53:33
+ */
+'use strict';
+// @ts-check
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require('lodash');
+const UUFlowManager = require('../manager/uuflow_manager');
+const { excuteTriggers } = require('../utils/trigger');
+const pushManager = require('../manager/push_manager');
+const { getCollection } = require("../utils/collection");
+/**
+ * 草稿箱提交申请单
+ * body {
+ *   Instances: [
+ *     {
+ *       _id: 申请单Id
+        flow: 流程Id
+        inbox_users: 不懂啊 TODO 待确认此属性功能
+        applicant:
+        submitter:
+        traces: [
+            {
+                _id: 
+                step: 
+                approves: [
+                    {
+                        _id:
+                        next_steps: [{ "step": "步骤id", "users": [步骤处理人] }]
+                        description: 意见,
+                        values: {}
+                    }
+                ]
+            }
+        ]
+ *     }
+ *   ]
+ * }
+ */
+router.post('/api/workflow/submit', requireAuthentication, async function (req, res) {
+    const db = {
+        instances: await getCollection('instances')
+    }
+    let userSession = req.user;
+    const spaceId = userSession.spaceId;
+    const userId = userSession.userId;
+    userSession._id = userId;
+    // const isSpaceAdmin = userSession.is_space_admin;
+
+    var hashData = req.body;
+    var result = [];
+    const instance_from_client = hashData['Instances'][0];
+    // beforeDraftSubmit
+    const insId = instance_from_client._id;
+    await excuteTriggers({ when: 'beforeDraftSubmit', userId: userId, flowId: instance_from_client['flow'], insId: insId });
+
+    try {
+        var r = await UUFlowManager.submit_instance(instance_from_client, userSession);
+        if (r.alerts) {
+            result.push(r);
+        }
+        if (!_.isEmpty(instance_from_client['inbox_users'])) {
+            // 如果是转发就需要给当前用户发送push 重新计算badge
+            await pushManager.send_message_to_specifyUser("current_user", userId);
+        }
+        if (_.isEmpty(r.alerts)) {
+            if (pushManager.hasWebhooks(instance_from_client.flow)) {
+                var instance = await db.instances.findOne({_id: instance_from_client._id});
+                var flow_id = instance.flow;
+                var current_approve = instance_from_client.traces[0].approves[0];
+                // 如果已经配置webhook并已激活则触发
+                pushManager.triggerWebhook(flow_id, instance, current_approve, 'draft_submit', userId, instance.inbox_users);
+            }
+        }
+        // 判断申请单是否分发，分发文件结束提醒发起人
+        await UUFlowManager.distributedInstancesRemind(instance_from_client);
+
+        res.status(200).send({ result: result });
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            errors: [{ errorMessage: error.message }]
+        });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,217 @@
+/*
+ * @Author: sunhaolin@hotoa.com 
+ * @Date: 2022-03-26 10:49:51 
+ * @Last Modified by: sunhaolin@hotoa.com
+ * @Last Modified time: 2022-03-26 10:53:33
+ */
+'use strict';
+// @ts-check
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const objectql = require('@steedos/objectql');
+const _ = require('lodash');
+const Fiber = function(fun){console.log('TODO Fiber...')}
+const { excuteTriggers } = require('../utils/trigger');
+const {
+    remove_many_instance_tasks,
+} = require('../manager/instance_tasks_manager')
+const PermissionManager = require('../manager/permission_manager');
+const UUFlowManager = require('../manager/uuflow_manager');
+const pushManager = require('../manager/push_manager');
+/**
+ * 申请人取消申请
+ * body {
+ *   Instances: [
+ *     {
+ *       
+ *     }
+ *   ]
+ * }
+ */
+router.post('/api/workflow/terminate', requireAuthentication, async function (req, res) {
+    try {
+        let userSession = req.user;
+        const spaceId = userSession.spaceId;
+        const userId = userSession.userId;
+        userSession._id = userId;
+        // const isSpaceAdmin = userSession.is_space_admin;
+
+        var hashData = req.body;
+        const instance_from_client = hashData['Instances'][0];
+
+        const insId = instance_from_client._id;
+        const instanceDoc = (await objectql.getObject('instances').find({ filters: [['_id', '=', insId]], fields: ['flow'] }))[0];
+        const flowId = instanceDoc.flow;
+        // beforeEnd
+        await excuteTriggers({ when: 'beforeEnd', userId, flowId, insId });
+
+        Fiber(async function () {
+            try {
+                var flow, flow_id, flow_ver_end_step, flow_vers, h, i, ins, instance, instance_flow_ver, instance_id, instance_trace, newApprove, newTrace, now, old_cc_users, old_inbox_users, old_outbox_users, permissions, r, setObj, space, space_id, space_user, space_user_org_info, tempUsers, terminate_reason, traces;
+                terminate_reason = instance_from_client["terminate_reason"];
+                instance_id = instance_from_client["_id"];
+                // 获取一个instance
+                instance = UUFlowManager.getInstance(instance_id);
+                space_id = instance.space;
+                flow_id = instance.flow;
+                // 获取一个space
+                space = UUFlowManager.getSpace(space_id);
+                // 获取一个flow
+                flow = UUFlowManager.getFlow(flow_id);
+                // 判断一个instance是否为审核中状态
+                UUFlowManager.isInstancePending(instance);
+                // 获取一个space下的一个user
+                space_user = UUFlowManager.getSpaceUser(space_id, userId);
+                // 获取space_user所在的部门信息
+                space_user_org_info = UUFlowManager.getSpaceUserOrgInfo(space_user);
+                // 获取结束节点
+                instance_flow_ver = null;
+                flow_ver_end_step = null;
+                flow_vers = new Array;
+                flow_vers.push(flow.current);
+                flow_vers = flow_vers.concat(flow.historys);
+                instance_flow_ver = _.find(flow_vers, function (f_ver) {
+                    return f_ver._id === instance.flow_version;
+                });
+                if (!instance_flow_ver) {
+                    throw new Error("未找到申请单对应流程版本");
+                }
+                flow_ver_end_step = _.find(instance_flow_ver.steps, function (f_step) {
+                    return f_step.step_type === "end";
+                });
+                // 调用getFlowPermissions方法，看返回的结果中是否有admin
+                permissions = PermissionManager.getFlowPermissions(flow_id, userId);
+                now = new Date;
+                setObj = new Object;
+                // space的admin, 填单人 申请人 有权限 取消申请
+                if (permissions.includes("admin") || space.admins.includes(userId) || instance.submitter === userId || instance.applicant === userId) {
+                    if (!terminate_reason) {
+                        throw new Error("还未填写强制结束申请单的理由，操作失败");
+                    }
+                    instance_trace = _.find(instance.traces, function (trace) {
+                        return trace.is_finished === false;
+                    });
+                    traces = instance.traces;
+                    const finishedApproveIds = []
+                    i = 0;
+                    while (i < traces.length) {
+                        if (traces[i].is_finished === false) {
+                            // 更新当前trace记录
+                            traces[i].is_finished = true;
+                            traces[i].finish_date = now;
+                            h = 0;
+                            while (h < traces[i].approves.length) {
+                                if (traces[i].approves[h].is_finished === false) {
+                                    // 更新当前trace.approve记录
+                                    traces[i].approves[h].is_finished = true;
+                                    traces[i].approves[h].finish_date = now;
+                                    traces[i].approves[h].judge = null;
+                                    traces[i].approves[h].description = null;
+                                    finishedApproveIds.push(traces[i].approves[h]._id)
+                                }
+                                h++;
+                            }
+                            // 插入当前Trace trace.approve记录：当trace.type为取回、强制结束时，is_read=true且read_date为当前时间。
+                            newApprove = new Object;
+                            newApprove._id = _makeNewID();
+                            newApprove.instance = instance_id;
+                            newApprove.trace = instance_trace._id;
+                            newApprove.is_finished = true;
+                            newApprove.user = userId;
+                            newApprove.user_name = userSession.name;
+                            newApprove.handler = userId;
+                            newApprove.handler_name = userSession.name;
+                            newApprove.handler_organization = space_user_org_info["organization"];
+                            newApprove.handler_organization_name = space_user_org_info["organization_name"];
+                            newApprove.handler_organization_fullname = space_user_org_info["organization_fullname"];
+                            newApprove.start_date = now;
+                            newApprove.finish_date = now;
+                            newApprove.due_date = instance_trace.due_date;
+                            newApprove.read_date = now;
+                            newApprove.judge = "terminated";
+                            newApprove.is_read = true;
+                            newApprove.description = terminate_reason;
+                            newApprove.is_error = false;
+                            newApprove.values = new Object;
+                            newApprove.cost_time = newApprove.finish_date - newApprove.start_date;
+                            traces[i].approves.push(newApprove);
+                        }
+                        i++;
+                    }
+                    // 插入下一步trace记录
+                    newTrace = new Object;
+                    newTrace._id = _makeNewID();
+                    newTrace.instance = instance_id;
+                    newTrace.previous_trace_ids = [instance_trace._id];
+                    // type---停用
+                    // newTrace.type = "terminated"
+                    newTrace.is_finished = true;
+                    newTrace.step = flow_ver_end_step._id;
+                    newTrace.name = flow_ver_end_step.name;
+                    newTrace.start_date = now;
+                    newTrace.finish_date = now;
+                    newTrace.judge = "terminated";
+                    setObj.state = "completed";
+                    setObj.final_decision = "terminated";
+                    old_inbox_users = instance.inbox_users;
+                    old_cc_users = instance.cc_users || [];
+                    old_outbox_users = instance.outbox_users;
+                    tempUsers = new Array;
+                    _.each(instance_trace.approves, function (nft_approve) {
+                        tempUsers.push(nft_approve.user);
+                        return tempUsers.push(nft_approve.handler);
+                    });
+                    setObj.outbox_users = _.uniq(instance.outbox_users.concat(tempUsers));
+                    setObj.inbox_users = new Array;
+                    setObj.cc_users = new Array;
+                    setObj.modified = now;
+                    setObj.modified_by = userId;
+                    traces.push(newTrace);
+                    setObj.traces = traces;
+                    setObj.current_step_name = flow_ver_end_step.name;
+                    setObj.current_step_auto_submit = false;
+                    r = db.instances.update({
+                        _id: instance_id
+                    }, {
+                        $set: setObj
+                    });
+                    // 删除intance_tasks
+                    remove_many_instance_tasks(finishedApproveIds)
+                    if (r) {
+                        ins = UUFlowManager.getInstance(instance_id);
+                        //通知填单人、申请人
+                        pushManager.send_instance_notification("submit_terminate_applicant", ins, terminate_reason, userSession);
+                        //发送给待处理人 被传阅人
+                        if (old_inbox_users) {
+                            _.each(_.uniq(old_inbox_users.concat(old_cc_users)), function (user_id) {
+                                return pushManager.send_message_to_specifyUser("terminate_approval", user_id);
+                            });
+                        }
+                        // 如果已经配置webhook并已激活则触发
+                        pushManager.triggerWebhook(ins.flow, ins, {}, 'terminate', userId, []);
+                    }
+                }
+                //发送消息给当前用户
+                pushManager.send_message_current_user(userSession);
+
+                // afterEnd
+                await excuteTriggers({ when: 'afterEnd', userId, flowId, insId });
+
+                res.status(200).send({});
+            } catch (error) {
+                console.error(error);
+                res.status(200).send({
+                    errors: [{ errorMessage: error.message }]
+                });
+            }
+
+        }).run()
+
+    } catch (e) {
+        res.status(200).send({
+            errors: [{ errorMessage: e.message }]
+        });
+    }
+});
+exports.default = router;