rez_core 2.2.158 → 2.2.159

package/src/module/communication/factories/communication.factory.ts

@@ -7,9 +7,9 @@ import { TelephoneFactory } from './telephone.factory';
 
 export enum CommunicationMode {
   EMAIL = 'EMAIL',
-  SMS = 'SMS', 
+  SMS = 'SMS',
   WA = 'WA',
-  TELEPHONE = 'TELEPHONE'
+  TELEPHONE = 'TELEPHONE',
 }
 
 @Injectable()
@@ -32,9 +32,13 @@ export class CommunicationFactory {
     this.modeFactoryMap.set(CommunicationMode.TELEPHONE, this.telephoneFactory);
   }
 
-  create(mode: string, service: string, provider: string): CommunicationStrategy {
+  create(
+    mode: string,
+    service: string,
+    provider: string,
+  ): CommunicationStrategy {
     const communicationMode = mode.toUpperCase() as CommunicationMode;
-    
+
     if (!Object.values(CommunicationMode).includes(communicationMode)) {
       throw new Error(`Unsupported communication mode: ${mode}`);
     }
@@ -47,43 +51,57 @@ export class CommunicationFactory {
     return factory.createProvider(service, provider);
   }
 
-  getAllSupportedCombinations(): Array<{ mode: string; service: string; provider: string }> {
-    const combinations: Array<{ mode: string; service: string; provider: string }> = [];
-    
+  getAllSupportedCombinations(): Array<{
+    mode: string;
+    service: string;
+    provider: string;
+  }> {
+    const combinations: Array<{
+      mode: string;
+      service: string;
+      provider: string;
+    }> = [];
+
     this.modeFactoryMap.forEach((factory, mode) => {
       const factoryCombinations = factory.getSupportedCombinations();
-      factoryCombinations.forEach(combo => {
+      factoryCombinations.forEach((combo) => {
         combinations.push({
           mode: mode,
           service: combo.service,
-          provider: combo.provider
+          provider: combo.provider,
         });
       });
     });
-    
+
     return combinations;
   }
 
-  getSupportedCombinationsForMode(mode: string): Array<{ service: string; provider: string }> {
+  getSupportedCombinationsForMode(
+    mode: string,
+  ): Array<{ service: string; provider: string }> {
     const communicationMode = mode.toUpperCase() as CommunicationMode;
     const factory = this.modeFactoryMap.get(communicationMode);
-    
+
     if (!factory) {
       throw new Error(`Factory not found for mode: ${mode}`);
     }
-    
+
     return factory.getSupportedCombinations();
   }
 
-  validateCombination(mode: string, service: string, provider: string): boolean {
+  validateCombination(
+    mode: string,
+    service: string,
+    provider: string,
+  ): boolean {
     try {
       const communicationMode = mode.toUpperCase() as CommunicationMode;
       const factory = this.modeFactoryMap.get(communicationMode);
-      
+
       if (!factory) {
         return false;
       }
-      
+
       return factory.validateCombination(service, provider);
     } catch {
       return false;
@@ -97,7 +115,7 @@ export class CommunicationFactory {
   getProvidersByModeAndService(mode: string, service: string): string[] {
     const combinations = this.getSupportedCombinationsForMode(mode);
     return combinations
-      .filter(combo => combo.service.toLowerCase() === service.toLowerCase())
-      .map(combo => combo.provider);
+      .filter((combo) => combo.service.toLowerCase() === service.toLowerCase())
+      .map((combo) => combo.provider);
   }
 }

package/src/module/communication/factories/email.factory.ts

@@ -17,7 +17,7 @@ export class EmailFactory implements BaseFactory {
 
   createProvider(service: string, provider: string): CommunicationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-    
+
     switch (key) {
       case 'api_gmail':
         return this.gmailStrategy;
@@ -27,9 +27,11 @@ export class EmailFactory implements BaseFactory {
         return this.gmailSMTPStrategy;
       case 'smtp_outlook':
         return this.outlookSMTPStrategy;
-      
+
       default:
-        throw new Error(`Unsupported EMAIL service/provider: ${service}/${provider}`);
+        throw new Error(
+          `Unsupported EMAIL service/provider: ${service}/${provider}`,
+        );
     }
   }
 
@@ -44,8 +46,9 @@ export class EmailFactory implements BaseFactory {
 
   validateCombination(service: string, provider: string): boolean {
     return this.getSupportedCombinations().some(
-      combo => combo.service.toLowerCase() === service.toLowerCase() && 
-               combo.provider.toLowerCase() === provider.toLowerCase()
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
     );
   }
 }

package/src/module/communication/factories/sms.factory.ts

@@ -13,15 +13,17 @@ export class SmsFactory implements BaseFactory {
 
   createProvider(service: string, provider: string): CommunicationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-    
+
     switch (key) {
       case 'third_party_twilio':
         return this.twilioStrategy;
       case 'third_party_knowlarity':
         return this.knowlarityStrategy;
-      
+
       default:
-        throw new Error(`Unsupported SMS service/provider: ${service}/${provider}`);
+        throw new Error(
+          `Unsupported SMS service/provider: ${service}/${provider}`,
+        );
     }
   }
 
@@ -34,8 +36,9 @@ export class SmsFactory implements BaseFactory {
 
   validateCombination(service: string, provider: string): boolean {
     return this.getSupportedCombinations().some(
-      combo => combo.service.toLowerCase() === service.toLowerCase() && 
-               combo.provider.toLowerCase() === provider.toLowerCase()
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
     );
   }
 }

package/src/module/communication/factories/telephone.factory.ts

@@ -9,26 +9,27 @@ export class TelephoneFactory implements BaseFactory {
 
   createProvider(service: string, provider: string): CommunicationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-    
+
     switch (key) {
       case 'third_party_knowlarity':
         return this.knowlarityStrategy;
-      
+
       default:
-        throw new Error(`Unsupported Telephone service/provider: ${service}/${provider}`);
+        throw new Error(
+          `Unsupported Telephone service/provider: ${service}/${provider}`,
+        );
     }
   }
 
   getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    return [
-      { service: 'THIRD_PARTY', provider: 'knowlarity' },
-    ];
+    return [{ service: 'THIRD_PARTY', provider: 'knowlarity' }];
   }
 
   validateCombination(service: string, provider: string): boolean {
     return this.getSupportedCombinations().some(
-      combo => combo.service.toLowerCase() === service.toLowerCase() && 
-               combo.provider.toLowerCase() === provider.toLowerCase()
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
     );
   }
 }

package/src/module/communication/factories/whatsapp.factory.ts

@@ -9,26 +9,27 @@ export class WhatsAppFactory implements BaseFactory {
 
   createProvider(service: string, provider: string): CommunicationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-    
+
     switch (key) {
       case 'api_whatsapp':
         return this.whatsappStrategy;
-      
+
       default:
-        throw new Error(`Unsupported WhatsApp service/provider: ${service}/${provider}`);
+        throw new Error(
+          `Unsupported WhatsApp service/provider: ${service}/${provider}`,
+        );
     }
   }
 
   getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    return [
-      { service: 'API', provider: 'whatsapp' },
-    ];
+    return [{ service: 'API', provider: 'whatsapp' }];
   }
 
   validateCombination(service: string, provider: string): boolean {
     return this.getSupportedCombinations().some(
-      combo => combo.service.toLowerCase() === service.toLowerCase() && 
-               combo.provider.toLowerCase() === provider.toLowerCase()
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
     );
   }
 }

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

@@ -0,0 +1,214 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+export interface QueuedMessage {
+  id: string;
+  levelId: number;
+  levelType: string;
+  recipient: string;
+  message: string;
+  type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+  priority: 'high' | 'medium' | 'low';
+  scheduledFor?: Date;
+  metadata?: any;
+  createdAt: Date;
+  retryCount: number;
+  maxRetries: number;
+}
+
+@Injectable()
+export class CommunicationQueueService {
+  private readonly logger = new Logger(CommunicationQueueService.name);
+  private queue: QueuedMessage[] = [];
+  private processing = false;
+
+  constructor() {
+    // Start processing queue every 5 seconds
+    setInterval(() => this.processQueue(), 5000);
+  }
+
+  async queueMessage(
+    levelId: number,
+    levelType: string,
+    recipient: string,
+    message: string,
+    type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    priority: 'high' | 'medium' | 'low' = 'medium',
+    scheduledFor?: Date,
+    metadata?: any,
+  ): Promise<string> {
+    const messageId = this.generateMessageId();
+    
+    const queuedMessage: QueuedMessage = {
+      id: messageId,
+      levelId,
+      levelType,
+      recipient,
+      message,
+      type,
+      priority,
+      scheduledFor,
+      metadata,
+      createdAt: new Date(),
+      retryCount: 0,
+      maxRetries: 3,
+    };
+
+    this.queue.push(queuedMessage);
+    this.sortQueue();
+
+    this.logger.log(`Message queued: ${messageId} for ${recipient} with priority ${priority}`);
+    return messageId;
+  }
+
+  async queueBulkMessages(
+    levelId: number,
+    levelType: string,
+    recipients: string[],
+    message: string,
+    type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    priority: 'high' | 'medium' | 'low' = 'low',
+    metadata?: any,
+  ): Promise<string[]> {
+    const messageIds: string[] = [];
+
+    for (const recipient of recipients) {
+      const messageId = await this.queueMessage(
+        levelId,
+        levelType,
+        recipient,
+        message,
+        type,
+        priority,
+        undefined,
+        metadata,
+      );
+      messageIds.push(messageId);
+    }
+
+    return messageIds;
+  }
+
+  getQueueStats() {
+    const total = this.queue.length;
+    const pending = this.queue.filter(m => !m.scheduledFor || m.scheduledFor <= new Date()).length;
+    const scheduled = this.queue.filter(m => m.scheduledFor && m.scheduledFor > new Date()).length;
+    
+    const byPriority = {
+      high: this.queue.filter(m => m.priority === 'high').length,
+      medium: this.queue.filter(m => m.priority === 'medium').length,
+      low: this.queue.filter(m => m.priority === 'low').length,
+    };
+
+    return {
+      total,
+      pending,
+      scheduled,
+      byPriority,
+      processing: this.processing,
+    };
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.processing || this.queue.length === 0) {
+      return;
+    }
+
+    this.processing = true;
+
+    try {
+      const now = new Date();
+      
+      // Get messages ready to send (not scheduled or scheduled time has passed)
+      const readyMessages = this.queue.filter(
+        message => !message.scheduledFor || message.scheduledFor <= now
+      );
+
+      if (readyMessages.length === 0) {
+        return;
+      }
+
+      // Sort by priority (high -> medium -> low)
+      const prioritySorted = readyMessages.sort((a, b) => {
+        const priorityOrder = { high: 3, medium: 2, low: 1 };
+        return priorityOrder[b.priority] - priorityOrder[a.priority];
+      });
+
+      // Process up to 5 messages at once
+      const messagesToProcess = prioritySorted.slice(0, 5);
+
+      for (const message of messagesToProcess) {
+        try {
+          // Remove message from queue
+          this.queue = this.queue.filter(m => m.id !== message.id);
+          
+          this.logger.log(`Processing queued message ${message.id} for ${message.recipient}`);
+          
+          // Note: In a real implementation, you would call the communication service here
+          // For now, we just simulate successful processing
+          
+        } catch (error) {
+          this.logger.error(`Failed to process message ${message.id}:`, error.message);
+          
+          // Retry logic
+          if (message.retryCount < message.maxRetries) {
+            message.retryCount++;
+            message.scheduledFor = new Date(Date.now() + (message.retryCount * 60000)); // Retry after 1, 2, 3 minutes
+            this.queue.push(message);
+            this.logger.warn(`Message ${message.id} will be retried (attempt ${message.retryCount}/${message.maxRetries})`);
+          } else {
+            this.logger.error(`Message ${message.id} failed permanently after ${message.maxRetries} attempts`);
+          }
+        }
+      }
+
+    } catch (error) {
+      this.logger.error('Error processing queue:', error.message);
+    } finally {
+      this.processing = false;
+    }
+  }
+
+  private sortQueue(): void {
+    this.queue.sort((a, b) => {
+      // Sort by priority first
+      const priorityOrder = { high: 3, medium: 2, low: 1 };
+      if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
+        return priorityOrder[b.priority] - priorityOrder[a.priority];
+      }
+      
+      // Then by creation time (oldest first)
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+  }
+
+  private generateMessageId(): string {
+    return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  // Helper methods for integration
+  isQueueEmpty(): boolean {
+    return this.queue.length === 0;
+  }
+
+  getQueueLength(): number {
+    return this.queue.length;
+  }
+
+  clearQueue(): void {
+    this.queue = [];
+    this.logger.log('Queue cleared');
+  }
+
+  // Cancel a specific message
+  cancelMessage(messageId: string): boolean {
+    const initialLength = this.queue.length;
+    this.queue = this.queue.filter(m => m.id !== messageId);
+    const canceled = this.queue.length < initialLength;
+    
+    if (canceled) {
+      this.logger.log(`Message ${messageId} canceled`);
+    }
+    
+    return canceled;
+  }
+}