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

package/main/default/services/flows.service.js

@@ -0,0 +1,279 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2023-01-14 11:31:56
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2023-10-18 09:50:42
+ * @Description:
+ */
+const objectql = require("@steedos/objectql");
+const { getStep } = require('../UUFlowManager');
+const _ = require("lodash");
+module.exports = {
+  name: "flows",
+  settings: {
+    graphql: {
+      type: `
+        """
+        This type describes a post entity.
+        """			
+        type categoriesTree {
+            _id: String
+            name: String
+            space: String
+            created: Date
+            created_by: JSON
+            modified: Date
+            modified_by: JSON
+            flows: [flows]
+        }
+      `
+    }
+  },
+  actions: {
+    flows__getList: {
+      graphql: {
+        query: `
+          #按权限获取flows数据
+          flows__getList(
+            # add || query || distribute
+            action: String,
+            # app Id
+            appId: String
+            # 搜索的关键字
+            keywords: String,
+            # distribute instance id
+            distributeInstanceId: String
+            # distribute step id
+            distributeStepId: String,
+            # 显示所有流程
+            allData: Boolean
+            ): [categoriesTree]
+          `,
+      },
+      async handler(ctx) {
+        try {
+          const userSession = ctx.meta.user;
+          const { resolveInfo } = ctx.meta;
+          const { action, appId, keywords, distributeInstanceId, distributeStepId, allData } = ctx.params;
+          return await this.getFlowListData(action, { appId, keywords, distributeInstanceId, distributeStepId, allData }, userSession)
+        } catch (error) {
+          throw error;
+        }
+      },
+    },
+  },
+  methods: {
+    formatKeywords: {
+      handler(keywords) {
+        if (keywords) {
+          return _.uniq(_.compact(keywords.split(' ')))
+        }
+      }
+    },
+    getKeywordsFilter: {
+      handler(keywords) {
+        if (keywords) {
+          const keys = this.formatKeywords(keywords);
+          if (keys && keys.length > 0) {
+            const keywordsFilter = [];
+            _.each(keys, (key) => {
+              keywordsFilter.push(['name', 'contains', key])
+            })
+            return keywordsFilter;
+          }
+        }
+      }
+    },
+    getAppCategoriesIds: {
+      async handler(appId, allData) {
+        const query = {};
+        if(appId && allData !=true){
+          query.filters = [['app', '=', appId]] 
+        }
+        // console.log(`getAppCategoriesIds`, appId, allData, query)
+        const categories = await objectql.getObject('categories').find(query);
+        return _.map(categories, '_id');
+      }
+    },
+    getFlowListData: {
+      async handler(action, options, userSession) {
+        const { appId, keywords, distributeInstanceId, distributeStepId, allData } = options;
+
+        const categoriesIds = await this.getAppCategoriesIds(appId, allData);
+
+        const keywordsFilter = this.getKeywordsFilter(keywords)
+        let data = [];
+        const { is_space_admin } = userSession;
+        // 分发的流程范围处理
+        let distributeOptionalFlows = [];
+        if (action === "distribute") {
+          if (distributeInstanceId && distributeStepId) {
+            const instance = await objectql.getObject('instances').findOne(distributeInstanceId);
+            if (instance) {
+              const flow = await objectql.getObject('flows').findOne(instance.flow);
+              if (flow) {
+                const step = getStep(instance, flow, distributeStepId);
+                if (step && step.allowDistribute == true) {
+                  distributeOptionalFlows = step.distribute_optional_flows || [];
+                }
+              }
+            }
+          }
+          if (distributeOptionalFlows.length > 0) {
+            const dflows = await objectql
+              .getObject("flows")
+              .find({
+                filters: [
+                  ["_id", "in", distributeOptionalFlows],
+                  ["state", "=", "enabled"],
+                ],
+                fields: ['_id', 'name', 'sort_no', 'category', 'distribute_optional_users', 'distribute_to_self', 'distribute_end_notification'], // 只取必要字段
+                sort: "sort_no desc,name"
+              });
+            const dCategoryIds = _.map(dflows, 'category')
+            const dCategoryDocs = await this.getSpaceCategories(dCategoryIds, userSession);
+            for (const category of dCategoryDocs) {
+              category.flows = [];
+              for (const flow of dflows) {
+                if (flow.category === category._id)
+                  category.flows.push(flow);
+              }
+            }
+            data = dCategoryDocs;
+          }
+        } else {
+          var categories = await this.getSpaceCategories(categoriesIds, userSession);
+          for (const category of categories) {
+            const filters = [
+              ["category", "=", category._id],
+              ["state", "=", "enabled"],
+            ];
+            if(action === "new"){
+              filters.push(["forbid_initiate_instance", "!=", true]);
+            }
+            if (keywordsFilter) {
+              filters.push(keywordsFilter)
+            }
+            // console.log(`filters`, filters)
+            const categoryFlows = await objectql.getObject("flows").find({
+              filters: filters,
+              fields: ['_id', 'name', 'sort_no', 'category', 'perms'],
+              sort: "sort_no desc,name",
+            });
+            category.flows = [];
+            for (const flow of categoryFlows) {
+              if(allData){
+                category.flows.push(flow);
+              }else{
+                if (this.canAdd(flow, userSession)) {
+                  category.flows.push(flow);
+                } else if (action == 'query') {
+                  if (is_space_admin || this.canMonitor(flow, userSession) || this.canAdmin(flow, userSession)) {
+                    category.flows.push(flow);
+                  }
+                }
+              }
+            }
+          }
+          data = categories;
+        }
+        return data;
+      }
+    },
+    getSpaceCategories: {
+      async handler(ids, userSession) {
+        const filters = [["space", "=", userSession.spaceId]];
+        if (!_.isEmpty(ids)) {
+          filters.push(["_id", "in", ids]);
+        }
+        return await objectql
+          .getObject("categories")
+          .find({ filters: filters, sort: "sort_no desc" });
+      }
+    },
+    canAdd: {
+      handler(flow, userSession) {
+        let canAdd = false;
+        const { perms } = flow;
+        const { userId, organizations, organizations_parents } = userSession;
+        const organizationIds = _.map(organizations, "_id");
+        if (perms) {
+          if (perms.users_can_add && perms.users_can_add.includes(userId)) {
+            canAdd = true;
+          } else if (perms.orgs_can_add && perms.orgs_can_add.length > 0) {
+            if (
+              organizationIds &&
+              _.intersection(organizationIds, perms.orgs_can_add).length > 0
+            ) {
+              canAdd = true;
+            } else {
+              canAdd =
+                organizations_parents &&
+                _.intersection(organizations_parents, perms.orgs_can_add).length >
+                0;
+            }
+          }
+        }
+        return canAdd;
+      }
+    },
+    canAdmin: {
+      handler(flow, userSession) {
+        let canAdmin = false;
+        const { perms } = flow;
+        const { userId, organizations, organizations_parents } = userSession;
+        const organizationIds = _.map(organizations, "_id");
+        if (perms) {
+          if (perms.users_can_admin && perms.users_can_admin.includes(userId)) {
+            canAdmin = true;
+          } else if (perms.orgs_can_admin && perms.orgs_can_admin.length > 0) {
+            if (
+              organizationIds &&
+              _.intersection(organizationIds, perms.orgs_can_admin).length > 0
+            ) {
+              canAdmin = true;
+            } else {
+              canAdmin =
+                organizations_parents &&
+                _.intersection(organizations_parents, perms.orgs_can_admin)
+                  .length > 0;
+            }
+          }
+        }
+        return canAdmin;
+      }
+    },
+    canMonitor: {
+      handler(flow, userSession) {
+        let canMonitor = false;
+        const { perms } = flow;
+        const { userId, organizations, organizations_parents } = userSession;
+        const organizationIds = _.map(organizations, "_id");
+        if (perms) {
+          if (
+            perms.users_can_monitor &&
+            perms.users_can_monitor.includes(userId)
+          ) {
+            canMonitor = true;
+          } else if (
+            perms.orgs_can_monitor &&
+            perms.orgs_can_monitor.length > 0
+          ) {
+            if (
+              organizationIds &&
+              _.intersection(organizationIds, perms.orgs_can_monitor).length > 0
+            ) {
+              canMonitor = true;
+            } else {
+              canMonitor =
+                organizations_parents &&
+                _.intersection(organizations_parents, perms.orgs_can_monitor)
+                  .length > 0;
+            }
+          }
+        }
+        return canMonitor;
+      }
+    },
+  },
+};

package/main/default/services/instance.service.js

@@ -0,0 +1,319 @@
+
+const objectql = require('@steedos/objectql');
+const _ = require('lodash');
+const { parseResolveInfo, simplifyParsedResolveInfoFragmentWithType } = require('graphql-parse-resolve-info');
+const WorkflowManager = require('../manager/workflow_manager');
+const EXPAND_SUFFIX = '__expand';
+const DISPLAY_PREFIX = '_display';
+const UI_PREFIX = '_ui';
+const RELATED_PREFIX = '_related';
+const PERMISSIONS_PREFIX = '_permissions';
+
+function getQueryFields(resolveInfo) {
+    const fieldsName = [];
+    const parsedResolveInfoFragment = parseResolveInfo(resolveInfo);
+    const simplifiedFragment = simplifyParsedResolveInfoFragmentWithType(
+        parsedResolveInfoFragment,
+        resolveInfo.returnType
+    );
+
+    const fields = simplifiedFragment.fields;
+    if (!_.isEmpty(fields)) {
+        for (const key in fields) {
+            const field = fields[key];
+            const name = field.name;
+            // 如果field.name以__expand结尾，则将field.name去掉__expand后，作为查询的字段名
+            if (name.endsWith(EXPAND_SUFFIX)) {
+                fieldsName.push(name.slice(0, -EXPAND_SUFFIX.length));
+                continue;
+            }
+            // 如果field.name值为_display，则跳过
+            if (name === DISPLAY_PREFIX) {
+                continue;
+            }
+            // 如果field.name以_related开头，则跳过
+            if (name.startsWith(RELATED_PREFIX)) {
+                continue;
+            }
+
+            if (name.startsWith(UI_PREFIX)) {
+                continue;
+            }
+
+            if (name.startsWith(PERMISSIONS_PREFIX)) {
+                continue;
+            }
+            fieldsName.push(name);
+        }
+    }
+    // console.log(fieldsName);
+    return fieldsName;
+}
+
+
+
+module.exports = {
+  name: "instance",
+  actions: {
+    instances__getRelatedInstances: {
+      graphql: {
+        query:
+          `
+          #获取可选取的相关申请单列表
+          instances__getRelatedInstances(
+            #过滤条件
+            filters: JSON,
+            #按流程过滤
+            flowId: String,
+            #按状态过滤 
+            state: String,
+            #按关键字过滤 
+            keywords: String,
+            #分页参数: 每次返回的记录数
+            top: Int, 
+            #分页参数: 跳过的记录数
+            skip: Int, 
+            #排序规则
+            sort: String): [instances]
+          `,
+      },
+      async handler(ctx) {
+        const userSession = ctx.meta.user;
+        const { resolveInfo } = ctx.meta;
+        const { flowId, state, keywords , top , skip , sort, filters: userFilters} = ctx.params;
+
+        const filters = await this.getRelatedFilters(flowId, state, keywords, userSession)
+
+        if(!_.isEmpty(userFilters)){
+            filters.push(userFilters);
+        }
+
+        let fields = [];
+
+        const fieldNames = getQueryFields(resolveInfo);
+
+        if (!_.isEmpty(fieldNames)) {
+            fields = fieldNames;
+        };
+
+        const query = {
+            filters: filters, 
+            fields: fields,
+            top: top,
+            skip: skip,
+            sort: sort,
+        }
+
+        return await objectql.getObject('instances').find(query, null)
+      },
+    },
+    instances__getRelatedInstances__count: {
+        graphql: {
+            query:
+            " instances__getRelatedInstances__count(flowId: String, state: String, keywords: String, filters: JSON): Int"
+        },
+        async handler(ctx) {
+            const userSession = ctx.meta.user;
+            const { flowId, state, keywords, filters: userFilters } = ctx.params;
+            const filters = await this.getRelatedFilters(flowId, state, keywords, userSession);
+            if(!_.isEmpty(userFilters)){
+                filters.push(userFilters);
+            }
+            const query = {
+                filters: filters
+            }
+    
+            return await objectql.getObject('instances').count(query, null)
+          },
+    },
+    getApprove: {
+        async handler(ctx){
+            const { instanceId, traceId, approveId } = ctx.params;
+            return await this.getApprove(instanceId, traceId, approveId);
+        }
+    },
+    getBoxFilters: {
+        async handler(ctx){
+            const { appId, box, flowId, userId, is_space_admin, spaceId } = ctx.params;
+            const categoriesIds = await this.getAppCategoriesIds(appId);
+            const filter = [];
+            switch (box) {
+                case 'inbox':
+                    filter.push(['handler', '=', userId]);
+                    filter.push(['is_finished', '=', false]);
+                    break;
+                case 'outbox':
+                    filter.push(['handler', '=', userId]);
+                    filter.push(['is_finished', '=', true]);
+                    filter.push(['is_latest_approve', '=', true]);
+                    break;
+                case 'draft':
+                    filter.push(['submitter', '=', userId]);
+                    filter.push(['state', '=', 'draft']);
+                    // 需要排除 分发、转发的申请单
+                    // filter.push(['inbox_users', '=', []]); // 按照数据库的语法这样查是可以的，但是在objectql中不行，会将[]转换成'__badQueryForEmptyArray'，变成((inbox_users eq '__badQueryForEmptyArray'))
+                    filter.push(['distribute_from_instance', '=', null]);
+                    filter.push(['forward_from_instance', '=', null]);
+                    break;
+                case 'pending':
+                    filter.push(['state', '=', 'pending']);
+                    filter.push([['submitter', '=', userId], 'or', ['applicant', '=', userId]]);
+                    break;
+                case 'completed':
+                    filter.push(['submitter', '=', userId]);
+                    filter.push(['state', '=', 'completed']);
+                    break;
+                case 'monitor':
+                    filter.push(['state', 'in', ["pending", "completed"]]);
+                    if(!is_space_admin){
+                        const flowIds = await new Promise(function (resolve, reject) {
+                            Fiber(function () {
+                                try {
+                                    resolve(WorkflowManager.getMyAdminOrMonitorFlows(spaceId, userId));
+                                } catch (error) {
+                                    reject(error);
+                                }
+                            }).run()
+                        })
+                        if(flowId){
+                            if(!_.includes(flowIds, flowId)){
+                                // filter.push([
+                                //     ['submitter', '=', userId], 'or', ['applicant', '=', userId], 'or', ['inbox_users', '=', userId], 'or', ['outbox_users', '=', userId]
+                                // ])
+                            }
+                        }else{
+                            filter.push(['flow', 'in', flowIds])
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+
+            if(categoriesIds && categoriesIds.length > 0){
+                filter.push(['category', 'in', categoriesIds])
+            }
+
+            return filter;
+        }
+    }
+  },
+  methods: {
+    getRelatedFilters: {
+        async handler(flowId, state, keywords, userSession){
+            const filters = [];
+            const defaultFilters = await this.getRelatedDefaultFilters(userSession);
+            const userFilters = [];
+
+            if(!_.isEmpty(defaultFilters)){
+                filters.push(defaultFilters);
+            }
+
+            if(flowId){
+                userFilters.push(['flow', '=', flowId]);
+            };
+
+            if(state){
+                userFilters.push(['state', '=', state]);
+            }else{
+                userFilters.push(['state', 'in', ['pending', 'completed']]);
+            }
+
+            if(keywords){
+                userFilters.push([
+                    ['name', 'contains', keywords], 
+                    'or', 
+                    ['applicant_name', 'contains', keywords], 
+                    'or', 
+                    ['flow_name', 'contains', keywords], 
+                    'or', 
+                    ['current_step_name', 'contains', keywords]
+                ])
+            };
+
+            if(!_.isEmpty(userFilters)){
+                filters.push(userFilters);
+            };
+            return filters;
+        }
+    },
+    getRelatedDefaultFilters: {
+        async handler(userSession){
+            const filters = [];
+
+            filters.push(['space', '=', userSession.spaceId]);
+
+            if(!userSession.is_space_admin){
+                const monitorFlows = await objectql.getObject('flows').find({filters: [
+                    ['perms.orgs_can_monitor', 'in',   userSession.organizations_parents],
+                    'or',
+                    ['perms.users_can_monitor', '=', userSession.userId]
+                ], fields: ['_id']});
+                
+                const adminFlows = await objectql.getObject('flows').find({filters: [
+                    ['perms.orgs_can_admin', 'in',   userSession.organizations_parents],
+                    'or',
+                    ['perms.users_can_admin', '=', userSession.userId]
+                ], fields: ['_id']})
+                
+                filters.push([
+                    ['submitter', '=', userSession.userId],
+                    'or',
+                    ['applicant', '=', userSession.userId],
+                    'or',
+                    ['inbox_users', '=', userSession.userId],
+                    'or',
+                    ['outbox_users', '=', userSession.userId],
+                    'or',
+                    ['cc_users', '=', userSession.userId],
+                    'or',
+                    ['inbox_users', '=', userSession.userId],
+                    'or',
+                    ['flow', 'in', _.uniq(_.concat(_.map(monitorFlows, '_id'), _.map(adminFlows, '_id')))],
+                ])
+
+            }
+            return filters;
+        },
+    },
+    getApprove: {
+        async handler(instanceId, traceId, approveId){
+            const instance = await objectql.getObject('instances').findOne(instanceId);
+            const trace = _.find(instance.traces, (trace) => {
+                return trace._id == traceId;
+              });
+            if(trace){
+                return _.find(trace.approves, (approve) => {
+                    return approve._id == approveId;
+                });
+            }
+        }
+    },
+    getAppCategoriesIds: {
+        async handler(appId) {
+          if(appId == "approve_workflow"){
+            return [];
+          }
+          const categories = await objectql.getObject('categories').directFind({ filters: [['app', '=', appId]] });
+          return _.map(categories, '_id');
+        }
+    },
+  },
+/**
+ * Service created lifecycle event handler
+ */
+async created() {
+},
+
+/**
+ * Service started lifecycle event handler
+ */
+async started(ctx) {
+},
+
+/**
+ * Service stopped lifecycle event handler
+ */
+async stopped() {
+}
+};

package/main/default/tabs/admin_categories.tab.yml

@@ -0,0 +1,21 @@
+name: admin_categories
+desktop: true
+icon: hierarchy
+is_new_window: false
+label: 流程分类
+mobile: true
+permissions:
+  - permission: 'on'
+    permission_set: admin
+  - permission: 'off'
+    permission_set: user
+  - permission: 'off'
+    permission_set: customer
+  - permission: 'off'
+    permission_set: supplier
+  - permission: 'off'
+    permission_set: organization_admin
+  - permission: 'off'
+    permission_set: workflow_admin
+type: object
+object: categories

package/main/default/tabs/admin_flow_positions.tab.yml

@@ -0,0 +1,21 @@
+name: admin_flow_positions
+desktop: true
+icon: person_account
+is_new_window: false
+label: 审批岗位成员
+mobile: true
+permissions:
+  - permission: 'on'
+    permission_set: admin
+  - permission: 'off'
+    permission_set: user
+  - permission: 'off'
+    permission_set: customer
+  - permission: 'off'
+    permission_set: supplier
+  - permission: 'off'
+    permission_set: organization_admin
+  - permission: 'off'
+    permission_set: workflow_admin
+type: object
+object: flow_positions

package/main/default/tabs/admin_flow_roles.tab.yml

@@ -0,0 +1,21 @@
+name: admin_flow_roles
+desktop: true
+icon: messaging_user
+is_new_window: false
+label: 审批岗位
+mobile: true
+permissions:
+  - permission: 'on'
+    permission_set: admin
+  - permission: 'off'
+    permission_set: user
+  - permission: 'off'
+    permission_set: customer
+  - permission: 'off'
+    permission_set: supplier
+  - permission: 'off'
+    permission_set: organization_admin
+  - permission: 'off'
+    permission_set: workflow_admin
+type: object
+object: flow_roles

package/main/default/tabs/admin_flows.tab.yml

@@ -0,0 +1,21 @@
+name: admin_flows
+desktop: true
+icon: environment_hub
+is_new_window: false
+label: 流程
+mobile: true
+permissions:
+  - permission: 'on'
+    permission_set: admin
+  - permission: 'off'
+    permission_set: user
+  - permission: 'off'
+    permission_set: customer
+  - permission: 'off'
+    permission_set: supplier
+  - permission: 'off'
+    permission_set: organization_admin
+  - permission: 'off'
+    permission_set: workflow_admin
+type: object
+object: flows