rez_core 4.0.82 → 4.0.84

package/src/module/integration/service/integration.service.ts

@@ -1,2621 +1,2621 @@
-import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, Not, Repository } from 'typeorm';
-import { ConfigService } from '@nestjs/config';
-import { google } from 'googleapis';
-import { IntegrationConfig } from '../entity/integration-config.entity';
-import { UserIntegration } from '../entity/user-integration.entity';
-import { IntegrationEntityMapper } from '../entity/integration-entity-mapper.entity';
-import { IntegrationFactory } from '../factories/integration.factory';
-import { IntegrationResult } from '../strategies/integration.strategy';
-import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
-import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
-import { IntegrationQueueService } from './integration-queue.service';
-import {
-  BulkMessageDto,
-  BulkCreateUserIntegrationDto,
-  CreateUserIntegrationDto,
-  UpdateUserIntegrationDto,
-} from '../dto/create-config.dto';
-import { FieldMapperService } from '../../mapper/service/field-mapper.service';
-import {
-  COMM_TEMPLATE,
-  ENTITYTYPE_MEDIA,
-} from '../../../constant/global.constant';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
-import { MediaDataService } from '../../meta/service/media-data.service';
-import axios from 'axios';
-
-export interface SendMessageDto {
-  levelId: number;
-  levelType: string;
-  app_code: string;
-  to: string;
-  message: string;
-  mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
-  priority?: number;
-  user_id?: number;
-}
-
-export interface GenericMessageDto {
-  levelId: number;
-  levelType: string;
-  app_code: string;
-  to: string | string[];
-  message: string;
-  subject?: string;
-  type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
-  priority?: 'high' | 'medium' | 'low';
-  cc?: string | string[];
-  bcc?: string | string[];
-  html?: string;
-  attachments?: any[];
-  mediaUrl?: string;
-  templateId?: string;
-  variables?: Record<string, any>;
-  user_id?: number;
-  entity_type?: string;
-  entity_id?: number;
-  organization_id?: number;
-  mapped_entities?: any;
-}
-
-export interface IntegrationConfigWithConfig extends IntegrationConfig {
-  config?: any;
-}
-
-interface GmailOAuthState {
-  levelId: number;
-  levelType: string;
-  app_code: string;
-  email?: string;
-  timestamp: number;
-}
-
-export interface GmailSSOResult {
-  hubId: number;
-  configId: number;
-}
-
-@Injectable()
-export class IntegrationService {
-  private readonly logger = new Logger(IntegrationService.name);
-  private readonly gmailOAuthStates = new Map<string, GmailOAuthState>();
-
-  constructor(
-    @InjectRepository(IntegrationConfig)
-    private readonly configRepository: Repository<IntegrationConfig>,
-    @InjectRepository(UserIntegration)
-    private readonly userIntegrationRepository: Repository<UserIntegration>,
-    @InjectRepository(IntegrationEntityMapper)
-    private readonly entityMapperRepository: Repository<IntegrationEntityMapper>,
-    private readonly dataSource: DataSource,
-    private readonly integrationFactory: IntegrationFactory,
-    private readonly gmailApiStrategy: GmailApiStrategy,
-    private readonly sendGridApiStrategy: SendGridApiStrategy,
-    private readonly configService: ConfigService,
-    private readonly mediaService: MediaDataService,
-    @Inject('FieldMapperService')
-    private readonly fieldMapperService: FieldMapperService,
-    private readonly entityService: EntityServiceImpl,
-    @Inject(forwardRef(() => IntegrationQueueService))
-    private readonly queueService?: IntegrationQueueService,
-  ) {}
-
-  private deriveServiceType(
-    integration_type: string,
-    integration_provider: string,
-    config_json: any,
-  ): string {
-    // All integrations use API only (no SMTP support)
-    return 'API';
-  }
-
-  async sendMessage({
-    levelId,
-    levelType,
-    app_code,
-    to,
-    message,
-    mode,
-    priority = 1,
-    user_id,
-  }: SendMessageDto): Promise<IntegrationResult> {
-    try {
-      // Get active communication configs for the level
-      const configs = await this.getActiveConfigs(
-        levelId,
-        levelType,
-        app_code,
-        mode,
-      );
-
-      if (!configs.length) {
-        throw new Error(
-          `No active communication configuration found for ${levelType} ${levelId}`,
-        );
-      }
-
-      // Sort by priority if provided
-      const sortedConfigs = this.sortConfigsByPriority(configs, priority);
-
-      // Try each config until one succeeds
-      for (const config of sortedConfigs) {
-        try {
-          const result = await this.sendViaConfig(config, to, message, user_id);
-          if (result.success) {
-            this.logger.log(
-              `Message sent successfully via ${config.integration_provider}`,
-            );
-            return result;
-          }
-
-          this.logger.warn(
-            `Failed to send via ${config.integration_provider}: ${result.error}`,
-          );
-        } catch (error) {
-          this.logger.error(
-            `Error sending via ${config.integration_provider}:`,
-            error.message,
-          );
-          continue;
-        }
-      }
-
-      throw new Error('All communication providers failed');
-    } catch (error) {
-      this.logger.error('Communication service error:', error.message);
-      throw error;
-    }
-  }
-
-  async getActiveConfigs(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-  ): Promise<IntegrationConfig[]> {
-    const queryBuilder = this.configRepository
-      .createQueryBuilder('config')
-      .where('config.level_id = :levelId', { levelId })
-      .andWhere('config.level_type = :levelType', { levelType })
-      .andWhere('config.app_code = :app_code', { app_code })
-      .andWhere('config.status = 1');
-
-    if (mode) {
-      queryBuilder.andWhere('config.integration_type = :mode', { mode });
-    }
-
-    return await queryBuilder.getMany();
-  }
-
-  async getSingleActiveConfig(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-  ): Promise<IntegrationConfig | null> {
-    const configs = await this.configRepository
-      .createQueryBuilder('config')
-      .where('config.level_id = :levelId', { levelId })
-      .andWhere('config.level_type = :levelType', { levelType })
-      .andWhere('config.app_code = :app_code', { app_code })
-      .andWhere('config.integration_type = :integration_type', {
-        integration_type,
-      })
-      .andWhere('config.status = 1')
-      .orderBy('config.is_default', 'DESC')
-      .addOrderBy('config.priority', 'ASC')
-      .addOrderBy('config.created_at', 'DESC')
-      .getMany();
-
-    return configs.length > 0 ? configs[0] : null;
-  }
-
-  async getAllIntegrationData(
-    loggedInUser,
-    integration_type?: string,
-  ): Promise<any[]> {
-    try {
-      const allIntegrationData = await this.dataSource.query(
-        `SELECT *
-         FROM frm_integration_master`,
-      );
-
-      // if entityType is provided, filter the results
-      if (integration_type) {
-        return allIntegrationData.filter(
-          (data) =>
-            data.integration_type.toLowerCase() ===
-            integration_type.toLowerCase(),
-        );
-      }
-
-      return allIntegrationData;
-    } catch (error) {
-      this.logger.error('Error fetching integration data:', error.message);
-      return [];
-    }
-  }
-
-  private sortConfigsByPriority(
-    configs: IntegrationConfig[],
-    _priority: number,
-  ): IntegrationConfig[] {
-    return configs.sort((a, b) => {
-      // First sort by default (true comes first)
-      if (a.is_default !== b.is_default) {
-        return a.is_default ? -1 : 1;
-      }
-      // Then by priority (lower number = higher priority)
-      return a.priority - b.priority;
-    });
-  }
-
-  private async sendViaConfig(
-    config: IntegrationConfig,
-    to: string,
-    message: string,
-    user_id?: number,
-  ): Promise<IntegrationResult> {
-    const strategy = this.integrationFactory.create(
-      config.integration_type,
-      'API', // service is deprecated, using default
-      config.integration_provider,
-    );
-
-    // Get user integration data if user_id provided
-    let finalConfig = config.config_json;
-    if (user_id) {
-      const userIntegrationData = await this.getUserIntegrationForStrategy(
-        user_id,
-        config.id,
-      );
-
-      if (userIntegrationData) {
-        finalConfig = {
-          ...config.config_json,
-          external_user_id: userIntegrationData.external_user_id,
-        };
-      }
-    }
-
-    const result = await strategy.sendMessage(to, message, finalConfig);
-
-    // If token was refreshed, update it in the database
-    if (result.refreshedToken && result.success) {
-      try {
-        const currentConfig = config.config_json as any;
-        const updatedConfig = {
-          ...currentConfig,
-          accessToken: result.refreshedToken,
-        };
-
-        await this.configRepository.update(config.id, {
-          config_json: updatedConfig,
-        } as any);
-
-        this.logger.log(
-          `Updated access token for ${config.integration_provider} configuration`,
-        );
-      } catch (error) {
-        this.logger.warn(
-          `Failed to update refreshed token in database: ${error.message}`,
-        );
-      }
-    }
-
-    return result;
-  }
-
-  async createIntegrationConfig(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    provider: string,
-    integration_source_id: number,
-    config: any,
-    priority?: number,
-    is_default?: boolean,
-  ): Promise<
-    IntegrationConfig | { authUrl: string; state: string; message: string }
-  > {
-    // Validate that no duplicate provider configurations exist
-    await this.validateUniqueActiveConfig(
-      levelId,
-      levelType,
-      app_code,
-      configType,
-      provider,
-    );
-
-    // Deactivate all other configurations of the same integration type
-    await this.configRepository.update(
-      {
-        level_id: levelId,
-        level_type: levelType,
-        app_code: app_code,
-        integration_type: configType,
-        status: 1,
-      },
-      { status: 0 },
-    );
-
-    // Validate provider and get service type from supported combinations
-    const supportedCombinations = await this.getSupportedCombinations();
-    const validCombination = supportedCombinations.find(
-      (combo) =>
-        combo.mode === configType &&
-        combo.provider.toLowerCase() === provider.toLowerCase(),
-    );
-
-    if (!validCombination) {
-      throw new Error(`Unsupported combination: ${configType}/${provider}`);
-    }
-
-    const service = validCombination.service;
-
-    // Check if this requires OAuth flow
-    const requiresOAuth = this.requiresOAuthFlow(configType, provider, config);
-
-    if (requiresOAuth) {
-      // Generate OAuth URL and return it instead of creating config immediately
-      return await this.generateOAuthUrl(
-        levelId,
-        levelType,
-        app_code,
-        configType,
-        provider,
-        integration_source_id,
-        config,
-        priority,
-        is_default,
-      );
-    }
-
-    // Direct config creation (non-OAuth flow)
-    return await this.createDirectConfig(
-      levelId,
-      levelType,
-      app_code,
-      configType,
-      provider,
-      integration_source_id,
-      config,
-      priority,
-      is_default,
-    );
-  }
-
-  getSupportedCombinations(): {
-    mode: string;
-    service: string;
-    provider: string;
-  }[] {
-    return this.integrationFactory.getAllSupportedCombinations();
-  }
-
-  async getLevelConfigs(
-    levelId: number,
-    levelType: string,
-    filters?: {
-      app_code?: string;
-      integration_type?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE';
-      integration_provider?: string;
-    },
-  ): Promise<
-    Array<IntegrationConfig & { linkedSource?: string; configDetails?: any }>
-  > {
-    const where: any = { level_id: levelId, level_type: levelType };
-
-    if (filters?.app_code) {
-      where.app_code = filters.app_code;
-    }
-
-    if (filters?.integration_type) {
-      where.integration_type = filters.integration_type;
-    }
-
-    if (filters?.integration_provider) {
-      where.integration_provider = filters.integration_provider;
-    }
-
-    const hubs = await this.configRepository.find({
-      where,
-      order: { created_at: 'DESC' },
-    });
-
-    // Enhance hubs with linked source information
-    const enhancedHubs = await Promise.all(
-      hubs.map(async (hub) => {
-        try {
-          const relatedConfig = await this.configRepository.findOne({
-            where: { id: hub.id },
-          });
-
-          if (!relatedConfig) {
-            return {
-              ...hub,
-              linkedSource: 'Configuration not found',
-              configDetails: null,
-            };
-          }
-
-          const linkedSource = this.extractLinkedSource(
-            hub.integration_type,
-            hub.integration_provider,
-            relatedConfig.config_json,
-          );
-
-          const configDetails = this.extractConfigDetails(
-            hub.integration_type,
-            hub.integration_provider,
-            relatedConfig.config_json,
-          );
-
-          return {
-            ...hub,
-            linkedSource,
-            configDetails,
-          };
-        } catch (error) {
-          this.logger.warn(
-            `Error extracting linked source for hub ${hub.id}:`,
-            error.message,
-          );
-          return {
-            ...hub,
-            linkedSource: 'Error retrieving source',
-            configDetails: null,
-          };
-        }
-      }),
-    );
-
-    return enhancedHubs;
-  }
-
-  private extractLinkedSource(
-    configType: string,
-    provider: string,
-    configJson: any,
-  ): string {
-    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
-
-    try {
-      switch (key) {
-        // Gmail configurations
-        case 'email_gmail':
-        case 'email_smtp_gmail':
-          return configJson?.email || 'Gmail account not configured';
-
-        // Outlook configurations
-        case 'email_outlook':
-        case 'email_smtp_outlook':
-          return configJson?.email || 'Outlook account not configured';
-
-        // WhatsApp configurations
-        case 'wa_api_whatsapp':
-          return configJson?.phoneNumberId
-            ? `WhatsApp Business: ${configJson.phoneNumberId}`
-            : 'WhatsApp not configured';
-
-        // SMS configurations
-        case 'sms_third_party_twilio':
-          return configJson?.fromNumber
-            ? `Twilio: ${configJson.fromNumber}`
-            : 'Twilio number not configured';
-
-        case 'sms_third_party_knowlarity':
-          return configJson?.callerNumber
-            ? `Knowlarity: ${configJson.callerNumber}`
-            : 'Knowlarity number not configured';
-
-        // Telephone configurations
-        case 'telephone_third_party_knowlarity':
-          return configJson?.callerNumber
-            ? `Knowlarity Voice: ${configJson.callerNumber}`
-            : 'Knowlarity voice number not configured';
-
-        case 'telephone_third_party_ozonetel':
-          return configJson?.userName
-            ? `Ozonetel Voice: ${configJson.userName}`
-            : 'Ozonetel voice not configured';
-
-        // AWS SES configurations
-        case 'email_aws-ses':
-        case 'email_ses':
-          return configJson?.fromEmail || 'AWS SES not configured';
-
-        // SendGrid configurations
-        case 'email_smtp_sendgrid':
-          return configJson?.from || 'SendGrid not configured';
-
-        // Generic SMTP configurations
-        case 'email_smtp_custom':
-        case 'email_smtp_generic':
-          return configJson?.from || configJson?.user || 'SMTP not configured';
-
-        default:
-          // Generic fallback - try to find common identifier fields
-          if (configJson?.email) return configJson.email;
-          if (configJson?.from) return configJson.from;
-          if (configJson?.user) return configJson.user;
-          if (configJson?.phoneNumberId) return configJson.phoneNumberId;
-          if (configJson?.fromNumber) return configJson.fromNumber;
-          if (configJson?.callerNumber) return configJson.callerNumber;
-
-          return `${provider} configured`;
-      }
-    } catch (error) {
-      return 'Configuration error';
-    }
-  }
-
-  private extractConfigDetails(
-    configType: string,
-    provider: string,
-    configJson: any,
-  ): any {
-    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
-
-    try {
-      switch (key) {
-        // Gmail configurations
-        case 'email_gmail':
-          return {
-            email: configJson?.email,
-            authMethod: configJson?.authMethod || 'OAUTH2',
-            hasRefreshToken: !!configJson?.refreshToken,
-            isExpired: configJson?.expiryDate
-              ? new Date(configJson.expiryDate) < new Date()
-              : false,
-          };
-
-        case 'email_smtp_gmail':
-          return {
-            email: configJson?.email,
-            authMethod: 'SMTP',
-            hasPassword: !!configJson?.password,
-          };
-
-        // Outlook configurations
-        case 'email_outlook':
-          return {
-            email: configJson?.email,
-            authMethod: 'OAUTH2',
-            hasRefreshToken: !!configJson?.refreshToken,
-            tenantId: configJson?.tenantId,
-          };
-
-        case 'email_smtp_outlook':
-          return {
-            email: configJson?.email,
-            authMethod: 'SMTP',
-            hasPassword: !!configJson?.password,
-          };
-
-        // WhatsApp configurations
-        case 'wa_api_whatsapp':
-          return {
-            phoneNumberId: configJson?.phoneNumberId,
-            apiVersion: configJson?.apiVersion || 'v17.0',
-            hasAccessToken: !!configJson?.accessToken,
-          };
-
-        // SMS configurations
-        case 'sms_third_party_twilio':
-          return {
-            fromNumber: configJson?.fromNumber,
-            accountSid: configJson?.accountSid
-              ? configJson.accountSid.substring(0, 8) + '...'
-              : null,
-            hasAuthToken: !!configJson?.authToken,
-          };
-
-        case 'sms_third_party_knowlarity':
-          return {
-            callerNumber: configJson?.callerNumber,
-            callType: configJson?.callType || 'sms',
-            hasApiSecret: !!configJson?.apiSecret,
-          };
-
-        // Telephone configurations
-        case 'telephone_third_party_knowlarity':
-          return {
-            callerNumber: configJson?.callerNumber,
-            callType: configJson?.callType || 'voice',
-            language: configJson?.language || 'en',
-            hasApiSecret: !!configJson?.apiSecret,
-          };
-
-        case 'telephone_third_party_ozonetel':
-          return {
-            userName: configJson?.userName,
-            agentID: configJson?.agentID,
-            campaignName: configJson?.campaignName,
-            agentLoginUrl: configJson?.agentLoginUrl,
-            hasApiKey: !!configJson?.apiKey,
-          };
-
-        // AWS SES configurations
-        case 'email_aws-ses':
-        case 'email_ses':
-          return {
-            fromEmail: configJson?.fromEmail,
-            region: configJson?.region,
-            hasCredentials: !!(
-              configJson?.accessKeyId && configJson?.secretAccessKey
-            ),
-          };
-
-        // SendGrid configurations
-        case 'email_smtp_sendgrid':
-          return {
-            from: configJson?.from,
-            hasApiKey: !!configJson?.apiKey,
-            templateId: configJson?.templateId,
-          };
-
-        // Generic SMTP configurations
-        case 'email_smtp_custom':
-        case 'email_smtp_generic':
-          return {
-            host: configJson?.host,
-            port: configJson?.port || 587,
-            secure: configJson?.secure || false,
-            from: configJson?.from || configJson?.user,
-            hasCredentials: !!(configJson?.user && configJson?.password),
-          };
-
-        default: {
-          // Generic details - return safe subset of config
-          const safeConfig: any = {};
-
-          // Include non-sensitive fields
-          const safeFields = [
-            'email',
-            'from',
-            'user',
-            'host',
-            'port',
-            'secure',
-            'phoneNumberId',
-            'fromNumber',
-            'callerNumber',
-            'region',
-            'apiVersion',
-            'callType',
-            'language',
-            'templateId',
-          ];
-
-          safeFields.forEach((field) => {
-            if (configJson?.[field]) {
-              safeConfig[field] = configJson[field];
-            }
-          });
-
-          // Include boolean indicators for sensitive fields
-          const sensitiveFields = [
-            'accessToken',
-            'refreshToken',
-            'password',
-            'authToken',
-            'apiKey',
-            'apiSecret',
-            'clientSecret',
-            'secretAccessKey',
-          ];
-
-          sensitiveFields.forEach((field) => {
-            if (configJson?.[field]) {
-              safeConfig[
-                `has${field.charAt(0).toUpperCase() + field.slice(1)}`
-              ] = true;
-            }
-          });
-
-          return safeConfig;
-        }
-      }
-    } catch (error) {
-      return { error: 'Unable to extract configuration details' };
-    }
-  }
-
-  async updateConfigStatus(hubId: number, status: number): Promise<void> {
-    // Find the hub to get level and type information
-    const config = await this.configRepository.findOne({
-      where: { id: hubId },
-    });
-
-    if (!config) {
-      throw new Error('Integration configuration not found');
-    }
-
-    // If activating, deactivate ALL other configs of the same integration type
-    if (status === 1) {
-      await this.configRepository.update(
-        {
-          level_id: config.level_id,
-          level_type: config.level_type,
-          app_code: config.app_code,
-          integration_type: config.integration_type,
-          status: 1,
-          id: Not(hubId),
-        },
-        { status: 0 },
-      );
-    }
-
-    // Update the requested config
-    await this.configRepository.update(hubId, { status });
-  }
-
-  async deleteConfiguration(configId: number): Promise<void> {
-    // Find the hub to get the id
-    const config = await this.configRepository.findOne({
-      where: { id: configId },
-    });
-
-    if (!config) {
-      throw new Error('Integration configuration not found');
-    }
-
-    await this.configRepository.delete(configId);
-
-    this.logger.log(`Integration configuration deleted: ${configId}`);
-  }
-
-  async updateConfiguration(
-    hubId: number,
-    updateData: {
-      config?: any;
-      priority?: number;
-      is_default?: boolean;
-      status?: number;
-    },
-  ): Promise<IntegrationConfig & { config?: any }> {
-    // Find the existing hub
-    const config = await this.configRepository.findOne({
-      where: { id: hubId },
-    });
-
-    if (!config) {
-      throw new Error('Integration configuration not found');
-    }
-
-    // Update configuration JSON if provided
-    if (updateData.config) {
-      // Merge the new config with existing config
-      const updatedConfigJson = {
-        ...config.config_json,
-        ...updateData.config,
-      };
-
-      await this.configRepository.update(config.id, {
-        config_json: updatedConfigJson,
-      });
-    }
-
-    // Handle default configuration logic (simplified for now)
-    if (updateData.is_default === true) {
-      // Remove default from other configurations of same type and level
-      await this.configRepository.update(
-        {
-          level_id: config.level_id,
-          level_type: config.level_type,
-          integration_type: config.integration_type,
-          id: Not(hubId),
-        },
-        { is_default: false },
-      );
-    }
-
-    if (config.integration_type === 'TELEPHONE') {
-      try {
-        // Extract DID from config (could be did, callerNumber, or fromNumber)
-        const did = config.config_json.did;
-
-        if (did) {
-          await this.entityMapperRepository.delete({
-            integration_config_id: config.id,
-          });
-
-          const entityMapper = this.entityMapperRepository.create({
-            integration_config_id: config.id,
-            level_id: String(config.level_id),
-            level_type: config.level_type,
-            appcode: config.app_code,
-            did: did,
-            campaign_name: config.config_json.campaignName || null,
-          });
-
-          await this.entityMapperRepository.save(entityMapper);
-          this.logger.log(
-            `DID mapping created for TELEPHONE integration: ${did} for ${config.level_id} ${config.level_type}`,
-          );
-        }
-      } catch (error) {
-        this.logger.warn(
-          `Failed to create DID mapping for TELEPHONE integration: ${error.message}`,
-        );
-      }
-    }
-
-    // Apply direct config updates if any
-    const directUpdates: any = {};
-    if (updateData.priority !== undefined)
-      directUpdates.priority = updateData.priority;
-    if (updateData.is_default !== undefined)
-      directUpdates.is_default = updateData.is_default;
-    if (updateData.status !== undefined)
-      directUpdates.status = updateData.status;
-
-    if (Object.keys(directUpdates).length > 0) {
-      await this.configRepository.update(config.id, directUpdates);
-    }
-
-    // Fetch and return updated config
-    const updatedConfig = await this.configRepository.findOne({
-      where: { id: hubId },
-    });
-
-    return {
-      ...updatedConfig,
-      config: updatedConfig?.config_json,
-    } as any;
-  }
-
-  async sendGenericMessage(
-    messageDto: GenericMessageDto,
-  ): Promise<IntegrationResult> {
-    try {
-      const {
-        levelId,
-        levelType,
-        app_code,
-        to,
-        message,
-        type,
-        priority = 'medium',
-        html,
-        cc,
-        bcc,
-        attachments,
-        mediaUrl,
-        templateId,
-        user_id,
-        entity_id,
-        entity_type,
-        organization_id,
-        mapped_entities,
-      } = messageDto;
-
-      let subject = messageDto.subject;
-
-      // Auto-detect communication type if not specified
-      const communicationType = this.detectCommunicationType(to, type);
-
-      // Get active configs for the detected type
-      const configs = await this.getActiveConfigs(
-        levelId,
-        levelType,
-        app_code,
-        communicationType,
-      );
-
-      if (!configs.length) {
-        this.logger.warn(
-          `No communication hubs found for ${levelType} ${levelId}. Please configure integration providers using the createIntegrationConfig method.`,
-        );
-        throw new Error(
-          `No active ${communicationType} configuration found for ${levelType} ${levelId}. Please configure a communication provider first.`,
-        );
-      }
-
-      // Sort hubs by priority and default preference
-      const sortedConfigs = this.sortConfigsByPriorityAndDefault(
-        configs,
-        priority,
-      );
-
-      // Prepare enhanced config with additional parameters
-      const enhancedConfig = {
-        subject,
-        html,
-        cc,
-        bcc,
-        attachments,
-        mediaUrl,
-      };
-
-      const loggedInUser = {
-        id: user_id || null,
-        organization_id: organization_id || null,
-        level_id: levelId,
-        level_type: levelType,
-        app_code: app_code,
-      };
-
-      // Handle multiple recipients by sending to each individually
-      if (Array.isArray(to)) {
-        const results: IntegrationResult[] = [];
-        let hasSuccess = false;
-
-        for (const recipient of to) {
-          for (const hub of sortedConfigs) {
-            try {
-              const serviceType = this.deriveServiceType(
-                hub.integration_type,
-                hub.integration_provider,
-                hub.config_json,
-              );
-              const strategy = this.integrationFactory.create(
-                hub.integration_type,
-                serviceType,
-                hub.integration_provider,
-              );
-
-              // Process template if provided
-              let variables;
-              let richText;
-              let externalTemplateId: string | undefined = undefined;
-              if (templateId) {
-                const templateData = await this.processTemplate(
-                  parseInt(templateId, 10),
-                  entity_type,
-                  entity_id,
-                  loggedInUser,
-                  mapped_entities,
-                );
-                variables = templateData.variables;
-                externalTemplateId = templateData.externalTemplateId;
-                richText = templateData.rich_text;
-                subject = templateData.subject;
-              }
-
-              // Merge config with enhanced parameters
-              let finalConfig = {
-                ...hub.config_json,
-                ...enhancedConfig,
-                templateId: externalTemplateId,
-                variables,
-                richText,
-                subject,
-              };
-
-              // Handle user integration if user_id provided
-              if (user_id) {
-                const userIntegrationData =
-                  await this.getUserIntegrationForStrategy(user_id, hub.id);
-
-                if (userIntegrationData) {
-                  finalConfig = {
-                    ...finalConfig,
-                    external_user_id: userIntegrationData.external_user_id,
-                  };
-                }
-              }
-
-              const result = await strategy.sendMessage(
-                recipient,
-                message,
-                finalConfig,
-              );
-
-              if (result.success) {
-                this.logger.log(
-                  `Generic message sent successfully via ${hub.integration_provider} to ${recipient}`,
-                );
-                results.push(result);
-                hasSuccess = true;
-                break; // Move to next recipient
-              }
-
-              this.logger.warn(
-                `Failed to send via ${hub.integration_provider} to ${recipient}: ${result.error}`,
-              );
-            } catch (error) {
-              this.logger.error(
-                `Error sending via ${hub.integration_provider} to ${recipient}:`,
-                error.message,
-              );
-              continue;
-            }
-          }
-        }
-
-        if (hasSuccess) {
-          return {
-            success: true,
-            messageId: results.map((r) => r.messageId).join(','),
-            provider: 'multiple',
-            service: 'multiple',
-            timestamp: new Date(),
-            message: results.map((r) => r.message).join(','),
-          };
-        }
-      } else {
-        // Handle single recipient
-        for (const hub of sortedConfigs) {
-          try {
-            const serviceType = this.deriveServiceType(
-              hub.integration_type,
-              hub.integration_provider,
-              hub.config_json,
-            );
-            const strategy = this.integrationFactory.create(
-              hub.integration_type,
-              serviceType,
-              hub.integration_provider,
-            );
-
-            // Process template if provided
-            let variables;
-            let externalTemplateId: string | undefined = undefined;
-            let richText;
-            if (templateId) {
-              const templateData = await this.processTemplate(
-                parseInt(templateId, 10),
-                entity_type,
-                entity_id,
-                loggedInUser,
-                mapped_entities,
-              );
-              variables = templateData.variables;
-              externalTemplateId = templateData.externalTemplateId;
-              richText = templateData.rich_text;
-              subject = templateData.subject;
-            }
-
-            // Merge config with enhanced parameters
-            let finalConfig = {
-              ...hub.config_json,
-              ...enhancedConfig,
-              templateId: externalTemplateId,
-              variables,
-              richText,
-            };
-
-            // Handle user integration if user_id provided
-            if (user_id) {
-              const userIntegrationData =
-                await this.getUserIntegrationForStrategy(user_id, hub.id);
-
-              if (userIntegrationData) {
-                finalConfig = {
-                  ...finalConfig,
-                  external_user_id: userIntegrationData.external_user_id,
-                };
-              }
-            }
-
-            const result = await strategy.sendMessage(to, message, finalConfig);
-
-            if (result.success) {
-              this.logger.log(
-                `Generic message sent successfully via ${hub.integration_provider} to ${to}`,
-              );
-              return result;
-            }
-
-            this.logger.warn(
-              `Failed to send via ${hub.integration_provider}: ${result.error}`,
-            );
-          } catch (error) {
-            this.logger.error(
-              `Error sending via ${hub.integration_provider}:`,
-              error.message,
-            );
-            continue;
-          }
-        }
-      }
-
-      throw new Error('All communication providers failed');
-    } catch (error) {
-      this.logger.error('Generic communication service error:', error.message);
-      throw error;
-    }
-  }
-
-  async sendBulkMessage(
-    bulkDto: BulkMessageDto,
-  ): Promise<{ results: IntegrationResult[]; summary: any }> {
-    try {
-      const {
-        levelId,
-        levelType,
-        app_code,
-        recipients,
-        message,
-        type,
-        priority = 'low',
-        subject,
-        html,
-        templateId,
-        variables,
-        batchSize = 10,
-      } = bulkDto;
-
-      const results: IntegrationResult[] = [];
-      const batches = this.chunkArray(recipients, batchSize);
-
-      for (let i = 0; i < batches.length; i++) {
-        const batch = batches[i];
-        this.logger.log(
-          `Processing batch ${i + 1}/${batches.length} with ${batch.length} recipients`,
-        );
-
-        const batchPromises = batch.map(async (recipient) => {
-          try {
-            const messageDto: GenericMessageDto = {
-              levelId,
-              levelType,
-              app_code,
-              to: recipient,
-              message,
-              type,
-              priority,
-              subject,
-              html,
-              templateId,
-              variables,
-            };
-
-            return await this.sendGenericMessage(messageDto);
-          } catch (error) {
-            return {
-              success: false,
-              provider: 'unknown',
-              service: 'unknown',
-              error: error.message,
-              timestamp: new Date(),
-            } as IntegrationResult;
-          }
-        });
-
-        const batchResults = await Promise.allSettled(batchPromises);
-        const processedResults = batchResults.map((result) => {
-          if (result.status === 'fulfilled') {
-            return result.value;
-          } else {
-            return {
-              success: false,
-              provider: 'unknown',
-              service: 'unknown',
-              error: result.reason?.message || 'Unknown error',
-              timestamp: new Date(),
-            } as IntegrationResult;
-          }
-        });
-
-        results.push(...processedResults);
-
-        // Rate limiting delay between batches
-        if (i < batches.length - 1) {
-          await new Promise((resolve) => setTimeout(resolve, 1000));
-        }
-      }
-
-      const summary = {
-        total: results.length,
-        successful: results.filter((r) => r.success).length,
-        failed: results.filter((r) => !r.success).length,
-        successRate:
-          (
-            (results.filter((r) => r.success).length / results.length) *
-            100
-          ).toFixed(2) + '%',
-      };
-
-      this.logger.log(
-        `Bulk message completed: ${summary.successful}/${summary.total} successful`,
-      );
-
-      return { results, summary };
-    } catch (error) {
-      this.logger.error('Bulk communication service error:', error.message);
-      throw error;
-    }
-  }
-
-  async scheduleMessage(
-    scheduledDto: any,
-  ): Promise<{ scheduled: boolean; scheduleId?: string }> {
-    // For now, return a placeholder. In production, integrate with a job queue like Bull or Agenda
-    this.logger.log(`Message scheduled for ${scheduledDto.scheduleFor}`);
-
-    return {
-      scheduled: true,
-      scheduleId: `sched_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
-    };
-  }
-
-  async sendTemplateMessage(templateDto: any): Promise<IntegrationResult> {
-    // Get template content (integrate with your template system)
-    const template = await this.getTemplate(templateDto.templateId);
-
-    const processedMessage = this.replaceTemplateVariables(
-      template.content,
-      templateDto.variables,
-    );
-    const processedSubject = template.subject
-      ? this.replaceTemplateVariables(template.subject, templateDto.variables)
-      : undefined;
-
-    const messageDto: GenericMessageDto = {
-      levelId: templateDto.levelId,
-      levelType: templateDto.levelType,
-      app_code: templateDto.app_code,
-      to: templateDto.to,
-      message: processedMessage,
-      subject: processedSubject,
-      type: templateDto.type,
-      templateId: templateDto.templateId,
-      variables: templateDto.variables,
-    };
-
-    return this.sendGenericMessage(messageDto);
-  }
-
-  private detectCommunicationType(
-    to: string | string[],
-    type?: string,
-  ): 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE' {
-    if (type) {
-      return type as 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
-    }
-
-    const recipient = Array.isArray(to) ? to[0] : to;
-
-    // Email detection
-    if (recipient.includes('@')) {
-      return 'EMAIL';
-    }
-
-    // Phone number detection (basic)
-    if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
-      // Could be SMS or WhatsApp, default to SMS
-      return 'SMS';
-    }
-
-    // Default to EMAIL if unsure
-    return 'EMAIL';
-  }
-
-  private sortConfigsByPriorityAndDefault(
-    configs: IntegrationConfigWithConfig[],
-    _priority: string,
-  ): IntegrationConfigWithConfig[] {
-    return configs.sort((a, b) => {
-      // First sort by default (true comes first)
-      if (a.is_default !== b.is_default) {
-        return b.is_default ? 1 : -1;
-      }
-
-      // Then sort by priority (lower number = higher priority)
-      if (a.priority !== b.priority) {
-        return a.priority - b.priority;
-      }
-
-      // Finally sort by created_at descending (newest first)
-      return (
-        new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
-      );
-    });
-  }
-
-  public async processTemplate(
-    templateId: number,
-    entity_type: any,
-    entity_id: any,
-    loggedInUser?: any,
-    mappedEntities?: Record<string, any>,
-  ): Promise<{
-    variables?: Record<string, any>;
-    externalTemplateId?: string;
-    rich_text?: string;
-    subject?: string;
-  }> {
-    const commTemplate: any = await this.entityService.getEntityData(
-      COMM_TEMPLATE,
-      templateId,
-      {} as any,
-    );
-    if (!commTemplate) {
-      return {
-        variables: {},
-        externalTemplateId: undefined,
-      };
-    }
-
-    let variables = {};
-    if (commTemplate.mapper_id) {
-      variables = await this.fieldMapperService.resolveData(
-        commTemplate.mapper_id,
-        'LOOKUP',
-        entity_type,
-        entity_id,
-        loggedInUser,
-        {} as any,
-        mappedEntities,
-      );
-    }
-
-    if (!commTemplate.template_id) {
-      let richText = commTemplate.rich_text;
-
-      if (!richText) {
-        if (commTemplate.markup_id) {
-          let url = await this.mediaService.getMediaDownloadUrl(
-            commTemplate.markup_id,
-            {},
-            60000,
-          );
-          if (url) {
-            let response = await axios.get(url.signedUrl, {
-              responseType: 'text',
-            });
-            richText = response.data;
-          }
-        }
-      }
-
-      richText = richText.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-        const value = variables[key];
-        if (value === undefined) return match;
-
-        // If value is an object with signedUrl, use only the signedUrl
-        if (
-          typeof value === 'object' &&
-          value !== null &&
-          'signedUrl' in value
-        ) {
-          return String(value.signedUrl);
-        }
-
-        return String(value);
-      });
-
-      return {
-        rich_text: richText,
-        subject: commTemplate.subject,
-      };
-    }
-
-    return {
-      variables,
-      externalTemplateId: commTemplate.template_id,
-    };
-  }
-
-  private replaceTemplateVariables(
-    template: string,
-    variables: Record<string, any>,
-  ): string {
-    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-      const value = variables[key];
-      return value !== undefined ? String(value) : match;
-    });
-  }
-
-  private async getTemplate(templateId: string) {
-    // Placeholder for template system integration
-    // In production, this would connect to your template database/service
-    return {
-      id: templateId,
-      subject: 'Default Subject {{variable}}',
-      content: 'Hello {{name}}, this is a template message with {{variable}}.',
-    };
-  }
-
-  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
-    const chunks: T[][] = [];
-    for (let i = 0; i < array.length; i += chunkSize) {
-      chunks.push(array.slice(i, i + chunkSize));
-    }
-    return chunks;
-  }
-
-  async initGmailOAuth(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    email?: string,
-  ): Promise<{ authUrl: string; state: string }> {
-    try {
-      // Get system OAuth credentials from config
-      const clientId = this.configService.get<string>('CLIENT_ID');
-      const clientSecret = this.configService.get<string>('CLIENT_SECRET');
-
-      if (!clientId || !clientSecret) {
-        throw new Error('Gmail OAuth credentials not configured');
-      }
-
-      const state = this.generateSecureState();
-      // Use the existing registered callback URL
-      const callbackUrl =
-        this.configService.get<string>('CALLBACK_URL') ||
-        'http://localhost:5001/auth/google/callback';
-
-      this.gmailOAuthStates.set(state, {
-        levelId,
-        levelType,
-        app_code,
-        email,
-        timestamp: Date.now(),
-      });
-
-      // Auto-cleanup after 10 minutes
-      setTimeout(
-        () => {
-          this.gmailOAuthStates.delete(state);
-        },
-        10 * 60 * 1000,
-      );
-
-      const oauth2Client = new google.auth.OAuth2(
-        clientId,
-        clientSecret,
-        callbackUrl,
-      );
-
-      const scopes = [
-        'https://www.googleapis.com/auth/gmail.send',
-        'https://www.googleapis.com/auth/gmail.readonly',
-        'https://www.googleapis.com/auth/userinfo.email',
-        'https://www.googleapis.com/auth/calendar',
-      ];
-
-      const authUrl = oauth2Client.generateAuthUrl({
-        access_type: 'offline',
-        scope: scopes,
-        state: `gmail_config:${state}`, // Prefix to identify Gmail config requests
-        prompt: 'consent',
-        login_hint: email,
-      });
-
-      return { authUrl, state };
-    } catch (error) {
-      this.logger.error('Error initializing Gmail OAuth:', error.message);
-      throw new Error('Failed to initialize Gmail OAuth');
-    }
-  }
-
-  async handleGmailOAuthCallback(
-    code: string,
-    state: string,
-  ): Promise<GmailSSOResult> {
-    try {
-      const oauthState = this.gmailOAuthStates.get(state);
-      if (!oauthState) {
-        throw new Error('Invalid or expired OAuth state');
-      }
-
-      this.gmailOAuthStates.delete(state);
-
-      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
-        throw new Error('OAuth state expired');
-      }
-
-      // Get system OAuth credentials
-      const clientId = this.configService.get<string>('CLIENT_ID');
-      const clientSecret = this.configService.get<string>('CLIENT_SECRET');
-      const callbackUrl =
-        this.configService.get<string>('CALLBACK_URL') ||
-        'http://localhost:5001/auth/google/callback';
-
-      const oauth2Client = new google.auth.OAuth2(
-        clientId,
-        clientSecret,
-        callbackUrl,
-      );
-
-      const { tokens } = await oauth2Client.getToken(code);
-
-      if (!tokens.access_token) {
-        throw new Error('Failed to obtain access token');
-      }
-
-      // Get user email from Google
-      oauth2Client.setCredentials(tokens);
-      const oauth2 = google.oauth2({ version: 'v2', auth: oauth2Client });
-      const userInfo = await oauth2.userinfo.get();
-      const email = userInfo.data.email;
-
-      if (!email) {
-        throw new Error('Failed to get user email');
-      }
-
-      // Verify email matches if hint was provided
-      if (oauthState.email && oauthState.email !== email) {
-        throw new Error('Email mismatch with OAuth hint');
-      }
-
-      const gmailConfig = {
-        clientId,
-        clientSecret,
-        email: email,
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        scope: tokens.scope,
-        tokenType: tokens.token_type,
-        expiryDate: tokens.expiry_date,
-      };
-
-      // Validate that no active EMAIL configuration exists
-      await this.validateUniqueActiveConfig(
-        oauthState.levelId,
-        oauthState.levelType,
-        oauthState.app_code,
-        'EMAIL',
-        'gmail',
-      );
-
-      // Create integration config
-      const config = this.configRepository.create({
-        app_code: oauthState.app_code,
-        integration_type: 'EMAIL',
-        integration_provider: 'gmail',
-        integration_source_id: 1, // Gmail source ID
-        level_id: oauthState.levelId,
-        level_type: oauthState.levelType,
-        status: 1,
-        priority: 1,
-        is_default: false,
-        config_json: gmailConfig as any,
-      });
-
-      const savedConfig = await this.configRepository.save(config);
-
-      this.logger.log(
-        `Gmail OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
-      );
-
-      return {
-        hubId: savedConfig.id,
-        configId: savedConfig.id,
-      };
-    } catch (error) {
-      this.logger.error('Error handling Gmail OAuth callback:', error.message);
-      throw new Error(`Failed to complete Gmail OAuth: ${error.message}`);
-    }
-  }
-
-  async handleGmailTokensCallback(
-    email: string,
-    accessToken: string,
-    refreshToken: string,
-    state: string,
-  ): Promise<GmailSSOResult> {
-    try {
-      const oauthState = this.gmailOAuthStates.get(state);
-      if (!oauthState) {
-        throw new Error('Invalid or expired OAuth state');
-      }
-
-      this.gmailOAuthStates.delete(state);
-
-      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
-        throw new Error('OAuth state expired');
-      }
-
-      // Verify email matches if hint was provided
-      if (oauthState.email && oauthState.email !== email) {
-        throw new Error('Email mismatch with OAuth hint');
-      }
-
-      // Validate that no active EMAIL configuration exists
-      await this.validateUniqueActiveConfig(
-        oauthState.levelId,
-        oauthState.levelType,
-        oauthState.app_code,
-        'EMAIL',
-        'gmail',
-      );
-
-      // Pure SSO configuration - no client credentials stored per user
-      const gmailConfig = {
-        email: email,
-        accessToken: accessToken,
-        refreshToken: refreshToken,
-        authMethod: 'GOOGLE_SSO',
-        scopes: [
-          'https://www.googleapis.com/auth/gmail.send',
-          'https://www.googleapis.com/auth/userinfo.email',
-        ],
-      };
-
-      // Create integration config
-      const config = this.configRepository.create({
-        app_code: oauthState.app_code,
-        integration_type: 'EMAIL',
-        integration_provider: 'gmail',
-        integration_source_id: 1, // Gmail source ID
-        level_id: oauthState.levelId,
-        level_type: oauthState.levelType,
-        status: 1,
-        priority: 1,
-        is_default: false,
-        config_json: gmailConfig as any,
-      });
-
-      const savedConfig = await this.configRepository.save(config);
-
-      this.logger.log(
-        `Gmail tokens configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
-      );
-
-      return {
-        hubId: savedConfig.id,
-        configId: savedConfig.id,
-      };
-    } catch (error) {
-      this.logger.error('Error handling Gmail tokens callback:', error.message);
-      throw new Error(
-        `Failed to complete Gmail tokens callback: ${error.message}`,
-      );
-    }
-  }
-
-  async testGmailConfig(
-    hubId: number,
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const integrationConfig = await this.configRepository.findOne({
-        where: { id: hubId },
-      });
-
-      if (!integrationConfig) {
-        throw new Error('Integration config not found');
-      }
-
-      const isValid = await this.gmailApiStrategy.validateConnection(
-        integrationConfig.config_json,
-      );
-
-      if (!isValid) {
-        return {
-          success: false,
-          error: 'Gmail configuration is invalid or expired',
-        };
-      }
-
-      return { success: true };
-    } catch (error) {
-      this.logger.error('Error testing Gmail config:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  private generateSecureState(): string {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-  }
-
-  private async validateUniqueActiveConfig(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    provider: string,
-    excludeHubId?: number,
-  ): Promise<void> {
-    // Find all active configurations of the same provider for this level and app_code
-    const query = this.configRepository
-      .createQueryBuilder('hub')
-      .where('hub.level_id = :levelId', { levelId })
-      .andWhere('hub.level_type = :levelType', { levelType })
-      .andWhere('hub.app_code = :app_code', { app_code })
-      .andWhere('hub.integration_type = :configType', { configType })
-      .andWhere('hub.integration_provider = :provider', { provider })
-      .andWhere('hub.status = :status', { status: 1 });
-
-    // Exclude current hub if updating
-    if (excludeHubId) {
-      query.andWhere('hub.id != :excludeHubId', { excludeHubId });
-    }
-
-    const existingActiveConfigs = await query.getMany();
-
-    // If there are existing active configurations of the same provider, throw error
-    if (existingActiveConfigs.length > 0) {
-      throw new Error(
-        `A ${provider} configuration already exists for ${configType} in app_code ${app_code}, ${levelType} ${levelId}. Only one configuration per provider is allowed.`,
-      );
-    }
-  }
-
-  private requiresOAuthFlow(
-    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    provider: string,
-    config: any,
-  ): boolean {
-    // Check if config indicates OAuth is needed (missing tokens or explicit OAuth request)
-    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
-
-    switch (key) {
-      case 'email_gmail':
-        // Requires OAuth if no access token provided or OAuth explicitly requested
-        return !config.accessToken || config.useOAuth === true;
-
-      case 'email_outlook':
-        // Requires OAuth if no access token provided or OAuth explicitly requested
-        return !config.accessToken || config.useOAuth === true;
-
-      default:
-        // Most other providers don't require OAuth
-        return false;
-    }
-  }
-
-  private async generateOAuthUrl(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    provider: string,
-    integration_source_id: number,
-    config: any,
-    priority?: number,
-    is_default?: boolean,
-  ): Promise<{ authUrl: string; state: string; message: string }> {
-    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
-
-    switch (key) {
-      case 'email_gmail':
-        const gmailResult = await this.initGmailOAuth(
-          levelId,
-          levelType,
-          app_code,
-          config.email,
-        );
-        return {
-          authUrl: gmailResult.authUrl,
-          state: gmailResult.state,
-          message:
-            'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.',
-        };
-
-      case 'email_outlook':
-        const outlookResult = await this.initOutlookOAuth(
-          levelId,
-          levelType,
-          app_code,
-          config.email,
-        );
-        return {
-          authUrl: outlookResult.authUrl,
-          state: outlookResult.state,
-          message:
-            'Please complete Outlook OAuth authorization. Configuration will be created automatically after authorization.',
-        };
-
-      default:
-        throw new Error(`OAuth not supported for ${configType}/${provider}`);
-    }
-  }
-
-  private async createDirectConfig(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-    provider: string,
-    integration_source_id: number,
-    config: any,
-    priority?: number,
-    is_default?: boolean,
-  ): Promise<IntegrationConfig> {
-    // Validate that no duplicate provider configurations exist
-    await this.validateUniqueActiveConfig(
-      levelId,
-      levelType,
-      app_code,
-      configType,
-      provider,
-    );
-
-    // Deactivate all other configurations of the same integration type
-    await this.configRepository.update(
-      {
-        level_id: levelId,
-        level_type: levelType,
-        app_code: app_code,
-        integration_type: configType,
-        status: 1,
-      },
-      { status: 0 },
-    );
-
-    // If setting as default, remove default from other configurations of same type and app_code
-    if (is_default) {
-      await this.configRepository.update(
-        {
-          level_id: levelId,
-          level_type: levelType,
-          app_code: app_code,
-          integration_type: configType,
-        },
-        { is_default: false },
-      );
-    }
-
-    // Create integration config
-    const integrationConfig = this.configRepository.create({
-      app_code: app_code,
-      integration_type: configType,
-      integration_provider: provider,
-      integration_source_id: integration_source_id,
-      level_id: levelId,
-      level_type: levelType,
-      status: 1,
-      priority: priority || 1,
-      is_default: is_default || false,
-      config_json: config,
-    });
-
-    const savedConfig = await this.configRepository.save(integrationConfig);
-    this.logger.log(
-      `Communication config created: ${configType}/${provider} for ${levelType} ${levelId}`,
-    );
-
-    // Store DID mapping for TELEPHONE integration
-    if (configType === 'TELEPHONE') {
-      try {
-        // Extract DID from config (could be did, callerNumber, or fromNumber)
-        const did = config.did || config.callerNumber || config.fromNumber;
-
-        if (did) {
-          const entityMapper = this.entityMapperRepository.create({
-            integration_config_id: savedConfig.id,
-            level_id: String(levelId),
-            level_type: levelType,
-            appcode: app_code,
-            did: did,
-            campaign_name: config.campaignName || null,
-          });
-
-          await this.entityMapperRepository.save(entityMapper);
-          this.logger.log(
-            `DID mapping created for TELEPHONE integration: ${did} for ${levelType} ${levelId}`,
-          );
-        }
-      } catch (error) {
-        this.logger.warn(
-          `Failed to create DID mapping for TELEPHONE integration: ${error.message}`,
-        );
-      }
-    }
-
-    return Array.isArray(savedConfig) ? savedConfig[0] : savedConfig;
-  }
-
-  async initOutlookOAuth(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    email?: string,
-  ): Promise<{ authUrl: string; state: string }> {
-    try {
-      // Get system OAuth credentials from config
-      const clientId = this.configService.get<string>('OUTLOOK_CLIENT_ID');
-      const tenantId = this.configService.get<string>('OUTLOOK_TENANT_ID');
-
-      if (!clientId || !tenantId) {
-        throw new Error('Outlook OAuth credentials not configured');
-      }
-
-      const state = this.generateSecureState();
-      const callbackUrl =
-        this.configService.get<string>('OUTLOOK_CALLBACK_URL') ||
-        'http://localhost:5001/auth/outlook/callback';
-
-      this.gmailOAuthStates.set(state, {
-        levelId,
-        levelType,
-        app_code,
-        email,
-        timestamp: Date.now(),
-      });
-
-      // Auto-cleanup after 10 minutes
-      setTimeout(
-        () => {
-          this.gmailOAuthStates.delete(state);
-        },
-        10 * 60 * 1000,
-      );
-
-      const scopes = [
-        'https://graph.microsoft.com/Mail.Send',
-        'https://graph.microsoft.com/User.Read',
-      ];
-
-      const authUrl =
-        `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize?` +
-        `client_id=${clientId}&` +
-        `response_type=code&` +
-        `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
-        `scope=${encodeURIComponent(scopes.join(' '))}&` +
-        `state=outlook_config:${state}&` +
-        `response_mode=query&` +
-        `prompt=consent` +
-        (email ? `&login_hint=${encodeURIComponent(email)}` : '');
-
-      return { authUrl, state };
-    } catch (error) {
-      this.logger.error('Error initializing Outlook OAuth:', error.message);
-      throw new Error('Failed to initialize Outlook OAuth');
-    }
-  }
-
-  async handleOutlookOAuthCallback(
-    code: string,
-    state: string,
-  ): Promise<GmailSSOResult> {
-    try {
-      const oauthState = this.gmailOAuthStates.get(state);
-      if (!oauthState) {
-        throw new Error('Invalid or expired OAuth state');
-      }
-
-      this.gmailOAuthStates.delete(state);
-
-      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
-        throw new Error('OAuth state expired');
-      }
-
-      const clientId = this.configService.get<string>('OUTLOOK_CLIENT_ID');
-      const clientSecret = this.configService.get<string>(
-        'OUTLOOK_CLIENT_SECRET',
-      );
-      const tenantId = this.configService.get<string>('OUTLOOK_TENANT_ID');
-      const callbackUrl =
-        this.configService.get<string>('OUTLOOK_CALLBACK_URL') ||
-        'http://localhost:5001/auth/outlook/callback';
-
-      // Exchange code for tokens
-      const tokenResponse = await fetch(
-        `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-          },
-          body: new URLSearchParams({
-            client_id: clientId!,
-            client_secret: clientSecret!,
-            code: code,
-            redirect_uri: callbackUrl,
-            grant_type: 'authorization_code',
-          }),
-        },
-      );
-
-      const tokens = await tokenResponse.json();
-
-      if (!tokens.access_token) {
-        throw new Error('Failed to obtain access token');
-      }
-
-      // Get user info from Microsoft Graph
-      const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
-        headers: {
-          Authorization: `Bearer ${tokens.access_token}`,
-        },
-      });
-
-      const userInfo = await userResponse.json();
-      const email = userInfo.mail || userInfo.userPrincipalName;
-
-      if (!email) {
-        throw new Error('Failed to get user email');
-      }
-
-      // Validate that no active EMAIL configuration exists
-      await this.validateUniqueActiveConfig(
-        oauthState.levelId,
-        oauthState.levelType,
-        oauthState.app_code,
-        'EMAIL',
-        'outlook',
-      );
-
-      const outlookConfig = {
-        clientId,
-        tenantId,
-        email: email,
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        scope: tokens.scope,
-        tokenType: tokens.token_type,
-        expiresIn: tokens.expires_in,
-      };
-
-      // Create integration config
-      const config = this.configRepository.create({
-        app_code: oauthState.app_code,
-        integration_type: 'EMAIL',
-        integration_provider: 'outlook',
-        integration_source_id: 1, // Outlook source ID
-        level_id: oauthState.levelId,
-        level_type: oauthState.levelType,
-        status: 1,
-        priority: 1,
-        is_default: false,
-        config_json: outlookConfig as any,
-      });
-
-      const savedConfig = await this.configRepository.save(config);
-
-      this.logger.log(
-        `Outlook OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
-      );
-
-      return {
-        hubId: savedConfig.id,
-        configId: savedConfig.id,
-      };
-    } catch (error) {
-      this.logger.error(
-        'Error handling Outlook OAuth callback:',
-        error.message,
-      );
-      throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
-    }
-  }
-
-  async getIntegrationConfigById(hubId: number): Promise<
-    | (IntegrationConfig & {
-        config: IntegrationConfig;
-        linkedSource?: string;
-        configDetails?: any;
-      })
-    | null
-  > {
-    try {
-      // Find the integration config by ID
-      const integrationConfig = await this.configRepository.findOne({
-        where: { id: hubId },
-      });
-
-      if (!integrationConfig) {
-        return null;
-      }
-
-      // Extract linked source and config details
-      const linkedSource = this.extractLinkedSource(
-        integrationConfig.integration_type,
-        integrationConfig.integration_provider,
-        integrationConfig.config_json,
-      );
-
-      const configDetails = this.extractConfigDetails(
-        integrationConfig.integration_type,
-        integrationConfig.integration_provider,
-        integrationConfig.config_json,
-      );
-
-      return {
-        ...integrationConfig,
-        config: integrationConfig,
-        linkedSource,
-        configDetails,
-      };
-    } catch (error) {
-      this.logger.error(
-        `Error fetching communication config by ID ${hubId}:`,
-        error.message,
-      );
-      throw new Error(
-        `Failed to fetch communication configuration: ${error.message}`,
-      );
-    }
-  }
-
-  async getIntegrationTemplates(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-    integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
-  ): Promise<{
-    success: boolean;
-    data?: Array<{
-      label: string;
-      value: string;
-    }>;
-    error?: string;
-  }> {
-    try {
-      // Get active configuration for the integration type
-      const config = await this.getSingleActiveConfig(
-        levelId,
-        levelType,
-        app_code,
-        integration_type,
-      );
-
-      if (!config) {
-        return {
-          success: false,
-          error: `No active ${integration_type} configuration found for this level`,
-        };
-      }
-
-      // Create strategy instance
-      const strategy = this.integrationFactory.create(
-        config.integration_type,
-        'API',
-        config.integration_provider,
-      );
-
-      // Check if strategy supports getTemplates
-      if (typeof (strategy as any).getTemplates !== 'function') {
-        return {
-          success: false,
-          error: `Template retrieval not supported for provider: ${config.integration_provider}`,
-        };
-      }
-
-      // Call getTemplates method
-      return await (strategy as any).getTemplates(config.config_json);
-    } catch (error) {
-      this.logger.error(
-        `Error fetching templates for ${integration_type} level ${levelId}/${levelType}:`,
-        error.message,
-      );
-      return {
-        success: false,
-        error: `Failed to fetch templates: ${error.message}`,
-      };
-    }
-  }
-
-  async getSendGridTemplates(
-    levelId: number,
-    levelType: string,
-    app_code: string,
-  ): Promise<{
-    success: boolean;
-    data?: Array<{
-      label: string;
-      value: string;
-    }>;
-    error?: string;
-  }> {
-    try {
-      // Find active SendGrid configurations for this level
-      const hubs = await this.getActiveConfigs(
-        levelId,
-        levelType,
-        app_code,
-        'EMAIL',
-      );
-
-      // Look for SendGrid provider
-      const sendGridHub = hubs.find(
-        (hub) => hub.integration_provider === 'sendgrid',
-      );
-
-      if (!sendGridHub) {
-        return {
-          success: false,
-          error: 'No active SendGrid configuration found for this level',
-        };
-      }
-
-      // Extract API key from configuration
-      const apiKey = sendGridHub.config_json?.apiKey;
-
-      if (!apiKey) {
-        return {
-          success: false,
-          error: 'SendGrid API key not found in configuration',
-        };
-      }
-
-      // Use the SendGrid strategy to fetch templates
-      return this.sendGridApiStrategy.getTemplates(apiKey);
-    } catch (error) {
-      this.logger.error(
-        `Error fetching SendGrid templates for level ${levelId}/${levelType}:`,
-        error.message,
-      );
-      return {
-        success: false,
-        error: `Failed to fetch SendGrid templates: ${error.message}`,
-      };
-    }
-  }
-
-  async getSendGridVerifiedSenders(apiKey: string): Promise<{
-    success: boolean;
-    data?: Array<{
-      label: string;
-      value: string;
-    }>;
-    error?: string;
-  }> {
-    try {
-      if (!apiKey) {
-        return {
-          success: false,
-          error: 'SendGrid API key not found in configuration',
-        };
-      }
-
-      // Use the SendGrid strategy to fetch verified senders
-      return this.sendGridApiStrategy.getVerifiedSenders(apiKey);
-    } catch (error) {
-      this.logger.error(
-        `Error fetching SendGrid verified senders`,
-        error.message,
-      );
-      return {
-        success: false,
-        error: `Failed to fetch SendGrid verified senders: ${error.message}`,
-      };
-    }
-  }
-
-  // UserIntegration Management Methods
-
-  async createUserIntegration(
-    createDto: CreateUserIntegrationDto,
-  ): Promise<UserIntegration> {
-    try {
-      // Check if mapping already exists
-      const existing = await this.userIntegrationRepository.findOne({
-        where: {
-          user_id: createDto.user_id,
-          integration_config_id: createDto.integration_config_id,
-        },
-      });
-
-      if (existing) {
-        throw new Error('User integration mapping already exists');
-      }
-
-      // Verify integration config exists
-      const config = await this.configRepository.findOne({
-        where: { id: createDto.integration_config_id },
-      });
-
-      if (!config) {
-        throw new Error('Integration configuration not found');
-      }
-
-      const userIntegration = this.userIntegrationRepository.create(createDto);
-      return await this.userIntegrationRepository.save(userIntegration);
-    } catch (error) {
-      this.logger.error(
-        `Error creating user integration mapping: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async bulkCreateUserIntegration(
-    bulkDto: BulkCreateUserIntegrationDto,
-  ): Promise<{
-    created: UserIntegration[];
-    updated: UserIntegration[];
-    failed: Array<{ data: CreateUserIntegrationDto; error: string }>;
-    summary: {
-      total: number;
-      created: number;
-      updated: number;
-      failed: number;
-    };
-  }> {
-    const created: UserIntegration[] = [];
-    const updated: UserIntegration[] = [];
-    const failed: Array<{ data: CreateUserIntegrationDto; error: string }> = [];
-
-    try {
-      for (const createDto of bulkDto.user_integrations) {
-        try {
-          // Check if mapping already exists
-          const existing = await this.userIntegrationRepository.findOne({
-            where: {
-              user_id: createDto.user_id,
-              integration_config_id: createDto.integration_config_id,
-            },
-          });
-
-          if (existing) {
-            // Update existing mapping
-            if (createDto.external_user_id !== undefined) {
-              existing.external_user_id = createDto.external_user_id;
-            }
-            if (createDto.external_user_data !== undefined) {
-              existing.external_user_data = createDto.external_user_data;
-            }
-            if (createDto.is_active !== undefined) {
-              existing.is_active = createDto.is_active;
-            }
-
-            const updatedIntegration =
-              await this.userIntegrationRepository.save(existing);
-            updated.push(updatedIntegration);
-
-            this.logger.log(
-              `Updated user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`,
-            );
-          } else {
-            // Verify integration config exists
-            const config = await this.configRepository.findOne({
-              where: { id: createDto.integration_config_id },
-            });
-
-            if (!config) {
-              failed.push({
-                data: createDto,
-                error: 'Integration configuration not found',
-              });
-              continue;
-            }
-
-            // Create new mapping
-            const userIntegration =
-              this.userIntegrationRepository.create(createDto);
-            const savedIntegration =
-              await this.userIntegrationRepository.save(userIntegration);
-            created.push(savedIntegration);
-
-            this.logger.log(
-              `Created user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`,
-            );
-          }
-        } catch (error) {
-          failed.push({
-            data: createDto,
-            error: error.message || 'Unknown error',
-          });
-          this.logger.error(
-            `Error processing user integration for user ${createDto.user_id}: ${error.message}`,
-          );
-        }
-      }
-
-      const summary = {
-        total: bulkDto.user_integrations.length,
-        created: created.length,
-        updated: updated.length,
-        failed: failed.length,
-      };
-
-      this.logger.log(
-        `Bulk user integration completed: ${summary.created} created, ${summary.updated} updated, ${summary.failed} failed`,
-      );
-
-      return { created, updated, failed, summary };
-    } catch (error) {
-      this.logger.error(
-        `Error in bulk user integration creation: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async getUserIntegrations(userId: number): Promise<UserIntegration[]> {
-    try {
-      return await this.userIntegrationRepository.find({
-        where: { user_id: userId, is_active: true },
-        order: { created_at: 'DESC' },
-      });
-    } catch (error) {
-      this.logger.error(
-        `Error fetching user integrations for user ${userId}: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async getConfigUserIntegrations(
-    configId: number,
-  ): Promise<UserIntegration[]> {
-    try {
-      return await this.userIntegrationRepository.find({
-        where: { integration_config_id: configId, is_active: true },
-        order: { created_at: 'DESC' },
-      });
-    } catch (error) {
-      this.logger.error(
-        `Error fetching user integrations for config ${configId}: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async getUserIntegrationByUserAndConfig(
-    userId: number,
-    configId: number,
-  ): Promise<UserIntegration | null> {
-    try {
-      return await this.userIntegrationRepository.findOne({
-        where: {
-          user_id: userId,
-          integration_config_id: configId,
-          is_active: true,
-        },
-      });
-    } catch (error) {
-      this.logger.error(
-        `Error fetching user integration for user ${userId} and config ${configId}: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async updateUserIntegration(
-    id: number,
-    updateDto: UpdateUserIntegrationDto,
-  ): Promise<UserIntegration> {
-    try {
-      const userIntegration = await this.userIntegrationRepository.findOne({
-        where: { id },
-      });
-
-      if (!userIntegration) {
-        throw new Error('User integration mapping not found');
-      }
-
-      Object.assign(userIntegration, updateDto);
-      return await this.userIntegrationRepository.save(userIntegration);
-    } catch (error) {
-      this.logger.error(
-        `Error updating user integration ${id}: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  async deleteUserIntegration(id: number): Promise<void> {
-    try {
-      const userIntegration = await this.userIntegrationRepository.findOne({
-        where: { id },
-      });
-
-      if (!userIntegration) {
-        throw new Error('User integration mapping not found');
-      }
-
-      await this.userIntegrationRepository.remove(userIntegration);
-    } catch (error) {
-      this.logger.error(
-        `Error deleting user integration ${id}: ${error.message}`,
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Get user integration data for a specific integration strategy
-   * This method is intended to be used by strategies that need user mapping
-   */
-  async getUserIntegrationForStrategy(
-    userId: number,
-    integrationConfigId: number,
-  ): Promise<any | null> {
-    try {
-      const userIntegration = await this.getUserIntegrationByUserAndConfig(
-        userId,
-        integrationConfigId,
-      );
-
-      if (!userIntegration) {
-        return null;
-      }
-
-      return {
-        external_user_id: userIntegration.external_user_id,
-        external_user_data: userIntegration.external_user_data,
-      };
-    } catch (error) {
-      this.logger.error(
-        `Error fetching user integration data for strategy: ${error.message}`,
-      );
-      return null;
-    }
-  }
-
-  /**
-   * Check agent status for TELEPHONE integration
-   * Works with any provider that implements checkAgentStatus method
-   */
-  async checkAgentStatus(
-    levelId: number,
-    levelType: string,
-    appCode: string,
-    userId: number,
-    integrationType: 'TELEPHONE' = 'TELEPHONE',
-  ): Promise<{
-    success: boolean;
-    isReady?: boolean;
-    state?: string;
-    agentInfo?: any;
-    error?: string;
-  }> {
-    try {
-      // Get the active configuration
-      const config = await this.getSingleActiveConfig(
-        levelId,
-        levelType,
-        appCode,
-        integrationType,
-      );
-
-      if (!config) {
-        return {
-          success: false,
-          error: 'No active TELEPHONE configuration found',
-        };
-      }
-
-      // Get user integration mapping
-      const userIntegration = await this.getUserIntegrationByUserAndConfig(
-        userId,
-        config.id,
-      );
-
-      if (!userIntegration) {
-        return {
-          success: false,
-          error:
-            'User integration mapping not found. Please configure agent details.',
-        };
-      }
-
-      // Create strategy instance
-      const strategy = this.integrationFactory.create(
-        config.integration_type,
-        'API', // service is deprecated, using default
-        config.integration_provider,
-      );
-
-      // Get the merged config with user data
-      let mergedConfig = config.config_json;
-
-      if (strategy.createUserSpecificConfig) {
-        mergedConfig = strategy.createUserSpecificConfig(
-          config.config_json,
-          userIntegration.external_user_id,
-        );
-      }
-
-      // Check if strategy supports agent status check
-      if (typeof (strategy as any).checkAgentStatus !== 'function') {
-        return {
-          success: false,
-          error: `Agent status check not supported for provider: ${config.integration_provider}`,
-        };
-      }
-
-      // Check agent status
-      const statusResult = await (strategy as any).checkAgentStatus(
-        mergedConfig,
-      );
-
-      return {
-        success: true,
-        isReady: statusResult.isReady,
-        state: statusResult.state,
-        error: statusResult.error,
-      };
-    } catch (error) {
-      this.logger.error(
-        `Error checking agent status: ${error.message}`,
-        error.stack,
-      );
-      return {
-        success: false,
-        error: error.message || 'Failed to check agent status',
-      };
-    }
-  }
-}
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Not, Repository } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+import { google } from 'googleapis';
+import { IntegrationConfig } from '../entity/integration-config.entity';
+import { UserIntegration } from '../entity/user-integration.entity';
+import { IntegrationEntityMapper } from '../entity/integration-entity-mapper.entity';
+import { IntegrationFactory } from '../factories/integration.factory';
+import { IntegrationResult } from '../strategies/integration.strategy';
+import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
+import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
+import { IntegrationQueueService } from './integration-queue.service';
+import {
+  BulkMessageDto,
+  BulkCreateUserIntegrationDto,
+  CreateUserIntegrationDto,
+  UpdateUserIntegrationDto,
+} from '../dto/create-config.dto';
+import { FieldMapperService } from '../../mapper/service/field-mapper.service';
+import {
+  COMM_TEMPLATE,
+  ENTITYTYPE_MEDIA,
+} from '../../../constant/global.constant';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { MediaDataService } from '../../meta/service/media-data.service';
+import axios from 'axios';
+
+export interface SendMessageDto {
+  levelId: number;
+  levelType: string;
+  app_code: string;
+  to: string;
+  message: string;
+  mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+  priority?: number;
+  user_id?: number;
+}
+
+export interface GenericMessageDto {
+  levelId: number;
+  levelType: string;
+  app_code: string;
+  to: string | string[];
+  message: string;
+  subject?: string;
+  type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+  priority?: 'high' | 'medium' | 'low';
+  cc?: string | string[];
+  bcc?: string | string[];
+  html?: string;
+  attachments?: any[];
+  mediaUrl?: string;
+  templateId?: string;
+  variables?: Record<string, any>;
+  user_id?: number;
+  entity_type?: string;
+  entity_id?: number;
+  organization_id?: number;
+  mapped_entities?: any;
+}
+
+export interface IntegrationConfigWithConfig extends IntegrationConfig {
+  config?: any;
+}
+
+interface GmailOAuthState {
+  levelId: number;
+  levelType: string;
+  app_code: string;
+  email?: string;
+  timestamp: number;
+}
+
+export interface GmailSSOResult {
+  hubId: number;
+  configId: number;
+}
+
+@Injectable()
+export class IntegrationService {
+  private readonly logger = new Logger(IntegrationService.name);
+  private readonly gmailOAuthStates = new Map<string, GmailOAuthState>();
+
+  constructor(
+    @InjectRepository(IntegrationConfig)
+    private readonly configRepository: Repository<IntegrationConfig>,
+    @InjectRepository(UserIntegration)
+    private readonly userIntegrationRepository: Repository<UserIntegration>,
+    @InjectRepository(IntegrationEntityMapper)
+    private readonly entityMapperRepository: Repository<IntegrationEntityMapper>,
+    private readonly dataSource: DataSource,
+    private readonly integrationFactory: IntegrationFactory,
+    private readonly gmailApiStrategy: GmailApiStrategy,
+    private readonly sendGridApiStrategy: SendGridApiStrategy,
+    private readonly configService: ConfigService,
+    private readonly mediaService: MediaDataService,
+    @Inject('FieldMapperService')
+    private readonly fieldMapperService: FieldMapperService,
+    private readonly entityService: EntityServiceImpl,
+    @Inject(forwardRef(() => IntegrationQueueService))
+    private readonly queueService?: IntegrationQueueService,
+  ) {}
+
+  private deriveServiceType(
+    integration_type: string,
+    integration_provider: string,
+    config_json: any,
+  ): string {
+    // All integrations use API only (no SMTP support)
+    return 'API';
+  }
+
+  async sendMessage({
+    levelId,
+    levelType,
+    app_code,
+    to,
+    message,
+    mode,
+    priority = 1,
+    user_id,
+  }: SendMessageDto): Promise<IntegrationResult> {
+    try {
+      // Get active communication configs for the level
+      const configs = await this.getActiveConfigs(
+        levelId,
+        levelType,
+        app_code,
+        mode,
+      );
+
+      if (!configs.length) {
+        throw new Error(
+          `No active communication configuration found for ${levelType} ${levelId}`,
+        );
+      }
+
+      // Sort by priority if provided
+      const sortedConfigs = this.sortConfigsByPriority(configs, priority);
+
+      // Try each config until one succeeds
+      for (const config of sortedConfigs) {
+        try {
+          const result = await this.sendViaConfig(config, to, message, user_id);
+          if (result.success) {
+            this.logger.log(
+              `Message sent successfully via ${config.integration_provider}`,
+            );
+            return result;
+          }
+
+          this.logger.warn(
+            `Failed to send via ${config.integration_provider}: ${result.error}`,
+          );
+        } catch (error) {
+          this.logger.error(
+            `Error sending via ${config.integration_provider}:`,
+            error.message,
+          );
+          continue;
+        }
+      }
+
+      throw new Error('All communication providers failed');
+    } catch (error) {
+      this.logger.error('Communication service error:', error.message);
+      throw error;
+    }
+  }
+
+  async getActiveConfigs(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ): Promise<IntegrationConfig[]> {
+    const queryBuilder = this.configRepository
+      .createQueryBuilder('config')
+      .where('config.level_id = :levelId', { levelId })
+      .andWhere('config.level_type = :levelType', { levelType })
+      .andWhere('config.app_code = :app_code', { app_code })
+      .andWhere('config.status = 1');
+
+    if (mode) {
+      queryBuilder.andWhere('config.integration_type = :mode', { mode });
+    }
+
+    return await queryBuilder.getMany();
+  }
+
+  async getSingleActiveConfig(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ): Promise<IntegrationConfig | null> {
+    const configs = await this.configRepository
+      .createQueryBuilder('config')
+      .where('config.level_id = :levelId', { levelId })
+      .andWhere('config.level_type = :levelType', { levelType })
+      .andWhere('config.app_code = :app_code', { app_code })
+      .andWhere('config.integration_type = :integration_type', {
+        integration_type,
+      })
+      .andWhere('config.status = 1')
+      .orderBy('config.is_default', 'DESC')
+      .addOrderBy('config.priority', 'ASC')
+      .addOrderBy('config.created_at', 'DESC')
+      .getMany();
+
+    return configs.length > 0 ? configs[0] : null;
+  }
+
+  async getAllIntegrationData(
+    loggedInUser,
+    integration_type?: string,
+  ): Promise<any[]> {
+    try {
+      const allIntegrationData = await this.dataSource.query(
+        `SELECT *
+         FROM frm_integration_master`,
+      );
+
+      // if entityType is provided, filter the results
+      if (integration_type) {
+        return allIntegrationData.filter(
+          (data) =>
+            data.integration_type.toLowerCase() ===
+            integration_type.toLowerCase(),
+        );
+      }
+
+      return allIntegrationData;
+    } catch (error) {
+      this.logger.error('Error fetching integration data:', error.message);
+      return [];
+    }
+  }
+
+  private sortConfigsByPriority(
+    configs: IntegrationConfig[],
+    _priority: number,
+  ): IntegrationConfig[] {
+    return configs.sort((a, b) => {
+      // First sort by default (true comes first)
+      if (a.is_default !== b.is_default) {
+        return a.is_default ? -1 : 1;
+      }
+      // Then by priority (lower number = higher priority)
+      return a.priority - b.priority;
+    });
+  }
+
+  private async sendViaConfig(
+    config: IntegrationConfig,
+    to: string,
+    message: string,
+    user_id?: number,
+  ): Promise<IntegrationResult> {
+    const strategy = this.integrationFactory.create(
+      config.integration_type,
+      'API', // service is deprecated, using default
+      config.integration_provider,
+    );
+
+    // Get user integration data if user_id provided
+    let finalConfig = config.config_json;
+    if (user_id) {
+      const userIntegrationData = await this.getUserIntegrationForStrategy(
+        user_id,
+        config.id,
+      );
+
+      if (userIntegrationData) {
+        finalConfig = {
+          ...config.config_json,
+          external_user_id: userIntegrationData.external_user_id,
+        };
+      }
+    }
+
+    const result = await strategy.sendMessage(to, message, finalConfig);
+
+    // If token was refreshed, update it in the database
+    if (result.refreshedToken && result.success) {
+      try {
+        const currentConfig = config.config_json as any;
+        const updatedConfig = {
+          ...currentConfig,
+          accessToken: result.refreshedToken,
+        };
+
+        await this.configRepository.update(config.id, {
+          config_json: updatedConfig,
+        } as any);
+
+        this.logger.log(
+          `Updated access token for ${config.integration_provider} configuration`,
+        );
+      } catch (error) {
+        this.logger.warn(
+          `Failed to update refreshed token in database: ${error.message}`,
+        );
+      }
+    }
+
+    return result;
+  }
+
+  async createIntegrationConfig(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
+    integration_source_id: number,
+    config: any,
+    priority?: number,
+    is_default?: boolean,
+  ): Promise<
+    IntegrationConfig | { authUrl: string; state: string; message: string }
+  > {
+    // Validate that no duplicate provider configurations exist
+    await this.validateUniqueActiveConfig(
+      levelId,
+      levelType,
+      app_code,
+      configType,
+      provider,
+    );
+
+    // Deactivate all other configurations of the same integration type
+    await this.configRepository.update(
+      {
+        level_id: levelId,
+        level_type: levelType,
+        app_code: app_code,
+        integration_type: configType,
+        status: 1,
+      },
+      { status: 0 },
+    );
+
+    // Validate provider and get service type from supported combinations
+    const supportedCombinations = await this.getSupportedCombinations();
+    const validCombination = supportedCombinations.find(
+      (combo) =>
+        combo.mode === configType &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
+    );
+
+    if (!validCombination) {
+      throw new Error(`Unsupported combination: ${configType}/${provider}`);
+    }
+
+    const service = validCombination.service;
+
+    // Check if this requires OAuth flow
+    const requiresOAuth = this.requiresOAuthFlow(configType, provider, config);
+
+    if (requiresOAuth) {
+      // Generate OAuth URL and return it instead of creating config immediately
+      return await this.generateOAuthUrl(
+        levelId,
+        levelType,
+        app_code,
+        configType,
+        provider,
+        integration_source_id,
+        config,
+        priority,
+        is_default,
+      );
+    }
+
+    // Direct config creation (non-OAuth flow)
+    return await this.createDirectConfig(
+      levelId,
+      levelType,
+      app_code,
+      configType,
+      provider,
+      integration_source_id,
+      config,
+      priority,
+      is_default,
+    );
+  }
+
+  getSupportedCombinations(): {
+    mode: string;
+    service: string;
+    provider: string;
+  }[] {
+    return this.integrationFactory.getAllSupportedCombinations();
+  }
+
+  async getLevelConfigs(
+    levelId: number,
+    levelType: string,
+    filters?: {
+      app_code?: string;
+      integration_type?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE';
+      integration_provider?: string;
+    },
+  ): Promise<
+    Array<IntegrationConfig & { linkedSource?: string; configDetails?: any }>
+  > {
+    const where: any = { level_id: levelId, level_type: levelType };
+
+    if (filters?.app_code) {
+      where.app_code = filters.app_code;
+    }
+
+    if (filters?.integration_type) {
+      where.integration_type = filters.integration_type;
+    }
+
+    if (filters?.integration_provider) {
+      where.integration_provider = filters.integration_provider;
+    }
+
+    const hubs = await this.configRepository.find({
+      where,
+      order: { created_at: 'DESC' },
+    });
+
+    // Enhance hubs with linked source information
+    const enhancedHubs = await Promise.all(
+      hubs.map(async (hub) => {
+        try {
+          const relatedConfig = await this.configRepository.findOne({
+            where: { id: hub.id },
+          });
+
+          if (!relatedConfig) {
+            return {
+              ...hub,
+              linkedSource: 'Configuration not found',
+              configDetails: null,
+            };
+          }
+
+          const linkedSource = this.extractLinkedSource(
+            hub.integration_type,
+            hub.integration_provider,
+            relatedConfig.config_json,
+          );
+
+          const configDetails = this.extractConfigDetails(
+            hub.integration_type,
+            hub.integration_provider,
+            relatedConfig.config_json,
+          );
+
+          return {
+            ...hub,
+            linkedSource,
+            configDetails,
+          };
+        } catch (error) {
+          this.logger.warn(
+            `Error extracting linked source for hub ${hub.id}:`,
+            error.message,
+          );
+          return {
+            ...hub,
+            linkedSource: 'Error retrieving source',
+            configDetails: null,
+          };
+        }
+      }),
+    );
+
+    return enhancedHubs;
+  }
+
+  private extractLinkedSource(
+    configType: string,
+    provider: string,
+    configJson: any,
+  ): string {
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+
+    try {
+      switch (key) {
+        // Gmail configurations
+        case 'email_gmail':
+        case 'email_smtp_gmail':
+          return configJson?.email || 'Gmail account not configured';
+
+        // Outlook configurations
+        case 'email_outlook':
+        case 'email_smtp_outlook':
+          return configJson?.email || 'Outlook account not configured';
+
+        // WhatsApp configurations
+        case 'wa_api_whatsapp':
+          return configJson?.phoneNumberId
+            ? `WhatsApp Business: ${configJson.phoneNumberId}`
+            : 'WhatsApp not configured';
+
+        // SMS configurations
+        case 'sms_third_party_twilio':
+          return configJson?.fromNumber
+            ? `Twilio: ${configJson.fromNumber}`
+            : 'Twilio number not configured';
+
+        case 'sms_third_party_knowlarity':
+          return configJson?.callerNumber
+            ? `Knowlarity: ${configJson.callerNumber}`
+            : 'Knowlarity number not configured';
+
+        // Telephone configurations
+        case 'telephone_third_party_knowlarity':
+          return configJson?.callerNumber
+            ? `Knowlarity Voice: ${configJson.callerNumber}`
+            : 'Knowlarity voice number not configured';
+
+        case 'telephone_third_party_ozonetel':
+          return configJson?.userName
+            ? `Ozonetel Voice: ${configJson.userName}`
+            : 'Ozonetel voice not configured';
+
+        // AWS SES configurations
+        case 'email_aws-ses':
+        case 'email_ses':
+          return configJson?.fromEmail || 'AWS SES not configured';
+
+        // SendGrid configurations
+        case 'email_smtp_sendgrid':
+          return configJson?.from || 'SendGrid not configured';
+
+        // Generic SMTP configurations
+        case 'email_smtp_custom':
+        case 'email_smtp_generic':
+          return configJson?.from || configJson?.user || 'SMTP not configured';
+
+        default:
+          // Generic fallback - try to find common identifier fields
+          if (configJson?.email) return configJson.email;
+          if (configJson?.from) return configJson.from;
+          if (configJson?.user) return configJson.user;
+          if (configJson?.phoneNumberId) return configJson.phoneNumberId;
+          if (configJson?.fromNumber) return configJson.fromNumber;
+          if (configJson?.callerNumber) return configJson.callerNumber;
+
+          return `${provider} configured`;
+      }
+    } catch (error) {
+      return 'Configuration error';
+    }
+  }
+
+  private extractConfigDetails(
+    configType: string,
+    provider: string,
+    configJson: any,
+  ): any {
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+
+    try {
+      switch (key) {
+        // Gmail configurations
+        case 'email_gmail':
+          return {
+            email: configJson?.email,
+            authMethod: configJson?.authMethod || 'OAUTH2',
+            hasRefreshToken: !!configJson?.refreshToken,
+            isExpired: configJson?.expiryDate
+              ? new Date(configJson.expiryDate) < new Date()
+              : false,
+          };
+
+        case 'email_smtp_gmail':
+          return {
+            email: configJson?.email,
+            authMethod: 'SMTP',
+            hasPassword: !!configJson?.password,
+          };
+
+        // Outlook configurations
+        case 'email_outlook':
+          return {
+            email: configJson?.email,
+            authMethod: 'OAUTH2',
+            hasRefreshToken: !!configJson?.refreshToken,
+            tenantId: configJson?.tenantId,
+          };
+
+        case 'email_smtp_outlook':
+          return {
+            email: configJson?.email,
+            authMethod: 'SMTP',
+            hasPassword: !!configJson?.password,
+          };
+
+        // WhatsApp configurations
+        case 'wa_api_whatsapp':
+          return {
+            phoneNumberId: configJson?.phoneNumberId,
+            apiVersion: configJson?.apiVersion || 'v17.0',
+            hasAccessToken: !!configJson?.accessToken,
+          };
+
+        // SMS configurations
+        case 'sms_third_party_twilio':
+          return {
+            fromNumber: configJson?.fromNumber,
+            accountSid: configJson?.accountSid
+              ? configJson.accountSid.substring(0, 8) + '...'
+              : null,
+            hasAuthToken: !!configJson?.authToken,
+          };
+
+        case 'sms_third_party_knowlarity':
+          return {
+            callerNumber: configJson?.callerNumber,
+            callType: configJson?.callType || 'sms',
+            hasApiSecret: !!configJson?.apiSecret,
+          };
+
+        // Telephone configurations
+        case 'telephone_third_party_knowlarity':
+          return {
+            callerNumber: configJson?.callerNumber,
+            callType: configJson?.callType || 'voice',
+            language: configJson?.language || 'en',
+            hasApiSecret: !!configJson?.apiSecret,
+          };
+
+        case 'telephone_third_party_ozonetel':
+          return {
+            userName: configJson?.userName,
+            agentID: configJson?.agentID,
+            campaignName: configJson?.campaignName,
+            agentLoginUrl: configJson?.agentLoginUrl,
+            hasApiKey: !!configJson?.apiKey,
+          };
+
+        // AWS SES configurations
+        case 'email_aws-ses':
+        case 'email_ses':
+          return {
+            fromEmail: configJson?.fromEmail,
+            region: configJson?.region,
+            hasCredentials: !!(
+              configJson?.accessKeyId && configJson?.secretAccessKey
+            ),
+          };
+
+        // SendGrid configurations
+        case 'email_smtp_sendgrid':
+          return {
+            from: configJson?.from,
+            hasApiKey: !!configJson?.apiKey,
+            templateId: configJson?.templateId,
+          };
+
+        // Generic SMTP configurations
+        case 'email_smtp_custom':
+        case 'email_smtp_generic':
+          return {
+            host: configJson?.host,
+            port: configJson?.port || 587,
+            secure: configJson?.secure || false,
+            from: configJson?.from || configJson?.user,
+            hasCredentials: !!(configJson?.user && configJson?.password),
+          };
+
+        default: {
+          // Generic details - return safe subset of config
+          const safeConfig: any = {};
+
+          // Include non-sensitive fields
+          const safeFields = [
+            'email',
+            'from',
+            'user',
+            'host',
+            'port',
+            'secure',
+            'phoneNumberId',
+            'fromNumber',
+            'callerNumber',
+            'region',
+            'apiVersion',
+            'callType',
+            'language',
+            'templateId',
+          ];
+
+          safeFields.forEach((field) => {
+            if (configJson?.[field]) {
+              safeConfig[field] = configJson[field];
+            }
+          });
+
+          // Include boolean indicators for sensitive fields
+          const sensitiveFields = [
+            'accessToken',
+            'refreshToken',
+            'password',
+            'authToken',
+            'apiKey',
+            'apiSecret',
+            'clientSecret',
+            'secretAccessKey',
+          ];
+
+          sensitiveFields.forEach((field) => {
+            if (configJson?.[field]) {
+              safeConfig[
+                `has${field.charAt(0).toUpperCase() + field.slice(1)}`
+              ] = true;
+            }
+          });
+
+          return safeConfig;
+        }
+      }
+    } catch (error) {
+      return { error: 'Unable to extract configuration details' };
+    }
+  }
+
+  async updateConfigStatus(hubId: number, status: number): Promise<void> {
+    // Find the hub to get level and type information
+    const config = await this.configRepository.findOne({
+      where: { id: hubId },
+    });
+
+    if (!config) {
+      throw new Error('Integration configuration not found');
+    }
+
+    // If activating, deactivate ALL other configs of the same integration type
+    if (status === 1) {
+      await this.configRepository.update(
+        {
+          level_id: config.level_id,
+          level_type: config.level_type,
+          app_code: config.app_code,
+          integration_type: config.integration_type,
+          status: 1,
+          id: Not(hubId),
+        },
+        { status: 0 },
+      );
+    }
+
+    // Update the requested config
+    await this.configRepository.update(hubId, { status });
+  }
+
+  async deleteConfiguration(configId: number): Promise<void> {
+    // Find the hub to get the id
+    const config = await this.configRepository.findOne({
+      where: { id: configId },
+    });
+
+    if (!config) {
+      throw new Error('Integration configuration not found');
+    }
+
+    await this.configRepository.delete(configId);
+
+    this.logger.log(`Integration configuration deleted: ${configId}`);
+  }
+
+  async updateConfiguration(
+    hubId: number,
+    updateData: {
+      config?: any;
+      priority?: number;
+      is_default?: boolean;
+      status?: number;
+    },
+  ): Promise<IntegrationConfig & { config?: any }> {
+    // Find the existing hub
+    const config = await this.configRepository.findOne({
+      where: { id: hubId },
+    });
+
+    if (!config) {
+      throw new Error('Integration configuration not found');
+    }
+
+    // Update configuration JSON if provided
+    if (updateData.config) {
+      // Merge the new config with existing config
+      const updatedConfigJson = {
+        ...config.config_json,
+        ...updateData.config,
+      };
+
+      await this.configRepository.update(config.id, {
+        config_json: updatedConfigJson,
+      });
+    }
+
+    // Handle default configuration logic (simplified for now)
+    if (updateData.is_default === true) {
+      // Remove default from other configurations of same type and level
+      await this.configRepository.update(
+        {
+          level_id: config.level_id,
+          level_type: config.level_type,
+          integration_type: config.integration_type,
+          id: Not(hubId),
+        },
+        { is_default: false },
+      );
+    }
+
+    if (config.integration_type === 'TELEPHONE') {
+      try {
+        // Extract DID from config (could be did, callerNumber, or fromNumber)
+        const did = config.config_json.did;
+
+        if (did) {
+          await this.entityMapperRepository.delete({
+            integration_config_id: config.id,
+          });
+
+          const entityMapper = this.entityMapperRepository.create({
+            integration_config_id: config.id,
+            level_id: String(config.level_id),
+            level_type: config.level_type,
+            appcode: config.app_code,
+            did: did,
+            campaign_name: config.config_json.campaignName || null,
+          });
+
+          await this.entityMapperRepository.save(entityMapper);
+          this.logger.log(
+            `DID mapping created for TELEPHONE integration: ${did} for ${config.level_id} ${config.level_type}`,
+          );
+        }
+      } catch (error) {
+        this.logger.warn(
+          `Failed to create DID mapping for TELEPHONE integration: ${error.message}`,
+        );
+      }
+    }
+
+    // Apply direct config updates if any
+    const directUpdates: any = {};
+    if (updateData.priority !== undefined)
+      directUpdates.priority = updateData.priority;
+    if (updateData.is_default !== undefined)
+      directUpdates.is_default = updateData.is_default;
+    if (updateData.status !== undefined)
+      directUpdates.status = updateData.status;
+
+    if (Object.keys(directUpdates).length > 0) {
+      await this.configRepository.update(config.id, directUpdates);
+    }
+
+    // Fetch and return updated config
+    const updatedConfig = await this.configRepository.findOne({
+      where: { id: hubId },
+    });
+
+    return {
+      ...updatedConfig,
+      config: updatedConfig?.config_json,
+    } as any;
+  }
+
+  async sendGenericMessage(
+    messageDto: GenericMessageDto,
+  ): Promise<IntegrationResult> {
+    try {
+      const {
+        levelId,
+        levelType,
+        app_code,
+        to,
+        message,
+        type,
+        priority = 'medium',
+        html,
+        cc,
+        bcc,
+        attachments,
+        mediaUrl,
+        templateId,
+        user_id,
+        entity_id,
+        entity_type,
+        organization_id,
+        mapped_entities,
+      } = messageDto;
+
+      let subject = messageDto.subject;
+
+      // Auto-detect communication type if not specified
+      const communicationType = this.detectCommunicationType(to, type);
+
+      // Get active configs for the detected type
+      const configs = await this.getActiveConfigs(
+        levelId,
+        levelType,
+        app_code,
+        communicationType,
+      );
+
+      if (!configs.length) {
+        this.logger.warn(
+          `No communication hubs found for ${levelType} ${levelId}. Please configure integration providers using the createIntegrationConfig method.`,
+        );
+        throw new Error(
+          `No active ${communicationType} configuration found for ${levelType} ${levelId}. Please configure a communication provider first.`,
+        );
+      }
+
+      // Sort hubs by priority and default preference
+      const sortedConfigs = this.sortConfigsByPriorityAndDefault(
+        configs,
+        priority,
+      );
+
+      // Prepare enhanced config with additional parameters
+      const enhancedConfig = {
+        subject,
+        html,
+        cc,
+        bcc,
+        attachments,
+        mediaUrl,
+      };
+
+      const loggedInUser = {
+        id: user_id || null,
+        organization_id: organization_id || -1,
+        level_id: levelId,
+        level_type: levelType,
+        app_code: app_code,
+      };
+
+      // Handle multiple recipients by sending to each individually
+      if (Array.isArray(to)) {
+        const results: IntegrationResult[] = [];
+        let hasSuccess = false;
+
+        for (const recipient of to) {
+          for (const hub of sortedConfigs) {
+            try {
+              const serviceType = this.deriveServiceType(
+                hub.integration_type,
+                hub.integration_provider,
+                hub.config_json,
+              );
+              const strategy = this.integrationFactory.create(
+                hub.integration_type,
+                serviceType,
+                hub.integration_provider,
+              );
+
+              // Process template if provided
+              let variables;
+              let richText;
+              let externalTemplateId: string | undefined = undefined;
+              if (templateId) {
+                const templateData = await this.processTemplate(
+                  parseInt(templateId, 10),
+                  entity_type,
+                  entity_id,
+                  loggedInUser,
+                  mapped_entities,
+                );
+                variables = templateData.variables;
+                externalTemplateId = templateData.externalTemplateId;
+                richText = templateData.rich_text;
+                subject = templateData.subject;
+              }
+
+              // Merge config with enhanced parameters
+              let finalConfig = {
+                ...hub.config_json,
+                ...enhancedConfig,
+                templateId: externalTemplateId,
+                variables,
+                richText,
+                subject,
+              };
+
+              // Handle user integration if user_id provided
+              if (user_id) {
+                const userIntegrationData =
+                  await this.getUserIntegrationForStrategy(user_id, hub.id);
+
+                if (userIntegrationData) {
+                  finalConfig = {
+                    ...finalConfig,
+                    external_user_id: userIntegrationData.external_user_id,
+                  };
+                }
+              }
+
+              const result = await strategy.sendMessage(
+                recipient,
+                message,
+                finalConfig,
+              );
+
+              if (result.success) {
+                this.logger.log(
+                  `Generic message sent successfully via ${hub.integration_provider} to ${recipient}`,
+                );
+                results.push(result);
+                hasSuccess = true;
+                break; // Move to next recipient
+              }
+
+              this.logger.warn(
+                `Failed to send via ${hub.integration_provider} to ${recipient}: ${result.error}`,
+              );
+            } catch (error) {
+              this.logger.error(
+                `Error sending via ${hub.integration_provider} to ${recipient}:`,
+                error.message,
+              );
+              continue;
+            }
+          }
+        }
+
+        if (hasSuccess) {
+          return {
+            success: true,
+            messageId: results.map((r) => r.messageId).join(','),
+            provider: 'multiple',
+            service: 'multiple',
+            timestamp: new Date(),
+            message: results.map((r) => r.message).join(','),
+          };
+        }
+      } else {
+        // Handle single recipient
+        for (const hub of sortedConfigs) {
+          try {
+            const serviceType = this.deriveServiceType(
+              hub.integration_type,
+              hub.integration_provider,
+              hub.config_json,
+            );
+            const strategy = this.integrationFactory.create(
+              hub.integration_type,
+              serviceType,
+              hub.integration_provider,
+            );
+
+            // Process template if provided
+            let variables;
+            let externalTemplateId: string | undefined = undefined;
+            let richText;
+            if (templateId) {
+              const templateData = await this.processTemplate(
+                parseInt(templateId, 10),
+                entity_type,
+                entity_id,
+                loggedInUser,
+                mapped_entities,
+              );
+              variables = templateData.variables;
+              externalTemplateId = templateData.externalTemplateId;
+              richText = templateData.rich_text;
+              subject = templateData.subject;
+            }
+
+            // Merge config with enhanced parameters
+            let finalConfig = {
+              ...hub.config_json,
+              ...enhancedConfig,
+              templateId: externalTemplateId,
+              variables,
+              richText,
+            };
+
+            // Handle user integration if user_id provided
+            if (user_id) {
+              const userIntegrationData =
+                await this.getUserIntegrationForStrategy(user_id, hub.id);
+
+              if (userIntegrationData) {
+                finalConfig = {
+                  ...finalConfig,
+                  external_user_id: userIntegrationData.external_user_id,
+                };
+              }
+            }
+
+            const result = await strategy.sendMessage(to, message, finalConfig);
+
+            if (result.success) {
+              this.logger.log(
+                `Generic message sent successfully via ${hub.integration_provider} to ${to}`,
+              );
+              return result;
+            }
+
+            this.logger.warn(
+              `Failed to send via ${hub.integration_provider}: ${result.error}`,
+            );
+          } catch (error) {
+            this.logger.error(
+              `Error sending via ${hub.integration_provider}:`,
+              error.message,
+            );
+            continue;
+          }
+        }
+      }
+
+      throw new Error('All communication providers failed');
+    } catch (error) {
+      this.logger.error('Generic communication service error:', error.message);
+      throw error;
+    }
+  }
+
+  async sendBulkMessage(
+    bulkDto: BulkMessageDto,
+  ): Promise<{ results: IntegrationResult[]; summary: any }> {
+    try {
+      const {
+        levelId,
+        levelType,
+        app_code,
+        recipients,
+        message,
+        type,
+        priority = 'low',
+        subject,
+        html,
+        templateId,
+        variables,
+        batchSize = 10,
+      } = bulkDto;
+
+      const results: IntegrationResult[] = [];
+      const batches = this.chunkArray(recipients, batchSize);
+
+      for (let i = 0; i < batches.length; i++) {
+        const batch = batches[i];
+        this.logger.log(
+          `Processing batch ${i + 1}/${batches.length} with ${batch.length} recipients`,
+        );
+
+        const batchPromises = batch.map(async (recipient) => {
+          try {
+            const messageDto: GenericMessageDto = {
+              levelId,
+              levelType,
+              app_code,
+              to: recipient,
+              message,
+              type,
+              priority,
+              subject,
+              html,
+              templateId,
+              variables,
+            };
+
+            return await this.sendGenericMessage(messageDto);
+          } catch (error) {
+            return {
+              success: false,
+              provider: 'unknown',
+              service: 'unknown',
+              error: error.message,
+              timestamp: new Date(),
+            } as IntegrationResult;
+          }
+        });
+
+        const batchResults = await Promise.allSettled(batchPromises);
+        const processedResults = batchResults.map((result) => {
+          if (result.status === 'fulfilled') {
+            return result.value;
+          } else {
+            return {
+              success: false,
+              provider: 'unknown',
+              service: 'unknown',
+              error: result.reason?.message || 'Unknown error',
+              timestamp: new Date(),
+            } as IntegrationResult;
+          }
+        });
+
+        results.push(...processedResults);
+
+        // Rate limiting delay between batches
+        if (i < batches.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+      }
+
+      const summary = {
+        total: results.length,
+        successful: results.filter((r) => r.success).length,
+        failed: results.filter((r) => !r.success).length,
+        successRate:
+          (
+            (results.filter((r) => r.success).length / results.length) *
+            100
+          ).toFixed(2) + '%',
+      };
+
+      this.logger.log(
+        `Bulk message completed: ${summary.successful}/${summary.total} successful`,
+      );
+
+      return { results, summary };
+    } catch (error) {
+      this.logger.error('Bulk communication service error:', error.message);
+      throw error;
+    }
+  }
+
+  async scheduleMessage(
+    scheduledDto: any,
+  ): Promise<{ scheduled: boolean; scheduleId?: string }> {
+    // For now, return a placeholder. In production, integrate with a job queue like Bull or Agenda
+    this.logger.log(`Message scheduled for ${scheduledDto.scheduleFor}`);
+
+    return {
+      scheduled: true,
+      scheduleId: `sched_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+    };
+  }
+
+  async sendTemplateMessage(templateDto: any): Promise<IntegrationResult> {
+    // Get template content (integrate with your template system)
+    const template = await this.getTemplate(templateDto.templateId);
+
+    const processedMessage = this.replaceTemplateVariables(
+      template.content,
+      templateDto.variables,
+    );
+    const processedSubject = template.subject
+      ? this.replaceTemplateVariables(template.subject, templateDto.variables)
+      : undefined;
+
+    const messageDto: GenericMessageDto = {
+      levelId: templateDto.levelId,
+      levelType: templateDto.levelType,
+      app_code: templateDto.app_code,
+      to: templateDto.to,
+      message: processedMessage,
+      subject: processedSubject,
+      type: templateDto.type,
+      templateId: templateDto.templateId,
+      variables: templateDto.variables,
+    };
+
+    return this.sendGenericMessage(messageDto);
+  }
+
+  private detectCommunicationType(
+    to: string | string[],
+    type?: string,
+  ): 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE' {
+    if (type) {
+      return type as 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+    }
+
+    const recipient = Array.isArray(to) ? to[0] : to;
+
+    // Email detection
+    if (recipient.includes('@')) {
+      return 'EMAIL';
+    }
+
+    // Phone number detection (basic)
+    if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
+      // Could be SMS or WhatsApp, default to SMS
+      return 'SMS';
+    }
+
+    // Default to EMAIL if unsure
+    return 'EMAIL';
+  }
+
+  private sortConfigsByPriorityAndDefault(
+    configs: IntegrationConfigWithConfig[],
+    _priority: string,
+  ): IntegrationConfigWithConfig[] {
+    return configs.sort((a, b) => {
+      // First sort by default (true comes first)
+      if (a.is_default !== b.is_default) {
+        return b.is_default ? 1 : -1;
+      }
+
+      // Then sort by priority (lower number = higher priority)
+      if (a.priority !== b.priority) {
+        return a.priority - b.priority;
+      }
+
+      // Finally sort by created_at descending (newest first)
+      return (
+        new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+      );
+    });
+  }
+
+  public async processTemplate(
+    templateId: number,
+    entity_type: any,
+    entity_id: any,
+    loggedInUser?: any,
+    mappedEntities?: Record<string, any>,
+  ): Promise<{
+    variables?: Record<string, any>;
+    externalTemplateId?: string;
+    rich_text?: string;
+    subject?: string;
+  }> {
+    const commTemplate: any = await this.entityService.getEntityData(
+      COMM_TEMPLATE,
+      templateId,
+      {} as any,
+    );
+    if (!commTemplate) {
+      return {
+        variables: {},
+        externalTemplateId: undefined,
+      };
+    }
+
+    let variables = {};
+    if (commTemplate.mapper_id) {
+      variables = await this.fieldMapperService.resolveData(
+        commTemplate.mapper_id,
+        'LOOKUP',
+        entity_type,
+        entity_id,
+        loggedInUser,
+        {} as any,
+        mappedEntities,
+      );
+    }
+
+    if (!commTemplate.template_id) {
+      let richText = commTemplate.rich_text;
+
+      if (!richText) {
+        if (commTemplate.markup_id) {
+          let url = await this.mediaService.getMediaDownloadUrl(
+            commTemplate.markup_id,
+            {},
+            60000,
+          );
+          if (url) {
+            let response = await axios.get(url.signedUrl, {
+              responseType: 'text',
+            });
+            richText = response.data;
+          }
+        }
+      }
+
+      richText = richText.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+        const value = variables[key];
+        if (value === undefined) return match;
+
+        // If value is an object with signedUrl, use only the signedUrl
+        if (
+          typeof value === 'object' &&
+          value !== null &&
+          'signedUrl' in value
+        ) {
+          return String(value.signedUrl);
+        }
+
+        return String(value);
+      });
+
+      return {
+        rich_text: richText,
+        subject: commTemplate.subject,
+      };
+    }
+
+    return {
+      variables,
+      externalTemplateId: commTemplate.template_id,
+    };
+  }
+
+  private replaceTemplateVariables(
+    template: string,
+    variables: Record<string, any>,
+  ): string {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+      const value = variables[key];
+      return value !== undefined ? String(value) : match;
+    });
+  }
+
+  private async getTemplate(templateId: string) {
+    // Placeholder for template system integration
+    // In production, this would connect to your template database/service
+    return {
+      id: templateId,
+      subject: 'Default Subject {{variable}}',
+      content: 'Hello {{name}}, this is a template message with {{variable}}.',
+    };
+  }
+
+  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+      chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+  }
+
+  async initGmailOAuth(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    email?: string,
+  ): Promise<{ authUrl: string; state: string }> {
+    try {
+      // Get system OAuth credentials from config
+      const clientId = this.configService.get<string>('CLIENT_ID');
+      const clientSecret = this.configService.get<string>('CLIENT_SECRET');
+
+      if (!clientId || !clientSecret) {
+        throw new Error('Gmail OAuth credentials not configured');
+      }
+
+      const state = this.generateSecureState();
+      // Use the existing registered callback URL
+      const callbackUrl =
+        this.configService.get<string>('CALLBACK_URL') ||
+        'http://localhost:5001/auth/google/callback';
+
+      this.gmailOAuthStates.set(state, {
+        levelId,
+        levelType,
+        app_code,
+        email,
+        timestamp: Date.now(),
+      });
+
+      // Auto-cleanup after 10 minutes
+      setTimeout(
+        () => {
+          this.gmailOAuthStates.delete(state);
+        },
+        10 * 60 * 1000,
+      );
+
+      const oauth2Client = new google.auth.OAuth2(
+        clientId,
+        clientSecret,
+        callbackUrl,
+      );
+
+      const scopes = [
+        'https://www.googleapis.com/auth/gmail.send',
+        'https://www.googleapis.com/auth/gmail.readonly',
+        'https://www.googleapis.com/auth/userinfo.email',
+        'https://www.googleapis.com/auth/calendar',
+      ];
+
+      const authUrl = oauth2Client.generateAuthUrl({
+        access_type: 'offline',
+        scope: scopes,
+        state: `gmail_config:${state}`, // Prefix to identify Gmail config requests
+        prompt: 'consent',
+        login_hint: email,
+      });
+
+      return { authUrl, state };
+    } catch (error) {
+      this.logger.error('Error initializing Gmail OAuth:', error.message);
+      throw new Error('Failed to initialize Gmail OAuth');
+    }
+  }
+
+  async handleGmailOAuthCallback(
+    code: string,
+    state: string,
+  ): Promise<GmailSSOResult> {
+    try {
+      const oauthState = this.gmailOAuthStates.get(state);
+      if (!oauthState) {
+        throw new Error('Invalid or expired OAuth state');
+      }
+
+      this.gmailOAuthStates.delete(state);
+
+      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+        throw new Error('OAuth state expired');
+      }
+
+      // Get system OAuth credentials
+      const clientId = this.configService.get<string>('CLIENT_ID');
+      const clientSecret = this.configService.get<string>('CLIENT_SECRET');
+      const callbackUrl =
+        this.configService.get<string>('CALLBACK_URL') ||
+        'http://localhost:5001/auth/google/callback';
+
+      const oauth2Client = new google.auth.OAuth2(
+        clientId,
+        clientSecret,
+        callbackUrl,
+      );
+
+      const { tokens } = await oauth2Client.getToken(code);
+
+      if (!tokens.access_token) {
+        throw new Error('Failed to obtain access token');
+      }
+
+      // Get user email from Google
+      oauth2Client.setCredentials(tokens);
+      const oauth2 = google.oauth2({ version: 'v2', auth: oauth2Client });
+      const userInfo = await oauth2.userinfo.get();
+      const email = userInfo.data.email;
+
+      if (!email) {
+        throw new Error('Failed to get user email');
+      }
+
+      // Verify email matches if hint was provided
+      if (oauthState.email && oauthState.email !== email) {
+        throw new Error('Email mismatch with OAuth hint');
+      }
+
+      const gmailConfig = {
+        clientId,
+        clientSecret,
+        email: email,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        scope: tokens.scope,
+        tokenType: tokens.token_type,
+        expiryDate: tokens.expiry_date,
+      };
+
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        oauthState.app_code,
+        'EMAIL',
+        'gmail',
+      );
+
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'gmail',
+        integration_source_id: 1, // Gmail source ID
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: gmailConfig as any,
+      });
+
+      const savedConfig = await this.configRepository.save(config);
+
+      this.logger.log(
+        `Gmail OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedConfig.id,
+        configId: savedConfig.id,
+      };
+    } catch (error) {
+      this.logger.error('Error handling Gmail OAuth callback:', error.message);
+      throw new Error(`Failed to complete Gmail OAuth: ${error.message}`);
+    }
+  }
+
+  async handleGmailTokensCallback(
+    email: string,
+    accessToken: string,
+    refreshToken: string,
+    state: string,
+  ): Promise<GmailSSOResult> {
+    try {
+      const oauthState = this.gmailOAuthStates.get(state);
+      if (!oauthState) {
+        throw new Error('Invalid or expired OAuth state');
+      }
+
+      this.gmailOAuthStates.delete(state);
+
+      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+        throw new Error('OAuth state expired');
+      }
+
+      // Verify email matches if hint was provided
+      if (oauthState.email && oauthState.email !== email) {
+        throw new Error('Email mismatch with OAuth hint');
+      }
+
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        oauthState.app_code,
+        'EMAIL',
+        'gmail',
+      );
+
+      // Pure SSO configuration - no client credentials stored per user
+      const gmailConfig = {
+        email: email,
+        accessToken: accessToken,
+        refreshToken: refreshToken,
+        authMethod: 'GOOGLE_SSO',
+        scopes: [
+          'https://www.googleapis.com/auth/gmail.send',
+          'https://www.googleapis.com/auth/userinfo.email',
+        ],
+      };
+
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'gmail',
+        integration_source_id: 1, // Gmail source ID
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: gmailConfig as any,
+      });
+
+      const savedConfig = await this.configRepository.save(config);
+
+      this.logger.log(
+        `Gmail tokens configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedConfig.id,
+        configId: savedConfig.id,
+      };
+    } catch (error) {
+      this.logger.error('Error handling Gmail tokens callback:', error.message);
+      throw new Error(
+        `Failed to complete Gmail tokens callback: ${error.message}`,
+      );
+    }
+  }
+
+  async testGmailConfig(
+    hubId: number,
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      const integrationConfig = await this.configRepository.findOne({
+        where: { id: hubId },
+      });
+
+      if (!integrationConfig) {
+        throw new Error('Integration config not found');
+      }
+
+      const isValid = await this.gmailApiStrategy.validateConnection(
+        integrationConfig.config_json,
+      );
+
+      if (!isValid) {
+        return {
+          success: false,
+          error: 'Gmail configuration is invalid or expired',
+        };
+      }
+
+      return { success: true };
+    } catch (error) {
+      this.logger.error('Error testing Gmail config:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  private generateSecureState(): string {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+  }
+
+  private async validateUniqueActiveConfig(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
+    excludeHubId?: number,
+  ): Promise<void> {
+    // Find all active configurations of the same provider for this level and app_code
+    const query = this.configRepository
+      .createQueryBuilder('hub')
+      .where('hub.level_id = :levelId', { levelId })
+      .andWhere('hub.level_type = :levelType', { levelType })
+      .andWhere('hub.app_code = :app_code', { app_code })
+      .andWhere('hub.integration_type = :configType', { configType })
+      .andWhere('hub.integration_provider = :provider', { provider })
+      .andWhere('hub.status = :status', { status: 1 });
+
+    // Exclude current hub if updating
+    if (excludeHubId) {
+      query.andWhere('hub.id != :excludeHubId', { excludeHubId });
+    }
+
+    const existingActiveConfigs = await query.getMany();
+
+    // If there are existing active configurations of the same provider, throw error
+    if (existingActiveConfigs.length > 0) {
+      throw new Error(
+        `A ${provider} configuration already exists for ${configType} in app_code ${app_code}, ${levelType} ${levelId}. Only one configuration per provider is allowed.`,
+      );
+    }
+  }
+
+  private requiresOAuthFlow(
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
+    config: any,
+  ): boolean {
+    // Check if config indicates OAuth is needed (missing tokens or explicit OAuth request)
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'email_gmail':
+        // Requires OAuth if no access token provided or OAuth explicitly requested
+        return !config.accessToken || config.useOAuth === true;
+
+      case 'email_outlook':
+        // Requires OAuth if no access token provided or OAuth explicitly requested
+        return !config.accessToken || config.useOAuth === true;
+
+      default:
+        // Most other providers don't require OAuth
+        return false;
+    }
+  }
+
+  private async generateOAuthUrl(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
+    integration_source_id: number,
+    config: any,
+    priority?: number,
+    is_default?: boolean,
+  ): Promise<{ authUrl: string; state: string; message: string }> {
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'email_gmail':
+        const gmailResult = await this.initGmailOAuth(
+          levelId,
+          levelType,
+          app_code,
+          config.email,
+        );
+        return {
+          authUrl: gmailResult.authUrl,
+          state: gmailResult.state,
+          message:
+            'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.',
+        };
+
+      case 'email_outlook':
+        const outlookResult = await this.initOutlookOAuth(
+          levelId,
+          levelType,
+          app_code,
+          config.email,
+        );
+        return {
+          authUrl: outlookResult.authUrl,
+          state: outlookResult.state,
+          message:
+            'Please complete Outlook OAuth authorization. Configuration will be created automatically after authorization.',
+        };
+
+      default:
+        throw new Error(`OAuth not supported for ${configType}/${provider}`);
+    }
+  }
+
+  private async createDirectConfig(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
+    integration_source_id: number,
+    config: any,
+    priority?: number,
+    is_default?: boolean,
+  ): Promise<IntegrationConfig> {
+    // Validate that no duplicate provider configurations exist
+    await this.validateUniqueActiveConfig(
+      levelId,
+      levelType,
+      app_code,
+      configType,
+      provider,
+    );
+
+    // Deactivate all other configurations of the same integration type
+    await this.configRepository.update(
+      {
+        level_id: levelId,
+        level_type: levelType,
+        app_code: app_code,
+        integration_type: configType,
+        status: 1,
+      },
+      { status: 0 },
+    );
+
+    // If setting as default, remove default from other configurations of same type and app_code
+    if (is_default) {
+      await this.configRepository.update(
+        {
+          level_id: levelId,
+          level_type: levelType,
+          app_code: app_code,
+          integration_type: configType,
+        },
+        { is_default: false },
+      );
+    }
+
+    // Create integration config
+    const integrationConfig = this.configRepository.create({
+      app_code: app_code,
+      integration_type: configType,
+      integration_provider: provider,
+      integration_source_id: integration_source_id,
+      level_id: levelId,
+      level_type: levelType,
+      status: 1,
+      priority: priority || 1,
+      is_default: is_default || false,
+      config_json: config,
+    });
+
+    const savedConfig = await this.configRepository.save(integrationConfig);
+    this.logger.log(
+      `Communication config created: ${configType}/${provider} for ${levelType} ${levelId}`,
+    );
+
+    // Store DID mapping for TELEPHONE integration
+    if (configType === 'TELEPHONE') {
+      try {
+        // Extract DID from config (could be did, callerNumber, or fromNumber)
+        const did = config.did || config.callerNumber || config.fromNumber;
+
+        if (did) {
+          const entityMapper = this.entityMapperRepository.create({
+            integration_config_id: savedConfig.id,
+            level_id: String(levelId),
+            level_type: levelType,
+            appcode: app_code,
+            did: did,
+            campaign_name: config.campaignName || null,
+          });
+
+          await this.entityMapperRepository.save(entityMapper);
+          this.logger.log(
+            `DID mapping created for TELEPHONE integration: ${did} for ${levelType} ${levelId}`,
+          );
+        }
+      } catch (error) {
+        this.logger.warn(
+          `Failed to create DID mapping for TELEPHONE integration: ${error.message}`,
+        );
+      }
+    }
+
+    return Array.isArray(savedConfig) ? savedConfig[0] : savedConfig;
+  }
+
+  async initOutlookOAuth(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    email?: string,
+  ): Promise<{ authUrl: string; state: string }> {
+    try {
+      // Get system OAuth credentials from config
+      const clientId = this.configService.get<string>('OUTLOOK_CLIENT_ID');
+      const tenantId = this.configService.get<string>('OUTLOOK_TENANT_ID');
+
+      if (!clientId || !tenantId) {
+        throw new Error('Outlook OAuth credentials not configured');
+      }
+
+      const state = this.generateSecureState();
+      const callbackUrl =
+        this.configService.get<string>('OUTLOOK_CALLBACK_URL') ||
+        'http://localhost:5001/auth/outlook/callback';
+
+      this.gmailOAuthStates.set(state, {
+        levelId,
+        levelType,
+        app_code,
+        email,
+        timestamp: Date.now(),
+      });
+
+      // Auto-cleanup after 10 minutes
+      setTimeout(
+        () => {
+          this.gmailOAuthStates.delete(state);
+        },
+        10 * 60 * 1000,
+      );
+
+      const scopes = [
+        'https://graph.microsoft.com/Mail.Send',
+        'https://graph.microsoft.com/User.Read',
+      ];
+
+      const authUrl =
+        `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize?` +
+        `client_id=${clientId}&` +
+        `response_type=code&` +
+        `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+        `scope=${encodeURIComponent(scopes.join(' '))}&` +
+        `state=outlook_config:${state}&` +
+        `response_mode=query&` +
+        `prompt=consent` +
+        (email ? `&login_hint=${encodeURIComponent(email)}` : '');
+
+      return { authUrl, state };
+    } catch (error) {
+      this.logger.error('Error initializing Outlook OAuth:', error.message);
+      throw new Error('Failed to initialize Outlook OAuth');
+    }
+  }
+
+  async handleOutlookOAuthCallback(
+    code: string,
+    state: string,
+  ): Promise<GmailSSOResult> {
+    try {
+      const oauthState = this.gmailOAuthStates.get(state);
+      if (!oauthState) {
+        throw new Error('Invalid or expired OAuth state');
+      }
+
+      this.gmailOAuthStates.delete(state);
+
+      if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+        throw new Error('OAuth state expired');
+      }
+
+      const clientId = this.configService.get<string>('OUTLOOK_CLIENT_ID');
+      const clientSecret = this.configService.get<string>(
+        'OUTLOOK_CLIENT_SECRET',
+      );
+      const tenantId = this.configService.get<string>('OUTLOOK_TENANT_ID');
+      const callbackUrl =
+        this.configService.get<string>('OUTLOOK_CALLBACK_URL') ||
+        'http://localhost:5001/auth/outlook/callback';
+
+      // Exchange code for tokens
+      const tokenResponse = await fetch(
+        `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          body: new URLSearchParams({
+            client_id: clientId!,
+            client_secret: clientSecret!,
+            code: code,
+            redirect_uri: callbackUrl,
+            grant_type: 'authorization_code',
+          }),
+        },
+      );
+
+      const tokens = await tokenResponse.json();
+
+      if (!tokens.access_token) {
+        throw new Error('Failed to obtain access token');
+      }
+
+      // Get user info from Microsoft Graph
+      const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
+        headers: {
+          Authorization: `Bearer ${tokens.access_token}`,
+        },
+      });
+
+      const userInfo = await userResponse.json();
+      const email = userInfo.mail || userInfo.userPrincipalName;
+
+      if (!email) {
+        throw new Error('Failed to get user email');
+      }
+
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        oauthState.app_code,
+        'EMAIL',
+        'outlook',
+      );
+
+      const outlookConfig = {
+        clientId,
+        tenantId,
+        email: email,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        scope: tokens.scope,
+        tokenType: tokens.token_type,
+        expiresIn: tokens.expires_in,
+      };
+
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'outlook',
+        integration_source_id: 1, // Outlook source ID
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: outlookConfig as any,
+      });
+
+      const savedConfig = await this.configRepository.save(config);
+
+      this.logger.log(
+        `Outlook OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedConfig.id,
+        configId: savedConfig.id,
+      };
+    } catch (error) {
+      this.logger.error(
+        'Error handling Outlook OAuth callback:',
+        error.message,
+      );
+      throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
+    }
+  }
+
+  async getIntegrationConfigById(hubId: number): Promise<
+    | (IntegrationConfig & {
+        config: IntegrationConfig;
+        linkedSource?: string;
+        configDetails?: any;
+      })
+    | null
+  > {
+    try {
+      // Find the integration config by ID
+      const integrationConfig = await this.configRepository.findOne({
+        where: { id: hubId },
+      });
+
+      if (!integrationConfig) {
+        return null;
+      }
+
+      // Extract linked source and config details
+      const linkedSource = this.extractLinkedSource(
+        integrationConfig.integration_type,
+        integrationConfig.integration_provider,
+        integrationConfig.config_json,
+      );
+
+      const configDetails = this.extractConfigDetails(
+        integrationConfig.integration_type,
+        integrationConfig.integration_provider,
+        integrationConfig.config_json,
+      );
+
+      return {
+        ...integrationConfig,
+        config: integrationConfig,
+        linkedSource,
+        configDetails,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error fetching communication config by ID ${hubId}:`,
+        error.message,
+      );
+      throw new Error(
+        `Failed to fetch communication configuration: ${error.message}`,
+      );
+    }
+  }
+
+  async getIntegrationTemplates(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      // Get active configuration for the integration type
+      const config = await this.getSingleActiveConfig(
+        levelId,
+        levelType,
+        app_code,
+        integration_type,
+      );
+
+      if (!config) {
+        return {
+          success: false,
+          error: `No active ${integration_type} configuration found for this level`,
+        };
+      }
+
+      // Create strategy instance
+      const strategy = this.integrationFactory.create(
+        config.integration_type,
+        'API',
+        config.integration_provider,
+      );
+
+      // Check if strategy supports getTemplates
+      if (typeof (strategy as any).getTemplates !== 'function') {
+        return {
+          success: false,
+          error: `Template retrieval not supported for provider: ${config.integration_provider}`,
+        };
+      }
+
+      // Call getTemplates method
+      return await (strategy as any).getTemplates(config.config_json);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching templates for ${integration_type} level ${levelId}/${levelType}:`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch templates: ${error.message}`,
+      };
+    }
+  }
+
+  async getSendGridTemplates(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+  ): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      // Find active SendGrid configurations for this level
+      const hubs = await this.getActiveConfigs(
+        levelId,
+        levelType,
+        app_code,
+        'EMAIL',
+      );
+
+      // Look for SendGrid provider
+      const sendGridHub = hubs.find(
+        (hub) => hub.integration_provider === 'sendgrid',
+      );
+
+      if (!sendGridHub) {
+        return {
+          success: false,
+          error: 'No active SendGrid configuration found for this level',
+        };
+      }
+
+      // Extract API key from configuration
+      const apiKey = sendGridHub.config_json?.apiKey;
+
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'SendGrid API key not found in configuration',
+        };
+      }
+
+      // Use the SendGrid strategy to fetch templates
+      return this.sendGridApiStrategy.getTemplates(apiKey);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching SendGrid templates for level ${levelId}/${levelType}:`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch SendGrid templates: ${error.message}`,
+      };
+    }
+  }
+
+  async getSendGridVerifiedSenders(apiKey: string): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'SendGrid API key not found in configuration',
+        };
+      }
+
+      // Use the SendGrid strategy to fetch verified senders
+      return this.sendGridApiStrategy.getVerifiedSenders(apiKey);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching SendGrid verified senders`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch SendGrid verified senders: ${error.message}`,
+      };
+    }
+  }
+
+  // UserIntegration Management Methods
+
+  async createUserIntegration(
+    createDto: CreateUserIntegrationDto,
+  ): Promise<UserIntegration> {
+    try {
+      // Check if mapping already exists
+      const existing = await this.userIntegrationRepository.findOne({
+        where: {
+          user_id: createDto.user_id,
+          integration_config_id: createDto.integration_config_id,
+        },
+      });
+
+      if (existing) {
+        throw new Error('User integration mapping already exists');
+      }
+
+      // Verify integration config exists
+      const config = await this.configRepository.findOne({
+        where: { id: createDto.integration_config_id },
+      });
+
+      if (!config) {
+        throw new Error('Integration configuration not found');
+      }
+
+      const userIntegration = this.userIntegrationRepository.create(createDto);
+      return await this.userIntegrationRepository.save(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error creating user integration mapping: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async bulkCreateUserIntegration(
+    bulkDto: BulkCreateUserIntegrationDto,
+  ): Promise<{
+    created: UserIntegration[];
+    updated: UserIntegration[];
+    failed: Array<{ data: CreateUserIntegrationDto; error: string }>;
+    summary: {
+      total: number;
+      created: number;
+      updated: number;
+      failed: number;
+    };
+  }> {
+    const created: UserIntegration[] = [];
+    const updated: UserIntegration[] = [];
+    const failed: Array<{ data: CreateUserIntegrationDto; error: string }> = [];
+
+    try {
+      for (const createDto of bulkDto.user_integrations) {
+        try {
+          // Check if mapping already exists
+          const existing = await this.userIntegrationRepository.findOne({
+            where: {
+              user_id: createDto.user_id,
+              integration_config_id: createDto.integration_config_id,
+            },
+          });
+
+          if (existing) {
+            // Update existing mapping
+            if (createDto.external_user_id !== undefined) {
+              existing.external_user_id = createDto.external_user_id;
+            }
+            if (createDto.external_user_data !== undefined) {
+              existing.external_user_data = createDto.external_user_data;
+            }
+            if (createDto.is_active !== undefined) {
+              existing.is_active = createDto.is_active;
+            }
+
+            const updatedIntegration =
+              await this.userIntegrationRepository.save(existing);
+            updated.push(updatedIntegration);
+
+            this.logger.log(
+              `Updated user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`,
+            );
+          } else {
+            // Verify integration config exists
+            const config = await this.configRepository.findOne({
+              where: { id: createDto.integration_config_id },
+            });
+
+            if (!config) {
+              failed.push({
+                data: createDto,
+                error: 'Integration configuration not found',
+              });
+              continue;
+            }
+
+            // Create new mapping
+            const userIntegration =
+              this.userIntegrationRepository.create(createDto);
+            const savedIntegration =
+              await this.userIntegrationRepository.save(userIntegration);
+            created.push(savedIntegration);
+
+            this.logger.log(
+              `Created user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`,
+            );
+          }
+        } catch (error) {
+          failed.push({
+            data: createDto,
+            error: error.message || 'Unknown error',
+          });
+          this.logger.error(
+            `Error processing user integration for user ${createDto.user_id}: ${error.message}`,
+          );
+        }
+      }
+
+      const summary = {
+        total: bulkDto.user_integrations.length,
+        created: created.length,
+        updated: updated.length,
+        failed: failed.length,
+      };
+
+      this.logger.log(
+        `Bulk user integration completed: ${summary.created} created, ${summary.updated} updated, ${summary.failed} failed`,
+      );
+
+      return { created, updated, failed, summary };
+    } catch (error) {
+      this.logger.error(
+        `Error in bulk user integration creation: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getUserIntegrations(userId: number): Promise<UserIntegration[]> {
+    try {
+      return await this.userIntegrationRepository.find({
+        where: { user_id: userId, is_active: true },
+        order: { created_at: 'DESC' },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integrations for user ${userId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getConfigUserIntegrations(
+    configId: number,
+  ): Promise<UserIntegration[]> {
+    try {
+      return await this.userIntegrationRepository.find({
+        where: { integration_config_id: configId, is_active: true },
+        order: { created_at: 'DESC' },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integrations for config ${configId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getUserIntegrationByUserAndConfig(
+    userId: number,
+    configId: number,
+  ): Promise<UserIntegration | null> {
+    try {
+      return await this.userIntegrationRepository.findOne({
+        where: {
+          user_id: userId,
+          integration_config_id: configId,
+          is_active: true,
+        },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integration for user ${userId} and config ${configId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async updateUserIntegration(
+    id: number,
+    updateDto: UpdateUserIntegrationDto,
+  ): Promise<UserIntegration> {
+    try {
+      const userIntegration = await this.userIntegrationRepository.findOne({
+        where: { id },
+      });
+
+      if (!userIntegration) {
+        throw new Error('User integration mapping not found');
+      }
+
+      Object.assign(userIntegration, updateDto);
+      return await this.userIntegrationRepository.save(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error updating user integration ${id}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async deleteUserIntegration(id: number): Promise<void> {
+    try {
+      const userIntegration = await this.userIntegrationRepository.findOne({
+        where: { id },
+      });
+
+      if (!userIntegration) {
+        throw new Error('User integration mapping not found');
+      }
+
+      await this.userIntegrationRepository.remove(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error deleting user integration ${id}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Get user integration data for a specific integration strategy
+   * This method is intended to be used by strategies that need user mapping
+   */
+  async getUserIntegrationForStrategy(
+    userId: number,
+    integrationConfigId: number,
+  ): Promise<any | null> {
+    try {
+      const userIntegration = await this.getUserIntegrationByUserAndConfig(
+        userId,
+        integrationConfigId,
+      );
+
+      if (!userIntegration) {
+        return null;
+      }
+
+      return {
+        external_user_id: userIntegration.external_user_id,
+        external_user_data: userIntegration.external_user_data,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integration data for strategy: ${error.message}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Check agent status for TELEPHONE integration
+   * Works with any provider that implements checkAgentStatus method
+   */
+  async checkAgentStatus(
+    levelId: number,
+    levelType: string,
+    appCode: string,
+    userId: number,
+    integrationType: 'TELEPHONE' = 'TELEPHONE',
+  ): Promise<{
+    success: boolean;
+    isReady?: boolean;
+    state?: string;
+    agentInfo?: any;
+    error?: string;
+  }> {
+    try {
+      // Get the active configuration
+      const config = await this.getSingleActiveConfig(
+        levelId,
+        levelType,
+        appCode,
+        integrationType,
+      );
+
+      if (!config) {
+        return {
+          success: false,
+          error: 'No active TELEPHONE configuration found',
+        };
+      }
+
+      // Get user integration mapping
+      const userIntegration = await this.getUserIntegrationByUserAndConfig(
+        userId,
+        config.id,
+      );
+
+      if (!userIntegration) {
+        return {
+          success: false,
+          error:
+            'User integration mapping not found. Please configure agent details.',
+        };
+      }
+
+      // Create strategy instance
+      const strategy = this.integrationFactory.create(
+        config.integration_type,
+        'API', // service is deprecated, using default
+        config.integration_provider,
+      );
+
+      // Get the merged config with user data
+      let mergedConfig = config.config_json;
+
+      if (strategy.createUserSpecificConfig) {
+        mergedConfig = strategy.createUserSpecificConfig(
+          config.config_json,
+          userIntegration.external_user_id,
+        );
+      }
+
+      // Check if strategy supports agent status check
+      if (typeof (strategy as any).checkAgentStatus !== 'function') {
+        return {
+          success: false,
+          error: `Agent status check not supported for provider: ${config.integration_provider}`,
+        };
+      }
+
+      // Check agent status
+      const statusResult = await (strategy as any).checkAgentStatus(
+        mergedConfig,
+      );
+
+      return {
+        success: true,
+        isReady: statusResult.isReady,
+        state: statusResult.state,
+        error: statusResult.error,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error checking agent status: ${error.message}`,
+        error.stack,
+      );
+      return {
+        success: false,
+        error: error.message || 'Failed to check agent status',
+      };
+    }
+  }
+}