@pxp-nd/flow 1.1.3 → 1.1.5

package/dist/controllers/Flow.d.ts

@@ -40,5 +40,6 @@ declare class Flow extends Controller {
     changeStatusFlow(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
     validateFlow(flowId: number, manager: EntityManager, status: string): Promise<unknown>;
     basicFlowList(params: Record<string, any>): Promise<unknown>;
+    listTemplates(params: Record<string, any>): Promise<unknown>;
 }
 export default Flow;

package/dist/controllers/Flow.js

@@ -326,29 +326,25 @@ let Flow = class Flow extends core_1.Controller {
                         }
                     }
                     if (flowIdDel.action.actionType.name === 'CHAINED FLOW') {
-                        console.log('CHAINED');
                         if (((_a = flowIdDel.action) === null || _a === void 0 ? void 0 : _a.configJsonTemplate) && flowIdDel.actionConfigJson) {
                             try {
                                 const parsedConfig = JSON.parse(flowIdDel.action.configJsonTemplate);
                                 const parsedValues = JSON.parse(flowIdDel.actionConfigJson);
-                                console.log('parsedConfig', parsedConfig);
-                                console.log('parsedValues', parsedValues);
                                 if (parsedConfig.deleteController && parsedValues.flowId) {
                                     const params = {
                                         flowId: parsedValues.flowId,
                                     };
-                                    console.log('params', params);
                                     const config = {
                                         method: "post",
-                                        url: `http://localhost:${process.env.PORT}/api/${parsedConfig.addController}`,
+                                        url: `http://localhost:${process.env.PORT}/api/${parsedConfig.deleteController}`,
                                         headers: {
                                             Authorization: "" + process.env.TOKEN_PXP_ND + "",
                                             "Content-Type": "application/json",
                                         },
                                         data: params,
                                     };
-                                    console.log('config', config);
                                     const resControllerAxios = await (0, axios_1.default)(config);
+                                    console.log('resControllerAxios.data', resControllerAxios.data);
                                 }
                             }
                             catch (error) {
@@ -877,6 +873,157 @@ let Flow = class Flow extends core_1.Controller {
         const count = totalCount.count;
         return { data, count };
     }
+    async listTemplates(params) {
+        var _a;
+        const isActive = params._isActive;
+        const type = params._type || "template"; // Filtrar solo templates
+        const vendorIds = params._vendorId ? params._vendorId.split(",").map(Number) : [];
+        const templateType = params._templateType;
+        const allowedColumns = ["name", "description"];
+        const filter = (params === null || params === void 0 ? void 0 : params.filter) ? JSON.parse(params === null || params === void 0 ? void 0 : params.filter) : null;
+        const filters = (filter === null || filter === void 0 ? void 0 : filter.items) || [];
+        const logicOperator = ((_a = filter === null || filter === void 0 ? void 0 : filter.logicOperator) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || "AND";
+        const queryBuilder = await (0, typeorm_1.getManager)()
+            .createQueryBuilder()
+            .select([
+            "f.flow_id as flowId",
+            "f.vendor_id as vendorId",
+            "f.code as code",
+            "f.name as name",
+            "f.enabled as enabled",
+            "f.type as type",
+            "f.created_by as createdBy",
+            "f.user_id_ai as userIdAi",
+            "f.user_ai as userAi",
+            "f.modified_by as modifiedBy",
+            "f.created_at as createdAt",
+            "f.modified_at as modifiedAt",
+            "f.is_active as isActive",
+            "f.description as description",
+            "f.icon as icon",
+            "f.status as status",
+            "COUNT(fi.flow_instance_id) AS numberOfInstance",
+        ])
+            .from("twf_flow", "f")
+            .leftJoin("twf_flow_instance", "fi", "fi.flow_id = f.flow_id");
+        // Aplicar filtros
+        if (isActive !== undefined) {
+            queryBuilder.where("f.is_active = :isActive", { isActive });
+        }
+        if (type) {
+            queryBuilder.andWhere("f.type = :type", { type });
+        }
+        if (templateType) {
+            queryBuilder.andWhere("f.template_type = :templateType", { templateType });
+        }
+        if (vendorIds.length > 0) {
+            queryBuilder.andWhere("f.vendor_id IN (:...vendorIds)", { vendorIds });
+        }
+        if (allowedColumns.includes(params.genericFilterFields)) {
+            if (params.genericFilterFields && params.genericFilterValue) {
+                queryBuilder.andWhere(`f.${params.genericFilterFields} LIKE :genericFilterValue`, {
+                    genericFilterValue: `%${params.genericFilterValue}%`,
+                });
+            }
+        }
+        const applyDynamicFilters = (queryBuilder, filters, logicOperator) => {
+            filters.forEach((filter, index) => {
+                const { field, operator, value } = filter;
+                const queryField = `f.${field}`;
+                const parameterName = `filterValue${index}`;
+                let condition;
+                switch (operator) {
+                    case 'contains':
+                        condition = `${queryField} LIKE :${parameterName}`;
+                        queryBuilder.setParameter(parameterName, `%${value}%`);
+                        break;
+                    case 'equals':
+                        condition = `${queryField} = :${parameterName}`;
+                        queryBuilder.setParameter(parameterName, value);
+                        break;
+                    case 'startsWith':
+                        condition = `${queryField} LIKE :${parameterName}`;
+                        queryBuilder.setParameter(parameterName, `${value}%`);
+                        break;
+                    case 'endsWith':
+                        condition = `${queryField} LIKE :${parameterName}`;
+                        queryBuilder.setParameter(parameterName, `%${value}`);
+                        break;
+                    case 'isEmpty':
+                        condition = `${queryField} IS NULL OR ${queryField} = ''`;
+                        break;
+                    case 'isNotEmpty':
+                        condition = `${queryField} IS NOT NULL AND ${queryField} <> ''`;
+                        break;
+                    case 'isAnyOf':
+                        condition = `${queryField} IN (:...${parameterName})`;
+                        queryBuilder.setParameter(parameterName, value.split(','));
+                        break;
+                    default:
+                        throw new Error(`Operator ${operator} is not supported.`);
+                }
+                if (index === 0) {
+                    queryBuilder.andWhere(condition);
+                }
+                else {
+                    queryBuilder[logicOperator === 'OR' ? 'orWhere' : 'andWhere'](condition);
+                }
+            });
+        };
+        // Aplicar filtros dinámicos
+        applyDynamicFilters(queryBuilder, filters, logicOperator);
+        queryBuilder.groupBy([
+            "f.flow_id",
+            "f.vendor_id",
+            "f.code",
+            "f.name",
+            "f.enabled",
+            "f.type",
+            "f.created_by",
+            "f.user_id_ai",
+            "f.user_ai",
+            "f.modified_by",
+            "f.created_at",
+            "f.modified_at",
+            "f.is_active",
+            "f.description",
+            "f.icon",
+            "f.status",
+        ]);
+        // Ordenamiento y paginación
+        queryBuilder.orderBy(`f.${params.sort || "flowId"}`, params.dir || "ASC");
+        queryBuilder.limit(params.limit || 50).offset(params.start || 0);
+        // Obtener los datos
+        const data = await queryBuilder.getRawMany();
+        // Query para contar registros
+        const countQuery = await (0, typeorm_1.getManager)()
+            .createQueryBuilder()
+            .select("COUNT(f.flow_id)", "count")
+            .from("twf_flow", "f");
+        if (isActive !== undefined) {
+            countQuery.where("f.is_active = :isActive", { isActive });
+        }
+        if (type) {
+            countQuery.andWhere("f.type = :type", { type });
+        }
+        if (templateType) {
+            countQuery.andWhere("f.template_type = :templateType", { templateType });
+        }
+        if (vendorIds.length > 0) {
+            countQuery.andWhere("f.vendor_id IN (:...vendorIds)", { vendorIds });
+        }
+        if (allowedColumns.includes(params.genericFilterFields)) {
+            if (params.genericFilterFields && params.genericFilterValue) {
+                countQuery.andWhere(`f.${params.genericFilterFields} LIKE :genericFilterValue`, {
+                    genericFilterValue: `%${params.genericFilterValue}%`,
+                });
+            }
+        }
+        // Aplicar filtros dinámicos en el conteo
+        applyDynamicFilters(countQuery, filters, logicOperator);
+        const totalCount = await countQuery.getRawOne();
+        return { data, count: totalCount.count };
+    }
 };
 __decorate([
     (0, core_1.Get)(),
@@ -978,6 +1125,15 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], Flow.prototype, "basicFlowList", null);
+__decorate([
+    (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, "listTemplates", null);
 Flow = __decorate([
     (0, core_1.Model)('flow-nd/Flow')
 ], Flow);

package/dist/entity/Flow.d.ts

@@ -17,5 +17,4 @@ export default class Flow extends PxpEntity {
     modifiedBy: string;
     templateType: string;
     flowType: string;
-    isActiveFlow: number;
 }

package/dist/entity/Flow.js

@@ -25,8 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * 04-Sep-2023      SP08SEP23       Rensi Arteaga       add modified at and by
  * 06-Dec-2024		8001237262		Mercedes Zambrana	add flow_type
  * 31-Jan-2025		8035304698		Mercedes Zambrana	Change code to string
- * 11-Feb-2025		8353091310		Merecedes Zambrana	Add isActive
- ****************************************************************************/
+  ****************************************************************************/
 const typeorm_1 = require("typeorm");
 const FlowInstance_1 = __importDefault(require("./FlowInstance"));
 const Node_1 = __importDefault(require("./Node"));
@@ -93,10 +92,6 @@ __decorate([
     (0, typeorm_1.Column)({ name: 'flow_type', type: 'varchar', nullable: true, length: 100 }),
     __metadata("design:type", String)
 ], Flow.prototype, "flowType", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ name: 'is_active', type: 'int', nullable: false }),
-    __metadata("design:type", Number)
-], Flow.prototype, "isActiveFlow", void 0);
 Flow = __decorate([
     (0, typeorm_1.Entity)({ name: 'twf_flow' })
 ], Flow);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pxp-nd/flow",
-  "version": "1.1.03",
+  "version": "1.1.05",
   "description": "Workflow module for pxp-nd framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",