@steedos/process 2.2.52 → 2.2.53-beta.2

package/lib/process_manager.js

@@ -1,91 +1,180 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processInstanceWorkitemRemovebyInstance = exports.processInstanceWorkitemReassign = exports.processInstanceWorkitemReject = exports.processInstanceWorkitemApprove = exports.getProcessInstanceWorkitem = exports.getReocrdProcessInstance = exports.recordSubmit = exports.getObjectProcessDefinition = void 0;
-const platform_action_manager_1 = require("./platform_action_manager");
-const notifications_1 = require("./notifications");
-const objectql_1 = require("@steedos/objectql");
-const objectql = require('@steedos/objectql');
-const Fiber = require('fibers');
-const _ = require("underscore");
-const lockObjectRecord = async (objectName, reocrdId) => {
-    await objectql.getObject(objectName).directUpdate(reocrdId, { locked: true });
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-const unlockObjectRecord = async (objectName, reocrdId) => {
-    await objectql.getObject(objectName).directUpdate(reocrdId, { locked: false });
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
 };
-const getProcessNodeApprover = async (instanceId, processNode, userSession, chooseApprover, isBack, record) => {
-    let nodeApprover = [];
-    if (isBack) {
-        const processInstanceNodes = await objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['process_node', '=', processNode._id]], sort: "created desc" });
-        if (!_.isEmpty(processInstanceNodes)) {
-            const lastProcessInstanceNode = processInstanceNodes[0];
-            const nodeHistroy = await objectql.getObject("process_instance_history").find({ filters: ['process_instance_node', '=', lastProcessInstanceNode._id] });
-            _.each(nodeHistroy, function (item) {
-                nodeApprover.push(item.original_actor);
-            });
+exports.__esModule = true;
+exports.processInstanceWorkitemRemovebyInstance = exports.processInstanceWorkitemReassign = exports.processInstanceWorkitemReject = exports.processInstanceWorkitemApprove = exports.getProcessInstanceWorkitem = exports.getReocrdProcessInstance = exports.recordSubmit = exports.getObjectProcessDefinition = void 0;
+var platform_action_manager_1 = require("./platform_action_manager");
+var notifications_1 = require("./notifications");
+var objectql_1 = require("@steedos/objectql");
+var objectql = require('@steedos/objectql');
+var Fiber = require('fibers');
+var _ = require("underscore");
+var lockObjectRecord = function (objectName, reocrdId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject(objectName).directUpdate(reocrdId, { locked: true })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
         }
-    }
-    else {
-        let approver = processNode.approver;
-        if (approver === 'auto_assign') {
-            if (!_.isEmpty(processNode.assigned_approver_users)) {
-                nodeApprover = nodeApprover.concat(processNode.assigned_approver_users);
-            }
-            if (!_.isEmpty(processNode.assigned_approver_roles)) {
-                for (const roleId of processNode.assigned_approver_roles) {
-                    let dbRoles = await objectql.getObject("roles").find({ filters: ['api_name', '=', roleId] });
-                    if (dbRoles && dbRoles.length > 0 && !_.isEmpty(dbRoles[0].users)) {
-                        nodeApprover = nodeApprover.concat(dbRoles[0].users);
-                    }
-                    else {
-                        let role = await objectql.getObject('roles').findOne(roleId);
-                        if (role && !_.isEmpty(role.users)) {
-                            nodeApprover = nodeApprover.concat(role.users);
-                        }
-                    }
-                }
-            }
-            if (!_.isEmpty(processNode.assigned_approver_flow_roles)) {
-                let submitted_by = userSession.userId;
-                let spaceId = userSession.spaceId;
-                if (instanceId) {
-                    let processInstance = await objectql.getObject("process_instance").findOne(instanceId);
-                    submitted_by = processInstance.submitted_by;
+    });
+}); };
+var unlockObjectRecord = function (objectName, reocrdId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject(objectName).directUpdate(reocrdId, { locked: false })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var getProcessNodeApprover = function (instanceId, processNode, userSession, chooseApprover, isBack, record) { return __awaiter(void 0, void 0, void 0, function () {
+    var nodeApprover, processInstanceNodes, lastProcessInstanceNode, nodeHistroy, approver, _i, _a, roleId, dbRoles, role, submitted_by_1, spaceId_1, processInstance, assigned_approver_flow_role_ids_1, flowRoleKeys, _b, flowRoleKeys_1, flowRoleKey, dbFlowRole, dbFlowRoles, handlers, processInstance;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                nodeApprover = [];
+                if (!isBack) return [3 /*break*/, 4];
+                return [4 /*yield*/, objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['process_node', '=', processNode._id]], sort: "created desc" })];
+            case 1:
+                processInstanceNodes = _c.sent();
+                if (!!_.isEmpty(processInstanceNodes)) return [3 /*break*/, 3];
+                lastProcessInstanceNode = processInstanceNodes[0];
+                return [4 /*yield*/, objectql.getObject("process_instance_history").find({ filters: ['process_instance_node', '=', lastProcessInstanceNode._id] })];
+            case 2:
+                nodeHistroy = _c.sent();
+                _.each(nodeHistroy, function (item) {
+                    nodeApprover.push(item.original_actor);
+                });
+                _c.label = 3;
+            case 3: return [3 /*break*/, 27];
+            case 4:
+                approver = processNode.approver;
+                if (!(approver === 'auto_assign')) return [3 /*break*/, 26];
+                if (!_.isEmpty(processNode.assigned_approver_users)) {
+                    nodeApprover = nodeApprover.concat(processNode.assigned_approver_users);
                 }
-                let assigned_approver_flow_role_ids = [];
-                let flowRoleKeys = processNode.assigned_approver_flow_roles;
-                for (let flowRoleKey of flowRoleKeys) {
-                    let dbFlowRole;
-                    let dbFlowRoles = await objectql.getObject("flow_roles").find({ filters: ['api_name', '=', flowRoleKey] });
-                    if (dbFlowRoles && dbFlowRoles.length == 1) {
-                        dbFlowRole = dbFlowRoles[0];
-                    }
-                    else {
-                        dbFlowRole = await objectql.getObject("flow_roles").findOne(flowRoleKey);
-                    }
-                    assigned_approver_flow_role_ids.push(dbFlowRole._id);
+                if (!!_.isEmpty(processNode.assigned_approver_roles)) return [3 /*break*/, 10];
+                _i = 0, _a = processNode.assigned_approver_roles;
+                _c.label = 5;
+            case 5:
+                if (!(_i < _a.length)) return [3 /*break*/, 10];
+                roleId = _a[_i];
+                return [4 /*yield*/, objectql.getObject("roles").find({ filters: ['api_name', '=', roleId] })];
+            case 6:
+                dbRoles = _c.sent();
+                if (!(dbRoles && dbRoles.length > 0 && !_.isEmpty(dbRoles[0].users))) return [3 /*break*/, 7];
+                nodeApprover = nodeApprover.concat(dbRoles[0].users);
+                return [3 /*break*/, 9];
+            case 7: return [4 /*yield*/, objectql.getObject('roles').findOne(roleId)];
+            case 8:
+                role = _c.sent();
+                if (role && !_.isEmpty(role.users)) {
+                    nodeApprover = nodeApprover.concat(role.users);
                 }
-                let handlers = await new Promise((resolve, reject) => {
+                _c.label = 9;
+            case 9:
+                _i++;
+                return [3 /*break*/, 5];
+            case 10:
+                if (!!_.isEmpty(processNode.assigned_approver_flow_roles)) return [3 /*break*/, 21];
+                submitted_by_1 = userSession.userId;
+                spaceId_1 = userSession.spaceId;
+                if (!instanceId) return [3 /*break*/, 12];
+                return [4 /*yield*/, objectql.getObject("process_instance").findOne(instanceId)];
+            case 11:
+                processInstance = _c.sent();
+                submitted_by_1 = processInstance.submitted_by;
+                _c.label = 12;
+            case 12:
+                assigned_approver_flow_role_ids_1 = [];
+                flowRoleKeys = processNode.assigned_approver_flow_roles;
+                _b = 0, flowRoleKeys_1 = flowRoleKeys;
+                _c.label = 13;
+            case 13:
+                if (!(_b < flowRoleKeys_1.length)) return [3 /*break*/, 19];
+                flowRoleKey = flowRoleKeys_1[_b];
+                dbFlowRole = void 0;
+                return [4 /*yield*/, objectql.getObject("flow_roles").find({ filters: ['api_name', '=', flowRoleKey] })];
+            case 14:
+                dbFlowRoles = _c.sent();
+                if (!(dbFlowRoles && dbFlowRoles.length == 1)) return [3 /*break*/, 15];
+                dbFlowRole = dbFlowRoles[0];
+                return [3 /*break*/, 17];
+            case 15: return [4 /*yield*/, objectql.getObject("flow_roles").findOne(flowRoleKey)];
+            case 16:
+                dbFlowRole = _c.sent();
+                _c.label = 17;
+            case 17:
+                assigned_approver_flow_role_ids_1.push(dbFlowRole._id);
+                _c.label = 18;
+            case 18:
+                _b++;
+                return [3 /*break*/, 13];
+            case 19: return [4 /*yield*/, new Promise(function (resolve, reject) {
                     Fiber(function () {
                         try {
-                            let handlers = getHandlersManager.getHandlersByUserAndRoles(submitted_by, assigned_approver_flow_role_ids, spaceId);
-                            resolve(handlers);
+                            var handlers_1 = getHandlersManager.getHandlersByUserAndRoles(submitted_by_1, assigned_approver_flow_role_ids_1, spaceId_1);
+                            resolve(handlers_1);
                         }
                         catch (error) {
                             reject(error);
                         }
                     }).run();
-                });
+                })];
+            case 20:
+                handlers = _c.sent();
                 nodeApprover = nodeApprover.concat(handlers);
-            }
-            if (!_.isEmpty(processNode.assigned_approver_user_field)) {
-                if (instanceId) {
-                    const processInstance = await objectql.getObject("process_instance").findOne(instanceId);
-                    record = await objectql.getObject(processInstance.target_object.o).findOne(processInstance.target_object.ids[0]);
-                }
+                _c.label = 21;
+            case 21:
+                if (!!_.isEmpty(processNode.assigned_approver_user_field)) return [3 /*break*/, 25];
+                if (!instanceId) return [3 /*break*/, 24];
+                return [4 /*yield*/, objectql.getObject("process_instance").findOne(instanceId)];
+            case 22:
+                processInstance = _c.sent();
+                return [4 /*yield*/, objectql.getObject(processInstance.target_object.o).findOne(processInstance.target_object.ids[0])];
+            case 23:
+                record = _c.sent();
+                _c.label = 24;
+            case 24:
                 if (record) {
                     _.each(processNode.assigned_approver_user_field, function (fieldName) {
-                        let fieldValue = record[fieldName];
+                        var fieldValue = record[fieldName];
                         if (_.isString(fieldValue)) {
                             fieldValue = [fieldValue];
                         }
@@ -94,107 +183,165 @@ const getProcessNodeApprover = async (instanceId, processNode, userSession, choo
                         }
                     });
                 }
-            }
-        }
-        else if (approver === 'submitter_choose') {
-            if (chooseApprover) {
-                if (_.isString(chooseApprover)) {
-                    return [chooseApprover];
-                }
-                else if (_.isArray(chooseApprover)) {
-                    return _.uniq(_.compact(chooseApprover));
-                }
-                else {
-                    throw new objectql_1.SteedosError('process_approval_error_invalidChooseApprover');
+                _c.label = 25;
+            case 25: return [3 /*break*/, 27];
+            case 26:
+                if (approver === 'submitter_choose') {
+                    if (chooseApprover) {
+                        if (_.isString(chooseApprover)) {
+                            return [2 /*return*/, [chooseApprover]];
+                        }
+                        else if (_.isArray(chooseApprover)) {
+                            return [2 /*return*/, _.uniq(_.compact(chooseApprover))];
+                        }
+                        else {
+                            throw new objectql_1.SteedosError('process_approval_error_invalidChooseApprover');
+                        }
+                    }
+                    else {
+                        throw new objectql_1.SteedosError('process_approval_error_needToChooseApprover');
+                    }
                 }
-            }
-            else {
-                throw new objectql_1.SteedosError('process_approval_error_needToChooseApprover');
-            }
+                _c.label = 27;
+            case 27: return [2 /*return*/, _.uniq(_.compact(nodeApprover))];
         }
-    }
-    return _.uniq(_.compact(nodeApprover));
-};
-const getProcessNodes = async (processDefinitionId, spaceId) => {
-    return await objectql.getObject('process_node').find({ filters: [['process_definition', '=', processDefinitionId], ['space', '=', spaceId]], sort: "order asc" });
-};
-const addInstanceHistory = async (spaceId, instanceId, status, comment, options, userSession) => {
-    let instance = await objectql.getObject("process_instance").findOne(instanceId);
-    let name = '';
-    if (options.nodeId) {
-        const node = await objectql.getObject("process_node").findOne(options.nodeId);
-        if (node) {
-            name = node.label;
+    });
+}); };
+var getProcessNodes = function (processDefinitionId, spaceId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject('process_node').find({ filters: [['process_definition', '=', processDefinitionId], ['space', '=', spaceId]], sort: "order asc" })];
+            case 1: return [2 /*return*/, _a.sent()];
         }
-    }
-    let instanceHistory = await objectql.getObject("process_instance_history").insert({
-        name: name,
-        process_instance: instanceId,
-        target_object: instance.target_object,
-        step_status: status,
-        original_actor: options.originalActor || options.actor,
-        actor: options.actor,
-        comments: comment,
-        step_node: options.nodeId,
-        process_instance_node: options.instanceNodeId,
-        space: spaceId,
-        created_by: userSession.userId
     });
-    if (status === 'approved' || status === 'rejected') {
-        await handleProcessInstance(instanceHistory.process_instance, status, userSession);
-    }
-    if (status === 'pending') {
-        await (0, notifications_1.sendNotifications)(instance.created_by, options.actor, { instanceHistory, status, instance });
-    }
-};
-const addInstanceNode = async (instanceId, node, userSession, nodeApprover) => {
-    let nodeId = node._id;
-    let nodeName = node.label;
-    // const nodeApprover = await getProcessNodeApprover(instanceId, node, userSession, isBack); 
-    const instanceNode = await objectql.getObject("process_instance_node").insert({
-        process_instance: instanceId,
-        process_node: nodeId,
-        process_node_name: nodeName,
-        node_status: 'pending',
-        space: userSession.spaceId,
-        created_by: userSession.userId
+}); };
+var addInstanceHistory = function (spaceId, instanceId, status, comment, options, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var instance, name, node, instanceHistory;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance").findOne(instanceId)];
+            case 1:
+                instance = _a.sent();
+                name = '';
+                if (!options.nodeId) return [3 /*break*/, 3];
+                return [4 /*yield*/, objectql.getObject("process_node").findOne(options.nodeId)];
+            case 2:
+                node = _a.sent();
+                if (node) {
+                    name = node.label;
+                }
+                _a.label = 3;
+            case 3: return [4 /*yield*/, objectql.getObject("process_instance_history").insert({
+                    name: name,
+                    process_instance: instanceId,
+                    target_object: instance.target_object,
+                    step_status: status,
+                    original_actor: options.originalActor || options.actor,
+                    actor: options.actor,
+                    comments: comment,
+                    step_node: options.nodeId,
+                    process_instance_node: options.instanceNodeId,
+                    space: spaceId,
+                    created_by: userSession.userId
+                })];
+            case 4:
+                instanceHistory = _a.sent();
+                if (!(status === 'approved' || status === 'rejected')) return [3 /*break*/, 6];
+                return [4 /*yield*/, handleProcessInstance(instanceHistory.process_instance, status, userSession)];
+            case 5:
+                _a.sent();
+                _a.label = 6;
+            case 6:
+                if (!(status === 'pending')) return [3 /*break*/, 8];
+                return [4 /*yield*/, (0, notifications_1.sendNotifications)(instance.created_by, options.actor, { instanceHistory: instanceHistory, status: status, instance: instance })];
+            case 7:
+                _a.sent();
+                _a.label = 8;
+            case 8: return [2 /*return*/];
+        }
     });
-    for (const actor of nodeApprover) {
-        await addInstanceHistory(userSession.spaceId, instanceId, 'pending', null, { nodeId: nodeId, actor: actor, originalActor: actor, submitted_by: userSession.userId, instanceNodeId: instanceNode._id }, userSession);
-    }
-};
-const getNextNode = async (nodes, index = 0, objectName, recordId, userSession) => {
-    let spaceId = userSession.spaceId;
-    let currentUserId = userSession.userId;
-    let node = nodes[index];
-    if (node) {
-        if (node.filtrad) {
-            return node;
+}); };
+var addInstanceNode = function (instanceId, node, userSession, nodeApprover) { return __awaiter(void 0, void 0, void 0, function () {
+    var nodeId, nodeName, instanceNode, _i, nodeApprover_1, actor;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                nodeId = node._id;
+                nodeName = node.label;
+                return [4 /*yield*/, objectql.getObject("process_instance_node").insert({
+                        process_instance: instanceId,
+                        process_node: nodeId,
+                        process_node_name: nodeName,
+                        node_status: 'pending',
+                        space: userSession.spaceId,
+                        created_by: userSession.userId
+                    })];
+            case 1:
+                instanceNode = _a.sent();
+                _i = 0, nodeApprover_1 = nodeApprover;
+                _a.label = 2;
+            case 2:
+                if (!(_i < nodeApprover_1.length)) return [3 /*break*/, 5];
+                actor = nodeApprover_1[_i];
+                return [4 /*yield*/, addInstanceHistory(userSession.spaceId, instanceId, 'pending', null, { nodeId: nodeId, actor: actor, originalActor: actor, submitted_by: userSession.userId, instanceNodeId: instanceNode._id }, userSession)];
+            case 3:
+                _a.sent();
+                _a.label = 4;
+            case 4:
+                _i++;
+                return [3 /*break*/, 2];
+            case 5: return [2 /*return*/];
         }
-        else {
-            const canEntry = await objectql.computeFormula(node.entry_criteria, objectName, recordId, currentUserId, spaceId);
-            if (canEntry) {
-                return node;
-            }
-            else {
-                if (node.if_criteria_not_met === 'skip') {
-                    return await getNextNode(nodes, index + 1, objectName, recordId, userSession);
-                }
-                else if (node.if_criteria_not_met === 'reject') {
-                    return { to_final_rejection: true };
-                }
-                else if (node.if_criteria_not_met === 'approve') {
-                    return { to_final_approval: true };
-                }
+    });
+}); };
+var getNextNode = function (nodes, index, objectName, recordId, userSession) {
+    if (index === void 0) { index = 0; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var spaceId, currentUserId, node, canEntry;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    spaceId = userSession.spaceId;
+                    currentUserId = userSession.userId;
+                    node = nodes[index];
+                    if (!node) return [3 /*break*/, 6];
+                    if (!node.filtrad) return [3 /*break*/, 1];
+                    return [2 /*return*/, node];
+                case 1: return [4 /*yield*/, objectql.computeFormula(node.entry_criteria, objectName, recordId, currentUserId, spaceId)];
+                case 2:
+                    canEntry = _a.sent();
+                    if (!canEntry) return [3 /*break*/, 3];
+                    return [2 /*return*/, node];
+                case 3:
+                    if (!(node.if_criteria_not_met === 'skip')) return [3 /*break*/, 5];
+                    return [4 /*yield*/, getNextNode(nodes, index + 1, objectName, recordId, userSession)];
+                case 4: return [2 /*return*/, _a.sent()];
+                case 5:
+                    if (node.if_criteria_not_met === 'reject') {
+                        return [2 /*return*/, { to_final_rejection: true }];
+                    }
+                    else if (node.if_criteria_not_met === 'approve') {
+                        return [2 /*return*/, { to_final_approval: true }];
+                    }
+                    _a.label = 6;
+                case 6: return [2 /*return*/];
             }
-        }
-    }
-};
-const toNextNode = async (instanceId, node, nextApprovers, userSession) => {
-    if (node) {
-        await addInstanceNode(instanceId, node, userSession, nextApprovers);
-    }
+        });
+    });
 };
+var toNextNode = function (instanceId, node, nextApprovers, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!node) return [3 /*break*/, 2];
+                return [4 /*yield*/, addInstanceNode(instanceId, node, userSession, nextApprovers)];
+            case 1:
+                _a.sent();
+                _a.label = 2;
+            case 2: return [2 /*return*/];
+        }
+    });
+}); };
 //TODO nextApprovers
 // const toNextNode = async (instanceId: string, comment: string, nodes: any, index: number = 0, objectName: string, recordId: string, userSession: any, nextApprovers?)=>{
 //     let spaceId = userSession.spaceId;
@@ -222,17 +369,23 @@ const toNextNode = async (instanceId, node, nextApprovers, userSession) => {
 //         }
 //     }
 // }
-const getPreviousNode = async (instanceId, currentNode, userSession) => {
-    const previousInstanceNodes = await objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['process_node', '!=', currentNode._id]], sort: 'created desc' });
-    if (!_.isEmpty(previousInstanceNodes)) {
-        const previousInstanceNode = previousInstanceNodes[0];
-        const previousNode = await objectql.getObject("process_node").findOne(previousInstanceNode.process_node);
-        return previousNode;
-    }
-    else {
-        throw new objectql_1.SteedosError('not find previous node');
-    }
-};
+var getPreviousNode = function (instanceId, currentNode, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var previousInstanceNodes, previousInstanceNode, previousNode;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['process_node', '!=', currentNode._id]], sort: 'created desc' })];
+            case 1:
+                previousInstanceNodes = _a.sent();
+                if (!!_.isEmpty(previousInstanceNodes)) return [3 /*break*/, 3];
+                previousInstanceNode = previousInstanceNodes[0];
+                return [4 /*yield*/, objectql.getObject("process_node").findOne(previousInstanceNode.process_node)];
+            case 2:
+                previousNode = _a.sent();
+                return [2 /*return*/, previousNode];
+            case 3: throw new objectql_1.SteedosError('not find previous node');
+        }
+    });
+}); };
 // const toPreviousNode = async (instanceId: string, currentNode: any, userSession: any)=>{
 //     const previousInstanceNodes = await objectql.getObject("process_instance_node").find({filters: [['process_instance', '=', instanceId], ['process_node', '!=', currentNode._id]], sort: 'created desc'});
 //     if(!_.isEmpty(previousInstanceNodes)){
@@ -244,88 +397,150 @@ const getPreviousNode = async (instanceId, currentNode, userSession) => {
 //     }
 // }
 //TODO 处理提交权限
-const getObjectProcessDefinition = async (objectName, recordId, userSession) => {
-    let spaceId = userSession.spaceId;
-    let currentUserId = userSession.userId;
-    let processes = await objectql.getObject('process_definition').find({ filters: [['object_name', '=', objectName], ['space', '=', spaceId], ['active', '=', true]], sort: "order asc" });
-    if (processes.length < 1) {
-        return null;
-    }
-    let process = null;
-    //计算符合条件的process_definition
-    for (const _process of processes) {
-        const canEntry = await objectql.computeFormula(_process.entry_criteria, objectName, recordId, currentUserId, spaceId);
-        if (canEntry) {
-            process = _process;
-            break;
+var getObjectProcessDefinition = function (objectName, recordId, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var spaceId, currentUserId, processes, process, _i, processes_1, _process, canEntry;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                spaceId = userSession.spaceId;
+                currentUserId = userSession.userId;
+                return [4 /*yield*/, objectql.getObject('process_definition').find({ filters: [['object_name', '=', objectName], ['space', '=', spaceId], ['active', '=', true]], sort: "order asc" })];
+            case 1:
+                processes = _a.sent();
+                if (processes.length < 1) {
+                    return [2 /*return*/, null];
+                }
+                process = null;
+                _i = 0, processes_1 = processes;
+                _a.label = 2;
+            case 2:
+                if (!(_i < processes_1.length)) return [3 /*break*/, 5];
+                _process = processes_1[_i];
+                return [4 /*yield*/, objectql.computeFormula(_process.entry_criteria, objectName, recordId, currentUserId, spaceId)];
+            case 3:
+                canEntry = _a.sent();
+                if (canEntry) {
+                    process = _process;
+                    return [3 /*break*/, 5];
+                }
+                _a.label = 4;
+            case 4:
+                _i++;
+                return [3 /*break*/, 2];
+            case 5: return [2 /*return*/, process];
         }
-    }
-    return process;
-};
+    });
+}); };
 exports.getObjectProcessDefinition = getObjectProcessDefinition;
-const recordSubmit = async (processDefinitionId, objectName, recordId, userSession, comment, chooseApprover) => {
-    const pendingInstanceCount = await objectql.getObject("process_instance").count({ filters: [['target_object.o', '=', objectName], ['target_object.ids', '=', recordId], ['status', '=', 'pending']] });
-    if (pendingInstanceCount > 0) {
-        throw new objectql_1.SteedosError('process_approval_error_processInstancePending');
-    }
-    const nodes = await getProcessNodes(processDefinitionId, userSession.spaceId);
-    const nextNode = await getNextNode(nodes, 0, objectName, recordId, userSession);
-    let to_final_rejection = false;
-    let to_final_approval = false;
-    if (nextNode.to_final_rejection) {
-        to_final_rejection = true;
-    }
-    else if (nextNode.to_final_approval) {
-        to_final_approval = true;
-    }
-    let approver = null;
-    if (!to_final_rejection && !to_final_rejection) {
-        const record = await objectql.getObject(objectName).findOne(recordId);
-        approver = await getProcessNodeApprover(null, nextNode, userSession, chooseApprover, false, record);
-    }
-    let instance = await objectql.getObject("process_instance").insert({
-        process_definition: processDefinitionId,
-        target_object: {
-            "o": objectName,
-            "ids": [recordId]
-        },
-        status: "pending",
-        space: userSession.spaceId,
-        submitted_by: userSession.userId,
-        created_by: userSession.userId
+var recordSubmit = function (processDefinitionId, objectName, recordId, userSession, comment, chooseApprover) { return __awaiter(void 0, void 0, void 0, function () {
+    var pendingInstanceCount, nodes, nextNode, to_final_rejection, to_final_approval, approver, record, instance, options, options;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance").count({ filters: [['target_object.o', '=', objectName], ['target_object.ids', '=', recordId], ['status', '=', 'pending']] })];
+            case 1:
+                pendingInstanceCount = _a.sent();
+                if (pendingInstanceCount > 0) {
+                    throw new objectql_1.SteedosError('process_approval_error_processInstancePending');
+                }
+                return [4 /*yield*/, getProcessNodes(processDefinitionId, userSession.spaceId)];
+            case 2:
+                nodes = _a.sent();
+                return [4 /*yield*/, getNextNode(nodes, 0, objectName, recordId, userSession)];
+            case 3:
+                nextNode = _a.sent();
+                to_final_rejection = false;
+                to_final_approval = false;
+                if (nextNode.to_final_rejection) {
+                    to_final_rejection = true;
+                }
+                else if (nextNode.to_final_approval) {
+                    to_final_approval = true;
+                }
+                approver = null;
+                if (!(!to_final_rejection && !to_final_rejection)) return [3 /*break*/, 6];
+                return [4 /*yield*/, objectql.getObject(objectName).findOne(recordId)];
+            case 4:
+                record = _a.sent();
+                return [4 /*yield*/, getProcessNodeApprover(null, nextNode, userSession, chooseApprover, false, record)];
+            case 5:
+                approver = _a.sent();
+                _a.label = 6;
+            case 6: return [4 /*yield*/, objectql.getObject("process_instance").insert({
+                    process_definition: processDefinitionId,
+                    target_object: {
+                        "o": objectName,
+                        "ids": [recordId]
+                    },
+                    status: "pending",
+                    space: userSession.spaceId,
+                    submitted_by: userSession.userId,
+                    created_by: userSession.userId
+                })];
+            case 7:
+                instance = _a.sent();
+                return [4 /*yield*/, lockObjectRecord(objectName, recordId)];
+            case 8:
+                _a.sent();
+                return [4 /*yield*/, (0, platform_action_manager_1.runProcessAction)(processDefinitionId, 'initial_submission', recordId, userSession)];
+            case 9:
+                _a.sent();
+                return [4 /*yield*/, addInstanceHistory(userSession.spaceId, instance._id, "started", comment, { actor: userSession.userId }, userSession)];
+            case 10:
+                _a.sent();
+                if (!to_final_rejection) return [3 /*break*/, 12];
+                options = { actor: userSession.userId };
+                return [4 /*yield*/, addInstanceHistory(userSession.spaceId, instance._id, "rejected", comment, options, userSession)];
+            case 11:
+                _a.sent();
+                return [3 /*break*/, 16];
+            case 12:
+                if (!to_final_approval) return [3 /*break*/, 14];
+                options = { actor: userSession.userId };
+                return [4 /*yield*/, addInstanceHistory(userSession.spaceId, instance._id, "approved", comment, options, userSession)];
+            case 13:
+                _a.sent();
+                return [3 /*break*/, 16];
+            case 14: return [4 /*yield*/, toNextNode(instance._id, nextNode, approver, userSession)];
+            case 15:
+                _a.sent();
+                _a.label = 16;
+            case 16: return [2 /*return*/];
+        }
     });
-    await lockObjectRecord(objectName, recordId);
-    await (0, platform_action_manager_1.runProcessAction)(processDefinitionId, 'initial_submission', recordId, userSession);
-    await addInstanceHistory(userSession.spaceId, instance._id, "started", comment, { actor: userSession.userId }, userSession);
-    if (to_final_rejection) {
-        let options = { actor: userSession.userId };
-        await addInstanceHistory(userSession.spaceId, instance._id, "rejected", comment, options, userSession);
-    }
-    else if (to_final_approval) {
-        let options = { actor: userSession.userId };
-        await addInstanceHistory(userSession.spaceId, instance._id, "approved", comment, options, userSession);
-    }
-    else {
-        await toNextNode(instance._id, nextNode, approver, userSession);
-    }
-};
+}); };
 exports.recordSubmit = recordSubmit;
-const getReocrdProcessInstance = async (objectName, recordId, status, userSession) => {
-    let spaceId = userSession.spaceId;
-    return await objectql.getObject("process_instance").find({ filters: [['space', '=', spaceId], ['status', '=', status], ['target_object.o', '=', objectName], ['target_object.ids', '=', recordId]] });
-};
+var getReocrdProcessInstance = function (objectName, recordId, status, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var spaceId;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                spaceId = userSession.spaceId;
+                return [4 /*yield*/, objectql.getObject("process_instance").find({ filters: [['space', '=', spaceId], ['status', '=', status], ['target_object.o', '=', objectName], ['target_object.ids', '=', recordId]] })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
 exports.getReocrdProcessInstance = getReocrdProcessInstance;
-const getProcessInstanceWorkitem = async (instanceHistoryId, userSession) => {
-    let spaceId = userSession.spaceId;
-    let userId = userSession.userId; //TODO 代理
-    const workitme = await objectql.getObject("process_instance_history").find({ filters: [['_id', '=', instanceHistoryId], ['step_status', '=', 'pending'], ['actor', '=', userId], ['space', '=', spaceId]] });
-    if (workitme.length > 0) {
-        return workitme[0];
-    }
-};
+var getProcessInstanceWorkitem = function (instanceHistoryId, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var spaceId, userId, workitme;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                spaceId = userSession.spaceId;
+                userId = userSession.userId;
+                return [4 /*yield*/, objectql.getObject("process_instance_history").find({ filters: [['_id', '=', instanceHistoryId], ['step_status', '=', 'pending'], ['actor', '=', userId], ['space', '=', spaceId]] })];
+            case 1:
+                workitme = _a.sent();
+                if (workitme.length > 0) {
+                    return [2 /*return*/, workitme[0]];
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
 exports.getProcessInstanceWorkitem = getProcessInstanceWorkitem;
-const getProcessActionWhenByStatus = (processStatus) => {
-    let when = '';
+var getProcessActionWhenByStatus = function (processStatus) {
+    var when = '';
     if (processStatus === 'approved') {
         when = 'final_approval';
     }
@@ -337,8 +552,8 @@ const getProcessActionWhenByStatus = (processStatus) => {
     }
     return when;
 };
-const getProcessNodeActionWhenByStatus = (processStatus) => {
-    let when = '';
+var getProcessNodeActionWhenByStatus = function (processStatus) {
+    var when = '';
     if (processStatus === 'approved') {
         when = 'approval';
     }
@@ -361,164 +576,321 @@ const getProcessNodeActionWhenByStatus = (processStatus) => {
 //     }
 // }
 //TODO 编写trigger 处理elapsed_time
-const handleProcessInstance = async (instanceId, processStatus, userSession) => {
-    let otherPendingInstanceNodeCount = await objectql.getObject("process_instance_node").count({ filters: [['process_instance', '=', instanceId], ['node_status', '=', 'pending']] });
-    if (otherPendingInstanceNodeCount === 0) {
-        const pInstance = await objectql.getObject("process_instance").update(instanceId, { status: processStatus, completed_date: new Date(), last_actor: userSession.userId });
-        if (processStatus === 'removed') {
-            await unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0]);
+var handleProcessInstance = function (instanceId, processStatus, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var otherPendingInstanceNodeCount, pInstance, process_1, when;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_node").count({ filters: [['process_instance', '=', instanceId], ['node_status', '=', 'pending']] })];
+            case 1:
+                otherPendingInstanceNodeCount = _a.sent();
+                if (!(otherPendingInstanceNodeCount === 0)) return [3 /*break*/, 18];
+                return [4 /*yield*/, objectql.getObject("process_instance").update(instanceId, { status: processStatus, completed_date: new Date(), last_actor: userSession.userId })];
+            case 2:
+                pInstance = _a.sent();
+                if (!(processStatus === 'removed')) return [3 /*break*/, 4];
+                return [4 /*yield*/, unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0])];
+            case 3:
+                _a.sent();
+                return [3 /*break*/, 14];
+            case 4: return [4 /*yield*/, objectql.getObject("process_definition").findOne(pInstance.process_definition)];
+            case 5:
+                process_1 = _a.sent();
+                if (!(processStatus === 'approved')) return [3 /*break*/, 10];
+                if (!(process_1.final_approval_record_lock === 'unlock')) return [3 /*break*/, 7];
+                return [4 /*yield*/, unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0])];
+            case 6:
+                _a.sent();
+                return [3 /*break*/, 9];
+            case 7: return [4 /*yield*/, lockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0])];
+            case 8:
+                _a.sent();
+                _a.label = 9;
+            case 9: return [3 /*break*/, 14];
+            case 10:
+                if (!(processStatus === 'rejected')) return [3 /*break*/, 14];
+                if (!(process_1.final_rejection_record_lock === 'unlock')) return [3 /*break*/, 12];
+                return [4 /*yield*/, unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0])];
+            case 11:
+                _a.sent();
+                return [3 /*break*/, 14];
+            case 12: return [4 /*yield*/, lockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0])];
+            case 13:
+                _a.sent();
+                _a.label = 14;
+            case 14:
+                when = getProcessActionWhenByStatus(processStatus);
+                if (!when) return [3 /*break*/, 16];
+                return [4 /*yield*/, (0, platform_action_manager_1.runProcessAction)(pInstance.process_definition, when, pInstance.target_object.ids[0], userSession)];
+            case 15:
+                _a.sent();
+                _a.label = 16;
+            case 16:
+                if (!(['approved', 'rejected'].indexOf(processStatus) > -1)) return [3 /*break*/, 18];
+                return [4 /*yield*/, (0, notifications_1.sendNotifications)(pInstance.created_by, pInstance.created_by, { status: processStatus, instance: pInstance })];
+            case 17:
+                _a.sent();
+                _a.label = 18;
+            case 18: return [2 /*return*/];
         }
-        else {
-            let process = await objectql.getObject("process_definition").findOne(pInstance.process_definition);
-            if (processStatus === 'approved') {
-                if (process.final_approval_record_lock === 'unlock') {
-                    await unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0]);
-                }
-                else {
-                    await lockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0]);
-                }
-            }
-            else if (processStatus === 'rejected') {
-                if (process.final_rejection_record_lock === 'unlock') {
-                    await unlockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0]);
-                }
-                else {
-                    await lockObjectRecord(pInstance.target_object.o, pInstance.target_object.ids[0]);
+    });
+}); };
+var getCurrentInstanceNode = function (instanceId) { return __awaiter(void 0, void 0, void 0, function () {
+    var pendingNodes, currentNode;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['node_status', '=', 'pending']] })];
+            case 1:
+                pendingNodes = _a.sent();
+                currentNode = null;
+                if (pendingNodes.length > 0) {
+                    currentNode = pendingNodes[0];
                 }
-            }
+                return [2 /*return*/, currentNode];
         }
-        let when = getProcessActionWhenByStatus(processStatus);
-        if (when) {
-            await (0, platform_action_manager_1.runProcessAction)(pInstance.process_definition, when, pInstance.target_object.ids[0], userSession);
+    });
+}); };
+var getProcessInstance = function (instanceId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance").findOne(instanceId)];
+            case 1: return [2 /*return*/, _a.sent()];
         }
-        if (['approved', 'rejected'].indexOf(processStatus) > -1) {
-            await (0, notifications_1.sendNotifications)(pInstance.created_by, pInstance.created_by, { status: processStatus, instance: pInstance });
+    });
+}); };
+var getProcessNode = function (processNodeId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_node").findOne(processNodeId)];
+            case 1: return [2 /*return*/, _a.sent()];
         }
-    }
-};
-const getCurrentInstanceNode = async (instanceId) => {
-    const pendingNodes = await objectql.getObject("process_instance_node").find({ filters: [['process_instance', '=', instanceId], ['node_status', '=', 'pending']] });
-    let currentNode = null;
-    if (pendingNodes.length > 0) {
-        currentNode = pendingNodes[0];
-    }
-    return currentNode;
-};
-const getProcessInstance = async (instanceId) => {
-    return await objectql.getObject("process_instance").findOne(instanceId);
-};
-const getProcessNode = async (processNodeId) => {
-    return await objectql.getObject("process_node").findOne(processNodeId);
-};
+    });
+}); };
 //TODO 编写trigger 处理elapsed_time
-const handleProcessInstanceNode = async (instanceId, currentInstanceNode, processStatus, nextNodeOptions, userSession) => {
-    let otherPendingInstanceHistoryCount = await objectql.getObject("process_instance_history").count({ filters: [['process_instance', '=', instanceId], ['step_status', '=', 'pending']] });
-    if (otherPendingInstanceHistoryCount === 0) {
-        let finalProcessStatus = processStatus;
-        await objectql.getObject("process_instance_node").updateMany([['process_instance', '=', instanceId], ['node_status', '=', 'pending']], { node_status: processStatus, completed_date: new Date(), last_actor: userSession.userId });
-        let when = getProcessNodeActionWhenByStatus(processStatus);
-        if (when) {
-            const instance = await objectql.getObject("process_instance").findOne(instanceId);
-            await (0, platform_action_manager_1.runProcessNodeAction)(currentInstanceNode.process_node, when, instance.target_object.ids[0], userSession);
+var handleProcessInstanceNode = function (instanceId, currentInstanceNode, processStatus, nextNodeOptions, userSession) { return __awaiter(void 0, void 0, void 0, function () {
+    var otherPendingInstanceHistoryCount, finalProcessStatus, when, instance, to_final_rejection, to_final_approval;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_history").count({ filters: [['process_instance', '=', instanceId], ['step_status', '=', 'pending']] })];
+            case 1:
+                otherPendingInstanceHistoryCount = _a.sent();
+                if (!(otherPendingInstanceHistoryCount === 0)) return [3 /*break*/, 11];
+                finalProcessStatus = processStatus;
+                return [4 /*yield*/, objectql.getObject("process_instance_node").updateMany([['process_instance', '=', instanceId], ['node_status', '=', 'pending']], { node_status: processStatus, completed_date: new Date(), last_actor: userSession.userId })];
+            case 2:
+                _a.sent();
+                when = getProcessNodeActionWhenByStatus(processStatus);
+                if (!when) return [3 /*break*/, 5];
+                return [4 /*yield*/, objectql.getObject("process_instance").findOne(instanceId)];
+            case 3:
+                instance = _a.sent();
+                return [4 /*yield*/, (0, platform_action_manager_1.runProcessNodeAction)(currentInstanceNode.process_node, when, instance.target_object.ids[0], userSession)];
+            case 4:
+                _a.sent();
+                _a.label = 5;
+            case 5:
+                if (!nextNodeOptions) return [3 /*break*/, 9];
+                to_final_rejection = false;
+                to_final_approval = false;
+                if (nextNodeOptions.node.to_final_rejection) {
+                    to_final_rejection = true;
+                    finalProcessStatus = 'rejected';
+                }
+                else if (nextNodeOptions.node.to_final_approval) {
+                    to_final_approval = true;
+                    finalProcessStatus = 'approved';
+                }
+                if (!to_final_rejection) return [3 /*break*/, 6];
+                return [3 /*break*/, 9];
+            case 6:
+                if (!to_final_approval) return [3 /*break*/, 7];
+                return [3 /*break*/, 9];
+            case 7: return [4 /*yield*/, toNextNode(instanceId, nextNodeOptions.node, nextNodeOptions.approve, userSession)];
+            case 8:
+                _a.sent();
+                _a.label = 9;
+            case 9: return [4 /*yield*/, handleProcessInstance(instanceId, finalProcessStatus, userSession)];
+            case 10:
+                _a.sent();
+                _a.label = 11;
+            case 11: return [2 /*return*/];
         }
-        if (nextNodeOptions) {
-            let to_final_rejection = false;
-            let to_final_approval = false;
-            if (nextNodeOptions.node.to_final_rejection) {
-                to_final_rejection = true;
-                finalProcessStatus = 'rejected';
-            }
-            else if (nextNodeOptions.node.to_final_approval) {
-                to_final_approval = true;
-                finalProcessStatus = 'approved';
-            }
-            if (to_final_rejection) {
-            }
-            else if (to_final_approval) {
-            }
-            else {
-                await toNextNode(instanceId, nextNodeOptions.node, nextNodeOptions.approve, userSession);
-            }
+    });
+}); };
+var getInstanceHistory = function (instanceHistoryId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_history").findOne(instanceHistoryId)];
+            case 1: return [2 /*return*/, _a.sent()];
         }
-        await handleProcessInstance(instanceId, finalProcessStatus, userSession);
-    }
-};
-const getInstanceHistory = async (instanceHistoryId) => {
-    return await objectql.getObject("process_instance_history").findOne(instanceHistoryId);
-};
-const getPendingInstanceHistoryCount = async (instanceId) => {
-    return await objectql.getObject("process_instance_history").count({ filters: [['process_instance', '=', instanceId], ['step_status', '=', 'pending']] });
-};
-const handleProcessInstanceWorkitem = async (currentInstanceNode, processStatus, instanceHistoryId, userSession, comment, nextNodeOptions) => {
-    let instanceHistory = await getInstanceHistory(instanceHistoryId);
-    if (processStatus === 'rejected' || processStatus === 'approved') {
-        await objectql.getObject("process_instance_history").update(instanceHistoryId, { step_status: processStatus, comments: comment, actor: userSession.userId });
-        let when_multiple_approvers = 'first_response';
-        if (instanceHistory.step_node) {
-            let processNode = await objectql.getObject("process_node").findOne(instanceHistory.step_node);
-            if (processNode && processNode.when_multiple_approvers) {
-                when_multiple_approvers = processNode.when_multiple_approvers;
-            }
+    });
+}); };
+var getPendingInstanceHistoryCount = function (instanceId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, objectql.getObject("process_instance_history").count({ filters: [['process_instance', '=', instanceId], ['step_status', '=', 'pending']] })];
+            case 1: return [2 /*return*/, _a.sent()];
         }
-        if (when_multiple_approvers === 'first_response' || (when_multiple_approvers === 'unanimous' && processStatus === 'rejected')) {
-            await objectql.getObject("process_instance_history").updateMany([['_id', '!=', instanceHistory._id], ['process_instance', '=', instanceHistory.process_instance], ['step_status', '=', 'pending']], { step_status: 'no_response' });
+    });
+}); };
+var handleProcessInstanceWorkitem = function (currentInstanceNode, processStatus, instanceHistoryId, userSession, comment, nextNodeOptions) { return __awaiter(void 0, void 0, void 0, function () {
+    var instanceHistory, when_multiple_approvers, processNode;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getInstanceHistory(instanceHistoryId)];
+            case 1:
+                instanceHistory = _a.sent();
+                if (!(processStatus === 'rejected' || processStatus === 'approved')) return [3 /*break*/, 6];
+                return [4 /*yield*/, objectql.getObject("process_instance_history").update(instanceHistoryId, { step_status: processStatus, comments: comment, actor: userSession.userId })];
+            case 2:
+                _a.sent();
+                when_multiple_approvers = 'first_response';
+                if (!instanceHistory.step_node) return [3 /*break*/, 4];
+                return [4 /*yield*/, objectql.getObject("process_node").findOne(instanceHistory.step_node)];
+            case 3:
+                processNode = _a.sent();
+                if (processNode && processNode.when_multiple_approvers) {
+                    when_multiple_approvers = processNode.when_multiple_approvers;
+                }
+                _a.label = 4;
+            case 4:
+                if (!(when_multiple_approvers === 'first_response' || (when_multiple_approvers === 'unanimous' && processStatus === 'rejected'))) return [3 /*break*/, 6];
+                return [4 /*yield*/, objectql.getObject("process_instance_history").updateMany([['_id', '!=', instanceHistory._id], ['process_instance', '=', instanceHistory.process_instance], ['step_status', '=', 'pending']], { step_status: 'no_response' })];
+            case 5:
+                _a.sent();
+                _a.label = 6;
+            case 6: return [4 /*yield*/, handleProcessInstanceNode(instanceHistory.process_instance, currentInstanceNode, processStatus, nextNodeOptions, userSession)];
+            case 7:
+                _a.sent();
+                return [2 /*return*/];
         }
-    }
-    await handleProcessInstanceNode(instanceHistory.process_instance, currentInstanceNode, processStatus, nextNodeOptions, userSession);
-};
-const processInstanceWorkitemApprove = async (instanceHistoryId, userSession, comment, chooseApprover) => {
-    let nextNodeOptions = null;
-    let instanceHistory = await getInstanceHistory(instanceHistoryId);
-    let instanceId = instanceHistory.process_instance;
-    let currentInstanceNode = await getCurrentInstanceNode(instanceId);
-    let instance = await getProcessInstance(instanceId);
-    let currentProcessNode = await getProcessNode(instanceHistory.step_node);
-    const nodes = await getProcessNodes(instance.process_definition, userSession.spaceId);
-    const index = _.findIndex(nodes, function (item) { return item._id === currentInstanceNode.process_node; });
-    if (currentProcessNode.when_multiple_approvers === 'first_response' || (await getPendingInstanceHistoryCount(instanceId)) < 2) {
-        let nextNode = await getNextNode(nodes, index + 1, instance.target_object.o, instance.target_object.ids[0], userSession);
-        if (nextNode) {
-            nextNodeOptions = {};
-            nextNodeOptions.node = nextNode;
-            nextNodeOptions.approve = await getProcessNodeApprover(instanceId, nextNodeOptions.node, userSession, chooseApprover, false);
+    });
+}); };
+var processInstanceWorkitemApprove = function (instanceHistoryId, userSession, comment, chooseApprover) { return __awaiter(void 0, void 0, void 0, function () {
+    var nextNodeOptions, instanceHistory, instanceId, currentInstanceNode, instance, currentProcessNode, nodes, index, _a, nextNode, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                nextNodeOptions = null;
+                return [4 /*yield*/, getInstanceHistory(instanceHistoryId)];
+            case 1:
+                instanceHistory = _c.sent();
+                instanceId = instanceHistory.process_instance;
+                return [4 /*yield*/, getCurrentInstanceNode(instanceId)];
+            case 2:
+                currentInstanceNode = _c.sent();
+                return [4 /*yield*/, getProcessInstance(instanceId)];
+            case 3:
+                instance = _c.sent();
+                return [4 /*yield*/, getProcessNode(instanceHistory.step_node)];
+            case 4:
+                currentProcessNode = _c.sent();
+                return [4 /*yield*/, getProcessNodes(instance.process_definition, userSession.spaceId)];
+            case 5:
+                nodes = _c.sent();
+                index = _.findIndex(nodes, function (item) { return item._id === currentInstanceNode.process_node; });
+                _a = currentProcessNode.when_multiple_approvers === 'first_response';
+                if (_a) return [3 /*break*/, 7];
+                return [4 /*yield*/, getPendingInstanceHistoryCount(instanceId)];
+            case 6:
+                _a = (_c.sent()) < 2;
+                _c.label = 7;
+            case 7:
+                if (!_a) return [3 /*break*/, 10];
+                return [4 /*yield*/, getNextNode(nodes, index + 1, instance.target_object.o, instance.target_object.ids[0], userSession)];
+            case 8:
+                nextNode = _c.sent();
+                if (!nextNode) return [3 /*break*/, 10];
+                nextNodeOptions = {};
+                nextNodeOptions.node = nextNode;
+                _b = nextNodeOptions;
+                return [4 /*yield*/, getProcessNodeApprover(instanceId, nextNodeOptions.node, userSession, chooseApprover, false)];
+            case 9:
+                _b.approve = _c.sent();
+                _c.label = 10;
+            case 10: return [4 /*yield*/, handleProcessInstanceWorkitem(currentInstanceNode, 'approved', instanceHistoryId, userSession, comment, nextNodeOptions)];
+            case 11:
+                _c.sent();
+                return [2 /*return*/];
         }
-    }
-    await handleProcessInstanceWorkitem(currentInstanceNode, 'approved', instanceHistoryId, userSession, comment, nextNodeOptions);
-};
+    });
+}); };
 exports.processInstanceWorkitemApprove = processInstanceWorkitemApprove;
-const processInstanceWorkitemReject = async (instanceHistoryId, userSession, comment) => {
-    let nextNodeOptions = null;
-    let instanceHistory = await getInstanceHistory(instanceHistoryId);
-    let instanceId = instanceHistory.process_instance;
-    let currentInstanceNode = await getCurrentInstanceNode(instanceId);
-    let currentProcessNode = await getProcessNode(instanceHistory.step_node);
-    if (currentProcessNode.reject_behavior === 'back_to_previous') {
-        nextNodeOptions = {};
-        nextNodeOptions.node = await getPreviousNode(instanceId, currentProcessNode, userSession);
-        nextNodeOptions.approve = await getProcessNodeApprover(instanceId, nextNodeOptions.node, userSession, null, true);
-    }
-    await handleProcessInstanceWorkitem(currentInstanceNode, 'rejected', instanceHistoryId, userSession, comment, nextNodeOptions);
-};
+var processInstanceWorkitemReject = function (instanceHistoryId, userSession, comment) { return __awaiter(void 0, void 0, void 0, function () {
+    var nextNodeOptions, instanceHistory, instanceId, currentInstanceNode, currentProcessNode, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                nextNodeOptions = null;
+                return [4 /*yield*/, getInstanceHistory(instanceHistoryId)];
+            case 1:
+                instanceHistory = _c.sent();
+                instanceId = instanceHistory.process_instance;
+                return [4 /*yield*/, getCurrentInstanceNode(instanceId)];
+            case 2:
+                currentInstanceNode = _c.sent();
+                return [4 /*yield*/, getProcessNode(instanceHistory.step_node)];
+            case 3:
+                currentProcessNode = _c.sent();
+                if (!(currentProcessNode.reject_behavior === 'back_to_previous')) return [3 /*break*/, 6];
+                nextNodeOptions = {};
+                _a = nextNodeOptions;
+                return [4 /*yield*/, getPreviousNode(instanceId, currentProcessNode, userSession)];
+            case 4:
+                _a.node = _c.sent();
+                _b = nextNodeOptions;
+                return [4 /*yield*/, getProcessNodeApprover(instanceId, nextNodeOptions.node, userSession, null, true)];
+            case 5:
+                _b.approve = _c.sent();
+                _c.label = 6;
+            case 6: return [4 /*yield*/, handleProcessInstanceWorkitem(currentInstanceNode, 'rejected', instanceHistoryId, userSession, comment, nextNodeOptions)];
+            case 7:
+                _c.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
 exports.processInstanceWorkitemReject = processInstanceWorkitemReject;
-const processInstanceWorkitemReassign = async (instanceHistoryId, userSession, comment, chooseApprover) => {
-    if (_.isEmpty(chooseApprover)) {
-        throw new objectql_1.SteedosError('process_approval_error_reassign_approver_notFind');
-    }
-    if (!_.isString(chooseApprover)) {
-        throw new objectql_1.SteedosError('process_approval_error_reassign_approver_mustBeString');
-    }
-    const history = await objectql.getObject("process_instance_history").update(instanceHistoryId, {
-        step_status: "reassigned",
-        actor: chooseApprover,
-        comments: comment
+var processInstanceWorkitemReassign = function (instanceHistoryId, userSession, comment, chooseApprover) { return __awaiter(void 0, void 0, void 0, function () {
+    var history;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (_.isEmpty(chooseApprover)) {
+                    throw new objectql_1.SteedosError('process_approval_error_reassign_approver_notFind');
+                }
+                if (!_.isString(chooseApprover)) {
+                    throw new objectql_1.SteedosError('process_approval_error_reassign_approver_mustBeString');
+                }
+                return [4 /*yield*/, objectql.getObject("process_instance_history").update(instanceHistoryId, {
+                        step_status: "reassigned",
+                        actor: chooseApprover,
+                        comments: comment
+                    })];
+            case 1:
+                history = _a.sent();
+                return [4 /*yield*/, addInstanceHistory(userSession.spaceId, history.process_instance, 'pending', null, { nodeId: history.step_node, actor: chooseApprover, originalActor: history.original_actor, submitted_by: userSession.userId }, userSession)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
     });
-    await addInstanceHistory(userSession.spaceId, history.process_instance, 'pending', null, { nodeId: history.step_node, actor: chooseApprover, originalActor: history.original_actor, submitted_by: userSession.userId }, userSession);
-};
+}); };
 exports.processInstanceWorkitemReassign = processInstanceWorkitemReassign;
-const processInstanceWorkitemRemovebyInstance = async (instanceId, userSession, comment) => {
-    const processStatus = 'removed';
-    await objectql.getObject("process_instance_history").updateMany([['process_instance', '=', instanceId], ['step_status', '=', 'pending']], { step_status: processStatus, comments: comment });
-    await handleProcessInstanceNode(instanceId, null, processStatus, null, userSession);
-};
+var processInstanceWorkitemRemovebyInstance = function (instanceId, userSession, comment) { return __awaiter(void 0, void 0, void 0, function () {
+    var processStatus;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                processStatus = 'removed';
+                return [4 /*yield*/, objectql.getObject("process_instance_history").updateMany([['process_instance', '=', instanceId], ['step_status', '=', 'pending']], { step_status: processStatus, comments: comment })];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, handleProcessInstanceNode(instanceId, null, processStatus, null, userSession)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
 exports.processInstanceWorkitemRemovebyInstance = processInstanceWorkitemRemovebyInstance;
 //# sourceMappingURL=process_manager.js.map