rez_core 2.2.253 → 2.2.255

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.2.253",
+  "version": "2.2.255",
   "description": "",
   "author": "",
   "private": false,

package/src/module/communication/communication.module.ts

@@ -22,6 +22,7 @@ import { KnowlarityStrategy as KnowlaritySMSStrategy } from './strategies/sms/kn
 import { WhatsAppCloudStrategy } from './strategies/whatsapp/whatsapp-cloud.strategy';
 import { KnowlarityVoiceStrategy } from './strategies/telephone/knowlarity-voice.strategy';
 import { OzonetelVoiceStrategy } from './strategies/telephone/ozonetel-voice.strategy';
+import { TubelightVoiceStrategy } from './strategies/telephone/tubelight-voice.strategy';
 
 // New unified strategies
 import { OutlookStrategy } from './strategies/email/outlook.strategy';
@@ -75,6 +76,7 @@ import { WebhookController } from './controller/webhook.controller';
     WhatsAppCloudStrategy,
     KnowlarityVoiceStrategy,
     OzonetelVoiceStrategy,
+    TubelightVoiceStrategy,
 
     // New unified strategies
     OutlookStrategy,

package/src/module/communication/factories/telephone.factory.ts

@@ -3,12 +3,14 @@ import { BaseFactory } from './base.factory';
 import { CommunicationStrategy } from '../strategies/communication.strategy';
 import { KnowlarityStrategy as TelephoneKnowlarityStrategy } from '../strategies/telephone/knowlarity-multi.strategy';
 import { OzonetelVoiceStrategy } from '../strategies/telephone/ozonetel-voice.strategy';
+import { TubelightVoiceStrategy } from '../strategies/telephone/tubelight-voice.strategy';
 
 @Injectable()
 export class TelephoneFactory implements BaseFactory {
   constructor(
     private knowlarityStrategy: TelephoneKnowlarityStrategy,
     private ozonetelVoiceStrategy: OzonetelVoiceStrategy,
+    private tubelightVoiceStrategy: TubelightVoiceStrategy,
   ) {}
 
   createProvider(service: string, provider: string): CommunicationStrategy {
@@ -19,6 +21,8 @@ export class TelephoneFactory implements BaseFactory {
         return this.knowlarityStrategy;
       case 'third_party_ozonetel':
         return this.ozonetelVoiceStrategy;
+      case 'third_party_tubelight':
+        return this.tubelightVoiceStrategy;
 
       default:
         throw new Error(
@@ -30,7 +34,8 @@ export class TelephoneFactory implements BaseFactory {
   getSupportedCombinations(): Array<{ service: string; provider: string }> {
     return [
       { service: 'THIRD_PARTY', provider: 'knowlarity' },
-      { service: 'THIRD_PARTY', provider: 'ozonetel' }
+      { service: 'THIRD_PARTY', provider: 'ozonetel' },
+      { service: 'THIRD_PARTY', provider: 'tubelight' }
     ];
   }
 

package/src/module/communication/strategies/telephone/tubelight-voice.strategy.ts

@@ -0,0 +1,122 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import {
+  CommunicationResult,
+  CommunicationStrategy,
+} from '../communication.strategy';
+
+interface TubelightVoiceConfig {
+  userName: string;
+  password: string;
+  agentVerificationKey: string;
+  tenantId: string;
+  agentLoginUrl?: string;
+}
+
+@Injectable()
+export class TubelightVoiceStrategy implements CommunicationStrategy {
+  private readonly baseUrl = 'https://portal.tubelightcommunications.com/voice/api/v1';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: TubelightVoiceConfig,
+  ): Promise<CommunicationResult> {
+    if (!this.validateConfig(config)) {
+      return {
+        success: false,
+        provider: 'tubelight',
+        service: 'THIRD_PARTY',
+        error: 'Invalid Tubelight Voice configuration',
+        timestamp: new Date(),
+      };
+    }
+
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        return {
+          success: false,
+          provider: 'tubelight',
+          service: 'THIRD_PARTY',
+          error: 'Failed to authenticate with Tubelight',
+          timestamp: new Date(),
+        };
+      }
+
+      const url = `${this.baseUrl}/user/sso/agent/outbound-call`;
+      await axios.post(
+        url,
+        {
+          agentVerificationKey: config.agentVerificationKey,
+          customerNumber: to,
+        },
+        {
+          headers: {
+            'X-TENANT-ID': config.tenantId,
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
+        },
+      );
+
+      return {
+        success: true,
+        messageId: `tubelight-voice-${Date.now()}`,
+        provider: 'tubelight',
+        service: 'THIRD_PARTY',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      let errorMsg = 'Unknown error';
+      if (axios.isAxiosError(error)) {
+        errorMsg = error.response?.data?.message || error.message;
+      } else if (error instanceof Error) {
+        errorMsg = error.message;
+      }
+      return {
+        success: false,
+        provider: 'tubelight',
+        service: 'THIRD_PARTY',
+        error: errorMsg,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private async authenticate(
+    config: TubelightVoiceConfig,
+  ): Promise<string | null> {
+    try {
+      const response = await axios.post(
+        `${this.baseUrl}/auth/login`,
+        {
+          user_name: config.userName,
+          password: config.password,
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            'X-TENANT-ID': config.tenantId,
+          },
+        },
+      );
+
+      const data = response.data as { bearer_token?: string; access_token?: string; token?: string };
+      return data?.bearer_token || data?.access_token || data?.token || null;
+    } catch (error) {
+      console.error('Failed to authenticate with Tubelight:', error);
+      return null;
+    }
+  }
+
+  validateConfig(config: Partial<TubelightVoiceConfig>): boolean {
+    return !!(
+      config &&
+      config.userName &&
+      config.password &&
+      config.agentVerificationKey &&
+      config.tenantId
+    );
+  }
+}

package/src/module/meta/controller/entity.controller.ts

@@ -142,47 +142,47 @@ export class EntityController {
     @Req() req: Request & { user: any },
   ) {
     const loggedInUser = req.user.userData;
-    const appcode = req.user.userData.appcode;
-
+    const appcode = loggedInUser.appcode;
+  
     if (!entityType) {
-      throw new BadRequestException(
-        `Query parameter "entity_type" is required`,
-      );
+      throw new BadRequestException(`Query parameter "entity_type" is required`);
     }
-
+  
     const entityMaster = await this.entityMasterService.getEntityData(
       entityType,
       loggedInUser,
     );
-    const entityService =
-      await this.reflectionHelper.getBean<EntityServiceImpl>(
-        entityMaster.entity_service,
-      );
-
+  
+    const entityService = await this.reflectionHelper.getBean<EntityServiceImpl>(
+      entityMaster.entity_service,
+    );
+  
     if (!entityService) {
       throw new InternalServerErrorException(
-        `No service found for Entity Type ${entityType}`,
+        `No service found for entity_type "${entityType}"`,
       );
     }
-
-    let savedData = await entityService.createEntity(
+  
+    // ✅ Create
+    const savedData = await entityService.createEntity(
       entityData,
       loggedInUser as UserData,
       null,
       appcode,
     );
-
+  
+    // ✅ Run workflow automation (no preUpdateStates for CREATE)
     await this.workflowAutomationEngineService.handleEntityEvent(
-      entityData.entity_type,
+      entityType,
       'CREATE',
       savedData,
-      null,
       loggedInUser,
+      null,
     );
-
+  
     return savedData;
   }
-
+  
   @Post('update/:id')
   @HttpCode(200)
   async update(
@@ -192,58 +192,67 @@ export class EntityController {
     @Req() req: Request & { user: any },
   ) {
     const loggedInUser = req.user.userData;
-
+  
     if (!entityType) {
-      throw new BadRequestException(
-        'Query parameter "entity_type" is required',
-      );
+      throw new BadRequestException('Query parameter "entity_type" is required');
     }
-
+  
     const entityMaster = await this.entityMasterService.getEntityData(
       entityType,
       loggedInUser,
     );
-
-    const entityService =
-      await this.reflectionHelper.getBean<EntityServiceImpl>(
-        entityMaster.entity_service,
-      );
-
+  
+    const entityService = await this.reflectionHelper.getBean<EntityServiceImpl>(
+      entityMaster.entity_service,
+    );
+  
     if (!entityService) {
       throw new InternalServerErrorException(
         `No service found for entity_type "${entityType}"`,
       );
     }
-
+  
+    // 1️⃣ Get old state
     const existingEntity = await entityService.getEntityData(
       entityType,
       id,
       loggedInUser,
     );
-
     if (!existingEntity) {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
-
-    let updatedData = await entityService.updateEntity(
+  
+    // 2️⃣ Pre-evaluate criteria
+    const workflows = await this.workflowAutomationEngineService['wfService'].getActiveRules(
+      entityType,
+      'UPDATE',
+    );
+    const preUpdateStates: Record<number, boolean> = {};
+    for (const wf of workflows) {
+      preUpdateStates[wf.id] = await this.workflowAutomationEngineService[
+        'filterEvaluator'
+      ].evaluateCriteria(entityType, wf.condition_filter_code, existingEntity.id, loggedInUser);
+    }
+  
+    // 3️⃣ Update
+    const updatedData = await entityService.updateEntity(
       entityData,
       loggedInUser as UserData,
     );
-
+  
+    // 4️⃣ Run workflow automation (pass preUpdateStates)
     await this.workflowAutomationEngineService.handleEntityEvent(
-      entityData.entity_type,
+      entityType,
       'UPDATE',
       updatedData,
-      existingEntity,
       loggedInUser,
+      preUpdateStates,
     );
-
+  
     return updatedData;
-    // return {
-    //   success: true,
-    //   data: updatedEntity,
-    // };
   }
+  
+  
 
   @Post('delete/:id')
   @HttpCode(200)

package/src/module/user/service/user.service.ts

@@ -31,7 +31,8 @@ import { Action } from 'src/module/workflow-automation/interface/action.interfac
 import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
 
 @Injectable()
-export class UserService extends EntityServiceImpl {
+@ActionHandler('User')  
+export class UserService extends EntityServiceImpl implements Action {
   constructor(
     private userRepository: UserRepository,
     private userRoleMappingService: UserRoleMappingService,

package/src/module/workflow/entity/action-data.entity.ts

@@ -46,4 +46,7 @@ export class ActionDataEntity extends BaseEntity {
 
   @Column({ nullable: true, default: 0 })
   resubmit_count: number;
+
+  @Column({ type: 'int', nullable: true })
+  dependent_action_id: number;
 }

package/src/module/workflow/entity/action.entity.ts

@@ -38,4 +38,7 @@ export class ActionEntity extends BaseEntity {
 
   @Column({ type: 'boolean', nullable: true })
   is_template: boolean;
+
+  @Column({ type: 'int', nullable: true })
+  dependent_action_id: number;
 }

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

@@ -20,59 +20,86 @@ export class WorkflowAutomationEngineService {
 
   /**
    * Called from entity hooks (CREATE / UPDATE / DELETE)
+   * @param preUpdateStates optional, used for UPDATE events to pass pre-update criteria results
    */
-  async handleEntityEvent(entityType, eventType, newEntity, oldEntity, user) {
-    const workflows = await this.wfService.getActiveRules(
-      entityType,
-      eventType,
-    );
-
+  async handleEntityEvent(
+    entityType: string,
+    eventType: 'CREATE' | 'UPDATE' | 'DELETE',
+    newEntity: any,
+    user: any,
+    preUpdateStates?: Record<number, boolean> | null,
+  ) {
+    const workflows = await this.wfService.getActiveRules(entityType, eventType);
+  
     for (const wf of workflows) {
-      const eventMatched = await this.filterEvaluator.evaluateTriggerAttributes(
-        oldEntity,
-        newEntity,
-        wf.condition_filter_code,
+      // Step 1️⃣ Condition / Trigger evaluation
+      let triggerMatched = false;
+  
+      if (eventType === 'CREATE') {
+        triggerMatched = await this.filterEvaluator.evaluateCriteria(
+          entityType,
+          wf.condition_filter_code,
+          newEntity.id,
+          user,
+        );
+      } else if (eventType === 'UPDATE' && preUpdateStates) {
+        const before = preUpdateStates[wf.id] ?? false;
+        const after = await this.filterEvaluator.evaluateCriteria(
+          entityType,
+          wf.condition_filter_code,
+          newEntity.id,
+          user,
+        );
+        triggerMatched = before !== after && after === true;
+      }
+  
+      // 🔍 Log Step 1 result
+      console.log(
+        `[Workflow:${wf.id}] Step 1 - Trigger matched:`,
+        triggerMatched,
       );
-      console.log(eventMatched, 'eventMatched');
-      if (!eventMatched) continue;
-
+  
+      if (!triggerMatched) continue;
+  
+      // Step 2️⃣ Final criteria evaluation
       const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
         entityType,
         wf.criteria_filter_code,
         newEntity.id,
         user,
       );
-      console.log(criteriaMatched, 'criteriaMatched');
+  
+      // 🔍 Log Step 2 result
+      console.log(
+        `[Workflow:${wf.id}] Step 2 - Criteria matched:`,
+        criteriaMatched,
+      );
+  
       if (!criteriaMatched) continue;
-
+  
+      // Step 3️⃣ Execute workflow actions
       await this.executeActions(wf.id, newEntity, user);
     }
   }
+  
 
   private async executeActions(
     workflow_automation_id: number,
     entity: any,
     user: any,
   ) {
-    // 1. Load actions for this rule from DB
-    const actions = await this.wfService.getActionsForRule(
-      workflow_automation_id,
-    );
+    // Load actions for this rule from DB
+    const actions = await this.wfService.getActionsForRule(workflow_automation_id);
     console.log(actions, 'actions found');
-    // (this should fetch from cr_workflow_automation_action)
 
     for (const action of actions) {
       const impl = this.actions.get(String(action.action_decorator)); // action_code = registered name
       if (!impl) {
-        console.warn(
-          `⚠️ No implementation found for action: ${action.action_decorator}`,
-        );
+        console.warn(`⚠️ No implementation found for action: ${action.action_decorator}`);
         continue;
       }
 
-      console.log(
-        `🚀 Executing action ${action.action_decorator} for entity ${entity.id}`,
-      );
+      console.log(`🚀 Executing action ${action.action_decorator} for entity ${entity.id}`);
       await impl.execute({ entity, user, config: action.payload });
     }
   }