rez_core 4.0.167 → 4.0.171

package/dist/module/workflow-schedule/entities/workflow-execution-log.entity.d.ts

@@ -0,0 +1,34 @@
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+export declare class WorkflowExecutionLog extends BaseEntity {
+    constructor();
+    schedule_id: number;
+    workflow_id: number;
+    job_id: string;
+    execution_status: string;
+    started_at: Date;
+    completed_at: Date;
+    duration_ms: number;
+    triggered_by: string;
+    triggered_by_user_id: number | null;
+    total_records: number;
+    successful_records: number;
+    failed_records: number;
+    retry_count: number;
+    max_retries: number;
+    error_message: string;
+    error_stack: string;
+    execution_details: {
+        batchesProcessed?: number;
+        actionsExecuted?: Array<{
+            actionType: string;
+            success: boolean;
+            recordsAffected?: number;
+            error?: string;
+        }>;
+        errors?: Array<{
+            recordId?: number;
+            error: string;
+        }>;
+    };
+    metadata: Record<string, any>;
+}

package/dist/module/workflow-schedule/entities/workflow-execution-log.entity.js

@@ -0,0 +1,118 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecutionLog = void 0;
+const typeorm_1 = require("typeorm");
+const class_transformer_1 = require("class-transformer");
+const base_entity_entity_1 = require("../../meta/entity/base-entity.entity");
+const schedule_constants_1 = require("../constants/schedule.constants");
+let WorkflowExecutionLog = class WorkflowExecutionLog extends base_entity_entity_1.BaseEntity {
+    constructor() {
+        super();
+        this.entity_type = schedule_constants_1.WORKFLOW_EXECUTION_LOG;
+    }
+};
+exports.WorkflowExecutionLog = WorkflowExecutionLog;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'bigint', nullable: false }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "schedule_id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'bigint', nullable: false }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "workflow_id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 255, nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], WorkflowExecutionLog.prototype, "job_id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 50, nullable: false, default: 'PENDING' }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], WorkflowExecutionLog.prototype, "execution_status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'datetime', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Date)
+], WorkflowExecutionLog.prototype, "started_at", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'datetime', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Date)
+], WorkflowExecutionLog.prototype, "completed_at", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "duration_ms", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 50, nullable: false, default: 'SCHEDULE' }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], WorkflowExecutionLog.prototype, "triggered_by", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'bigint', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Object)
+], WorkflowExecutionLog.prototype, "triggered_by_user_id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 0 }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "total_records", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 0 }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "successful_records", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 0 }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "failed_records", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 0 }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "retry_count", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 3 }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], WorkflowExecutionLog.prototype, "max_retries", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], WorkflowExecutionLog.prototype, "error_message", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], WorkflowExecutionLog.prototype, "error_stack", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Object)
+], WorkflowExecutionLog.prototype, "execution_details", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Object)
+], WorkflowExecutionLog.prototype, "metadata", void 0);
+exports.WorkflowExecutionLog = WorkflowExecutionLog = __decorate([
+    (0, typeorm_1.Entity)({ name: 'frm_wf_execution_log' }),
+    __metadata("design:paramtypes", [])
+], WorkflowExecutionLog);
+//# sourceMappingURL=workflow-execution-log.entity.js.map

package/dist/module/workflow-schedule/entities/workflow-execution-log.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-execution-log.entity.js","sourceRoot":"","sources":["../../../../src/module/workflow-schedule/entities/workflow-execution-log.entity.ts"],"names":[],"mappings":"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"}

package/dist/module/workflow-schedule/interfaces/schedule-job-data.interface.d.ts

@@ -0,0 +1,44 @@
+import { UserData } from "src/module/user/entity/user.entity";
+export interface ScheduleJobData {
+    scheduleId: number;
+    workflowId: number;
+    workflowName: string;
+    organizationId: number;
+    enterpriseId: number;
+    levelId?: string;
+    levelType?: string;
+    appcode?: string;
+    createdBy: number;
+    triggeredBy: 'SCHEDULE' | 'MANUAL';
+    triggeredAt: Date;
+    metadata?: Record<string, any>;
+    loggedInUser?: UserData;
+}
+export interface WorkflowActionData {
+    actionType: string;
+    actionConfig: Record<string, any>;
+    targetEntityType?: string;
+    filterCriteria?: Record<string, any>;
+}
+export interface BatchProcessingResult {
+    totalRecords: number;
+    processedRecords: number;
+    successfulRecords: number;
+    failedRecords: number;
+    errors: Array<{
+        recordId?: number;
+        error: string;
+    }>;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    retryDelay: number;
+    backoffMultiplier: number;
+}
+export interface ScheduleConfig {
+    cronExpression: string;
+    timezone: string;
+    startDate?: Date;
+    endDate?: Date;
+    maxExecutions?: number;
+}

package/dist/module/workflow-schedule/interfaces/schedule-job-data.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schedule-job-data.interface.js.map

package/dist/module/workflow-schedule/interfaces/schedule-job-data.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-job-data.interface.js","sourceRoot":"","sources":["../../../../src/module/workflow-schedule/interfaces/schedule-job-data.interface.ts"],"names":[],"mappings":""}

package/dist/module/workflow-schedule/processors/schedule.processor.d.ts

@@ -0,0 +1,31 @@
+import { Job } from 'bull';
+import { Repository, DataSource } from 'typeorm';
+import { ScheduledWorkflow } from '../entities/scheduled-workflow.entity';
+import { WorkflowExecutionLog } from '../entities/workflow-execution-log.entity';
+import { ScheduleJobData, BatchProcessingResult } from '../interfaces/schedule-job-data.interface';
+import { ScheduleHandlerService } from 'src/module/workflow-automation/service/schedule-handler.service';
+export declare class ScheduleProcessor {
+    private readonly scheduledWorkflowRepository;
+    private readonly executionLogRepository;
+    private readonly dataSource;
+    private readonly scheduleHandlerService;
+    private readonly logger;
+    constructor(scheduledWorkflowRepository: Repository<ScheduledWorkflow>, executionLogRepository: Repository<WorkflowExecutionLog>, dataSource: DataSource, scheduleHandlerService: ScheduleHandlerService);
+    handleScheduledWorkflowExecution(job: Job<ScheduleJobData>): Promise<{
+        success: boolean;
+        executionLogId: number;
+        result: BatchProcessingResult;
+    }>;
+    private executeWorkflowActions;
+    private executeAction;
+    private executeSendEmailAction;
+    private executeUpdateRecordsAction;
+    private executeCreateTaskAction;
+    private executeSendNotificationAction;
+    private getTargetRecords;
+    private getTableNameForEntityType;
+    private chunkArray;
+    onActive(job: Job<ScheduleJobData>): void;
+    onCompleted(job: Job<ScheduleJobData>, result: any): void;
+    onFailed(job: Job<ScheduleJobData>, error: Error): void;
+}

package/dist/module/workflow-schedule/processors/schedule.processor.js

@@ -0,0 +1,409 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ScheduleProcessor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleProcessor = void 0;
+const bull_1 = require("@nestjs/bull");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const scheduled_workflow_entity_1 = require("../entities/scheduled-workflow.entity");
+const workflow_execution_log_entity_1 = require("../entities/workflow-execution-log.entity");
+const schedule_constants_1 = require("../constants/schedule.constants");
+const schedule_handler_service_1 = require("../../workflow-automation/service/schedule-handler.service");
+let ScheduleProcessor = ScheduleProcessor_1 = class ScheduleProcessor {
+    constructor(scheduledWorkflowRepository, executionLogRepository, dataSource, scheduleHandlerService) {
+        this.scheduledWorkflowRepository = scheduledWorkflowRepository;
+        this.executionLogRepository = executionLogRepository;
+        this.dataSource = dataSource;
+        this.scheduleHandlerService = scheduleHandlerService;
+        this.logger = new common_1.Logger(ScheduleProcessor_1.name);
+    }
+    async handleScheduledWorkflowExecution(job) {
+        const { scheduleId, workflowId, organizationId, triggeredBy, createdBy } = job.data;
+        this.logger.log(`🚀 [handleScheduledWorkflowExecution] Invoked for scheduleId=${scheduleId}, workflowId=${workflowId}`);
+        const executionLog = this.executionLogRepository.create({
+            schedule_id: scheduleId,
+            workflow_id: workflowId,
+            job_id: job.id.toString(),
+            execution_status: schedule_constants_1.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 {
+            executionLog.execution_status = schedule_constants_1.EXECUTION_STATUS_RUNNING;
+            executionLog.started_at = new Date();
+            await this.executionLogRepository.save(executionLog);
+            this.logger.log(`🏃 Workflow execution started for scheduleId=${scheduleId}`);
+            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)}`);
+            this.logger.log(`⚙️ Executing workflow actions...`);
+            const result = await this.executeWorkflowActions(schedule, job.data);
+            this.logger.debug(`🧮 Execution result: ${JSON.stringify(result)}`);
+            const completedAt = new Date();
+            executionLog.execution_status =
+                result.failedRecords > 0 && result.successfulRecords > 0
+                    ? schedule_constants_1.EXECUTION_STATUS_PARTIAL
+                    : result.failedRecords > 0
+                        ? schedule_constants_1.EXECUTION_STATUS_FAILED
+                        : schedule_constants_1.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 / schedule_constants_1.DEFAULT_BATCH_SIZE),
+                errors: result.errors,
+            };
+            await this.executionLogRepository.save(executionLog);
+            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);
+            executionLog.execution_status = schedule_constants_1.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;
+        }
+    }
+    async executeWorkflowActions(schedule, jobData) {
+        const result = {
+            totalRecords: 0,
+            processedRecords: 0,
+            successfulRecords: 0,
+            failedRecords: 0,
+            errors: [],
+        };
+        const resultData = 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;
+        }
+        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;
+    }
+    async executeAction(action, jobData) {
+        this.logger.log(`🚀 Executing scheduled action: ${action.actionType}`);
+        try {
+            const { workflowId, loggedInUser } = jobData;
+            const result = 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 }],
+            };
+        }
+    }
+    async executeSendEmailAction(action, jobData) {
+        const result = {
+            totalRecords: 0,
+            processedRecords: 0,
+            successfulRecords: 0,
+            failedRecords: 0,
+            errors: [],
+        };
+        try {
+            const records = await this.getTargetRecords(action.targetEntityType, action.filterCriteria, jobData);
+            result.totalRecords = records.length;
+            const batches = this.chunkArray(records, schedule_constants_1.DEFAULT_BATCH_SIZE);
+            for (const batch of batches) {
+                for (const record of batch) {
+                    try {
+                        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;
+    }
+    async executeUpdateRecordsAction(action, jobData) {
+        const result = {
+            totalRecords: 0,
+            processedRecords: 0,
+            successfulRecords: 0,
+            failedRecords: 0,
+            errors: [],
+        };
+        try {
+            const records = await this.getTargetRecords(action.targetEntityType, action.filterCriteria, jobData);
+            result.totalRecords = records.length;
+            const batches = this.chunkArray(records, schedule_constants_1.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) {
+                        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;
+    }
+    async executeCreateTaskAction(action, jobData) {
+        const result = {
+            totalRecords: 0,
+            processedRecords: 0,
+            successfulRecords: 0,
+            failedRecords: 0,
+            errors: [],
+        };
+        try {
+            const records = await this.getTargetRecords(action.targetEntityType, action.filterCriteria, jobData);
+            result.totalRecords = records.length;
+            const batches = this.chunkArray(records, schedule_constants_1.DEFAULT_BATCH_SIZE);
+            for (const batch of batches) {
+                for (const record of batch) {
+                    try {
+                        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;
+    }
+    async executeSendNotificationAction(action, jobData) {
+        const result = {
+            totalRecords: 0,
+            processedRecords: 0,
+            successfulRecords: 0,
+            failedRecords: 0,
+            errors: [],
+        };
+        try {
+            const records = await this.getTargetRecords(action.targetEntityType, action.filterCriteria, jobData);
+            result.totalRecords = records.length;
+            const batches = this.chunkArray(records, schedule_constants_1.DEFAULT_BATCH_SIZE);
+            for (const batch of batches) {
+                for (const record of batch) {
+                    try {
+                        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;
+    }
+    async getTargetRecords(entityType, filterCriteria, jobData) {
+        const tableName = this.getTableNameForEntityType(entityType);
+        let whereClause = `organization_id = ${jobData.organizationId}`;
+        const params = [];
+        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;
+    }
+    getTableNameForEntityType(entityType) {
+        const entityTypeMap = {
+            USR: 'sso_user',
+            LEAD: 'cr_lead',
+            TASK: 'cr_wf_task',
+        };
+        return entityTypeMap[entityType] || 'unknown_table';
+    }
+    chunkArray(array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+    onActive(job) {
+        this.logger.log(`Processing job ${job.id} of type ${job.name} for schedule ${job.data.scheduleId}`);
+    }
+    onCompleted(job, result) {
+        this.logger.log(`Job ${job.id} completed for schedule ${job.data.scheduleId} with result: ${JSON.stringify(result)}`);
+    }
+    onFailed(job, error) {
+        this.logger.error(`Job ${job.id} failed for schedule ${job.data.scheduleId} with error: ${error.message}`, error.stack);
+    }
+};
+exports.ScheduleProcessor = ScheduleProcessor;
+__decorate([
+    (0, bull_1.Process)(schedule_constants_1.EXECUTE_SCHEDULED_WORKFLOW_JOB),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ScheduleProcessor.prototype, "handleScheduledWorkflowExecution", null);
+__decorate([
+    (0, bull_1.OnQueueActive)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ScheduleProcessor.prototype, "onActive", null);
+__decorate([
+    (0, bull_1.OnQueueCompleted)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], ScheduleProcessor.prototype, "onCompleted", null);
+__decorate([
+    (0, bull_1.OnQueueFailed)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Error]),
+    __metadata("design:returntype", void 0)
+], ScheduleProcessor.prototype, "onFailed", null);
+exports.ScheduleProcessor = ScheduleProcessor = ScheduleProcessor_1 = __decorate([
+    (0, bull_1.Processor)(schedule_constants_1.WORKFLOW_SCHEDULE_QUEUE),
+    __param(0, (0, typeorm_1.InjectRepository)(scheduled_workflow_entity_1.ScheduledWorkflow)),
+    __param(1, (0, typeorm_1.InjectRepository)(workflow_execution_log_entity_1.WorkflowExecutionLog)),
+    __param(3, (0, common_1.Inject)('ScheduleHandlerService')),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.DataSource,
+        schedule_handler_service_1.ScheduleHandlerService])
+], ScheduleProcessor);
+//# sourceMappingURL=schedule.processor.js.map