rez_core 4.0.183 → 4.0.184

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

@@ -1,584 +0,0 @@
-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,
-    );
-  }
-}