@steedos-labs/plugin-workflow 3.0.18 → 3.0.19

package/main/default/manager/instance_tasks_manager.js

@@ -117,22 +117,30 @@ async function insert_many_instance_tasks(insId, traceId, approveIds) {
  * @returns 更新后的instance_tasks
  */
 async function update_instance_tasks(insId, traceId, approveId, doc) {
+    console.time(`update_instance_tasks ${approveId}`);
     let taskDoc = doc
     if (!taskDoc) {
+        console.time(`update_instance_tasks_makeTaskDoc ${approveId}`);
         taskDoc = await _makeTaskDoc(insId, traceId, approveId)
         delete taskDoc._id
+        console.timeEnd(`update_instance_tasks_makeTaskDoc ${approveId}`);
     }
+    console.time(`update_instance_tasks_update ${approveId}`);
     const result = await _update(approveId, taskDoc)
+    console.timeEnd(`update_instance_tasks_update ${approveId}`);
     
     // 如果任务已完成，更新相关通知为已读
     if (taskDoc.is_finished) {
+        console.time(`update_instance_tasks_notifications ${approveId}`);
         const instance = taskDoc.instance || insId
         const handler = taskDoc.handler
         if (instance && handler) {
             await _updateNotificationsAsRead(instance, handler)
         }
+        console.timeEnd(`update_instance_tasks_notifications ${approveId}`);
     }
     
+    console.timeEnd(`update_instance_tasks ${approveId}`);
     return result
 }
 
@@ -265,6 +273,9 @@ async function direct_remove_many_instance_tasks(approveIds) {
  * @returns 1
  */
 async function count_instance_tasks(query) {
+    if(process.env.STEEDOS_WORKFLOW_DISABLE_BADGE === 'true'){
+        return 0;
+    } 
     const result = await _count(query)
     return result
 }

package/main/default/manager/push_manager.js

@@ -55,6 +55,9 @@ const settings = require('@steedos/objectql').getSteedosConfig();
 
 
 async function count_instance_tasks(query) {
+    if(process.env.STEEDOS_WORKFLOW_DISABLE_BADGE === 'true'){
+        return 0;
+    } 
     return await getObject('instance_tasks').count(query)
 }
 
@@ -539,7 +542,7 @@ pushManager.send_email_to_SMTP = async function (subject, content, to_user, repl
             subject: subject,            // 主题
             html: content
         };
-        await ctx.broker.call('@builder6/email.send', mailOptions)
+        await broker.call('@builder6/email.send', mailOptions)
 
     } catch (error) {
         console.error(error.stack);

package/main/default/manager/uuflow_manager.js

@@ -18,7 +18,14 @@ const moment = require('moment')
 const { getObject } = require('@steedos/objectql');
 const { evaluate } = require('amis-formula');
 
-const UUFlowManager = {};
+const UUFlowManager = {
+    stats: {
+        getFlow: 0,
+        getFlowVersion: 0,
+        getForm: 0,
+        getFormVersion: 0
+    }
+};
 
 /**
  * Check user authorization
@@ -158,6 +165,7 @@ UUFlowManager.getSpaceUser = async function (space_id, user_id, options = {}) {
  * @throws {Error} If flow not found
  */
 UUFlowManager.getFlow = async function (flow_id, options = {}) {
+    UUFlowManager.stats.getFlow++;
     if (process.env.STEEDOS_DEBUG) {
         const now = new Date().toISOString();
         console.time('UUFlowManager.getFlow' + now);
@@ -185,6 +193,7 @@ UUFlowManager.getFlow = async function (flow_id, options = {}) {
  * @throws {Error} If version not found
  */
 UUFlowManager.getFlowVersion = function (flow, flow_version) {
+    UUFlowManager.stats.getFlowVersion++;
     let flow_v = null;
     
     if (flow_version === flow.current._id) {
@@ -1079,6 +1088,7 @@ UUFlowManager.getUpdatedValues = function (instance, approve_id) {
  * @throws {Error} If form not found
  */
 UUFlowManager.getForm = async function (form_id, options = {}) {
+    UUFlowManager.stats.getForm++;
     if (process.env.STEEDOS_DEBUG) {
         console.time('UUFlowManager.getForm');
     }
@@ -1105,6 +1115,7 @@ UUFlowManager.getForm = async function (form_id, options = {}) {
  * @throws {Error} If version not found
  */
 UUFlowManager.getFormVersion = function (form, form_version) {
+    UUFlowManager.stats.getFormVersion++;
     let form_v = null;
     
     if (form_version === form.current._id) {
@@ -1292,6 +1303,14 @@ UUFlowManager.getApproveValues = async function (approve_values, permissions, fo
  * @returns {Object} Updated instance
  */
 UUFlowManager.workflow_engine = async function (approve_from_client, current_user_info, current_user, auto_submitted = false) {
+    // Reset stats at the beginning of workflow_engine
+    UUFlowManager.stats = {
+        getFlow: 0,
+        getFlowVersion: 0,
+        getForm: 0,
+        getFormVersion: 0
+    };
+    const t0 = Date.now();
     // Extract data from approve_from_client
     const {
         instance: instance_id,
@@ -1306,21 +1325,24 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
 
     // Get instance, space, flow and related data
     const instance = await UUFlowManager.getInstance(instance_id);
+    console.log(`[workflow/engine] [workflow_engine] getInstance took ${Date.now() - t0}ms`);
     const space_id = instance.space;
     const flow_id = instance.flow;
-    const space = await UUFlowManager.getSpace(space_id);
-    const applicant_id = instance.applicant;
+    const t1 = Date.now();
     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);
+    console.log(`[workflow/engine] [workflow_engine] load related data took ${Date.now() - t1}ms`);
 
     // Validate instance state and permissions
+    const t2 = Date.now();
     UUFlowManager.isTraceNotFinished(trace);
     UUFlowManager.isApproveNotFinished(approve);
     UUFlowManager.isInstancePending(instance);
     UUFlowManager.isHandlerOrAgent(approve, current_user);
+    console.log(`[workflow/engine] [workflow_engine] validate took ${Date.now() - t2}ms`);
 
     // Get current step info
     const step = await UUFlowManager.getStep(instance, flow, trace.step);
@@ -1332,6 +1354,7 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     const setObj = {};
     let key_str = "";
 
+    const t3 = Date.now();
     // Find the approve to update
     for (let i = 0; i < trace_approves.length; i++) {
         if (trace_approves[i]._id === approve_id) {
@@ -1372,18 +1395,24 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
             setObj.modified_by = current_user;
 
             // Update instance
+            const t3_1 = Date.now();
             const instancesCollection = await getCollection('instances');
             await instancesCollection.updateOne(
                 { _id: instance_id, "traces._id": trace_id },
                 { $set: setObj }
             );
+            console.log(`[workflow/engine] [workflow_engine] first updateOne took ${Date.now() - t3_1}ms`);
 
             // Update instance tasks
+            const t3_2 = Date.now();
             await update_instance_tasks(instance_id, trace_id, approve_id);
+            console.log(`[workflow/engine] [workflow_engine] first update_instance_tasks took ${Date.now() - t3_2}ms`);
             break;
         }
     }
+    console.log(`[workflow/engine] [workflow_engine] update instance(first part) took ${Date.now() - t3}ms`);
 
+    const t4 = Date.now();
     // Reload instance and revalidate after update
     const updatedInstance = await UUFlowManager.getInstance(instance_id);
     const updatedTrace = await UUFlowManager.getTrace(updatedInstance, trace_id);
@@ -1393,6 +1422,7 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     UUFlowManager.isApproveNotFinished(updatedApprove);
     UUFlowManager.isInstancePending(updatedInstance);
     UUFlowManager.isHandlerOrAgent(updatedApprove, current_user);
+    console.log(`[workflow/engine] [workflow_engine] reload and revalidate took ${Date.now() - t4}ms`);
 
     // Prepare final update object
     const updateObj = { $set: {} };
@@ -1406,11 +1436,14 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
         throw new Error('不能指定多个后续步骤');
     }
 
+    const t5 = Date.now();
     // Validate next step users
     for (const next_step_user of next_steps[0].users || []) {
         await UUFlowManager.getSpaceUser(space_id, next_step_user);
     }
+    console.log(`[workflow/engine] [workflow_engine] validate next step users took ${Date.now() - t5}ms`);
 
+    const t6 = Date.now();
     // 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(
@@ -1433,23 +1466,33 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     } else if (step_type === "end") {
         throw new Error('end结点出现approve，服务器错误');
     }
+    console.log(`[workflow/engine] [workflow_engine] engine_step_type_... took ${Date.now() - t6}ms`);
 
+    const t7 = Date.now();
     // 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);
+    console.log(`[workflow/engine] [workflow_engine] caculateKeywords and extras took ${Date.now() - t7}ms`);
 
+    const t8 = Date.now();
     // Update instance
+    const t8_1 = Date.now();
     const instancesCollection = await getCollection('instances');
     await instancesCollection.updateOne({ _id: instance_id }, updateObj);
+    console.log(`[workflow/engine] [workflow_engine] second updateOne took ${Date.now() - t8_1}ms`);
 
     // Insert new instance tasks if needed
     if (updateObj.$push?.traces?.approves) {
+        const t8_2 = Date.now();
         const newTrace = updateObj.$push.traces;
         const approveIds = newTrace.approves.map(a => a._id);
         await insert_many_instance_tasks(instance_id, newTrace._id, approveIds);
+        console.log(`[workflow/engine] [workflow_engine] second insert_many_instance_tasks took ${Date.now() - t8_2}ms`);
     }
+    console.log(`[workflow/engine] [workflow_engine] update instance(second part) took ${Date.now() - t8}ms`);
 
+    const t9 = Date.now();
     // Get final updated instance
     const finalInstance = await UUFlowManager.getInstance(instance_id);
     const finalInstanceTrace = _.find(finalInstance.traces, t => t._id === trace_id);
@@ -1480,7 +1523,9 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
             await pushManager.send_instance_notification("submit_pending_inbox", finalInstance, description, current_user_info);
         }
     }
+    console.log(`[workflow/engine] [workflow_engine] send_instance_notification took ${Date.now() - t9}ms`);
 
+    const t10 = Date.now();
     // Send message to current user and trigger webhook
     await pushManager.send_message_current_user(current_user_info);
     
@@ -1494,6 +1539,8 @@ UUFlowManager.workflow_engine = async function (approve_from_client, current_use
     
     await pushManager.triggerWebhook(flow_id, finalInstance, approve_from_client, 'engine_submit', current_user, to_users);
     await UUFlowManager.distributedInstancesRemind(finalInstance);
+    console.log(`[workflow/engine] [workflow_engine] others took ${Date.now() - t10}ms`);
+    console.log(`[workflow/engine] stats: ${JSON.stringify(UUFlowManager.stats)}`);
 
     return finalInstance;
 };
@@ -1519,11 +1566,14 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
     space_user_org_info, judge, instance, flow, step, 
     current_user, current_user_info, auto_submitted
 ) {
+    console.time(`engine_step_type_is_start_or_submit_or_condition ${approve_id}`);
     const setObj = {};
     const updateObj = {};
     const setTraceObj = {};
     const space_id = instance.space;
 
+    console.time(`start_submit_validate_next_step ${approve_id}`);
+    const t0 = Date.now();
     // Validate next steps
     const nextSteps = await UUFlowManager.getNextSteps(instance, flow, step, "");
     for (const approve_next_step of next_steps) {
@@ -1537,9 +1587,12 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
     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;
+    console.log(`[workflow/engine] [step_start_submit] validate and get next step took ${Date.now() - t0}ms`);
+    console.timeEnd(`start_submit_validate_next_step ${approve_id}`);
 
     // Handle end step
     if (next_step_type === "end") {
+        console.time(`start_submit_handle_end_step ${approve_id}`);
         const instance_traces = instance.traces;
         
         // Update current trace and approve
@@ -1602,7 +1655,10 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
         setObj.current_step_name = next_step_name;
         setObj.final_decision = 'approved';
         setObj.current_step_auto_submit = false;
+        console.timeEnd(`start_submit_handle_end_step ${approve_id}`);
     } else {
+        console.time(`start_submit_handle_next_step ${approve_id}`);
+        const t1 = Date.now();
         // Handle non-end steps
         const next_step_users = next_steps[0].users;
         
@@ -1619,6 +1675,7 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
         if (!UUFlowManager.checkNestStepUsersIsValid(next_step_users, next_user_ids, next_step)) {
             throw new Error("指定的下一步处理人有误");
         }
+        console.log(`[workflow/engine] [step_start_submit] validate next step users internal took ${Date.now() - t1}ms`);
 
         // Update current trace and approve
         const instance_traces = instance.traces;
@@ -1665,6 +1722,7 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
         const usersCollection = await getCollection('users');
         const spaceUsersCollection = await getCollection('space_users');
 
+        let tLoop = Date.now();
         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(
@@ -1718,6 +1776,7 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
             UUFlowManager.setRemindInfo(updated_values, newApprove);
             newTrace.approves.push(newApprove);
         }
+        console.log(`[workflow/engine] [step_start_submit] next_step_users loop took ${Date.now() - tLoop}ms`);
 
         // Prepare instance update
         setObj.state = "pending";
@@ -1739,20 +1798,30 @@ UUFlowManager.engine_step_type_is_start_or_submit_or_condition = async function
         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);
+        console.timeEnd(`start_submit_handle_next_step ${approve_id}`);
     }
 
     // Apply trace updates
+    console.time(`start_submit_trace_updateOne ${approve_id}`);
+    const t2 = Date.now();
     const instancesCollection = await getCollection('instances');
     await instancesCollection.updateOne(
         { _id: instance_id },
         { $set: setTraceObj }
     );
+    console.log(`[workflow/engine] [step_start_submit] trace updateOne took ${Date.now() - t2}ms`);
+    console.timeEnd(`start_submit_trace_updateOne ${approve_id}`);
 
     // Update instance tasks
+    console.time(`start_submit_update_instance_tasks ${approve_id}`);
+    const t3 = Date.now();
     await update_instance_tasks(instance_id, trace_id, approve_id);
+    console.log(`[workflow/engine] [step_start_submit] update_instance_tasks took ${Date.now() - t3}ms`);
+    console.timeEnd(`start_submit_update_instance_tasks ${approve_id}`);
 
     // Combine all updates
     updateObj.$set = setObj;
+    console.timeEnd(`engine_step_type_is_start_or_submit_or_condition ${approve_id}`);
     return updateObj;
 };
 

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

@@ -44,6 +44,7 @@ router.get('/am/designer/startup', async function (req, res) {
         let userId = req.user.userId;
         let queryParams = req.query;
         let companyId = queryParams["companyId"];
+        let flowId = queryParams["flowId"];
         let isCompanyAdmin = false;
         let spaceIds = [];
         let spaces = [];
@@ -71,7 +72,7 @@ router.get('/am/designer/startup', async function (req, res) {
             spaceIds = _.pluck(spaces, '_id');
         }
 
-        let changeSet = await designerManager.getByAdminSpaceIds(spaceIds, companyId, isCompanyAdmin)
+        let changeSet = await designerManager.getByAdminSpaceIds(spaceIds, companyId, isCompanyAdmin, flowId)
         changeSet['Spaces'] = spaces
         changeSet['sync_token'] = new Date().getTime() / 1000
         res.send(changeSet)

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

@@ -54,6 +54,8 @@ const afterHook = require('./afterHook');
  * }
  */
 router.post('/api/workflow/engine', requireAuthentication, afterHook, async function (req, res) {
+    const startTime = Date.now();
+    console.log(`[workflow/engine] start`);
     try {
         let userSession = req.user;
         const spaceId = userSession.spaceId;
@@ -66,11 +68,17 @@ router.post('/api/workflow/engine', requireAuthentication, afterHook, async func
 
         // beforeStepSubmit
         const insId = approve_from_client.instance;
-        const instanceDoc = (await objectql.getObject('instances').find({ filters: [['_id', '=', insId]], fields: ['flow', 'flow_version'] }))[0];
+        const t1 = Date.now();
+        const instanceDoc = await objectql.getObject('instances').findOne(insId, { fields: ['flow', 'flow_version'] });
+        console.log(`[workflow/engine] getObject instances took ${Date.now() - t1}ms`);
         const flowId = instanceDoc.flow;
+        const t2 = Date.now();
         await excuteTriggers({ when: 'beforeStepSubmit', userId, flowId, insId });
+        console.log(`[workflow/engine] beforeStepSubmit took ${Date.now() - t2}ms`);
         // beforeEnd
+        const t3 = Date.now();
         const flowDoc = await objectql.getObject('flows').findOne(flowId);
+        console.log(`[workflow/engine] beforeEnd find logic took ${Date.now() - t3}ms`);
         const next_steps = approve_from_client["next_steps"];
         const next_step_id = next_steps[0]["step"];
         const next_step = getStep(instanceDoc, flowDoc, next_step_id);
@@ -78,17 +86,26 @@ router.post('/api/workflow/engine', requireAuthentication, afterHook, async func
         if (next_step_type == "end") {
             await excuteTriggers({ when: 'beforeEnd', userId, flowId, insId });
         }
+        console.log(`[workflow/engine] beforeEnd logic took ${Date.now() - t3}ms`);
 
         try {
+            const t4 = Date.now();
             const instance = await UUFlowManager.workflow_engine(approve_from_client, userSession, userId);
+            console.log(`[workflow/engine] workflow_engine took ${Date.now() - t4}ms`);
             // afterStepSubmit
+            const t5 = Date.now();
             await excuteTriggers({ when: 'afterStepSubmit', userId, flowId, insId });
+            console.log(`[workflow/engine] afterStepSubmit took ${Date.now() - t5}ms`);
             // afterEnd
             if (instance.state === 'completed') {
+                const t6 = Date.now();
                 await excuteTriggers({ when: 'afterEnd', userId, flowId, insId });
+                console.log(`[workflow/engine] afterEnd took ${Date.now() - t6}ms`);
             }
+            console.log(`[workflow/engine] total took ${Date.now() - startTime}ms`);
             res.status(200).send({});
         } catch (e) {
+            console.log(`[workflow/engine] inner catch total took ${Date.now() - startTime}ms`);
             console.error(e);
             res.status(200).send({
                 errors: [{ errorMessage: e.message }]
@@ -96,6 +113,7 @@ router.post('/api/workflow/engine', requireAuthentication, afterHook, async func
         }
 
     } catch (e) {
+        console.log(`[workflow/engine] outer catch total took ${Date.now() - startTime}ms`);
         res.status(200).send({
             errors: [{ errorMessage: e.message }]
         });

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

@@ -137,6 +137,32 @@ var DesignerAPI = {
 							}
 						}, 100);
 						
+						var closeBtnInterval = setInterval(function(){
+							var iframeWin = $(self)[0].contentWindow;
+							var iframeDoc = iframeWin.document;
+							var closeBtn = $(iframeDoc).find(".htv3.designer.square.sc-view.sc-button-view.button.sc-huge-size");
+							if(closeBtn.length > 0){
+								clearInterval(closeBtnInterval);
+								var lastBtn = closeBtn.last()[0];
+								
+								var newBtn = iframeDoc.createElement("div");
+								newBtn.setAttribute("role", "button");
+								newBtn.className = lastBtn.className; 
+								newBtn.style.cssText = lastBtn.style.cssText;
+								newBtn.innerHTML = '<div class="left"></div><div class="middle"></div><div class="right"></div><label class="sc-button-label sc-huge-size ellipsis">关闭</label>';
+								
+								if(lastBtn.parentNode){
+									lastBtn.parentNode.replaceChild(newBtn, lastBtn);
+									
+									newBtn.onclick = function(e){
+										e.preventDefault();
+										e.stopPropagation();
+										window.close();
+									};
+								}
+							}
+						}, 100);
+
 					});
         			var designer = {
             				urlQuery:function(name){

package/main/default/utils/designerManager.js

@@ -4,82 +4,120 @@ const lodash = require('lodash');
 
 const { _makeNewID, getCollection } = require('./collection');
 
-async function getByAdminSpaceIds(spaceIds, companyId, isCompanyAdmin) {
+async function getByAdminSpaceIds(spaceIds, companyId, isCompanyAdmin, flowId) {
     let filters = _makeInFilters('space', spaceIds);
     let spaceFilters = filters;
     if (isCompanyAdmin && companyId) {
         filters = `(${filters}) and ((company_id eq '${companyId}') or (company_id eq null))`;
     }
-    let userIds = [];
-    let spaceUsers = [];
-
-    spaceUsers = await getObject('space_users').find({
+    
+    const spaceUsersPromise = getObject('space_users').find({
         filters: spaceFilters,
         fields: ['name', 'email', 'space', 'organization', 'organizations', 'user', 'user_accepted', 'company_id']
     })
-    userIds = _.pluck(spaceUsers, 'user');
-    
-    let usersCollection = await getCollection('users');
-    let users = await usersCollection.find({
-        _id: {
-            $in: userIds
-        }
-    }, {
-        fields: {
-            'photo': 1,
-            'google_id': 1,
-            'imo_uid': 1,
-            'company': 1,
-            'name': 1,
-            'locale': 1,
-            'steedos_id': 1,
-            'primary_email_verified': 1,
-            'is_paid_user': 1,
-            'mobile': 1,
-            'email': 1,
-            'created': 1,
-            'modified': 1,
-            'created_by': 1,
-            'modified_by': 1,
-            'email_notification': 1,
-            'qq_open_id': 1
-        }
-    }).toArray();
 
-    let forms = await getObject('forms').find({
-        filters: filters,
-        fields: ['name', 'state', 'is_deleted', 'is_valid', 'space', 'description', 'help_text', 'created', 'created_by', 'error_message', 'current', 'enable_workflow', 'enable_view_others', 'app', 'category', 'is_subform', 'instance_style', 'company_id']
-    })
-    let flows = await getObject('flows').find({
-        filters: filters,
+    const usersPromise = spaceUsersPromise.then(async (spaceUsers) => {
+        let userIds = _.pluck(spaceUsers, 'user');
+        let usersCollection = await getCollection('users');
+        return await usersCollection.find({
+            _id: {
+                $in: userIds
+            }
+        }, {
+            fields: {
+                'photo': 1,
+                'google_id': 1,
+                'imo_uid': 1,
+                'company': 1,
+                'name': 1,
+                'locale': 1,
+                'steedos_id': 1,
+                'primary_email_verified': 1,
+                'is_paid_user': 1,
+                'mobile': 1,
+                'email': 1,
+                'created': 1,
+                'modified': 1,
+                'created_by': 1,
+                'modified_by': 1,
+                'email_notification': 1,
+                'qq_open_id': 1
+            }
+        }).toArray();
+    });
+
+    let flowsFilters = filters;
+    if (flowId) {
+        flowsFilters = `(${flowsFilters}) and (_id eq '${flowId}')`;
+    }
+
+    const flowsPromise = getObject('flows').find({
+        filters: flowsFilters,
         fields: ['name', 'name_formula', 'code_formula', 'space', 'description', 'is_valid', 'form', 'flowtype', 'state', 'is_deleted', 'created', 'created_by', 'help_text', 'current_no', 'current', 'perms', 'error_message', 'app', 'distribute_optional_users', 'company_id']
     })
-    let roles = await getObject('flow_roles').find({
+    
+    let formsPromise;
+    if (flowId) {
+        formsPromise = flowsPromise.then(async (flows) => {
+            let formsFilters = filters;
+            if (flows.length > 0) {
+                const formIds = _.pluck(flows, 'form');
+                if (formIds && formIds.length > 0) {
+                    formsFilters = `(${formsFilters}) and (_id eq '${formIds[0]}')`
+                }
+            } else {
+                formsFilters = `(1 eq 0)`
+            }
+            return await getObject('forms').find({
+                filters: formsFilters,
+                fields: ['name', 'state', 'is_deleted', 'is_valid', 'space', 'description', 'help_text', 'created', 'created_by', 'error_message', 'current', 'enable_workflow', 'enable_view_others', 'app', 'category', 'is_subform', 'instance_style', 'company_id']
+            })
+        })
+    } else {
+        formsPromise = getObject('forms').find({
+            filters: filters,
+            fields: ['name', 'state', 'is_deleted', 'is_valid', 'space', 'description', 'help_text', 'created', 'created_by', 'error_message', 'current', 'enable_workflow', 'enable_view_others', 'app', 'category', 'is_subform', 'instance_style', 'company_id']
+        })
+    }
+
+    const rolesPromise = getObject('flow_roles').find({
         filters: filters
     });
-    let organizations = await getObject('organizations').find({
+    const organizationsPromise = getObject('organizations').find({
         filters: spaceFilters
     });
-    let positions = await getObject('flow_positions').find({
+    const positionsPromise = getObject('flow_positions').find({
         filters: filters
     });
-    let categories = await getObject('categories').find({
+    const categoriesPromise = getObject('categories').find({
         filters: _makeInFilters('space', spaceIds)
     });
 
-    let hrRoles = await getObject('roles').find({
+    const hrRolesPromise = getObject('roles').find({
         filters: filters
     })
 
+    let [spaceUsers, users, forms, flows, organizations, positions, roles, categories, hrRoles] = await Promise.all([
+        spaceUsersPromise,
+        usersPromise,
+        formsPromise,
+        flowsPromise,
+        organizationsPromise,
+        positionsPromise,
+        rolesPromise,
+        categoriesPromise,
+        hrRolesPromise
+    ]);
+
     if (_.isArray(roles)) {
-        for (let role of roles) {
+        await Promise.all(roles.map(async (role) => {
             if (role && role.company_id) {
                 let company = await getObject('company').findOne(role.company_id, { fields: ['name'] }) //, 'abbreviation'
                 if (company && (company.name || company.abbreviation)) {
                     role.name = `${role.name} (${company.abbreviation || company.name})`
                 }
             }
-        }
+        }))
     }
 
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.18",
+  "version": "3.0.19",
   "main": "package.service.js",
   "license": "MIT",
   "scripts": {