rez_core 2.2.154 → 2.2.156

package/src/module/communication/service/communication.service.ts

@@ -0,0 +1,1118 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+import { google } from 'googleapis';
+import {
+  CommunicationHub,
+  CommunicationConfigType,
+} from '../entity/communication-hub.entity';
+import { CommunicationConfig } from '../entity/communication-config.entity';
+import { CommunicationFactory } from '../factories/communication.factory';
+import { CommunicationResult } from '../strategies/communication.strategy';
+import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
+
+export interface SendMessageDto {
+  levelId: number;
+  levelType: string;
+  to: string;
+  message: string;
+  mode?: CommunicationConfigType;
+  priority?: number;
+}
+
+export interface GenericMessageDto {
+  levelId: number;
+  levelType: 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>;
+}
+
+export interface BulkMessageDto {
+  levelId: number;
+  levelType: string;
+  recipients: string[];
+  message: string;
+  subject?: string;
+  type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+  priority?: 'high' | 'medium' | 'low';
+  html?: string;
+  templateId?: string;
+  variables?: Record<string, any>;
+  batchSize?: number;
+}
+
+export interface CommunicationHubWithConfig extends CommunicationHub {
+  config: CommunicationConfig;
+}
+
+interface GmailOAuthState {
+  levelId: number;
+  levelType: string;
+  email?: string;
+  timestamp: number;
+}
+
+export interface GmailSSOResult {
+  hubId: number;
+  configId: number;
+}
+
+@Injectable()
+export class CommunicationService {
+  private readonly logger = new Logger(CommunicationService.name);
+  private readonly gmailOAuthStates = new Map<string, GmailOAuthState>();
+
+  constructor(
+    @InjectRepository(CommunicationHub)
+    private readonly hubRepository: Repository<CommunicationHub>,
+
+    @InjectRepository(CommunicationConfig)
+    private readonly configRepository: Repository<CommunicationConfig>,
+
+    private readonly communicationFactory: CommunicationFactory,
+    private readonly gmailApiStrategy: GmailApiStrategy,
+    private readonly configService: ConfigService,
+  ) {}
+
+  async sendMessage({
+    levelId,
+    levelType,
+    to,
+    message,
+    mode,
+    priority = 1,
+  }: SendMessageDto): Promise<CommunicationResult> {
+    try {
+      // Get active communication hubs for the level
+      const hubs = await this.getActiveHubs(levelId, levelType, mode);
+
+      if (!hubs.length) {
+        throw new Error(
+          `No active communication configuration found for ${levelType} ${levelId}`,
+        );
+      }
+
+      // Sort by priority if provided
+      const sortedHubs = this.sortHubsByPriority(hubs, priority);
+
+      // Try each hub until one succeeds
+      for (const hub of sortedHubs) {
+        try {
+          const result = await this.sendViaHub(hub, to, message);
+          if (result.success) {
+            this.logger.log(
+              `Message sent successfully via ${hub.provider}/${hub.service}`,
+            );
+            return result;
+          }
+
+          this.logger.warn(
+            `Failed to send via ${hub.provider}/${hub.service}: ${result.error}`,
+          );
+        } catch (error) {
+          this.logger.error(
+            `Error sending via ${hub.provider}/${hub.service}:`,
+            error.message,
+          );
+          continue;
+        }
+      }
+
+      throw new Error('All communication providers failed');
+    } catch (error) {
+      this.logger.error('Communication service error:', error.message);
+      throw error;
+    }
+  }
+
+  async getActiveHubs(
+    levelId: number,
+    levelType: string,
+    mode?: CommunicationConfigType,
+  ): Promise<CommunicationHubWithConfig[]> {
+    let query = this.hubRepository
+      .createQueryBuilder('hub')
+      .leftJoin('communication_config', 'config', 'config.id = hub.config_id')
+      .select([
+        'hub.id',
+        'hub.status',
+        'hub.config_id',
+        'hub.communication_config_type',
+        'hub.service',
+        'hub.provider',
+        'hub.priority',
+        'hub.is_default',
+        'hub.created_at',
+        'hub.updated_at',
+        'config.id as config_id',
+        'config.config_json as config_json',
+        'config.created_at as config_created_at',
+        'config.updated_at as config_updated_at'
+      ])
+      .where('hub.level_id = :levelId', { levelId })
+      .andWhere('hub.level_type = :levelType', { levelType })
+      .andWhere('hub.status = :status', { status: 1 });
+
+    if (mode) {
+      query = query.andWhere('hub.communication_config_type = :mode', { mode });
+    }
+
+    const results = await query.getRawMany();
+
+    // Transform the raw results into the expected format
+    const hubsWithConfig: CommunicationHubWithConfig[] = results.map(row => ({
+      id: row.hub_id,
+      level_id: row.hub_level_id,
+      level_type: row.hub_level_type,
+      status: row.hub_status,
+      config_id: row.hub_config_id,
+      communication_config_type: row.hub_communication_config_type,
+      service: row.hub_service,
+      provider: row.hub_provider,
+      priority: row.hub_priority || 1,
+      is_default: row.hub_is_default || false,
+      created_at: row.hub_created_at,
+      updated_at: row.hub_updated_at,
+      config: {
+        id: row.config_id,
+        config_json: row.config_json,
+        created_at: row.config_created_at,
+        updated_at: row.config_updated_at,
+      },
+    }));
+
+    return hubsWithConfig;
+  }
+
+  private sortHubsByPriority(
+    hubs: CommunicationHubWithConfig[],
+    _priority: number,
+  ): CommunicationHubWithConfig[] {
+    // For now, just return as-is. In the future, implement priority logic
+    return hubs;
+  }
+
+  private async sendViaHub(
+    hub: CommunicationHubWithConfig,
+    to: string,
+    message: string,
+  ): Promise<CommunicationResult> {
+    const strategy = this.communicationFactory.create(
+      hub.communication_config_type,
+      hub.service,
+      hub.provider,
+    );
+
+    return strategy.sendMessage(to, message, hub.config.config_json);
+  }
+
+  async createCommunicationConfig(
+    levelId: number,
+    levelType: string,
+    configType: CommunicationConfigType,
+    service: string,
+    provider: string,
+    config: any,
+    priority?: number,
+    is_default?: boolean,
+  ): Promise<CommunicationHub | { authUrl: string; state: string; message: string }> {
+    // Validate service/provider combination using supported combinations
+    const supportedCombinations = await this.getSupportedCombinations();
+    const isValidCombination = supportedCombinations.some(
+      combo => combo.mode === configType && 
+               combo.service.toLowerCase() === service.toLowerCase() && 
+               combo.provider.toLowerCase() === provider.toLowerCase()
+    );
+    
+    if (!isValidCombination) {
+      throw new Error(`Unsupported combination: ${configType}/${service}/${provider}`);
+    }
+
+    // Check if this requires OAuth flow
+    const requiresOAuth = this.requiresOAuthFlow(configType, service, provider, config);
+    
+    if (requiresOAuth) {
+      // Generate OAuth URL and return it instead of creating config immediately
+      return await this.generateOAuthUrl(levelId, levelType, configType, service, provider, config, priority, is_default);
+    }
+
+    // Direct config creation (non-OAuth flow)
+    return await this.createDirectConfig(levelId, levelType, configType, service, provider, config, priority, is_default);
+  }
+
+  async getSupportedCombinations(): Promise<
+    {
+      mode: string;
+      service: string;
+      provider: string;
+    }[]
+  > {
+    return this.communicationFactory.getAllSupportedCombinations();
+  }
+
+  async getLevelConfigs(
+    levelId: number,
+    levelType: string,
+  ): Promise<CommunicationHub[]> {
+    return this.hubRepository.find({
+      where: { level_id: levelId, level_type: levelType },
+      order: { created_at: 'DESC' },
+    });
+  }
+
+  async updateConfigStatus(hubId: number, status: number): Promise<void> {
+    await this.hubRepository.update(hubId, { status });
+  }
+
+  async sendGenericMessage(messageDto: GenericMessageDto): Promise<CommunicationResult> {
+    try {
+      const {
+        levelId,
+        levelType,
+        to,
+        message,
+        type,
+        priority = 'medium',
+        subject,
+        html,
+        cc,
+        bcc,
+        attachments,
+        mediaUrl,
+        templateId,
+        variables
+      } = messageDto;
+
+      // Auto-detect communication type if not specified
+      const communicationType = this.detectCommunicationType(to, type);
+      
+      // Get active hubs for the detected type
+      const hubs = await this.getActiveHubs(levelId, levelType, communicationType);
+      
+      if (!hubs.length) {
+        throw new Error(`No active ${communicationType} configuration found for ${levelType} ${levelId}`);
+      }
+
+      // Sort hubs by priority and default preference
+      const sortedHubs = this.sortHubsByPriorityAndDefault(hubs, priority);
+
+      // Prepare enhanced config with additional parameters
+      const enhancedConfig = {
+        subject,
+        html,
+        cc,
+        bcc,
+        attachments,
+        mediaUrl,
+      };
+
+      // Handle multiple recipients by sending to each individually
+      if (Array.isArray(to)) {
+        const results: CommunicationResult[] = [];
+        let hasSuccess = false;
+
+        for (const recipient of to) {
+          for (const hub of sortedHubs) {
+            try {
+              const strategy = this.communicationFactory.create(
+                hub.communication_config_type,
+                hub.service,
+                hub.provider,
+              );
+
+              // Process template if provided
+              let processedMessage = message;
+              if (templateId && variables) {
+                processedMessage = this.processTemplate(message, variables);
+              }
+
+              // Merge config with enhanced parameters
+              const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+
+              const result = await strategy.sendMessage(recipient, processedMessage, finalConfig);
+              
+              if (result.success) {
+                this.logger.log(
+                  `Generic message sent successfully via ${hub.provider}/${hub.service} to ${recipient}`,
+                );
+                results.push(result);
+                hasSuccess = true;
+                break; // Move to next recipient
+              }
+
+              this.logger.warn(
+                `Failed to send via ${hub.provider}/${hub.service} to ${recipient}: ${result.error}`,
+              );
+            } catch (error) {
+              this.logger.error(
+                `Error sending via ${hub.provider}/${hub.service} to ${recipient}:`,
+                error.message,
+              );
+              continue;
+            }
+          }
+        }
+
+        if (hasSuccess) {
+          return {
+            success: true,
+            messageId: results.map(r => r.messageId).join(','),
+            provider: 'multiple',
+            service: 'multiple',
+            timestamp: new Date(),
+          };
+        }
+      } else {
+        // Handle single recipient
+        for (const hub of sortedHubs) {
+          try {
+            const strategy = this.communicationFactory.create(
+              hub.communication_config_type,
+              hub.service,
+              hub.provider,
+            );
+
+            // Process template if provided
+            let processedMessage = message;
+            if (templateId && variables) {
+              processedMessage = this.processTemplate(message, variables);
+            }
+
+            // Merge config with enhanced parameters
+            const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+
+            const result = await strategy.sendMessage(to, processedMessage, finalConfig);
+            
+            if (result.success) {
+              this.logger.log(
+                `Generic message sent successfully via ${hub.provider}/${hub.service} to ${to}`,
+              );
+              return result;
+            }
+
+            this.logger.warn(
+              `Failed to send via ${hub.provider}/${hub.service}: ${result.error}`,
+            );
+          } catch (error) {
+            this.logger.error(
+              `Error sending via ${hub.provider}/${hub.service}:`,
+              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: CommunicationResult[]; summary: any }> {
+    try {
+      const {
+        levelId,
+        levelType,
+        recipients,
+        message,
+        type,
+        priority = 'low',
+        subject,
+        html,
+        templateId,
+        variables,
+        batchSize = 10
+      } = bulkDto;
+
+      const results: CommunicationResult[] = [];
+      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,
+              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 CommunicationResult;
+          }
+        });
+
+        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 CommunicationResult;
+          }
+        });
+
+        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<CommunicationResult> {
+    // Get template content (integrate with your template system)
+    const template = await this.getTemplate(templateDto.templateId);
+    
+    const processedMessage = this.processTemplate(template.content, templateDto.variables);
+    const processedSubject = template.subject ? this.processTemplate(template.subject, templateDto.variables) : undefined;
+
+    const messageDto: GenericMessageDto = {
+      levelId: templateDto.levelId,
+      levelType: templateDto.levelType,
+      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): CommunicationConfigType {
+    if (type) {
+      return type as CommunicationConfigType;
+    }
+
+    const recipient = Array.isArray(to) ? to[0] : to;
+
+    // Email detection
+    if (recipient.includes('@')) {
+      return CommunicationConfigType.EMAIL;
+    }
+
+    // Phone number detection (basic)
+    if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
+      // Could be SMS or WhatsApp, default to SMS
+      return CommunicationConfigType.SMS;
+    }
+
+    // Default to EMAIL if unsure
+    return CommunicationConfigType.EMAIL;
+  }
+
+  private sortHubsByPriorityAndDefault(
+    hubs: CommunicationHubWithConfig[],
+    _priority: string,
+  ): CommunicationHubWithConfig[] {
+    return hubs.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();
+    });
+  }
+
+  private processTemplate(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,
+    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,
+        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',
+      ];
+
+      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,
+      };
+
+      // Create communication config
+      const communicationConfig = this.configRepository.create({
+        config_json: gmailConfig as any,
+      });
+      const savedConfig = await this.configRepository.save(communicationConfig);
+
+      // Create communication hub
+      const hub = this.hubRepository.create({
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        config_id: savedConfig.id,
+        communication_config_type: CommunicationConfigType.EMAIL,
+        service: 'API',
+        provider: 'gmail',
+        status: 1,
+      });
+
+      const savedHub = await this.hubRepository.save(hub);
+
+      this.logger.log(
+        `Gmail OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedHub.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');
+      }
+
+      // 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 communication config
+      const communicationConfig = this.configRepository.create({
+        config_json: gmailConfig as any,
+      });
+      const savedConfig = await this.configRepository.save(communicationConfig);
+
+      // Create communication hub
+      const hub = this.hubRepository.create({
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        config_id: savedConfig.id,
+        communication_config_type: CommunicationConfigType.EMAIL,
+        service: 'API',
+        provider: 'gmail',
+        status: 1,
+      });
+
+      const savedHub = await this.hubRepository.save(hub);
+
+      this.logger.log(
+        `Gmail tokens configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedHub.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 hub = await this.hubRepository.findOne({
+        where: { id: hubId },
+      });
+
+      if (!hub) {
+        throw new Error('Communication hub not found');
+      }
+
+      const config = await this.configRepository.findOne({
+        where: { id: hub.config_id },
+      });
+
+      if (!config) {
+        throw new Error('Configuration not found');
+      }
+
+      const isValid = await this.gmailApiStrategy.validateConnection(config.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 requiresOAuthFlow(
+    configType: CommunicationConfigType,
+    service: string,
+    provider: string,
+    config: any
+  ): boolean {
+    // Check if config indicates OAuth is needed (missing tokens or explicit OAuth request)
+    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    
+    switch (key) {
+      case 'email_api_gmail':
+        // Requires OAuth if no access token provided or OAuth explicitly requested
+        return !config.accessToken || config.useOAuth === true;
+      
+      case 'email_api_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,
+    configType: CommunicationConfigType,
+    service: string,
+    provider: string,
+    config: any,
+    priority?: number,
+    is_default?: boolean
+  ): Promise<{ authUrl: string; state: string; message: string }> {
+    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    
+    switch (key) {
+      case 'email_api_gmail':
+        const gmailResult = await this.initGmailOAuth(levelId, levelType, config.email);
+        return {
+          authUrl: gmailResult.authUrl,
+          state: gmailResult.state,
+          message: 'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.'
+        };
+      
+      case 'email_api_outlook':
+        const outlookResult = await this.initOutlookOAuth(levelId, levelType, 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}/${service}/${provider}`);
+    }
+  }
+
+  private async createDirectConfig(
+    levelId: number,
+    levelType: string,
+    configType: CommunicationConfigType,
+    service: string,
+    provider: string,
+    config: any,
+    priority?: number,
+    is_default?: boolean
+  ): Promise<CommunicationHub> {
+    // If setting as default, remove default from other configurations of same type
+    if (is_default) {
+      await this.hubRepository.update(
+        { 
+          level_id: levelId,
+          level_type: levelType,
+          communication_config_type: configType,
+        },
+        { is_default: false }
+      );
+    }
+
+    // First, create the config
+    const communicationConfig = this.configRepository.create({
+      config_json: config as any,
+    });
+    const savedConfig = await this.configRepository.save(communicationConfig);
+
+    // Then create the hub
+    const hub = this.hubRepository.create({
+      level_id: levelId,
+      level_type: levelType,
+      config_id: savedConfig.id,
+      communication_config_type: configType,
+      service: service as any,
+      provider: provider as any,
+      priority: priority || 1,
+      is_default: is_default || false,
+      status: 1,
+    });
+
+    const savedHub = await this.hubRepository.save(hub);
+    this.logger.log(`Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`);
+    
+    return Array.isArray(savedHub) ? savedHub[0] : savedHub;
+  }
+
+  async initOutlookOAuth(
+    levelId: number,
+    levelType: 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,
+        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');
+      }
+
+      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 communication config
+      const communicationConfig = this.configRepository.create({
+        config_json: outlookConfig as any,
+      });
+      const savedConfig = await this.configRepository.save(communicationConfig);
+
+      // Create communication hub
+      const hub = this.hubRepository.create({
+        level_id: oauthState.levelId,
+        level_type: oauthState.levelType,
+        config_id: savedConfig.id,
+        communication_config_type: CommunicationConfigType.EMAIL,
+        service: 'API',
+        provider: 'outlook',
+        status: 1,
+      });
+
+      const savedHub = await this.hubRepository.save(hub);
+
+      this.logger.log(
+        `Outlook OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
+      );
+
+      return {
+        hubId: savedHub.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}`);
+    }
+  }
+}