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

package/main/default/manager/uuflow_manager.js

@@ -0,0 +1,4278 @@
+const {
+    insert_instance_tasks,
+    insert_many_instance_tasks,
+    update_instance_tasks,
+    update_many_instance_tasks,
+    remove_many_instance_tasks,
+} = require('./instance_tasks_manager');
+const Cookies = require("cookies");
+const _eval = require('eval');
+const HandlersManager = require('./handlers_manager');
+const PermissionManager = require('./permission_manager');
+const WorkflowManager = require('./workflow_manager');
+const { getCollection, _makeNewID } = require('../utils/collection');
+const WorkingTime = require('../utils/workingTime');
+const pushManager = require('./push_manager');
+const { t } = require('@steedos/i18n')
+const moment = require('moment')
+const { getObject } = require('@steedos/objectql');
+
+const UUFlowManager = {};
+
+/**
+ * Check user authorization
+ * @param {Object} req - Request object
+ * @param {Object} res - Response object
+ * @returns {Object} User object if authorized
+ * @throws {Error} If unauthorized
+ */
+UUFlowManager.check_authorization = async function (req, res) {
+    const query = req.query;
+    let userId = query["X-User-Id"];
+    let authToken = query["X-Auth-Token"];
+    
+    if (!userId || !authToken) {
+        const cookies = new Cookies(req, res);
+        userId = cookies.get("X-User-Id");
+        authToken = cookies.get("X-Auth-Token");
+    }
+
+    if (!userId || !authToken) {
+        throw new Error(401);
+    }
+
+    const hashedToken = Accounts._hashLoginToken(authToken);
+    const usersCollection = await getCollection('users');
+    const user = await usersCollection.findOne({
+        _id: userId,
+        "services.resume.loginTokens.hashedToken": hashedToken
+    });
+
+    if (!user) {
+        throw new Error(401);
+    }
+
+    return user;
+};
+
+/**
+ * Check if next step users are valid
+ * @param {Array} selected - Selected users
+ * @param {Array} scope - Allowed users
+ * @param {Object} nextStep - Next step configuration
+ * @returns {Boolean} True if valid
+ */
+UUFlowManager.checkNestStepUsersIsValid = function (selected = [], scope = [], nextStep = null) {
+    if (nextStep?.allow_pick_approve_users) {
+        return true;
+    }
+    return _.difference(selected, scope).length === 0;
+};
+
+/**
+ * Get instance by ID
+ * @param {String} instance_id - Instance ID
+ * @returns {Object} Instance object
+ * @throws {Error} If instance not found
+ */
+UUFlowManager.getInstance = async function (instance_id) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getInstance');
+    }
+    
+    const instancesCollection = await getCollection('instances');
+    const ins = await instancesCollection.findOne({_id: instance_id});
+    
+    if (!ins) {
+        throw new Error(`申请单ID：${instance_id}有误或此申请单已经被删除`);
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getInstance');
+    }
+    
+    return ins;
+};
+
+/**
+ * Get space by ID
+ * @param {String} space_id - Space ID
+ * @returns {Object} Space object
+ * @throws {Error} If space not found
+ */
+UUFlowManager.getSpace = async function (space_id) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getSpace');
+    }
+    
+    const spacesCollection = await getCollection('spaces');
+    const space = await spacesCollection.findOne({_id: space_id});
+    
+    if (!space) {
+        throw new Error("space_id有误或此space已经被删除");
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getSpace');
+    }
+    
+    return space;
+};
+
+/**
+ * Get space user
+ * @param {String} space_id - Space ID
+ * @param {String} user_id - User ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} Space user object
+ * @throws {Error} If space user not found
+ */
+UUFlowManager.getSpaceUser = async function (space_id, user_id, options = {}) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getSpaceUser');
+    }
+    
+    const spaceUsersCollection = await getCollection('space_users');
+    const space_user = await spaceUsersCollection.findOne({
+        space: space_id,
+        user: user_id
+    }, options);
+    
+    if (!space_user) {
+        throw new Error("user_id对应的用户不属于当前space");
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getSpaceUser');
+    }
+    
+    return space_user;
+};
+
+/**
+ * Get flow by ID
+ * @param {String} flow_id - Flow ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} Flow object
+ * @throws {Error} If flow not found
+ */
+UUFlowManager.getFlow = async function (flow_id, options = {}) {
+    if (process.env.STEEDOS_DEBUG) {
+        const now = new Date().toISOString();
+        console.time('UUFlowManager.getFlow' + now);
+    }
+    
+    const flowsCollection = await getCollection('flows');
+    const flow = await flowsCollection.findOne({_id: flow_id}, options);
+    
+    if (!flow) {
+        throw new Error("id有误或此流程已经被删除");
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getFlow' + now);
+    }
+    
+    return flow;
+};
+
+/**
+ * Get flow version
+ * @param {Object} flow - Flow object
+ * @param {String} flow_version - Flow version ID
+ * @returns {Object} Flow version object
+ * @throws {Error} If version not found
+ */
+UUFlowManager.getFlowVersion = function (flow, flow_version) {
+    let flow_v = null;
+    
+    if (flow_version === flow.current._id) {
+        flow_v = flow.current;
+    } else {
+        flow_v = _.find(flow.historys, (flow_h) => flow_version === flow_h._id);
+    }
+    
+    if (!flow_v) {
+        throw new Error('未找到流程对应的版本');
+    }
+    
+    return flow_v;
+};
+
+/**
+ * Get step from steps array
+ * @param {Array} steps - Steps array
+ * @param {String} stepId - Step ID
+ * @returns {Object} Step object
+ */
+UUFlowManager.getStepFromSteps = function (steps, stepId) {
+    return _.find(steps, (step) => step._id === stepId);
+};
+
+/**
+ * Get space user organization info
+ * @param {Object} space_user - Space user object
+ * @returns {Object} Organization info
+ */
+UUFlowManager.getSpaceUserOrgInfo = async function (space_user) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getSpaceUserOrgInfo');
+    }
+    
+    const info = {
+        organization: space_user.organization,
+        organization_name: '',
+        organization_fullname: ''
+    };
+    
+    const organizationsCollection = await getCollection('organizations');
+    const org = await organizationsCollection.findOne({_id: space_user.organization}, {
+        projection: {
+            name: 1,
+            fullname: 1
+        }
+    });
+    
+    if (org) {
+        info.organization_name = org.name;
+        info.organization_fullname = org.fullname;
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getSpaceUserOrgInfo');
+    }
+    
+    return info;
+};
+
+/**
+ * Get trace from instance
+ * @param {Object} instance - Instance object
+ * @param {String} trace_id - Trace ID
+ * @returns {Object} Trace object
+ * @throws {Error} If trace not found
+ */
+UUFlowManager.getTrace = function (instance, trace_id) {
+    const trace = _.find(instance.traces, (t) => t._id === trace_id);
+    
+    if (!trace) {
+        throw new Error("trace_id有误");
+    }
+    
+    return trace;
+};
+
+/**
+ * Get approve from trace
+ * @param {Object} trace - Trace object
+ * @param {String} approve_id - Approve ID
+ * @returns {Object} Approve object
+ * @throws {Error} If approve not found
+ */
+UUFlowManager.getApprove = function (trace, approve_id) {
+    const approve = _.find(trace.approves, (t) => t._id === approve_id);
+    
+    if (!approve) {
+        throw new Error("trace_id有误");
+    }
+    
+    return approve;
+};
+
+/**
+ * Check if trace is not finished
+ * @param {Object} trace - Trace object
+ * @throws {Error} If trace is finished
+ */
+UUFlowManager.isTraceNotFinished = function (trace) {
+    if (trace.is_finished !== false) {
+        throw new Error("可能已有人对此文件做了处理。请点击已审核，查看文件的最新状态");
+    }
+};
+
+/**
+ * Check if approve is not finished
+ * @param {Object} approve - Approve object
+ * @throws {Error} If approve is finished
+ */
+UUFlowManager.isApproveNotFinished = function (approve) {
+    if (approve.is_finished !== false) {
+        throw new Error("当前步骤不为未完成状态,不能进行此操作");
+    }
+};
+
+/**
+ * Check if instance is pending
+ * @param {Object} instance - Instance object
+ * @param {String} lang - Language code
+ * @throws {Error} If instance is not pending
+ */
+UUFlowManager.isInstancePending = function (instance, lang = "zh-CN") {
+    if (instance.state !== "pending") {
+        throw new Error(t('instance.remindMessage.update_failed', {}, lang));
+    }
+};
+
+/**
+ * Check if user is handler or agent
+ * @param {Object} approve - Approve object
+ * @param {String} user_id - User ID
+ * @throws {Error} If user is not handler or agent
+ */
+UUFlowManager.isHandlerOrAgent = function (approve, user_id) {
+    if (approve.user !== user_id && approve.agent !== user_id) {
+        throw new Error("不是当前步骤对应的处理人或其代理人，不能进行此操作");
+    }
+};
+
+/**
+ * Check if instance is draft
+ * @param {Object} instance - Instance object
+ * @param {String} lang - Language code
+ * @throws {Error} If instance is not draft
+ */
+UUFlowManager.isInstanceDraft = function (instance, lang = "zh-CN") {
+    if (instance.state !== "draft") {
+        throw new Error(t('instance.remindMessage.update_failed', {}, lang));
+    }
+};
+
+/**
+ * Check if user is instance submitter
+ * @param {Object} instance - Instance object
+ * @param {String} current_user_id - User ID
+ * @throws {Error} If user is not submitter
+ */
+UUFlowManager.isInstanceSubmitter = function (instance, current_user_id) {
+    if (instance.submitter !== current_user_id) {
+        throw new Error('当前用户不是申请单对应的提交人,不能进行此操作');
+    }
+};
+
+/**
+ * Check if user is submitter, applicant or space admin
+ * @param {Object} instance - Instance object
+ * @param {String} current_user_id - User ID
+ * @param {Object} space - Space object
+ * @throws {Error} If user doesn't have permission
+ */
+UUFlowManager.isInstanceSubmitterOrApplicantOrSpaceAdmin = function (instance, current_user_id, space) {
+    if (instance.submitter !== current_user_id && 
+        instance.applicant !== current_user_id && 
+        !space.admins.includes(current_user_id)) {
+        throw new Error("当前用户不是申请单对应的提交人或申请人或工作区管理员");
+    }
+};
+
+/**
+ * Get step from instance and flow
+ * @param {Object} instance - Instance object
+ * @param {Object} flow - Flow object
+ * @param {String} step_id - Step ID
+ * @returns {Object} Step object
+ * @throws {Error} If step not found
+ */
+UUFlowManager.getStep = function (instance, flow, step_id) {
+    // console.log('getStep: ', instance, flow, step_id)
+    const flow_rev = instance.flow_version;
+    let isExistStep = null;
+    
+    if (flow.current._id === flow_rev) {
+        isExistStep = _.find(flow.current.steps, (step) => step._id === step_id);
+    } else {
+        _.each(flow.historys, (history) => {
+            if (history._id === flow_rev) {
+                isExistStep = _.find(history.steps, (step) => step._id === step_id);
+                return false; // Break loop
+            }
+        });
+    }
+    
+    if (!isExistStep) {
+        throw new Error("不能获取step");
+    }
+    
+    return isExistStep;
+};
+
+/**
+ * Check if judge value is legal
+ * @param {String} judge - Judge value
+ * @throws {Error} If judge is invalid
+ */
+UUFlowManager.isJudgeLegal = function (judge) {
+    const validJudges = ["approved", "rejected", "readed", "submitted"];
+    if (!validJudges.includes(judge)) {
+        throw new Error("judge有误");
+    }
+};
+
+/**
+ * Check if user is space admin
+ * @param {String} space_id - Space ID
+ * @param {String} user_id - User ID
+ * @throws {Error} If user is not admin
+ */
+UUFlowManager.isSpaceAdmin = async function (space_id, user_id) {
+    const spacesCollection = await getCollection('spaces');
+    const space = await spacesCollection.findOne({
+        _id: space_id
+    }, {
+        projection: {
+            admins: 1
+        }
+    });
+    
+    if (!space?.admins?.includes(user_id)) {
+        throw new Error("当前用户不是工作区管理员,不能进行此操作");
+    }
+};
+
+/**
+ * Get user by ID
+ * @param {String} user_id - User ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} User object
+ * @throws {Error} If user not found
+ */
+UUFlowManager.getUser = async function (user_id, options = {}) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getUser');
+    }
+    
+    const usersCollection = await getCollection('users');
+    const user = await usersCollection.findOne({_id: user_id}, options);
+    
+    if (!user) {
+        throw new Error("用户ID有误或此用户已经被删除");
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getUser');
+    }
+    
+    return user;
+};
+
+/**
+ * Get organization by ID
+ * @param {String} orgId - Organization ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} Organization object
+ * @throws {Error} If organization not found
+ */
+UUFlowManager.getOrganization = async function (orgId, options = {}) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getOrganization');
+    }
+    
+    const organizationsCollection = await getCollection('organizations');
+    const orgDoc = await organizationsCollection.findOne({_id: orgId}, options);
+    
+    if (!orgDoc) {
+        throw new Error("组织ID有误或此组织已经被删除");
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getOrganization');
+    }
+    
+    return orgDoc;
+};
+
+/**
+ * Get user organization
+ * @param {String} user_id - User ID
+ * @param {String} space_id - Space ID
+ * @returns {Object} Organization object
+ */
+UUFlowManager.getUserOrganization = async function (user_id, space_id) {
+    const organizationsCollection = await getCollection('organizations');
+    return await organizationsCollection.findOne({
+        space: space_id,
+        users: user_id
+    });
+};
+
+/**
+ * Get user roles
+ * @param {String} user_id - User ID
+ * @param {String} space_id - Space ID
+ * @returns {Array} Array of role names
+ */
+UUFlowManager.getUserRoles = async function (user_id, space_id) {
+    const role_names = [];
+    
+    const positionsCollection = await getCollection('flow_positions');
+    const positionsCursor = await positionsCollection.find({
+        space: space_id,
+        users: user_id
+    }, {
+        projection: {
+            role: 1
+        }
+    });
+    
+    const positions = await positionsCursor.toArray();
+    
+    const flowRolesCollection = await getCollection('flow_roles');
+    for (const position of positions) {
+        const role = await flowRolesCollection.findOne({
+            _id: position.role
+        }, {
+            projection: {
+                name: 1
+            }
+        });
+        
+        if (role) {
+            role_names.push(role.name);
+        }
+    }
+    
+    return role_names;
+};
+
+/**
+ * Check if flow is enabled
+ * @param {Object} flow - Flow object
+ * @throws {Error} If flow is not enabled
+ */
+UUFlowManager.isFlowEnabled = function (flow) {
+    if (flow.state !== "enabled") {
+        throw new Error("流程未启用,操作失败");
+    }
+};
+
+/**
+ * Check if flow matches space
+ * @param {Object} flow - Flow object
+ * @param {String} space_id - Space ID
+ * @throws {Error} If flow doesn't belong to space
+ */
+UUFlowManager.isFlowSpaceMatched = function (flow, space_id) {
+    if (flow.space !== space_id) {
+        throw new Error("流程和工作区ID不匹配");
+    }
+};
+
+/**
+ * Calculate condition for conditional step
+ * @param {Object} values - Form values
+ * @param {String} condition_str - Condition string
+ * @returns {Boolean} Condition result
+ */
+UUFlowManager.calculateCondition = function (values, condition_str) {
+    try {
+        const __values = values;
+        
+        // Helper functions for condition calculation
+        const sum = (subform_field) => {
+            if (!subform_field) {
+                throw new Error("参数为空");
+            }
+            if (!Array.isArray(subform_field)) {
+                throw new Error("参数不是数组类型");
+            }
+            
+            return subform_field.reduce((total, field_value) => {
+                return total + Number(String(field_value));
+            }, 0);
+        };
+        
+        const average = (subform_field) => {
+            if (!subform_field) {
+                throw new Error("参数为空");
+            }
+            if (!Array.isArray(subform_field)) {
+                throw new Error("参数不是数组类型");
+            }
+            
+            return sum(subform_field) / subform_field.length;
+        };
+        
+        const count = (subform_field) => {
+            if (!subform_field) {
+                throw new Error("参数为空");
+            }
+            return subform_field.length;
+        };
+        
+        const max = (subform_field) => {
+            if (!subform_field) {
+                throw new Error("参数为空");
+            }
+            if (!Array.isArray(subform_field)) {
+                throw new Error("参数不是数组类型");
+            }
+            
+            const sub_field = subform_field.map(field_value => Number(String(field_value)));
+            return Math.max(...sub_field);
+        };
+        
+        const min = (subform_field) => {
+            if (!subform_field) {
+                throw new Error("参数为空");
+            }
+            if (!Array.isArray(subform_field)) {
+                throw new Error("参数不是数组类型");
+            }
+            
+            const sub_field = subform_field.map(field_value => Number(String(field_value)));
+            return Math.min(...sub_field);
+        };
+        
+        return eval(condition_str);
+    } catch (error) {
+        console.error(error.stack);
+        return false;
+    }
+};
+
+/**
+ * Set form field variables for condition calculation
+ * @param {Array} fields - Form fields
+ * @param {Object} __values - Form values
+ * @param {String} space_id - Space ID
+ */
+UUFlowManager.setFormFieldVariable = async function (fields, __values, space_id) {
+    try {
+        for (const field of fields) {
+            if (field.type === "table") { // Subform
+                const subform_fields_all = field.fields;
+                for (const current_field of subform_fields_all) {
+                    const values_arr = [];
+                    
+                    if (["number", "percentage", "currency"].includes(current_field.type)) {
+                        for (const sub_field of (__values[field.code] || [])) {
+                            values_arr.push(sub_field[current_field.code]);
+                        }
+                    } else if (current_field.type === "checkbox") {
+                        for (const sub_field of (__values[field.code] || [])) {
+                            if (sub_field[current_field.code] === "true") {
+                                values_arr.push(true);
+                            } else if (sub_field[current_field.code] === "false") {
+                                values_arr.push(false);
+                            }
+                        }
+                    } else {
+                        for (const sub_field of (__values[field.code] || [])) {
+                            values_arr.push(sub_field[current_field.code] || "");
+                        }
+                    }
+                    
+                    __values[current_field.code] = values_arr;
+                }
+            } else if (field.type === "group") { // Group selection
+                if (field.is_multiselect) {
+                    if (__values[field.code]?.length > 0) {
+                        const group_id = [];
+                        const group_name = [];
+                        const group_fullname = [];
+                        
+                        for (const group of __values[field.code]) {
+                            group_id.push(group.id);
+                            group_name.push(group.name);
+                            group_fullname.push(group.fullname);
+                        }
+                        
+                        __values[field.code] = {
+                            id: group_id,
+                            name: group_name,
+                            fullname: group_fullname
+                        };
+                    }
+                }
+            } else if (field.type === "user") { // User selection
+                if (field.is_multiselect) {
+                    if (__values[field.code]?.length > 0) {
+                        const user_id = [];
+                        const user_name = [];
+                        const organization = {
+                            user_organization_fullname: [],
+                            user_organization_name: []
+                        };
+                        let user_roles = [];
+                        
+                        for (const select_user of __values[field.code]) {
+                            user_id.push(select_user.id);
+                            user_name.push(select_user.name);
+                            
+                            const organization_selectuser = await UUFlowManager.getUserOrganization(select_user.id, space_id);
+                            const role_selectuser = await UUFlowManager.getUserRoles(select_user.id, space_id);
+                            
+                            if (organization_selectuser) {
+                                organization.user_organization_fullname.push(organization_selectuser.fullname);
+                                organization.user_organization_name.push(organization_selectuser.name);
+                            }
+                            
+                            if (role_selectuser) {
+                                user_roles = user_roles.concat(role_selectuser);
+                            }
+                        }
+                        
+                        __values[field.code] = {
+                            id: user_id,
+                            name: user_name,
+                            organization: organization,
+                            roles: user_roles
+                        };
+                    }
+                } else {
+                    if (__values[field.code]) {
+                        const organization_selectuser = await UUFlowManager.getUserOrganization(__values[field.code].id, space_id);
+                        const role_selectuser = await UUFlowManager.getUserRoles(__values[field.code].id, space_id);
+                        
+                        if (organization_selectuser) {
+                            __values[field.code].organization = {
+                                fullname: organization_selectuser.fullname,
+                                name: organization_selectuser.name
+                            };
+                        }
+                        
+                        __values[field.code].roles = role_selectuser;
+                    }
+                }
+            } else if (["number", "percentage", "currency"].includes(field.type)) { // Numeric types
+                __values[field.code] = __values[field.code] ? Number(__values[field.code]) : 0;
+            } else if (field.type === "checkbox") { // Checkbox
+                if (__values[field.code] === "true") {
+                    __values[field.code] = true;
+                } else if (__values[field.code] === "false") {
+                    __values[field.code] = false;
+                }
+            }
+        }
+    } catch (error) {
+        console.error(error.stack);
+    }
+};
+
+function isSkipStep(instance, step) {
+    return instance.skip_steps?.includes(step._id);
+}
+
+/**
+ * Get next steps for instance
+ * @param {Object} instance - Instance object
+ * @param {Object} flow - Flow object
+ * @param {Object} step - Current step object
+ * @param {String} judge - Judge value (approved/rejected)
+ * @param {Object} values - Form values
+ * @returns {Array} Array of next step IDs
+ */
+UUFlowManager.getNextSteps = async function (instance, flow, step, judge, values) {
+    const step_type = step.step_type;
+    let nextSteps = [];
+    
+    if (step_type === "condition") {
+        // Get values for condition calculation
+        let __values = values !== undefined ? values : UUFlowManager.getUpdatedValues(instance);
+        
+        // Get current and start approve
+        let current_approve = null;
+        let start_approve = null;
+        
+        for (const trace of instance.traces) {
+            if (trace.is_finished === false) {
+                current_approve = trace.approves[0];
+            }
+            if (!trace.previous_trace_ids || trace.previous_trace_ids.length === 0) {
+                start_approve = trace.approves[0];
+            }
+        }
+        
+        // Set variables for condition evaluation
+        __values["applicant"] = {
+            roles: await UUFlowManager.getUserRoles(instance.applicant, instance.space),
+            name: instance.applicant_name,
+            organization: {
+                fullname: instance.applicant_organization_fullname,
+                name: instance.applicant_organization_name
+            }
+        };
+        
+        __values["submitter"] = {
+            roles: await UUFlowManager.getUserRoles(start_approve.handler, instance.space),
+            name: start_approve.handler_name,
+            organization: {
+                fullname: start_approve.handler_organization_fullname,
+                name: start_approve.handler_organization_name
+            }
+        };
+        
+        __values["approver"] = {
+            roles: await UUFlowManager.getUserRoles(current_approve.handler, instance.space),
+            name: current_approve.handler_name,
+            organization: {
+                fullname: current_approve.handler_organization_fullname,
+                name: current_approve.handler_organization_name
+            }
+        };
+        
+        // Get form and form version
+        const form = await UUFlowManager.getForm(instance.form);
+        let formVersion = null;
+        
+        if (instance.form_version === form.current._id) {
+            formVersion = form.current;
+        } else {
+            formVersion = _.find(form.historys, (history) => instance.form_version === history._id);
+        }
+        
+        // Set form field variables
+        await UUFlowManager.setFormFieldVariable(formVersion.fields, __values, instance.space);
+        
+        // Evaluate conditions
+        const reg = /(\{[^{}]*\})/g;
+        const prefix = "__values";
+        
+        for (const step_line of step.lines) {
+            if (step_line.state === "submitted") {
+                const step_line_condition = step_line.condition.replace(reg, (vowel) => {
+                    return prefix + vowel.replace(/\{\s*/, "[\"").replace(/\s*\}/, "\"]").replace(/\s*\.\s*/g, "\"][\"");
+                });
+                const allow = UUFlowManager.calculateCondition(__values, step_line_condition);
+                if (allow) {
+                    nextSteps.push(step_line.to_step);
+                }
+            }
+        }
+    } else if (step_type === "end") {
+        return [];
+    } else if (["submit", "start", "counterSign"].includes(step_type)) {
+        const lines = step.lines.filter((line) => line.state === "submitted");
+        
+        if (lines.length === 0) {
+            throw new Error("流程的连线配置有误");
+        }
+        
+        nextSteps = lines.map((line) => line.to_step);
+    } else if (step_type === "sign") {
+        if (judge === "approved") {
+            const lines = step.lines.filter((line) => line.state === "approved");
+            
+            if (lines.length === 0) {
+                throw new Error("流程的连线配置有误");
+            }
+            
+            nextSteps = lines.map((line) => line.to_step);
+        } else if (judge === "rejected") {
+            const lines = step.lines.filter((line) => line.state === "rejected");
+            const rejectedSteps = lines.map((line) => line.to_step);
+            
+            // Get all finished trace steps
+            const trace_steps = [];
+            for (const trace of instance.traces) {
+                if (trace.is_finished === true) {
+                    const flowVersions = [flow.current].concat(flow.historys || []);
+                    
+                    for (const flowVer of flowVersions) {
+                        if (flowVer._id === instance.flow_version) {
+                            for (const flow_ver_step of flowVer.steps) {
+                                if (flow_ver_step._id === trace.step && flow_ver_step.step_type !== "condition") {
+                                    trace_steps.push(trace.step);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            // Get start and end steps from flow
+            const flow_steps = [];
+            if (instance.flow_version === flow.current._id) {
+                for (const flow_step of flow.current.steps) {
+                    if (flow_step.step_type === "start" || flow_step.step_type === "end") {
+                        flow_steps.push(flow_step._id);
+                    }
+                }
+            } else {
+                for (const history of flow.historys) {
+                    for (const history_step of history.steps) {
+                        if (history_step.step_type === "start" || history_step.step_type === "end") {
+                            flow_steps.push(history_step._id);
+                        }
+                    }
+                }
+            }
+            
+            nextSteps = _.union(rejectedSteps, trace_steps, flow_steps);
+        }
+    }
+    
+    // If next steps include condition steps, get their subsequent steps
+    const version_steps = {};
+    const flowVersions = [flow.current].concat(flow.historys || []);
+    
+    for (const flowVer of flowVersions) {
+        if (flowVer._id === instance.flow_version) {
+            for (const flow_ver_step of flowVer.steps) {
+                version_steps[flow_ver_step._id] = flow_ver_step;
+            }
+        }
+    }
+    
+    nextSteps = _.uniq(nextSteps);
+    
+    for (const next_step_id of nextSteps) {
+        const _next_step = version_steps[next_step_id];
+        if (_next_step?.step_type === "condition" && _next_step.lines) {
+            for (const line of _next_step.lines) {
+                if (line.to_step) {
+                    nextSteps.push(line.to_step);
+                }
+            }
+        }
+    }
+    
+    nextSteps = _.uniq(nextSteps);
+    let rev_nextSteps = [];
+    
+    for (const nextStepId of nextSteps) {
+        const _step = await UUFlowManager.getStep(instance, flow, nextStepId);
+        
+        if (isSkipStep(instance, _step)) {
+            if (!judge && _step.step_type === 'sign') {
+                judge = 'approved';
+            }
+            rev_nextSteps = rev_nextSteps.concat(await UUFlowManager.getNextSteps(instance, flow, _step, judge));
+        } else {
+            rev_nextSteps.push(nextStepId);
+        }
+    }
+    
+    // Include steps with always_enter_step = false and their next steps
+    const flowVersion = await UUFlowManager.getFlowVersion(flow, instance.flow_version);
+    const flowVersionSteps = flowVersion.steps;
+    
+    for (const step of flowVersionSteps) {
+        if (step.always_enter_step === false) {
+            for (const line of step.lines) {
+                const toStepId = line.to_step;
+                rev_nextSteps.push(toStepId);
+                const toStep = await UUFlowManager.getStepFromSteps(flowVersionSteps, toStepId);
+                
+                if (toStep?.step_type === "condition") {
+                    for (const condLine of toStep.lines) {
+                        rev_nextSteps.push(condLine.to_step);
+                    }
+                }
+            }
+        }
+    }
+    
+    return _.uniq(rev_nextSteps);
+};
+
+/**
+ * Get updated values from instance
+ * @param {Object} instance - Instance object
+ * @param {String} approve_id - Approve ID (optional)
+ * @returns {Object} Updated values
+ */
+UUFlowManager.getUpdatedValues = function (instance, approve_id) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getUpdatedValues');
+    }
+    
+    // Get the newest approve
+    let trace_approve = null;
+    
+    for (const trace of instance.traces) {
+        if (trace.is_finished === false) {
+            if (approve_id) {
+                trace_approve = _.find(trace.approves, (approve) => approve._id === approve_id);
+            } else {
+                trace_approve = _.find(trace.approves, (approve) => 
+                    approve.is_finished === false && 
+                    approve.type !== 'cc' && 
+                    approve.type !== 'distribute'
+                );
+            }
+            break;
+        }
+    }
+    
+    // Get the newest values
+    let newest_values = null;
+    
+    if (!instance.values) {
+        newest_values = trace_approve?.values;
+    } else if (!trace_approve?.values) {
+        newest_values = instance.values;
+    } else {
+        newest_values = _.extend(_.clone(instance.values), trace_approve.values);
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getUpdatedValues');
+    }
+    
+    return newest_values;
+};
+
+/**
+ * Get form by ID
+ * @param {String} form_id - Form ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} Form object
+ * @throws {Error} If form not found
+ */
+UUFlowManager.getForm = async function (form_id, options = {}) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getForm');
+    }
+    
+    const formsCollection = await getCollection('forms');
+    const form = await formsCollection.findOne({_id: form_id}, options);
+    
+    if (!form) {
+        throw new Error('表单ID有误或此表单已经被删除');
+    }
+    
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getForm');
+    }
+    
+    return form;
+};
+
+/**
+ * Get form version
+ * @param {Object} form - Form object
+ * @param {String} form_version - Form version ID
+ * @returns {Object} Form version object
+ * @throws {Error} If version not found
+ */
+UUFlowManager.getFormVersion = function (form, form_version) {
+    let form_v = null;
+    
+    if (form_version === form.current._id) {
+        form_v = form.current;
+    } else {
+        form_v = _.find(form.historys, (form_h) => form_version === form_h._id);
+    }
+    
+    if (!form_v) {
+        throw new Error('未找到表单对应的版本');
+    }
+    
+    return form_v;
+};
+
+////////////////////////////////
+
+/**
+ * Get category by ID
+ * @param {String} category_id - Category ID
+ * @param {Object} options - MongoDB find options
+ * @returns {Object} Category object
+ */
+UUFlowManager.getCategory = async function (category_id, options = {}) {
+    const categoriesCollection = await getCollection('categories');
+    return await categoriesCollection.findOne({_id: category_id}, options);
+};
+
+/**
+ * Get instance name based on naming formula
+ * @param {Object} instance - Instance object
+ * @param {Object} vals - Form values (optional)
+ * @returns {String} Instance name
+ */
+UUFlowManager.getInstanceName = async function (instance, vals) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getInstanceName');
+    }
+
+    const default_value = `${instance.flow_name} ${instance.code}`.trim();
+    const form_id = instance.form;
+    const form_version = instance.form_version;
+    
+    // Get form and form version
+    const form = await UUFlowManager.getForm(form_id);
+    const form_v = await UUFlowManager.getFormVersion(form, form_version);
+    
+    // Return default name if no naming formula
+    if (!form_v.name_forumla) {
+        if (process.env.STEEDOS_DEBUG) {
+            console.timeEnd('UUFlowManager.getInstanceName');
+        }
+        return default_value;
+    }
+
+    // Prepare values for formula evaluation
+    const values = _.clone(vals || instance.values) || {};
+    const applicant = await WorkflowManager.getFormulaUserObject(instance.space, instance.applicant);
+    
+    // Add standard fields to values
+    values["applicant"] = applicant;
+    values["applicant_name"] = instance.applicant_name;
+    values["applicant_organization"] = instance.applicant_organization;
+    values["applicant_organization_fullname"] = instance.applicant_organization_fullname;
+    values["applicant_organization_name"] = instance.applicant_organization_name;
+    values["submit_date"] = moment(instance.submit_date).utcOffset(0, false).format("YYYY-MM-DD");
+
+    // Process select fields to show labels instead of values
+    if (form_v.fields) {
+        for (const field of form_v.fields) {
+            if (["select", "multiSelect", "radio"].includes(field.type)) {
+                const fieldOptions = field.options?.split("\n").map((n) => {
+                    const itemSplits = n.split(":");
+                    return {
+                        label: itemSplits[0],
+                        value: itemSplits[1] || n
+                    };
+                }) || [];
+
+                const value = values[field.code];
+                switch (field.type) {
+                    case 'select':
+                    case 'radio':
+                        const selectedOption = fieldOptions.find((item) => item.value == value);
+                        if (selectedOption) {
+                            values[field.code] = selectedOption.label;
+                        }
+                        break;
+                    case 'multiSelect':
+                        const splitedValues = typeof value === 'string' ? value.split(",") : value;
+                        if (Array.isArray(splitedValues)) {
+                            const selectedOptions = fieldOptions.filter((item) => splitedValues.includes(item.value));
+                            if (selectedOptions.length) {
+                                values[field.code] = selectedOptions.map((item) => item.label).join(",");
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+    }
+
+    let rev = default_value;
+    if (form_v.name_forumla) {
+        try {
+            // Prepare the formula script
+            let iscript = form_v.name_forumla;
+            if (iscript.includes("{applicant.")) {
+                iscript = iscript.replace(/\{applicant./g, "(applicant.").replace(/\}/g, " || '')");
+            }
+            iscript = iscript.replace(/\{/g, "(values.").replace(/\}/g, " || '')");
+
+            // Create and evaluate the naming function
+            const script = `module.exports = function (applicant, values, flow, form) { return ${iscript} }`;
+            const func = _eval(script, "getInstanceName");
+            rev = func(applicant, values, null, form) || default_value;
+            
+            // Remove special characters from the name
+            rev = rev.replace(/\?|\*|\:|\"|\<|\>|\\|\/|\|/g, "");
+        } catch (error) {
+            console.error('Error evaluating instance name formula:', error);
+        }
+    }
+
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getInstanceName');
+    }
+
+    return rev.trim();
+};
+
+/**
+ * Filter approve values based on permissions
+ * @param {Object} approve_values - Approve values
+ * @param {Object} permissions - Permissions object
+ * @param {String} form_id - Form ID
+ * @param {String} form_version - Form version ID
+ * @returns {Object} Filtered approve values
+ */
+UUFlowManager.getApproveValues = async function (approve_values, permissions, form_id, form_version) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('UUFlowManager.getApproveValues');
+    }
+
+    // Return empty object if no permissions
+    if (permissions === null) {
+        if (process.env.STEEDOS_DEBUG) {
+            console.timeEnd('UUFlowManager.getApproveValues');
+        }
+        return {};
+    }
+
+    // Get form and form version
+    const form = await UUFlowManager.getForm(form_id);
+    const form_v = await UUFlowManager.getFormVersion(form, form_version);
+
+    // Filter fields based on permissions
+    for (const field of form_v.fields || []) {
+        if (field.type === "section") {
+            // Handle section fields
+            for (const sectionField of field.fields || []) {
+                if (!sectionField.formula && (permissions[sectionField.code] === null || permissions[sectionField.code] !== "editable")) {
+                    delete approve_values[sectionField.code];
+                }
+            }
+        } else if (!field.formula && (permissions[field.code] === null || permissions[field.code] !== "editable")) {
+            // Handle regular fields
+            delete approve_values[field.code];
+        }
+    }
+
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('UUFlowManager.getApproveValues');
+    }
+
+    return approve_values;
+};
+
+/**
+ * Main workflow engine function
+ * @param {Object} approve_from_client - Approve data from client
+ * @param {Object} current_user_info - Current user info
+ * @param {String} current_user - Current user ID
+ * @param {Boolean} auto_submitted - If the action was auto-submitted
+ * @returns {Object} Updated instance
+ */
+UUFlowManager.workflow_engine = async function (approve_from_client, current_user_info, current_user, auto_submitted = false) {
+    // Extract data from approve_from_client
+    const {
+        instance: instance_id,
+        trace: trace_id,
+        _id: approve_id,
+        values = {},
+        next_steps,
+        judge,
+        description,
+        geolocation
+    } = approve_from_client;
+
+    // Get instance, space, flow and related data
+    const instance = await UUFlowManager.getInstance(instance_id);
+    const space_id = instance.space;
+    const flow_id = instance.flow;
+    const space = await UUFlowManager.getSpace(space_id);
+    const applicant_id = instance.applicant;
+    const flow = await UUFlowManager.getFlow(flow_id);
+    const space_user = await UUFlowManager.getSpaceUser(space_id, current_user);
+    const space_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(space_user);
+    const trace = await UUFlowManager.getTrace(instance, trace_id);
+    const approve = await UUFlowManager.getApprove(trace, approve_id);
+
+    // Validate instance state and permissions
+    UUFlowManager.isTraceNotFinished(trace);
+    UUFlowManager.isApproveNotFinished(approve);
+    UUFlowManager.isInstancePending(instance);
+    UUFlowManager.isHandlerOrAgent(approve, current_user);
+
+    // Get current step info
+    const step = await UUFlowManager.getStep(instance, flow, trace.step);
+    const step_type = step.step_type;
+    const instance_trace = _.find(instance.traces, (t) => t._id === trace_id);
+    const trace_approves = instance_trace.approves;
+
+    // Prepare update object for temporary save
+    const setObj = {};
+    let key_str = "";
+
+    // Find the approve to update
+    for (let i = 0; i < trace_approves.length; i++) {
+        if (trace_approves[i]._id === approve_id) {
+            key_str = `traces.$.approves.${i}.`;
+            setObj[`${key_str}geolocation`] = geolocation;
+
+            // Set judge and description based on step type
+            if (["start", "submit"].includes(step_type)) {
+                setObj[`${key_str}judge`] = "submitted";
+                setObj[`${key_str}description`] = description;
+            } else if (["sign", "counterSign"].includes(step_type)) {
+                // For counterSign without judge, default to 'submitted'
+                if (step_type === "counterSign" && !judge) {
+                    judge = 'submitted';
+                }
+                UUFlowManager.isJudgeLegal(judge);
+                setObj[`${key_str}judge`] = judge;
+                setObj[`${key_str}description`] = description;
+            }
+
+            // Set common fields
+            setObj[`${key_str}next_steps`] = next_steps;
+            setObj[`${key_str}is_read`] = true;
+            if (!trace_approves[i].read_date) {
+                setObj[`${key_str}read_date`] = new Date();
+            }
+
+            // Filter approve values based on permissions
+            setObj[`${key_str}values`] = await UUFlowManager.getApproveValues(
+                values, 
+                step.permissions, 
+                instance.form, 
+                instance.form_version
+            );
+
+            // Set modified info
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+
+            // Update instance
+            const instancesCollection = await getCollection('instances');
+            await instancesCollection.updateOne(
+                { _id: instance_id, "traces._id": trace_id },
+                { $set: setObj }
+            );
+
+            // Update instance tasks
+            await update_instance_tasks(instance_id, trace_id, approve_id);
+            break;
+        }
+    }
+
+    // Reload instance and revalidate after update
+    const updatedInstance = await UUFlowManager.getInstance(instance_id);
+    const updatedTrace = await UUFlowManager.getTrace(updatedInstance, trace_id);
+    const updatedApprove = await UUFlowManager.getApprove(updatedTrace, approve_id);
+
+    UUFlowManager.isTraceNotFinished(updatedTrace);
+    UUFlowManager.isApproveNotFinished(updatedApprove);
+    UUFlowManager.isInstancePending(updatedInstance);
+    UUFlowManager.isHandlerOrAgent(updatedApprove, current_user);
+
+    // Prepare final update object
+    const updateObj = { $set: {} };
+
+    // Validate next steps
+    if (!next_steps || next_steps.length === 0) {
+        throw new Error('还未指定下一步和处理人，操作失败');
+    }
+
+    if (next_steps.length > 1) {
+        throw new Error('不能指定多个后续步骤');
+    }
+
+    // Validate next step users
+    for (const next_step_user of next_steps[0].users || []) {
+        await UUFlowManager.getSpaceUser(space_id, next_step_user);
+    }
+
+    // Handle different step types
+    if (["start", "submit", "condition"].includes(step_type)) {
+        Object.assign(updateObj, await UUFlowManager.engine_step_type_is_start_or_submit_or_condition(
+            instance_id, trace_id, approve_id, next_steps, 
+            space_user_org_info, judge, updatedInstance, flow, step, 
+            current_user, current_user_info, auto_submitted
+        ));
+    } else if (step_type === "sign") {
+        Object.assign(updateObj, await UUFlowManager.engine_step_type_is_sign(
+            instance_id, trace_id, approve_id, next_steps, 
+            space_user_org_info, judge, updatedInstance, flow, step, 
+            current_user, current_user_info, description, auto_submitted
+        ));
+    } else if (step_type === "counterSign") {
+        Object.assign(updateObj, await UUFlowManager.engine_step_type_is_counterSign(
+            instance_id, trace_id, approve_id, next_steps, 
+            space_user_org_info, judge, updatedInstance, flow, step, 
+            current_user, current_user_info, auto_submitted
+        ));
+    } else if (step_type === "end") {
+        throw new Error('end结点出现approve，服务器错误');
+    }
+
+    // Calculate keywords and extras
+    const form = await UUFlowManager.getForm(updatedInstance.form);
+    updateObj.$set.keywords = await UUFlowManager.caculateKeywords(updateObj.$set.values, form, updatedInstance.form_version);
+    updateObj.$set.extras = await UUFlowManager.caculateExtras(updateObj.$set.values, form, updatedInstance.form_version);
+
+    // Update instance
+    const instancesCollection = await getCollection('instances');
+    await instancesCollection.updateOne({ _id: instance_id }, updateObj);
+
+    // Insert new instance tasks if needed
+    if (updateObj.$push?.traces?.approves) {
+        const newTrace = updateObj.$push.traces;
+        const approveIds = newTrace.approves.map(a => a._id);
+        await insert_many_instance_tasks(instance_id, newTrace._id, approveIds);
+    }
+
+    // Get final updated instance
+    const finalInstance = await UUFlowManager.getInstance(instance_id);
+    const finalInstanceTrace = _.find(finalInstance.traces, t => t._id === trace_id);
+    const next_step_id = next_steps[0].step;
+    const next_step = await UUFlowManager.getStep(finalInstance, flow, next_step_id);
+    const next_step_type = next_step.step_type;
+
+    // Send notifications based on instance state
+    if (finalInstance.state === "completed") {
+        if (finalInstance.final_decision === "approved") {
+            await pushManager.send_instance_notification("approved_completed_applicant", finalInstance, description, current_user_info);
+        } else if (finalInstance.final_decision === "rejected") {
+            await pushManager.send_instance_notification("rejected_completed_applicant", finalInstance, description, current_user_info);
+        } else {
+            await pushManager.send_instance_notification("submit_completed_applicant", finalInstance, description, current_user_info);
+        }
+    } else if (finalInstance.state === "pending") {
+        if (finalInstanceTrace.judge === "rejected" && finalInstanceTrace.is_finished === true) {
+            if (next_step_type === 'start') {
+                await pushManager.send_instance_notification("submit_pending_rejected_applicant_inbox", finalInstance, description, current_user_info);
+            } else {
+                await pushManager.send_instance_notification("submit_pending_rejected_applicant", finalInstance, description, current_user_info);
+                await pushManager.send_instance_notification("submit_pending_rejected_inbox", finalInstance, description, current_user_info);
+            }
+        } else if (!finalInstanceTrace.is_finished) {
+            // Do nothing for unfinished traces
+        } else {
+            await pushManager.send_instance_notification("submit_pending_inbox", finalInstance, description, current_user_info);
+        }
+    }
+
+    // Send message to current user and trigger webhook
+    await pushManager.send_message_current_user(current_user_info);
+    
+    let to_users = finalInstance.inbox_users;
+    const last_trace = _.last(finalInstance.traces);
+    const last_step = await UUFlowManager.getStep(finalInstance, flow, last_trace.step);
+    
+    if (last_step.step_type === "counterSign" && _.where(last_trace.approves, { is_finished: true }).length > 0) {
+        to_users = [];
+    }
+    
+    await pushManager.triggerWebhook(flow_id, finalInstance, approve_from_client, 'engine_submit', current_user, to_users);
+    await UUFlowManager.distributedInstancesRemind(finalInstance);
+
+    return finalInstance;
+};
+
+/**
+ * Handle workflow engine for start/submit/condition steps
+ * @param {String} instance_id - Instance ID
+ * @param {String} trace_id - Trace ID
+ * @param {String} approve_id - Approve ID
+ * @param {Array} next_steps - Next steps data
+ * @param {Object} space_user_org_info - Space user org info
+ * @param {String} judge - Judge value
+ * @param {Object} instance - Instance object
+ * @param {Object} flow - Flow object
+ * @param {Object} step - Current step object
+ * @param {String} current_user - Current user ID
+ * @param {Object} current_user_info - Current user info
+ * @param {Boolean} auto_submitted - If auto-submitted
+ * @returns {Object} Update object
+ */
+UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function (
+    instance_id, trace_id, approve_id, next_steps, 
+    space_user_org_info, judge, instance, flow, step, 
+    current_user, current_user_info, auto_submitted
+) {
+    const setObj = {};
+    const updateObj = {};
+    const setTraceObj = {};
+    const space_id = instance.space;
+
+    // Validate next steps
+    const nextSteps = await UUFlowManager.getNextSteps(instance, flow, step, "");
+    for (const approve_next_step of next_steps) {
+        if (!nextSteps.includes(approve_next_step.step)) {
+            throw new Error(`approve中next_steps.step：${approve_next_step.step} 不合法`);
+        }
+    }
+
+    // Get next step info
+    const next_step_id = next_steps[0].step;
+    const next_step = await UUFlowManager.getStep(instance, flow, next_step_id);
+    const next_step_type = next_step.step_type;
+    const next_step_name = next_step.name;
+
+    // Handle end step
+    if (next_step_type === "end") {
+        const instance_traces = instance.traces;
+        
+        // Update current trace and approve
+        for (let i = 0; i < instance_traces.length; i++) {
+            if (instance_traces[i]._id === trace_id) {
+                setTraceObj[`traces.${i}.is_finished`] = true;
+                setTraceObj[`traces.${i}.finish_date`] = new Date();
+                setTraceObj[`traces.${i}.judge`] = judge;
+
+                for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                    if (instance_traces[i].approves[h]._id === approve_id) {
+                        const approveFinishDate = new Date();
+                        setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                        setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                        setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info.organization;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info.organization_name;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info.organization_fullname;
+                        setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                        setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+
+        // Create new trace for end step
+        const newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [trace_id],
+            is_finished: true,
+            step: next_step_id,
+            name: next_step_name,
+            start_date: new Date(),
+            finish_date: new Date()
+        };
+
+        // Prepare instance update
+        setObj.state = "completed";
+        setObj.modified = new Date();
+        setObj.modified_by = current_user;
+        setObj.values = await UUFlowManager.getUpdatedValues(instance);
+        setObj.name = await UUFlowManager.getInstanceName(instance);
+        
+        const instance_trace = _.find(instance.traces, t => t._id === trace_id);
+        const trace_approve = _.find(instance_trace.approves, a => a._id === approve_id);
+        
+        updateObj.$addToSet = {
+            outbox_users: {
+                $each: [trace_approve.handler, trace_approve.user]
+            }
+        };
+        updateObj.$push = { traces: newTrace };
+        
+        setObj.inbox_users = [];
+        setObj.finish_date = new Date();
+        setObj.current_step_name = next_step_name;
+        setObj.final_decision = 'approved';
+        setObj.current_step_auto_submit = false;
+    } else {
+        // Handle non-end steps
+        const next_step_users = next_steps[0].users;
+        
+        if (!next_step_users || next_step_users.length === 0) {
+            throw new Error("未指定下一步处理人");
+        }
+        
+        if (next_step_users.length > 1 && next_step.step_type !== "counterSign") {
+            throw new Error("不能指定多个处理人");
+        }
+        
+        // Validate next users
+        const next_user_ids = await HandlersManager.getHandlers(instance_id, next_step_id, current_user);
+        if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, next_user_ids, next_step)) {
+            throw new Error("指定的下一步处理人有误");
+        }
+
+        // Update current trace and approve
+        const instance_traces = instance.traces;
+        for (let i = 0; i < instance_traces.length; i++) {
+            if (instance_traces[i]._id === trace_id) {
+                setTraceObj[`traces.${i}.is_finished`] = true;
+                setTraceObj[`traces.${i}.finish_date`] = new Date();
+                setTraceObj[`traces.${i}.judge`] = judge;
+
+                for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                    if (instance_traces[i].approves[h]._id === approve_id) {
+                        const approveFinishDate = new Date();
+                        setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                        setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                        setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info.organization;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info.organization_name;
+                        setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info.organization_fullname;
+                        setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                        setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+
+        // Create new trace for next step
+        const newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [trace_id],
+            is_finished: false,
+            step: next_step_id,
+            name: next_step_name,
+            start_date: new Date(),
+            due_date: UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+            approves: []
+        };
+
+        // Add approves for next step users
+        const updated_values = await UUFlowManager.getUpdatedValues(instance);
+        const usersCollection = await getCollection('users');
+        const spaceUsersCollection = await getCollection('space_users');
+
+        for (let idx = 0; idx < next_step_users.length; idx++) {
+            const next_step_user_id = next_step_users[idx];
+            const user_info = await usersCollection.findOne(
+                { _id: next_step_user_id },
+                { projection: { name: 1 } }
+            );
+
+            const newApprove = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                trace: newTrace._id,
+                is_finished: false,
+                user: next_step_user_id,
+                user_name: user_info.name
+            };
+
+            // Check for agent
+            let handler_id = next_step_user_id;
+            let handler_info = user_info;
+            const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+
+            if (agent) {
+                next_step_users[idx] = agent;
+                handler_id = agent;
+                handler_info = await usersCollection.findOne(
+                    { _id: agent },
+                    { projection: { name: 1 } }
+                );
+                newApprove.agent = agent;
+            }
+
+            newApprove.handler = handler_id;
+            newApprove.handler_name = handler_info.name;
+
+            const next_step_space_user = await spaceUsersCollection.findOne({
+                space: space_id,
+                user: handler_id
+            });
+
+            const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+            
+            newApprove.handler_organization = next_step_user_org_info.organization;
+            newApprove.handler_organization_name = next_step_user_org_info.organization_name;
+            newApprove.handler_organization_fullname = next_step_user_org_info.organization_fullname;
+            newApprove.start_date = new Date();
+            newApprove.due_date = newTrace.due_date;
+            newApprove.is_read = false;
+            newApprove.is_error = false;
+            newApprove.values = {};
+
+            UUFlowManager.setRemindInfo(updated_values, newApprove);
+            newTrace.approves.push(newApprove);
+        }
+
+        // Prepare instance update
+        setObj.state = "pending";
+        setObj.modified = new Date();
+        setObj.modified_by = current_user;
+        setObj.values = updated_values;
+        setObj.name = await UUFlowManager.getInstanceName(instance);
+        
+        const instance_trace = _.find(instance.traces, t => t._id === trace_id);
+        const trace_approve = _.find(instance_trace.approves, a => a._id === approve_id);
+        
+        updateObj.$addToSet = {
+            outbox_users: {
+                $each: [trace_approve.handler, trace_approve.user]
+            }
+        };
+        
+        setObj.inbox_users = next_step_users;
+        updateObj.$push = { traces: newTrace };
+        setObj.current_step_name = next_step_name;
+        setObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+    }
+
+    // Apply trace updates
+    const instancesCollection = await getCollection('instances');
+    await instancesCollection.updateOne(
+        { _id: instance_id },
+        { $set: setTraceObj }
+    );
+
+    // Update instance tasks
+    await update_instance_tasks(instance_id, trace_id, approve_id);
+
+    // Combine all updates
+    updateObj.$set = setObj;
+    return updateObj;
+};
+
+/////////////
+UUFlowManager.engine_step_type_is_sign = async function (
+    instance_id, 
+    trace_id, 
+    approve_id, 
+    next_steps, 
+    space_user_org_info, 
+    judge, 
+    instance, 
+    flow, 
+    step, 
+    current_user, 
+    current_user_info, 
+    description, 
+    auto_submitted
+) {
+    const db = {
+        instances: await getCollection('instances'),
+        users: await getCollection('users'),
+        space_users: await getCollection('space_users')
+    };
+
+    let updateObj = {};
+    let setObj = {};
+    let setTraceObj = {};
+    const space_id = instance.space;
+
+    // 验证approve的judge是否为空
+    if (!judge) {
+        throw new Error('单签结点还未选择处理意见，操作失败');
+    }
+
+    if (judge === "approved") {
+        // 验证next_steps.step是否合法,判断next_steps.step是否在其中
+        const nextSteps = await UUFlowManager.getNextSteps(instance, flow, step, "approved");
+        
+        // 判断next_steps.step是否在nextSteps中,若不在则不合法
+        next_steps.forEach(approve_next_step => {
+            if (!nextSteps.includes(approve_next_step["step"])) {
+                throw new Error('指定的下一步有误');
+            }
+        });
+
+        // 若合法,执行流转
+        const next_step_id = next_steps[0]["step"];
+        const next_step = await UUFlowManager.getStep(instance, flow, next_step_id);
+        const next_step_type = next_step["step_type"];
+        const next_step_name = next_step["name"];
+
+        // 判断next_step是否为结束结点
+        if (next_step_type === "end") {
+            // 若是结束结点
+            const instance_traces = instance.traces;
+            
+            for (let i = 0; i < instance_traces.length; i++) {
+                if (instance_traces[i]._id === trace_id) {
+                    // 更新当前trace记录
+                    setTraceObj[`traces.${i}.is_finished`] = true;
+                    setTraceObj[`traces.${i}.finish_date`] = new Date();
+                    setTraceObj[`traces.${i}.judge`] = judge;
+                    
+                    for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                        if (instance_traces[i].approves[h]._id === approve_id) {
+                            // 更新当前trace.approve记录
+                            const approveFinishDate = new Date();
+                            setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                            setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                            setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info["organization"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info["organization_name"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info["organization_fullname"];
+                            setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                            setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        }
+                    }
+                }
+            }
+
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: true,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                finish_date: new Date()
+            };
+
+            // 更新instance记录
+            setObj.state = "completed";
+            setObj.final_decision = judge;
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            setObj.values = await UUFlowManager.getUpdatedValues(instance);
+            instance.values = setObj.values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.inbox_users = [];
+            setObj.finish_date = new Date();
+            setObj.current_step_name = next_step_name;
+            setObj.current_step_auto_submit = false;
+        } else {
+            // 若不是结束结点
+            // 先判断nextsteps.step.users是否为空
+            const next_step_users = next_steps[0]["users"];
+            
+            if (!next_step_users || next_step_users.length === 0) {
+                throw new Error('未指定下一步处理人');
+            }
+            
+            if (next_step_users.length > 1 && next_step["step_type"] !== "counterSign") {
+                throw new Error('不能指定多个处理人');
+            }
+            
+            // 验证next_user是否合法
+            const next_user_ids = await HandlersManager.getHandlers(instance_id, next_step_id, current_user);
+            
+            if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, next_user_ids, next_step)) {
+                throw new Error('指定的下一步处理人有误');
+            }
+            
+            // 若合法，执行流转操作
+            const instance_traces = instance.traces;
+            
+            for (let i = 0; i < instance_traces.length; i++) {
+                if (instance_traces[i]._id === trace_id) {
+                    // 更新当前trace记录
+                    setTraceObj[`traces.${i}.is_finished`] = true;
+                    setTraceObj[`traces.${i}.finish_date`] = new Date();
+                    setTraceObj[`traces.${i}.judge`] = judge;
+                    
+                    for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                        if (instance_traces[i].approves[h]._id === approve_id) {
+                            // 更新当前trace.approve记录
+                            const approveFinishDate = new Date();
+                            setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                            setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                            setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info["organization"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info["organization_name"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info["organization_fullname"];
+                            setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                            setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        }
+                    }
+                }
+            }
+
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: false,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                due_date: UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+                approves: []
+            };
+
+            const updated_values = await UUFlowManager.getUpdatedValues(instance);
+            
+            for (let idx = 0; idx < next_step_users.length; idx++) {
+                const next_step_user_id = next_step_users[idx];
+                // 插入下一步trace.approve记录
+                const newApprove = {
+                    _id: _makeNewID(),
+                    instance: instance_id,
+                    trace: newTrace._id,
+                    is_finished: false,
+                    user: next_step_user_id
+                };
+
+                const user_info = await db.users.findOne(
+                    { _id: next_step_user_id },
+                    { fields: { name: 1 } }
+                );
+                
+                newApprove.user_name = user_info.name;
+                let handler_id = next_step_user_id;
+                let handler_info = user_info;
+                
+                const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+                if (agent) {
+                    next_step_users[idx] = agent;
+                    handler_id = agent;
+                    handler_info = await db.users.findOne(
+                        { _id: agent },
+                        { fields: { name: 1 } }
+                    );
+                    newApprove.agent = agent;
+                }
+                
+                newApprove.handler = handler_id;
+                newApprove.handler_name = handler_info.name;
+                
+                const next_step_space_user = await db.space_users.findOne({
+                    space: space_id,
+                    user: handler_id
+                });
+                
+                // 获取next_step_user所在的部门信息
+                const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                newApprove.handler_organization = next_step_user_org_info["organization"];
+                newApprove.handler_organization_name = next_step_user_org_info["organization_name"];
+                newApprove.handler_organization_fullname = next_step_user_org_info["organization_fullname"];
+                newApprove.start_date = new Date();
+                newApprove.due_date = newTrace.due_date;
+                newApprove.is_read = false;
+                newApprove.is_error = false;
+                newApprove.values = {};
+                
+                UUFlowManager.setRemindInfo(updated_values, newApprove);
+                newTrace.approves.push(newApprove);
+            }
+
+            // 更新instance记录
+            setObj.final_decision = judge;
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            setObj.values = updated_values;
+            instance.values = setObj.values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            setObj.inbox_users = next_step_users;
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.state = "pending";
+            setObj.current_step_name = next_step_name;
+            setObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+        }
+    } else if (judge === "rejected") {
+        if (!description) {
+            throw new Error('请填写驳回理由');
+        }
+
+        // 验证next_steps.step是否合法,判断next_steps.step是否在其中
+        const nextSteps = await UUFlowManager.getNextSteps(instance, flow, step, "rejected");
+        
+        // 判断next_steps.step是否在nextSteps中,若不在则不合法
+        next_steps.forEach(approve_next_step => {
+            if (!nextSteps.includes(approve_next_step["step"])) {
+                throw new Error('指定的下一步有误');
+            }
+        });
+
+        // 若合法,执行流转
+        const next_step_id = next_steps[0]["step"];
+        const next_step = await UUFlowManager.getStep(instance, flow, next_step_id);
+        const next_step_type = next_step["step_type"];
+        const next_step_name = next_step["name"];
+
+        // 判断next_step是否为结束结点
+        if (next_step_type === "end") {
+            // 若是结束结点
+            const instance_traces = instance.traces;
+            
+            for (let i = 0; i < instance_traces.length; i++) {
+                if (instance_traces[i]._id === trace_id) {
+                    // 更新当前trace记录
+                    setTraceObj[`traces.${i}.is_finished`] = true;
+                    setTraceObj[`traces.${i}.finish_date`] = new Date();
+                    setTraceObj[`traces.${i}.judge`] = judge;
+                    
+                    for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                        if (instance_traces[i].approves[h]._id === approve_id) {
+                            // 更新当前trace.approve记录
+                            const approveFinishDate = new Date();
+                            setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                            setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                            setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info["organization"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info["organization_name"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info["organization_fullname"];
+                            setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                            setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        }
+                    }
+                }
+            }
+
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: true,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                finish_date: new Date()
+            };
+
+            // 更新instance记录
+            setObj.state = "completed";
+            setObj.final_decision = judge;
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            setObj.values = await UUFlowManager.getUpdatedValues(instance);
+            instance.values = setObj.values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.inbox_users = [];
+            setObj.finish_date = new Date();
+            setObj.current_step_name = next_step_name;
+            setObj.current_step_auto_submit = false;
+        } else {
+            // 若不是结束结点
+            // 先判断nextsteps.step.users是否为空
+            const next_step_users = next_steps[0]["users"];
+            
+            if (!next_step_users || next_step_users.length === 0) {
+                throw new Error('未指定下一步处理人');
+            }
+            
+            if (next_step_users.length > 1 && next_step["step_type"] !== "counterSign") {
+                throw new Error('不能指定多个处理人');
+            }
+            
+            // 验证next_user是否合法
+            const next_user_ids = await HandlersManager.getHandlers(instance_id, next_step_id, current_user);
+            
+            if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, next_user_ids, next_step)) {
+                throw new Error('指定的下一步处理人有误');
+            }
+            
+            // 若合法，执行流转操作
+            const instance_traces = instance.traces;
+            
+            for (let i = 0; i < instance_traces.length; i++) {
+                if (instance_traces[i]._id === trace_id) {
+                    // 更新当前trace记录
+                    setTraceObj[`traces.${i}.is_finished`] = true;
+                    setTraceObj[`traces.${i}.finish_date`] = new Date();
+                    setTraceObj[`traces.${i}.judge`] = judge;
+                    
+                    for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                        if (instance_traces[i].approves[h]._id === approve_id) {
+                            // 更新当前trace.approve记录
+                            const approveFinishDate = new Date();
+                            setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                            setTraceObj[`traces.${i}.approves.${h}.handler`] = current_user;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_name`] = current_user_info.name;
+                            setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization`] = space_user_org_info["organization"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_name`] = space_user_org_info["organization_name"];
+                            setTraceObj[`traces.${i}.approves.${h}.handler_organization_fullname`] = space_user_org_info["organization_fullname"];
+                            setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                            setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        }
+                    }
+                }
+            }
+
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: false,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                due_date: UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+                approves: []
+            };
+
+            const updated_values = await UUFlowManager.getUpdatedValues(instance);
+            
+            for (let idx = 0; idx < next_step_users.length; idx++) {
+                const next_step_user_id = next_step_users[idx];
+                // 插入下一步trace.approve记录
+                const newApprove = {
+                    _id: _makeNewID(),
+                    instance: instance_id,
+                    trace: newTrace._id,
+                    is_finished: false,
+                    user: next_step_user_id
+                };
+
+                const user_info = await db.users.findOne(
+                    { _id: next_step_user_id },
+                    { fields: { name: 1 } }
+                );
+                
+                newApprove.user_name = user_info.name;
+                let handler_id = next_step_user_id;
+                let handler_info = user_info;
+                
+                const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+                if (agent) {
+                    next_step_users[idx] = agent;
+                    handler_id = agent;
+                    handler_info = await db.users.findOne(
+                        { _id: agent },
+                        { fields: { name: 1 } }
+                    );
+                    newApprove.agent = agent;
+                }
+                
+                newApprove.handler = handler_id;
+                newApprove.handler_name = handler_info.name;
+                
+                const next_step_space_user = await db.space_users.findOne({
+                    space: space_id,
+                    user: handler_id
+                });
+                
+                // 获取next_step_user所在的部门信息
+                const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                newApprove.handler_organization = next_step_user_org_info["organization"];
+                newApprove.handler_organization_name = next_step_user_org_info["organization_name"];
+                newApprove.handler_organization_fullname = next_step_user_org_info["organization_fullname"];
+                newApprove.start_date = new Date();
+                newApprove.due_date = newTrace.due_date;
+                newApprove.is_read = false;
+                newApprove.is_error = false;
+                newApprove.values = {};
+                
+                UUFlowManager.setRemindInfo(updated_values, newApprove);
+                newTrace.approves.push(newApprove);
+            }
+
+            // 更新instance记录
+            setObj.final_decision = judge;
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            setObj.values = updated_values;
+            instance.values = setObj.values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            setObj.inbox_users = next_step_users;
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.state = "pending";
+            setObj.current_step_name = next_step_name;
+            setObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+        }
+    }
+
+    await db.instances.update({_id: instance_id}, { $set: setTraceObj });
+    // 更新instance_tasks
+    await update_instance_tasks(instance_id, trace_id, approve_id);
+    
+    updateObj.$set = setObj;
+    return updateObj;
+};
+////////////
+UUFlowManager.engine_step_type_is_counterSign = async function (
+    instance_id,
+    trace_id,
+    approve_id,
+    next_steps,
+    space_user_org_info,
+    judge,
+    instance,
+    flow,
+    step,
+    current_user,
+    current_user_info,
+    auto_submitted
+) {
+    const db = {
+        instances: await getCollection('instances'),
+        users: await getCollection('users'),
+        space_users: await getCollection('space_users')
+    };
+
+    let setObj = {};
+    let updateObj = {};
+    let setTraceObj = {};
+    const space_id = instance.space;
+    const finishedApproveIds = [];
+
+    // 验证approve的judge是否为空
+    if (!judge) {
+        throw new Error('请选择核准或驳回。');
+    }
+
+    if (step.oneClickApproval && ['approved', 'readed'].includes(judge)) {
+        // 验证next_steps.step是否合法,判断next_steps.step是否在其中
+        const nextSteps = await UUFlowManager.getNextSteps(instance, flow, step, "approved");
+        // 判断next_steps.step是否在nextSteps中,若不在则不合法
+        next_steps.forEach(approve_next_step => {
+            if (!nextSteps.includes(approve_next_step["step"])) {
+                throw new Error('指定的下一步有误');
+            }
+        });
+    }
+
+    // 若合法,执行流转
+    const next_step_id = next_steps[0]["step"];
+    const next_step = await UUFlowManager.getStep(instance, flow, next_step_id);
+    const next_step_type = next_step["step_type"];
+    const next_step_name = next_step["name"];
+    const instance_traces = instance.traces;
+    let isAllApproveFinished = true;
+
+    for (let i = 0; i < instance_traces.length; i++) {
+        if (instance_traces[i]._id === trace_id) {
+            for (let h = 0; h < instance_traces[i].approves.length; h++) {
+                if (instance_traces[i].approves[h].type !== 'cc' && instance_traces[i].approves[h].type !== 'distribute') {
+                    if (instance_traces[i].approves[h]._id === approve_id || 
+                        ((step.oneClickApproval && ['approved', 'readed'].includes(judge)) || 
+                        (step.oneClickRejection && 'rejected' === judge))) {
+                        // 更新当前trace.approve记录
+                        const approveFinishDate = new Date();
+                        setTraceObj[`traces.${i}.approves.${h}.is_finished`] = true;
+                        setTraceObj[`traces.${i}.approves.${h}.finish_date`] = approveFinishDate;
+                        setTraceObj[`traces.${i}.approves.${h}.cost_time`] = approveFinishDate - instance_traces[i].approves[h].start_date;
+                        setTraceObj[`traces.${i}.approves.${h}.auto_submitted`] = auto_submitted;
+                        finishedApproveIds.push(instance_traces[i].approves[h]._id);
+                    }
+                    else if (instance_traces[i].approves[h].is_finished === false) {
+                        isAllApproveFinished = false;
+                    }
+                }
+            }
+        }
+    }
+
+    if (isAllApproveFinished === true) {
+        for (let i = 0; i < instance_traces.length; i++) {
+            if (instance_traces[i]._id === trace_id) {
+                // 更新当前trace记录
+                setTraceObj[`traces.${i}.is_finished`] = true;
+                setTraceObj[`traces.${i}.finish_date`] = new Date();
+                setTraceObj[`traces.${i}.judge`] = "submitted";
+            }
+        }
+
+        // 判断next_step是否为结束结点
+        if (next_step_type === "end") {
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: true,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                finish_date: new Date()
+            };
+
+            // 更新instance记录
+            setObj.state = "completed";
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            setObj.inbox_users = [];
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.finish_date = new Date();
+            const updated_values = await UUFlowManager.getUpdatedValues(await UUFlowManager.getInstance(instance_id), approve_id);
+            setObj.values = updated_values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            setObj.current_step_name = next_step_name;
+            
+            let final_decision = '';
+            if (step.oneClickApproval && ['approved', 'readed'].includes(judge)) {
+                // 如果开启了一键核准并且选择了核准则设置final_decision为approved
+                final_decision = 'approved';
+            } else if (step.oneClickRejection && 'rejected' === judge) {
+                // 如果开启了一键驳回并且选择了驳回则设置final_decision为rejected
+                final_decision = 'rejected';
+            }
+            
+            setObj.final_decision = final_decision || 'approved'; // 会签到结束默认为approved
+            setObj.current_step_auto_submit = false;
+        } else {
+            // 若不是结束结点
+            // 先判断nextsteps.step.users是否为空
+            const next_step_users = next_steps[0]["users"];
+            
+            if (!next_step_users || next_step_users.length === 0) {
+                throw new Error('未指定下一步处理人');
+            }
+            
+            if (next_step_users.length > 1 && next_step["step_type"] !== "counterSign") {
+                throw new Error('不能指定多个处理人');
+            }
+            
+            // 验证next_user是否合法
+            const next_user_ids = await HandlersManager.getHandlers(instance_id, next_step_id, current_user);
+            
+            if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, next_user_ids, next_steps)) {
+                throw new Error('指定的下一步处理人有误');
+            }
+            
+            // 插入下一步trace记录
+            const newTrace = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                previous_trace_ids: [trace_id],
+                is_finished: false,
+                step: next_step_id,
+                name: next_step_name,
+                start_date: new Date(),
+                due_date: UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+                approves: []
+            };
+
+            for (let idx = 0; idx < next_step_users.length; idx++) {
+                const next_step_user_id = next_step_users[idx];
+                // 插入下一步trace.approve记录
+                const newApprove = {
+                    _id: _makeNewID(),
+                    instance: instance_id,
+                    trace: newTrace._id,
+                    is_finished: false,
+                    user: next_step_user_id
+                };
+
+                const user_info = await db.users.findOne(
+                    { _id: next_step_user_id },
+                    { fields: { name: 1 } }
+                );
+                
+                newApprove.user_name = user_info.name;
+                let handler_id = next_step_user_id;
+                let handler_info = user_info;
+                
+                const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+                if (agent) {
+                    next_step_users[idx] = agent;
+                    handler_id = agent;
+                    handler_info = await db.users.findOne(
+                        { _id: agent },
+                        { fields: { name: 1 } }
+                    );
+                    newApprove.agent = agent;
+                }
+                
+                newApprove.handler = handler_id;
+                newApprove.handler_name = handler_info.name;
+                
+                const next_step_space_user = await db.space_users.findOne({
+                    space: space_id,
+                    user: handler_id
+                });
+                
+                // 获取next_step_user所在的部门信息
+                const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                newApprove.handler_organization = next_step_user_org_info["organization"];
+                newApprove.handler_organization_name = next_step_user_org_info["organization_name"];
+                newApprove.handler_organization_fullname = next_step_user_org_info["organization_fullname"];
+                newApprove.start_date = new Date();
+                newApprove.due_date = newTrace.due_date;
+                newApprove.is_read = false;
+                newApprove.is_error = false;
+                newApprove.values = {};
+                
+                UUFlowManager.setRemindInfo(instance.values, newApprove);
+                newTrace.approves.push(newApprove);
+            }
+
+            // 更新instance记录
+            setObj.modified = new Date();
+            setObj.modified_by = current_user;
+            
+            const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+            const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+            
+            setObj.inbox_users = next_step_users;
+            updateObj.$addToSet = {
+                outbox_users: {
+                    $each: [trace_approve.handler, trace_approve.user]
+                }
+            };
+            
+            updateObj.$push = {
+                traces: newTrace
+            };
+            
+            setObj.state = "pending";
+            const updated_values = await UUFlowManager.getUpdatedValues(await UUFlowManager.getInstance(instance_id), approve_id);
+            setObj.values = updated_values;
+            setObj.name = await UUFlowManager.getInstanceName(instance);
+            setObj.current_step_name = next_step_name;
+            setObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+        }
+    } else {
+        // 当前trace未结束
+        const instance_trace = instance_traces.find(trace => trace._id === trace_id);
+        const trace_approve = instance_trace.approves.find(approve => approve._id === approve_id);
+        
+        updateObj.$addToSet = {
+            outbox_users: {
+                $each: [trace_approve.handler, trace_approve.user]
+            }
+        };
+        
+        instance.inbox_users.splice(instance.inbox_users.indexOf(trace_approve.handler), 1);
+        setObj.inbox_users = instance.inbox_users;
+        setObj.modified = new Date();
+        setObj.modified_by = current_user;
+        setObj.state = "pending";
+        const updated_values = await UUFlowManager.getUpdatedValues(await UUFlowManager.getInstance(instance_id), approve_id);
+        setObj.values = updated_values;
+        setObj.name = await UUFlowManager.getInstanceName(instance);
+    }
+
+    await db.instances.update({_id: instance_id}, { $set: setTraceObj });
+    // 更新instance_tasks
+    await update_many_instance_tasks(instance_id, trace_id, finishedApproveIds);
+    
+    updateObj.$set = setObj;
+    return updateObj;
+};
+
+/////////////
+// 生成HTML格式只读表单和签核历程, 由于此方法生成的html数据会作为邮件内容发送，为了再邮件中样式显示正常，
+// 请不要写单独的css，所有样式请写在html标签的style属性中。
+UUFlowManager.ins_html = function (current_user_info, ins) {
+    const options = {
+        templateName: 'table',
+        showTrace: true,
+        showAttachments: false,
+        tagger: 'email',
+        width: "765px" // 此处宽度不能设置为偶数，否则会引起子表与主表线条对不齐的bug
+    };
+
+    options.styles = `body { background: #ffffff !important; }.steedos .pull-right { float: right !important; }.steedos .inline-left{ display: inline;float: left; }.steedos .inline-right{ display: inline;float: right; }.steedos .no-border{ border: 0px; }.steedos .no-border td{ border: 0px; }.steedos tr:nth-child(2) td{ border-top: 0px !important; }.steedos .ins_applicant{ display: inline; background: transparent !important; border: none; }.steedos .instance-name{ width: ${options.width} !important; }.steedos table { border-spacing: 0; border-collapse: collapse; }.steedos .box { background: #ffffff; }.steedos .form-table { width: ${options.width}; border: solid 2px #000000; border-collapse: collapse; table-layout: fixed; }.steedosTable-item-field{ padding: 5px; }.steedos td{ border: solid 1px #000000; border-collapse: collapse; }.steedos th { border: 0px; border-collapse: collapse; padding: 0px; }.steedos .td-title{ padding: 4px 12px; }.steedos .td-field { padding: 4px 12px; }.instance-view .instance-name { text-align: center; font-weight: bolder; }.td-childfield { border-top: solid 1px #000000; border-right: solid 1px #000000; border-bottom: solid 1px #000000; padding: 0px; }.panel-heading{ padding: 4px 12px; font-weight: bold; color: #333; background-color: #f5f5f5; }.table-bordered tr:last-child th { border-bottom: none; }.table-bordered tr:last-child td { border-bottom: none; }.steedos-table th:first-child{ border-left: 0px !important; }.steedos-table td:first-child { border-left: 0px !important; }.steedos-table table thead .title { min-width: 50px; }.steedos-table th:last-child{ border-right: 0px !important; }.steedos-table td:last-child { border-right: 0px !important; }.steedos-table table .number { text-align: right; }.callout-default{ border-color: #D2D6DE; color: #333; background-color: #F1F1F1; font-weight: bold; }.instance-table .callout { margin: 0px; padding: 4px 12px; border-radius: 0px; border-left: none; }.approved{ color: green; }.rejected{ color: red; }.terminated{ color: black; }.reassigned{ color: black; }.retrieved{ color: black; }.trace-approve-talbe td { text-align: left; border: none; }.traces td table { width: 100%; }.approve-item .name{ width: 40%; }.approve-item .finish-date{ width: 35%; }.td-stepname{ padding: 4px 12px; }.td-approve td{ padding: 4px 12px; }.applicant-wrapper { font-weight: bolder; }`;
+
+    let instanceHtml = InstanceReadOnlyTemplate.getInstanceHtml(current_user_info, ins.space, ins, options);
+    
+    // 处理outlook中，对部分css不支持的处理
+    const replacements = [
+        ['style="width: 100%;display: inline-table;"', 'style="border:0px;text-align: center;width:765px;"'],
+        ['class="instance-table-name-td"', `class="instance-table-name-td" style="width:${options.width};border:0px"`],
+        ['class="instance-name"', `class="instance-name" style="width:${options.width}"`],
+        ['class="table-page-body form-table"', `class="table-page-body form-table" style="width:${options.width}"`],
+        ['class="table table-condensed traces"', `class="table table-condensed traces" style="width:${options.width};border:solid 2.0px #000000"`],
+        ['class="table-page-footer form-table no-border"', 'class="table-page-footer form-table no-border" style="border:0px;width:765px;"'],
+        [/class="td-title "/g, 'class="td-title" style="width:14%"'],
+        [/class="td-stepname"/g, `class="td-stepname" style="width:${765 * 20 / 100}px"`],
+        [/class="td-childfield"/g, 'class="td-childfield" style="padding:0px"'],
+        [/class="status approved"/g, 'class="status approved" style="color: green;"'],
+        [/class="status rejected"/g, 'class="status rejected" style="color: red;"'],
+        [/<table>/g, '<table style="width:100%;border:none">'],
+        [/<td class="name">/g, '<td class="name" style="width: 40%;">'],
+        [/<td class="finish-date">/g, '<td class="finish-date" style="width: 35%;">'],
+        [/inline-left'/g, "inline-left' style='display: inline;float: left;'"],
+        [/inline-right'/g, "inline-right' style='display: inline;float: right;'"],
+        [/pull-right'/g, "pull-right' style='float: right;'"]
+    ];
+
+    replacements.forEach(([search, replace]) => {
+        instanceHtml = instanceHtml.replace(search, replace);
+    });
+
+    return instanceHtml;
+};
+
+UUFlowManager.getFlowCompanyId = async function (flowId) {
+    const db = {
+        flows: await getCollection('flows')
+    };
+    
+    const flow = await db.flows.findOne({_id: flowId}, {
+        fields: {
+            company_id: 1
+        }
+    });
+    
+    return flow?.company_id;
+};
+
+UUFlowManager.create_instance = async function (instance_from_client, user_info) {
+    const db = {
+        instances: await getCollection('instances')
+    };
+
+    const space_id = instance_from_client["space"];
+    const flow_id = instance_from_client["flow"];
+    const user_id = user_info._id;
+
+    // 获取前台所传的trace
+    let trace_from_client = null;
+    // 获取前台所传的approve
+    let approve_from_client = null;
+    
+    if (instance_from_client["traces"]?.[0]) {
+        trace_from_client = instance_from_client["traces"][0];
+        if (trace_from_client["approves"]?.[0]) {
+            approve_from_client = trace_from_client["approves"][0];
+        }
+    }
+
+    // 获取一个space
+    const space = await UUFlowManager.getSpace(space_id);
+    // 获取一个flow
+    const flow = await UUFlowManager.getFlow(flow_id, { fields: { historys: 0 } });
+    // 获取一个space下的一个user
+    const space_user = await UUFlowManager.getSpaceUser(space_id, user_id);
+    // 获取space_user所在的部门信息
+    const space_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(space_user);
+    // 判断一个flow是否为启用状态
+    UUFlowManager.isFlowEnabled(flow);
+    // 判断一个flow和space_id是否匹配
+    UUFlowManager.isFlowSpaceMatched(flow, space_id);
+    
+    const form = await UUFlowManager.getForm(flow.form, { fields: { historys: 0 } });
+    const permissions = await PermissionManager.getFlowPermissions(flow_id, user_id, flow);
+    
+    if (!permissions.includes("add")) {
+        throw new Error('当前用户没有此流程的新建权限');
+    }
+
+    const now = new Date();
+    const ins_obj = {};
+    ins_obj._id = _makeNewID();
+    ins_obj.space = space_id;
+    ins_obj.flow = flow_id;
+    ins_obj.flow_version = flow.current._id;
+    ins_obj.form = flow.form;
+    ins_obj.form_version = flow.current.form_version;
+    ins_obj.name = flow.name;
+    ins_obj.submitter = user_id;
+    ins_obj.submitter_name = user_info.name;
+    ins_obj.applicant = instance_from_client["applicant"] || user_id;
+    ins_obj.applicant_name = instance_from_client["applicant_name"] || user_info.name;
+    ins_obj.applicant_organization = instance_from_client["applicant_organization"] || space_user.organization;
+    ins_obj.applicant_organization_name = instance_from_client["applicant_organization_name"] || space_user_org_info.organization_name;
+    ins_obj.applicant_organization_fullname = instance_from_client["applicant_organization_fullname"] || space_user_org_info.organization_fullname;
+    ins_obj.applicant_company = instance_from_client["applicant_company"] || space_user.company_id;
+    ins_obj.state = 'draft';
+    ins_obj.code = '';
+    ins_obj.is_archived = false;
+    ins_obj.is_deleted = false;
+    ins_obj.created = now;
+    ins_obj.created_by = user_id;
+    ins_obj.modified = now;
+    ins_obj.modified_by = user_id;
+    ins_obj.values = {};
+
+    const companyId = flow.company_id;
+    if (companyId) {
+        ins_obj.company_id = companyId;
+    }
+
+    // 新建Trace
+    const trace_obj = {
+        _id: _makeNewID(),
+        instance: ins_obj._id,
+        is_finished: false,
+        step: flow.current.steps.find(step => step.step_type === 'start')._id,
+        name: flow.current.steps.find(step => step.step_type === 'start').name,
+        start_date: now
+    };
+
+    // 新建Approve
+    const appr_obj = {
+        _id: _makeNewID(),
+        instance: ins_obj._id,
+        trace: trace_obj._id,
+        is_finished: false,
+        user: instance_from_client["applicant"] || user_id,
+        user_name: instance_from_client["applicant_name"] || user_info.name,
+        handler: user_id,
+        handler_name: user_info.name,
+        handler_organization: space_user.organization,
+        handler_organization_name: space_user_org_info.organization_name,
+        handler_organization_fullname: space_user_org_info.organization_fullname,
+        type: 'draft',
+        start_date: now,
+        read_date: now,
+        is_read: true,
+        is_error: false,
+        description: '',
+        values: approve_from_client?.values || {}
+    };
+
+    trace_obj.approves = [appr_obj];
+    ins_obj.traces = [trace_obj];
+    ins_obj.inbox_users = instance_from_client.inbox_users || [];
+    ins_obj.current_step_name = flow.current.steps.find(step => step.step_type === 'start').name;
+    
+    if (flow.auto_remind === true) {
+        ins_obj.auto_remind = true;
+    }
+
+    // 新建申请单时，instances记录流程名称、流程分类名称 #1313
+    ins_obj.flow_name = flow.name;
+    
+    if (form.category) {
+        const category = await UUFlowManager.getCategory(form.category, { fields: { _id: 1, name: 1 } });
+        if (category) {
+            ins_obj.category_name = category.name;
+            ins_obj.category = category._id;
+        }
+    }
+
+    await db.instances.insert(ins_obj);
+    return ins_obj._id;
+};
+
+UUFlowManager.getCurrentStepAutoSubmit = function (timeout_auto_submit, lines) {
+    if (timeout_auto_submit && lines) {
+        return lines.some(l => l.timeout_line === true);
+    }
+    return false;
+};
+
+UUFlowManager.getDueDate = async function (hours, spaceId) {
+    if (hours) {
+        // TODO: 实现异步获取超时日期
+        // return await steedosCore.getTimeoutDateWithoutHolidays(new Date(), hours, spaceId);
+    }
+    return undefined;
+};
+//////////
+
+UUFlowManager.submit_instance = async function (instance_from_client, user_info) {
+    if (process.env.STEEDOS_DEBUG) {
+        console.time('submit_instance');
+    }
+
+    const db = {
+        instances: await getCollection('instances'),
+        flows: await getCollection('flows')
+    };
+
+    const current_user = user_info._id;
+    const lang = user_info.locale === 'zh-cn' ? 'zh-CN' : 'en';
+    const instance_id = instance_from_client._id;
+    const trace_id = instance_from_client.traces[0]._id;
+    const approve_id = instance_from_client.traces[0].approves[0]._id;
+    let values = instance_from_client.traces[0].approves[0].values || {};
+
+    // 验证表单上的applicant已填写
+    if (!instance_from_client.applicant) {
+        throw new Error('请选择提交人');
+    }
+
+    const applicant_id = instance_from_client.applicant;
+    const submitter_id = instance_from_client.submitter;
+    const next_steps = instance_from_client.traces[0].approves[0].next_steps;
+    const attachments = instance_from_client.traces[0].approves[0].attachments;
+    const description = instance_from_client.traces[0].approves[0].description;
+
+    // 获取一个instance
+    const instance = await UUFlowManager.getInstance(instance_id);
+    const space_id = instance.space;
+    const flow_id = instance.flow;
+
+    // 获取一个space
+    const space = await UUFlowManager.getSpace(space_id);
+    // 校验申请人user_accepted = true
+    const checkApplicant = await UUFlowManager.getSpaceUser(space_id, applicant_id);
+    // 获取一个flow
+    const flow = await UUFlowManager.getFlow(flow_id, { historys: 0 });
+    // 确定instance的name
+    const instance_name = instance_from_client.name;
+
+    // 判断一个instance是否为拟稿状态
+    UUFlowManager.isInstanceDraft(instance, lang);
+    // 获取一个space下的一个user
+    const space_user = await UUFlowManager.getSpaceUser(space_id, current_user);
+    // 获取space_user所在的部门信息
+    const space_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(space_user);
+    // 判断一个用户是否是一个instance的提交者
+    UUFlowManager.isInstanceSubmitter(instance, current_user);
+    // 判断一个flow是否为启用状态
+    UUFlowManager.isFlowEnabled(flow);
+    // 验证该user_id或其所在的组有提交此申请单的权限
+    const permissions = await PermissionManager.getFlowPermissions(flow_id, current_user, flow);
+    
+    if (!permissions.includes("add")) {
+        throw new Error('该提交人没有提交此申请单的权限。');
+    }
+
+    const trace = instance_from_client.traces[0];
+    // 获取一个step
+    const step = await UUFlowManager.getStep(instance, flow, trace.step);
+    const approve = trace.approves[0];
+
+    // 先执行暂存的操作
+    // ================begin================
+    const form = await UUFlowManager.getForm(instance.form, { fields: { historys: 0 } });
+    // 获取Flow当前版本开始节点
+    const start_step = flow.current.steps.find(step => step.step_type === 'start');
+    
+    const instance_traces = instance.traces;
+    instance_traces[0].approves[0].description = description;
+    
+    let setObj = {};
+    let flow_has_upgrade = false;
+
+    // 判断:applicant和原instance的applicant是否相等
+    if (applicant_id !== instance.applicant) {
+        // applicant和原instance的applicant不相等
+        const user = await UUFlowManager.getUser(applicant_id);
+        const applicant = await UUFlowManager.getSpaceUser(space_id, applicant_id);
+        // 获取applicant所在的部门信息
+        const applicant_org_info = await UUFlowManager.getSpaceUserOrgInfo(applicant);
+        
+        // 修改instance的applicant,applicant_name，同时修改开始结点的approve的user为:applicant,user_name
+        setObj.applicant = applicant_id;
+        setObj.applicant_name = user.name;
+        setObj.applicant_organization = applicant_org_info.organization;
+        setObj.applicant_organization_name = applicant_org_info.organization_name;
+        setObj.applicant_organization_fullname = applicant_org_info.organization_fullname;
+        setObj.applicant_company = applicant.company_id;
+        instance_traces[0].approves[0].user = applicant_id;
+        instance_traces[0].approves[0].user_name = user.name;
+    }
+
+    // 判断流程是否已升级，instance["flow_version"] == flow["current"]["_id"]表示流程未升级
+    if (instance.flow_version === flow.current._id) {
+        // 判断next_steps是否为空,不为空则写入到当前approve的next_steps中
+        if (next_steps) {
+            instance_traces[0].approves[0].next_steps = next_steps;
+        }
+    } else {
+        // 流程已升级
+        flow_has_upgrade = true;
+        // 更新instance记录
+        setObj.flow_version = flow.current._id;
+        setObj.form_version = flow.current.form_version;
+        // 清空原来的值，存入当前最新版flow中开始节点的step_id
+        instance_traces[0].step = start_step._id;
+        instance_traces[0].name = start_step.name;
+    }
+
+    // 调整approves的values删除values中在当前步骤中没有编辑权限的字段值
+    instance_traces[0].approves[0].values = await UUFlowManager.getApproveValues(
+        values, 
+        step.permissions, 
+        instance.form, 
+        instance.form_version
+    );
+    
+    setObj.traces = instance_traces;
+    setObj.modified = new Date();
+    setObj.modified_by = current_user;
+
+    await db.instances.updateOne(
+        { _id: instance_id },
+        { $set: setObj }
+    );
+
+    if (flow_has_upgrade) {
+        return {
+            alerts: t('flow.point_upgraded', {}, lang)
+        };
+    }
+    // ================end================
+
+    // 使用最新的instance
+    const updatedInstance = await UUFlowManager.getInstance(instance_id);
+    // 判断一个instance是否为拟稿状态
+    await UUFlowManager.isInstanceDraft(updatedInstance, lang);
+
+    const traces = updatedInstance.traces;
+    const upObj = {};
+    const now = new Date();
+
+    if (!approve.next_steps || approve.next_steps.length === 0) {
+        throw new Error('还未指定下一步和处理人，提交失败');
+    }
+
+    // 验证next_steps里面是否只有一个step
+    if (approve.next_steps.length > 1) {
+        throw new Error('不能指定多个后续步骤');
+    }
+
+    const nextSteps = await UUFlowManager.getNextSteps(updatedInstance, flow, step, "");
+    approve.next_steps.forEach(approve_next_step => {
+        if (!nextSteps.includes(approve_next_step.step)) {
+            throw new Error('下一步步骤不合法');
+        }
+    });
+
+    // 校验下一步处理人user_accepted = true
+    for (const next_step_user of approve.next_steps[0].users) {
+        await UUFlowManager.getSpaceUser(space_id, next_step_user);
+    }
+
+    const next_step = await UUFlowManager.getStep(updatedInstance, flow, approve.next_steps[0].step);
+    let nextTrace = null;
+
+    // 判断next_step是否为结束结点
+    if (next_step.step_type === "end") {
+        // 更新approve
+        traces[0].approves[0].judge = "submitted";
+        traces[0].approves[0].is_finished = true;
+        traces[0].approves[0].finish_date = now;
+        traces[0].approves[0].cost_time = now - traces[0].approves[0].start_date;
+        
+        // 更新trace
+        traces[0].is_finished = true;
+        traces[0].judge = "submitted";
+        traces[0].finish_date = now;
+        
+        // 插入下一步trace记录
+        const newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [trace._id],
+            is_finished: true,
+            step: next_step._id,
+            name: next_step.name,
+            start_date: now,
+            finish_date: now
+        };
+
+        // 更新instance记录
+        // 申请单名称按照固定规则生成申请单名称：流程名称＋' '+申请单编号
+        upObj.submit_date = now;
+        upObj.state = "completed";
+        upObj.values = await UUFlowManager.getUpdatedValues(await UUFlowManager.getInstance(instance_id));
+        upObj.code = flow.current_no + 1 + "";
+        updatedInstance.code = upObj.code;
+        updatedInstance.values = upObj.values;
+        upObj.name = await UUFlowManager.getInstanceName(updatedInstance);
+        upObj.modified = now;
+        upObj.modified_by = current_user;
+        upObj.inbox_users = [];
+        upObj.outbox_users = [...new Set([current_user, traces[0].approves[0].user])];
+        traces.push(newTrace);
+        upObj.traces = traces;
+        upObj.finish_date = now;
+        upObj.current_step_name = next_step.name;
+        upObj.final_decision = "approved";
+        upObj.current_step_auto_submit = false;
+    } else {
+        // 取得下一步处理人
+        const next_step_users = approve.next_steps[0].users;
+        
+        // 判断nextsteps.step.users是否为空
+        if (!next_step_users || next_step_users.length === 0) {
+            throw new Error('未指定下一步处理人');
+        }
+        
+        if (next_step_users.length > 1 && next_step.step_type !== "counterSign") {
+            throw new Error('不能指定多个处理人');
+        }
+        
+        // 验证下一步处理人next_user是否合法
+        const checkUsers = await await HandlersManager.getHandlers(instance_id, approve.next_steps[0].step, current_user);
+        
+        if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, checkUsers, next_step)) {
+            throw new Error('指定的下一步处理人有误');
+        }
+        
+        // 若合法，执行流转操作
+        // 更新approve
+        traces[0].approves[0].judge = "submitted";
+        traces[0].approves[0].is_finished = true;
+        traces[0].approves[0].finish_date = now;
+        traces[0].approves[0].cost_time = traces[0].approves[0].finish_date - traces[0].approves[0].start_date;
+        
+        // 更新trace
+        traces[0].is_finished = true;
+        traces[0].finish_date = now;
+        traces[0].judge = "submitted";
+        
+        // 插入下一步trace记录
+        nextTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [trace._id],
+            is_finished: false,
+            step: next_step._id,
+            name: next_step.name,
+            start_date: now,
+            due_date: await UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+            approves: []
+        };
+
+        const updated_values = await UUFlowManager.getUpdatedValues(await UUFlowManager.getInstance(instance_id));
+        
+        // 插入下一步trace.approve记录
+        for (let idx = 0; idx < next_step_users.length; idx++) {
+            const next_step_user_id = next_step_users[idx];
+            const nextApprove = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                trace: nextTrace._id,
+                is_finished: false,
+                user: next_step_user_id
+            };
+
+            const user_info = await UUFlowManager.getUser(next_step_user_id);
+            let handler_id = next_step_user_id;
+            let handler_info = user_info;
+            
+            const agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+            if (agent) {
+                next_step_users[idx] = agent;
+                handler_id = agent;
+                handler_info = await UUFlowManager.getUser(agent);
+                nextApprove.agent = agent;
+            }
+            
+            nextApprove.user_name = user_info.name;
+            nextApprove.handler = handler_id;
+            nextApprove.handler_name = handler_info.name;
+            
+            const next_step_space_user = await UUFlowManager.getSpaceUser(space_id, handler_id);
+            // 获取next_step_user所在的部门信息
+            const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+            
+            nextApprove.handler_organization = next_step_user_org_info.organization;
+            nextApprove.handler_organization_name = next_step_user_org_info.organization_name;
+            nextApprove.handler_organization_fullname = next_step_user_org_info.organization_fullname;
+            nextApprove.start_date = now;
+            nextApprove.due_date = nextTrace.due_date;
+            nextApprove.is_read = false;
+            nextApprove.is_error = false;
+            nextApprove.values = {};
+            
+            await UUFlowManager.setRemindInfo(updated_values, nextApprove);
+            nextTrace.approves.push(nextApprove);
+        }
+
+        // 更新instance记录
+        upObj.name = instance_name;
+        upObj.submit_date = now;
+        upObj.state = "pending";
+        upObj.values = updated_values;
+        upObj.inbox_users = next_step_users;
+        upObj.modified = now;
+        upObj.modified_by = current_user;
+        upObj.code = flow.current_no + 1 + "";
+        updatedInstance.code = upObj.code;
+        updatedInstance.values = upObj.values;
+        upObj.name = await UUFlowManager.getInstanceName(updatedInstance);
+        traces.push(nextTrace);
+        upObj.traces = traces;
+        upObj.outbox_users = [];
+        upObj.current_step_name = next_step.name;
+        upObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+    }
+
+    upObj.keywords = await UUFlowManager.caculateKeywords(upObj.values, form, instance.form_version);
+    // 计算extras
+    upObj.extras = await UUFlowManager.caculateExtras(upObj.values, form, instance.form_version);
+
+    // 如果不是转发、分发，新建instance_tasks
+    if (!instance.forward_from_instance && !instance.distribute_from_instance) {
+        await insert_instance_tasks(instance_id, traces[0]._id, traces[0].approves[0]._id);
+    }
+
+    await getObject('instances').update(instance_id, upObj);
+
+    await db.flows.updateOne(
+        { _id: flow._id },
+        { $set: { current_no: flow.current_no + 1 } }
+    );
+
+    await update_instance_tasks(instance_id, traces[0]._id, traces[0].approves[0]._id);
+
+    if (nextTrace) {
+        // 生成新记录
+        const approveIds = nextTrace.approves.map(a => a._id);
+        await insert_many_instance_tasks(instance_id, nextTrace._id, approveIds);
+    }
+
+    if (next_step.step_type !== "end") {
+        const finalInstance = await UUFlowManager.getInstance(instance_id);
+        // 发送短消息给申请人
+        await pushManager.send_instance_notification("first_submit_applicant", finalInstance, "", user_info, null, flow);
+        // 发送消息给下一步处理人
+        await pushManager.send_instance_notification("first_submit_inbox", finalInstance, "", user_info, null, flow);
+    }
+
+    if (process.env.STEEDOS_DEBUG) {
+        console.timeEnd('submit_instance');
+    }
+
+    return {};
+};
+
+/////////
+
+UUFlowManager.get_SpaceChangeSet = async function (formids, is_admin, sync_token) {
+    const db = {
+        instances: await getCollection('instances'),
+        deleted_instances: await getCollection('deleted_instances'),
+        users: await getCollection('users')
+    };
+
+    sync_token = new Date(Number(sync_token) * 1000);
+    const changeSet = {
+        sync_token: new Date().getTime() / 1000,
+        inserts: {
+            Spaces: [],
+            Users: [],
+            SpaceUsers: [],
+            Organizations: [],
+            Roles: [],
+            Positions: [],
+            Forms: [],
+            Flows: [],
+            Instances: []
+        },
+        updates: {
+            Spaces: [],
+            Users: [],
+            SpaceUsers: [],
+            Organizations: [],
+            Roles: [],
+            Positions: [],
+            Forms: [],
+            Flows: [],
+            Instances: []
+        },
+        deletes: {
+            Spaces: [],
+            Users: [],
+            SpaceUsers: [],
+            Organizations: [],
+            Roles: [],
+            Positions: [],
+            Forms: [],
+            Flows: [],
+            Instances: []
+        }
+    };
+
+    if (formids?.trim()) {
+        const formids_ary = formids.split(",");
+        changeSet.inserts.Instances = await db.instances.find({
+            form: { $in: formids_ary },
+            created: { $gt: sync_token }
+        }).toArray();
+
+        changeSet.updates.Instances = await db.instances.find({
+            form: { $in: formids_ary },
+            created: { $lte: sync_token },
+            modified: { $gt: sync_token }
+        }).toArray();
+
+        changeSet.deletes.Instances = await db.deleted_instances.find({
+            form: { $in: formids_ary },
+            deleted: { $gt: sync_token }
+        }, {
+            projection: { _id: 1 }
+        }).toArray();
+    } else if (is_admin?.trim()) {
+        changeSet.inserts.Instances = await db.instances.find({
+            created: { $gt: sync_token }
+        }).toArray();
+
+        changeSet.updates.Instances = await db.instances.find({
+            created: { $lte: sync_token },
+            modified: { $gt: sync_token }
+        }).toArray();
+
+        changeSet.deletes.Instances = await db.deleted_instances.find({
+            deleted: { $gt: sync_token }
+        }, {
+            projection: { _id: 1 }
+        }).toArray();
+    }
+
+    // Process submitter and applicant steedos_ids
+    const processInstance = async (ins) => {
+        const [submitter, applicant] = await Promise.all([
+            db.users.findOne({ _id: ins.submitter }, { projection: { steedos_id: 1 } }),
+            db.users.findOne({ _id: ins.applicant }, { projection: { steedos_id: 1 } })
+        ]);
+
+        if (submitter) {
+            ins.submitter_steedos_id = submitter.steedos_id;
+        }
+        if (applicant) {
+            ins.applicant_steedos_id = applicant.steedos_id;
+        }
+        return ins;
+    };
+
+    await Promise.all([
+        ...changeSet.inserts.Instances.map(processInstance),
+        ...changeSet.updates.Instances.map(processInstance)
+    ]);
+
+    return { ChangeSet: changeSet };
+};
+
+UUFlowManager.setRemindInfo = async function (values, approve) {
+    if (!values || !approve?.start_date) return;
+
+    let remind_date = null;
+    let deadline = null;
+    const start_date = approve.start_date;
+
+    if (values.priority && values.deadline) {
+        const validPriorities = ["普通", "办文", "紧急", "特急"];
+        if (!validPriorities.includes(values.priority)) return;
+
+        deadline = new Date(values.deadline);
+        if (isNaN(deadline.getTime())) return;
+
+        const priority = values.priority;
+
+        if (priority === "普通") {
+            remind_date = WorkingTime.caculateWorkingTime(start_date, 3);
+        } else {
+            const halfDay = WorkingTime.caculatePlusHalfWorkingDay(start_date);
+            const oneDay = WorkingTime.caculateWorkingTime(start_date, 1);
+
+            if (halfDay > deadline) {
+                remind_date = WorkingTime.caculatePlusHalfWorkingDay(start_date, true);
+            } else if (oneDay > deadline) {
+                const calculateDate = (base_date) => {
+                    const plus_halfday_date = WorkingTime.caculatePlusHalfWorkingDay(base_date);
+                    if (plus_halfday_date > deadline) {
+                        remind_date = base_date;
+                    } else {
+                        calculateDate(WorkingTime.caculatePlusHalfWorkingDay(base_date, true));
+                    }
+                };
+                calculateDate(start_date);
+            } else {
+                remind_date = priority === "办文" ? oneDay : halfDay;
+            }
+
+            if (priority === "紧急" || priority === "特急") {
+                const instance = db.instances.findOne({_id: approve.instance});
+                if (instance?.state === 'draft') {
+                    const flow = db.flows.findOne(
+                        { _id: instance.flow },
+                        { fields: { current_no: 1 } }
+                    );
+                    if (flow) {
+                        instance.code = flow.current_no + 1 + '';
+                    }
+                }
+                instance.values = values;
+                const iname = await UUFlowManager.getInstanceName(instance);
+                UUFlowManager.sendRemindSMS(
+                    iname,
+                    deadline,
+                    [approve.user],
+                    instance.space,
+                    instance._id
+                );
+            }
+        }
+    } else {
+        remind_date = WorkingTime.caculateWorkingTime(start_date, 3);
+    }
+
+    approve.deadline = deadline;
+    approve.remind_date = remind_date;
+    approve.reminded_count = 0;
+};
+
+UUFlowManager.sendRemindSMS = async function (ins_name, deadline, users_id, space_id, ins_id) {
+    if (!ins_name || !deadline || !users_id?.length || !space_id || !ins_id) return;
+
+    const skip_users = settings?.remind?.skip_users || [];
+    const send_users = users_id.filter(uid => !skip_users.includes(uid));
+
+    const name = ins_name.length > 15 ? ins_name.substr(0, 12) + '...' : ins_name;
+    const users = await db.users.find({
+        _id: { $in: [...new Set(send_users)] },
+        mobile: { $exists: true },
+        mobile_verified: true
+    }, {
+        projection: { mobile: 1, utcOffset: 1, locale: 1, name: 1 }
+    }).toArray();
+
+    await Promise.all(users.map(async (user) => {
+        const utcOffset = user.utcOffset ?? 8;
+        const params = {
+            instance_name: name,
+            deadline: moment(deadline).utcOffset(utcOffset).format('MM-DD HH:mm')
+        };
+
+        const lang = user.locale === 'zh-cn' ? 'zh-CN' : 'en';
+        
+        // Send SMS
+        await SMSQueue.send({
+            Format: 'JSON',
+            Action: 'SingleSendSms',
+            ParamString: JSON.stringify(params),
+            RecNum: user.mobile,
+            SignName: 'OA系统',
+            TemplateCode: 'SMS_67200967',
+            msg: t('sms.remind.template', {
+                instance_name: ins_name,
+                deadline: params.deadline,
+                open_app_url: Meteor.absoluteUrl() + `workflow.html?space_id=${space_id}&ins_id=${ins_id}`
+            }, lang)
+        });
+
+        // Send push notification
+        const notification = {
+            createdAt: new Date(),
+            createdBy: '<SERVER>',
+            from: 'workflow',
+            title: user.name,
+            text: t('instance.push.body.remind', {
+                instance_name: ins_name,
+                deadline: params.deadline
+            }, lang),
+            payload: {
+                space: space_id,
+                instance: ins_id,
+                host: Meteor.absoluteUrl().slice(0, -1),
+                requireInteraction: true
+            },
+            query: {
+                userId: user._id,
+                appName: 'workflow'
+            }
+        };
+        await Push.send(notification);
+    }));
+};
+
+UUFlowManager.checkMainAttach = async function (instance_id, name) {
+    const main = await cfs.instances.findOne({
+        'metadata.instance': instance_id,
+        'metadata.main': true,
+        'metadata.current': true
+    });
+
+    if (main) {
+        const ins = await db.instances.findOne(
+            { _id: instance_id },
+            { projection: { name: 1 } }
+        );
+
+        let new_ins_name = (name || ins?.name || '')
+            .replace(/\r|\n/g, "")
+            .replace(/\?|\*|\:|\"|\<|\>|\\|\/|\|/g, "");
+
+        const main_name_split = main.name().split('.');
+        main_name_split.pop();
+        
+        if (new_ins_name !== main_name_split.join("")) {
+            const file_name = `${new_ins_name}.${main.extension()}`;
+            await main.update({
+                $set: {
+                    'original.name': file_name,
+                    'copies.instances.name': file_name
+                }
+            });
+        }
+    }
+};
+
+UUFlowManager.caculateKeywords = function (values = {}, form, form_version) {
+    if (_.isEmpty(values)) return "";
+
+    const keywords = [];
+    let form_v = null;
+
+    if (form_version === form.current._id) {
+        form_v = form.current;
+    } else {
+        form_v = form.historys.find(form_h => form_version === form_h._id);
+    }
+
+    if (!form_v) return "";
+
+    form_v.fields.forEach(field => {
+        if (!field.is_searchable) return;
+
+        const value = values[field.code];
+        if (!value) return;
+
+        switch (field.type) {
+            case 'input':
+            case 'email':
+            case 'url':
+            case 'number':
+            case 'select':
+            case 'radio':
+            case 'multiSelect':
+                keywords.push(value);
+                break;
+
+            case 'user':
+            case 'group':
+                if (field.is_multiselect) {
+                    if (Array.isArray(value)) {
+                        value.forEach(singleV => {
+                            if (singleV?.name) keywords.push(singleV.name);
+                        });
+                    }
+                } else if (value?.name) {
+                    keywords.push(value.name);
+                }
+                break;
+
+            case 'table':
+                if (Array.isArray(value)) {
+                    value.forEach(s_value => {
+                        field.fields.forEach(s_field => {
+                            if (s_field.is_searchable) {
+                                const s_value_field = s_value[s_field.code];
+                                if (!s_value_field) return;
+
+                                if (['input', 'email', 'url', 'number', 'select', 'radio', 'multiSelect'].includes(s_field.type)) {
+                                    keywords.push(s_value_field);
+                                } else if (['user', 'group'].includes(s_field.type)) {
+                                    if (s_field.is_multiselect) {
+                                        if (Array.isArray(s_value_field)) {
+                                            s_value_field.forEach(singleV => {
+                                                if (singleV?.name) keywords.push(singleV.name);
+                                            });
+                                        }
+                                    } else if (s_value_field?.name) {
+                                        keywords.push(s_value_field.name);
+                                    }
+                                }
+                            }
+                        });
+                    });
+                }
+                break;
+
+            case 'section':
+                field.fields.forEach(s_field => {
+                    if (s_field.is_searchable) {
+                        const s_value = values[s_field.code];
+                        if (!s_value) return;
+
+                        if (['input', 'email', 'url', 'number', 'select', 'radio', 'multiSelect'].includes(s_field.type)) {
+                            keywords.push(s_value);
+                        } else if (['user', 'group'].includes(s_field.type)) {
+                            if (s_field.is_multiselect) {
+                                if (Array.isArray(s_value)) {
+                                    s_value.forEach(singleV => {
+                                        if (singleV?.name) keywords.push(singleV.name);
+                                    });
+                                }
+                            } else if (s_value?.name) {
+                                keywords.push(s_value.name);
+                            }
+                        }
+                    }
+                });
+                break;
+        }
+    });
+
+    return keywords.join(" ");
+};
+
+UUFlowManager.checkValueFieldsRequire = function (values = {}, form, form_version) {
+    const require_but_empty_fields = [];
+    let form_v = null;
+
+    if (form_version === form.current._id) {
+        form_v = form.current;
+    } else {
+        form_v = form.historys.find(form_h => form_version === form_h._id);
+    }
+
+    if (!form_v) return require_but_empty_fields;
+
+    form_v.fields.forEach(field => {
+        if (field.type !== 'table') {
+            if (field.is_required && _.isEmpty(values[field.code])) {
+                require_but_empty_fields.push(field.name || field.code);
+            }
+        } else {
+            if (_.isEmpty(values[field.code])) {
+                field.fields.forEach(s_field => {
+                    if (s_field.is_required) {
+                        require_but_empty_fields.push(s_field.name || s_field.code);
+                    }
+                });
+            } else {
+                values[field.code].forEach(s_value => {
+                    field.fields.forEach(s_field => {
+                        if (s_field.is_required && _.isEmpty(s_value[s_field.code])) {
+                            require_but_empty_fields.push(s_field.name || s_field.code);
+                        }
+                    });
+                });
+            }
+        }
+    });
+
+    return require_but_empty_fields;
+};
+
+UUFlowManager.triggerRecordInstanceQueue = async function (ins_id, record_ids, step_name, flow_id, ins_state) {
+    const db = {
+        instance_record_queue: await getCollection('instance_record_queue')
+    };
+    const owColl = await getCollection('object_workflows');
+    const owDoc = await owColl.findOne(
+        { flow_id: flow_id },
+        { projection: { sync_type: 1 } }
+    );
+
+    if (owDoc) {
+        const syncType = owDoc.sync_type;
+        if ((!syncType || syncType === 'every_step') || (syncType === 'final_step' && ins_state === 'completed')) {
+            const newObj = {
+                info: {
+                    instance_id: ins_id,
+                    records: record_ids,
+                    step_name: step_name,
+                    instance_finish_date: new Date()
+                },
+                sent: false,
+                sending: 0,
+                createdAt: new Date(),
+                createdBy: '<SERVER>'
+            };
+            await db.instance_record_queue.insertOne(newObj);
+        }
+    }
+};
+
+UUFlowManager.distributedInstancesRemind = async function (instance) {
+    if (!instance?.distribute_from_instances?.length) return;
+
+    try {
+        const flow = await db.flows.findOne({ _id: instance.flow });
+        const current_trace = instance.traces[instance.traces.length - 1];
+        let next_step_id;
+
+        if (instance.state === "draft") {
+            const next_approves = current_trace?.approves;
+            if (next_approves?.length === 1) {
+                next_step_id = next_approves[0]?.next_steps?.[0]?.step;
+            }
+        } else {
+            next_step_id = current_trace?.step;
+        }
+
+        if (next_step_id) {
+            const next_step = await UUFlowManager.getStep(instance, flow, next_step_id);
+            if (next_step?.step_type === "end") {
+                const original_instacne_id = instance.distribute_from_instances[0];
+                const original_instacne = await db.instances.findOne(
+                    { _id: original_instacne_id },
+                    { projection: { flow: 1, name: 1, space: 1, created_by: 1 } }
+                );
+
+                const original_flow = await db.flows.findOne(
+                    { _id: original_instacne?.flow },
+                    { projection: { distribute_end_notification: 1 } }
+                );
+
+                if (original_flow?.distribute_end_notification) {
+                    const original_user = await db.users.findOne(
+                        { _id: instance.created_by }
+                    );
+
+                    if (original_user) {
+                        const lang = original_user.locale === 'zh-cn' ? 'zh-CN' : 'en';
+                        const notification = {
+                            createdAt: new Date(),
+                            createdBy: '<SERVER>',
+                            from: 'workflow',
+                            title: original_user.name,
+                            text: t('instance.push.body.distribute_remind', {
+                                instance_name: instance.name
+                            }, lang),
+                            payload: {
+                                space: original_instacne?.space,
+                                instance: original_instacne?._id,
+                                host: Meteor.absoluteUrl().slice(0, -1),
+                                requireInteraction: true
+                            },
+                            query: {
+                                userId: original_user._id,
+                                appName: 'workflow'
+                            }
+                        };
+                        await Push.send(notification);
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error(error.stack);
+    }
+};
+
+UUFlowManager.getAgent = async function (spaceId, fromId) {
+    const coll = await getCollection('process_delegation_rules');
+    const now = new Date();
+    const r = await coll.findOne({
+        space: spaceId,
+        from: fromId,
+        enabled: true,
+        start_time: { $lte: now },
+        end_time: { $gte: now }
+    });
+    return r?.to;
+};
+////////////
+
+UUFlowManager.cancelProcessDelegation = async function (spaceId, toId) {
+    const db = {
+        instances: await getCollection('instances')
+    };
+
+    // Query for inbox users
+    const inboxQuery = {
+        space: spaceId,
+        inbox_users: toId,
+        traces: {
+            $elemMatch: {
+                is_finished: false,
+                approves: {
+                    $elemMatch: {
+                        is_finished: false,
+                        agent: toId
+                    }
+                }
+            }
+        }
+    };
+
+    const inboxInstances = await db.instances.find(inboxQuery, {
+        projection: {
+            inbox_users: 1,
+            traces: 1,
+            state: 1
+        }
+    }).toArray();
+
+    await Promise.all(inboxInstances.map(async (ins) => {
+        const trace = ins.traces.find(t => !t.is_finished);
+        if (!trace) return;
+
+        await Promise.all(trace.approves.map(async (a, idx) => {
+            if (!a.is_finished) {
+                if (a.agent === toId) {
+                    const next_step_space_user = await UUFlowManager.getSpaceUser(spaceId, a.user);
+                    const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                    
+                    const idxStr = `traces.$.approves.${idx}.`;
+                    const setObj = {
+                        [idxStr + 'handler']: a.user,
+                        [idxStr + 'handler_name']: a.user_name,
+                        [idxStr + 'handler_organization']: next_step_user_org_info.organization,
+                        [idxStr + 'handler_organization_name']: next_step_user_org_info.organization_name,
+                        [idxStr + 'handler_organization_fullname']: next_step_user_org_info.organization_fullname,
+                        [idxStr + 'agent']: null,
+                        inbox_users: ins.inbox_users.map(u => u === toId ? a.user : u)
+                    };
+
+                    if (ins.state === 'draft') {
+                        setObj.submitter = a.user;
+                        setObj.submitter_name = a.user_name;
+                    }
+
+                    await db.instances.updateOne({
+                        _id: ins._id,
+                        inbox_users: toId,
+                        'traces._id': a.trace
+                    }, { $set: setObj });
+
+                    await update_instance_tasks(ins._id, a.trace, a._id);
+                    await pushManager.send_message_to_specifyUser('current_user', a.user);
+                    await pushManager.send_message_to_specifyUser('current_user', toId);
+                } else if (a.user === toId) {
+                    await db.instances.updateOne(
+                        { _id: ins._id },
+                        { $addToSet: { inbox_users: toId } }
+                    );
+                }
+            }
+        }));
+    }));
+
+    // Query for CC users
+    const ccQuery = {
+        space: spaceId,
+        cc_users: toId,
+        'traces.approves': {
+            $elemMatch: {
+                is_finished: false,
+                agent: toId,
+                type: 'cc'
+            }
+        }
+    };
+
+    const ccInstances = await db.instances.find(ccQuery, {
+        projection: {
+            cc_users: 1,
+            traces: 1
+        }
+    }).toArray();
+
+    await Promise.all(ccInstances.map(async (ins) => {
+        await Promise.all(ins.traces.map(async (t) => {
+            await Promise.all(t.approves.map(async (a, idx) => {
+                if (!a.is_finished && a.type === 'cc') {
+                    if (a.agent === toId) {
+                        const next_step_space_user = await UUFlowManager.getSpaceUser(spaceId, a.user);
+                        const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+                        
+                        const idxStr = `traces.$.approves.${idx}.`;
+                        const setObj = {
+                            [idxStr + 'handler']: a.user,
+                            [idxStr + 'handler_name']: a.user_name,
+                            [idxStr + 'handler_organization']: next_step_user_org_info.organization,
+                            [idxStr + 'handler_organization_name']: next_step_user_org_info.organization_name,
+                            [idxStr + 'handler_organization_fullname']: next_step_user_org_info.organization_fullname,
+                            [idxStr + 'agent']: null,
+                            cc_users: ins.cc_users.map(u => u === toId ? a.user : u)
+                        };
+
+                        await db.instances.updateOne({
+                            _id: ins._id,
+                            cc_users: toId,
+                            'traces._id': a.trace
+                        }, { $set: setObj });
+
+                        await update_instance_tasks(ins._id, a.trace, a._id);
+                        await pushManager.send_message_to_specifyUser('current_user', a.user);
+                        await pushManager.send_message_to_specifyUser('current_user', toId);
+                    } else if (a.user === toId) {
+                        await db.instances.updateOne(
+                            { _id: ins._id },
+                            { $addToSet: { cc_users: toId } }
+                        );
+                    }
+                    await UUFlowManager.updateCCcount(ins._id);
+                }
+            }));
+        }));
+    }));
+};
+
+UUFlowManager.updateCCcount = async function (insId) {
+    const db = {
+        instances: await getCollection('instances')
+    };
+
+    const insDoc = await db.instances.findOne(
+        { _id: insId },
+        { projection: { cc_users: 1 } }
+    );
+
+    if (insDoc?.cc_users) {
+        await db.instances.updateOne(
+            { _id: insId },
+            { $set: { cc_count: insDoc.cc_users.length } }
+        );
+    }
+};
+
+UUFlowManager.timeoutAutoSubmit = async function (ins_id) {
+    const db = {
+        instances: await getCollection('instances')
+    };
+
+    const query = {
+        state: 'pending',
+        current_step_auto_submit: true,
+        traces: {
+            $elemMatch: {
+                is_finished: false,
+                due_date: { $lte: new Date() }
+            }
+        }
+    };
+
+    if (ins_id) {
+        query._id = ins_id;
+    }
+
+    const instances = await db.instances.find(query).toArray();
+
+    await Promise.all(instances.map(async (ins) => {
+        try {
+            const flow_id = ins.flow;
+            const instance_id = ins._id;
+            const trace = ins.traces[ins.traces.length - 1];
+            const flow = await UUFlowManager.getFlow(flow_id);
+            const step = await UUFlowManager.getStep(ins, flow, trace.step);
+            const step_type = step.step_type;
+            
+            const toLine = step.lines.find(l => l.timeout_line === true);
+            if (!toLine) return;
+
+            let nextStepId = toLine.to_step;
+            let nextStep = await UUFlowManager.getStep(ins, flow, nextStepId);
+
+            if (nextStep.step_type === 'condition') {
+                const nextSteps = await UUFlowManager.getNextSteps(ins, flow, nextStep, "");
+                console.error(nextSteps);
+                nextStepId = nextSteps[0];
+                nextStep = await UUFlowManager.getStep(ins, flow, nextStepId);
+            }
+
+            const nextUserIds = await await HandlersManager.getHandlers(instance_id, nextStepId);
+            const judge = step_type === "sign" ? "approved" : "submitted";
+
+            const approve_from_client = {
+                instance: instance_id,
+                trace: trace._id,
+                judge: judge,
+                next_steps: [{
+                    step: nextStepId,
+                    users: nextUserIds
+                }]
+            };
+
+            await Promise.all(trace.approves.map(async (a) => {
+                approve_from_client._id = a._id;
+                const current_user_info = await db.users.findOne(
+                    { _id: a.handler },
+                    { projection: { services: 0 } }
+                );
+
+                const updatedInstance = await UUFlowManager.workflow_engine(
+                    approve_from_client, 
+                    current_user_info, 
+                    current_user_info._id, 
+                    true
+                );
+
+                await pushManager.send_instance_notification(
+                    "auto_submit_pending_inbox", 
+                    updatedInstance, 
+                    "", 
+                    current_user_info
+                );
+            }));
+        } catch (error) {
+            console.error('AUTO TIMEOUT_AUTO_SUBMIT ERROR: ', error.stack);
+        }
+    }));
+
+    return true;
+};
+
+UUFlowManager.relocate = async function (instance_from_client, current_user_info) {
+    const db = {
+        instances: await getCollection('instances'),
+        users: await getCollection('users'),
+        organizations: await getCollection('organizations'),
+        spaces: await getCollection('spaces')
+    };
+
+    const current_user = current_user_info._id;
+    const instance = await UUFlowManager.getInstance(instance_from_client._id);
+    const last_trace = instance.traces[instance.traces.length - 1];
+
+    // Verify permissions
+    const permissions = await PermissionManager.getFlowPermissions(instance.flow, current_user);
+    const space = await db.spaces.findOne(
+        { _id: instance.space },
+        { projection: { admins: 1 } }
+    );
+
+    if (!permissions.includes("admin") && !space?.admins?.includes(current_user)) {
+        throw new Error('用户没有对当前流程的管理权限');
+    }
+
+    const space_id = instance.space;
+    const instance_id = last_trace.instance;
+    const inbox_users = instance.inbox_users || [];
+    const relocate_inbox_users = instance_from_client.relocate_inbox_users || [];
+    const relocate_comment = instance_from_client.relocate_comment;
+    const relocate_next_step = instance_from_client.relocate_next_step;
+
+    const not_in_inbox_users = inbox_users.filter(u => !relocate_inbox_users.includes(u));
+    const new_inbox_users = relocate_inbox_users.filter(u => !inbox_users.includes(u));
+    const approve_users = [];
+
+    const flow = await UUFlowManager.getFlow(instance.flow);
+    const next_step = await UUFlowManager.getStep(instance, flow, relocate_next_step);
+    const next_step_type = next_step.step_type;
+    const next_step_name = next_step.name;
+
+    const current_setp = await UUFlowManager.getStep(instance, flow, last_trace.step);
+    const current_setp_type = current_setp.step_type;
+
+    const traces = instance.traces;
+    const setObj = {};
+    setObj.values = await UUFlowManager.getUpdatedValues(instance);
+
+    const now = new Date();
+    const finishedApproveIds = [];
+
+    // Update traces and approves
+    for (let i = 0; i < traces.length; i++) {
+        if (traces[i]._id === last_trace._id) {
+            if (!traces[i].approves) {
+                traces[i].approves = [];
+            }
+
+            // Update current trace.approve records
+            for (let h = 0; h < traces[i].approves.length; h++) {
+                const a = traces[i].approves[h];
+                if (!a.is_finished && a.type !== "cc" && a.type !== "distribute") {
+                    traces[i].approves[h] = {
+                        ...a,
+                        start_date: now,
+                        finish_date: now,
+                        read_date: now,
+                        is_error: false,
+                        is_read: true,
+                        is_finished: true,
+                        judge: "terminated",
+                        cost_time: now - a.start_date
+                    };
+
+                    approve_users.push(a.user);
+                    finishedApproveIds.push(a._id);
+
+                    // Handle sign_show logic
+                    if (a.sign_show === true) {
+                        const sameTraces = traces.filter(t => t.step === traces[i].step);
+                        let signShowApproveId = null;
+
+                        for (let l = sameTraces.length - 1; l >= 0; l--) {
+                            const found = sameTraces[l].approves.find(a => 
+                                a.user === traces[i].approves[h].user && 
+                                a.judge !== "terminated" && 
+                                a.description
+                            );
+                            if (found) {
+                                signShowApproveId = found._id;
+                                break;
+                            }
+                        }
+
+                        if (signShowApproveId) {
+                            for (const trace of traces) {
+                                for (const approve of trace.approves) {
+                                    if (approve._id === signShowApproveId) {
+                                        approve.sign_show = true;
+                                        traces[i].approves[h].sign_show = false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Add relocation approver record
+            const current_space_user = await UUFlowManager.getSpaceUser(space_id, current_user);
+            const current_user_organization = await db.organizations.findOne(
+                { _id: current_space_user.organization },
+                { projection: { name: 1, fullname: 1 } }
+            );
+
+            const relocate_appr = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                trace: traces[i]._id,
+                is_finished: true,
+                user: current_user,
+                user_name: current_user_info.name,
+                handler: current_user,
+                handler_name: current_user_info.name,
+                handler_organization: current_space_user.organization,
+                handler_organization_name: current_user_organization.name,
+                handler_organization_fullname: current_user_organization.fullname,
+                start_date: now,
+                finish_date: now,
+                due_date: traces[i].due_date,
+                read_date: now,
+                judge: "relocated",
+                is_read: true,
+                description: relocate_comment,
+                is_error: false,
+                values: {},
+                cost_time: 0
+            };
+
+            traces[i].approves.push(relocate_appr);
+            traces[i].is_finished = true;
+            traces[i].finish_date = now;
+            traces[i].judge = "relocated";
+        }
+    }
+
+    // Create new trace
+    let newTrace;
+    if (next_step_type === "end") {
+        newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [last_trace._id],
+            is_finished: true,
+            step: relocate_next_step,
+            name: next_step_name,
+            start_date: now,
+            finish_date: now,
+            approves: []
+        };
+
+        setObj.state = "completed";
+        setObj.inbox_users = [];
+        setObj.final_decision = "terminated";
+        setObj.finish_date = new Date();
+        setObj.current_step_name = next_step_name;
+        setObj.current_step_auto_submit = false;
+    } else {
+        newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [last_trace._id],
+            is_finished: false,
+            step: relocate_next_step,
+            name: next_step_name,
+            start_date: now,
+            due_date: await UUFlowManager.getDueDate(next_step.timeout_hours, space_id),
+            approves: []
+        };
+
+        await Promise.all(relocate_inbox_users.map(async (next_step_user_id, idx) => {
+            const user_info = await db.users.findOne(
+                { _id: next_step_user_id },
+                { projection: { name: 1 } }
+            );
+
+            let handler_id = next_step_user_id;
+            let handler_info = user_info;
+            let agent = await UUFlowManager.getAgent(space_id, next_step_user_id);
+
+            if (agent) {
+                relocate_inbox_users[idx] = agent;
+                handler_id = agent;
+                handler_info = await db.users.findOne(
+                    { _id: agent },
+                    { projection: { name: 1 } }
+                );
+            }
+
+            const next_step_space_user = await UUFlowManager.getSpaceUser(space_id, handler_id);
+            const next_step_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(next_step_space_user);
+
+            const newApprove = {
+                _id: _makeNewID(),
+                instance: instance_id,
+                trace: newTrace._id,
+                is_finished: false,
+                user: next_step_user_id,
+                user_name: user_info.name,
+                handler: handler_id,
+                handler_name: handler_info.name,
+                handler_organization: next_step_user_org_info.organization,
+                handler_organization_name: next_step_user_org_info.organization_name,
+                handler_organization_fullname: next_step_user_org_info.organization_fullname,
+                start_date: now,
+                due_date: newTrace.due_date,
+                is_read: false,
+                is_error: false,
+                values: {},
+                ...(agent ? { agent } : {})
+            };
+
+            await UUFlowManager.setRemindInfo(instance.values, newApprove);
+            newTrace.approves.push(newApprove);
+        }));
+
+        setObj.inbox_users = relocate_inbox_users;
+        setObj.state = "pending";
+        setObj.current_step_name = next_step_name;
+        setObj.current_step_auto_submit = await UUFlowManager.getCurrentStepAutoSubmit(flow.timeout_auto_submit, next_step.lines);
+    }
+
+    // Update outbox users
+    const outbox_users = [...new Set([
+        current_user,
+        ...(instance.outbox_users || []),
+        ...inbox_users,
+        ...approve_users
+    ])];
+
+    setObj.outbox_users = outbox_users;
+    setObj.modified = now;
+    setObj.modified_by = current_user;
+    setObj.is_archived = false;
+    traces.push(newTrace);
+    setObj.traces = traces;
+
+    // Update instance
+    const updateOperation = setObj.state === 'completed' 
+        ? { $set: setObj }
+        : { $set: setObj, $unset: { finish_date: 1 } };
+
+    const result = await db.instances.updateOne(
+        { _id: instance_id },
+        updateOperation
+    );
+
+    if (result.modifiedCount > 0) {
+        // Update instance tasks
+        await remove_many_instance_tasks(finishedApproveIds);
+        if (newTrace.approves?.length) {
+            await insert_many_instance_tasks(
+                instance_id, 
+                newTrace._id, 
+                newTrace.approves.map(a => a._id)
+            );
+        }
+
+        const updatedInstance = await UUFlowManager.getInstance(instance_id);
+
+        // Send notifications
+        await pushManager.send_message_current_user(current_user_info);
+        await Promise.all(not_in_inbox_users
+            .filter(user_id => user_id !== current_user)
+            .map(user_id => pushManager.send_message_to_specifyUser("current_user", user_id))
+        );
+
+        const notifyUsers = [...new Set([
+            updatedInstance.applicant,
+            updatedInstance.submitter,
+            ...(updatedInstance.outbox_users || [])
+        ])];
+
+        await Promise.all(notifyUsers.map(user_id => 
+            pushManager.send_message_to_specifyUser("current_user", user_id)
+        ));
+
+        await pushManager.send_instance_notification(
+            "reassign_new_inbox_users", 
+            updatedInstance, 
+            relocate_comment, 
+            current_user_info
+        );
+
+        await pushManager.triggerWebhook(
+            updatedInstance.flow, 
+            updatedInstance, 
+            {}, 
+            'relocate', 
+            current_user, 
+            updatedInstance.inbox_users
+        );
+    }
+
+    return result;
+};
+
+UUFlowManager.draft_save_instance = async function (ins, userId) {
+    const db = {
+        instances: await getCollection('instances'),
+        flows: await getCollection('flows'),
+        forms: await getCollection('forms'),
+        users: await getCollection('users'),
+        organizations: await getCollection('organizations'),
+    };
+
+    let result = true;
+    const setObj = {};
+    const ins_id = ins._id;
+    const trace_id = ins.traces[0]._id;
+    const approve_id = ins.traces[0].approves[0]._id;
+    const description = ins.traces[0].approves[0].description;
+    const next_steps = ins.traces[0].approves[0].next_steps;
+    const values = ins.traces[0].approves[0].values || {};
+    const applicant_id = ins.applicant;
+
+    const instance = await db.instances.findOne(
+        { _id: ins_id },
+        { 
+            projection: {
+                applicant: 1,
+                state: 1,
+                submitter: 1,
+                traces: 1,
+                form: 1,
+                flow_version: 1,
+                space: 1,
+                flow: 1
+            }
+        }
+    );
+
+    const space_id = instance.space;
+    const flow_id = instance.flow;
+    const form_id = instance.form;
+    const traces = instance.traces;
+    const current_trace = traces.find(t => t._id === trace_id);
+    const index = current_trace.approves.findIndex(a => a._id === approve_id);
+    const key_str = `traces.$.approves.${index}.`;
+
+    // Verify instance state and permissions
+    const current_user = await db.users.findOne(
+        { _id: userId },
+        { projection: { locale: 1 } }
+    );
+    const lang = current_user?.locale === 'zh-cn' ? 'zh-CN' : 'en';
+    
+    UUFlowManager.isInstanceDraft(instance, lang);
+    UUFlowManager.isInstanceSubmitter(instance, userId);
+
+    const flow = await db.flows.findOne(
+        { _id: flow_id },
+        { 
+            projection: {
+                'current._id': 1,
+                'current.form_version': 1,
+                'name': 1,
+                'current.steps': 1
+            }
+        }
+    );
+
+    setObj.modified = new Date();
+    setObj.modified_by = userId;
+
+    if (flow.current._id !== instance.flow_version) {
+        result = 'upgraded';
+        const start_step = flow.current.steps.find(s => s.step_type === 'start');
+        
+        setObj.flow_version = flow.current._id;
+        setObj.form_version = flow.current.form_version;
+        setObj['traces.$.step'] = start_step._id;
+        setObj['traces.$.name'] = start_step.name;
+    }
+
+    if (instance.applicant !== applicant_id) {
+        const [user, applicant] = await Promise.all([
+            db.users.findOne(
+                { _id: applicant_id },
+                { projection: { name: 1 } }
+            ),
+            db.space_users.findOne(
+                { space: space_id, user: applicant_id },
+                { projection: { organization: 1 } }
+            )
+        ]);
+
+        if (user && applicant) {
+            const organization = await db.organizations.findOne(
+                { _id: applicant.organization },
+                { projection: { name: 1, fullname: 1 } }
+            );
+
+            setObj.applicant = applicant_id;
+            setObj.applicant_name = user.name;
+            setObj.applicant_organization = applicant.organization;
+            setObj.applicant_organization_name = organization.name;
+            setObj.applicant_organization_fullname = organization.fullname;
+            setObj[key_str + 'user'] = applicant_id;
+            setObj[key_str + 'user_name'] = user.name;
+        }
+    }
+
+    setObj[key_str + 'values'] = values;
+    setObj[key_str + 'description'] = description;
+    setObj[key_str + 'judge'] = 'submitted';
+    setObj[key_str + 'read_date'] = new Date();
+
+    if (result !== 'upgraded' && next_steps) {
+        setObj[key_str + 'next_steps'] = next_steps;
+    }
+
+    // Calculate instance name
+    const form = await db.forms.findOne(
+        { _id: form_id },
+        { projection: { 'current.name_forumla': 1 } }
+    );
+
+    if (form?.current?.name_forumla) {
+        setObj.name = await UUFlowManager.getInstanceName(ins, values);
+    }
+
+    await db.instances.updateOne(
+        { _id: ins_id, 'traces._id': trace_id },
+        { $set: setObj }
+    );
+
+    await update_instance_tasks(ins_id, trace_id, approve_id);
+    return result;
+};
+
+UUFlowManager.caculateExtras = async function (values = {}, formDoc, formVersionId) {
+    if (_.isEmpty(values)) return;
+
+    const extras = {};
+    const formVersion = await UUFlowManager.getFormVersion(formDoc, formVersionId);
+    
+    formVersion.fields.forEach(field => {
+        if (field.is_list_display) {
+            extras[field.code] = values[field.code];
+        } else if (field.type === 'table' && values[field.code]) {
+            const tableExtras = values[field.code]
+                .map(s_value => {
+                    const rowValues = {};
+                    field.fields.forEach(s_field => {
+                        if (s_field.is_list_display && s_value[s_field.code] !== undefined) {
+                            rowValues[s_field.code] = s_value[s_field.code];
+                        }
+                    });
+                    return _.isEmpty(rowValues) ? null : rowValues;
+                })
+                .filter(Boolean);
+
+            if (tableExtras.length) {
+                extras[field.code] = tableExtras;
+            }
+        } else if (field.type === 'section') {
+            field.fields.forEach(s_field => {
+                if (s_field.is_list_display && values[s_field.code] !== undefined) {
+                    extras[s_field.code] = values[s_field.code];
+                }
+            });
+        }
+    });
+
+    return _.isEmpty(extras) ? undefined : extras;
+};
+
+module.exports = UUFlowManager;