rez_core 5.0.89 → 5.0.91

package/src/module/workflow/service/workflow.service.ts

@@ -20,7 +20,6 @@ export class WorkflowService extends EntityServiceImpl {
     private readonly listMasterService: ListMasterService,
     @Inject('StageGroupService')
     private readonly stateGroupService: StageGroupService,
-    private readonly stageGroupRepository: StageGroupRepository,
   ) {
     super();
   }
@@ -149,10 +148,15 @@ export class WorkflowService extends EntityServiceImpl {
       );
     }
 
-    const getAllStageGroup = await this.dataSource.query(
-      `SELECT id FROM frm_wf_stage_group WHERE workflow_id = $1 AND level_id = $2 AND level_type = $3`,
-      [id, loggedInUser.level_id, loggedInUser.level_type],
-    );
+    const stageGroupRepo = this.reflectionHelper.getRepoService('StageGroup');
+
+    const getAllStageGroup = await stageGroupRepo.find({
+      where: {
+        workflow_id: id,
+        level_id: loggedInUser.level_id,
+        level_type:loggedInUser.level_type
+      }
+    });
 
     if (getAllStageGroup.length > 0) {
       for (const stageGroup of getAllStageGroup) {

package/src/module/workflow-schedule/processors/schedule.processor.ts

@@ -1,5 +1,11 @@
-import { Process, Processor, OnQueueActive, OnQueueCompleted, OnQueueFailed } from '@nestjs/bull';
-import { Logger, Inject, forwardRef } from '@nestjs/common';
+import {
+  Process,
+  Processor,
+  OnQueueActive,
+  OnQueueCompleted,
+  OnQueueFailed,
+} from '@nestjs/bull';
+import { Logger, Inject } from '@nestjs/common';
 import { Job } from 'bull';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, DataSource } from 'typeorm';
@@ -14,13 +20,13 @@ import {
   EXECUTION_STATUS_FAILED,
   EXECUTION_STATUS_PARTIAL,
   DEFAULT_BATCH_SIZE,
-  ACTION_TYPE_SEND_EMAIL,
-  ACTION_TYPE_UPDATE_RECORDS,
-  ACTION_TYPE_CREATE_TASK,
-  ACTION_TYPE_SEND_NOTIFICATION,
 } from '../constants/schedule.constants';
-import { ScheduleJobData, BatchProcessingResult } from '../interfaces/schedule-job-data.interface';
+import {
+  ScheduleJobData,
+  BatchProcessingResult,
+} from '../interfaces/schedule-job-data.interface';
 import { ScheduleHandlerService } from 'src/module/workflow-automation/service/schedule-handler.service';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 
 /**
  * Schedule Processor
@@ -35,17 +41,19 @@ export class ScheduleProcessor {
     private readonly scheduledWorkflowRepository: Repository<ScheduledWorkflow>,
     @InjectRepository(WorkflowExecutionLog)
     private readonly executionLogRepository: Repository<WorkflowExecutionLog>,
-    private readonly dataSource: DataSource,
-@Inject('ScheduleHandlerService')
-  private readonly scheduleHandlerService: ScheduleHandlerService,
+    @Inject('ScheduleHandlerService')
+    private readonly scheduleHandlerService: ScheduleHandlerService,
+    private readonly reflectionHelper: ReflectionHelper,
+    private readonly dataSource: DataSource
   ) {}
 
   /**
    * Main job processor for scheduled workflow execution
    */
   @Process(EXECUTE_SCHEDULED_WORKFLOW_JOB)
- async handleScheduledWorkflowExecution(job: Job<ScheduleJobData>) {
-    const { scheduleId, workflowId, organizationId, triggeredBy, createdBy } = job.data;
+  async handleScheduledWorkflowExecution(job: Job<ScheduleJobData>) {
+    const { scheduleId, workflowId, organizationId, triggeredBy, createdBy } =
+      job.data;
 
     this.logger.log(
       `🚀 [handleScheduledWorkflowExecution] Invoked for scheduleId=${scheduleId}, workflowId=${workflowId}`,
@@ -74,7 +82,9 @@ export class ScheduleProcessor {
       executionLog.started_at = new Date();
       await this.executionLogRepository.save(executionLog);
 
-      this.logger.log(`🏃 Workflow execution started for scheduleId=${scheduleId}`);
+      this.logger.log(
+        `🏃 Workflow execution started for scheduleId=${scheduleId}`,
+      );
 
       // Get scheduled workflow details
       const schedule = await this.scheduledWorkflowRepository.findOne({
@@ -85,7 +95,9 @@ export class ScheduleProcessor {
         throw new Error(`Scheduled workflow not found: ${scheduleId}`);
       }
 
-      this.logger.debug(`📋 Loaded schedule from DB: ${JSON.stringify(schedule)}`);
+      this.logger.debug(
+        `📋 Loaded schedule from DB: ${JSON.stringify(schedule)}`,
+      );
 
       // Execute workflow actions
       this.logger.log(`⚙️ Executing workflow actions...`);
@@ -98,10 +110,11 @@ export class ScheduleProcessor {
         result.failedRecords > 0 && result.successfulRecords > 0
           ? EXECUTION_STATUS_PARTIAL
           : result.failedRecords > 0
-          ? EXECUTION_STATUS_FAILED
-          : EXECUTION_STATUS_COMPLETED;
+            ? EXECUTION_STATUS_FAILED
+            : EXECUTION_STATUS_COMPLETED;
       executionLog.completed_at = completedAt;
-      executionLog.duration_ms = completedAt.getTime() - executionLog.started_at.getTime();
+      executionLog.duration_ms =
+        completedAt.getTime() - executionLog.started_at.getTime();
       executionLog.total_records = result.totalRecords;
       executionLog.successful_records = result.successfulRecords;
       executionLog.failed_records = result.failedRecords;
@@ -136,7 +149,8 @@ export class ScheduleProcessor {
       executionLog.execution_status = EXECUTION_STATUS_FAILED;
       executionLog.completed_at = new Date();
       executionLog.duration_ms = executionLog.started_at
-        ? executionLog.completed_at.getTime() - executionLog.started_at.getTime()
+        ? executionLog.completed_at.getTime() -
+          executionLog.started_at.getTime()
         : 0;
       executionLog.error_message = error.message;
       executionLog.error_stack = error.stack;
@@ -162,11 +176,11 @@ export class ScheduleProcessor {
       errors: [],
     };
 
-    const resultData: any = await this.scheduleHandlerService.handleScheduledWorkflow(
-      jobData.workflowId,
-      jobData,
-    );
-
+    const resultData: any =
+      await this.scheduleHandlerService.handleScheduledWorkflow(
+        jobData.workflowId,
+        jobData,
+      );
 
     if (!schedule.actions || schedule.actions.length === 0) {
       this.logger.warn(`No actions defined for schedule: ${schedule.id}`);
@@ -199,42 +213,44 @@ export class ScheduleProcessor {
   /**
    * Execute a single workflow action
    */
- private async executeAction(action: any, jobData: ScheduleJobData) {
-  this.logger.log(`🚀 Executing scheduled action: ${action.actionType}`);
-
-  try {
-    // We’ll assume jobData contains workflowId and user info
-    const { workflowId, loggedInUser } = jobData;
+  private async executeAction(action: any, jobData: ScheduleJobData) {
+    this.logger.log(`🚀 Executing scheduled action: ${action.actionType}`);
 
-    // 🧠 Call your handler that performs filtering and workflow execution
-    const result: any = await this.scheduleHandlerService.handleScheduledWorkflow(
-      workflowId,
-      loggedInUser,
-    );
+    try {
+      // We’ll assume jobData contains workflowId and user info
+      const { workflowId, loggedInUser } = jobData;
+
+      // 🧠 Call your handler that performs filtering and workflow execution
+      const result: any =
+        await this.scheduleHandlerService.handleScheduledWorkflow(
+          workflowId,
+          loggedInUser,
+        );
 
-    this.logger.log(`✅ Scheduled workflow ${workflowId} executed successfully`);
-    return {
-      totalRecords: result?.length || 0,
-      processedRecords: result?.length || 0,
-      successfulRecords: result?.length || 0,
-      failedRecords: 0,
-      errors: [],
-    };
-  } catch (error) {
-    this.logger.error(
-      `🔥 Error executing scheduled workflow action: ${error.message}`,
-      error.stack,
-    );
-    return {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 1,
-      errors: [{ error: error.message }],
-    };
+      this.logger.log(
+        `✅ Scheduled workflow ${workflowId} executed successfully`,
+      );
+      return {
+        totalRecords: result?.length || 0,
+        processedRecords: result?.length || 0,
+        successfulRecords: result?.length || 0,
+        failedRecords: 0,
+        errors: [],
+      };
+    } catch (error) {
+      this.logger.error(
+        `🔥 Error executing scheduled workflow action: ${error.message}`,
+        error.stack,
+      );
+      return {
+        totalRecords: 0,
+        processedRecords: 0,
+        successfulRecords: 0,
+        failedRecords: 1,
+        errors: [{ error: error.message }],
+      };
+    }
   }
-}
-
 
   /**
    * Execute send email action
@@ -337,7 +353,9 @@ export class ScheduleProcessor {
             const values = Object.values(updateFields);
 
             if (updateValues.length > 0) {
-              const tableName = this.getTableNameForEntityType(action.targetEntityType);
+              const tableName = this.getTableNameForEntityType(
+                action.targetEntityType,
+              );
               await queryRunner.query(
                 `UPDATE ${tableName} SET ${updateValues.join(', ')} WHERE id = ?`,
                 [...values, record.id],
@@ -391,34 +409,38 @@ export class ScheduleProcessor {
 
       result.totalRecords = records.length;
 
+      // Task repo (cr_wf_task)
+      const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
+
       // Process in batches
       const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
 
       for (const batch of batches) {
         for (const record of batch) {
           try {
-            // Create task for each record
-            await this.dataSource.query(
-              `INSERT INTO cr_wf_task (name, description, status, mapped_entity_id, mapped_entity_type,
-                organization_id, enterprise_id, created_by, created_date, entity_type)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, NOW(), 'WFTK')`,
-              [
-                action.actionConfig.taskName || 'Scheduled Task',
-                action.actionConfig.taskDescription || '',
-                'PENDING',
-                record.id,
-                action.targetEntityType,
-                jobData.organizationId,
-                jobData.enterpriseId,
-                jobData.createdBy,
-              ],
-            );
+            // Build task object
+            const task = {
+              name: action.actionConfig.taskName || 'Scheduled Task',
+              description: action.actionConfig.taskDescription || '',
+              status: 'PENDING',
+              mapped_entity_id: record.id,
+              mapped_entity_type: action.targetEntityType,
+              organization_id: jobData.organizationId,
+              enterprise_id: jobData.enterpriseId,
+              created_by: jobData.createdBy,
+              created_date: new Date(), // NOW()
+              entity_type: 'WFTK',
+            };
+
+            // Insert using TypeORM repository
+            await taskRepo.insert(task);
 
             result.processedRecords += 1;
             result.successfulRecords += 1;
           } catch (error) {
             result.processedRecords += 1;
             result.failedRecords += 1;
+
             result.errors.push({
               recordId: record.id,
               error: error.message,
@@ -458,32 +480,41 @@ export class ScheduleProcessor {
 
       result.totalRecords = records.length;
 
+      // Prepare repo
+      const notificationRepo = this.reflectionHelper.getRepoService(
+        'NotificationData', // cr_notification repo
+      );
+
       // Process in batches
       const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
 
       for (const batch of batches) {
         for (const record of batch) {
           try {
-            // Create notification
-            await this.dataSource.query(
-              `INSERT INTO cr_notification (user_id, event_type, message, mapped_entity_id,
-                mapped_entity_type, is_read, organization_id, created_date, entity_type, status)
-               VALUES (?, ?, ?, ?, ?, 0, ?, NOW(), 'NOTF', 'ACTIVE')`,
-              [
-                record.user_id || jobData.createdBy,
-                action.actionConfig.eventType || 'WORKFLOW_SCHEDULED',
+            // Build notification object
+            const notification = {
+              user_id: record.user_id || jobData.createdBy,
+              event_type: action.actionConfig.eventType || 'WORKFLOW_SCHEDULED',
+              message:
                 action.actionConfig.message || 'Scheduled workflow executed',
-                record.id,
-                action.targetEntityType,
-                jobData.organizationId,
-              ],
-            );
+              mapped_entity_id: record.id,
+              mapped_entity_type: action.targetEntityType,
+              is_read: 0,
+              organization_id: jobData.organizationId,
+              created_date: new Date(), // NOW()
+              entity_type: 'NOTF',
+              status: 'ACTIVE',
+            };
+
+            // Insert using TypeORM (replaces raw SQL)
+            await notificationRepo.insert(notification);
 
             result.processedRecords += 1;
             result.successfulRecords += 1;
           } catch (error) {
             result.processedRecords += 1;
             result.failedRecords += 1;
+
             result.errors.push({
               recordId: record.id,
               error: error.message,
@@ -506,22 +537,27 @@ export class ScheduleProcessor {
     filterCriteria: any,
     jobData: ScheduleJobData,
   ): Promise<any[]> {
-    const tableName = this.getTableNameForEntityType(entityType);
+    // Get repository dynamically based on entityType
+    const repo = this.reflectionHelper.getRepoService(entityType);
 
-    // Build WHERE clause from filter criteria
-    let whereClause = `organization_id = ${jobData.organizationId}`;
-    const params: any[] = [];
+    // Start QueryBuilder
+    const qb = repo.createQueryBuilder('e');
 
+    // Mandatory organization filter
+    qb.where('e.organization_id = :orgId', {
+      orgId: jobData.organizationId,
+    });
+
+    // Apply additional filters
     if (filterCriteria && Object.keys(filterCriteria).length > 0) {
-      Object.keys(filterCriteria).forEach((key) => {
-        whereClause += ` AND ${key} = ?`;
-        params.push(filterCriteria[key]);
-      });
+      for (const key of Object.keys(filterCriteria)) {
+        qb.andWhere(`e.${key} = :${key}`, {
+          [key]: filterCriteria[key],
+        });
+      }
     }
 
-    const query = `SELECT * FROM ${tableName} WHERE ${whereClause}`;
-    const records = await this.dataSource.query(query, params);
-
+    const records = await qb.getMany();
     return records;
   }
 

package/src/module/workflow-schedule/service/workflow-schedule.service.ts

@@ -1,6 +1,6 @@
-import { Injectable, Logger, NotFoundException, BadRequestException } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, DataSource, Between, In } from 'typeorm';
+import { Between, In, Repository } from 'typeorm';
 import { InjectQueue } from '@nestjs/bull';
 import { Queue } from 'bull';
 import * as cronParser from 'cron-parser';
@@ -12,15 +12,15 @@ import { UpdateScheduleDto } from '../dto/update-schedule.dto';
 import { GetExecutionLogsDto } from '../dto/get-execution-logs.dto';
 import { UserData } from '../../user/entity/user.entity';
 import {
-  WORKFLOW_SCHEDULE_QUEUE,
-  EXECUTE_SCHEDULED_WORKFLOW_JOB,
-  SCHEDULE_STATUS_ACTIVE,
-  SCHEDULE_STATUS_PAUSED,
-  SCHEDULE_STATUS_INACTIVE,
+  DEFAULT_BACKOFF_MULTIPLIER,
   DEFAULT_MAX_RETRIES,
   DEFAULT_RETRY_DELAY,
-  DEFAULT_BACKOFF_MULTIPLIER,
   DEFAULT_TIMEZONE,
+  EXECUTE_SCHEDULED_WORKFLOW_JOB,
+  SCHEDULE_STATUS_ACTIVE,
+  SCHEDULE_STATUS_INACTIVE,
+  SCHEDULE_STATUS_PAUSED,
+  WORKFLOW_SCHEDULE_QUEUE,
 } from '../constants/schedule.constants';
 import { ScheduleJobData } from '../interfaces/schedule-job-data.interface';
 
@@ -37,10 +37,10 @@ export class WorkflowScheduleService {
     private readonly scheduledWorkflowRepository: Repository<ScheduledWorkflow>,
     @InjectRepository(WorkflowExecutionLog)
     private readonly executionLogRepository: Repository<WorkflowExecutionLog>,
-    @InjectQueue(WORKFLOW_SCHEDULE_QUEUE) 
+    @InjectQueue(WORKFLOW_SCHEDULE_QUEUE)
     private readonly scheduleQueue: Queue<ScheduleJobData>,
-    private readonly dataSource: DataSource,
-  ) {}
+  ) {
+  }
 
   /**
    * 1. Create a new scheduled workflow
@@ -484,21 +484,19 @@ export class WorkflowScheduleService {
   async getExecutionStats(scheduleId: number, loggedInUser: UserData): Promise<any> {
     const schedule = await this.getScheduleById(scheduleId, loggedInUser);
 
-    const stats = await this.dataSource.query(
-      `SELECT
-        COUNT(*) as total_executions,
-        SUM(CASE WHEN execution_status = 'COMPLETED' THEN 1 ELSE 0 END) as successful_executions,
-        SUM(CASE WHEN execution_status = 'FAILED' THEN 1 ELSE 0 END) as failed_executions,
-        SUM(CASE WHEN execution_status = 'PENDING' THEN 1 ELSE 0 END) as pending_executions,
-        SUM(CASE WHEN execution_status = 'RUNNING' THEN 1 ELSE 0 END) as running_executions,
-        AVG(duration_ms) as average_duration_ms,
-        SUM(total_records) as total_records_processed
-       FROM cr_wf_execution_log
-       WHERE schedule_id = ?`,
-      [scheduleId],
-    );
-
-    const result = stats[0];
+    const result = await this.executionLogRepository
+      .createQueryBuilder('log')
+      .select([
+        'COUNT(*) AS total_executions',
+        'SUM(CASE WHEN log.execution_status = \'COMPLETED\' THEN 1 ELSE 0 END) AS successful_executions',
+        'SUM(CASE WHEN log.execution_status = \'FAILED\' THEN 1 ELSE 0 END) AS failed_executions',
+        'SUM(CASE WHEN log.execution_status = \'PENDING\' THEN 1 ELSE 0 END) AS pending_executions',
+        'SUM(CASE WHEN log.execution_status = \'RUNNING\' THEN 1 ELSE 0 END) AS running_executions',
+        'AVG(log.duration_ms) AS average_duration_ms',
+        'SUM(log.total_records) AS total_records_processed',
+      ])
+      .where('log.schedule_id = :scheduleId', { scheduleId })
+      .getRawOne();
     const successRate =
       result.total_executions > 0
         ? (result.successful_executions / result.total_executions) * 100