rez_core 4.0.184 → 4.0.186

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

@@ -1,662 +1,662 @@
-import {
-  BadRequestException,
-  Body,
-  Controller,
-  Get,
-  HttpCode,
-  HttpStatus,
-  Param,
-  ParseIntPipe,
-  Post,
-  Query,
-  Req,
-  UseGuards,
-} from '@nestjs/common';
-import { IntegrationService } from '../service/integration.service';
-import {
-  BulkMessageDto,
-  CheckAgentStatusDto,
-  CreateConfigDto,
-  CreateUserIntegrationDto,
-  GenericSendMessageDto,
-  GetIntegrationTemplatesDto,
-  SendGridTemplatesDto,
-  SendGridVerifiedSendersDto,
-  UpdateConfigDto,
-  UpdateUserIntegrationDto,
-} from '../dto/create-config.dto';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-
-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) {
-    try {
-      return await this.integrationService.sendGenericMessage(sendMessageDto);
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'SEND_MESSAGE_ERROR',
-        message: error.message || 'Failed to send message',
-        code: 'MESSAGE_SEND_ERROR',
-      });
-    }
-  }
-
-  @Post('send/bulk')
-  @HttpCode(HttpStatus.OK)
-  async sendBulkMessage(@Body() bulkMessageDto: BulkMessageDto) {
-    try {
-      return await this.integrationService.sendBulkMessage(bulkMessageDto);
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'SEND_BULK_MESSAGE_ERROR',
-        message: error.message || 'Failed to send bulk messages',
-        code: 'BULK_MESSAGE_SEND_ERROR',
-      });
-    }
-  }
-
-  @Post('send/scheduled')
-  @HttpCode(HttpStatus.OK)
-  async scheduleMessage(@Body() scheduledMessageDto: ScheduledMessageDto) {
-    try {
-      return await this.integrationService.scheduleMessage(scheduledMessageDto);
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'SCHEDULE_MESSAGE_ERROR',
-        message: error.message || 'Failed to schedule message',
-        code: 'MESSAGE_SCHEDULE_ERROR',
-      });
-    }
-  }
-
-  @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';
-    },
-  ) {
-    try {
-      return await this.integrationService.sendTemplateMessage(templateMessage);
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'SEND_TEMPLATE_MESSAGE_ERROR',
-        message: error.message || 'Failed to send template message',
-        code: 'TEMPLATE_MESSAGE_SEND_ERROR',
-      });
-    }
-  }
-
-  @Post('check-agent-status')
-  @HttpCode(HttpStatus.OK)
-  async checkAgentStatus(@Body() checkAgentStatusDto: CheckAgentStatusDto) {
-    try {
-      const result = await this.integrationService.checkAgentStatus(
-        checkAgentStatusDto.levelId,
-        checkAgentStatusDto.levelType,
-        checkAgentStatusDto.app_code,
-        checkAgentStatusDto.user_id,
-        checkAgentStatusDto.type || 'TELEPHONE',
-      );
-
-      return result;
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'CHECK_AGENT_STATUS_ERROR',
-        message: error.message || 'Failed to check agent status',
-        code: 'AGENT_STATUS_ERROR',
-      });
-    }
-  }
-
-  @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() {
-    try {
-      return await this.integrationService.getSupportedCombinations();
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_COMBINATIONS_ERROR',
-        message: error.message || 'Failed to get supported combinations',
-        code: 'FETCH_ERROR',
-      });
-    }
-  }
-
-  @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,
-  ) {
-    try {
-      return await this.integrationService.getLevelConfigs(levelId, levelType, {
-        app_code,
-        integration_type: configType,
-        integration_provider: provider,
-      });
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_LEVEL_CONFIGS_ERROR',
-        message: error.message || 'Failed to get level configurations',
-        code: 'FETCH_ERROR',
-      });
-    }
-  }
-
-  @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) {
-    try {
-      return await this.integrationService.getSendGridVerifiedSenders(dto.apiKey);
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_SENDGRID_SENDERS_ERROR',
-        message: error.message || 'Failed to get SendGrid verified senders',
-        code: 'SENDGRID_ERROR',
-      });
-    }
-  }
-
-  @Post('sendgrid/templates')
-  @HttpCode(HttpStatus.OK)
-  async getSendGridTemplates(@Body() dto: SendGridTemplatesDto) {
-    try {
-      return await this.integrationService.getSendGridTemplates(
-        dto.levelId,
-        dto.levelType,
-        dto.app_code,
-      );
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_SENDGRID_TEMPLATES_ERROR',
-        message: error.message || 'Failed to get SendGrid templates',
-        code: 'SENDGRID_ERROR',
-      });
-    }
-  }
-
-  @Post('templates')
-  @HttpCode(HttpStatus.OK)
-  async getIntegrationTemplates(@Body() dto: GetIntegrationTemplatesDto) {
-    try {
-      return await this.integrationService.getIntegrationTemplates(
-        dto.levelId,
-        dto.levelType,
-        dto.app_code,
-        dto.integration_type,
-      );
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_TEMPLATES_ERROR',
-        message: error.message || 'Failed to get templates',
-        code: 'INTEGRATION_TEMPLATES_ERROR',
-      });
-    }
-  }
-
-  @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',
-      });
-    }
-  }
-
-  @Post('user-integration/bulk')
-  @HttpCode(HttpStatus.OK)
-  async bulkCreateUserIntegration(@Body() userIntegrations: CreateUserIntegrationDto[]) {
-    try {
-      const result =
-        await this.integrationService.bulkCreateUserIntegration({ user_integrations: userIntegrations });
-      return {
-        success: true,
-        message: `Bulk user integration completed: ${result.summary.created} created, ${result.summary.updated} updated, ${result.summary.failed} failed`,
-        data: result,
-      };
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'BULK_CREATE_USER_INTEGRATION_ERROR',
-        message: error.message || 'Failed to bulk create user integration mappings',
-        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/delete/: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',
-      });
-    }
-  }
-
-  @Get('getAll')
-  @UseGuards(JwtAuthGuard)
-  async getAllIntegration(
-    @Req() req: Request & { user: any },
-    @Query('integration_type')
-    integration_type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-  ) {
-    try {
-      const loggedInUser = req.user.userData;
-
-      const allIntegrationData =
-        await this.integrationService.getAllIntegrationData(
-          loggedInUser,
-          integration_type,
-        );
-
-      return allIntegrationData;
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_ALL_INTEGRATIONS_ERROR',
-        message: error.message || 'Failed to get all integrations',
-        code: 'FETCH_ERROR',
-      });
-    }
-  }
-
-  @Get('provider-urls')
-  getProviderUrls(
-    @Query('integration_type')
-    integration_type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    @Query('integration_provider') integration_provider?: string,
-  ) {
-    if (integration_type === 'TELEPHONE' && integration_provider) {
-      if (integration_provider.toLowerCase() == 'ozonetel') {
-        return {
-          success: true,
-          data: {
-            baseUrl: 'https://in1-ccaas-api.ozonetel.com',
-            agentLoginUrl: 'https://agent.cloudagent.ozonetel.com/login',
-          },
-        };
-      } else if (integration_provider.toLowerCase() == 'tubelight') {
-        return {
-          success: true,
-          data: {
-            baseUrl: 'https://portal.tubelightcommunications.com',
-            agentLoginUrl: 'https://dashboard.hellotubelight.com/sign-in',
-          },
-        };
-      }
-    } else if (integration_type === 'WA' && integration_provider) {
-      if (integration_provider.toLowerCase() == 'tubelight') {
-        return {
-          success: true,
-          data: {
-            baseUrl: 'https://portal.tubelightcommunications.com',
-            agentLoginUrl: 'https://dashboard.hellotubelight.com/sign-in',
-          },
-        };
-      } else if (integration_provider.toLowerCase() == 'gupshup') {
-        return {
-          success: true,
-          data: {
-            baseUrl: 'https://api.gupshup.io',
-            agentLoginUrl: 'https://login.gupshup.io/u/login',
-          },
-        };
-      }
-    }
-  }
-
-  @Get('active-config')
-  async getActiveConfig(
-    @Query('level_id', ParseIntPipe) levelId: number,
-    @Query('level_type') levelType: string,
-    @Query('app_code') appCode: string,
-    @Query('integration_type')
-    integrationType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-  ) {
-    try {
-      const config = await this.integrationService.getSingleActiveConfig(
-        levelId,
-        levelType,
-        appCode,
-        integrationType,
-      );
-
-      if (!config) {
-        return {
-          success: false,
-          message: 'No active configuration found',
-          data: null,
-        };
-      }
-
-      return {
-        success: true,
-        data: config,
-      };
-    } catch (error) {
-      throw new BadRequestException({
-        success: false,
-        error: 'GET_ACTIVE_CONFIG_ERROR',
-        message: error.message || 'Failed to fetch active configuration',
-        code: 'FETCH_ERROR',
-      });
-    }
-  }
-}
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { IntegrationService } from '../service/integration.service';
+import {
+  BulkMessageDto,
+  CheckAgentStatusDto,
+  CreateConfigDto,
+  CreateUserIntegrationDto,
+  GenericSendMessageDto,
+  GetIntegrationTemplatesDto,
+  SendGridTemplatesDto,
+  SendGridVerifiedSendersDto,
+  UpdateConfigDto,
+  UpdateUserIntegrationDto,
+} from '../dto/create-config.dto';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+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) {
+    try {
+      return await this.integrationService.sendGenericMessage(sendMessageDto);
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'SEND_MESSAGE_ERROR',
+        message: error.message || 'Failed to send message',
+        code: 'MESSAGE_SEND_ERROR',
+      });
+    }
+  }
+
+  @Post('send/bulk')
+  @HttpCode(HttpStatus.OK)
+  async sendBulkMessage(@Body() bulkMessageDto: BulkMessageDto) {
+    try {
+      return await this.integrationService.sendBulkMessage(bulkMessageDto);
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'SEND_BULK_MESSAGE_ERROR',
+        message: error.message || 'Failed to send bulk messages',
+        code: 'BULK_MESSAGE_SEND_ERROR',
+      });
+    }
+  }
+
+  @Post('send/scheduled')
+  @HttpCode(HttpStatus.OK)
+  async scheduleMessage(@Body() scheduledMessageDto: ScheduledMessageDto) {
+    try {
+      return await this.integrationService.scheduleMessage(scheduledMessageDto);
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'SCHEDULE_MESSAGE_ERROR',
+        message: error.message || 'Failed to schedule message',
+        code: 'MESSAGE_SCHEDULE_ERROR',
+      });
+    }
+  }
+
+  @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';
+    },
+  ) {
+    try {
+      return await this.integrationService.sendTemplateMessage(templateMessage);
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'SEND_TEMPLATE_MESSAGE_ERROR',
+        message: error.message || 'Failed to send template message',
+        code: 'TEMPLATE_MESSAGE_SEND_ERROR',
+      });
+    }
+  }
+
+  @Post('check-agent-status')
+  @HttpCode(HttpStatus.OK)
+  async checkAgentStatus(@Body() checkAgentStatusDto: CheckAgentStatusDto) {
+    try {
+      const result = await this.integrationService.checkAgentStatus(
+        checkAgentStatusDto.levelId,
+        checkAgentStatusDto.levelType,
+        checkAgentStatusDto.app_code,
+        checkAgentStatusDto.user_id,
+        checkAgentStatusDto.type || 'TELEPHONE',
+      );
+
+      return result;
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'CHECK_AGENT_STATUS_ERROR',
+        message: error.message || 'Failed to check agent status',
+        code: 'AGENT_STATUS_ERROR',
+      });
+    }
+  }
+
+  @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() {
+    try {
+      return await this.integrationService.getSupportedCombinations();
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_COMBINATIONS_ERROR',
+        message: error.message || 'Failed to get supported combinations',
+        code: 'FETCH_ERROR',
+      });
+    }
+  }
+
+  @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,
+  ) {
+    try {
+      return await this.integrationService.getLevelConfigs(levelId, levelType, {
+        app_code,
+        integration_type: configType,
+        integration_provider: provider,
+      });
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_LEVEL_CONFIGS_ERROR',
+        message: error.message || 'Failed to get level configurations',
+        code: 'FETCH_ERROR',
+      });
+    }
+  }
+
+  @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) {
+    try {
+      return await this.integrationService.getSendGridVerifiedSenders(dto.apiKey);
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_SENDGRID_SENDERS_ERROR',
+        message: error.message || 'Failed to get SendGrid verified senders',
+        code: 'SENDGRID_ERROR',
+      });
+    }
+  }
+
+  @Post('sendgrid/templates')
+  @HttpCode(HttpStatus.OK)
+  async getSendGridTemplates(@Body() dto: SendGridTemplatesDto) {
+    try {
+      return await this.integrationService.getSendGridTemplates(
+        dto.levelId,
+        dto.levelType,
+        dto.app_code,
+      );
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_SENDGRID_TEMPLATES_ERROR',
+        message: error.message || 'Failed to get SendGrid templates',
+        code: 'SENDGRID_ERROR',
+      });
+    }
+  }
+
+  @Post('templates')
+  @HttpCode(HttpStatus.OK)
+  async getIntegrationTemplates(@Body() dto: GetIntegrationTemplatesDto) {
+    try {
+      return await this.integrationService.getIntegrationTemplates(
+        dto.levelId,
+        dto.levelType,
+        dto.app_code,
+        dto.integration_type,
+      );
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_TEMPLATES_ERROR',
+        message: error.message || 'Failed to get templates',
+        code: 'INTEGRATION_TEMPLATES_ERROR',
+      });
+    }
+  }
+
+  @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',
+      });
+    }
+  }
+
+  @Post('user-integration/bulk')
+  @HttpCode(HttpStatus.OK)
+  async bulkCreateUserIntegration(@Body() userIntegrations: CreateUserIntegrationDto[]) {
+    try {
+      const result =
+        await this.integrationService.bulkCreateUserIntegration({ user_integrations: userIntegrations });
+      return {
+        success: true,
+        message: `Bulk user integration completed: ${result.summary.created} created, ${result.summary.updated} updated, ${result.summary.failed} failed`,
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'BULK_CREATE_USER_INTEGRATION_ERROR',
+        message: error.message || 'Failed to bulk create user integration mappings',
+        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/delete/: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',
+      });
+    }
+  }
+
+  @Get('getAll')
+  @UseGuards(JwtAuthGuard)
+  async getAllIntegration(
+    @Req() req: Request & { user: any },
+    @Query('integration_type')
+    integration_type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ) {
+    try {
+      const loggedInUser = req.user.userData;
+
+      const allIntegrationData =
+        await this.integrationService.getAllIntegrationData(
+          loggedInUser,
+          integration_type,
+        );
+
+      return allIntegrationData;
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_ALL_INTEGRATIONS_ERROR',
+        message: error.message || 'Failed to get all integrations',
+        code: 'FETCH_ERROR',
+      });
+    }
+  }
+
+  @Get('provider-urls')
+  getProviderUrls(
+    @Query('integration_type')
+    integration_type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    @Query('integration_provider') integration_provider?: string,
+  ) {
+    if (integration_type === 'TELEPHONE' && integration_provider) {
+      if (integration_provider.toLowerCase() == 'ozonetel') {
+        return {
+          success: true,
+          data: {
+            baseUrl: 'https://in1-ccaas-api.ozonetel.com',
+            agentLoginUrl: 'https://agent.cloudagent.ozonetel.com/login',
+          },
+        };
+      } else if (integration_provider.toLowerCase() == 'tubelight') {
+        return {
+          success: true,
+          data: {
+            baseUrl: 'https://portal.tubelightcommunications.com',
+            agentLoginUrl: 'https://dashboard.hellotubelight.com/sign-in',
+          },
+        };
+      }
+    } else if (integration_type === 'WA' && integration_provider) {
+      if (integration_provider.toLowerCase() == 'tubelight') {
+        return {
+          success: true,
+          data: {
+            baseUrl: 'https://portal.tubelightcommunications.com',
+            agentLoginUrl: 'https://dashboard.hellotubelight.com/sign-in',
+          },
+        };
+      } else if (integration_provider.toLowerCase() == 'gupshup') {
+        return {
+          success: true,
+          data: {
+            baseUrl: 'https://api.gupshup.io',
+            agentLoginUrl: 'https://login.gupshup.io/u/login',
+          },
+        };
+      }
+    }
+  }
+
+  @Get('active-config')
+  async getActiveConfig(
+    @Query('level_id', ParseIntPipe) levelId: number,
+    @Query('level_type') levelType: string,
+    @Query('app_code') appCode: string,
+    @Query('integration_type')
+    integrationType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ) {
+    try {
+      const config = await this.integrationService.getSingleActiveConfig(
+        levelId,
+        levelType,
+        appCode,
+        integrationType,
+      );
+
+      if (!config) {
+        return {
+          success: false,
+          message: 'No active configuration found',
+          data: null,
+        };
+      }
+
+      return {
+        success: true,
+        data: config,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_ACTIVE_CONFIG_ERROR',
+        message: error.message || 'Failed to fetch active configuration',
+        code: 'FETCH_ERROR',
+      });
+    }
+  }
+}