rez_core 2.2.154 → 2.2.156

package/src/module/communication/examples/usage.example.ts

@@ -0,0 +1,169 @@
+/**
+ * Communication Hub Usage Examples
+ * 
+ * This file demonstrates how to use the hierarchical communication system.
+ */
+
+import { CommunicationService } from '../service/communication.service';
+import { CommunicationConfigType } from '../entity/communication-hub.entity';
+
+export class CommunicationUsageExamples {
+  constructor(private readonly communicationService: CommunicationService) {}
+
+  /**
+   * Example 1: Send an email using Gmail API
+   */
+  async sendEmailViaGmailApi() {
+    // First, create a configuration for Gmail API
+    const emailConfig = {
+      clientId: 'your-gmail-client-id',
+      clientSecret: 'your-gmail-client-secret',
+      refreshToken: 'your-refresh-token'
+    };
+
+    const hub = await this.communicationService.createCommunicationConfig(
+      1, // levelId
+      'organization', // levelType
+      CommunicationConfigType.EMAIL,
+      'API',
+      'gmail',
+      emailConfig
+    );
+
+    console.log('Created email config:', hub);
+
+    // Send a message
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      to: 'recipient@example.com',
+      message: 'Hello from Gmail API!',
+      mode: CommunicationConfigType.EMAIL
+    });
+
+    console.log('Email sent:', result);
+  }
+
+  /**
+   * Example 2: Send SMS using Twilio
+   */
+  async sendSmsViaTwilio() {
+    const smsConfig = {
+      accountSid: 'your-twilio-account-sid',
+      authToken: 'your-twilio-auth-token',
+      fromNumber: '+1234567890'
+    };
+
+    await this.communicationService.createCommunicationConfig(
+      1,
+      'organization',
+      CommunicationConfigType.SMS,
+      'THIRD_PARTY',
+      'twilio',
+      smsConfig
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      to: '+9876543210',
+      message: 'Hello from Twilio SMS!',
+      mode: CommunicationConfigType.SMS
+    });
+
+    console.log('SMS sent:', result);
+  }
+
+  /**
+   * Example 3: Send WhatsApp message
+   */
+  async sendWhatsAppMessage() {
+    const whatsappConfig = {
+      accessToken: 'your-whatsapp-access-token',
+      phoneNumberId: 'your-phone-number-id',
+      businessAccountId: 'your-business-account-id'
+    };
+
+    await this.communicationService.createCommunicationConfig(
+      1,
+      'organization',
+      CommunicationConfigType.WA,
+      'API',
+      'whatsapp',
+      whatsappConfig
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      to: '+9876543210',
+      message: 'Hello from WhatsApp!',
+      mode: CommunicationConfigType.WA
+    });
+
+    console.log('WhatsApp sent:', result);
+  }
+
+  /**
+   * Example 4: Make a voice call using Knowlarity
+   */
+  async makeVoiceCall() {
+    const voiceConfig = {
+      apiKey: 'your-knowlarity-api-key',
+      callerId: '+1234567890',
+      voiceUrl: 'https://your-voice-script-url.com'
+    };
+
+    await this.communicationService.createCommunicationConfig(
+      1,
+      'organization',
+      CommunicationConfigType.TELEPHONE,
+      'THIRD_PARTY',
+      'knowlarity',
+      voiceConfig
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      to: '+9876543210',
+      message: 'Voice message content',
+      mode: CommunicationConfigType.TELEPHONE
+    });
+
+    console.log('Voice call initiated:', result);
+  }
+
+  /**
+   * Example 5: Get all supported combinations
+   */
+  async getSupportedCombinations() {
+    const combinations = await this.communicationService.getSupportedCombinations();
+    console.log('Supported combinations:', combinations);
+    
+    // Output will be:
+    // [
+    //   { mode: 'EMAIL', service: 'API', provider: 'gmail' },
+    //   { mode: 'EMAIL', service: 'SMTP', provider: 'gmail' },
+    //   { mode: 'EMAIL', service: 'API', provider: 'outlook' },
+    //   { mode: 'SMS', service: 'THIRD_PARTY', provider: 'twilio' },
+    //   { mode: 'SMS', service: 'THIRD_PARTY', provider: 'knowlarity' },
+    //   { mode: 'WA', service: 'API', provider: 'whatsapp' },
+    //   { mode: 'TELEPHONE', service: 'THIRD_PARTY', provider: 'knowlarity' }
+    // ]
+  }
+
+  /**
+   * Example 6: Send message without specifying mode (uses first available)
+   */
+  async sendMessageAutoMode() {
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      to: 'recipient@example.com',
+      message: 'Hello! This will use the first available communication method.'
+    });
+
+    console.log('Message sent via auto-selected provider:', result);
+  }
+}

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

@@ -0,0 +1,7 @@
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+
+export interface BaseFactory {
+  createProvider(service: string, provider: string): CommunicationStrategy;
+  getSupportedCombinations(): Array<{ service: string; provider: string }>;
+  validateCombination(service: string, provider: string): boolean;
+}

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

@@ -0,0 +1,103 @@
+import { Injectable } from '@nestjs/common';
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { EmailFactory } from './email.factory';
+import { SmsFactory } from './sms.factory';
+import { WhatsAppFactory } from './whatsapp.factory';
+import { TelephoneFactory } from './telephone.factory';
+
+export enum CommunicationMode {
+  EMAIL = 'EMAIL',
+  SMS = 'SMS', 
+  WA = 'WA',
+  TELEPHONE = 'TELEPHONE'
+}
+
+@Injectable()
+export class CommunicationFactory {
+  private readonly modeFactoryMap = new Map<CommunicationMode, any>();
+
+  constructor(
+    private emailFactory: EmailFactory,
+    private smsFactory: SmsFactory,
+    private whatsappFactory: WhatsAppFactory,
+    private telephoneFactory: TelephoneFactory,
+  ) {
+    this.initializeFactoryMap();
+  }
+
+  private initializeFactoryMap(): void {
+    this.modeFactoryMap.set(CommunicationMode.EMAIL, this.emailFactory);
+    this.modeFactoryMap.set(CommunicationMode.SMS, this.smsFactory);
+    this.modeFactoryMap.set(CommunicationMode.WA, this.whatsappFactory);
+    this.modeFactoryMap.set(CommunicationMode.TELEPHONE, this.telephoneFactory);
+  }
+
+  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}`);
+    }
+
+    const factory = this.modeFactoryMap.get(communicationMode);
+    if (!factory) {
+      throw new Error(`Factory not found for mode: ${mode}`);
+    }
+
+    return factory.createProvider(service, provider);
+  }
+
+  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 => {
+        combinations.push({
+          mode: mode,
+          service: combo.service,
+          provider: combo.provider
+        });
+      });
+    });
+    
+    return combinations;
+  }
+
+  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 {
+    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;
+    }
+  }
+
+  getAvailableModes(): string[] {
+    return Object.values(CommunicationMode);
+  }
+
+  getProvidersByModeAndService(mode: string, service: string): string[] {
+    const combinations = this.getSupportedCombinationsForMode(mode);
+    return combinations
+      .filter(combo => combo.service.toLowerCase() === service.toLowerCase())
+      .map(combo => combo.provider);
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { GmailStrategy } from '../strategies/gmail.strategy';
+import { OutlookStrategy } from '../strategies/outlook.strategy';
+import { GmailSMTPStrategy } from '../strategies/gmail-smtp.strategy';
+import { OutlookSMTPStrategy } from '../strategies/outlook-smtp.strategy';
+
+@Injectable()
+export class EmailFactory implements BaseFactory {
+  constructor(
+    private gmailStrategy: GmailStrategy,
+    private outlookStrategy: OutlookStrategy,
+    private gmailSMTPStrategy: GmailSMTPStrategy,
+    private outlookSMTPStrategy: OutlookSMTPStrategy,
+  ) {}
+
+  createProvider(service: string, provider: string): CommunicationStrategy {
+    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
+    
+    switch (key) {
+      case 'api_gmail':
+        return this.gmailStrategy;
+      case 'api_outlook':
+        return this.outlookStrategy;
+      case 'smtp_gmail':
+        return this.gmailSMTPStrategy;
+      case 'smtp_outlook':
+        return this.outlookSMTPStrategy;
+      
+      default:
+        throw new Error(`Unsupported EMAIL service/provider: ${service}/${provider}`);
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    return [
+      { service: 'API', provider: 'gmail' },
+      { service: 'API', provider: 'outlook' },
+      { service: 'SMTP', provider: 'gmail' },
+      { service: 'SMTP', provider: 'outlook' },
+    ];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    return this.getSupportedCombinations().some(
+      combo => combo.service.toLowerCase() === service.toLowerCase() && 
+               combo.provider.toLowerCase() === provider.toLowerCase()
+    );
+  }
+}

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

@@ -0,0 +1,41 @@
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { SmsStrategy } from '../strategies/sms.strategy';
+import { KnowlarityStrategy } from '../strategies/knowlarity.strategy';
+
+@Injectable()
+export class SmsFactory implements BaseFactory {
+  constructor(
+    private twilioStrategy: SmsStrategy,
+    private knowlarityStrategy: KnowlarityStrategy,
+  ) {}
+
+  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}`);
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    return [
+      { service: 'THIRD_PARTY', provider: 'twilio' },
+      { 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()
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { KnowlarityStrategy } from '../strategies/knowlarity.strategy';
+
+@Injectable()
+export class TelephoneFactory implements BaseFactory {
+  constructor(private knowlarityStrategy: KnowlarityStrategy) {}
+
+  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}`);
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    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()
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { WhatsAppStrategy } from '../strategies/whatsapp.strategy';
+
+@Injectable()
+export class WhatsAppFactory implements BaseFactory {
+  constructor(private whatsappStrategy: WhatsAppStrategy) {}
+
+  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}`);
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    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()
+    );
+  }
+}