@pxp-nd/flow 1.1.4 → 1.1.6

package/dist/controllers/Flow.d.ts

@@ -18,6 +18,7 @@
  * 16-Sep-2023    SP22SEP23     Mercedes Zambrana       Change GET to POST in insertEventFlow
  * 28-Sep-2023    SP06OCT23     Mercedes Zambrana      Add Validation when change off status (validateFlow, deleteflow, saveFlow, saveflowName)
  * 07-Feb-2025    8353064698    Mercedes Zambrana      Add validation for opt in page when flow si funnel change
+ * 18-Feb-2025    8501163144    Mercedes Zambrana      Add publish filter
  * ******************************************************************************
  */
 import { EntityManager } from 'typeorm';
@@ -40,5 +41,8 @@ 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>;
+    changePublishTemplate(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
+    validatePublishTemplate(flowId: number, manager: EntityManager, publish: string): Promise<unknown>;
 }
 export default Flow;

package/dist/controllers/Flow.js

@@ -19,6 +19,7 @@
  * 16-Sep-2023    SP22SEP23     Mercedes Zambrana       Change GET to POST in insertEventFlow
  * 28-Sep-2023    SP06OCT23     Mercedes Zambrana      Add Validation when change off status (validateFlow, deleteflow, saveFlow, saveflowName)
  * 07-Feb-2025    8353064698    Mercedes Zambrana      Add validation for opt in page when flow si funnel change
+ * 18-Feb-2025    8501163144    Mercedes Zambrana      Add publish filter
  * ******************************************************************************
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -873,6 +874,199 @@ 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 publish = params._publish;
+        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 (publish !== undefined) {
+            queryBuilder.where("f.publish = :publish", { publish });
+        }
+        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 (publish !== undefined) {
+            countQuery.where("f.publish = :publish", { publish });
+        }
+        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 };
+    }
+    async changePublishTemplate(params, manager) {
+        let dataFlow = await (0, core_1.__)(Flow_1.default.findOne(params.flowId));
+        if (dataFlow) {
+            console.log("publish es:::::::::", dataFlow.publish);
+            if (dataFlow.publish === 'N') {
+                await this.validatePublishTemplate(params.flowId, manager, 'Y');
+                //change to active
+                dataFlow.publish = 'Y';
+            }
+            else {
+                await this.validatePublishTemplate(params.flowId, manager, 'N');
+                dataFlow.publish = 'N';
+            }
+            dataFlow.modifiedAt = new Date();
+            dataFlow.modifiedBy = this.user.username;
+            const updFlow = await (0, core_1.__)(manager.save(dataFlow));
+            return { success: true };
+        }
+        else {
+            return { success: false };
+        }
+    }
+    async validatePublishTemplate(flowId, manager, publish) {
+        if (publish == 'Y') {
+            const nodes = await Node_1.default.find({ flowId, isActive: true });
+            let res = '';
+            if (nodes.length < 2) {
+                throw new core_1.PxpError(400, 'Your template must have at least 2 steps. Please finish configuring it before publish');
+            }
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
 };
 __decorate([
     (0, core_1.Get)(),
@@ -974,6 +1168,24 @@ __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);
+__decorate([
+    (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, "changePublishTemplate", null);
 Flow = __decorate([
     (0, core_1.Model)('flow-nd/Flow')
 ], Flow);

package/dist/entity/Flow.d.ts

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

package/dist/entity/Flow.js

@@ -25,6 +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
+ * 18-Feb-2025		8501163144		Mercedes Zambrana 	Add publish column
   ****************************************************************************/
 const typeorm_1 = require("typeorm");
 const FlowInstance_1 = __importDefault(require("./FlowInstance"));
@@ -92,6 +93,10 @@ __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: 'publish', type: 'varchar', nullable: false, length: 1 }),
+    __metadata("design:type", String)
+], Flow.prototype, "publish", 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.04",
+  "version": "1.1.06",
   "description": "Workflow module for pxp-nd framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",