rez_core 3.1.22 → 3.1.24

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

@@ -0,0 +1,419 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationResult,
+  IntegrationStrategy,
+} from '../integration.strategy';
+
+interface TubelightWhatsAppConfig {
+  userName: string;
+  password: string;
+  tenantId: string;
+  baseUrl?: string;
+  sourceNumber?: string;
+}
+
+interface TubelightMessage {
+  to: string;
+  message: string;
+  messageType?: string;
+  mediaUrl?: string;
+  caption?: string;
+  filename?: string;
+  templateId?: string;
+  templateParams?: any[];
+}
+
+interface TubelightApiResponse {
+  success: boolean;
+  messageId?: string;
+  id?: string;
+  status?: string;
+  message?: string;
+  error?: string;
+  details?: string;
+}
+
+@Injectable()
+export class TubelightWhatsAppStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(TubelightWhatsAppStrategy.name);
+  private readonly defaultBaseUrl =
+    'https://portal.tubelightcommunications.com/whatsapp/api/v1';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Tubelight WhatsApp configuration');
+      }
+
+      const tubelightConfig = config as TubelightWhatsAppConfig;
+      const token = await this.authenticate(tubelightConfig);
+
+      if (!token) {
+        throw new Error('Failed to authenticate with Tubelight');
+      }
+
+      const baseUrl = tubelightConfig.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/messages/send`;
+
+      const payload = this.prepareMessagePayload(to, message, config);
+
+      const response: AxiosResponse<TubelightApiResponse> = await axios.post(
+        url,
+        payload,
+        {
+          headers: {
+            'X-TENANT-ID': tubelightConfig.tenantId,
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
+          timeout: 30000,
+        },
+      );
+
+      if (
+        response.data?.success &&
+        (response.data?.messageId || response.data?.id)
+      ) {
+        const messageId = response.data.messageId || response.data.id;
+        this.logger.log(
+          `Tubelight WhatsApp message sent successfully to ${to}, messageId: ${messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: messageId,
+          provider: 'tubelight',
+          service: 'API',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(
+          response.data?.error ||
+            response.data?.message ||
+            'Invalid response from Tubelight API',
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send Tubelight WhatsApp message to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'tubelight',
+        service: 'API',
+        error: this.extractErrorMessage(error),
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private async authenticate(
+    config: TubelightWhatsAppConfig,
+  ): Promise<string | null> {
+    try {
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const authUrl = baseUrl.replace('/whatsapp/api/v1', '/auth/api/v1');
+
+      const response = await axios.post(
+        `${authUrl}/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;
+        success?: boolean;
+      };
+
+      if (data.success !== false) {
+        return data?.bearer_token || data?.access_token || data?.token || null;
+      }
+
+      return null;
+    } catch (error) {
+      this.logger.error(
+        'Failed to authenticate with Tubelight:',
+        error.response?.data || error.message,
+      );
+      return null;
+    }
+  }
+
+  private prepareMessagePayload(to: string, message: string, config: any): any {
+    const basePayload = {
+      to: this.formatPhoneNumber(to),
+      from: config.sourceNumber || config.from,
+    };
+
+    // Handle different message types based on config
+    if (config.messageType) {
+      switch (config.messageType) {
+        case 'template':
+          return {
+            ...basePayload,
+            messageType: 'TEMPLATE',
+            templateId: config.templateId,
+            templateParams: config.templateParams || [],
+            language: config.templateLanguage || 'en',
+          };
+
+        case 'image':
+          return {
+            ...basePayload,
+            messageType: 'IMAGE',
+            mediaUrl: config.mediaUrl,
+            caption: message || config.caption || '',
+          };
+
+        case 'document':
+          return {
+            ...basePayload,
+            messageType: 'DOCUMENT',
+            mediaUrl: config.mediaUrl,
+            filename: config.filename || 'document',
+            caption: message || config.caption || '',
+          };
+
+        case 'audio':
+          return {
+            ...basePayload,
+            messageType: 'AUDIO',
+            mediaUrl: config.mediaUrl,
+          };
+
+        case 'video':
+          return {
+            ...basePayload,
+            messageType: 'VIDEO',
+            mediaUrl: config.mediaUrl,
+            caption: message || config.caption || '',
+          };
+
+        case 'location':
+          return {
+            ...basePayload,
+            messageType: 'LOCATION',
+            latitude: config.latitude,
+            longitude: config.longitude,
+            name: config.locationName || '',
+            address: config.locationAddress || '',
+          };
+
+        case 'interactive':
+          return {
+            ...basePayload,
+            messageType: 'INTERACTIVE',
+            interactiveType: config.interactiveType || 'button',
+            text: message,
+            buttons: config.buttons || [],
+            sections: config.sections || [],
+            header: config.header,
+            footer: config.footer,
+          };
+
+        default:
+          // Fall back to text message
+          break;
+      }
+    }
+
+    // Default text message
+    return {
+      ...basePayload,
+      messageType: 'TEXT',
+      text: message,
+    };
+  }
+
+  private formatPhoneNumber(phoneNumber: string): string {
+    // Remove any non-digit characters except +
+    let formatted = phoneNumber.replace(/[^\d+]/g, '');
+
+    // If it doesn't start with +, assume it needs country code
+    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.response?.data?.details) {
+      return error.response.data.details;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return 'Unknown Tubelight API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (!config.userName || !config.password || !config.tenantId) {
+      return false;
+    }
+
+    // Validate message type specific requirements
+    if (config.messageType) {
+      switch (config.messageType) {
+        case 'template':
+          if (!config.templateId) {
+            return false;
+          }
+          break;
+
+        case 'image':
+        case 'document':
+        case 'audio':
+        case 'video':
+          if (!config.mediaUrl) {
+            return false;
+          }
+          break;
+
+        case 'location':
+          if (
+            typeof config.latitude !== 'number' ||
+            typeof config.longitude !== 'number'
+          ) {
+            return false;
+          }
+          break;
+
+        case 'interactive':
+          if (
+            !config.buttons &&
+            !config.sections &&
+            (!config.interactiveType ||
+              !['button', 'list'].includes(config.interactiveType))
+          ) {
+            return false;
+          }
+          break;
+      }
+    }
+
+    return true;
+  }
+
+  async getAccountInfo(config: TubelightWhatsAppConfig): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/account/info`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Tubelight account info',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get account info: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async getTemplates(config: TubelightWhatsAppConfig): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/templates`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Tubelight templates',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get templates: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async getMessageStatus(
+    config: TubelightWhatsAppConfig,
+    messageId: string,
+  ): Promise<any> {
+    try {
+      const token = await this.authenticate(config);
+      if (!token) {
+        throw new Error('Authentication failed');
+      }
+
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/messages/${messageId}/status`;
+
+      const response = await axios.get(url, {
+        headers: {
+          'X-TENANT-ID': config.tenantId,
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get message status',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get message status: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+}

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;
+  }
+}