rez_core 2.2.258 → 2.2.259

package/src/module/integration/entity/user-integration.entity.ts

@@ -0,0 +1,71 @@
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Index,
+} from 'typeorm';
+
+@Entity({ name: 'cr_user_integration' })
+@Index(['user_id', 'integration_config_id'], { unique: true })
+@Index(['integration_config_id'])
+@Index(['user_id'])
+export class UserIntegration {
+  @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
+  id: number;
+
+  @Column({ name: 'user_id', type: 'int' })
+  user_id: number;
+
+  @Column({ name: 'integration_config_id', type: 'int' })
+  integration_config_id: number;
+
+  @Column({
+    name: 'external_user_id',
+    type: 'varchar',
+    length: 255,
+    nullable: true,
+  })
+  external_user_id: string;
+
+  @Column({ name: 'external_user_data', type: 'json', nullable: true })
+  external_user_data: {
+    // Ozonetel agent mapping (admin creds stay in config)
+    agentId?: string;
+    agentEmail?: string;
+    agentPhone?: string;
+    // NOTE: userName, campaignName stay in integration config, not here
+
+    // Tubelight agent mapping (admin creds stay in config)
+    agentNumber?: string;
+    extension?: string;
+    department?: string;
+    // NOTE: userName, password, tenantId stay in integration config, not here
+
+    // Common agent fields (no admin credentials)
+    displayName?: string;
+    role?: string;
+    skillLevel?: string;
+    metadata?: any;
+    [key: string]: any;
+  };
+
+  @Column({ name: 'status', type: 'tinyint', default: 1 })
+  status: number;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  is_active: boolean;
+
+  @CreateDateColumn({
+    name: 'created_at',
+    type: 'datetime',
+  })
+  created_at: Date;
+
+  @UpdateDateColumn({
+    name: 'updated_at',
+    type: 'datetime',
+  })
+  updated_at: Date;
+}

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

@@ -0,0 +1,338 @@
+/**
+ * Communication Hub Usage Examples
+ *
+ * This file demonstrates how to use the hierarchical communication system.
+ */
+
+import { IntegrationService } from '../service/integration.service';
+
+export class CommunicationUsageExamples {
+  constructor(private readonly communicationService: IntegrationService) {}
+
+  /**
+   * 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.createIntegrationConfig(
+      1, // levelId
+      'organization', // levelType
+      'MY_APP_001', // app_code
+      'EMAIL', // integration_type
+      'gmail', // integration_provider
+      1, // integration_source_id
+      emailConfig,
+    );
+
+    console.log('Created email config:', hub);
+
+    // Send a message
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      message: 'Hello from Gmail API!',
+      mode: 'EMAIL',
+    });
+
+    console.log('Email sent:', result);
+  }
+
+  /**
+   * Example 2: Send Email using Outlook API
+   */
+  async sendEmailViaOutlookApi() {
+    const outlookConfig = {
+      clientId: 'your-outlook-client-id',
+      clientSecret: 'your-outlook-client-secret',
+      tenantId: 'your-tenant-id',
+      email: 'user@outlook.com',
+    };
+
+    await this.communicationService.createIntegrationConfig(
+      1,
+      'organization',
+      'MY_APP_001',
+      'EMAIL',
+      'outlook',
+      2,
+      outlookConfig,
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      message: 'Hello from Outlook API!',
+      mode: 'EMAIL',
+    });
+
+    console.log('Email 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.createIntegrationConfig(
+      1,
+      'organization',
+      'MY_APP_001',
+      'WA',
+      'whatsapp',
+      3,
+      whatsappConfig,
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: '+9876543210',
+      message: 'Hello from WhatsApp!',
+      mode: 'WA',
+    });
+
+    console.log('WhatsApp sent:', result);
+  }
+
+  /**
+   * Example 4: Make a voice call using Ozonetel
+   */
+  async makeVoiceCall() {
+    const voiceConfig = {
+      apiKey: 'your-ozonetel-api-key',
+      callerId: '+1234567890',
+      voiceUrl: 'https://your-voice-script-url.com',
+    };
+
+    await this.communicationService.createIntegrationConfig(
+      1,
+      'organization',
+      'MY_APP_001',
+      'TELEPHONE',
+      'ozonetel',
+      4,
+      voiceConfig,
+    );
+
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: '+9876543210',
+      message: 'Voice message content',
+      mode: 'TELEPHONE',
+    });
+
+    console.log('Voice call initiated:', result);
+  }
+
+  /**
+   * Example 5: Get all supported combinations
+   */
+  getSupportedCombinations() {
+    const combinations = 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: 'EMAIL', service: 'API', provider: 'sendgrid' },
+    //   { mode: 'WA', service: 'API', provider: 'whatsapp' },
+    //   { mode: 'TELEPHONE', service: 'THIRD_PARTY', provider: 'ozonetel' },
+    //   { mode: 'TELEPHONE', service: 'THIRD_PARTY', provider: 'tubelight' }
+    // ]
+  }
+
+  /**
+   * Example 6: Send Gmail email with attachments
+   */
+  async sendGmailWithAttachments() {
+    const result = await this.communicationService.sendGenericMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      subject: 'Email with Attachments',
+      message: 'Please find the attached documents.',
+      type: 'EMAIL',
+      attachments: [
+        {
+          filename: 'document.pdf',
+          content: 'base64-encoded-content-here',
+          contentType: 'application/pdf',
+        },
+        {
+          filename: 'image.jpg',
+          path: '/path/to/local/image.jpg',
+          contentType: 'image/jpeg',
+        },
+      ],
+    });
+
+    console.log('Gmail with attachments sent:', result);
+  }
+
+  /**
+   * Example 7: Send Gmail email using HTML template
+   */
+  async sendGmailWithTemplate() {
+    const htmlTemplate = `
+      <html>
+        <body>
+          <h2>Welcome {{userName}}!</h2>
+          <p>Thank you for joining our platform.</p>
+          <p>Your account ID is: {{accountId}}</p>
+          <a href="{{verificationLink}}">Verify your email</a>
+        </body>
+      </html>
+    `;
+
+    const result = await this.communicationService.sendGenericMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      subject: 'Welcome to Our Platform',
+      message: 'Welcome to Our Platform',
+      html: htmlTemplate,
+      type: 'EMAIL',
+      variables: {
+        userName: 'John Doe',
+        accountId: 'ACC_12345',
+        verificationLink: 'https://example.com/verify/token123',
+      },
+    });
+
+    console.log('Gmail template email sent:', result);
+  }
+
+  /**
+   * Example 8: Send SendGrid email with attachments
+   */
+  async sendSendGridWithAttachments() {
+    // First create SendGrid config
+    const sendGridConfig = {
+      apiKey: 'your-sendgrid-api-key',
+      fromEmail: 'noreply@yourdomain.com',
+      fromName: 'Your Company',
+    };
+
+    await this.communicationService.createIntegrationConfig(
+      1,
+      'organization',
+      'MY_APP_001',
+      'EMAIL',
+      'sendgrid',
+      5,
+      sendGridConfig,
+    );
+
+    const result = await this.communicationService.sendGenericMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      subject: 'Invoice and Receipt',
+      message: 'Please find your invoice and receipt attached.',
+      type: 'EMAIL',
+      attachments: [
+        {
+          filename: 'invoice.pdf',
+          content: 'base64-encoded-invoice-content',
+          contentType: 'application/pdf',
+          disposition: 'attachment',
+        },
+        {
+          filename: 'receipt.pdf',
+          content: 'base64-encoded-receipt-content',
+          contentType: 'application/pdf',
+          disposition: 'attachment',
+        },
+      ],
+    });
+
+    console.log('SendGrid with attachments sent:', result);
+  }
+
+  /**
+   * Example 9: Send SendGrid email using dynamic template
+   */
+  async sendSendGridWithDynamicTemplate() {
+    const result = await this.communicationService.sendGenericMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: 'recipient@example.com',
+      message: '', // Required field, can be empty for template emails
+      type: 'EMAIL',
+      templateId: 'd-1234567890abcdef1234567890abcdef', // SendGrid template ID
+      variables: {
+        firstName: 'John',
+        lastName: 'Doe',
+        companyName: 'Acme Corp',
+        orderNumber: 'ORD-2024-001',
+        orderDate: '2024-01-15',
+        items: [
+          { name: 'Product A', quantity: 2, price: '$29.99' },
+          { name: 'Product B', quantity: 1, price: '$49.99' },
+        ],
+        totalAmount: '$109.97',
+      },
+    });
+
+    console.log('SendGrid dynamic template email sent:', result);
+  }
+
+  /**
+   * Example 10: Send SendGrid email with custom headers and categories
+   */
+  async sendSendGridWithCustomOptions() {
+    const result = await this.communicationService.sendGenericMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      to: ['recipient1@example.com', 'recipient2@example.com'],
+      cc: ['manager@example.com'],
+      bcc: ['archive@example.com'],
+      subject: 'Monthly Newsletter',
+      message: 'Our Monthly Newsletter',
+      html: '<h1>Our Monthly Newsletter</h1><p>Latest updates from our team...</p>',
+      type: 'EMAIL',
+    });
+
+    console.log('SendGrid custom email sent:', result);
+  }
+
+  /**
+   * Example 11: Send message without specifying mode (uses first available)
+   */
+  async sendMessageAutoMode() {
+    const result = await this.communicationService.sendMessage({
+      levelId: 1,
+      levelType: 'organization',
+      app_code: 'MY_APP_001',
+      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 → integration}/factories/base.factory.ts

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

package/src/module/{communication → integration}/factories/email.factory.ts

@@ -1,10 +1,8 @@
 import { Injectable } from '@nestjs/common';
 import { BaseFactory } from './base.factory';
-import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
 import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
 import { OutlookStrategy } from '../strategies/email/outlook.strategy';
-import { GmailSMTPStrategy } from '../strategies/email/gmail-smtp-v2.strategy';
-import { OutlookSMTPStrategy } from '../strategies/email/outlook-smtp.strategy';
 import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
 
 @Injectable()
@@ -12,12 +10,10 @@ export class EmailFactory implements BaseFactory {
   constructor(
     private gmailApiStrategy: GmailApiStrategy,
     private outlookStrategy: OutlookStrategy,
-    private gmailSMTPStrategy: GmailSMTPStrategy,
-    private outlookSMTPStrategy: OutlookSMTPStrategy,
     private sendGridApiStrategy: SendGridApiStrategy,
   ) {}
 
-  createProvider(service: string, provider: string): CommunicationStrategy {
+  createProvider(service: string, provider: string): IntegrationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
 
     switch (key) {
@@ -27,10 +23,6 @@ export class EmailFactory implements BaseFactory {
         return this.outlookStrategy;
       case 'api_sendgrid':
         return this.sendGridApiStrategy;
-      case 'smtp_gmail':
-        return this.gmailSMTPStrategy;
-      case 'smtp_outlook':
-        return this.outlookSMTPStrategy;
 
       default:
         throw new Error(
@@ -44,8 +36,6 @@ export class EmailFactory implements BaseFactory {
       { service: 'API', provider: 'gmail' },
       { service: 'API', provider: 'outlook' },
       { service: 'API', provider: 'sendgrid' },
-      { service: 'SMTP', provider: 'gmail' },
-      { service: 'SMTP', provider: 'outlook' },
     ];
   }
 

package/src/module/{communication/factories/communication.factory.ts → integration/factories/integration.factory.ts}

@@ -1,11 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
 import { EmailFactory } from './email.factory';
 import { SmsFactory } from './sms.factory';
 import { WhatsAppFactory } from './whatsapp.factory';
 import { TelephoneFactory } from './telephone.factory';
 
-export enum CommunicationMode {
+export enum IntegrationMode {
   EMAIL = 'EMAIL',
   SMS = 'SMS',
   WA = 'WA',
@@ -13,8 +13,8 @@ export enum CommunicationMode {
 }
 
 @Injectable()
-export class CommunicationFactory {
-  private readonly modeFactoryMap = new Map<CommunicationMode, any>();
+export class IntegrationFactory {
+  private readonly modeFactoryMap = new Map<IntegrationMode, any>();
 
   constructor(
     private emailFactory: EmailFactory,
@@ -26,24 +26,24 @@ export class CommunicationFactory {
   }
 
   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);
+    this.modeFactoryMap.set(IntegrationMode.EMAIL, this.emailFactory);
+    this.modeFactoryMap.set(IntegrationMode.SMS, this.smsFactory);
+    this.modeFactoryMap.set(IntegrationMode.WA, this.whatsappFactory);
+    this.modeFactoryMap.set(IntegrationMode.TELEPHONE, this.telephoneFactory);
   }
 
   create(
     mode: string,
     service: string,
     provider: string,
-  ): CommunicationStrategy {
-    const communicationMode = mode.toUpperCase() as CommunicationMode;
+  ): IntegrationStrategy {
+    const integrationMode = mode.toUpperCase() as IntegrationMode;
 
-    if (!Object.values(CommunicationMode).includes(communicationMode)) {
-      throw new Error(`Unsupported communication mode: ${mode}`);
+    if (!Object.values(IntegrationMode).includes(integrationMode)) {
+      throw new Error(`Unsupported integration mode: ${mode}`);
     }
 
-    const factory = this.modeFactoryMap.get(communicationMode);
+    const factory = this.modeFactoryMap.get(integrationMode);
     if (!factory) {
       throw new Error(`Factory not found for mode: ${mode}`);
     }
@@ -79,8 +79,8 @@ export class CommunicationFactory {
   getSupportedCombinationsForMode(
     mode: string,
   ): Array<{ service: string; provider: string }> {
-    const communicationMode = mode.toUpperCase() as CommunicationMode;
-    const factory = this.modeFactoryMap.get(communicationMode);
+    const integrationMode = mode.toUpperCase() as IntegrationMode;
+    const factory = this.modeFactoryMap.get(integrationMode);
 
     if (!factory) {
       throw new Error(`Factory not found for mode: ${mode}`);
@@ -95,8 +95,8 @@ export class CommunicationFactory {
     provider: string,
   ): boolean {
     try {
-      const communicationMode = mode.toUpperCase() as CommunicationMode;
-      const factory = this.modeFactoryMap.get(communicationMode);
+      const integrationMode = mode.toUpperCase() as IntegrationMode;
+      const factory = this.modeFactoryMap.get(integrationMode);
 
       if (!factory) {
         return false;
@@ -109,7 +109,7 @@ export class CommunicationFactory {
   }
 
   getAvailableModes(): string[] {
-    return Object.values(CommunicationMode);
+    return Object.values(IntegrationMode);
   }
 
   getProvidersByModeAndService(mode: string, service: string): string[] {

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

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
+
+@Injectable()
+export class SmsFactory {
+  createProvider(service: string, provider: string): IntegrationStrategy {
+    throw new Error(`SMS integration is not supported. Provider: ${provider}, Service: ${service}`);
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    // Return empty array since no SMS strategies are supported
+    return [];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    // No SMS combinations are valid since we removed all strategies
+    return false;
+  }
+}

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

@@ -0,0 +1,41 @@
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
+import { OzonetelVoiceStrategy } from '../strategies/telephone/ozonetel-voice.strategy';
+import { TubelightVoiceStrategy } from '../strategies/telephone/tubelight-voice.strategy';
+
+@Injectable()
+export class TelephoneFactory implements BaseFactory {
+  constructor(
+    private ozonetelVoiceStrategy: OzonetelVoiceStrategy,
+    private tubelightVoiceStrategy: TubelightVoiceStrategy,
+  ) {}
+
+  createProvider(service: string, provider: string): IntegrationStrategy {
+    const providerKey = provider.toLowerCase();
+
+    switch (providerKey) {
+      case 'ozonetel':
+        return this.ozonetelVoiceStrategy;
+      case 'tubelight':
+        return this.tubelightVoiceStrategy;
+
+      default:
+        throw new Error(
+          `Unsupported Telephone provider: ${provider}`,
+        );
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    return [
+      { service: 'API', provider: 'ozonetel' },
+      { service: 'API', provider: 'tubelight' }
+    ];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    const supportedProviders = ['ozonetel', 'tubelight'];
+    return supportedProviders.includes(provider.toLowerCase());
+  }
+}

package/src/module/{communication → integration}/factories/whatsapp.factory.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { BaseFactory } from './base.factory';
-import { CommunicationStrategy } from '../strategies/communication.strategy';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
 import { WhatsAppStrategy } from '../strategies/whatsapp/whatsapp.strategy';
 import { WhatsAppCloudStrategy } from '../strategies/whatsapp/whatsapp-cloud.strategy';
 
@@ -11,7 +11,7 @@ export class WhatsAppFactory implements BaseFactory {
     private whatsappCloudStrategy: WhatsAppCloudStrategy,
   ) {}
 
-  createProvider(service: string, provider: string): CommunicationStrategy {
+  createProvider(service: string, provider: string): IntegrationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
 
     switch (key) {