rez_core 2.2.158 → 2.2.161

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

@@ -1,16 +1,17 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, Inject, forwardRef } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { ConfigService } from '@nestjs/config';
 import { google } from 'googleapis';
 import {
-  CommunicationHub,
   CommunicationConfigType,
+  CommunicationHub,
 } 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';
+import { CommunicationQueueService } from './communication-queue.service';
 
 export interface SendMessageDto {
   levelId: number;
@@ -83,6 +84,8 @@ export class CommunicationService {
     private readonly communicationFactory: CommunicationFactory,
     private readonly gmailApiStrategy: GmailApiStrategy,
     private readonly configService: ConfigService,
+    @Inject(forwardRef(() => CommunicationQueueService))
+    private readonly queueService?: CommunicationQueueService,
   ) {}
 
   async sendMessage({
@@ -145,20 +148,22 @@ export class CommunicationService {
       .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',
+        'hub.id as hub_id',
+        'hub.level_id as hub_level_id',
+        'hub.level_type as hub_level_type',
+        'hub.status as hub_status',
+        'hub.config_id as hub_config_id',
+        'hub.communication_config_type as hub_communication_config_type',
+        'hub.service as hub_service',
+        'hub.provider as hub_provider',
+        'hub.priority as hub_priority',
+        'hub.is_default as hub_is_default',
+        'hub.created_at as hub_created_at',
+        'hub.updated_at as 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'
+        'config.updated_at as config_updated_at',
       ])
       .where('hub.level_id = :levelId', { levelId })
       .andWhere('hub.level_type = :levelType', { levelType })
@@ -171,7 +176,7 @@ export class CommunicationService {
     const results = await query.getRawMany();
 
     // Transform the raw results into the expected format
-    const hubsWithConfig: CommunicationHubWithConfig[] = results.map(row => ({
+    const hubsWithConfig: CommunicationHubWithConfig[] = results.map((row) => ({
       id: row.hub_id,
       level_id: row.hub_level_id,
       level_type: row.hub_level_type,
@@ -214,7 +219,32 @@ export class CommunicationService {
       hub.provider,
     );
 
-    return strategy.sendMessage(to, message, hub.config.config_json);
+    const result = await strategy.sendMessage(to, message, hub.config.config_json);
+
+    // If token was refreshed, update it in the database
+    if (result.refreshedToken && result.success) {
+      try {
+        const currentConfig = hub.config.config_json as any;
+        const updatedConfig = {
+          ...currentConfig,
+          accessToken: result.refreshedToken,
+        };
+        
+        await this.configRepository.update(hub.config.id, {
+          config_json: updatedConfig,
+        } as any);
+        
+        this.logger.log(
+          `Updated access token for ${hub.provider}/${hub.service} configuration`,
+        );
+      } catch (error) {
+        this.logger.warn(
+          `Failed to update refreshed token in database: ${error.message}`,
+        );
+      }
+    }
+
+    return result;
   }
 
   async createCommunicationConfig(
@@ -226,29 +256,57 @@ export class CommunicationService {
     config: any,
     priority?: number,
     is_default?: boolean,
-  ): Promise<CommunicationHub | { authUrl: string; state: string; message: string }> {
+  ): 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()
+      (combo) =>
+        combo.mode === configType &&
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
     );
-    
+
     if (!isValidCombination) {
-      throw new Error(`Unsupported combination: ${configType}/${service}/${provider}`);
+      throw new Error(
+        `Unsupported combination: ${configType}/${service}/${provider}`,
+      );
     }
 
     // Check if this requires OAuth flow
-    const requiresOAuth = this.requiresOAuthFlow(configType, service, provider, config);
-    
+    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);
+      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);
+    return await this.createDirectConfig(
+      levelId,
+      levelType,
+      configType,
+      service,
+      provider,
+      config,
+      priority,
+      is_default,
+    );
   }
 
   async getSupportedCombinations(): Promise<
@@ -275,7 +333,9 @@ export class CommunicationService {
     await this.hubRepository.update(hubId, { status });
   }
 
-  async sendGenericMessage(messageDto: GenericMessageDto): Promise<CommunicationResult> {
+  async sendGenericMessage(
+    messageDto: GenericMessageDto,
+  ): Promise<CommunicationResult> {
     try {
       const {
         levelId,
@@ -291,17 +351,26 @@ export class CommunicationService {
         attachments,
         mediaUrl,
         templateId,
-        variables
+        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);
-      
+      const hubs = await this.getActiveHubs(
+        levelId,
+        levelType,
+        communicationType,
+      );
+
       if (!hubs.length) {
-        throw new Error(`No active ${communicationType} configuration found for ${levelType} ${levelId}`);
+        this.logger.warn(
+          `No communication hubs found for ${levelType} ${levelId}. Please configure communication providers using the createCommunicationConfig 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
@@ -338,10 +407,17 @@ export class CommunicationService {
               }
 
               // Merge config with enhanced parameters
-              const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+              const finalConfig = {
+                ...hub.config.config_json,
+                ...enhancedConfig,
+              };
+
+              const result = await strategy.sendMessage(
+                recipient,
+                processedMessage,
+                finalConfig,
+              );
 
-              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}`,
@@ -367,7 +443,7 @@ export class CommunicationService {
         if (hasSuccess) {
           return {
             success: true,
-            messageId: results.map(r => r.messageId).join(','),
+            messageId: results.map((r) => r.messageId).join(','),
             provider: 'multiple',
             service: 'multiple',
             timestamp: new Date(),
@@ -390,10 +466,17 @@ export class CommunicationService {
             }
 
             // Merge config with enhanced parameters
-            const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+            const finalConfig = {
+              ...hub.config.config_json,
+              ...enhancedConfig,
+            };
+
+            const result = await strategy.sendMessage(
+              to,
+              processedMessage,
+              finalConfig,
+            );
 
-            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}`,
@@ -421,7 +504,9 @@ export class CommunicationService {
     }
   }
 
-  async sendBulkMessage(bulkDto: BulkMessageDto): Promise<{ results: CommunicationResult[]; summary: any }> {
+  async sendBulkMessage(
+    bulkDto: BulkMessageDto,
+  ): Promise<{ results: CommunicationResult[]; summary: any }> {
     try {
       const {
         levelId,
@@ -434,7 +519,7 @@ export class CommunicationService {
         html,
         templateId,
         variables,
-        batchSize = 10
+        batchSize = 10,
       } = bulkDto;
 
       const results: CommunicationResult[] = [];
@@ -442,7 +527,9 @@ export class CommunicationService {
 
       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`);
+        this.logger.log(
+          `Processing batch ${i + 1}/${batches.length} with ${batch.length} recipients`,
+        );
 
         const batchPromises = batch.map(async (recipient) => {
           try {
@@ -490,18 +577,24 @@ export class CommunicationService {
 
         // Rate limiting delay between batches
         if (i < batches.length - 1) {
-          await new Promise(resolve => setTimeout(resolve, 1000));
+          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) + '%',
+        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`);
+      this.logger.log(
+        `Bulk message completed: ${summary.successful}/${summary.total} successful`,
+      );
 
       return { results, summary };
     } catch (error) {
@@ -510,10 +603,12 @@ export class CommunicationService {
     }
   }
 
-  async scheduleMessage(scheduledDto: any): Promise<{ scheduled: boolean; scheduleId?: string }> {
+  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)}`,
@@ -523,9 +618,14 @@ export class CommunicationService {
   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 processedMessage = this.processTemplate(
+      template.content,
+      templateDto.variables,
+    );
+    const processedSubject = template.subject
+      ? this.processTemplate(template.subject, templateDto.variables)
+      : undefined;
 
     const messageDto: GenericMessageDto = {
       levelId: templateDto.levelId,
@@ -541,7 +641,10 @@ export class CommunicationService {
     return this.sendGenericMessage(messageDto);
   }
 
-  private detectCommunicationType(to: string | string[], type?: string): CommunicationConfigType {
+  private detectCommunicationType(
+    to: string | string[],
+    type?: string,
+  ): CommunicationConfigType {
     if (type) {
       return type as CommunicationConfigType;
     }
@@ -572,18 +675,23 @@ export class CommunicationService {
       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();
+      return (
+        new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+      );
     });
   }
 
-  private processTemplate(template: string, variables: Record<string, any>): string {
+  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;
@@ -617,15 +725,17 @@ export class CommunicationService {
       // 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';
-      
+      const callbackUrl =
+        this.configService.get<string>('CALLBACK_URL') ||
+        'http://localhost:5001/auth/google/callback';
+
       this.gmailOAuthStates.set(state, {
         levelId,
         levelType,
@@ -634,9 +744,12 @@ export class CommunicationService {
       });
 
       // Auto-cleanup after 10 minutes
-      setTimeout(() => {
-        this.gmailOAuthStates.delete(state);
-      }, 10 * 60 * 1000);
+      setTimeout(
+        () => {
+          this.gmailOAuthStates.delete(state);
+        },
+        10 * 60 * 1000,
+      );
 
       const oauth2Client = new google.auth.OAuth2(
         clientId,
@@ -684,7 +797,9 @@ export class CommunicationService {
       // 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 callbackUrl =
+        this.configService.get<string>('CALLBACK_URL') ||
+        'http://localhost:5001/auth/google/callback';
 
       const oauth2Client = new google.auth.OAuth2(
         clientId,
@@ -693,7 +808,7 @@ export class CommunicationService {
       );
 
       const { tokens } = await oauth2Client.getToken(code);
-      
+
       if (!tokens.access_token) {
         throw new Error('Failed to obtain access token');
       }
@@ -821,11 +936,15 @@ export class CommunicationService {
       };
     } catch (error) {
       this.logger.error('Error handling Gmail tokens callback:', error.message);
-      throw new Error(`Failed to complete 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 }> {
+  async testGmailConfig(
+    hubId: number,
+  ): Promise<{ success: boolean; error?: string }> {
     try {
       const hub = await this.hubRepository.findOne({
         where: { id: hubId },
@@ -843,10 +962,15 @@ export class CommunicationService {
         throw new Error('Configuration not found');
       }
 
-      const isValid = await this.gmailApiStrategy.validateConnection(config.config_json);
-      
+      const isValid = await this.gmailApiStrategy.validateConnection(
+        config.config_json,
+      );
+
       if (!isValid) {
-        return { success: false, error: 'Gmail configuration is invalid or expired' };
+        return {
+          success: false,
+          error: 'Gmail configuration is invalid or expired',
+        };
       }
 
       return { success: true };
@@ -864,20 +988,20 @@ export class CommunicationService {
     configType: CommunicationConfigType,
     service: string,
     provider: string,
-    config: any
+    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;
@@ -892,29 +1016,41 @@ export class CommunicationService {
     provider: string,
     config: any,
     priority?: number,
-    is_default?: boolean
+    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);
+        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.'
+          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);
+        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.'
+          message:
+            'Please complete Outlook OAuth authorization. Configuration will be created automatically after authorization.',
         };
-      
+
       default:
-        throw new Error(`OAuth not supported for ${configType}/${service}/${provider}`);
+        throw new Error(
+          `OAuth not supported for ${configType}/${service}/${provider}`,
+        );
     }
   }
 
@@ -926,23 +1062,23 @@ export class CommunicationService {
     provider: string,
     config: any,
     priority?: number,
-    is_default?: boolean
+    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 }
+        { is_default: false },
       );
     }
 
     // First, create the config
     const communicationConfig = this.configRepository.create({
-      config_json: config as any,
+      config_json: config,
     });
     const savedConfig = await this.configRepository.save(communicationConfig);
 
@@ -960,8 +1096,10 @@ export class CommunicationService {
     });
 
     const savedHub = await this.hubRepository.save(hub);
-    this.logger.log(`Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`);
-    
+    this.logger.log(
+      `Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`,
+    );
+
     return Array.isArray(savedHub) ? savedHub[0] : savedHub;
   }
 
@@ -974,14 +1112,16 @@ export class CommunicationService {
       // 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';
-      
+      const callbackUrl =
+        this.configService.get<string>('OUTLOOK_CALLBACK_URL') ||
+        'http://localhost:5001/auth/outlook/callback';
+
       this.gmailOAuthStates.set(state, {
         levelId,
         levelType,
@@ -990,16 +1130,20 @@ export class CommunicationService {
       });
 
       // Auto-cleanup after 10 minutes
-      setTimeout(() => {
-        this.gmailOAuthStates.delete(state);
-      }, 10 * 60 * 1000);
+      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?` +
+      const authUrl =
+        `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize?` +
         `client_id=${clientId}&` +
         `response_type=code&` +
         `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
@@ -1033,27 +1177,34 @@ export class CommunicationService {
       }
 
       const clientId = this.configService.get<string>('OUTLOOK_CLIENT_ID');
-      const clientSecret = this.configService.get<string>('OUTLOOK_CLIENT_SECRET');
+      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';
+      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',
+      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',
+          }),
         },
-        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');
       }
@@ -1061,7 +1212,7 @@ export class CommunicationService {
       // Get user info from Microsoft Graph
       const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
         headers: {
-          'Authorization': `Bearer ${tokens.access_token}`,
+          Authorization: `Bearer ${tokens.access_token}`,
         },
       });
 
@@ -1111,8 +1262,126 @@ export class CommunicationService {
         configId: savedConfig.id,
       };
     } catch (error) {
-      this.logger.error('Error handling Outlook OAuth callback:', error.message);
+      this.logger.error(
+        'Error handling Outlook OAuth callback:',
+        error.message,
+      );
       throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
     }
   }
+
+  // Simple Queue Integration Methods
+
+  async queueMessage(
+    messageDto: GenericMessageDto & { useQueue?: boolean; scheduledFor?: Date },
+  ): Promise<{ queued: boolean; messageId?: string; result?: CommunicationResult }> {
+    if (!this.queueService || !messageDto.useQueue) {
+      // Fallback to immediate sending if queue is not available or not requested
+      const result = await this.sendGenericMessage(messageDto);
+      return { queued: false, result };
+    }
+
+    try {
+      const priority = this.mapPriorityToSimpleQueue(messageDto.priority);
+
+      const messageId = await this.queueService.queueMessage(
+        messageDto.levelId,
+        messageDto.levelType,
+        Array.isArray(messageDto.to) ? messageDto.to[0] : messageDto.to,
+        messageDto.message,
+        messageDto.type,
+        priority,
+        messageDto.scheduledFor,
+        {
+          subject: messageDto.subject,
+          html: messageDto.html,
+          cc: messageDto.cc,
+          bcc: messageDto.bcc,
+          attachments: messageDto.attachments,
+          mediaUrl: messageDto.mediaUrl,
+          templateId: messageDto.templateId,
+          variables: messageDto.variables,
+        },
+      );
+
+      return { queued: true, messageId };
+    } catch (error) {
+      this.logger.error('Error queuing message, falling back to immediate send:', error.message);
+      // Fallback to immediate sending
+      const result = await this.sendGenericMessage(messageDto);
+      return { queued: false, result };
+    }
+  }
+
+  async queueBulkMessage(
+    bulkDto: BulkMessageDto & { useQueue?: boolean; scheduledFor?: Date },
+  ): Promise<{ queued: boolean; messageIds?: string[]; result?: any }> {
+    if (!this.queueService || !bulkDto.useQueue) {
+      // Fallback to immediate sending if queue is not available or not requested
+      const result = await this.sendBulkMessage(bulkDto);
+      return { queued: false, result };
+    }
+
+    try {
+      const priority = this.mapPriorityToSimpleQueue(bulkDto.priority) || 'low';
+
+      const messageIds = await this.queueService.queueBulkMessages(
+        bulkDto.levelId,
+        bulkDto.levelType,
+        bulkDto.recipients,
+        bulkDto.message,
+        bulkDto.type,
+        priority,
+        {
+          subject: bulkDto.subject,
+          html: bulkDto.html,
+          templateId: bulkDto.templateId,
+          variables: bulkDto.variables,
+        },
+      );
+
+      return { queued: true, messageIds };
+    } catch (error) {
+      this.logger.error('Error queuing bulk message, falling back to immediate send:', error.message);
+      // Fallback to immediate sending
+      const result = await this.sendBulkMessage(bulkDto);
+      return { queued: false, result };
+    }
+  }
+
+  // Helper method to check if queue service is available
+  isQueueAvailable(): boolean {
+    return !!this.queueService;
+  }
+
+  // Helper method to get queue stats if available
+  getQueueStats() {
+    if (!this.queueService) {
+      return null;
+    }
+
+    return this.queueService.getQueueStats();
+  }
+
+  // Helper method to cancel queued messages
+  cancelQueuedMessage(messageId: string): boolean {
+    if (!this.queueService) {
+      return false;
+    }
+
+    return this.queueService.cancelMessage(messageId);
+  }
+
+  private mapPriorityToSimpleQueue(priority?: string): 'high' | 'medium' | 'low' {
+    switch (priority?.toLowerCase()) {
+      case 'high':
+      case 'urgent':
+        return 'high';
+      case 'low':
+        return 'low';
+      case 'medium':
+      default:
+        return 'medium';
+    }
+  }
 }