@pxp-nd/flow 1.0.42 → 1.0.45

package/dist/controllers/Action.js

@@ -33,7 +33,7 @@ const OriginName_1 = __importDefault(require("../entity/OriginName"));
 let Action = class Action extends core_1.Controller {
     async getFieldMapByAction(params, manager) {
         const { originName } = params;
-        const fieldMapData = await core_1.__(manager.createQueryBuilder(FieldMap_1.default, 'fm')
+        const fieldMapData = await (0, core_1.__)(manager.createQueryBuilder(FieldMap_1.default, 'fm')
             .innerJoin(OriginName_1.default, 'on', 'on.originNameId = fm.originNameId')
             .where("on.name = :n ", { n: originName })
             .getMany());
@@ -59,24 +59,24 @@ let Action = class Action extends core_1.Controller {
     }
 };
 __decorate([
-    core_1.Get(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Get)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Action.prototype, "getFieldMapByAction", null);
 __decorate([
-    core_1.Get(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(true),
-    core_1.Log(true),
+    (0, core_1.Get)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(true),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Action.prototype, "getActions", null);
 Action = __decorate([
-    core_1.Model('flow-nd/Action')
+    (0, core_1.Model)('flow-nd/Action')
 ], Action);
 exports.default = Action;

package/dist/controllers/ActionType.js

@@ -23,6 +23,6 @@ const core_1 = require("@pxp-nd/core");
 let ActionType = class ActionType extends core_1.Controller {
 };
 ActionType = __decorate([
-    core_1.Model('flow-nd/ActionType')
+    (0, core_1.Model)('flow-nd/ActionType')
 ], ActionType);
 exports.default = ActionType;

package/dist/controllers/Event.js

@@ -23,6 +23,6 @@ const core_1 = require("@pxp-nd/core");
 let Event = class Event extends core_1.Controller {
 };
 Event = __decorate([
-    core_1.Model('flow-nd/Event')
+    (0, core_1.Model)('flow-nd/Event')
 ], Event);
 exports.default = Event;

package/dist/controllers/FieldMap.js

@@ -23,6 +23,6 @@ const core_1 = require("@pxp-nd/core");
 let FieldMap = class FieldMap extends core_1.Controller {
 };
 FieldMap = __decorate([
-    core_1.Model('flow-nd/FieldMap')
+    (0, core_1.Model)('flow-nd/FieldMap')
 ], FieldMap);
 exports.default = FieldMap;

package/dist/controllers/Flow.d.ts

@@ -10,6 +10,7 @@
  * * -------------- ----------- -------------- ------------------------------------
  * 08-Jul-2021                  Jaime Rivera           Created
  * 18-Jul-2023    SP28JUL23     Mercedes Zambrana      Add deleteFlow, saveFlowName, duplicateFlow
+ * 02-Aug-2023    SP11AUG23     Mercedes Zambrana      Add validations in deleteFlow and saveFlow
  * ******************************************************************************
  */
 import { EntityManager } from 'typeorm';
@@ -24,8 +25,8 @@ declare class Flow extends Controller {
     deleteFlow(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
     saveFlowName(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
     duplicateFlow(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
+    saveFlow(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
     getFlowRender(params: Record<string, any>): Promise<unknown>;
     sortNodesByConnections(nodes: any[], connections: any[]): any[];
-    saveFlow(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
 }
 export default Flow;

package/dist/controllers/Flow.js

@@ -11,6 +11,7 @@
  * * -------------- ----------- -------------- ------------------------------------
  * 08-Jul-2021                  Jaime Rivera           Created
  * 18-Jul-2023    SP28JUL23     Mercedes Zambrana      Add deleteFlow, saveFlowName, duplicateFlow
+ * 02-Aug-2023    SP11AUG23     Mercedes Zambrana      Add validations in deleteFlow and saveFlow
  * ******************************************************************************
  */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
@@ -57,7 +58,7 @@ let Flow = class Flow extends core_1.Controller {
         return restNodes;
     }
     async copyNodeConnections(nodeId, newNodeId, newFlowId, manager) {
-        const connections = await core_1.__(NodeConnection_1.default.find({ nodeIdMaster: nodeId }));
+        const connections = await (0, core_1.__)(NodeConnection_1.default.find({ nodeIdMaster: nodeId }));
         for (let connection of connections) {
             const newNodeConnection = new NodeConnection_1.default();
             const { nodeConnectionId, nodeIdMaster, nodeIdChild, createdAt, modifiedAt, ...nodeConnectionToCopy } = connection;
@@ -65,7 +66,7 @@ let Flow = class Flow extends core_1.Controller {
             const dataNodeChild = await Node_1.default.findOne({ nodeId: connection.nodeIdChild });
             const { nodeId: newNodeIdChild } = await this.copyNode(dataNodeChild, newFlowId, manager);
             Object.assign(newNodeConnection, { ...nodeConnectionToCopy, nodeIdMaster: newNodeId, nodeIdChild: newNodeIdChild });
-            const insertNewNodeConnection = await core_1.__(manager.save(NodeConnection_1.default, newNodeConnection));
+            const insertNewNodeConnection = await (0, core_1.__)(manager.save(NodeConnection_1.default, newNodeConnection));
         }
     }
     async copyNode(node, newFlowId, manager) {
@@ -73,20 +74,20 @@ let Flow = class Flow extends core_1.Controller {
         const newNode = new Node_1.default();
         const { nodeId, flowId, createdAt, modifiedAt, actionConfigJson, ...nodeToCopy } = node;
         Object.assign(newNode, { ...nodeToCopy, flowId: newFlowId });
-        const insertNewNode = await core_1.__(manager.save(Node_1.default, newNode));
+        const insertNewNode = await (0, core_1.__)(manager.save(Node_1.default, newNode));
         // insert connection
         await this.copyNodeConnections(node.nodeId, insertNewNode.nodeId, newFlowId, manager);
         return { nodeId: insertNewNode.nodeId };
     }
     async createFlowFromFlow(params, manager) {
         // we need clone the flow selected
-        const dataFlow = await core_1.__(Flow_1.default.findOne(params.flowId));
+        const dataFlow = await (0, core_1.__)(Flow_1.default.findOne(params.flowId));
         const { flowId, createdAt, modifiedAt, nodes, ...flowToCopy } = dataFlow;
         const newFlow = new Flow_1.default();
         Object.assign(newFlow, flowToCopy);
         newFlow.name = params.name;
         newFlow.description = params.description;
-        const insertNewFlow = await core_1.__(manager.save(Flow_1.default, newFlow));
+        const insertNewFlow = await (0, core_1.__)(manager.save(Flow_1.default, newFlow));
         // create the nodes
         // get the first node "the trigger node"
         const dataNode = await Node_1.default.findOne({ where: { flowId: params.flowId }, order: { nodeId: "ASC" } });
@@ -94,27 +95,32 @@ let Flow = class Flow extends core_1.Controller {
         return { flowId: insertNewFlow.flowId };
     }
     async deleteFlow(params, manager) {
-        let dataFlow = await core_1.__(Flow_1.default.findOne(params.flowId));
+        let dataFlow = await (0, core_1.__)(Flow_1.default.findOne(params.flowId));
         if (dataFlow) {
             dataFlow.isActive = 0;
             dataFlow.enabled = 'N';
-            const updFlow = await core_1.__(manager.save(dataFlow));
+            const updFlow = await (0, core_1.__)(manager.save(dataFlow));
             if (updFlow) {
                 let flowInstance = `UPDATE twf_flow_instance SET
             is_active = 'N' WHERE flow_id = ${updFlow.flowId}`;
                 await manager.query(flowInstance);
-                let flowNode = `UPDATE twf_node SET
+                const nodesToInact = await manager.find(Node_1.default, { flowId: updFlow.flowId, isActive: true });
+                if (nodesToInact.length > 0) {
+                    let flowNode = `UPDATE twf_node SET
             is_active = 'N' WHERE flow_id = ${updFlow.flowId}`;
-                await manager.query(flowNode);
-                const nodesToInact = await manager.find(Node_1.default, { flowId: updFlow.flowId });
-                const originalNodeIds = nodesToInact.map((node) => node.nodeId);
-                const connectionsToInact = await manager.find(NodeConnection_1.default, {
-                    where: { nodeIdChild: typeorm_1.In(originalNodeIds) } // Suponiendo que originalNodeIds contiene los IDs de los nodos originales que deseas duplicar
-                });
-                const originalNodeCIds = connectionsToInact.map((node) => node.nodeConnectionId);
-                let flowNodeC = `UPDATE twf_node_connection SET
+                    await manager.query(flowNode);
+                    const nodesToInact = await manager.find(Node_1.default, { flowId: updFlow.flowId });
+                    const originalNodeIds = nodesToInact.map((node) => node.nodeId);
+                    const connectionsToInact = await manager.find(NodeConnection_1.default, {
+                        where: { nodeIdChild: (0, typeorm_1.In)(originalNodeIds) } // Suponiendo que originalNodeIds contiene los IDs de los nodos originales que deseas duplicar
+                    });
+                    const originalNodeCIds = connectionsToInact.map((node) => node.nodeConnectionId);
+                    if (originalNodeCIds.length > 0) {
+                        let flowNodeC = `UPDATE twf_node_connection SET
             is_active = 'N' WHERE node_connection_id in ( ${originalNodeCIds})`;
-                await manager.query(flowNodeC);
+                        await manager.query(flowNodeC);
+                    }
+                }
                 return { success: true };
             }
             else {
@@ -126,10 +132,10 @@ let Flow = class Flow extends core_1.Controller {
         }
     }
     async saveFlowName(params, manager) {
-        let dataFlow = await core_1.__(Flow_1.default.findOne(params.flowId));
+        let dataFlow = await (0, core_1.__)(Flow_1.default.findOne(params.flowId));
         if (dataFlow) {
             dataFlow.name = params.name;
-            const updFlow = await core_1.__(manager.save(dataFlow));
+            const updFlow = await (0, core_1.__)(manager.save(dataFlow));
             return { success: true };
         }
         else {
@@ -157,7 +163,7 @@ let Flow = class Flow extends core_1.Controller {
                 const savedNodes = await manager.save(duplicatedNodes);
                 const newNodeIds = savedNodes.map((node) => node.nodeId);
                 const connectionsToDuplicate = await manager.find(NodeConnection_1.default, {
-                    where: { nodeIdChild: typeorm_1.In(originalNodeIds) }
+                    where: { nodeIdChild: (0, typeorm_1.In)(originalNodeIds) }
                 });
                 const duplicatedConnections = newNodeIds.map((nodeId, index) => {
                     const duplicatedConnection = manager.create(NodeConnection_1.default, {
@@ -175,8 +181,106 @@ let Flow = class Flow extends core_1.Controller {
             return { success: false, "respuesta": "No Flow" };
         }
     }
+    async saveFlow(params, manager) {
+        console.log(params);
+        let nodeRefIds = params.board.columns['2-column-nodes-configured'].taskIds;
+        console.log("nodesRef:", nodeRefIds);
+        let nodes = params.board.tasks ? params.board.tasks : [];
+        console.log("nod:", nodes);
+        let masterId = null;
+        let id = null;
+        let flowId = null;
+        let taskIds = [];
+        if (nodeRefIds.length === 0) {
+            flowId = params.board.columns['2-column-nodes-configured'].flowId;
+        }
+        else {
+            for (const nodeId of nodeRefIds) {
+                // console.log ('node:',nodes[`${nodeId}`]);
+                if (nodeId != 'new') {
+                    id = parseInt(nodeId.split("-")[1]);
+                    taskIds.push(id);
+                    const connectionsToDel = await manager.find(NodeConnection_1.default, {
+                        where: { nodeIdChild: id }
+                    });
+                    if (connectionsToDel) {
+                        //console.log("hay para eliminar---->", connectionsToDel);
+                        const originalNodeCIds = connectionsToDel.map((node) => node.nodeConnectionId);
+                        //console.log("eliminando: ", originalNodeCIds);
+                        let flowNodeC = await (0, typeorm_1.getManager)().query(`DELETE
+                                                       from twf_node_connection
+                                                       WHERE node_connection_id = ${originalNodeCIds}`);
+                    }
+                }
+                //}
+            }
+        }
+        //if (nodes[`${nodeId}`]) {
+        //flowId = nodes[`${nodeId}`].flowId;
+        if (params.board.origin == 'deleteTask') {
+            console.log("aqui elimina", params.board.deleteID);
+            let nodeDelId = parseInt(params.board.deleteId.split("-")[1]);
+            console.log(nodeDelId);
+            if (nodeDelId) {
+                //If there are some nodes in node_connections after delete all records sent, to inactive node
+                let connectNoDel = await (0, typeorm_1.getManager)().query(`SELECT n.node_id
+                                                    from twf_node_connection nd
+                                                           inner join twf_node n on n.node_id = nd.node_id_child
+                                                    WHERE n.node_id = ${nodeDelId}`);
+                const currentNodesIds = connectNoDel.map((record) => record.node_id);
+                // Get nodes to remove
+                const nodesToRemove = currentNodesIds.filter((nodeId) => !taskIds.includes(nodeId.toString()));
+                // Inactive nodes
+                if (nodesToRemove.length > 0) {
+                    const delNodeConnect = await manager.delete(NodeConnection_1.default, { nodeIdChild: nodesToRemove[0] });
+                    if (delNodeConnect) {
+                        let dNode = `UPDATE twf_node
+                        SET is_active = 'N'
+                        WHERE node_id = ${nodesToRemove[0]}`;
+                        await manager.query(dNode);
+                    }
+                }
+            }
+        }
+        console.log("aqui tiene q entrar a volver a insertar");
+        //armamos las relaciones
+        if (nodeRefIds.length === 0) {
+        }
+        else {
+            for (const nodeId of nodeRefIds) {
+                // if (nodes[`${nodeId}`]) {
+                if (nodeId === 'new') {
+                    //get information about Action
+                    const newAction = await Action_1.default.findOne({ code: nodes[`${nodeId}`].action.code });
+                    const newNode = manager.create(Node_1.default, {
+                        nodeId: undefined,
+                        flowId: nodes[`${nodeId}`].flowId,
+                        isInit: 'N',
+                        actionId: newAction.actionId
+                    });
+                    const saveNode = await manager.save(newNode);
+                    id = saveNode.nodeId;
+                }
+                else {
+                    id = parseInt(nodeId.split("-")[1]);
+                }
+                //save in node and node_connection
+                const newConnection = manager.create(NodeConnection_1.default, {
+                    nodeConnectionId: undefined,
+                    nodeIdMaster: masterId,
+                    nodeIdChild: id,
+                });
+                masterId = id;
+                const savedNodes = await manager.save(newConnection);
+                // }
+            }
+            //}
+        }
+        console.log("fin de funcion");
+        return { success: true };
+    }
     async getFlowRender(params) {
-        let actions = await typeorm_1.getManager()
+        let actions = await (0, typeorm_1.getManager)()
             .createQueryBuilder(Action_1.default, "a")
             .select([
             "a.actionId",
@@ -188,16 +292,16 @@ let Flow = class Flow extends core_1.Controller {
             .innerJoin("a.actionType", "at")
             .where(`a.isActive = 1 and a.hidden = 'N'`)
             .getMany();
-        const connections = await typeorm_1.getManager()
+        const connections = await (0, typeorm_1.getManager)()
             .createQueryBuilder(NodeConnection_1.default, "nc")
             .select([
             "nc.nodeIdMaster",
             "nc.nodeIdChild",
         ])
             .innerJoin("nc.childNode", "cn")
-            .where(`cn.flowId = :flowId`, { flowId: params.flowId })
+            .where(`cn.isActive = 1 and cn.flowId = :flowId`, { flowId: params.flowId })
             .getMany();
-        const nodes = await typeorm_1.getManager()
+        const nodes = await (0, typeorm_1.getManager)()
             .createQueryBuilder(Node_1.default, "n")
             .select([
             "n.nodeId",
@@ -207,7 +311,7 @@ let Flow = class Flow extends core_1.Controller {
             "a.description",
         ])
             .innerJoin("n.action", "a")
-            .where(`n.flowId = :flowId`, { flowId: params.flowId })
+            .where(`n.isActive = 1 and n.flowId = :flowId`, { flowId: params.flowId })
             .getMany();
         let sortedNodes = this.sortNodesByConnections(nodes, connections);
         actions.forEach((item) => {
@@ -277,155 +381,71 @@ let Flow = class Flow extends core_1.Controller {
         });
         return sortedNodes;
     }
-    async saveFlow(params, manager) {
-        let nodeRefIds = params.board.columns['2-column-nodes-configured'].taskIds;
-        let nodes = params.board.tasks;
-        let masterId = null;
-        let id = null;
-        let flowId = null;
-        let taskIds = [];
-        if (nodeRefIds.length === 0) {
-            flowId = params.board.columns['2-column-nodes-configured'].flowId;
-        }
-        else {
-            for (const nodeId of nodeRefIds) {
-                // console.log ('node:',nodes[`${nodeId}`]);
-                if (nodes[`${nodeId}`]) {
-                    flowId = nodes[`${nodeId}`].flowId;
-                    if (nodeId != 'new') {
-                        id = parseInt(nodeId.split("-")[1]);
-                        taskIds.push(id);
-                        const connectionsToDel = await manager.find(NodeConnection_1.default, {
-                            where: { nodeIdChild: id }
-                        });
-                        if (connectionsToDel) {
-                            //console.log("hay para eliminar---->", connectionsToDel);
-                            const originalNodeCIds = connectionsToDel.map((node) => node.nodeConnectionId);
-                            //console.log("eliminando: ", originalNodeCIds);
-                            let flowNodeC = await typeorm_1.getManager().query(`DELETE
-                                                      from twf_node_connection
-                                                      WHERE node_connection_id = ${originalNodeCIds}`);
-                        }
-                    }
-                }
-            }
-        }
-        //If there are some nodes in node_connections after delete all records sent, to inactive node
-        let connectNoDel = await typeorm_1.getManager().query(`SELECT n.node_id
-                                                    from twf_node_connection nd 
-                                                    inner join twf_node n on n.node_id = nd.node_id_child
-                                                    WHERE n.flow_id= ${flowId}`);
-        const currentNodesIds = connectNoDel.map((record) => record.node_id);
-        // Get nodes to remove
-        const nodesToRemove = currentNodesIds.filter((nodeId) => !taskIds.includes(nodeId.toString()));
-        // Inactive nodes
-        if (nodesToRemove.length > 0) {
-            const delNodeConnect = await manager.delete(NodeConnection_1.default, { nodeIdChild: nodesToRemove[0] });
-            if (delNodeConnect) {
-                let dNode = `UPDATE twf_node SET
-            is_active = 'N' WHERE node_id = ${nodesToRemove[0]}`;
-                await manager.query(dNode);
-            }
-        }
-        if (nodeRefIds.length === 0) {
-        }
-        else {
-            for (const nodeId of nodeRefIds) {
-                if (nodes[`${nodeId}`]) {
-                    if (nodeId === 'new') {
-                        //get information about Action
-                        const newAction = await Action_1.default.findOne({ code: nodes[`${nodeId}`].action.code });
-                        const newNode = manager.create(Node_1.default, {
-                            nodeId: undefined,
-                            flowId: nodes[`${nodeId}`].flowId,
-                            isInit: 'N',
-                            actionId: newAction.actionId
-                        });
-                        const saveNode = await manager.save(newNode);
-                        id = saveNode.nodeId;
-                    }
-                    else {
-                        id = parseInt(nodeId.split("-")[1]);
-                    }
-                    //save in node and node_connection
-                    const newConnection = manager.create(NodeConnection_1.default, {
-                        nodeConnectionId: undefined,
-                        nodeIdMaster: masterId,
-                        nodeIdChild: id,
-                    });
-                    masterId = id;
-                    const savedNodes = await manager.save(newConnection);
-                    // }
-                }
-            }
-        }
-        return { success: true };
-    }
 };
 __decorate([
-    core_1.Get(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(true),
-    core_1.Log(true),
+    (0, core_1.Get)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(true),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "get", null);
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "createFlowFromFlow", null);
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "deleteFlow", null);
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "saveFlowName", null);
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "duplicateFlow", null);
 __decorate([
-    core_1.Get(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(true),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)
-], Flow.prototype, "getFlowRender", null);
+], Flow.prototype, "saveFlow", null);
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Get)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(true),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], Flow.prototype, "saveFlow", null);
+], Flow.prototype, "getFlowRender", null);
 Flow = __decorate([
-    core_1.Model('flow-nd/Flow')
+    (0, core_1.Model)('flow-nd/Flow')
 ], Flow);
 exports.default = Flow;

package/dist/controllers/FlowInstance.js

@@ -42,7 +42,7 @@ class FlowInstance extends core_1.Controller {
             }
             flag.value = 'true';
             let flowInstanceIdProcessing = -1;
-            await typeorm_1.getManager().save(flag);
+            await (0, typeorm_1.getManager)().save(flag);
             try {
                 const maxFlows = await common_1.GlobalData.findOne({ data: 'wf_max_concurrent_flows_process' });
                 const flowInstances = await FlowInstance_1.default.find({ take: (maxFlows && maxFlows.value), where: [{ status: 'pending' }], order: { flowInstanceId: "ASC" } });
@@ -63,20 +63,20 @@ class FlowInstance extends core_1.Controller {
             }
             catch (error) {
                 flag.value = 'false';
-                await typeorm_1.getManager().save(flag);
+                await (0, typeorm_1.getManager)().save(flag);
                 throw new core_1.PxpError(400, 'Error processing flow: ' + flowInstanceIdProcessing);
             }
             flag.value = 'false';
-            await typeorm_1.getManager().save(flag);
+            await (0, typeorm_1.getManager)().save(flag);
         }
         return { success: true };
     }
 }
 __decorate([
-    core_1.Post(),
-    core_1.DbSettings('Orm'),
-    core_1.ReadOnly(false),
-    core_1.Log(true),
+    (0, core_1.Post)(),
+    (0, core_1.DbSettings)('Orm'),
+    (0, core_1.ReadOnly)(false),
+    (0, core_1.Log)(true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
     __metadata("design:returntype", Promise)