rez_core 4.0.98 → 4.0.99

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

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

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

@@ -1,49 +1,49 @@
-import { Injectable } from '@nestjs/common';
-import { BaseFactory } from './base.factory';
-import { IntegrationStrategy } from '../strategies/integration.strategy';
-import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
-import { OutlookStrategy } from '../strategies/email/outlook.strategy';
-import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
-
-@Injectable()
-export class EmailFactory implements BaseFactory {
-  constructor(
-    private gmailApiStrategy: GmailApiStrategy,
-    private outlookStrategy: OutlookStrategy,
-    private sendGridApiStrategy: SendGridApiStrategy,
-  ) {}
-
-  createProvider(service: string, provider: string): IntegrationStrategy {
-    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-
-    switch (key) {
-      case 'api_gmail':
-        return this.gmailApiStrategy;
-      case 'api_outlook':
-        return this.outlookStrategy;
-      case 'api_sendgrid':
-        return this.sendGridApiStrategy;
-
-      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: 'API', provider: 'sendgrid' },
-    ];
-  }
-
-  validateCombination(service: string, provider: string): boolean {
-    return this.getSupportedCombinations().some(
-      (combo) =>
-        combo.service.toLowerCase() === service.toLowerCase() &&
-        combo.provider.toLowerCase() === provider.toLowerCase(),
-    );
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
+import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
+import { OutlookStrategy } from '../strategies/email/outlook.strategy';
+import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
+
+@Injectable()
+export class EmailFactory implements BaseFactory {
+  constructor(
+    private gmailApiStrategy: GmailApiStrategy,
+    private outlookStrategy: OutlookStrategy,
+    private sendGridApiStrategy: SendGridApiStrategy,
+  ) {}
+
+  createProvider(service: string, provider: string): IntegrationStrategy {
+    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'api_gmail':
+        return this.gmailApiStrategy;
+      case 'api_outlook':
+        return this.outlookStrategy;
+      case 'api_sendgrid':
+        return this.sendGridApiStrategy;
+
+      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: 'API', provider: 'sendgrid' },
+    ];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    return this.getSupportedCombinations().some(
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
+    );
+  }
+}

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

@@ -1,121 +1,121 @@
-import { Injectable } from '@nestjs/common';
-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 IntegrationMode {
-  EMAIL = 'EMAIL',
-  SMS = 'SMS',
-  WA = 'WA',
-  TELEPHONE = 'TELEPHONE',
-}
-
-@Injectable()
-export class IntegrationFactory {
-  private readonly modeFactoryMap = new Map<IntegrationMode, any>();
-
-  constructor(
-    private emailFactory: EmailFactory,
-    private smsFactory: SmsFactory,
-    private whatsappFactory: WhatsAppFactory,
-    private telephoneFactory: TelephoneFactory,
-  ) {
-    this.initializeFactoryMap();
-  }
-
-  private initializeFactoryMap(): void {
-    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,
-  ): IntegrationStrategy {
-    const integrationMode = mode.toUpperCase() as IntegrationMode;
-
-    if (!Object.values(IntegrationMode).includes(integrationMode)) {
-      throw new Error(`Unsupported integration mode: ${mode}`);
-    }
-
-    const factory = this.modeFactoryMap.get(integrationMode);
-    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 integrationMode = mode.toUpperCase() as IntegrationMode;
-    const factory = this.modeFactoryMap.get(integrationMode);
-
-    if (!factory) {
-      throw new Error(`Factory not found for mode: ${mode}`);
-    }
-
-    return factory.getSupportedCombinations();
-  }
-
-  validateCombination(
-    mode: string,
-    service: string,
-    provider: string,
-  ): boolean {
-    try {
-      const integrationMode = mode.toUpperCase() as IntegrationMode;
-      const factory = this.modeFactoryMap.get(integrationMode);
-
-      if (!factory) {
-        return false;
-      }
-
-      return factory.validateCombination(service, provider);
-    } catch {
-      return false;
-    }
-  }
-
-  getAvailableModes(): string[] {
-    return Object.values(IntegrationMode);
-  }
-
-  getProvidersByModeAndService(mode: string, service: string): string[] {
-    const combinations = this.getSupportedCombinationsForMode(mode);
-    return combinations
-      .filter((combo) => combo.service.toLowerCase() === service.toLowerCase())
-      .map((combo) => combo.provider);
-  }
-}
+import { Injectable } from '@nestjs/common';
+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 IntegrationMode {
+  EMAIL = 'EMAIL',
+  SMS = 'SMS',
+  WA = 'WA',
+  TELEPHONE = 'TELEPHONE',
+}
+
+@Injectable()
+export class IntegrationFactory {
+  private readonly modeFactoryMap = new Map<IntegrationMode, any>();
+
+  constructor(
+    private emailFactory: EmailFactory,
+    private smsFactory: SmsFactory,
+    private whatsappFactory: WhatsAppFactory,
+    private telephoneFactory: TelephoneFactory,
+  ) {
+    this.initializeFactoryMap();
+  }
+
+  private initializeFactoryMap(): void {
+    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,
+  ): IntegrationStrategy {
+    const integrationMode = mode.toUpperCase() as IntegrationMode;
+
+    if (!Object.values(IntegrationMode).includes(integrationMode)) {
+      throw new Error(`Unsupported integration mode: ${mode}`);
+    }
+
+    const factory = this.modeFactoryMap.get(integrationMode);
+    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 integrationMode = mode.toUpperCase() as IntegrationMode;
+    const factory = this.modeFactoryMap.get(integrationMode);
+
+    if (!factory) {
+      throw new Error(`Factory not found for mode: ${mode}`);
+    }
+
+    return factory.getSupportedCombinations();
+  }
+
+  validateCombination(
+    mode: string,
+    service: string,
+    provider: string,
+  ): boolean {
+    try {
+      const integrationMode = mode.toUpperCase() as IntegrationMode;
+      const factory = this.modeFactoryMap.get(integrationMode);
+
+      if (!factory) {
+        return false;
+      }
+
+      return factory.validateCombination(service, provider);
+    } catch {
+      return false;
+    }
+  }
+
+  getAvailableModes(): string[] {
+    return Object.values(IntegrationMode);
+  }
+
+  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/integration/factories/sms.factory.ts

@@ -1,52 +1,52 @@
-import { Injectable } from '@nestjs/common';
-import { BaseFactory } from './base.factory';
-import { IntegrationStrategy } from '../strategies/integration.strategy';
-import { GupshupSmsStrategy } from '../strategies/sms/gupshup-sms.strategy';
-import { TubelightSmsStrategy } from '../strategies/sms/tubelight-sms.strategy';
-import { Msg91SmsStrategy } from '../strategies/sms/msg91-sms.strategy';
-
-@Injectable()
-export class SmsFactory implements BaseFactory {
-  constructor(
-    private gupshupSmsStrategy: GupshupSmsStrategy,
-    private tubelightSmsStrategy: TubelightSmsStrategy,
-    private msg91SmsStrategy: Msg91SmsStrategy,
-  ) {}
-
-  createProvider(service: string, provider: string): IntegrationStrategy {
-    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-
-    switch (key) {
-      case 'api_gupshup':
-      case 'sms_gupshup':
-        return this.gupshupSmsStrategy;
-      case 'api_tubelight':
-      case 'sms_tubelight':
-        return this.tubelightSmsStrategy;
-      case 'api_msg91':
-      case 'sms_msg91':
-        return this.msg91SmsStrategy;
-
-      default:
-        throw new Error(
-          `Unsupported SMS service/provider: ${service}/${provider}`,
-        );
-    }
-  }
-
-  getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    return [
-      { service: 'API', provider: 'gupshup' },
-      { service: 'API', provider: 'tubelight' },
-      { service: 'API', provider: 'msg91' },
-    ];
-  }
-
-  validateCombination(service: string, provider: string): boolean {
-    return this.getSupportedCombinations().some(
-      (combo) =>
-        combo.service.toLowerCase() === service.toLowerCase() &&
-        combo.provider.toLowerCase() === provider.toLowerCase(),
-    );
-  }
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
+import { GupshupSmsStrategy } from '../strategies/sms/gupshup-sms.strategy';
+import { TubelightSmsStrategy } from '../strategies/sms/tubelight-sms.strategy';
+import { Msg91SmsStrategy } from '../strategies/sms/msg91-sms.strategy';
+
+@Injectable()
+export class SmsFactory implements BaseFactory {
+  constructor(
+    private gupshupSmsStrategy: GupshupSmsStrategy,
+    private tubelightSmsStrategy: TubelightSmsStrategy,
+    private msg91SmsStrategy: Msg91SmsStrategy,
+  ) {}
+
+  createProvider(service: string, provider: string): IntegrationStrategy {
+    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'api_gupshup':
+      case 'sms_gupshup':
+        return this.gupshupSmsStrategy;
+      case 'api_tubelight':
+      case 'sms_tubelight':
+        return this.tubelightSmsStrategy;
+      case 'api_msg91':
+      case 'sms_msg91':
+        return this.msg91SmsStrategy;
+
+      default:
+        throw new Error(
+          `Unsupported SMS service/provider: ${service}/${provider}`,
+        );
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    return [
+      { service: 'API', provider: 'gupshup' },
+      { service: 'API', provider: 'tubelight' },
+      { service: 'API', provider: 'msg91' },
+    ];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    return this.getSupportedCombinations().some(
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
+    );
+  }
 }

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

@@ -1,41 +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());
-  }
-}
+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/integration/factories/whatsapp.factory.ts

@@ -1,56 +1,56 @@
-import { Injectable } from '@nestjs/common';
-import { BaseFactory } from './base.factory';
-import { IntegrationStrategy } from '../strategies/integration.strategy';
-import { WhatsAppStrategy } from '../strategies/whatsapp/whatsapp.strategy';
-import { WhatsAppCloudStrategy } from '../strategies/whatsapp/whatsapp-cloud.strategy';
-import { GupshupWhatsAppStrategy } from '../strategies/whatsapp/gupshup-whatsapp.strategy';
-import { TubelightWhatsAppStrategy } from '../strategies/whatsapp/tubelight-whatsapp.strategy';
-
-@Injectable()
-export class WhatsAppFactory implements BaseFactory {
-  constructor(
-    private whatsappStrategy: WhatsAppStrategy,
-    private whatsappCloudStrategy: WhatsAppCloudStrategy,
-    private gupshupWhatsAppStrategy: GupshupWhatsAppStrategy,
-    private tubelightWhatsAppStrategy: TubelightWhatsAppStrategy,
-  ) {}
-
-  createProvider(service: string, provider: string): IntegrationStrategy {
-    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
-
-    switch (key) {
-      case 'api_whatsapp':
-        return this.whatsappStrategy;
-      case 'api_whatsapp-cloud':
-      case 'api_meta':
-        return this.whatsappCloudStrategy;
-      case 'api_gupshup':
-        return this.gupshupWhatsAppStrategy;
-      case 'api_tubelight':
-        return this.tubelightWhatsAppStrategy;
-
-      default:
-        throw new Error(
-          `Unsupported WhatsApp service/provider: ${service}/${provider}`,
-        );
-    }
-  }
-
-  getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    return [
-      { service: 'API', provider: 'whatsapp' },
-      { service: 'API', provider: 'whatsapp-cloud' },
-      { service: 'API', provider: 'meta' },
-      { service: 'API', provider: 'gupshup' },
-      { service: 'API', provider: 'tubelight' },
-    ];
-  }
-
-  validateCombination(service: string, provider: string): boolean {
-    return this.getSupportedCombinations().some(
-      (combo) =>
-        combo.service.toLowerCase() === service.toLowerCase() &&
-        combo.provider.toLowerCase() === provider.toLowerCase(),
-    );
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
+import { IntegrationStrategy } from '../strategies/integration.strategy';
+import { WhatsAppStrategy } from '../strategies/whatsapp/whatsapp.strategy';
+import { WhatsAppCloudStrategy } from '../strategies/whatsapp/whatsapp-cloud.strategy';
+import { GupshupWhatsAppStrategy } from '../strategies/whatsapp/gupshup-whatsapp.strategy';
+import { TubelightWhatsAppStrategy } from '../strategies/whatsapp/tubelight-whatsapp.strategy';
+
+@Injectable()
+export class WhatsAppFactory implements BaseFactory {
+  constructor(
+    private whatsappStrategy: WhatsAppStrategy,
+    private whatsappCloudStrategy: WhatsAppCloudStrategy,
+    private gupshupWhatsAppStrategy: GupshupWhatsAppStrategy,
+    private tubelightWhatsAppStrategy: TubelightWhatsAppStrategy,
+  ) {}
+
+  createProvider(service: string, provider: string): IntegrationStrategy {
+    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'api_whatsapp':
+        return this.whatsappStrategy;
+      case 'api_whatsapp-cloud':
+      case 'api_meta':
+        return this.whatsappCloudStrategy;
+      case 'api_gupshup':
+        return this.gupshupWhatsAppStrategy;
+      case 'api_tubelight':
+        return this.tubelightWhatsAppStrategy;
+
+      default:
+        throw new Error(
+          `Unsupported WhatsApp service/provider: ${service}/${provider}`,
+        );
+    }
+  }
+
+  getSupportedCombinations(): Array<{ service: string; provider: string }> {
+    return [
+      { service: 'API', provider: 'whatsapp' },
+      { service: 'API', provider: 'whatsapp-cloud' },
+      { service: 'API', provider: 'meta' },
+      { service: 'API', provider: 'gupshup' },
+      { service: 'API', provider: 'tubelight' },
+    ];
+  }
+
+  validateCombination(service: string, provider: string): boolean {
+    return this.getSupportedCombinations().some(
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
+    );
+  }
+}