rez_core 2.2.258 → 2.2.259

package/src/module/integration/controller/integration.controller.ts

@@ -0,0 +1,411 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { IntegrationService } from '../service/integration.service';
+import {
+  BulkMessageDto,
+  CreateConfigDto,
+  CreateUserIntegrationDto,
+  GenericSendMessageDto,
+  SendGridTemplatesDto,
+  SendGridVerifiedSendersDto,
+  UpdateConfigDto,
+  UpdateUserIntegrationDto,
+} from '../dto/create-config.dto';
+
+export class ScheduledMessageDto extends GenericSendMessageDto {
+  scheduleFor: Date;
+  timezone?: string;
+}
+
+@Controller('integration')
+export class IntegrationController {
+  constructor(private readonly integrationService: IntegrationService) {}
+
+  @Post('send')
+  @HttpCode(HttpStatus.OK)
+  async sendMessage(@Body() sendMessageDto: GenericSendMessageDto) {
+    return this.integrationService.sendGenericMessage(sendMessageDto);
+  }
+
+  @Post('send/bulk')
+  @HttpCode(HttpStatus.OK)
+  async sendBulkMessage(@Body() bulkMessageDto: BulkMessageDto) {
+    return this.integrationService.sendBulkMessage(bulkMessageDto);
+  }
+
+  @Post('send/scheduled')
+  @HttpCode(HttpStatus.OK)
+  async scheduleMessage(@Body() scheduledMessageDto: ScheduledMessageDto) {
+    return this.integrationService.scheduleMessage(scheduledMessageDto);
+  }
+
+  @Post('send/template')
+  @HttpCode(HttpStatus.OK)
+  async sendTemplateMessage(
+    @Body()
+    templateMessage: {
+      levelId: number;
+      levelType: string;
+      app_code: string;
+      to: string | string[];
+      templateId: string;
+      variables: Record<string, any>;
+      type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+    },
+  ) {
+    return this.integrationService.sendTemplateMessage(templateMessage);
+  }
+
+  @Post('config')
+  @HttpCode(HttpStatus.OK)
+  async createConfig(@Body() createConfigDto: CreateConfigDto) {
+    try {
+      const result = await this.integrationService.createIntegrationConfig(
+        createConfigDto.levelId,
+        createConfigDto.levelType,
+        createConfigDto.app_code,
+        createConfigDto.integration_type as
+          | 'EMAIL'
+          | 'SMS'
+          | 'WA'
+          | 'TELEPHONE',
+        createConfigDto.integration_provider,
+        createConfigDto.integration_source_id,
+        createConfigDto.config,
+        createConfigDto.priority,
+        createConfigDto.is_default,
+      );
+
+      return result;
+    } catch (error) {
+      // Handle validation errors with BadRequest status
+      if (
+        error.message?.includes('active') &&
+        error.message?.includes('configuration already exists')
+      ) {
+        throw new BadRequestException({
+          success: false,
+          error: 'DUPLICATE_CONFIGURATION',
+          message: error.message,
+          code: 'VALIDATION_ERROR',
+        });
+      }
+
+      // Handle unsupported combination errors
+      if (error.message?.includes('Unsupported combination')) {
+        throw new BadRequestException({
+          success: false,
+          error: 'UNSUPPORTED_COMBINATION',
+          message: error.message,
+          code: 'VALIDATION_ERROR',
+        });
+      }
+
+      // Handle OAuth redirect responses (return as success with OAuth info)
+      if (error.authUrl && error.state) {
+        return {
+          success: false,
+          requiresOAuth: true,
+          authUrl: error.authUrl,
+          state: error.state,
+          message: error.message || 'OAuth authorization required',
+        };
+      }
+
+      // Handle other errors as BadRequest
+      throw new BadRequestException({
+        success: false,
+        error: 'CONFIGURATION_ERROR',
+        message:
+          error.message || 'Failed to create communication configuration',
+        code: 'INTERNAL_ERROR',
+      });
+    }
+  }
+
+  @Get('supported-combinations')
+  async getSupportedCombinations() {
+    return this.integrationService.getSupportedCombinations();
+  }
+
+  @Get('level/:id/:type/configs')
+  async getLevelConfigs(
+    @Param('id', ParseIntPipe) levelId: number,
+    @Param('type') levelType: string,
+    @Query('app_code') app_code?: string,
+    @Query('communication_config_type')
+    configType?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE',
+    @Query('provider') provider?: string,
+  ) {
+    return this.integrationService.getLevelConfigs(levelId, levelType, {
+      app_code,
+      integration_type: configType,
+      integration_provider: provider,
+    });
+  }
+
+  @Get('config/:id')
+  async getIntegrationConfigById(@Param('id', ParseIntPipe) hubId: number) {
+    try {
+      const config =
+        await this.integrationService.getIntegrationConfigById(hubId);
+
+      if (!config) {
+        throw new BadRequestException({
+          success: false,
+          error: 'NOT_FOUND',
+          message: 'Communication configuration not found',
+          code: 'CONFIGURATION_NOT_FOUND',
+        });
+      }
+
+      return {
+        success: true,
+        data: config,
+      };
+    } catch (error) {
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+
+      throw new BadRequestException({
+        success: false,
+        error: 'FETCH_ERROR',
+        message: error.message || 'Failed to fetch communication configuration',
+        code: 'INTERNAL_ERROR',
+      });
+    }
+  }
+
+  @Post('config/:id/update')
+  @HttpCode(HttpStatus.OK)
+  async activateConfig(
+    @Param('id', ParseIntPipe) hubId: number,
+    @Query('status') status: string,
+  ) {
+    try {
+      const statusNumber = parseInt(status, 10);
+      if (isNaN(statusNumber) || (statusNumber !== 0 && statusNumber !== 1)) {
+        throw new BadRequestException('Status must be 0 or 1');
+      }
+
+      await this.integrationService.updateConfigStatus(hubId, statusNumber);
+      return {
+        success: true,
+        message: 'Configuration updated successfully',
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'UPDATE_STATUS_ERROR',
+      });
+    }
+  }
+
+  @Post('sendgrid/verified-senders')
+  @HttpCode(HttpStatus.OK)
+  async getSendGridVerifiedSenders(@Body() dto: SendGridVerifiedSendersDto) {
+    return this.integrationService.getSendGridVerifiedSenders(dto.apiKey);
+  }
+
+  @Post('sendgrid/templates')
+  @HttpCode(HttpStatus.OK)
+  async getSendGridTemplates(@Body() dto: SendGridTemplatesDto) {
+    return this.integrationService.getSendGridTemplates(
+      dto.levelId,
+      dto.levelType,
+      dto.app_code,
+    );
+  }
+
+  @Post('config/delete/:configId')
+  @HttpCode(HttpStatus.OK)
+  async disconnectConfig(@Param('configId', ParseIntPipe) configId: number) {
+    try {
+      await this.integrationService.deleteConfiguration(configId);
+
+      return {
+        success: true,
+        message: 'Communication configuration deleted successfully',
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'DELETE_ERROR',
+        message:
+          error.message || 'Failed to delete communication configuration',
+        code: 'CONFIGURATION_ERROR',
+      });
+    }
+  }
+
+  @Post('config/update/:hubId')
+  @HttpCode(HttpStatus.OK)
+  async updateConfig(
+    @Param('hubId', ParseIntPipe) hubId: number,
+    @Body() updateDto: UpdateConfigDto,
+  ) {
+    try {
+      const result = await this.integrationService.updateConfiguration(
+        hubId,
+        updateDto,
+      );
+
+      return {
+        success: true,
+        message: 'Communication configuration updated successfully',
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'UPDATE_ERROR',
+        message:
+          error.message || 'Failed to update communication configuration',
+        code: 'CONFIGURATION_ERROR',
+      });
+    }
+  }
+
+  // UserIntegration Management Endpoints
+
+  @Post('user-integration')
+  @HttpCode(HttpStatus.OK)
+  async createUserIntegration(@Body() createDto: CreateUserIntegrationDto) {
+    try {
+      const result =
+        await this.integrationService.createUserIntegration(createDto);
+      return {
+        success: true,
+        message: 'User integration mapping created successfully',
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'CREATE_USER_INTEGRATION_ERROR',
+        message: error.message || 'Failed to create user integration mapping',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+
+  @Get('user-integration/user/:userId')
+  async getUserIntegrations(@Param('userId', ParseIntPipe) userId: number) {
+    try {
+      const result = await this.integrationService.getUserIntegrations(userId);
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_USER_INTEGRATIONS_ERROR',
+        message: error.message || 'Failed to fetch user integrations',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+
+  @Get('user-integration/config/:configId')
+  async getConfigUserIntegrations(
+    @Param('configId', ParseIntPipe) configId: number,
+  ) {
+    try {
+      const result =
+        await this.integrationService.getConfigUserIntegrations(configId);
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_CONFIG_USER_INTEGRATIONS_ERROR',
+        message: error.message || 'Failed to fetch config user integrations',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+
+  @Post('user-integration/:id')
+  @HttpCode(HttpStatus.OK)
+  async updateUserIntegration(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() updateDto: UpdateUserIntegrationDto,
+  ) {
+    try {
+      const result = await this.integrationService.updateUserIntegration(
+        id,
+        updateDto,
+      );
+      return {
+        success: true,
+        message: 'User integration mapping updated successfully',
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'UPDATE_USER_INTEGRATION_ERROR',
+        message: error.message || 'Failed to update user integration mapping',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+
+  @Post('user-integration/:id')
+  @HttpCode(HttpStatus.OK)
+  async deleteUserIntegration(@Param('id', ParseIntPipe) id: number) {
+    try {
+      await this.integrationService.deleteUserIntegration(id);
+      return {
+        success: true,
+        message: 'User integration mapping deleted successfully',
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'DELETE_USER_INTEGRATION_ERROR',
+        message: error.message || 'Failed to delete user integration mapping',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+
+  @Get('user-integration/:userId/:configId')
+  async getUserIntegrationByUserAndConfig(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Param('configId', ParseIntPipe) configId: number,
+  ) {
+    try {
+      const result =
+        await this.integrationService.getUserIntegrationByUserAndConfig(
+          userId,
+          configId,
+        );
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_USER_INTEGRATION_ERROR',
+        message: error.message || 'Failed to fetch user integration mapping',
+        code: 'USER_INTEGRATION_ERROR',
+      });
+    }
+  }
+}

package/src/module/{communication → integration}/dto/create-config.dto.ts

@@ -4,11 +4,9 @@ import {
   IsString,
   IsObject,
   IsOptional,
-  IsEnum,
   IsIn,
   IsBoolean,
 } from 'class-validator';
-import { CommunicationConfigType } from '../entity/communication-hub.entity';
 
 export class CreateConfigDto {
   @IsNotEmpty()
@@ -20,28 +18,20 @@ export class CreateConfigDto {
   levelType: string;
 
   @IsNotEmpty()
-  @IsEnum(CommunicationConfigType)
-  configType: CommunicationConfigType;
+  @IsString()
+  app_code: string;
 
   @IsNotEmpty()
   @IsString()
-  @IsIn(['API', 'THIRD_PARTY', 'SMTP'])
-  service: string;
+  integration_type: string;
 
   @IsNotEmpty()
   @IsString()
-  @IsIn([
-    'gmail',
-    'outlook',
-    'whatsapp',
-    'twilio',
-    'aws-ses',
-    'sendgrid',
-    'custom',
-    'generic',
-    'knowlarity',
-  ])
-  provider: string;
+  integration_provider: string;
+
+  @IsNotEmpty()
+  @IsNumber()
+  integration_source_id: number;
 
   @IsNotEmpty()
   @IsObject()
@@ -195,6 +185,10 @@ export class GenericSendMessageDto {
   @IsString()
   levelType: string;
 
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
   @IsNotEmpty()
   to: string | string[];
 
@@ -202,6 +196,10 @@ export class GenericSendMessageDto {
   @IsString()
   message: string;
 
+  @IsOptional()
+  @IsNumber()
+  user_id?: number;
+
   @IsOptional()
   @IsString()
   subject?: string;
@@ -249,6 +247,10 @@ export class BulkMessageDto {
   @IsString()
   levelType: string;
 
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
   @IsNotEmpty()
   recipients: string[];
 
@@ -256,6 +258,10 @@ export class BulkMessageDto {
   @IsString()
   message: string;
 
+  @IsOptional()
+  @IsNumber()
+  user_id?: number;
+
   @IsOptional()
   @IsString()
   subject?: string;
@@ -294,6 +300,10 @@ export class GmailOAuthInitDto {
   @IsString()
   levelType: string;
 
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
   @IsOptional()
   @IsString()
   email?: string;
@@ -318,6 +328,10 @@ export class OutlookOAuthInitDto {
   @IsString()
   levelType: string;
 
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
   @IsOptional()
   @IsString()
   email?: string;
@@ -337,6 +351,10 @@ export class SendGridTemplatesDto {
   @IsNotEmpty()
   @IsString()
   levelType: string;
+
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
 }
 
 export class VerifiedSenderDto {
@@ -381,3 +399,77 @@ export class TemplatesResponseDto {
   @IsString()
   error?: string;
 }
+
+export class CreateUserIntegrationDto {
+  @IsNotEmpty()
+  @IsNumber()
+  user_id: number;
+
+  @IsNotEmpty()
+  @IsNumber()
+  integration_config_id: number;
+
+  @IsOptional()
+  @IsString()
+  external_user_id?: string;
+
+  @IsOptional()
+  @IsObject()
+  external_user_data?: {
+    // Ozonetel agent mapping (admin creds like userName, campaignName stay in config)
+    agentId?: string;
+    agentEmail?: string;
+    agentPhone?: string;
+
+    // Tubelight agent mapping (admin creds like userName/password stay in config)
+    agentNumber?: string;
+    extension?: string;
+    department?: string;
+
+    // Common agent fields (no admin credentials stored here)
+    displayName?: string;
+    role?: string;
+    skillLevel?: string;
+    metadata?: any;
+    [key: string]: any;
+  };
+
+  @IsOptional()
+  @IsBoolean()
+  is_active?: boolean;
+}
+
+export class UpdateUserIntegrationDto {
+  @IsOptional()
+  @IsString()
+  external_user_id?: string;
+
+  @IsOptional()
+  @IsObject()
+  external_user_data?: {
+    // Ozonetel agent mapping (admin creds like userName, campaignName stay in config)
+    agentId?: string;
+    agentEmail?: string;
+    agentPhone?: string;
+
+    // Tubelight agent mapping (admin creds like userName/password stay in config)
+    agentNumber?: string;
+    extension?: string;
+    department?: string;
+
+    // Common agent fields (no admin credentials stored here)
+    displayName?: string;
+    role?: string;
+    skillLevel?: string;
+    metadata?: any;
+    [key: string]: any;
+  };
+
+  @IsOptional()
+  @IsNumber()
+  status?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  is_active?: boolean;
+}

package/src/module/{communication/entity/communication-config.entity.ts → integration/entity/integration-config.entity.ts}

@@ -5,16 +5,40 @@ import {
   CreateDateColumn,
   UpdateDateColumn,
 } from 'typeorm';
-import { IsNotEmpty, IsObject } from 'class-validator';
 
-@Entity({ name: 'cr_communication_config' })
-export class CommunicationConfig {
+@Entity({ name: 'cr_integration_config' })
+export class IntegrationConfig {
   @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
   id: number;
 
+  @Column({ name: 'app_code', type: 'varchar', length: 100 })
+  app_code: string;
+
+  @Column({ name: 'integration_type', type: 'varchar', length: 20 })
+  integration_type: string;
+
+  @Column({ name: 'integration_provider', type: 'varchar', length: 100 })
+  integration_provider: string;
+
+  @Column({ name: 'integration_source_id', type: 'int' })
+  integration_source_id: number;
+
+  @Column({ name: 'level_id', type: 'int' })
+  level_id: number;
+
+  @Column({ name: 'level_type', type: 'varchar', length: 100 })
+  level_type: string;
+
+  @Column({ name: 'status', type: 'tinyint', default: 1 })
+  status: number;
+
+  @Column({ name: 'priority', type: 'int', default: 1 })
+  priority: number;
+
+  @Column({ name: 'is_default', type: 'boolean', default: false })
+  is_default: boolean;
+
   @Column({ name: 'config_json', type: 'json' })
-  @IsNotEmpty()
-  @IsObject()
   config_json: {
     // Gmail Config
     clientId?: string;
@@ -63,6 +87,9 @@ export class CommunicationConfig {
     voiceMessage?: string;
     language?: string;
 
+    // User Integration
+    external_user_id?: string;
+
     // Common fields
     subject?: string;
     html?: string;
@@ -83,4 +110,4 @@ export class CommunicationConfig {
     type: 'datetime',
   })
   updated_at: Date;
-}
+}

package/src/module/{communication → integration}/entity/integration-source.entity.ts

@@ -2,7 +2,7 @@ import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'cr_integration_master' })
-export class IntegrationConfig extends BaseEntity {
+export class IntegrationSource extends BaseEntity {
   @Column({ name: 'logo', type: 'varchar', length: 100 })
   logo: string;