rez_core 5.0.100 → 5.0.102

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

@@ -1,620 +1,620 @@
-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';
-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,
-} from '../constants/schedule.constants';
-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
- * 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>,
-    @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;
-
-    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;
-
-      // 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 {
-            // 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,
-            });
-          }
-        }
-      }
-    } 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;
-
-      // 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 {
-            // 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',
-              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,
-            });
-          }
-        }
-      }
-    } 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[]> {
-    // Get repository dynamically based on entityType
-    const repo = this.reflectionHelper.getRepoService(entityType);
-
-    // 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) {
-      for (const key of Object.keys(filterCriteria)) {
-        qb.andWhere(`e.${key} = :${key}`, {
-          [key]: filterCriteria[key],
-        });
-      }
-    }
-
-    const records = await qb.getMany();
-    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 } 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,
+} from '../constants/schedule.constants';
+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
+ * 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>,
+    @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;
+
+    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;
+
+      // 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 {
+            // 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,
+            });
+          }
+        }
+      }
+    } 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;
+
+      // 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 {
+            // 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',
+              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,
+            });
+          }
+        }
+      }
+    } 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[]> {
+    // Get repository dynamically based on entityType
+    const repo = this.reflectionHelper.getRepoService(entityType);
+
+    // 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) {
+      for (const key of Object.keys(filterCriteria)) {
+        qb.andWhere(`e.${key} = :${key}`, {
+          [key]: filterCriteria[key],
+        });
+      }
+    }
+
+    const records = await qb.getMany();
+    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,
+    );
+  }
+}