rez_core 2.3.2 → 2.3.4

package/src/module/integration/strategies/sms/tubelight-sms.strategy.ts

@@ -0,0 +1,163 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationStrategy,
+  IntegrationResult,
+} from '../integration.strategy';
+
+interface TubelightSmsConfig {
+  userName: string;
+  password: string;
+  tenantId: string;
+  sourceNumber: string;
+  baseUrl?: string;
+  senderId?: string;
+  dltTemplateId?: string;
+}
+
+interface TubelightSmsApiResponse {
+  status: string;
+  statusCode?: number;
+  messageId?: string;
+  data?: {
+    messageId: string;
+    status: string;
+  };
+  message?: string;
+  error?: string;
+}
+
+@Injectable()
+export class TubelightSmsStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(TubelightSmsStrategy.name);
+  private readonly defaultBaseUrl = 'https://portal.tubelightcommunications.com/sms/api/v1';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Tubelight SMS configuration');
+      }
+
+      const tubelightConfig = config as TubelightSmsConfig;
+      const baseUrl = tubelightConfig.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/send`;
+
+      // Create Basic Auth token
+      const authToken = Buffer.from(
+        `${tubelightConfig.userName}:${tubelightConfig.password}`,
+      ).toString('base64');
+
+      const payload = {
+        tenantId: tubelightConfig.tenantId,
+        from: tubelightConfig.senderId || tubelightConfig.sourceNumber,
+        to: this.formatPhoneNumber(to),
+        message: message,
+        dltTemplateId: tubelightConfig.dltTemplateId,
+      };
+
+      const response: AxiosResponse<TubelightSmsApiResponse> = await axios.post(
+        url,
+        payload,
+        {
+          headers: {
+            Authorization: `Basic ${authToken}`,
+            'Content-Type': 'application/json',
+          },
+          timeout: 30000,
+        },
+      );
+
+      if (
+        response.data?.status === 'success' ||
+        response.data?.statusCode === 200 ||
+        response.data?.data?.status === 'sent'
+      ) {
+        const messageId =
+          response.data?.messageId ||
+          response.data?.data?.messageId ||
+          new Date().getTime().toString();
+
+        this.logger.log(
+          `Tubelight SMS sent successfully to ${to}, messageId: ${messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: messageId,
+          provider: 'tubelight',
+          service: 'SMS',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(
+          response.data?.error ||
+            response.data?.message ||
+            'Failed to send SMS via Tubelight',
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send Tubelight SMS to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'tubelight',
+        service: 'SMS',
+        error: this.extractErrorMessage(error),
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private formatPhoneNumber(phoneNumber: string): string {
+    // Remove any non-digit characters except +
+    let formatted = phoneNumber.replace(/[^\d+]/g, '');
+
+    // Ensure it has + prefix
+    if (!formatted.startsWith('+')) {
+      formatted = `+${formatted}`;
+    }
+
+    return formatted;
+  }
+
+  private extractErrorMessage(error: any): string {
+    if (error.response?.data?.error) {
+      return error.response.data.error;
+    }
+
+    if (error.response?.data?.message) {
+      return error.response.data.message;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return 'Unknown Tubelight SMS API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (
+      !config.userName ||
+      !config.password ||
+      !config.tenantId ||
+      !config.sourceNumber
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/module/integration/strategies/telephone/ozonetel-voice.strategy.ts

@@ -16,6 +16,19 @@ interface OzonetelVoiceConfig {
   external_user_id?: string;
 }
 
+interface AgentDetailsResponse {
+  status: string;
+  message: Array<{
+    AgentId: string;
+    AgentName: string;
+    State: string;
+    PhoneNumber: string;
+    Skill: string;
+    Mode: string;
+    Since: string;
+  }>;
+}
+
 @Injectable()
 export class OzonetelVoiceStrategy implements IntegrationStrategy {
   private readonly baseUrl = 'https://in1-ccaas-api.ozonetel.com';
@@ -49,6 +62,19 @@ export class OzonetelVoiceStrategy implements IntegrationStrategy {
         };
       }
 
+      // Check agent status before making the call
+      const agentStatus = await this.checkAgentStatus(config, token);
+      if (!agentStatus.isReady) {
+        return {
+          success: false,
+          provider: 'ozonetel',
+          service: 'THIRD_PARTY',
+          error: agentStatus.error ||
+                 `Agent is not ready. Current state: ${agentStatus.state || 'Unknown'}. Please login to your agent dashboard.`,
+          timestamp: new Date(),
+        };
+      }
+
       // Then make the manual dial call
       const url = `${this.baseUrl}/ca_apis/AgentManualDial`;
 
@@ -56,7 +82,7 @@ export class OzonetelVoiceStrategy implements IntegrationStrategy {
         url,
         {
           userName: config.userName,
-          agentID: config.external_user_id || config.agentID,
+          agentID: config.external_user_id,
           campaignName: config.campaignName, // Always from config
           customerNumber: to,
           UCID: true,
@@ -95,7 +121,7 @@ export class OzonetelVoiceStrategy implements IntegrationStrategy {
     }
   }
 
-  private async generateToken(
+  async generateToken(
     config: OzonetelVoiceConfig,
   ): Promise<string | null> {
     try {
@@ -121,6 +147,53 @@ export class OzonetelVoiceStrategy implements IntegrationStrategy {
     }
   }
 
+  async checkAgentStatus(
+    config: OzonetelVoiceConfig,
+    token: string,
+  ): Promise<{ isReady: boolean; state?: string; error?: string }> {
+    try {
+      const url = `${this.baseUrl}/ca_apis/AgentDetails`;
+
+      const response = await axios.post<AgentDetailsResponse>(
+        url,
+        {
+          userName: config.userName,
+          agentId: config.external_user_id,
+        },
+        {
+          headers: {
+            apiKey: config.apiKey,
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
+        },
+      );
+
+      if (response.data?.status === 'success' && response.data?.message?.length > 0) {
+        const agentInfo = response.data.message[0];
+        const isReady = agentInfo.State?.toUpperCase() === 'READY';
+
+        return {
+          isReady,
+          state: agentInfo.State,
+        };
+      }
+
+      return {
+        isReady: false,
+        error: 'Failed to retrieve agent details',
+      };
+    } catch (error) {
+      console.error('Failed to check agent status:', error);
+      return {
+        isReady: false,
+        error: axios.isAxiosError(error)
+          ? error.response?.data?.message || error.message
+          : 'Unknown error checking agent status',
+      };
+    }
+  }
+
   validateConfig(config: Partial<OzonetelVoiceConfig>): boolean {
     return !!(
       config &&
@@ -133,24 +206,24 @@ export class OzonetelVoiceStrategy implements IntegrationStrategy {
   /**
    * Create configuration with user agent data merged with admin credentials
    * Admin credentials (apiKey, userName, campaignName) stay in base config
-   * Only agent-specific info (agentID) comes from user integration
+   * Only agent-specific info (external_user_id) comes from user integration
    */
   createUserSpecificConfig(
     baseConfig: Pick<
       OzonetelVoiceConfig,
       'apiKey' | 'userName' | 'campaignName' | 'agentLoginUrl'
     >,
-    userIntegrationData?: any,
+    externalUserId?: string,
   ): OzonetelVoiceConfig {
-    if (!userIntegrationData) {
+    if (!externalUserId) {
       throw new Error(
-        'User integration data is required for Ozonetel voice calls',
+        'External user ID is required for Ozonetel voice calls',
       );
     }
 
     return {
       ...baseConfig,
-      agentID: userIntegrationData.agentId,
+      external_user_id: externalUserId,
     };
   }
 }

package/src/module/mapper/controller/field-mapper.controller.ts

@@ -0,0 +1,19 @@
+import { Controller, Inject, Post, Query, Req, UseGuards } from '@nestjs/common';
+import { FieldMapperService } from '../service/field-mapper.service';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+
+@Controller('field-mapper')
+export class FieldMapperController {
+  constructor(@Inject('FieldMapperService') private readonly fieldMapperService: FieldMapperService) {
+  }
+
+  @Post('resolve')
+  @UseGuards(JwtAuthGuard)
+  async resolve(@Req() req: any, @Query('integration_component') integration_component: string,
+                @Query('parent_type') parent_type: string,
+                @Query('parent_id') parent_id: number) {
+    const loggedInUser = req.user.userData;
+    return this.fieldMapperService.resolveData(integration_component, parent_type, parent_id, loggedInUser);
+  }
+
+}

package/src/module/mapper/dto/field-mapper.dto.ts

@@ -0,0 +1,14 @@
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+export class FieldMapperDto extends BaseEntity {
+  integration_component: string;
+  action: string;
+  source_attribute: string;
+  destination_attribute: string;
+  destination_entity_type: string;
+  mapped_entity_type: string;
+  filter_code?: string;
+  filter_json?: any;
+
+}
+

package/src/module/mapper/entity/field-lovs.entity.ts

@@ -0,0 +1,21 @@
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'cr_field_lov_mapper' })
+export class FieldLovMapper extends BaseEntity {
+
+  constructor() {
+    super();
+    this.entity_type = 'FLOV';
+  }
+
+  @Column({ name: 'mapper_field_id'})
+  mapper_field_id: number; //1
+
+  @Column({ name: 'destination_attribute_value', type: 'varchar', length: 30 })
+  destination_attribute_value: string; //INDIA
+
+  @Column({ name: 'source_attribute_value', type: 'varchar', length: 30 })
+  source_attribute_value: string; //IND
+
+}

package/src/module/mapper/entity/field-mapper.entity.ts

@@ -0,0 +1,36 @@
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'cr_field_mapper' })
+export class FieldMapper extends BaseEntity {
+
+  constructor() {
+    super();
+    this.entity_type = 'FMAP';
+  }
+
+  @Column({ name: 'integration_component', type: 'varchar', length: 30 })
+  integration_component: string;
+
+  @Column({ name: 'action', type: 'varchar', length: 30 })
+  action: string;
+
+  @Column({ name: 'source_attribute', type: 'varchar', length: 30 })
+  source_attribute: string;
+
+  @Column({ name: 'destination_attribute', type: 'varchar', length: 30 })
+  destination_attribute: string;
+
+  @Column({ name: 'destination_entity_type', type: 'varchar', length: 30 })
+  destination_entity_type: string;
+
+  @Column({ name: 'mapped_entity_type', type: 'varchar', length: 30, nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ name: 'filter_code', type: 'varchar', length: 30, default: 'default' })
+  filter_code: string;
+
+  @Column({ name: 'is_lov_present', type: 'tinyint' })
+  is_lov_present: number;
+
+}

package/src/module/mapper/mapper.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { FieldMapper } from './entity/field-mapper.entity';
+import { FieldMapperService } from './service/field-mapper.service';
+import { FieldMapperRepository } from './repository/field-mapper.repository';
+import { FilterModule } from '../filter/filter.module';
+import { EntityModule } from '../meta/entity.module';
+import { FieldMapperController } from './controller/field-mapper.controller';
+import { FieldLovMapper } from './entity/field-lovs.entity';
+import { FieldLovsRepository } from './repository/field-lovs.repository';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([FieldMapper, FieldLovMapper]),
+    FilterModule,
+    EntityModule,
+  ],
+  providers: [
+    { provide: 'FieldMapperService', useClass: FieldMapperService },
+    FieldMapperRepository,
+    FieldLovsRepository,
+  ],
+  controllers: [FieldMapperController],
+})
+export class MapperModule {
+}

package/src/module/mapper/repository/field-lovs.repository.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FieldLovMapper } from '../entity/field-lovs.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class FieldLovsRepository {
+  constructor(@InjectRepository(FieldLovMapper) private readonly fieldLovMapperRepository: Repository<FieldLovMapper>) {
+  }
+
+  async findByMapperFieldIdAndSourceAttributeValue(mapper_field_id: number, source_attribute_value: string) {
+    return await this.fieldLovMapperRepository.findOne({
+      where: { mapper_field_id, source_attribute_value },
+    });
+  }
+
+  async findByMapperFieldIdAndDestinationAttributeValue(mapper_field_id: number, destination_attribute_value: string) {
+    return await this.fieldLovMapperRepository.findOne({
+      where: { mapper_field_id, destination_attribute_value },
+    })
+  }
+}

package/src/module/mapper/repository/field-mapper.repository.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FieldMapper } from '../entity/field-mapper.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class FieldMapperRepository {
+  constructor(
+    @InjectRepository(FieldMapper)
+    private readonly fieldMapperRepository: Repository<FieldMapper>,
+  ) {
+  }
+
+  async findByIntegrationComponentAndDestinationEntityType(integrationComponent: string, destinationEntityType: string) {
+    return await this.fieldMapperRepository.find({
+      where: { integration_component: integrationComponent, destination_entity_type: destinationEntityType },
+    });
+  }
+
+  async save(dto: Partial<FieldMapper>) {
+    return await this.fieldMapperRepository.save(dto);
+  }
+
+  async saveBulk(dtos: Partial<FieldMapper>[]) {
+    return await this.fieldMapperRepository.save(dtos);
+  }
+}

package/src/module/mapper/service/field-mapper.service.ts

@@ -0,0 +1,91 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { FieldMapperRepository } from '../repository/field-mapper.repository';
+import { FieldMapperDto } from '../dto/field-mapper.dto';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { UserData } from '../../user/entity/user.entity';
+import { SavedFilterService } from '../../filter/service/saved-filter.service';
+import { FieldLovsRepository } from '../repository/field-lovs.repository';
+
+@Injectable()
+export class FieldMapperService extends EntityServiceImpl {
+  constructor(
+    private readonly fieldMapperRepository: FieldMapperRepository,
+    @Inject('SavedFilterService') private readonly savedFilterService: SavedFilterService,
+    private readonly fieldLovsRepository: FieldLovsRepository,
+  ) {
+    super();
+  }
+
+  async createEntity(dto: FieldMapperDto, loggedInUser: UserData) {
+    if (dto.filter_json) {
+      const savedFilter = await this.savedFilterService.createEntity(dto.filter_json, loggedInUser);
+      dto.filter_code = savedFilter.code;
+    }
+    return super.createEntity(dto, loggedInUser);
+  }
+
+  async updateEntity(dto: FieldMapperDto, loggedInUser: UserData) {
+    if (dto.filter_json) {
+      const savedFilter = await this.savedFilterService.createEntity(dto.filter_json, loggedInUser);
+      dto.filter_code = savedFilter.code;
+    }
+    return super.updateEntity(dto, loggedInUser);
+  }
+
+  async createFieldMappers(dtos: FieldMapperDto[]) {
+    return await this.fieldMapperRepository.saveBulk(dtos);
+  }
+
+  async resolveData(
+    integration_component: string,
+    parent_type: string,
+    parent_id: number,
+    userData: UserData,
+  ) {
+    const fieldMappers =
+      await this.fieldMapperRepository.findByIntegrationComponentAndDestinationEntityType(
+        integration_component,
+        parent_type,
+      );
+    const result: Record<string, any> = {};
+
+    const inMemory: Record<string, Record<string, any>> = {};
+
+    for (const field of fieldMappers) {
+      const entityType = field.mapped_entity_type ? field.mapped_entity_type : field.destination_entity_type;
+      const filterCode = field.filter_code || 'default';
+      if (!inMemory[entityType]) {
+        inMemory[entityType] = {};
+      }
+      if (!inMemory[entityType][filterCode] && !field.mapped_entity_type) {
+        inMemory[entityType][filterCode] = await super.getResolvedEntityData(
+          entityType,
+          parent_id,
+          userData,
+        );
+      } else {
+        // TODO: Handle mapped_entity_type with filterCode
+        inMemory[entityType][filterCode] = {};
+      }
+      const entityData = inMemory[entityType][filterCode];
+      if (entityData) {
+        let value = entityData[field.destination_attribute];
+        if (field.is_lov_present) {
+          if (field.action === 'LOOKUP') {
+            let fieldLovMapper = await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(field.id, value);
+            if (fieldLovMapper) {
+              value = fieldLovMapper.source_attribute_value;
+            }
+          } else {
+            let fieldLovMapper = await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(field.id, value);
+            if (fieldLovMapper) {
+              value = fieldLovMapper.destination_attribute_value;
+            }
+          }
+        }
+        result[field.source_attribute] = value;
+      }
+    }
+    return result;
+  }
+}

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

@@ -41,4 +41,10 @@ export class ActionEntity extends BaseEntity {
 
   @Column({ type: 'int', nullable: true })
   dependent_action_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  mode: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  template: string;
 }