rez_core 4.0.197 → 4.0.198

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

@@ -1,584 +1,584 @@
-import { Process, Processor, OnQueueActive, OnQueueCompleted, OnQueueFailed } from '@nestjs/bull';
-import { Logger, Inject, forwardRef } from '@nestjs/common';
-import { Job } from 'bull';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, DataSource } from 'typeorm';
-import { ScheduledWorkflow } from '../entities/scheduled-workflow.entity';
-import { WorkflowExecutionLog } from '../entities/workflow-execution-log.entity';
-import {
-  WORKFLOW_SCHEDULE_QUEUE,
-  EXECUTE_SCHEDULED_WORKFLOW_JOB,
-  EXECUTION_STATUS_PENDING,
-  EXECUTION_STATUS_RUNNING,
-  EXECUTION_STATUS_COMPLETED,
-  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 { ScheduleHandlerService } from 'src/module/workflow-automation/service/schedule-handler.service';
-
-/**
- * Schedule Processor
- * Processes scheduled workflow execution jobs from Bull queue
- */
-@Processor(WORKFLOW_SCHEDULE_QUEUE)
-export class ScheduleProcessor {
-  private readonly logger = new Logger(ScheduleProcessor.name);
-
-  constructor(
-    @InjectRepository(ScheduledWorkflow)
-    private readonly scheduledWorkflowRepository: Repository<ScheduledWorkflow>,
-    @InjectRepository(WorkflowExecutionLog)
-    private readonly executionLogRepository: Repository<WorkflowExecutionLog>,
-    private readonly dataSource: DataSource,
-@Inject('ScheduleHandlerService')
-  private readonly scheduleHandlerService: ScheduleHandlerService,
-  ) {}
-
-  /**
-   * 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;
-
-    this.logger.log(
-      `🚀 [handleScheduledWorkflowExecution] Invoked for scheduleId=${scheduleId}, workflowId=${workflowId}`,
-    );
-
-    // Create execution log entry
-    const executionLog = this.executionLogRepository.create({
-      schedule_id: scheduleId,
-      workflow_id: workflowId,
-      job_id: job.id.toString(),
-      execution_status: EXECUTION_STATUS_PENDING,
-      triggered_by: triggeredBy,
-      triggered_by_user_id: triggeredBy === 'MANUAL' ? createdBy : null,
-      organization_id: organizationId,
-      enterprise_id: job.data.enterpriseId,
-      created_by: createdBy,
-      entity_type: 'WFEL',
-    });
-
-    this.logger.debug(`🧾 Creating execution log for jobId=${job.id}`);
-    await this.executionLogRepository.save(executionLog);
-
-    try {
-      // Update status to running
-      executionLog.execution_status = EXECUTION_STATUS_RUNNING;
-      executionLog.started_at = new Date();
-      await this.executionLogRepository.save(executionLog);
-
-      this.logger.log(`🏃 Workflow execution started for scheduleId=${scheduleId}`);
-
-      // Get scheduled workflow details
-      const schedule = await this.scheduledWorkflowRepository.findOne({
-        where: { id: scheduleId },
-      });
-
-      if (!schedule) {
-        throw new Error(`Scheduled workflow not found: ${scheduleId}`);
-      }
-
-      this.logger.debug(`📋 Loaded schedule from DB: ${JSON.stringify(schedule)}`);
-
-      // Execute workflow actions
-      this.logger.log(`⚙️ Executing workflow actions...`);
-      const result = await this.executeWorkflowActions(schedule, job.data);
-      this.logger.debug(`🧮 Execution result: ${JSON.stringify(result)}`);
-
-      // Update execution log with results
-      const completedAt = new Date();
-      executionLog.execution_status =
-        result.failedRecords > 0 && result.successfulRecords > 0
-          ? EXECUTION_STATUS_PARTIAL
-          : result.failedRecords > 0
-          ? EXECUTION_STATUS_FAILED
-          : EXECUTION_STATUS_COMPLETED;
-      executionLog.completed_at = completedAt;
-      executionLog.duration_ms = completedAt.getTime() - executionLog.started_at.getTime();
-      executionLog.total_records = result.totalRecords;
-      executionLog.successful_records = result.successfulRecords;
-      executionLog.failed_records = result.failedRecords;
-      executionLog.execution_details = {
-        batchesProcessed: Math.ceil(result.totalRecords / DEFAULT_BATCH_SIZE),
-        errors: result.errors,
-      };
-
-      await this.executionLogRepository.save(executionLog);
-
-      // Update schedule execution count and last execution time
-      schedule.execution_count += 1;
-      schedule.last_execution_at = completedAt;
-      await this.scheduledWorkflowRepository.save(schedule);
-
-      this.logger.log(
-        `✅ Workflow execution completed: scheduleId=${scheduleId}, status=${executionLog.execution_status}, processed=${result.totalRecords}`,
-      );
-
-      return {
-        success: true,
-        executionLogId: executionLog.id,
-        result,
-      };
-    } catch (error) {
-      this.logger.error(
-        `🔥 Workflow execution failed: scheduleId=${scheduleId}, error=${error.message}`,
-        error.stack,
-      );
-
-      // Update execution log with error
-      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()
-        : 0;
-      executionLog.error_message = error.message;
-      executionLog.error_stack = error.stack;
-
-      await this.executionLogRepository.save(executionLog);
-
-      throw error;
-    }
-  }
-
-  /**
-   * Execute all actions defined in the workflow
-   */
-  private async executeWorkflowActions(
-    schedule: ScheduledWorkflow,
-    jobData: ScheduleJobData,
-  ): Promise<BatchProcessingResult> {
-    const result: BatchProcessingResult = {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 0,
-      errors: [],
-    };
-
-    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}`);
-      return result;
-    }
-
-    // Execute each action sequentially
-    for (const action of schedule.actions) {
-      try {
-        const actionResult = await this.executeAction(action, jobData);
-        result.totalRecords += actionResult.totalRecords;
-        result.processedRecords += actionResult.processedRecords;
-        result.successfulRecords += actionResult.successfulRecords;
-        result.failedRecords += actionResult.failedRecords;
-        result.errors.push(...actionResult.errors);
-      } catch (error) {
-        this.logger.error(
-          `Action execution failed: actionType=${action.actionType}, error=${error.message}`,
-        );
-        result.failedRecords += 1;
-        result.errors.push({
-          error: `Action ${action.actionType} failed: ${error.message}`,
-        });
-      }
-    }
-
-    return resultData;
-  }
-
-  /**
-   * 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;
-
-    // 🧠 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 }],
-    };
-  }
-}
-
-
-  /**
-   * Execute send email action
-   */
-  private async executeSendEmailAction(
-    action: any,
-    jobData: ScheduleJobData,
-  ): Promise<BatchProcessingResult> {
-    const result: BatchProcessingResult = {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 0,
-      errors: [],
-    };
-
-    try {
-      // Get target records based on filter criteria
-      const records = await this.getTargetRecords(
-        action.targetEntityType,
-        action.filterCriteria,
-        jobData,
-      );
-
-      result.totalRecords = records.length;
-
-      // Process in batches
-      const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
-
-      for (const batch of batches) {
-        for (const record of batch) {
-          try {
-            // TODO: Integrate with email service
-            // await this.emailService.sendEmail({
-            //   to: record.email,
-            //   subject: action.actionConfig.subject,
-            //   template: action.actionConfig.template,
-            //   data: record,
-            // });
-
-            result.processedRecords += 1;
-            result.successfulRecords += 1;
-          } catch (error) {
-            result.processedRecords += 1;
-            result.failedRecords += 1;
-            result.errors.push({
-              recordId: record.id,
-              error: error.message,
-            });
-          }
-        }
-      }
-    } catch (error) {
-      throw new Error(`Send email action failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Execute update records action
-   */
-  private async executeUpdateRecordsAction(
-    action: any,
-    jobData: ScheduleJobData,
-  ): Promise<BatchProcessingResult> {
-    const result: BatchProcessingResult = {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 0,
-      errors: [],
-    };
-
-    try {
-      // Get target records
-      const records = await this.getTargetRecords(
-        action.targetEntityType,
-        action.filterCriteria,
-        jobData,
-      );
-
-      result.totalRecords = records.length;
-
-      // Process in batches
-      const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
-
-      for (const batch of batches) {
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-
-        try {
-          for (const record of batch) {
-            // Build update query based on action config
-            const updateFields = action.actionConfig.updateFields || {};
-            const updateValues = Object.keys(updateFields).map((key) => {
-              return `${key} = ?`;
-            });
-            const values = Object.values(updateFields);
-
-            if (updateValues.length > 0) {
-              const tableName = this.getTableNameForEntityType(action.targetEntityType);
-              await queryRunner.query(
-                `UPDATE ${tableName} SET ${updateValues.join(', ')} WHERE id = ?`,
-                [...values, record.id],
-              );
-            }
-
-            result.processedRecords += 1;
-            result.successfulRecords += 1;
-          }
-
-          await queryRunner.commitTransaction();
-        } catch (error) {
-          await queryRunner.rollbackTransaction();
-          result.failedRecords += batch.length;
-          result.errors.push({
-            error: `Batch update failed: ${error.message}`,
-          });
-        } finally {
-          await queryRunner.release();
-        }
-      }
-    } catch (error) {
-      throw new Error(`Update records action failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Execute create task action
-   */
-  private async executeCreateTaskAction(
-    action: any,
-    jobData: ScheduleJobData,
-  ): Promise<BatchProcessingResult> {
-    const result: BatchProcessingResult = {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 0,
-      errors: [],
-    };
-
-    try {
-      // Get target records
-      const records = await this.getTargetRecords(
-        action.targetEntityType,
-        action.filterCriteria,
-        jobData,
-      );
-
-      result.totalRecords = records.length;
-
-      // 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,
-              ],
-            );
-
-            result.processedRecords += 1;
-            result.successfulRecords += 1;
-          } catch (error) {
-            result.processedRecords += 1;
-            result.failedRecords += 1;
-            result.errors.push({
-              recordId: record.id,
-              error: error.message,
-            });
-          }
-        }
-      }
-    } catch (error) {
-      throw new Error(`Create task action failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Execute send notification action
-   */
-  private async executeSendNotificationAction(
-    action: any,
-    jobData: ScheduleJobData,
-  ): Promise<BatchProcessingResult> {
-    const result: BatchProcessingResult = {
-      totalRecords: 0,
-      processedRecords: 0,
-      successfulRecords: 0,
-      failedRecords: 0,
-      errors: [],
-    };
-
-    try {
-      // Get target records
-      const records = await this.getTargetRecords(
-        action.targetEntityType,
-        action.filterCriteria,
-        jobData,
-      );
-
-      result.totalRecords = records.length;
-
-      // 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',
-                action.actionConfig.message || 'Scheduled workflow executed',
-                record.id,
-                action.targetEntityType,
-                jobData.organizationId,
-              ],
-            );
-
-            result.processedRecords += 1;
-            result.successfulRecords += 1;
-          } catch (error) {
-            result.processedRecords += 1;
-            result.failedRecords += 1;
-            result.errors.push({
-              recordId: record.id,
-              error: error.message,
-            });
-          }
-        }
-      }
-    } catch (error) {
-      throw new Error(`Send notification action failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Get target records based on entity type and filter criteria
-   */
-  private async getTargetRecords(
-    entityType: string,
-    filterCriteria: any,
-    jobData: ScheduleJobData,
-  ): Promise<any[]> {
-    const tableName = this.getTableNameForEntityType(entityType);
-
-    // Build WHERE clause from filter criteria
-    let whereClause = `organization_id = ${jobData.organizationId}`;
-    const params: any[] = [];
-
-    if (filterCriteria && Object.keys(filterCriteria).length > 0) {
-      Object.keys(filterCriteria).forEach((key) => {
-        whereClause += ` AND ${key} = ?`;
-        params.push(filterCriteria[key]);
-      });
-    }
-
-    const query = `SELECT * FROM ${tableName} WHERE ${whereClause}`;
-    const records = await this.dataSource.query(query, params);
-
-    return records;
-  }
-
-  /**
-   * Get table name for entity type
-   */
-  private getTableNameForEntityType(entityType: string): string {
-    // Map entity types to table names
-    const entityTypeMap: Record<string, string> = {
-      USR: 'sso_user',
-      LEAD: 'cr_lead',
-      TASK: 'cr_wf_task',
-      // Add more mappings as needed
-    };
-
-    return entityTypeMap[entityType] || 'unknown_table';
-  }
-
-  /**
-   * Split array into chunks
-   */
-  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
-    const chunks: T[][] = [];
-    for (let i = 0; i < array.length; i += chunkSize) {
-      chunks.push(array.slice(i, i + chunkSize));
-    }
-    return chunks;
-  }
-
-  /**
-   * Event handler for when job becomes active
-   */
-  @OnQueueActive()
-  onActive(job: Job<ScheduleJobData>) {
-    this.logger.log(
-      `Processing job ${job.id} of type ${job.name} for schedule ${job.data.scheduleId}`,
-    );
-  }
-
-  /**
-   * Event handler for when job completes
-   */
-  @OnQueueCompleted()
-  onCompleted(job: Job<ScheduleJobData>, result: any) {
-    this.logger.log(
-      `Job ${job.id} completed for schedule ${job.data.scheduleId} with result: ${JSON.stringify(result)}`,
-    );
-  }
-
-  /**
-   * Event handler for when job fails
-   */
-  @OnQueueFailed()
-  onFailed(job: Job<ScheduleJobData>, error: Error) {
-    this.logger.error(
-      `Job ${job.id} failed for schedule ${job.data.scheduleId} with error: ${error.message}`,
-      error.stack,
-    );
-  }
-}
+import { Process, Processor, OnQueueActive, OnQueueCompleted, OnQueueFailed } from '@nestjs/bull';
+import { Logger, Inject, forwardRef } from '@nestjs/common';
+import { Job } from 'bull';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, DataSource } from 'typeorm';
+import { ScheduledWorkflow } from '../entities/scheduled-workflow.entity';
+import { WorkflowExecutionLog } from '../entities/workflow-execution-log.entity';
+import {
+  WORKFLOW_SCHEDULE_QUEUE,
+  EXECUTE_SCHEDULED_WORKFLOW_JOB,
+  EXECUTION_STATUS_PENDING,
+  EXECUTION_STATUS_RUNNING,
+  EXECUTION_STATUS_COMPLETED,
+  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 { ScheduleHandlerService } from 'src/module/workflow-automation/service/schedule-handler.service';
+
+/**
+ * Schedule Processor
+ * Processes scheduled workflow execution jobs from Bull queue
+ */
+@Processor(WORKFLOW_SCHEDULE_QUEUE)
+export class ScheduleProcessor {
+  private readonly logger = new Logger(ScheduleProcessor.name);
+
+  constructor(
+    @InjectRepository(ScheduledWorkflow)
+    private readonly scheduledWorkflowRepository: Repository<ScheduledWorkflow>,
+    @InjectRepository(WorkflowExecutionLog)
+    private readonly executionLogRepository: Repository<WorkflowExecutionLog>,
+    private readonly dataSource: DataSource,
+@Inject('ScheduleHandlerService')
+  private readonly scheduleHandlerService: ScheduleHandlerService,
+  ) {}
+
+  /**
+   * 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;
+
+    this.logger.log(
+      `🚀 [handleScheduledWorkflowExecution] Invoked for scheduleId=${scheduleId}, workflowId=${workflowId}`,
+    );
+
+    // Create execution log entry
+    const executionLog = this.executionLogRepository.create({
+      schedule_id: scheduleId,
+      workflow_id: workflowId,
+      job_id: job.id.toString(),
+      execution_status: EXECUTION_STATUS_PENDING,
+      triggered_by: triggeredBy,
+      triggered_by_user_id: triggeredBy === 'MANUAL' ? createdBy : null,
+      organization_id: organizationId,
+      enterprise_id: job.data.enterpriseId,
+      created_by: createdBy,
+      entity_type: 'WFEL',
+    });
+
+    this.logger.debug(`🧾 Creating execution log for jobId=${job.id}`);
+    await this.executionLogRepository.save(executionLog);
+
+    try {
+      // Update status to running
+      executionLog.execution_status = EXECUTION_STATUS_RUNNING;
+      executionLog.started_at = new Date();
+      await this.executionLogRepository.save(executionLog);
+
+      this.logger.log(`🏃 Workflow execution started for scheduleId=${scheduleId}`);
+
+      // Get scheduled workflow details
+      const schedule = await this.scheduledWorkflowRepository.findOne({
+        where: { id: scheduleId },
+      });
+
+      if (!schedule) {
+        throw new Error(`Scheduled workflow not found: ${scheduleId}`);
+      }
+
+      this.logger.debug(`📋 Loaded schedule from DB: ${JSON.stringify(schedule)}`);
+
+      // Execute workflow actions
+      this.logger.log(`⚙️ Executing workflow actions...`);
+      const result = await this.executeWorkflowActions(schedule, job.data);
+      this.logger.debug(`🧮 Execution result: ${JSON.stringify(result)}`);
+
+      // Update execution log with results
+      const completedAt = new Date();
+      executionLog.execution_status =
+        result.failedRecords > 0 && result.successfulRecords > 0
+          ? EXECUTION_STATUS_PARTIAL
+          : result.failedRecords > 0
+          ? EXECUTION_STATUS_FAILED
+          : EXECUTION_STATUS_COMPLETED;
+      executionLog.completed_at = completedAt;
+      executionLog.duration_ms = completedAt.getTime() - executionLog.started_at.getTime();
+      executionLog.total_records = result.totalRecords;
+      executionLog.successful_records = result.successfulRecords;
+      executionLog.failed_records = result.failedRecords;
+      executionLog.execution_details = {
+        batchesProcessed: Math.ceil(result.totalRecords / DEFAULT_BATCH_SIZE),
+        errors: result.errors,
+      };
+
+      await this.executionLogRepository.save(executionLog);
+
+      // Update schedule execution count and last execution time
+      schedule.execution_count += 1;
+      schedule.last_execution_at = completedAt;
+      await this.scheduledWorkflowRepository.save(schedule);
+
+      this.logger.log(
+        `✅ Workflow execution completed: scheduleId=${scheduleId}, status=${executionLog.execution_status}, processed=${result.totalRecords}`,
+      );
+
+      return {
+        success: true,
+        executionLogId: executionLog.id,
+        result,
+      };
+    } catch (error) {
+      this.logger.error(
+        `🔥 Workflow execution failed: scheduleId=${scheduleId}, error=${error.message}`,
+        error.stack,
+      );
+
+      // Update execution log with error
+      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()
+        : 0;
+      executionLog.error_message = error.message;
+      executionLog.error_stack = error.stack;
+
+      await this.executionLogRepository.save(executionLog);
+
+      throw error;
+    }
+  }
+
+  /**
+   * Execute all actions defined in the workflow
+   */
+  private async executeWorkflowActions(
+    schedule: ScheduledWorkflow,
+    jobData: ScheduleJobData,
+  ): Promise<BatchProcessingResult> {
+    const result: BatchProcessingResult = {
+      totalRecords: 0,
+      processedRecords: 0,
+      successfulRecords: 0,
+      failedRecords: 0,
+      errors: [],
+    };
+
+    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}`);
+      return result;
+    }
+
+    // Execute each action sequentially
+    for (const action of schedule.actions) {
+      try {
+        const actionResult = await this.executeAction(action, jobData);
+        result.totalRecords += actionResult.totalRecords;
+        result.processedRecords += actionResult.processedRecords;
+        result.successfulRecords += actionResult.successfulRecords;
+        result.failedRecords += actionResult.failedRecords;
+        result.errors.push(...actionResult.errors);
+      } catch (error) {
+        this.logger.error(
+          `Action execution failed: actionType=${action.actionType}, error=${error.message}`,
+        );
+        result.failedRecords += 1;
+        result.errors.push({
+          error: `Action ${action.actionType} failed: ${error.message}`,
+        });
+      }
+    }
+
+    return resultData;
+  }
+
+  /**
+   * 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;
+
+    // 🧠 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 }],
+    };
+  }
+}
+
+
+  /**
+   * Execute send email action
+   */
+  private async executeSendEmailAction(
+    action: any,
+    jobData: ScheduleJobData,
+  ): Promise<BatchProcessingResult> {
+    const result: BatchProcessingResult = {
+      totalRecords: 0,
+      processedRecords: 0,
+      successfulRecords: 0,
+      failedRecords: 0,
+      errors: [],
+    };
+
+    try {
+      // Get target records based on filter criteria
+      const records = await this.getTargetRecords(
+        action.targetEntityType,
+        action.filterCriteria,
+        jobData,
+      );
+
+      result.totalRecords = records.length;
+
+      // Process in batches
+      const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
+
+      for (const batch of batches) {
+        for (const record of batch) {
+          try {
+            // TODO: Integrate with email service
+            // await this.emailService.sendEmail({
+            //   to: record.email,
+            //   subject: action.actionConfig.subject,
+            //   template: action.actionConfig.template,
+            //   data: record,
+            // });
+
+            result.processedRecords += 1;
+            result.successfulRecords += 1;
+          } catch (error) {
+            result.processedRecords += 1;
+            result.failedRecords += 1;
+            result.errors.push({
+              recordId: record.id,
+              error: error.message,
+            });
+          }
+        }
+      }
+    } catch (error) {
+      throw new Error(`Send email action failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Execute update records action
+   */
+  private async executeUpdateRecordsAction(
+    action: any,
+    jobData: ScheduleJobData,
+  ): Promise<BatchProcessingResult> {
+    const result: BatchProcessingResult = {
+      totalRecords: 0,
+      processedRecords: 0,
+      successfulRecords: 0,
+      failedRecords: 0,
+      errors: [],
+    };
+
+    try {
+      // Get target records
+      const records = await this.getTargetRecords(
+        action.targetEntityType,
+        action.filterCriteria,
+        jobData,
+      );
+
+      result.totalRecords = records.length;
+
+      // Process in batches
+      const batches = this.chunkArray(records, DEFAULT_BATCH_SIZE);
+
+      for (const batch of batches) {
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+
+        try {
+          for (const record of batch) {
+            // Build update query based on action config
+            const updateFields = action.actionConfig.updateFields || {};
+            const updateValues = Object.keys(updateFields).map((key) => {
+              return `${key} = ?`;
+            });
+            const values = Object.values(updateFields);
+
+            if (updateValues.length > 0) {
+              const tableName = this.getTableNameForEntityType(action.targetEntityType);
+              await queryRunner.query(
+                `UPDATE ${tableName} SET ${updateValues.join(', ')} WHERE id = ?`,
+                [...values, record.id],
+              );
+            }
+
+            result.processedRecords += 1;
+            result.successfulRecords += 1;
+          }
+
+          await queryRunner.commitTransaction();
+        } catch (error) {
+          await queryRunner.rollbackTransaction();
+          result.failedRecords += batch.length;
+          result.errors.push({
+            error: `Batch update failed: ${error.message}`,
+          });
+        } finally {
+          await queryRunner.release();
+        }
+      }
+    } catch (error) {
+      throw new Error(`Update records action failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Execute create task action
+   */
+  private async executeCreateTaskAction(
+    action: any,
+    jobData: ScheduleJobData,
+  ): Promise<BatchProcessingResult> {
+    const result: BatchProcessingResult = {
+      totalRecords: 0,
+      processedRecords: 0,
+      successfulRecords: 0,
+      failedRecords: 0,
+      errors: [],
+    };
+
+    try {
+      // Get target records
+      const records = await this.getTargetRecords(
+        action.targetEntityType,
+        action.filterCriteria,
+        jobData,
+      );
+
+      result.totalRecords = records.length;
+
+      // 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,
+              ],
+            );
+
+            result.processedRecords += 1;
+            result.successfulRecords += 1;
+          } catch (error) {
+            result.processedRecords += 1;
+            result.failedRecords += 1;
+            result.errors.push({
+              recordId: record.id,
+              error: error.message,
+            });
+          }
+        }
+      }
+    } catch (error) {
+      throw new Error(`Create task action failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Execute send notification action
+   */
+  private async executeSendNotificationAction(
+    action: any,
+    jobData: ScheduleJobData,
+  ): Promise<BatchProcessingResult> {
+    const result: BatchProcessingResult = {
+      totalRecords: 0,
+      processedRecords: 0,
+      successfulRecords: 0,
+      failedRecords: 0,
+      errors: [],
+    };
+
+    try {
+      // Get target records
+      const records = await this.getTargetRecords(
+        action.targetEntityType,
+        action.filterCriteria,
+        jobData,
+      );
+
+      result.totalRecords = records.length;
+
+      // 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',
+                action.actionConfig.message || 'Scheduled workflow executed',
+                record.id,
+                action.targetEntityType,
+                jobData.organizationId,
+              ],
+            );
+
+            result.processedRecords += 1;
+            result.successfulRecords += 1;
+          } catch (error) {
+            result.processedRecords += 1;
+            result.failedRecords += 1;
+            result.errors.push({
+              recordId: record.id,
+              error: error.message,
+            });
+          }
+        }
+      }
+    } catch (error) {
+      throw new Error(`Send notification action failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get target records based on entity type and filter criteria
+   */
+  private async getTargetRecords(
+    entityType: string,
+    filterCriteria: any,
+    jobData: ScheduleJobData,
+  ): Promise<any[]> {
+    const tableName = this.getTableNameForEntityType(entityType);
+
+    // Build WHERE clause from filter criteria
+    let whereClause = `organization_id = ${jobData.organizationId}`;
+    const params: any[] = [];
+
+    if (filterCriteria && Object.keys(filterCriteria).length > 0) {
+      Object.keys(filterCriteria).forEach((key) => {
+        whereClause += ` AND ${key} = ?`;
+        params.push(filterCriteria[key]);
+      });
+    }
+
+    const query = `SELECT * FROM ${tableName} WHERE ${whereClause}`;
+    const records = await this.dataSource.query(query, params);
+
+    return records;
+  }
+
+  /**
+   * Get table name for entity type
+   */
+  private getTableNameForEntityType(entityType: string): string {
+    // Map entity types to table names
+    const entityTypeMap: Record<string, string> = {
+      USR: 'sso_user',
+      LEAD: 'cr_lead',
+      TASK: 'cr_wf_task',
+      // Add more mappings as needed
+    };
+
+    return entityTypeMap[entityType] || 'unknown_table';
+  }
+
+  /**
+   * Split array into chunks
+   */
+  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+      chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+  }
+
+  /**
+   * Event handler for when job becomes active
+   */
+  @OnQueueActive()
+  onActive(job: Job<ScheduleJobData>) {
+    this.logger.log(
+      `Processing job ${job.id} of type ${job.name} for schedule ${job.data.scheduleId}`,
+    );
+  }
+
+  /**
+   * Event handler for when job completes
+   */
+  @OnQueueCompleted()
+  onCompleted(job: Job<ScheduleJobData>, result: any) {
+    this.logger.log(
+      `Job ${job.id} completed for schedule ${job.data.scheduleId} with result: ${JSON.stringify(result)}`,
+    );
+  }
+
+  /**
+   * Event handler for when job fails
+   */
+  @OnQueueFailed()
+  onFailed(job: Job<ScheduleJobData>, error: Error) {
+    this.logger.error(
+      `Job ${job.id} failed for schedule ${job.data.scheduleId} with error: ${error.message}`,
+      error.stack,
+    );
+  }
+}