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

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

@@ -0,0 +1,202 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2022-09-15 13:09:51
+ * @LastEditors: sunhaolin@hotoa.com
+ * @LastEditTime: 2023-01-14 11:22:30
+ * @Description: 
+ */
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require('lodash');
+const Fiber = function(fun){console.log('TODO Fiber...')}
+const pushManager = require('../manager/push_manager');
+const objectql = require('@steedos/objectql');
+const {
+    update_instance_tasks,
+    insert_instance_tasks
+} = require('../manager/instance_tasks_manager')
+const UUFlowManager = require('../manager/uuflow_manager');
+router.post('/api/workflow/v2/instance/return', requireAuthentication, async function (req, res) {
+    try {
+        let userSession = req.user;
+        const { approve, reason } = req.body;
+
+        Fiber(async function () {
+            try {
+                var approve_values, b, current_step, current_user, current_user_info, flow, ins, instance, instance_id, last_trace, newTrace, new_inbox_users, now, pre_step, pre_trace, r, rest_counter_users, setObj, space_id, traces;
+                current_user = userSession.userId;
+                instance_id = approve.instance;
+                ins = UUFlowManager.getInstance(instance_id);
+                space_id = ins.space;
+                if (ins.state !== "pending" || !ins.inbox_users.includes(current_user)) {
+                    throw new Error("不符合退回条件");
+                }
+                if (approve.type === "cc" && ins.cc_users.includes(current_user)) {
+                    throw new Error("不符合退回条件");
+                }
+                if (ins.traces.length < 2) {
+                    throw new Error("不符合退回条件");
+                }
+                flow = UUFlowManager.getFlow(ins.flow);
+                pre_trace = ins.traces[ins.traces.length - 2];
+                pre_step = UUFlowManager.getStep(ins, flow, pre_trace.step);
+                if (pre_step.step_type === "counterSign") {
+                    throw new Error("不符合退回条件");
+                }
+                last_trace = _.last(ins.traces);
+                current_step = UUFlowManager.getStep(ins, flow, last_trace.step);
+                if (current_step.step_type !== "submit" && current_step.step_type !== "sign" && current_step.step_type !== "counterSign") {
+                    throw new Error("不符合退回条件");
+                }
+                if (approve.trace !== last_trace._id) {
+                    throw new Error("不符合退回条件");
+                }
+                new_inbox_users = new Array;
+                _.each(pre_trace.approves, function (a) {
+                    if ((!a.type || a.type === "draft" || a.type === "reassign") && (!a.judge || a.judge === "submitted" || a.judge === "approved" || a.judge === "rejected")) {
+                        return new_inbox_users.push(a.user);
+                    }
+                });
+                if (_.isEmpty(new_inbox_users)) {
+                    throw new Error("未找到下一步处理人，退回失败");
+                }
+                traces = ins.traces;
+                approve_values = UUFlowManager.getApproveValues(approve.values || {}, current_step.permissions, ins.form, ins.form_version);
+                setObj = new Object;
+                now = new Date;
+                rest_counter_users = new Array;
+                _.each(traces, function (t) {
+                    if (t._id === last_trace._id) {
+                        if (!t.approves) {
+                            t.approves = new Array;
+                        }
+                        _.each(t.approves, function (a, idx) {
+                            if ((!a.type || a.type === "reassign") && (!a.judge || a.judge === "submitted" || a.judge === "approved" || a.judge === "rejected" || a.judge === "readed") && a.is_finished !== true) {
+                                setObj['traces.$.approves.' + idx + '.finish_date'] = now;
+                                setObj['traces.$.approves.' + idx + '.read_date'] = now;
+                                setObj['traces.$.approves.' + idx + '.is_error'] = false;
+                                setObj['traces.$.approves.' + idx + '.is_read'] = true;
+                                setObj['traces.$.approves.' + idx + '.is_finished'] = true;
+                                setObj['traces.$.approves.' + idx + '.cost_time'] = now - a.start_date;
+                                setObj['traces.$.approves.' + idx + '.values'] = approve_values;
+                                if (a.handler === current_user) {
+                                    setObj['traces.$.approves.' + idx + '.judge'] = "returned";
+                                    return setObj['traces.$.approves.' + idx + '.description'] = reason;
+                                } else {
+                                    return rest_counter_users.push(a.handler);
+                                }
+                            }
+                        });
+                        setObj['traces.$.is_finished'] = true;
+                        setObj['traces.$.finish_date'] = true;
+                        return setObj['traces.$.judge'] = "returned";
+                    }
+                });
+                ins.values = _.extend(ins.values || {}, approve_values);
+                newTrace = new Object;
+                newTrace._id = _makeNewID();
+                newTrace.instance = instance_id;
+                newTrace.previous_trace_ids = [last_trace._id];
+                newTrace.is_finished = false;
+                newTrace.step = pre_trace.step;
+                newTrace.name = pre_trace.name;
+                newTrace.start_date = now;
+                newTrace.due_date = UUFlowManager.getDueDate(pre_step.timeout_hours, space_id);
+                newTrace.approves = [];
+                _.each(new_inbox_users, function (next_step_user_id, idx) {
+                    var agent, handler_id, handler_info, newApprove, next_step_space_user, next_step_user_org_info, user_info;
+                    newApprove = new Object;
+                    newApprove._id = _makeNewID();
+                    newApprove.instance = instance_id;
+                    newApprove.trace = newTrace._id;
+                    newApprove.is_finished = false;
+                    newApprove.user = next_step_user_id;
+                    user_info = db.users.findOne(next_step_user_id, {
+                        fields: {
+                            name: 1
+                        }
+                    });
+                    newApprove.user_name = user_info.name;
+                    handler_id = next_step_user_id;
+                    handler_info = user_info;
+                    agent = UUFlowManager.getAgent(space_id, next_step_user_id);
+                    if (agent) {
+                        new_inbox_users[idx] = agent;
+                        handler_id = agent;
+                        handler_info = db.users.findOne({
+                            _id: agent
+                        }, {
+                            fields: {
+                                name: 1
+                            }
+                        });
+                        newApprove.agent = agent;
+                    }
+                    newApprove.handler = handler_id;
+                    newApprove.handler_name = handler_info.name;
+                    next_step_space_user = UUFlowManager.getSpaceUser(space_id, handler_id);
+                    next_step_user_org_info = 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 = now;
+                    newApprove.is_read = false;
+                    newApprove.is_error = false;
+                    newApprove.values = new Object;
+                    UUFlowManager.setRemindInfo(ins.values, newApprove);
+                    return newTrace.approves.push(newApprove);
+                });
+                setObj.inbox_users = new_inbox_users;
+                setObj.state = "pending";
+                ins.outbox_users.push(current_user);
+                setObj.outbox_users = _.uniq(ins.outbox_users);
+                setObj.modified = now;
+                setObj.modified_by = current_user;
+                setObj.values = ins.values;
+                setObj.current_step_name = pre_trace.name;
+                r = db.instances.update({
+                    _id: instance_id,
+                    'traces._id': last_trace._id
+                }, {
+                    $set: setObj
+                });
+                // 更新当前记录
+                update_instance_tasks(instance_id, last_trace._id, approve._id)
+                b = db.instances.update({
+                    _id: instance_id
+                }, {
+                    $push: {
+                        traces: newTrace
+                    }
+                });
+                // 生成新记录
+                insert_instance_tasks(instance_id, newTrace._id, newTrace.approves[0]._id)
+                if (r && b) {
+                    pushManager.send_message_to_specifyUser("current_user", current_user);
+                    instance = UUFlowManager.getInstance(instance_id);
+                    current_user_info = db.users.findOne(current_user);
+                    pushManager.send_instance_notification("return_pending_inbox", instance, reason, current_user_info);
+                    _.each(rest_counter_users, function (user_id) {
+                        return pushManager.send_message_to_specifyUser("current_user", user_id);
+                    });
+                    pushManager.triggerWebhook(instance.flow, instance, {}, 'return', current_user, instance.inbox_users);
+                }
+                res.status(200).send({});
+            } catch (error) {
+                console.error(error);
+                res.status(200).send({
+                    error: error.message
+                });
+            }
+
+        }).run()
+
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            error: error.message
+        });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,33 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2022-09-15 13:09:51
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2022-09-21 11:37:30
+ * @Description: 
+ */
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require('lodash');
+const objectql = require('@steedos/objectql');
+const UUFlowManager = require('../manager/uuflow_manager');
+router.post('/api/workflow/v2/instance/save', requireAuthentication, async function (req, res) {
+    try {
+        let userSession = req.user;
+        const { instance } = req.body;
+        const record = await objectql.getObject('instances').findOne(instance._id, {fields:[
+            'flow','form','applicant_name','applicant_organization','applicant_organization_fullname','applicant_organization_name',
+            'code', 'flow_version', 'form_version', 'submit_date'
+        ]});
+        const ins = await UUFlowManager.draft_save_instance(Object.assign(record, instance), userSession.userId);
+        res.status(200).send({
+            'instance': ins
+        });
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            error: error.message
+        });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,216 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2022-09-15 13:09:51
+ * @LastEditors: sunhaolin@hotoa.com
+ * @LastEditTime: 2023-10-08 Updated to use new utils and async/await
+ * @Description: Refactored to use async/await and new utils
+ */
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const _ = require("lodash");
+const {
+    remove_many_instance_tasks,
+} = require('../manager/instance_tasks_manager')
+const PermissionManager = require('../manager/permission_manager');
+const UUFlowManager = require('../manager/uuflow_manager');
+const pushManager = require('../manager/push_manager');
+const { _makeNewID, getCollection } = require('../utils/collection');
+
+/**
+ * Terminate a workflow instance
+ */
+router.post("/api/workflow/v2/instance/terminate", requireAuthentication, async function (req, res) {
+    try {
+        const userSession = req.user;
+        const { terminate_reason, instance_id } = req.body;
+        
+        if (!terminate_reason) {
+            throw new Error("还未填写强制结束申请单的理由，操作失败");
+        }
+        if (!instance_id) {
+            throw new Error("instance_id is required");
+        }
+
+        const current_user_info = userSession;
+        const current_user = current_user_info.userId;
+
+        // Get necessary data
+        const instance = await UUFlowManager.getInstance(instance_id);
+        const space_id = instance.space;
+        const flow_id = instance.flow;
+
+        const [space, flow] = await Promise.all([
+            UUFlowManager.getSpace(space_id),
+            UUFlowManager.getFlow(flow_id)
+        ]);
+
+        // Validate instance status
+        await UUFlowManager.isInstancePending(instance);
+
+        // Get user and org info
+        const space_user = await UUFlowManager.getSpaceUser(space_id, current_user);
+        const space_user_org_info = await UUFlowManager.getSpaceUserOrgInfo(space_user);
+
+        // Find flow version matching instance
+        const flow_vers = [flow.current, ...(flow.historys || [])];
+        const instance_flow_ver = flow_vers.find(f_ver => f_ver._id === instance.flow_version);
+        if (!instance_flow_ver) {
+            throw new Error("未找到申请单对应流程版本");
+        }
+
+        // Find end step
+        const flow_ver_end_step = instance_flow_ver.steps.find(step => step.step_type === "end");
+        if (!flow_ver_end_step) {
+            throw new Error("流程版本中未找到结束节点");
+        }
+
+        // Check permissions
+        const permissions = await PermissionManager.getFlowPermissions(flow_id, current_user);
+        const hasPermission = permissions.includes("admin") || 
+                             space.admins.includes(current_user) || 
+                             instance.submitter === current_user || 
+                             instance.applicant === current_user;
+        if (!hasPermission) {
+            throw new Error("无权终止此申请单");
+        }
+
+        const now = new Date();
+        const setObj = {};
+        const instance_trace = instance.traces.find(trace => !trace.is_finished);
+        if (!instance_trace) {
+            throw new Error("未找到未完成的流程轨迹");
+        }
+
+        // Process traces and approves
+        const traces = _.cloneDeep(instance.traces);
+        const finishedApproveIds = [];
+
+        for (const trace of traces) {
+            if (!trace.is_finished) {
+                trace.is_finished = true;
+                trace.finish_date = now;
+
+                for (const approve of trace.approves) {
+                    if (!approve.is_finished) {
+                        approve.is_finished = true;
+                        approve.finish_date = now;
+                        approve.judge = null;
+                        approve.description = null;
+                        finishedApproveIds.push(approve._id);
+                    }
+                }
+
+                // Add new terminate approve
+                const newApprove = {
+                    _id: _makeNewID(),
+                    instance: instance_id,
+                    trace: instance_trace._id,
+                    is_finished: true,
+                    user: current_user,
+                    user_name: current_user_info.name,
+                    handler: current_user,
+                    handler_name: current_user_info.name,
+                    handler_organization: space_user_org_info.organization,
+                    handler_organization_name: space_user_org_info.organization_name,
+                    handler_organization_fullname: space_user_org_info.organization_fullname,
+                    start_date: now,
+                    finish_date: now,
+                    due_date: instance_trace.due_date,
+                    read_date: now,
+                    judge: "terminated",
+                    is_read: true,
+                    description: terminate_reason,
+                    is_error: false,
+                    values: {},
+                    cost_time: 0 // Will be calculated below
+                };
+                newApprove.cost_time = newApprove.finish_date - newApprove.start_date;
+                trace.approves.push(newApprove);
+            }
+        }
+
+        // Add new terminate trace
+        const newTrace = {
+            _id: _makeNewID(),
+            instance: instance_id,
+            previous_trace_ids: [instance_trace._id],
+            is_finished: true,
+            step: flow_ver_end_step._id,
+            name: flow_ver_end_step.name,
+            start_date: now,
+            finish_date: now,
+            judge: "terminated"
+        };
+
+        // Prepare update object
+        const old_inbox_users = instance.inbox_users || [];
+        const old_cc_users = instance.cc_users || [];
+        const old_outbox_users = instance.outbox_users || [];
+        
+        const tempUsers = [];
+        instance_trace.approves.forEach(approve => {
+            tempUsers.push(approve.user);
+            tempUsers.push(approve.handler);
+        });
+
+        setObj.state = "completed";
+        setObj.final_decision = "terminated";
+        setObj.outbox_users = _.uniq([...old_outbox_users, ...tempUsers]);
+        setObj.inbox_users = [];
+        setObj.cc_users = [];
+        setObj.modified = now;
+        setObj.modified_by = current_user;
+        setObj.traces = [...traces, newTrace];
+        setObj.current_step_name = flow_ver_end_step.name;
+        setObj.current_step_auto_submit = false;
+
+        // Update instance
+        const instancesCollection = await getCollection('instances');
+        const result = await instancesCollection.updateOne(
+            { _id: instance_id },
+            { $set: setObj }
+        );
+
+        if (result.modifiedCount > 0) {
+            // Remove instance tasks
+            await remove_many_instance_tasks(finishedApproveIds);
+
+            // Send notifications
+            const updatedInstance = await UUFlowManager.getInstance(instance_id);
+            await pushManager.send_instance_notification(
+                "submit_terminate_applicant",
+                updatedInstance,
+                terminate_reason,
+                current_user_info
+            );
+
+            // Notify all involved users
+            const usersToNotify = _.uniq([...old_inbox_users, ...old_cc_users]);
+            await Promise.all(
+                usersToNotify.map(user_id => 
+                    pushManager.send_message_to_specifyUser("terminate_approval", user_id)
+                )
+            );
+
+            // Trigger webhook
+            await pushManager.triggerWebhook(
+                updatedInstance.flow,
+                updatedInstance,
+                {},
+                "terminate",
+                current_user,
+                []
+            );
+        }
+
+        res.status(200).send({});
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            error: error.message,
+        });
+    }
+});
+
+exports.default = router;