Merge branch 'ev2' into v2.0.0

src/api/integrations/event/event.controller.ts

@@ -3,6 +3,25 @@ import { rabbitmqController, sqsController, webhookController, websocketControll
 import { WAMonitoringService } from '@api/services/monitor.service';
 import { Server } from 'http';
 
+export type EmitData = {
+  instanceName: string;
+  origin: string;
+  event: string;
+  data: Object;
+  serverUrl: string;
+  dateTime: string;
+  sender: string;
+  apiKey?: string;
+  local?: boolean;
+};
+
+export interface EventControllerInterface {
+  integrationEnabled: boolean;
+  set(instanceName: string, data: any): Promise<any>;
+  get(instanceName: string): Promise<any>;
+  emit({ instanceName, origin, event, data, serverUrl, dateTime, sender, apiKey, local }: EmitData): Promise<void>;
+}
+
 export class EventController {
   public prismaRepository: PrismaRepository;
   public waMonitor: WAMonitoringService;

src/api/integrations/event/rabbitmq/controllers/rabbitmq.controller.ts

@@ -7,19 +7,19 @@ import { Logger } from '@config/logger.config';
 import { NotFoundException } from '@exceptions';
 import * as amqp from 'amqplib/callback_api';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class RabbitmqController extends EventController {
+export class RabbitmqController extends EventController implements EventControllerInterface {
   public amqpChannel: amqp.Channel | null = null;
   private readonly logger = new Logger(RabbitmqController.name);
+  integrationEnabled = configService.get<Rabbitmq>('RABBITMQ')?.ENABLED;
+
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
 
   public async init(): Promise<void> {
-    if (!configService.get<Rabbitmq>('RABBITMQ')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     await new Promise<void>((resolve, reject) => {
       const uri = configService.get<Rabbitmq>('RABBITMQ').URI;
@@ -62,6 +62,8 @@ export class RabbitmqController extends EventController {
   }
 
   public async set(instanceName: string, data: RabbitmqDto): Promise<wa.LocalRabbitmq> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -91,6 +93,8 @@ export class RabbitmqController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -117,19 +121,8 @@ export class RabbitmqController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Rabbitmq>('RABBITMQ')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const instanceRabbitmq = await this.get(instanceName);
     const rabbitmqLocal = instanceRabbitmq?.events;

src/api/integrations/event/sqs/controllers/sqs.controller.ts

@@ -7,20 +7,19 @@ import { configService, Log, Sqs } from '@config/env.config';
 import { Logger } from '@config/logger.config';
 import { NotFoundException } from '@exceptions';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class SqsController extends EventController {
+export class SqsController extends EventController implements EventControllerInterface {
   private sqs: SQS;
   private readonly logger = new Logger(SqsController.name);
+  integrationEnabled = configService.get<Sqs>('SQS')?.ENABLED;
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
 
   public init(): void {
-    if (!configService.get<Sqs>('SQS')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     new Promise<void>((resolve, reject) => {
@@ -48,6 +47,8 @@ export class SqsController extends EventController {
   }
 
   public async set(instanceName: string, data: SqsDto): Promise<wa.LocalSqs> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -77,6 +78,8 @@ export class SqsController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalSqs> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -103,19 +106,8 @@ export class SqsController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Sqs>('SQS')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const instanceSqs = await this.get(instanceName);
     const sqsLocal = instanceSqs?.events;

src/api/integrations/event/webhook/controllers/webhook.controller.ts

@@ -1,21 +1,22 @@
 import { PrismaRepository } from '@api/repository/repository.service';
 import { WAMonitoringService } from '@api/services/monitor.service';
 import { wa } from '@api/types/wa.types';
-import { configService, Log, Webhook, Websocket } from '@config/env.config';
+import { configService, Log, Webhook } from '@config/env.config';
 import { Logger } from '@config/logger.config';
 import { BadRequestException, NotFoundException } from '@exceptions';
 import axios from 'axios';
 import { isURL } from 'class-validator';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 import { WebhookDto } from '../dto/webhook.dto';
 
-export class WebhookController extends EventController {
+export class WebhookController extends EventController implements EventControllerInterface {
   private readonly logger = new Logger(WebhookController.name);
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
+  integrationEnabled: boolean;
 
   public async set(instanceName: string, data: WebhookDto): Promise<wa.LocalWebHook> {
     if (!isURL(data.url, { require_tld: false })) {
@@ -31,7 +32,7 @@ export class WebhookController extends EventController {
     }
 
     await this.get(instanceName);
-    
+
     return this.prisma.webhook.upsert({
       where: {
         instanceId: this.monitor.waInstances[instanceName].instanceId,
@@ -78,23 +79,13 @@ export class WebhookController extends EventController {
     sender,
     apiKey,
     local,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-    local?: boolean;
-  }): Promise<void> {
-    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
+  }: EmitData): Promise<void> {
+    const instanceWebhook = await this.get(instanceName);
+    if (!instanceWebhook || !instanceWebhook.enabled) {
       return;
     }
 
-    const instanceWebhook = await this.get(instanceName);
-    const webhookGlobal = configService.get<Webhook>('WEBHOOK');
+    const webhookConfig = configService.get<Webhook>('WEBHOOK');
     const webhookLocal = instanceWebhook?.events;
     const we = event.replace(/[.-]/gm, '_').toUpperCase();
     const transformedWe = we.replace(/_/gm, '-').toLowerCase();
@@ -110,6 +101,7 @@ export class WebhookController extends EventController {
       server_url: serverUrl,
       apikey: apiKey,
     };
+
     if (local) {
       if (Array.isArray(webhookLocal) && webhookLocal.includes(we)) {
         let baseURL: string;
@@ -153,16 +145,12 @@ export class WebhookController extends EventController {
       }
     }
 
-    if (webhookGlobal.GLOBAL?.ENABLED) {
-      if (webhookGlobal.EVENTS[we]) {
-        const globalWebhook = configService.get<Webhook>('WEBHOOK').GLOBAL;
+    if (webhookConfig.GLOBAL?.ENABLED) {
+      if (webhookConfig.EVENTS[we]) {
+        let globalURL = webhookConfig.GLOBAL.URL;
 
-        let globalURL;
-
-        if (webhookGlobal.GLOBAL.WEBHOOK_BY_EVENTS) {
-          globalURL = `${globalWebhook.URL}/${transformedWe}`;
-        } else {
-          globalURL = globalWebhook.URL;
+        if (webhookConfig.GLOBAL.WEBHOOK_BY_EVENTS) {
+          globalURL = `${globalURL}/${transformedWe}`;
         }
 
         if (enabledLog) {
@@ -176,7 +164,7 @@ export class WebhookController extends EventController {
         }
 
         try {
-          if (globalWebhook && globalWebhook?.ENABLED && isURL(globalURL)) {
+          if (isURL(globalURL)) {
             const httpService = axios.create({ baseURL: globalURL });
 
             await httpService.post('', webhookData);

src/api/integrations/event/webhook/routes/webhook.router.ts

@@ -1,7 +1,7 @@
 import { RouterBroker } from '@api/abstract/abstract.router';
 import { InstanceDto } from '@api/dto/instance.dto';
-import { webhookController } from '@api/server.module';
 import { HttpStatus } from '@api/routes/index.router';
+import { webhookController } from '@api/server.module';
 import { ConfigService, WaBusiness } from '@config/env.config';
 import { instanceSchema, webhookSchema } from '@validate/validate.schema';
 import { RequestHandler, Router } from 'express';

src/api/integrations/event/websocket/controllers/websocket.controller.ts

@@ -8,12 +8,13 @@ import { NotFoundException } from '@exceptions';
 import { Server } from 'http';
 import { Server as SocketIO } from 'socket.io';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class WebsocketController extends EventController {
+export class WebsocketController extends EventController implements EventControllerInterface {
   private io: SocketIO;
   private corsConfig: Array<any>;
   private readonly logger = new Logger(WebsocketController.name);
+  integrationEnabled = configService.get<Websocket>('WEBSOCKET')?.ENABLED;
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
@@ -21,9 +22,7 @@ export class WebsocketController extends EventController {
   }
 
   public init(httpServer: Server): void {
-    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     this.socket = new SocketIO(httpServer, {
       cors: {
@@ -59,6 +58,8 @@ export class WebsocketController extends EventController {
   }
 
   public async set(instanceName: string, data: WebsocketDto): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -88,6 +89,8 @@ export class WebsocketController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -114,19 +117,8 @@ export class WebsocketController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const configEv = event.replace(/[.-]/gm, '_').toUpperCase();
     const logEnabled = configService.get<Log>('LOG').LEVEL.includes('WEBSOCKET');