rez_core 4.0.184 → 4.0.187

package/src/module/workflow-automation/SCHEDULING_GUIDE.md

@@ -0,0 +1,145 @@
+# Workflow Automation Scheduling Guide
+
+## Overview
+This module integrates with `WorkflowScheduleModule` to enable creating scheduled workflow automations. You can create schedules that run automatically via cron, or create them in a disabled state for manual triggering only.
+
+## Controlling Auto-Scheduling Behavior
+
+### Option 1: Create Schedules WITHOUT Auto-Execution
+When creating a schedule, set `is_enabled: false` to prevent it from running automatically:
+
+```typescript
+// Inject WorkflowScheduleService in your controller/service
+constructor(
+  private readonly workflowScheduleService: WorkflowScheduleService,
+) {}
+
+// Create schedule without auto-execution
+const schedule = await this.workflowScheduleService.createSchedule(
+  {
+    workflow_id: workflowId,
+    workflow_name: 'My Workflow',
+    name: 'My Schedule',
+    cron_expression: '0 9 * * *', // Every day at 9 AM
+    timezone: 'America/New_York',
+    is_enabled: false, // 👈 This prevents auto-execution
+    // ... other fields
+  },
+  loggedInUser,
+);
+```
+
+### Option 2: Create Schedules WITH Auto-Execution
+Simply set `is_enabled: true` (or omit it, as it defaults to true):
+
+```typescript
+const schedule = await this.workflowScheduleService.createSchedule(
+  {
+    workflow_id: workflowId,
+    workflow_name: 'My Workflow',
+    name: 'My Schedule',
+    cron_expression: '0 9 * * *',
+    timezone: 'America/New_York',
+    is_enabled: true, // 👈 Schedule will run automatically on cron
+    // ... other fields
+  },
+  loggedInUser,
+);
+```
+
+## How It Works
+
+The scheduling logic in `WorkflowScheduleService.createSchedule()` (line 101-103) only adds jobs to the Bull queue if:
+1. `is_enabled === true`
+2. `schedule_status === 'ACTIVE'`
+
+If either condition is false, the schedule is saved to the database but NOT added to the queue, meaning the cron processor won't execute it.
+
+## Manual Triggering
+
+You can manually trigger any schedule (enabled or disabled) using:
+
+```typescript
+const result = await this.workflowScheduleService.triggerManualExecution(
+  scheduleId,
+  loggedInUser,
+  { /* optional metadata */ },
+);
+```
+
+## Enabling/Disabling Schedules Later
+
+### To Enable a Disabled Schedule:
+```typescript
+await this.workflowScheduleService.updateSchedule(
+  {
+    id: scheduleId,
+    is_enabled: true,
+  },
+  loggedInUser,
+);
+```
+
+### To Disable an Active Schedule:
+```typescript
+await this.workflowScheduleService.updateSchedule(
+  {
+    id: scheduleId,
+    is_enabled: false,
+  },
+  loggedInUser,
+);
+```
+
+### To Pause a Schedule Temporarily:
+```typescript
+await this.workflowScheduleService.pauseSchedule(scheduleId, loggedInUser);
+```
+
+### To Resume a Paused Schedule:
+```typescript
+await this.workflowScheduleService.resumeSchedule(scheduleId, loggedInUser);
+```
+
+## Best Practices
+
+1. **Testing**: Create schedules with `is_enabled: false` during development and testing
+2. **Staged Rollout**: Create schedules disabled, test manually, then enable when ready
+3. **Monitoring**: Use `getExecutionLogs()` and `getExecutionStats()` to monitor schedule performance
+4. **Cleanup**: Use `deleteSchedule()` to soft-delete schedules you no longer need
+
+## Example: Complete Workflow
+
+```typescript
+// 1. Create schedule (disabled)
+const schedule = await this.workflowScheduleService.createSchedule({
+  workflow_id: 123,
+  workflow_name: 'Send Daily Report',
+  name: 'Daily Report Schedule',
+  cron_expression: '0 9 * * *',
+  is_enabled: false, // Start disabled
+}, loggedInUser);
+
+// 2. Test manually
+const testResult = await this.workflowScheduleService.triggerManualExecution(
+  schedule.id,
+  loggedInUser,
+);
+
+// 3. Check execution logs
+const logs = await this.workflowScheduleService.getExecutionLogs({
+  schedule_id: schedule.id,
+}, loggedInUser);
+
+// 4. If tests pass, enable for auto-execution
+if (logs.data[0].execution_status === 'COMPLETED') {
+  await this.workflowScheduleService.updateSchedule({
+    id: schedule.id,
+    is_enabled: true, // Now it will run on cron
+  }, loggedInUser);
+}
+```
+
+## Environment Configuration
+
+The Bull queue (Redis) connection is configured in `src/config/bull.config.ts`. Ensure Redis is running and accessible for the scheduler to work.

package/src/module/workflow-automation/controller/workflow-automation.controller.ts

@@ -1,4 +1,5 @@
 import {
+  BadRequestException,
   Body,
   Controller,
   HttpCode,
@@ -18,4 +19,25 @@ export class WorkflowAutomationController {
     @Inject('WorkflowAutomationService')
     private readonly workflowAutomationService: WorkflowAutomationService,
   ) {}
+
+  /**
+   * Endpoint to update the sequence of workflow automations.
+   * Accepts an array of objects with `id` and `sequence`.
+   */
+  @Post('/updateSequence')
+  @HttpCode(HttpStatus.OK)
+  async updateSequence(
+    @Body() body: any,
+    @Req() req: Request & { user?: any },
+  ) {
+    const loggedInUser = req.user?.userData;
+
+    if (!Array.isArray(body) || body.length === 0) {
+      throw new BadRequestException(
+        'Invalid input. Expected a non-empty array.',
+      );
+    }
+
+    return this.workflowAutomationService.updateSequence(body, loggedInUser);
+  }
 }

package/src/module/workflow-automation/entity/workflow-automation.entity.ts

@@ -32,4 +32,9 @@ export class WorkflowAutomation extends BaseEntity {
 
   @Column({ type: 'json', nullable: true })
   schedule: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  cron_type: string;
+  @Column({ type: 'int', nullable: true })
+  sequence: number;
 }

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

@@ -0,0 +1,149 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { FilterEvaluatorService } from 'src/module/filter/service/filter-evaluator.service';
+import { DataSource } from 'typeorm';
+import { WorkflowAutomationEngineService } from './workflow-automation-engine.service';
+
+@Injectable()
+export class ScheduleHandlerService {
+  private readonly logger = new Logger(ScheduleHandlerService.name);
+
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly filterEvaluator: FilterEvaluatorService,
+    // @Inject('WorkflowAutomationEngineService')
+    private readonly workflowAutomationEngineService: WorkflowAutomationEngineService,
+  ) {}
+
+  async scheduleQueryBuilder(workflowId: number, jobData: any) {
+    // 1️⃣ Fetch workflow automation config
+    const [workflow] = await this.dataSource.query(
+      `SELECT * FROM frm_wf_automation WHERE id = ? AND organization_id = ?`,
+      [workflowId, jobData.organizationId],
+    );
+
+    if (!workflow) throw new Error(`Workflow with ID ${workflowId} not found`);
+
+    const event = JSON.parse(workflow.event_json || '{}');
+    const scheduleJson = workflow.schedule;
+    const entityType = workflow.applicable_entity_type;
+
+    // 2️⃣ Get table name from frm_entity_master
+    const [entity] = await this.dataSource.query(
+      `SELECT data_source FROM frm_entity_master WHERE mapped_entity_type = ? AND organization_id = ?`,
+      [entityType, jobData.organizationId],
+    );
+    if (!entity?.data_source) throw new Error(`Entity ${entityType} not found`);
+
+    const tableName = entity.data_source;
+
+    // 3️⃣ Resolve executionDate (list master item name)
+    const [executionDateItem] = await this.dataSource.query(
+      `SELECT name FROM frm_list_master_items WHERE id = ${scheduleJson.executionDate}`
+    );
+    const executionDateName = executionDateItem?.name?.toLowerCase() || '';
+    const executionDataOrTime = scheduleJson.executionDateOrTime;
+
+    const executionUnits = Number(scheduleJson.executionDateUnits || 0);
+    const fixedTime = scheduleJson.fixedTime; // e.g. "16:00"
+
+    // Build time window logic
+    let comparisonDateCondition = '';
+
+    if (executionDateName.includes('after')) {
+      comparisonDateCondition = `
+    ${executionDataOrTime} >= CURDATE() + INTERVAL ${executionUnits} DAY
+    AND ${executionDataOrTime} < CURDATE() + INTERVAL ${executionUnits + 1} DAY
+  `;
+    } else if (executionDateName.includes('before')) {
+      comparisonDateCondition = `
+    ${executionDataOrTime} >= CURDATE() - INTERVAL ${executionUnits + 1} DAY
+    AND ${executionDataOrTime} < CURDATE() - INTERVAL ${executionUnits} DAY
+  `;
+    } else if (executionDateName.includes('same')) {
+      comparisonDateCondition = `
+    ${executionDataOrTime} >= CURDATE()
+    AND ${executionDataOrTime} < CURDATE() + INTERVAL 1 DAY
+  `;
+    }
+
+    const query = `
+  SELECT *
+  FROM ${tableName}
+  WHERE ${comparisonDateCondition}
+    AND organization_id = ?
+`;
+
+    this.logger.debug(`Executing Scheduler Query: ${query}`);
+
+    const results = await this.dataSource.query(query, [
+      jobData.organizationId,
+    ]);
+
+    this.logger.log(
+      `Found ${results.length} scheduled records for ${tableName}`,
+    );
+
+    return { results, workflow, tableName };
+  }
+
+  // ⚙️ Step 2: Handle scheduled automation (main entry point)
+  async handleScheduledWorkflow(workflowId: number, jobData: any) {
+    const { results, workflow, tableName } = await this.scheduleQueryBuilder(
+      workflowId,
+      jobData,
+    );
+
+    if (!results?.length) {
+      this.logger.warn(`No records found for scheduled workflow ${workflowId}`);
+      return;
+    }
+
+    this.logger.log(
+      `Processing ${results.length} records for workflow ${workflowId}`,
+    );
+
+    // Parse the workflow event JSON again to get filter/action info
+    const event = JSON.parse(workflow.event_json || '{}');
+    const filter = workflow.condition_filter_code;
+    const mappedEntityType = workflow.applicable_entity_type;
+
+    const matchedEntities: any[] = [];
+
+    // 🔁 Step 2A: Evaluate criteria for each record
+    for (const record of results) {
+      const entityIdToUse = record.id; // assuming 'id' column in the table
+      const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
+        mappedEntityType,
+        filter,
+        entityIdToUse,
+        jobData,
+      );
+
+      this.logger.debug(
+        `⚖️ Criteria check for entity ${entityIdToUse} -> ${criteriaMatched}`,
+      );
+
+      if (criteriaMatched) {
+        matchedEntities.push(record);
+      }
+    }
+
+    // 🧮 Step 3: Execute workflow actions for matched entities
+    if (!matchedEntities.length) {
+      this.logger.log(`No records passed criteria for workflow ${workflowId}`);
+      return;
+    }
+
+    this.logger.log(
+      `✅ ${matchedEntities.length} entities passed criteria, executing actions...`,
+    );
+
+    for (const entity of matchedEntities) {
+      await this.workflowAutomationEngineService.executeActions(
+        workflowId,
+        entity,
+        jobData,
+      );
+    }
+  }
+}

package/src/module/workflow-automation/service/workflow-automation-engine.service.ts

@@ -145,7 +145,7 @@ export class WorkflowAutomationEngineService {
   }
   
 
-  private async executeActions(
+   async executeActions(
     workflow_automation_id: number,
     entity: any,
     user: any,

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

@@ -1,4 +1,10 @@
-import { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, Repository } from 'typeorm';
 import { WorkflowAutomation } from '../entity/workflow-automation.entity';
@@ -7,7 +13,9 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { UserData } from 'src/module/user/entity/user.entity';
 import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
 import { ENTITYTYPE_SAVEDFILTERMASTER } from 'src/constant/global.constant';
-import { app } from 'firebase-admin';
+import { ScheduledWorkflow } from 'src/module/workflow-schedule/entities/scheduled-workflow.entity';
+import { WorkflowScheduleService } from 'src/module/workflow-schedule/service/workflow-schedule.service';
+import * as moment from 'moment';
 
 @Injectable()
 export class WorkflowAutomationService extends EntityServiceImpl {
@@ -20,6 +28,9 @@ export class WorkflowAutomationService extends EntityServiceImpl {
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
     private readonly dataSource: DataSource,
+    @InjectRepository(ScheduledWorkflow)
+    private readonly scheduledWorkflowRepository: Repository<ScheduledWorkflow>,
+    private readonly workflowScheduleService: WorkflowScheduleService,
   ) {
     super();
   }
@@ -131,11 +142,13 @@ export class WorkflowAutomationService extends EntityServiceImpl {
       if (event.triggerType === 'on_schedule') {
         // just store JSON directly into schedule column
         workflow.schedule = event?.scheduleJson ?? null;
+        workflow.trigger_type = 'on_schedule';
         this.logger.log(
           `Stored schedule JSON for workflow ${workflow.id}: ${JSON.stringify(
             workflow.schedule,
           )}`,
         );
+        await this.registerScheduleAutomation(workflow, loggedInUser);
       }
 
       workflow.trigger_type = event.triggerType;
@@ -344,4 +357,152 @@ export class WorkflowAutomationService extends EntityServiceImpl {
     this.logger.debug(`Fetched WorkflowAutomation (id=${id}) with relations`);
     return response;
   }
+
+  async registerScheduleAutomation(workflow: any, loggedInUser: UserData) {
+    this.logger.log(
+      `Registering schedule automation for workflow ${workflow.id}`,
+    );
+
+    const scheduleJson = workflow.schedule;
+    if (!scheduleJson) {
+      this.logger.warn(`No schedule JSON provided for workflow ${workflow.id}`);
+      return;
+    }
+
+    // Try to find an existing scheduled workflow by workflow_id
+    const existingSchedule = await this.scheduledWorkflowRepository.findOne({
+      where: { workflow_id: workflow.id },
+    });
+
+    const cronExpression = await this.generateDailyCron(scheduleJson.fixedTime);
+
+    const payload = {
+      workflow_id: workflow.id,
+      workflow_name: workflow.name,
+      name: scheduleJson.name ?? `Schedule_${workflow.id}`,
+      description: scheduleJson.description ?? '',
+      cron_expression: cronExpression,
+      timezone: scheduleJson.timezone ?? 'Asia/Kolkata',
+      start_date: scheduleJson.start_date ?? null,
+      end_date: scheduleJson.end_date ?? null,
+      max_executions: scheduleJson.max_executions ?? null,
+      retry_config: scheduleJson.retry_config ?? {},
+      actions: scheduleJson.actions ?? [],
+      metadata: scheduleJson.metadata ?? {},
+      is_enabled: scheduleJson.is_enabled ?? true,
+      organization_id: loggedInUser.organization_id,
+      enterprise_id: loggedInUser.enterprise_id,
+      level_id: loggedInUser.level_id,
+      level_type: loggedInUser.level_type,
+      appcode: loggedInUser.appcode,
+    };
+
+    if (existingSchedule) {
+      this.logger.log(
+        `Existing schedule found (id=${existingSchedule.id}), updating...`,
+      );
+      payload['id'] = existingSchedule.id;
+      // return await this.workflowScheduleService.updateSchedule(payload, loggedInUser);
+    } else {
+      this.logger.log(`No existing schedule found, creating new one...`);
+      return await this.workflowScheduleService.createSchedule(
+        payload,
+        loggedInUser,
+      );
+    }
+  }
+
+  // CRON
+
+  async generateDailyCron(executionTime: string): Promise<string> {
+    const time = moment(executionTime, 'HH:mm');
+
+    if (!time.isValid()) {
+      throw new Error('Invalid executionTime format (expected HH:mm)');
+    }
+
+    const minute = time.minute();
+    const hour = time.hour();
+
+    // Ensure cron has 5 fields: minute hour day month weekday
+    const cron = `${minute} ${hour} * * *`;
+
+    // ✅ Validate against your regex before returning
+    const cronRegex =
+      /^(\*|([0-5]?\d)) (\*|([01]?\d|2[0-3])) (\*|([01]?\d|2\d|3[01])) (\*|([1-9]|1[0-2])) (\*|([0-6]))$/;
+    if (!cronRegex.test(cron)) {
+      throw new Error(
+        `Generated cron expression "${cron}" does not match expected format`,
+      );
+    }
+
+    return '*/1 * * * *';
+  }
+  /**
+   * Updates the sequence of multiple workflow automations.
+   */
+  async updateSequence(
+    body: any[],
+    loggedInUser: any,
+  ): Promise<{ updated: number; results: any[] }> {
+    if (!Array.isArray(body) || body.length === 0) {
+      throw new BadRequestException(
+        'Invalid input. Expected a non-empty array.',
+      );
+    }
+
+    const results: {
+      id: number | string | null;
+      success: boolean;
+      result?: any;
+      error?: string;
+    }[] = [];
+
+    for (const item of body) {
+      const { id, sequence } = item;
+
+      // Validate required fields
+      if (!id || sequence === undefined || sequence === null) {
+        results.push({
+          id: id || null,
+          success: false,
+          error: 'Missing id or sequence',
+        });
+        continue;
+      }
+
+      try {
+        // Check if workflow exists
+        const existing = await this.wfRepo.findOne({ where: { id } });
+        if (!existing) {
+          results.push({
+            id,
+            success: false,
+            error: `Workflow with id ${id} not found`,
+          });
+          continue;
+        }
+
+        // Update sequence + audit fields
+        existing.sequence = Number(sequence);
+        existing.modified_by =
+          loggedInUser?.id || loggedInUser?.user_id || null;
+        existing.modified_date = new Date();
+
+        const saved = await this.wfRepo.save(existing);
+        results.push({ id, success: true, result: saved });
+      } catch (err) {
+        results.push({
+          id,
+          success: false,
+          error: err.message || 'Unknown error occurred',
+        });
+      }
+    }
+
+    return {
+      updated: results.filter((r) => r.success).length,
+      results,
+    };
+  }
 }

package/src/module/workflow-automation/workflow-automation.module.ts

@@ -9,12 +9,17 @@ import { WorkflowAutomationService } from './service/workflow-automation.service
 import { WorkflowAutomationActionEntity } from './entity/workflow-automation-action.entity';
 import { EntityModule } from '../meta/entity.module';
 import { ActionRegistryService } from './service/action-registery.service';
+import { ScheduleHandlerService } from './service/schedule-handler.service';
+import { ScheduledWorkflow } from '../workflow-schedule/entities/scheduled-workflow.entity';
+import { WorkflowExecutionLog } from '../workflow-schedule/entities/workflow-execution-log.entity';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       WorkflowAutomation,
       WorkflowAutomationActionEntity,
+      ScheduledWorkflow, // 👈 Required by WorkflowAutomationService
+      WorkflowExecutionLog, // 👈 May be used by services
     ]),
     FilterModule,
     forwardRef(() => EntityModule),
@@ -26,9 +31,17 @@ import { ActionRegistryService } from './service/action-registery.service';
       provide: 'WorkflowAutomationService',
       useClass: WorkflowAutomationService,
     },
+    {
+      provide: 'ScheduleHandlerService',
+      useClass: ScheduleHandlerService,
+    },
     ActionRegistryService, // 👈 auto-registers actions
   ],
-  exports: [WorkflowAutomationEngineService, 'WorkflowAutomationService'],
+  exports: [
+    WorkflowAutomationEngineService,
+    'WorkflowAutomationService',
+    'ScheduleHandlerService',
+  ],
   controllers: [WorkflowAutomationController],
 })
 export class WorkflowAutomationModule {}