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

package/main/default/manager/index.js

@@ -0,0 +1,23 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-20 14:49:06
+ * @LastEditors: sunhaolin@hotoa.com
+ * @LastEditTime: 2022-12-28 15:31:18
+ * @Description: 
+ */
+require('./approve_manager')
+require('./export')
+require('./flow_manager')
+require('./form_manager')
+require('./get_handlers_manager')
+require('./import')
+require('./instance_manager')
+require('./permission_manager')
+require('./push_manager')
+require('./step_manager')
+require('./uuflow_manager')
+require('./workflow_manager')
+
+module.exports = {
+    instance_tasks_manager: require('./instance_tasks_manager')
+}

package/main/default/manager/instance_manager.js

@@ -0,0 +1,182 @@
+var _eval, logger;
+
+_eval = require('eval');
+
+global.InstanceManager = {};
+
+logger = new Logger('Workflow -> InstanceManager');
+
+InstanceManager.handlerInstanceByFieldMap = function (ins, field_map) {
+    var context, e, flow, res, script;
+    res = ins;
+    if (ins) {
+        if (!field_map) {
+            flow = db.flows.findOne({
+                _id: ins.flow
+            }, {
+                fields: {
+                    field_map: 1
+                }
+            });
+            if (flow != null ? flow.field_map : void 0) {
+                field_map = flow.field_map;
+            }
+        }
+        if (field_map) {
+            context = _.clone(ins);
+            context._ = _;
+            script = `var instances = ${field_map}; exports.instances = instances`;
+            try {
+                res = _eval(script, "handlerInstanceByFieldMap", context, false).instances;
+            } catch (error) {
+                e = error;
+                res = {
+                    _error: e
+                };
+                logger.error(e);
+            }
+        }
+    }
+    return res;
+};
+
+InstanceManager.getCurrentApprove = function (instance, handler) {
+    var currentApprove, currentApproves, currentTraces;
+    if (!instance || !instance.traces || instance.traces.length < 1) {
+        return;
+    }
+    currentTraces = instance.traces.filterProperty('is_finished', false);
+    if (currentTraces.length) {
+        currentApproves = currentTraces[0].approves.filterProperty('is_finished', false).filterProperty('handler', handler);
+        currentApprove = currentApproves.length > 0 ? currentApproves[0] : null;
+    }
+    if (!currentApprove || currentApprove.type === 'cc') {
+        // 当前是传阅
+        _.each(instance.traces, function (t) {
+            _.each(t.approves, function (a) {
+                if (a.type === 'cc' && a.user === handler && a.is_finished === false) {
+                    currentApprove = a;
+                }
+            });
+        });
+    }
+    if (!currentApprove) {
+        return;
+    }
+    return currentApprove;
+};
+
+InstanceManager.getCurrentTrace = function (instance, traceId) {
+    return instance.traces.findPropertyByPK("_id", traceId);
+};
+
+InstanceManager.getMyApprove = function (instanceId, userId) {
+    var flow, instance, judge, my_approve, nextSteps, next_user_ids, step, step_type, trace;
+    instance = db.instances.findOne({
+        _id: instanceId
+    });
+    flow = uuflowManager.getFlow(instance.flow);
+    my_approve = InstanceManager.getCurrentApprove(instance, userId);
+    if (my_approve) {
+        //		lang = Steedos.locale(that.userId, true)
+        trace = InstanceManager.getCurrentTrace(instance, my_approve.trace);
+        step = uuflowManager.getStep(instance, flow, trace.step);
+        step_type = step.step_type;
+        judge = step_type === "sign" ? "approved" : "";
+        nextSteps = uuflowManager.getNextSteps(instance, flow, step, judge);
+        if (nextSteps.length === 1) {
+            if (step_type === "sign" || step_type === "counterSign") {
+                my_approve.judge = 'approved';
+            }
+            next_user_ids = getHandlersManager.getHandlers(instance._id, nextSteps[0], userId);
+            if (!next_user_ids) {
+                my_approve.next_steps = [
+                    {
+                        step: nextSteps[0],
+                        users: []
+                    }
+                ];
+                return my_approve;
+            }
+            if (next_user_ids.length === 1) {
+                my_approve.next_steps = [
+                    {
+                        step: nextSteps[0],
+                        users: next_user_ids
+                    }
+                ];
+                return my_approve;
+            }
+        }
+    }
+};
+
+//			else
+//				throw new Error(t('workflow_error_multiple_next_step_users', {insname: instance.name}, lang))
+//		else
+//			throw new Error(t('workflow_error_multiple_next_step', {insname: instance.name}, lang))
+InstanceManager.getBatchInstances = function (space, categoryId, flowIds, inbox_user) {
+    var FIELDS, _batch_instances, categoryFlows, inbox_instances, query, unCategoryFlows;
+    _batch_instances = new Array();
+    query = {
+        space: space,
+        inbox_users: inbox_user
+    };
+    FIELDS = {
+        name: 1,
+        applicant_name: 1,
+        submit_date: 1,
+        flow_version: 1,
+        "traces.step": 1,
+        flow: 1,
+        current_step_name: 1,
+        flow_name: 1
+    };
+    if (categoryId) {
+        if (categoryId === '-1') {
+            unCategoryFlows = flowManager.getUnCategoriesFlows(space, {
+                _id: 1
+            }).fetch().getProperty("_id");
+            query.flow = {
+                $in: unCategoryFlows
+            };
+        } else {
+            categoryFlows = flowManager.getCategoriesFlows(space, categoryId, {
+                _id: 1
+            }).fetch().getProperty("_id");
+            query.flow = {
+                $in: categoryFlows
+            };
+        }
+    }
+    if (flowIds) {
+        query.flow = {
+            $in: flowIds
+        };
+    }
+    //	console.log("query", JSON.stringify(query))
+    inbox_instances = db.instances.find(query, {
+        fields: FIELDS,
+        skip: 0,
+        limit: 100
+    });
+    inbox_instances.forEach(function (ins) {
+        var currentStep, currentStepId, flow, myApprove;
+        currentStepId = _.last(ins.traces).step; //TODO 此代码不适用传阅批处理
+        flow = db.flows.findOne({
+            _id: ins.flow
+        });
+        currentStep = stepManager.getStep(ins, flow, currentStepId);
+        myApprove = InstanceManager.getMyApprove(ins._id, inbox_user);
+        if (stepManager.allowBatch(currentStep) && myApprove) {
+            delete ins.flow_version;
+            delete ins.traces;
+            delete ins.flow;
+            ins.approve_start_date = myApprove.start_date;
+            return _batch_instances.push(ins);
+        }
+    });
+    //		else
+    //			console.log("批量审批-异常数据", ins._id)
+    return _batch_instances;
+};

package/main/default/manager/instance_tasks_manager.js

@@ -0,0 +1,285 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-28 10:36:06
+ * @LastEditors: 孙浩林 sunhaolin@steedos.com
+ * @LastEditTime: 2024-04-16 13:14:20
+ * @Description: 
+ */
+'use strict';
+// @ts-check
+const _ = require('lodash')
+const { getObject } = require('@steedos/objectql')
+
+const DISABLE_DIRECT = process.env.STEEDOS_INSTANCE_TASKS_DISABLE_DIRECT == true || process.env.STEEDOS_INSTANCE_TASKS_DISABLE_DIRECT == 'true';
+
+async function _insert(taskDoc) {
+    return await getObject('instance_tasks').insert(taskDoc);
+}
+
+async function _directInsert(taskDoc) {
+    return await getObject('instance_tasks').directInsert(taskDoc);
+}
+
+async function _update(_id, taskDoc) {
+    return await getObject('instance_tasks').update(_id, taskDoc);
+}
+
+async function _remove(_id) {
+    return await getObject('instance_tasks').delete(_id);
+}
+
+async function _directRemove(_id) {
+    return await getObject('instance_tasks').directDelete(_id);
+}
+
+async function _find(query) {
+    return await getObject('instance_tasks').find(query);
+}
+
+async function _count(query) {
+    return await getObject('instance_tasks').count(query);
+}
+
+/**
+ * 新增instance_tasks记录
+ * @param {String} insId 申请单ID
+ * @param {String} traceId TraceID
+ * @param {String} approveId ApproveID
+ * @returns 新增的instance_tasks
+ */
+async function insert_instance_tasks(insId, traceId, approveId) {
+    const taskDoc = await _makeTaskDoc(insId, traceId, approveId)
+    if (DISABLE_DIRECT) {
+        return await _insert(taskDoc)
+    }
+    return await _directInsert(taskDoc)
+}
+
+/**
+ * 批量新增instance_tasks记录
+ * @param {String} insId 申请单ID
+ * @param {String} traceId TraceID
+ * @param {String[]} approveIds ApproveID集合
+ * @returns 新增的instance_tasks的ID集合
+ */
+async function insert_many_instance_tasks(insId, traceId, approveIds) {
+    const insDoc = await _getInsDoc(insId)
+    const traceDoc = await _getTraceDoc(insDoc, traceId)
+    const newDocs = []
+    for (const aId of approveIds) {
+        const approveDoc = await _getApproveDoc(traceDoc, aId)
+        const taskDoc = await _generateTaskDoc(insDoc, traceDoc, approveDoc)
+        const newTaskDoc = await _insert(taskDoc)
+        newDocs.push(newTaskDoc)
+    }
+    return newDocs
+}
+
+/**
+ * 更新instance_tasks记录
+ * @param {String} insId 申请单ID
+ * @param {String} traceId TraceID
+ * @param {String} approveId ApproveID
+ * @param {Object} doc TaskeDoc
+ * @returns 更新后的instance_tasks
+ */
+async function update_instance_tasks(insId, traceId, approveId, doc) {
+    let taskDoc = doc
+    if (!taskDoc) {
+        taskDoc = await _makeTaskDoc(insId, traceId, approveId)
+        delete taskDoc._id
+    }
+    const result = await _update(approveId, taskDoc)
+    return result
+}
+
+/**
+ * 批量更新instance_tasks记录
+ * @param {String} insId 
+ * @param {String} traceId 
+ * @param {String[]} approveIds 
+ * @param {String[]} keys 
+ * @returns 更新后的instance_tasks
+ */
+async function update_many_instance_tasks(insId, traceId, approveIds, keys) {
+    const insDoc = await _getInsDoc(insId)
+    const traceDoc = await _getTraceDoc(insDoc, traceId)
+    const results = []
+    for (const aId of approveIds) {
+        const approveDoc = await _getApproveDoc(traceDoc, aId)
+        let taskDoc = await _generateTaskDoc(insDoc, traceDoc, approveDoc)
+        delete taskDoc._id
+        if (!_.isEmpty(keys)) {
+            taskDoc = _.pick(taskDoc, keys)
+        }
+        const result = await _update(aId, taskDoc)
+        results.push(result)
+    }
+    return results
+}
+
+/**
+ * 删除instance_tasks记录
+ * @param {String} approveId 
+ * @returns 1
+ */
+async function remove_instance_tasks(approveId) {
+    const result = await _remove(approveId)
+    return result
+}
+
+/**
+ * 删除instance_tasks记录
+ * @param {String[]} approveIds
+ * @returns 1
+ */
+async function remove_many_instance_tasks(approveIds) {
+    const results = []
+    for (const aId of approveIds) {
+        const r = await _remove(aId)
+        results.push(r)
+    }
+    return results
+}
+
+/**
+ * 删除instance相关的所有instance_tasks记录
+ * @param {String} insId 申请单ID 
+ * @returns 1
+ */
+async function remove_instance_tasks_by_instance_id(insId) {
+    const results = []
+    const taskDocs = await _find({
+        filters: [
+            ['instance', '=', insId]
+        ],
+        fields: ['_id']
+    })
+    for (const t of taskDocs) {
+        const r = await _remove(t._id)
+        results.push(r)
+    }
+    return results
+}
+
+/**
+ * 删除instance_tasks记录，不触发钩子
+ * @param {String[]} approveIds
+ * @returns 1
+ */
+async function direct_remove_many_instance_tasks(approveIds) {
+    const results = []
+    for (const aId of approveIds) {
+        if (DISABLE_DIRECT) {
+            const r = await _remove(aId)
+            results.push(r)
+        } else {
+            const r = await _directRemove(aId)
+            results.push(r)
+        }
+    }
+    return results
+}
+
+/**
+ * 计数instance_tasks
+ * @param {object} query
+ * @returns 1
+ */
+async function count_instance_tasks(query) {
+    const result = await _count(query)
+    return result
+}
+
+/**
+ * 使用insId、traceId、approveId整理成instnce_tasks结构
+ * @param {String} insId 申请单ID
+ * @param {String} traceId TraceID
+ * @param {String} approveId ApproveID
+ * @returns instance_tasks文档
+ */
+async function _makeTaskDoc(insId, traceId, approveId) {
+    const insDoc = await _getInsDoc(insId)
+    const traceDoc = await _getTraceDoc(insDoc, traceId)
+    const approveDoc = await _getApproveDoc(traceDoc, approveId)
+    return await _generateTaskDoc(insDoc, traceDoc, approveDoc)
+}
+
+/**
+ * 使用instance、trace、approve整理成instnce_tasks结构
+ * @param {Object} insDoc 申请单文档
+ * @param {Object} traceDoc Trace文档
+ * @param {Object} approveDoc Approve文档
+ * @returns instance_tasks文档
+ */
+function _generateTaskDoc(insDoc, traceDoc, approveDoc) {
+    return {
+        ...approveDoc,
+        'space': insDoc.space,
+        'instance_name': insDoc.name,
+        'submitter': insDoc.submitter,
+        'submitter_name': insDoc.submitter_name,
+        'applicant': insDoc.applicant,
+        'applicant_name': insDoc.applicant_name,
+        'applicant_organization_name': insDoc.applicant_organization_name,
+        'submit_date': insDoc.submit_date,
+        'flow': insDoc.flow,
+        'flow_name': insDoc.flow_name,
+        'form': insDoc.form,
+        'step': traceDoc.step,
+        'step_name': traceDoc.name,
+        'category_name': insDoc.category_name,
+        'instance_state': insDoc.state,
+        'distribute_from_instance': insDoc.distribute_from_instance,
+        'forward_from_instance': insDoc.forward_from_instance,
+        'keywords': insDoc.keywords,
+        'is_archived': insDoc.is_archived,
+        'category': insDoc.category,
+        'extras': insDoc.extras,
+    }
+}
+
+/**
+ * 查找申请单文档
+ * @param {String} insId 申请单ID
+ * @returns 申请单文档
+ */
+async function _getInsDoc(insId) {
+    return await getObject('instances').findOne(insId)
+}
+
+/**
+ * 查找Trace
+ * @param {Object} insDoc 申请单文档
+ * @param {String} traceId TraceID
+ * @returns Trace文档
+ */
+function _getTraceDoc(insDoc, traceId) {
+    return _.find(insDoc.traces, function (t) {
+        return t._id === traceId
+    })
+}
+
+/**
+ * 查找Approve
+ * @param {Object} traceDoc Trace文档
+ * @param {String} approveId ApproveID
+ * @returns Approve文档
+ */
+function _getApproveDoc(traceDoc, approveId) {
+    return _.find(traceDoc.approves, function (a) {
+        return a._id === approveId
+    })
+}
+
+module.exports = {
+    insert_instance_tasks,
+    insert_many_instance_tasks,
+    update_instance_tasks,
+    update_many_instance_tasks,
+    remove_instance_tasks,
+    remove_many_instance_tasks,
+    remove_instance_tasks_by_instance_id,
+    direct_remove_many_instance_tasks,
+    count_instance_tasks
+}

package/main/default/manager/permission_manager.js

@@ -0,0 +1,140 @@
+const { getCollection } = require('../utils/collection');
+const _ = require('lodash');
+
+const PermissionManager = {};
+
+/**
+ * 获取用户所属组织ID（包括父组织）
+ * @param {string} spaceId 工作区ID
+ * @param {string} userId 用户ID
+ * @returns {Promise<string[]>} 组织ID数组
+ */
+const _getUserOrganizationIds = async function (spaceId, userId) {
+    const organizationsCollection = await getCollection('organizations');
+    const organizations = await organizationsCollection.find(
+        {
+            space: spaceId,
+            users: userId
+        },
+        {
+            projection: { parents: 1 }
+        }
+    ).toArray();
+
+    const orgIds = new Set();
+    organizations.forEach(org => {
+        orgIds.add(org._id);
+        if (org.parents) {
+            org.parents.forEach(parentId => orgIds.add(parentId));
+        }
+    });
+
+    return Array.from(orgIds);
+}
+
+/**
+ * 检查添加权限
+ * @param {Object} perms 权限对象
+ * @param {string} userId 用户ID
+ * @param {string[]} orgIds 组织ID数组
+ * @param {Set<string>} permissions 权限集合
+ */
+const _checkAddPermission = function(perms, userId, orgIds, permissions) {
+    if (perms.users_can_add?.includes(userId)) {
+        permissions.add('add');
+        return;
+    }
+
+    if (perms.orgs_can_add) {
+        const hasPermission = orgIds.some(orgId =>
+            perms.orgs_can_add.includes(orgId)
+        );
+        if (hasPermission) permissions.add('add');
+    }
+}
+
+/**
+ * 检查监控权限
+ * @param {Object} perms 权限对象
+ * @param {string} userId 用户ID
+ * @param {string[]} orgIds 组织ID数组
+ * @param {Set<string>} permissions 权限集合
+ */
+const _checkMonitorPermission= function(perms, userId, orgIds, permissions) {
+    if (perms.users_can_monitor?.includes(userId)) {
+        permissions.add('monitor');
+        return;
+    }
+
+    if (perms.orgs_can_monitor) {
+        const hasPermission = orgIds.some(orgId =>
+            perms.orgs_can_monitor.includes(orgId)
+        );
+        if (hasPermission) permissions.add('monitor');
+    }
+}
+
+/**
+ * 检查管理权限
+ * @param {Object} perms 权限对象
+ * @param {string} userId 用户ID
+ * @param {string[]} orgIds 组织ID数组
+ * @param {Set<string>} permissions 权限集合
+ */
+const _checkAdminPermission = function (perms, userId, orgIds, permissions) {
+    if (perms.users_can_admin?.includes(userId)) {
+        permissions.add('admin');
+        return;
+    }
+
+    if (perms.orgs_can_admin) {
+        const hasPermission = orgIds.some(orgId =>
+            perms.orgs_can_admin.includes(orgId)
+        );
+        if (hasPermission) permissions.add('admin');
+    }
+}
+
+/**
+ * 获取用户对流程的权限
+ * @param {string} flowId 流程ID
+ * @param {string} userId 用户ID
+ * @param {Object} [flowDoc] 可选的流程文档（避免重复查询）
+ * @returns {Promise<string[]>} 权限数组（可能包含 'add', 'monitor', 'admin'）
+ */
+PermissionManager.getFlowPermissions = async function(flowId, userId, flowDoc) {
+    const flowColl = await getCollection('flows');
+    try {
+        // 获取流程信息
+        let flow = flowDoc;
+        if(!flow){
+            flow = await flowColl.findOne({_id: flowId}, {
+                projection: { space: 1, perms: 1 }
+            })
+        }
+
+        if (!flow) {
+            throw new Error(`Flow not found: ${flowId}`);
+        }
+
+        const spaceId = flow.space;
+        const myPermissions = new Set();
+
+        // 获取用户所属组织ID（包括父组织）
+        const orgIds = await _getUserOrganizationIds(spaceId, userId);
+
+        // 检查流程权限
+        if (flow.perms) {
+            _checkAddPermission(flow.perms, userId, orgIds, myPermissions);
+            _checkMonitorPermission(flow.perms, userId, orgIds, myPermissions);
+            _checkAdminPermission(flow.perms, userId, orgIds, myPermissions);
+        }
+
+        return Array.from(myPermissions);
+    } catch (error) {
+        console.error('Error in getFlowPermissions:', error);
+        throw error;
+    }
+}
+
+module.exports = PermissionManager;