fix: reorganization of files and folders

src/api/controllers/chamaai.controller.ts

@@ -0,0 +1,29 @@
+import { Logger } from '../../config/logger.config';
+import { ChamaaiDto } from '../dto/chamaai.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { ChamaaiService } from '../services/chamaai.service';
+
+const logger = new Logger('ChamaaiController');
+
+export class ChamaaiController {
+  constructor(private readonly chamaaiService: ChamaaiService) {}
+
+  public async createChamaai(instance: InstanceDto, data: ChamaaiDto) {
+    logger.verbose('requested createChamaai from ' + instance.instanceName + ' instance');
+
+    if (!data.enabled) {
+      logger.verbose('chamaai disabled');
+      data.url = '';
+      data.token = '';
+      data.waNumber = '';
+      data.answerByAudio = false;
+    }
+
+    return this.chamaaiService.create(instance, data);
+  }
+
+  public async findChamaai(instance: InstanceDto) {
+    logger.verbose('requested findChamaai from ' + instance.instanceName + ' instance');
+    return this.chamaaiService.find(instance);
+  }
+}

src/api/controllers/chat.controller.ts

@@ -0,0 +1,132 @@
+import { Logger } from '../../config/logger.config';
+import {
+  ArchiveChatDto,
+  BlockUserDto,
+  DeleteMessage,
+  getBase64FromMediaMessageDto,
+  NumberDto,
+  PrivacySettingDto,
+  ProfileNameDto,
+  ProfilePictureDto,
+  ProfileStatusDto,
+  ReadMessageDto,
+  SendPresenceDto,
+  UpdateMessageDto,
+  WhatsAppNumberDto,
+} from '../dto/chat.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { ContactQuery } from '../repository/contact.repository';
+import { MessageQuery } from '../repository/message.repository';
+import { MessageUpQuery } from '../repository/messageUp.repository';
+import { WAMonitoringService } from '../services/monitor.service';
+
+const logger = new Logger('ChatController');
+
+export class ChatController {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  public async whatsappNumber({ instanceName }: InstanceDto, data: WhatsAppNumberDto) {
+    logger.verbose('requested whatsappNumber from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].whatsappNumber(data);
+  }
+
+  public async readMessage({ instanceName }: InstanceDto, data: ReadMessageDto) {
+    logger.verbose('requested readMessage from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].markMessageAsRead(data);
+  }
+
+  public async archiveChat({ instanceName }: InstanceDto, data: ArchiveChatDto) {
+    logger.verbose('requested archiveChat from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].archiveChat(data);
+  }
+
+  public async deleteMessage({ instanceName }: InstanceDto, data: DeleteMessage) {
+    logger.verbose('requested deleteMessage from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].deleteMessage(data);
+  }
+
+  public async fetchProfilePicture({ instanceName }: InstanceDto, data: NumberDto) {
+    logger.verbose('requested fetchProfilePicture from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].profilePicture(data.number);
+  }
+
+  public async fetchProfile({ instanceName }: InstanceDto, data: NumberDto) {
+    logger.verbose('requested fetchProfile from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchProfile(instanceName, data.number);
+  }
+
+  public async fetchContacts({ instanceName }: InstanceDto, query: ContactQuery) {
+    logger.verbose('requested fetchContacts from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchContacts(query);
+  }
+
+  public async getBase64FromMediaMessage({ instanceName }: InstanceDto, data: getBase64FromMediaMessageDto) {
+    logger.verbose('requested getBase64FromMediaMessage from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].getBase64FromMediaMessage(data);
+  }
+
+  public async fetchMessages({ instanceName }: InstanceDto, query: MessageQuery) {
+    logger.verbose('requested fetchMessages from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchMessages(query);
+  }
+
+  public async fetchStatusMessage({ instanceName }: InstanceDto, query: MessageUpQuery) {
+    logger.verbose('requested fetchStatusMessage from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchStatusMessage(query);
+  }
+
+  public async fetchChats({ instanceName }: InstanceDto) {
+    logger.verbose('requested fetchChats from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchChats();
+  }
+
+  public async sendPresence({ instanceName }: InstanceDto, data: SendPresenceDto) {
+    logger.verbose('requested sendPresence from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].sendPresence(data);
+  }
+
+  public async fetchPrivacySettings({ instanceName }: InstanceDto) {
+    logger.verbose('requested fetchPrivacySettings from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchPrivacySettings();
+  }
+
+  public async updatePrivacySettings({ instanceName }: InstanceDto, data: PrivacySettingDto) {
+    logger.verbose('requested updatePrivacySettings from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].updatePrivacySettings(data);
+  }
+
+  public async fetchBusinessProfile({ instanceName }: InstanceDto, data: ProfilePictureDto) {
+    logger.verbose('requested fetchBusinessProfile from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchBusinessProfile(data.number);
+  }
+
+  public async updateProfileName({ instanceName }: InstanceDto, data: ProfileNameDto) {
+    logger.verbose('requested updateProfileName from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].updateProfileName(data.name);
+  }
+
+  public async updateProfileStatus({ instanceName }: InstanceDto, data: ProfileStatusDto) {
+    logger.verbose('requested updateProfileStatus from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].updateProfileStatus(data.status);
+  }
+
+  public async updateProfilePicture({ instanceName }: InstanceDto, data: ProfilePictureDto) {
+    logger.verbose('requested updateProfilePicture from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].updateProfilePicture(data.picture);
+  }
+
+  public async removeProfilePicture({ instanceName }: InstanceDto) {
+    logger.verbose('requested removeProfilePicture from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].removeProfilePicture();
+  }
+
+  public async updateMessage({ instanceName }: InstanceDto, data: UpdateMessageDto) {
+    logger.verbose('requested updateMessage from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].updateMessage(data);
+  }
+
+  public async blockUser({ instanceName }: InstanceDto, data: BlockUserDto) {
+    logger.verbose('requested blockUser from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].blockUser(data);
+  }
+}

src/api/controllers/group.controller.ts

@@ -0,0 +1,103 @@
+import { Logger } from '../../config/logger.config';
+import {
+  AcceptGroupInvite,
+  CreateGroupDto,
+  GetParticipant,
+  GroupDescriptionDto,
+  GroupInvite,
+  GroupJid,
+  GroupPictureDto,
+  GroupSendInvite,
+  GroupSubjectDto,
+  GroupToggleEphemeralDto,
+  GroupUpdateParticipantDto,
+  GroupUpdateSettingDto,
+} from '../dto/group.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { WAMonitoringService } from '../services/monitor.service';
+
+const logger = new Logger('ChatController');
+
+export class GroupController {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  public async createGroup(instance: InstanceDto, create: CreateGroupDto) {
+    logger.verbose('requested createGroup from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].createGroup(create);
+  }
+
+  public async updateGroupPicture(instance: InstanceDto, update: GroupPictureDto) {
+    logger.verbose('requested updateGroupPicture from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].updateGroupPicture(update);
+  }
+
+  public async updateGroupSubject(instance: InstanceDto, update: GroupSubjectDto) {
+    logger.verbose('requested updateGroupSubject from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].updateGroupSubject(update);
+  }
+
+  public async updateGroupDescription(instance: InstanceDto, update: GroupDescriptionDto) {
+    logger.verbose('requested updateGroupDescription from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].updateGroupDescription(update);
+  }
+
+  public async findGroupInfo(instance: InstanceDto, groupJid: GroupJid) {
+    logger.verbose('requested findGroupInfo from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].findGroup(groupJid);
+  }
+
+  public async fetchAllGroups(instance: InstanceDto, getPaticipants: GetParticipant) {
+    logger.verbose('requested fetchAllGroups from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].fetchAllGroups(getPaticipants);
+  }
+
+  public async inviteCode(instance: InstanceDto, groupJid: GroupJid) {
+    logger.verbose('requested inviteCode from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].inviteCode(groupJid);
+  }
+
+  public async inviteInfo(instance: InstanceDto, inviteCode: GroupInvite) {
+    logger.verbose('requested inviteInfo from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].inviteInfo(inviteCode);
+  }
+
+  public async sendInvite(instance: InstanceDto, data: GroupSendInvite) {
+    logger.verbose('requested sendInvite from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].sendInvite(data);
+  }
+
+  public async acceptInviteCode(instance: InstanceDto, inviteCode: AcceptGroupInvite) {
+    logger.verbose('requested acceptInviteCode from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].acceptInviteCode(inviteCode);
+  }
+
+  public async revokeInviteCode(instance: InstanceDto, groupJid: GroupJid) {
+    logger.verbose('requested revokeInviteCode from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].revokeInviteCode(groupJid);
+  }
+
+  public async findParticipants(instance: InstanceDto, groupJid: GroupJid) {
+    logger.verbose('requested findParticipants from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].findParticipants(groupJid);
+  }
+
+  public async updateGParticipate(instance: InstanceDto, update: GroupUpdateParticipantDto) {
+    logger.verbose('requested updateGParticipate from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].updateGParticipant(update);
+  }
+
+  public async updateGSetting(instance: InstanceDto, update: GroupUpdateSettingDto) {
+    logger.verbose('requested updateGSetting from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].updateGSetting(update);
+  }
+
+  public async toggleEphemeral(instance: InstanceDto, update: GroupToggleEphemeralDto) {
+    logger.verbose('requested toggleEphemeral from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].toggleEphemeral(update);
+  }
+
+  public async leaveGroup(instance: InstanceDto, groupJid: GroupJid) {
+    logger.verbose('requested leaveGroup from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].leaveGroup(groupJid);
+  }
+}

src/api/controllers/instance.controller.ts

@@ -0,0 +1,751 @@
+import { delay } from '@whiskeysockets/baileys';
+import { isURL } from 'class-validator';
+import EventEmitter2 from 'eventemitter2';
+import { v4 } from 'uuid';
+
+import { ConfigService, HttpServer, WaBusiness } from '../../config/env.config';
+import { Logger } from '../../config/logger.config';
+import { BadRequestException, InternalServerErrorException } from '../../exceptions';
+import { RedisCache } from '../../libs/redis.client';
+import { InstanceDto, SetPresenceDto } from '../dto/instance.dto';
+import { ChatwootService } from '../integrations/chatwoot/services/chatwoot.service';
+import { RabbitmqService } from '../integrations/rabbitmq/services/rabbitmq.service';
+import { SqsService } from '../integrations/sqs/services/sqs.service';
+import { TypebotService } from '../integrations/typebot/services/typebot.service';
+import { WebsocketService } from '../integrations/websocket/services/websocket.service';
+import { RepositoryBroker } from '../repository/repository.manager';
+import { AuthService, OldToken } from '../services/auth.service';
+import { CacheService } from '../services/cache.service';
+import { IntegrationService } from '../services/integration.service';
+import { WAMonitoringService } from '../services/monitor.service';
+import { SettingsService } from '../services/settings.service';
+import { WebhookService } from '../services/webhook.service';
+import { BaileysStartupService } from '../services/whatsapp.baileys.service';
+import { BusinessStartupService } from '../services/whatsapp.business.service';
+import { Events, Integration, wa } from '../types/wa.types';
+import { ProxyController } from './proxy.controller';
+
+export class InstanceController {
+  constructor(
+    private readonly waMonitor: WAMonitoringService,
+    private readonly configService: ConfigService,
+    private readonly repository: RepositoryBroker,
+    private readonly eventEmitter: EventEmitter2,
+    private readonly authService: AuthService,
+    private readonly webhookService: WebhookService,
+    private readonly chatwootService: ChatwootService,
+    private readonly settingsService: SettingsService,
+    private readonly websocketService: WebsocketService,
+    private readonly rabbitmqService: RabbitmqService,
+    private readonly sqsService: SqsService,
+    private readonly typebotService: TypebotService,
+    private readonly integrationService: IntegrationService,
+    private readonly proxyService: ProxyController,
+    private readonly cache: RedisCache,
+    private readonly chatwootCache: CacheService,
+  ) {}
+
+  private readonly logger = new Logger(InstanceController.name);
+
+  public async createInstance({
+    instanceName,
+    webhook,
+    webhook_by_events,
+    webhook_base64,
+    events,
+    qrcode,
+    number,
+    mobile,
+    integration,
+    token,
+    chatwoot_account_id,
+    chatwoot_token,
+    chatwoot_url,
+    chatwoot_sign_msg,
+    chatwoot_reopen_conversation,
+    chatwoot_conversation_pending,
+    chatwoot_import_contacts,
+    chatwoot_import_messages,
+    chatwoot_days_limit_import_messages,
+    reject_call,
+    msg_call,
+    groups_ignore,
+    always_online,
+    read_messages,
+    read_status,
+    sync_full_history,
+    websocket_enabled,
+    websocket_events,
+    rabbitmq_enabled,
+    rabbitmq_events,
+    sqs_enabled,
+    sqs_events,
+    typebot_url,
+    typebot,
+    typebot_expire,
+    typebot_keyword_finish,
+    typebot_delay_message,
+    typebot_unknown_message,
+    typebot_listening_from_me,
+    proxy,
+  }: InstanceDto) {
+    try {
+      this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
+
+      this.logger.verbose('checking duplicate token');
+      await this.authService.checkDuplicateToken(token);
+
+      if (!token && integration === Integration.WHATSAPP_BUSINESS) {
+        throw new BadRequestException('token is required');
+      }
+
+      this.logger.verbose('creating instance');
+      let instance: BaileysStartupService | BusinessStartupService;
+      if (integration === Integration.WHATSAPP_BUSINESS) {
+        instance = new BusinessStartupService(
+          this.configService,
+          this.eventEmitter,
+          this.repository,
+          this.cache,
+          this.chatwootCache,
+        );
+      } else {
+        instance = new BaileysStartupService(
+          this.configService,
+          this.eventEmitter,
+          this.repository,
+          this.cache,
+          this.chatwootCache,
+        );
+      }
+
+      await this.waMonitor.saveInstance({ integration, instanceName, token, number, mobile });
+
+      instance.instanceName = instanceName;
+
+      const instanceId = v4();
+
+      instance.sendDataWebhook(Events.INSTANCE_CREATE, {
+        instanceName,
+        instanceId: instanceId,
+      });
+
+      this.logger.verbose('instance: ' + instance.instanceName + ' created');
+
+      this.waMonitor.waInstances[instance.instanceName] = instance;
+      this.waMonitor.delInstanceTime(instance.instanceName);
+
+      this.logger.verbose('generating hash');
+      const hash = await this.authService.generateHash(
+        {
+          instanceName: instance.instanceName,
+          instanceId: instanceId,
+        },
+        token,
+      );
+
+      this.logger.verbose('hash: ' + hash + ' generated');
+
+      let webhookEvents: string[];
+
+      if (webhook) {
+        if (!isURL(webhook, { require_tld: false })) {
+          throw new BadRequestException('Invalid "url" property in webhook');
+        }
+
+        this.logger.verbose('creating webhook');
+        try {
+          let newEvents: string[] = [];
+          if (events.length === 0) {
+            newEvents = [
+              'APPLICATION_STARTUP',
+              'QRCODE_UPDATED',
+              'MESSAGES_SET',
+              'MESSAGES_UPSERT',
+              'MESSAGES_UPDATE',
+              'MESSAGES_DELETE',
+              'SEND_MESSAGE',
+              'CONTACTS_SET',
+              'CONTACTS_UPSERT',
+              'CONTACTS_UPDATE',
+              'PRESENCE_UPDATE',
+              'CHATS_SET',
+              'CHATS_UPSERT',
+              'CHATS_UPDATE',
+              'CHATS_DELETE',
+              'GROUPS_UPSERT',
+              'GROUP_UPDATE',
+              'GROUP_PARTICIPANTS_UPDATE',
+              'CONNECTION_UPDATE',
+              'LABELS_EDIT',
+              'LABELS_ASSOCIATION',
+              'CALL',
+              'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
+            ];
+          } else {
+            newEvents = events;
+          }
+          this.webhookService.create(instance, {
+            enabled: true,
+            url: webhook,
+            events: newEvents,
+            webhook_by_events,
+            webhook_base64,
+          });
+
+          webhookEvents = (await this.webhookService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      let websocketEvents: string[];
+
+      if (websocket_enabled) {
+        this.logger.verbose('creating websocket');
+        try {
+          let newEvents: string[] = [];
+          if (websocket_events.length === 0) {
+            newEvents = [
+              'APPLICATION_STARTUP',
+              'QRCODE_UPDATED',
+              'MESSAGES_SET',
+              'MESSAGES_UPSERT',
+              'MESSAGES_UPDATE',
+              'MESSAGES_DELETE',
+              'SEND_MESSAGE',
+              'CONTACTS_SET',
+              'CONTACTS_UPSERT',
+              'CONTACTS_UPDATE',
+              'PRESENCE_UPDATE',
+              'CHATS_SET',
+              'CHATS_UPSERT',
+              'CHATS_UPDATE',
+              'CHATS_DELETE',
+              'GROUPS_UPSERT',
+              'GROUP_UPDATE',
+              'GROUP_PARTICIPANTS_UPDATE',
+              'CONNECTION_UPDATE',
+              'LABELS_EDIT',
+              'LABELS_ASSOCIATION',
+              'CALL',
+              'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
+            ];
+          } else {
+            newEvents = websocket_events;
+          }
+          this.websocketService.create(instance, {
+            enabled: true,
+            events: newEvents,
+          });
+
+          websocketEvents = (await this.websocketService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      let rabbitmqEvents: string[];
+
+      if (rabbitmq_enabled) {
+        this.logger.verbose('creating rabbitmq');
+        try {
+          let newEvents: string[] = [];
+          if (rabbitmq_events.length === 0) {
+            newEvents = [
+              'APPLICATION_STARTUP',
+              'QRCODE_UPDATED',
+              'MESSAGES_SET',
+              'MESSAGES_UPSERT',
+              'MESSAGES_UPDATE',
+              'MESSAGES_DELETE',
+              'SEND_MESSAGE',
+              'CONTACTS_SET',
+              'CONTACTS_UPSERT',
+              'CONTACTS_UPDATE',
+              'PRESENCE_UPDATE',
+              'CHATS_SET',
+              'CHATS_UPSERT',
+              'CHATS_UPDATE',
+              'CHATS_DELETE',
+              'GROUPS_UPSERT',
+              'GROUP_UPDATE',
+              'GROUP_PARTICIPANTS_UPDATE',
+              'CONNECTION_UPDATE',
+              'LABELS_EDIT',
+              'LABELS_ASSOCIATION',
+              'CALL',
+              'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
+            ];
+          } else {
+            newEvents = rabbitmq_events;
+          }
+          this.rabbitmqService.create(instance, {
+            enabled: true,
+            events: newEvents,
+          });
+
+          rabbitmqEvents = (await this.rabbitmqService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      let sqsEvents: string[];
+
+      if (sqs_enabled) {
+        this.logger.verbose('creating sqs');
+        try {
+          let newEvents: string[] = [];
+          if (sqs_events.length === 0) {
+            newEvents = [
+              'APPLICATION_STARTUP',
+              'QRCODE_UPDATED',
+              'MESSAGES_SET',
+              'MESSAGES_UPSERT',
+              'MESSAGES_UPDATE',
+              'MESSAGES_DELETE',
+              'SEND_MESSAGE',
+              'CONTACTS_SET',
+              'CONTACTS_UPSERT',
+              'CONTACTS_UPDATE',
+              'PRESENCE_UPDATE',
+              'CHATS_SET',
+              'CHATS_UPSERT',
+              'CHATS_UPDATE',
+              'CHATS_DELETE',
+              'GROUPS_UPSERT',
+              'GROUP_UPDATE',
+              'GROUP_PARTICIPANTS_UPDATE',
+              'CONNECTION_UPDATE',
+              'LABELS_EDIT',
+              'LABELS_ASSOCIATION',
+              'CALL',
+              'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
+            ];
+          } else {
+            newEvents = sqs_events;
+          }
+          this.sqsService.create(instance, {
+            enabled: true,
+            events: newEvents,
+          });
+
+          sqsEvents = (await this.sqsService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      if (proxy) {
+        const testProxy = await this.proxyService.testProxy(proxy);
+        if (!testProxy) {
+          throw new BadRequestException('Invalid proxy');
+        }
+
+        await this.proxyService.createProxy(instance, {
+          enabled: true,
+          proxy,
+        });
+      }
+
+      if (typebot_url) {
+        try {
+          if (!isURL(typebot_url, { require_tld: false })) {
+            throw new BadRequestException('Invalid "url" property in typebot_url');
+          }
+
+          this.logger.verbose('creating typebot');
+
+          this.typebotService.create(instance, {
+            enabled: true,
+            url: typebot_url,
+            typebot: typebot,
+            expire: typebot_expire,
+            keyword_finish: typebot_keyword_finish,
+            delay_message: typebot_delay_message,
+            unknown_message: typebot_unknown_message,
+            listening_from_me: typebot_listening_from_me,
+          });
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      this.logger.verbose('creating settings');
+      const settings: wa.LocalSettings = {
+        reject_call: reject_call || false,
+        msg_call: msg_call || '',
+        groups_ignore: groups_ignore || true,
+        always_online: always_online || false,
+        read_messages: read_messages || false,
+        read_status: read_status || false,
+        sync_full_history: sync_full_history ?? false,
+      };
+
+      this.logger.verbose('settings: ' + JSON.stringify(settings));
+
+      this.settingsService.create(instance, settings);
+
+      let webhook_wa_business = null,
+        access_token_wa_business = '';
+
+      if (integration === Integration.WHATSAPP_BUSINESS) {
+        if (!number) {
+          throw new BadRequestException('number is required');
+        }
+        const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+        webhook_wa_business = `${urlServer}/webhook/whatsapp/${encodeURIComponent(instance.instanceName)}`;
+        access_token_wa_business = this.configService.get<WaBusiness>('WA_BUSINESS').TOKEN_WEBHOOK;
+      }
+
+      this.integrationService.create(instance, {
+        integration,
+        number,
+        token,
+      });
+      if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
+        let getQrcode: wa.QrCode;
+
+        if (qrcode) {
+          this.logger.verbose('creating qrcode');
+          await instance.connectToWhatsapp(number, mobile);
+          await delay(5000);
+          getQrcode = instance.qrCode;
+        }
+
+        const result = {
+          instance: {
+            instanceName: instance.instanceName,
+            instanceId: instanceId,
+            integration: integration,
+            webhook_wa_business,
+            access_token_wa_business,
+            status: 'created',
+          },
+          hash,
+          webhook: {
+            webhook,
+            webhook_by_events,
+            webhook_base64,
+            events: webhookEvents,
+          },
+          websocket: {
+            enabled: websocket_enabled,
+            events: websocketEvents,
+          },
+          rabbitmq: {
+            enabled: rabbitmq_enabled,
+            events: rabbitmqEvents,
+          },
+          sqs: {
+            enabled: sqs_enabled,
+            events: sqsEvents,
+          },
+          typebot: {
+            enabled: typebot_url ? true : false,
+            url: typebot_url,
+            typebot,
+            expire: typebot_expire,
+            keyword_finish: typebot_keyword_finish,
+            delay_message: typebot_delay_message,
+            unknown_message: typebot_unknown_message,
+            listening_from_me: typebot_listening_from_me,
+          },
+          settings,
+          qrcode: getQrcode,
+        };
+
+        this.logger.verbose('instance created');
+        this.logger.verbose(result);
+
+        return result;
+      }
+
+      if (!chatwoot_account_id) {
+        throw new BadRequestException('account_id is required');
+      }
+
+      if (!chatwoot_token) {
+        throw new BadRequestException('token is required');
+      }
+
+      if (!chatwoot_url) {
+        throw new BadRequestException('url is required');
+      }
+
+      if (!isURL(chatwoot_url, { require_tld: false })) {
+        throw new BadRequestException('Invalid "url" property in chatwoot');
+      }
+
+      if (chatwoot_sign_msg !== true && chatwoot_sign_msg !== false) {
+        throw new BadRequestException('sign_msg is required');
+      }
+
+      if (chatwoot_reopen_conversation !== true && chatwoot_reopen_conversation !== false) {
+        throw new BadRequestException('reopen_conversation is required');
+      }
+
+      if (chatwoot_conversation_pending !== true && chatwoot_conversation_pending !== false) {
+        throw new BadRequestException('conversation_pending is required');
+      }
+
+      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+      try {
+        this.chatwootService.create(instance, {
+          enabled: true,
+          account_id: chatwoot_account_id,
+          token: chatwoot_token,
+          url: chatwoot_url,
+          sign_msg: chatwoot_sign_msg || false,
+          name_inbox: instance.instanceName.split('-cwId-')[0],
+          number,
+          reopen_conversation: chatwoot_reopen_conversation || false,
+          conversation_pending: chatwoot_conversation_pending || false,
+          import_contacts: chatwoot_import_contacts ?? true,
+          import_messages: chatwoot_import_messages ?? true,
+          days_limit_import_messages: chatwoot_days_limit_import_messages ?? 60,
+          auto_create: true,
+        });
+      } catch (error) {
+        this.logger.log(error);
+      }
+
+      return {
+        instance: {
+          instanceName: instance.instanceName,
+          instanceId: instanceId,
+          integration: integration,
+          webhook_wa_business,
+          access_token_wa_business,
+          status: 'created',
+        },
+        hash,
+        webhook: {
+          webhook,
+          webhook_by_events,
+          webhook_base64,
+          events: webhookEvents,
+        },
+        websocket: {
+          enabled: websocket_enabled,
+          events: websocketEvents,
+        },
+        rabbitmq: {
+          enabled: rabbitmq_enabled,
+          events: rabbitmqEvents,
+        },
+        sqs: {
+          enabled: sqs_enabled,
+          events: sqsEvents,
+        },
+        typebot: {
+          enabled: typebot_url ? true : false,
+          url: typebot_url,
+          typebot,
+          expire: typebot_expire,
+          keyword_finish: typebot_keyword_finish,
+          delay_message: typebot_delay_message,
+          unknown_message: typebot_unknown_message,
+          listening_from_me: typebot_listening_from_me,
+        },
+        settings,
+        chatwoot: {
+          enabled: true,
+          account_id: chatwoot_account_id,
+          token: chatwoot_token,
+          url: chatwoot_url,
+          sign_msg: chatwoot_sign_msg || false,
+          reopen_conversation: chatwoot_reopen_conversation || false,
+          conversation_pending: chatwoot_conversation_pending || false,
+          import_contacts: chatwoot_import_contacts ?? true,
+          import_messages: chatwoot_import_messages ?? true,
+          days_limit_import_messages: chatwoot_days_limit_import_messages || 60,
+          number,
+          name_inbox: instance.instanceName,
+          webhook_url: `${urlServer}/chatwoot/webhook/${encodeURIComponent(instance.instanceName)}`,
+        },
+      };
+    } catch (error) {
+      this.logger.error(error.message[0]);
+      throw new BadRequestException(error.message[0]);
+    }
+  }
+
+  public async connectToWhatsapp({ instanceName, number = null, mobile = null }: InstanceDto) {
+    try {
+      this.logger.verbose('requested connectToWhatsapp from ' + instanceName + ' instance');
+
+      const instance = this.waMonitor.waInstances[instanceName];
+      const state = instance?.connectionStatus?.state;
+
+      this.logger.verbose('state: ' + state);
+
+      if (!state) {
+        throw new BadRequestException('The "' + instanceName + '" instance does not exist');
+      }
+
+      if (state == 'open') {
+        return await this.connectionState({ instanceName });
+      }
+
+      if (state == 'connecting') {
+        return instance.qrCode;
+      }
+
+      if (state == 'close') {
+        this.logger.verbose('connecting');
+        await instance.connectToWhatsapp(number, mobile);
+
+        await delay(5000);
+        return instance.qrCode;
+      }
+
+      return {
+        instance: {
+          instanceName: instanceName,
+          status: state,
+        },
+        qrcode: instance?.qrCode,
+      };
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+
+  public async restartInstance({ instanceName }: InstanceDto) {
+    try {
+      this.logger.verbose('requested restartInstance from ' + instanceName + ' instance');
+
+      const instance = this.waMonitor.waInstances[instanceName];
+      const state = instance?.connectionStatus?.state;
+
+      switch (state) {
+        case 'open':
+          this.logger.verbose('logging out instance: ' + instanceName);
+          instance.clearCacheChatwoot();
+          await instance.reloadConnection();
+          await delay(2000);
+
+          return await this.connectionState({ instanceName });
+        default:
+          return await this.connectionState({ instanceName });
+      }
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+
+  public async registerMobileCode({ instanceName }: InstanceDto, { mobileCode }: any) {
+    try {
+      this.logger.verbose('requested registerMobileCode from ' + instanceName + ' instance');
+
+      const instance = this.waMonitor.waInstances[instanceName];
+
+      console.log('mobileCode', mobileCode);
+      await instance.receiveMobileCode(mobileCode);
+      return { status: 'SUCCESS', error: false, response: { message: 'Mobile code registered' } };
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+
+  public async connectionState({ instanceName }: InstanceDto) {
+    this.logger.verbose('requested connectionState from ' + instanceName + ' instance');
+    return {
+      instance: {
+        instanceName: instanceName,
+        state: this.waMonitor.waInstances[instanceName]?.connectionStatus?.state,
+      },
+    };
+  }
+
+  public async fetchInstances({ instanceName, instanceId, number }: InstanceDto) {
+    if (instanceName) {
+      this.logger.verbose('requested fetchInstances from ' + instanceName + ' instance');
+      this.logger.verbose('instanceName: ' + instanceName);
+      return this.waMonitor.instanceInfo(instanceName);
+    } else if (instanceId || number) {
+      return this.waMonitor.instanceInfoById(instanceId, number);
+    }
+
+    this.logger.verbose('requested fetchInstances (all instances)');
+    return this.waMonitor.instanceInfo();
+  }
+
+  public async setPresence({ instanceName }: InstanceDto, data: SetPresenceDto) {
+    this.logger.verbose('requested sendPresence from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].setPresence(data);
+  }
+
+  public async logout({ instanceName }: InstanceDto) {
+    this.logger.verbose('requested logout from ' + instanceName + ' instance');
+    const { instance } = await this.connectionState({ instanceName });
+
+    if (instance.state === 'close') {
+      throw new BadRequestException('The "' + instanceName + '" instance is not connected');
+    }
+
+    try {
+      this.waMonitor.waInstances[instanceName]?.logoutInstance();
+
+      return { status: 'SUCCESS', error: false, response: { message: 'Instance logged out' } };
+    } catch (error) {
+      throw new InternalServerErrorException(error.toString());
+    }
+  }
+
+  public async deleteInstance({ instanceName }: InstanceDto) {
+    this.logger.verbose('requested deleteInstance from ' + instanceName + ' instance');
+    const { instance } = await this.connectionState({ instanceName });
+
+    if (instance.state === 'open') {
+      throw new BadRequestException('The "' + instanceName + '" instance needs to be disconnected');
+    }
+    try {
+      this.waMonitor.waInstances[instanceName]?.removeRabbitmqQueues();
+      this.waMonitor.waInstances[instanceName]?.clearCacheChatwoot();
+
+      if (instance.state === 'connecting') {
+        this.logger.verbose('logging out instance: ' + instanceName);
+
+        await this.logout({ instanceName });
+      }
+
+      this.logger.verbose('deleting instance: ' + instanceName);
+
+      try {
+        this.waMonitor.waInstances[instanceName].sendDataWebhook(Events.INSTANCE_DELETE, {
+          instanceName,
+          instanceId: (await this.repository.auth.find(instanceName))?.instanceId,
+        });
+      } catch (error) {
+        this.logger.error(error);
+      }
+
+      delete this.waMonitor.waInstances[instanceName];
+      this.eventEmitter.emit('remove.instance', instanceName, 'inner');
+      return { status: 'SUCCESS', error: false, response: { message: 'Instance deleted' } };
+    } catch (error) {
+      throw new BadRequestException(error.toString());
+    }
+  }
+
+  public async refreshToken(_: InstanceDto, oldToken: OldToken) {
+    this.logger.verbose('requested refreshToken');
+    return await this.authService.refreshToken(oldToken);
+  }
+}

src/api/controllers/label.controller.ts

@@ -0,0 +1,20 @@
+import { Logger } from '../../config/logger.config';
+import { InstanceDto } from '../dto/instance.dto';
+import { HandleLabelDto } from '../dto/label.dto';
+import { WAMonitoringService } from '../services/monitor.service';
+
+const logger = new Logger('LabelController');
+
+export class LabelController {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  public async fetchLabels({ instanceName }: InstanceDto) {
+    logger.verbose('requested fetchLabels from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].fetchLabels();
+  }
+
+  public async handleLabel({ instanceName }: InstanceDto, data: HandleLabelDto) {
+    logger.verbose('requested chat label change from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].handleLabel(data);
+  }
+}

src/api/controllers/proxy.controller.ts

@@ -0,0 +1,72 @@
+import axios from 'axios';
+
+import { Logger } from '../../config/logger.config';
+import { BadRequestException, NotFoundException } from '../../exceptions';
+import { makeProxyAgent } from '../../utils/makeProxyAgent';
+import { InstanceDto } from '../dto/instance.dto';
+import { ProxyDto } from '../dto/proxy.dto';
+import { WAMonitoringService } from '../services/monitor.service';
+import { ProxyService } from '../services/proxy.service';
+
+const logger = new Logger('ProxyController');
+
+export class ProxyController {
+  constructor(private readonly proxyService: ProxyService, private readonly waMonitor: WAMonitoringService) {}
+
+  public async createProxy(instance: InstanceDto, data: ProxyDto) {
+    logger.verbose('requested createProxy from ' + instance.instanceName + ' instance');
+
+    if (!this.waMonitor.waInstances[instance.instanceName]) {
+      throw new NotFoundException(`The "${instance.instanceName}" instance does not exist`);
+    }
+
+    if (!data.enabled) {
+      logger.verbose('proxy disabled');
+      data.proxy = null;
+    }
+
+    if (data.proxy) {
+      const testProxy = await this.testProxy(data.proxy);
+      if (!testProxy) {
+        throw new BadRequestException('Invalid proxy');
+      }
+      logger.verbose('proxy enabled');
+    }
+
+    return this.proxyService.create(instance, data);
+  }
+
+  public async findProxy(instance: InstanceDto) {
+    logger.verbose('requested findProxy from ' + instance.instanceName + ' instance');
+
+    if (!this.waMonitor.waInstances[instance.instanceName]) {
+      throw new NotFoundException(`The "${instance.instanceName}" instance does not exist`);
+    }
+
+    return this.proxyService.find(instance);
+  }
+
+  public async testProxy(proxy: ProxyDto['proxy']) {
+    logger.verbose('requested testProxy');
+    try {
+      const serverIp = await axios.get('https://icanhazip.com/');
+      const response = await axios.get('https://icanhazip.com/', {
+        httpsAgent: makeProxyAgent(proxy),
+      });
+
+      logger.verbose('[testProxy] from IP: ' + response?.data + ' To IP: ' + serverIp?.data);
+      return response?.data !== serverIp?.data;
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response?.data) {
+        logger.error('testProxy error: ' + error.response.data);
+      } else if (axios.isAxiosError(error)) {
+        logger.error('testProxy error: ');
+        logger.verbose(error.cause ?? error.message);
+      } else {
+        logger.error('testProxy error: ');
+        logger.verbose(error);
+      }
+      return false;
+    }
+  }
+}

src/api/controllers/sendMessage.controller.ts

@@ -0,0 +1,117 @@
+import { isBase64, isURL } from 'class-validator';
+
+import { Logger } from '../../config/logger.config';
+import { BadRequestException } from '../../exceptions';
+import { InstanceDto } from '../dto/instance.dto';
+import {
+  SendAudioDto,
+  SendButtonDto,
+  SendContactDto,
+  SendListDto,
+  SendLocationDto,
+  SendMediaDto,
+  SendPollDto,
+  SendReactionDto,
+  SendStatusDto,
+  SendStickerDto,
+  SendTemplateDto,
+  SendTextDto,
+} from '../dto/sendMessage.dto';
+import { WAMonitoringService } from '../services/monitor.service';
+
+const logger = new Logger('MessageRouter');
+
+export class SendMessageController {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  public async sendText({ instanceName }: InstanceDto, data: SendTextDto) {
+    logger.verbose('requested sendText from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].textMessage(data);
+  }
+
+  public async sendTemplate({ instanceName }: InstanceDto, data: SendTemplateDto) {
+    logger.verbose('requested sendList from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].templateMessage(data);
+  }
+
+  public async sendMedia({ instanceName }: InstanceDto, data: SendMediaDto) {
+    logger.verbose('requested sendMedia from ' + instanceName + ' instance');
+
+    if (
+      isBase64(data?.mediaMessage?.media) &&
+      !data?.mediaMessage?.fileName &&
+      data?.mediaMessage?.mediatype === 'document'
+    ) {
+      throw new BadRequestException('For base64 the file name must be informed.');
+    }
+
+    logger.verbose('isURL: ' + isURL(data?.mediaMessage?.media) + ', isBase64: ' + isBase64(data?.mediaMessage?.media));
+    if (isURL(data?.mediaMessage?.media) || isBase64(data?.mediaMessage?.media)) {
+      return await this.waMonitor.waInstances[instanceName].mediaMessage(data);
+    }
+    throw new BadRequestException('Owned media must be a url or base64');
+  }
+
+  public async sendSticker({ instanceName }: InstanceDto, data: SendStickerDto) {
+    logger.verbose('requested sendSticker from ' + instanceName + ' instance');
+
+    logger.verbose(
+      'isURL: ' + isURL(data?.stickerMessage?.image) + ', isBase64: ' + isBase64(data?.stickerMessage?.image),
+    );
+    if (isURL(data.stickerMessage.image) || isBase64(data.stickerMessage.image)) {
+      return await this.waMonitor.waInstances[instanceName].mediaSticker(data);
+    }
+    throw new BadRequestException('Owned media must be a url or base64');
+  }
+
+  public async sendWhatsAppAudio({ instanceName }: InstanceDto, data: SendAudioDto) {
+    logger.verbose('requested sendWhatsAppAudio from ' + instanceName + ' instance');
+
+    logger.verbose('isURL: ' + isURL(data?.audioMessage?.audio) + ', isBase64: ' + isBase64(data?.audioMessage?.audio));
+    if (isURL(data.audioMessage.audio) || isBase64(data.audioMessage.audio)) {
+      return await this.waMonitor.waInstances[instanceName].audioWhatsapp(data);
+    }
+    throw new BadRequestException('Owned media must be a url or base64');
+  }
+
+  public async sendButtons({ instanceName }: InstanceDto, data: SendButtonDto) {
+    logger.verbose('requested sendButtons from ' + instanceName + ' instance');
+    if (isBase64(data.buttonMessage.mediaMessage?.media) && !data.buttonMessage.mediaMessage?.fileName) {
+      throw new BadRequestException('For bse64 the file name must be informed.');
+    }
+    return await this.waMonitor.waInstances[instanceName].buttonMessage(data);
+  }
+
+  public async sendLocation({ instanceName }: InstanceDto, data: SendLocationDto) {
+    logger.verbose('requested sendLocation from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].locationMessage(data);
+  }
+
+  public async sendList({ instanceName }: InstanceDto, data: SendListDto) {
+    logger.verbose('requested sendList from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].listMessage(data);
+  }
+
+  public async sendContact({ instanceName }: InstanceDto, data: SendContactDto) {
+    logger.verbose('requested sendContact from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].contactMessage(data);
+  }
+
+  public async sendReaction({ instanceName }: InstanceDto, data: SendReactionDto) {
+    logger.verbose('requested sendReaction from ' + instanceName + ' instance');
+    if (!data.reactionMessage.reaction.match(/[^()\w\sà-ú"-+]+/)) {
+      throw new BadRequestException('"reaction" must be an emoji');
+    }
+    return await this.waMonitor.waInstances[instanceName].reactionMessage(data);
+  }
+
+  public async sendPoll({ instanceName }: InstanceDto, data: SendPollDto) {
+    logger.verbose('requested sendPoll from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].pollMessage(data);
+  }
+
+  public async sendStatus({ instanceName }: InstanceDto, data: SendStatusDto) {
+    logger.verbose('requested sendStatus from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].statusMessage(data);
+  }
+}

src/api/controllers/settings.controller.ts

@@ -0,0 +1,22 @@
+import { Logger } from '../../config/logger.config';
+import { InstanceDto } from '../dto/instance.dto';
+import { SettingsDto } from '../dto/settings.dto';
+import { SettingsService } from '../services/settings.service';
+
+const logger = new Logger('SettingsController');
+
+export class SettingsController {
+  constructor(private readonly settingsService: SettingsService) {}
+
+  public async createSettings(instance: InstanceDto, data: SettingsDto) {
+    logger.verbose('requested createSettings from ' + instance.instanceName + ' instance');
+
+    return this.settingsService.create(instance, data);
+  }
+
+  public async findSettings(instance: InstanceDto) {
+    logger.verbose('requested findSettings from ' + instance.instanceName + ' instance');
+    const settings = this.settingsService.find(instance);
+    return settings;
+  }
+}

src/api/controllers/webhook.controller.ts

@@ -0,0 +1,72 @@
+import { isURL } from 'class-validator';
+
+import { Logger } from '../../config/logger.config';
+import { BadRequestException } from '../../exceptions';
+import { InstanceDto } from '../dto/instance.dto';
+import { WebhookDto } from '../dto/webhook.dto';
+import { WAMonitoringService } from '../services/monitor.service';
+import { WebhookService } from '../services/webhook.service';
+
+const logger = new Logger('WebhookController');
+
+export class WebhookController {
+  constructor(private readonly webhookService: WebhookService, private readonly waMonitor: WAMonitoringService) {}
+
+  public async createWebhook(instance: InstanceDto, data: WebhookDto) {
+    logger.verbose('requested createWebhook from ' + instance.instanceName + ' instance');
+
+    if (!isURL(data.url, { require_tld: false })) {
+      throw new BadRequestException('Invalid "url" property');
+    }
+
+    data.enabled = data.enabled ?? true;
+
+    if (!data.enabled) {
+      logger.verbose('webhook disabled');
+      data.url = '';
+      data.events = [];
+    } else if (data.events.length === 0) {
+      logger.verbose('webhook events empty');
+      data.events = [
+        'APPLICATION_STARTUP',
+        'QRCODE_UPDATED',
+        'MESSAGES_SET',
+        'MESSAGES_UPSERT',
+        'MESSAGES_UPDATE',
+        'MESSAGES_DELETE',
+        'SEND_MESSAGE',
+        'CONTACTS_SET',
+        'CONTACTS_UPSERT',
+        'CONTACTS_UPDATE',
+        'PRESENCE_UPDATE',
+        'CHATS_SET',
+        'CHATS_UPSERT',
+        'CHATS_UPDATE',
+        'CHATS_DELETE',
+        'GROUPS_UPSERT',
+        'GROUP_UPDATE',
+        'GROUP_PARTICIPANTS_UPDATE',
+        'CONNECTION_UPDATE',
+        'LABELS_EDIT',
+        'LABELS_ASSOCIATION',
+        'CALL',
+        'NEW_JWT_TOKEN',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+        'CHAMA_AI_ACTION',
+      ];
+    }
+
+    return this.webhookService.create(instance, data);
+  }
+
+  public async findWebhook(instance: InstanceDto) {
+    logger.verbose('requested findWebhook from ' + instance.instanceName + ' instance');
+    return this.webhookService.find(instance);
+  }
+
+  public async receiveWebhook(instance: InstanceDto, data: any) {
+    logger.verbose('requested receiveWebhook from ' + instance.instanceName + ' instance');
+    return await this.waMonitor.waInstances[instance.instanceName].connectToWhatsapp(data);
+  }
+}