Merge branch 'release/1.4.1'

version: 1.4.1
fix: connection state
2025-12-19 03:42:23 -06:00 · 2023-07-24 18:28:45 -03:00 · 2023-07-24 18:28:39 -03:00 · 2023-07-24 18:28:01 -03:00 · 2023-07-24 18:21:11 -03:00 · 2023-07-24 17:05:43 -03:00
35 changed files with 1124 additions and 589 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,8 @@ lerna-debug.log*
 /docker-compose-data
 /docker-data

+docker-compose.yaml
+
 # Package
 /yarn.lock
 /package-lock.json
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,16 +1,69 @@
+# 1.4.1 (2023-07-24 18:28)
+
+### Fixed
+
+* Fixed reconnect with pairing code or qrcode
+* Fixed problem in createJid
+
+# 1.4.0 (2023-07-24 17:03)
+
+### Features
+
+* Added connection functionality via pairing code
+* Added fetch profile endpoint in chat controller
+* Created settings controller
+* Added reject call and send text message when receiving a call
+* Added setting to ignore group messages
+* Added connection with pairing code in chatwoot with command /init:{NUMBER}
+* Added encoding option in endpoint sendWhatsAppAudio
+
+### Fixed
+
+* Added link preview option in send text message
+* Fixed problem with fileSha256 appearing when sending a sticker in chatwoot
+* Fixed issue where it was not possible to open a conversation when sent at first by me on my cell phone in chatwoot
+* Now it only updates the contact name if it is the same as the phone number in chatwoot
+* Now accepts all chatwoot inbox templates
+* Command to create new instances set to /new_instance:{NAME}:{NUMBER}
+* Fix in chatwoot set, sign msg can now be disabled
+
+### Integrations
+
+- Chatwoot: v2.18.0 - v3.0.0 (Beta)
+
+# 1.3.2 (2023-07-21 17:19)
+
+### Fixed
+
+* Fix in update settings that needed to restart after updated
+* Correction in the use of the api with mongodb
+* Adjustments to search endpoint for contacts, chats, messages and Status messages
+* Now when deleting the instance, the data referring to it in mongodb is also deleted
+* It is now validated if the instance name contains uppercase and special characters
+* For compatibility reasons, container mode has been removed
+* Added docker-compose files example
+
+### Integrations
+
+- Chatwoot: v2.18.0
+
 # 1.3.1 (2023-07-20 07:48)

 ### Fixed

 * Adjust in create store files

+### Integrations
+
+- Chatwoot: v2.18.0
+
 # 1.3.0 (2023-07-19 11:33)

 ### Features

 * Added messages.delete event
 * Added restart instance endpoint
-* Created automation for creating instances in the chatwoot bot with the command '#inbox_whatsapp:<INSTANCE_NAME>'
+* Created automation for creating instances in the chatwoot bot with the command '#inbox_whatsapp:{INSTANCE_NAME}
 * Change Baileys version to: 6.4.0
 * Send contact in chatwoot
 * Send contact array in chatwoot
--- a/Docker/.env.example
+++ b/Docker/.env.example
@@ -1,13 +1,13 @@
 # Server URL - Set your application url
-SERVER_URL='http://localhost:8080'
+SERVER_URL=http://localhost:8080

 # Cors - * for all or set separate by commas -  ex.: 'yourdomain1.com, yourdomain2.com'
-CORS_ORIGIN='*'
-CORS_METHODS='POST,GET,PUT,DELETE'
+CORS_ORIGIN=*
+CORS_METHODS=POST,GET,PUT,DELETE
 CORS_CREDENTIALS=true

 # Determine the logs to be displayed
-LOG_LEVEL='ERROR,WARN,DEBUG,INFO,LOG,VERBOSE,DARK,WEBHOOKS'
+LOG_LEVEL=ERROR,WARN,DEBUG,INFO,LOG,VERBOSE,DARK,WEBHOOKS
 LOG_COLOR=true
 # Log Baileys - "fatal" | "error" | "warn" | "info" | "debug" | "trace"
 LOG_BAILEYS=error
@@ -31,9 +31,9 @@ CLEAN_STORE_CONTACTS=true
 CLEAN_STORE_CHATS=true

 # Permanent data storage
-DATABASE_ENABLED=false
+DATABASE_ENABLED=true
 DATABASE_CONNECTION_URI=mongodb://root:root@mongodb:27017/?authSource=admin&readPreference=primary&ssl=false&directConnection=true
-DATABASE_CONNECTION_DB_PREFIX_NAME=evolution
+DATABASE_CONNECTION_DB_PREFIX_NAME=evdocker

 # Choose the data you want to save in the application's database or store
 DATABASE_SAVE_DATA_INSTANCE=false
@@ -42,9 +42,9 @@ DATABASE_SAVE_MESSAGE_UPDATE=false
 DATABASE_SAVE_DATA_CONTACTS=false
 DATABASE_SAVE_DATA_CHATS=false

-REDIS_ENABLED=false
+REDIS_ENABLED=true
 REDIS_URI=redis://redis:6379
-REDIS_PREFIX_KEY=evolution
+REDIS_PREFIX_KEY=evdocker

 # Global Webhook Settings
 # Each instance's Webhook URL and events will be requested at the time it is created
@@ -77,7 +77,7 @@ WEBHOOK_EVENTS_CONNECTION_UPDATE=true
 WEBHOOK_EVENTS_NEW_JWT_TOKEN=false

 # Name that will be displayed on smartphone connection
-CONFIG_SESSION_PHONE_CLIENT='Evolution API'
+CONFIG_SESSION_PHONE_CLIENT=EvolutionAPI
 # Browser Name = chrome | firefox | edge | opera | safari
 CONFIG_SESSION_PHONE_NAME=chrome

@@ -88,22 +88,12 @@ QRCODE_LIMIT=30
 # We recommend using the apikey because it will allow you to use a custom token,
 # if you use jwt, a random token will be generated and may be expired and you will have to generate a new token
 # jwt or 'apikey'
-AUTHENTICATION_TYPE='apikey'
+AUTHENTICATION_TYPE=apikey
 ## Define a global apikey to access all instances.
 ### OBS: This key must be inserted in the request header to create an instance.
-AUTHENTICATION_API_KEY='B6D711FCDE4D4FD5936544120E713976'
+AUTHENTICATION_API_KEY=B6D711FCDE4D4FD5936544120E713976
 AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES=true
 ## Set the secret key to encrypt and decrypt your token and its expiration time
 # seconds - 3600s ===1h | zero (0) - never expires
 AUTHENTICATION_JWT_EXPIRIN_IN=0
-AUTHENTICATION_JWT_SECRET='L0YWtjb2w554WFqPG'
-# Set the instance name and webhook url to create an instance in init the application
-# With this option activated, you work with a url per webhook event, respecting the local url and the name of each event
-# container or server
-AUTHENTICATION_INSTANCE_MODE=server
-# if you are using container mode, set the container name and the webhook url to default instance
-AUTHENTICATION_INSTANCE_NAME=evolution
-AUTHENTICATION_INSTANCE_WEBHOOK_URL=''
-AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
-AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
-AUTHENTICATION_INSTANCE_CHATWOOT_URL=''
+AUTHENTICATION_JWT_SECRET='L=0YWt]b2w[WF>#>:&E`'
--- a/Docker/redis/docker-compose.yaml
+++ b/Docker/redis/docker-compose.yaml
@@ -12,13 +12,6 @@ services:
      - evolution_redis:/data
    ports:
      - 6379:6379
-  
-  rebrow:
-    image: marian/rebrow
-    ports: 
-      - 5001:5001
-    links:
-      - redis
    
 volumes:
  evolution_redis:
--- a/4
+++ b/4
@@ -13,7 +13,7 @@ COPY ./package.json .

 ENV DOCKER_ENV=true

-ENV SERVER_URL='http://localhost:8080'
+ENV SERVER_URL=http://localhost:8080

 ENV CORS_ORIGIN=*
 ENV CORS_METHODS=POST,GET,PUT,DELETE
@@ -77,7 +77,7 @@ ENV WEBHOOK_EVENTS_CONNECTION_UPDATE=true

 ENV WEBHOOK_EVENTS_NEW_JWT_TOKEN=false

-ENV CONFIG_SESSION_PHONE_CLIENT='Evolution API'
+ENV CONFIG_SESSION_PHONE_CLIENT=EvolutionAPI
 ENV CONFIG_SESSION_PHONE_NAME=chrome

 ENV QRCODE_LIMIT=30
--- a/docker-compose.yaml.example
+++ b/docker-compose.yaml.example
@@ -10,6 +10,8 @@ services:
    volumes:
      - evolution_instances:/evolution/instances
      - evolution_store:/evolution/store
+    networks:
+      - evolution-net
    env_file:
      - ./Docker/.env
    command: ['node', './dist/src/main.js']
--- a/docker-compose.yaml.example.complete
+++ b/docker-compose.yaml.example.complete
@@ -0,0 +1,79 @@
+version: '3.3'
+
+services:
+  api:
+    container_name: evolution_api
+    image: evolution/api:local
+    restart: always
+    ports:
+      - 8080:8080
+    volumes:
+      - evolution_instances:/evolution/instances
+      - evolution_store:/evolution/store
+    networks:
+      - evolution-net
+    env_file:
+      - ./Docker/.env
+    command: ['node', './dist/src/main.js']
+    expose:
+      - 8080
+
+  mongodb:
+    container_name: mongodb
+    image: mongo
+    restart: always
+    ports:
+      - 27017:27017
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME=root
+      - MONGO_INITDB_ROOT_PASSWORD=root
+      - PUID=1000
+      - PGID=1000
+    volumes:
+      - evolution_mongodb_data:/data/db
+      - evolution_mongodb_configdb:/data/configdb
+    networks:
+      - evolution-net
+    expose:
+      - 27017
+
+  mongo-express:
+    image: mongo-express
+    networks:
+      - evolution-net
+    environment:
+      ME_CONFIG_BASICAUTH_USERNAME: root
+      ME_CONFIG_BASICAUTH_PASSWORD: root
+      ME_CONFIG_MONGODB_SERVER: mongodb
+      ME_CONFIG_MONGODB_ADMINUSERNAME: root
+      ME_CONFIG_MONGODB_ADMINPASSWORD: root
+    ports:
+      - 8081:8081
+    links:
+      - mongodb
+
+  redis:
+    image: redis:latest
+    container_name: redis
+    command: >
+      redis-server
+      --port 6379
+      --appendonly yes
+    volumes:
+      - evolution_redis:/data
+    networks:
+      - evolution-net
+    ports:
+      - 6379:6379
+
+volumes:
+  evolution_instances:
+  evolution_store:
+  evolution_mongodb_data:
+  evolution_mongodb_configdb:
+  evolution_redis:
+
+networks:
+  evolution-net:
+    external: true
+  
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "evolution-api",
-  "version": "1.3.1",
+  "version": "1.4.1",
  "description": "Rest api for communication with WhatsApp",
  "main": "./dist/src/main.js",
  "scripts": {
--- a/src/config/env.config.ts
+++ b/src/config/env.config.ts
@@ -94,20 +94,12 @@ export type EventsWebhook = {

 export type ApiKey = { KEY: string };
 export type Jwt = { EXPIRIN_IN: number; SECRET: string };
-export type Instance = {
-  NAME: string;
-  WEBHOOK_URL: string;
-  MODE: string;
-  CHATWOOT_ACCOUNT_ID: string;
-  CHATWOOT_TOKEN: string;
-  CHATWOOT_URL: string;
-};
+
 export type Auth = {
  API_KEY: ApiKey;
  EXPOSE_IN_FETCH_INSTANCES: boolean;
  JWT: Jwt;
  TYPE: 'jwt' | 'apikey';
-  INSTANCE: Instance;
 };

 export type DelInstance = number | boolean;
@@ -276,15 +268,6 @@ export class ConfigService {
            : 3600,
          SECRET: process.env.AUTHENTICATION_JWT_SECRET,
        },
-        INSTANCE: {
-          NAME: process.env.AUTHENTICATION_INSTANCE_NAME,
-          WEBHOOK_URL: process.env.AUTHENTICATION_INSTANCE_WEBHOOK_URL,
-          MODE: process.env.AUTHENTICATION_INSTANCE_MODE,
-          CHATWOOT_ACCOUNT_ID:
-            process.env.AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID || '',
-          CHATWOOT_TOKEN: process.env.AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN || '',
-          CHATWOOT_URL: process.env.AUTHENTICATION_INSTANCE_CHATWOOT_URL || '',
-        },
      },
    };
  }
--- a/src/dev-env.yml
+++ b/src/dev-env.yml
@@ -136,14 +136,4 @@ AUTHENTICATION:
  # Set the secret key to encrypt and decrypt your token and its expiration time.
  JWT:
    EXPIRIN_IN: 0 # seconds - 3600s === 1h | zero (0) - never expires
-    SECRET: L=0YWt]b2w[WF>#>:&E`
-  # Set the instance name and webhook url to create an instance in init the application
-  INSTANCE:
-    # With this option activated, you work with a url per webhook event, respecting the local url and the name of each event
-    MODE: server # container or server
-    # if you are using container mode, set the container name and the webhook url to default instance
-    NAME: evolution
-    WEBHOOK_URL: <url>
-    CHATWOOT_ACCOUNT_ID: 1
-    CHATWOOT_TOKEN: 123456
-    CHATWOOT_URL: <url>
+    SECRET: L=0YWt]b2w[WF>#>:&E`
--- a/src/validate/validate.schema.ts
+++ b/src/validate/validate.schema.ts
@@ -58,6 +58,7 @@ export const instanceNameSchema: JSONSchema7 = {
      },
    },
    qrcode: { type: 'boolean', enum: [true, false] },
+    number: { type: 'string', pattern: '^\\d+[\\.@\\w-]+' },
    token: { type: 'string' },
  },
  ...isNotEmpty('instanceName'),
@@ -123,7 +124,6 @@ const optionsSchema: JSONSchema7 = {

 const numberDefinition: JSONSchema7Definition = {
  type: 'string',
-  pattern: '^\\d+[\\.@\\w-]+',
  description: 'Invalid format',
 };

@@ -398,7 +398,7 @@ export const contactMessageSchema: JSONSchema7 = {
          email: { type: 'string' },
          url: { type: 'string' },
        },
-        required: ['fullName', 'wuid', 'phoneNumber'],
+        required: ['fullName', 'phoneNumber'],
        ...isNotEmpty('fullName'),
      },
      minItems: 1,
@@ -445,7 +445,6 @@ export const whatsappNumberSchema: JSONSchema7 = {
      uniqueItems: true,
      items: {
        type: 'string',
-        pattern: '^\\d+',
        description: '"numbers" must be an array of numeric strings',
      },
    },
@@ -587,6 +586,17 @@ export const profilePictureSchema: JSONSchema7 = {
  },
 };

+export const profileSchema: JSONSchema7 = {
+  type: 'object',
+  properties: {
+    wuid: { type: 'string' },
+    name: { type: 'string' },
+    picture: { type: 'string' },
+    status: { type: 'string' },
+    isBusiness: { type: 'boolean' },
+  },
+};
+
 export const messageValidateSchema: JSONSchema7 = {
  $id: v4(),
  type: 'object',
@@ -865,3 +875,15 @@ export const chatwootSchema: JSONSchema7 = {
  required: ['enabled', 'account_id', 'token', 'url', 'sign_msg'],
  ...isNotEmpty('account_id', 'token', 'url', 'sign_msg'),
 };
+
+export const settingsSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    reject_call: { type: 'boolean', enum: [true, false] },
+    msg_call: { type: 'string' },
+    groups_ignore: { type: 'boolean', enum: [true, false] },
+  },
+  required: ['reject_call'],
+  ...isNotEmpty('reject_call'),
+};
--- a/src/whatsapp/controllers/chat.controller.ts
+++ b/src/whatsapp/controllers/chat.controller.ts
@@ -48,6 +48,14 @@ export class ChatController {
    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);
--- a/src/whatsapp/controllers/chatwoot.controller.ts
+++ b/src/whatsapp/controllers/chatwoot.controller.ts
@@ -33,7 +33,7 @@ export class ChatwootController {
        throw new BadRequestException('token is required');
      }

-      if (!data.sign_msg) {
+      if (data.sign_msg !== true && data.sign_msg !== false) {
        throw new BadRequestException('sign_msg is required');
      }
    }
@@ -94,4 +94,10 @@ export class ChatwootController {

    return chatwootService.receiveWebhook(instance, data);
  }
+
+  public async newInstance(data: any) {
+    const chatwootService = new ChatwootService(waMonitor, this.configService);
+
+    return chatwootService.newInstance(data);
+  }
 }
--- a/src/whatsapp/controllers/instance.controller.ts
+++ b/src/whatsapp/controllers/instance.controller.ts
@@ -34,6 +34,7 @@ export class InstanceController {
    webhook_by_events,
    events,
    qrcode,
+    number,
    token,
    chatwoot_account_id,
    chatwoot_token,
@@ -42,275 +43,75 @@ export class InstanceController {
  }: InstanceDto) {
    this.logger.verbose('requested createInstance from ' + instanceName + ' instance');

-    const mode = this.configService.get<Auth>('AUTHENTICATION').INSTANCE.MODE;
-
-    if (mode === 'container') {
-      this.logger.verbose('container mode');
-
-      if (Object.keys(this.waMonitor.waInstances).length > 0) {
-        throw new BadRequestException([
-          'Instance already created',
-          'Only one instance can be created',
-        ]);
-      }
-
-      this.logger.verbose('checking duplicate token');
-      await this.authService.checkDuplicateToken(token);
-
-      this.logger.verbose('creating instance');
-      const instance = new WAStartupService(
-        this.configService,
-        this.eventEmitter,
-        this.repository,
-        this.cache,
+    if (instanceName !== instanceName.toLowerCase().replace(/[^a-z0-9]/g, '')) {
+      throw new BadRequestException(
+        'The instance name must be lowercase and without special characters',
      );
-      instance.instanceName = instanceName
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, '')
-        .replace(' ', '');
-      this.logger.verbose('instance: ' + instance.instanceName + ' created');
+    }

-      this.waMonitor.waInstances[instance.instanceName] = instance;
-      this.waMonitor.delInstanceTime(instance.instanceName);
+    this.logger.verbose('checking duplicate token');
+    await this.authService.checkDuplicateToken(token);

-      this.logger.verbose('generating hash');
-      const hash = await this.authService.generateHash(
-        {
-          instanceName: instance.instanceName,
-        },
-        token,
-      );
+    this.logger.verbose('creating instance');
+    const instance = new WAStartupService(
+      this.configService,
+      this.eventEmitter,
+      this.repository,
+      this.cache,
+    );
+    instance.instanceName = instanceName
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '')
+      .replace(' ', '');

-      this.logger.verbose('hash: ' + hash + ' generated');
+    this.logger.verbose('instance: ' + instance.instanceName + ' created');

-      let getEvents: string[];
+    this.waMonitor.waInstances[instance.instanceName] = instance;
+    this.waMonitor.delInstanceTime(instance.instanceName);

-      if (webhook) {
-        if (!isURL(webhook, { require_tld: false })) {
-          throw new BadRequestException('Invalid "url" property in webhook');
-        }
-        this.logger.verbose('creating webhook');
-        try {
-          this.webhookService.create(instance, {
-            enabled: true,
-            url: webhook,
-            events,
-            webhook_by_events,
-          });
+    this.logger.verbose('generating hash');
+    const hash = await this.authService.generateHash(
+      {
+        instanceName: instance.instanceName,
+      },
+      token,
+    );

-          getEvents = (await this.webhookService.find(instance)).events;
-        } catch (error) {
-          this.logger.log(error);
-        }
+    this.logger.verbose('hash: ' + hash + ' generated');
+
+    let getEvents: string[];
+
+    if (webhook) {
+      if (!isURL(webhook, { require_tld: false })) {
+        throw new BadRequestException('Invalid "url" property in webhook');
      }

-      if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
-        this.logger.verbose('instance created');
-        this.logger.verbose({
-          instance: {
-            instanceName: instance.instanceName,
-            status: 'created',
-          },
-          hash,
-          webhook,
-          events: getEvents,
-        });
-
-        return {
-          instance: {
-            instanceName: instance.instanceName,
-            status: 'created',
-          },
-          hash,
-          webhook,
-          events: getEvents,
-        };
-      }
-
-      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');
-      }
-
-      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
-
+      this.logger.verbose('creating webhook');
      try {
-        this.chatwootService.create(instance, {
+        this.webhookService.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,
+          url: webhook,
+          events,
+          webhook_by_events,
        });

-        this.chatwootService.initInstanceChatwoot(
-          instance,
-          instance.instanceName,
-          `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-          qrcode,
-        );
+        getEvents = (await this.webhookService.find(instance)).events;
      } catch (error) {
        this.logger.log(error);
      }
+    }

-      return {
-        instance: {
-          instanceName: instance.instanceName,
-          status: 'created',
-        },
-        hash,
-        chatwoot: {
-          enabled: true,
-          account_id: chatwoot_account_id,
-          token: chatwoot_token,
-          url: chatwoot_url,
-          sign_msg: chatwoot_sign_msg || false,
-          name_inbox: instance.instanceName,
-          webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-        },
-      };
-    } else {
-      this.logger.verbose('server mode');
+    if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
+      let getQrcode: wa.QrCode;

-      this.logger.verbose('checking duplicate token');
-      await this.authService.checkDuplicateToken(token);
-
-      this.logger.verbose('creating instance');
-      const instance = new WAStartupService(
-        this.configService,
-        this.eventEmitter,
-        this.repository,
-        this.cache,
-      );
-      instance.instanceName = instanceName
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, '')
-        .replace(' ', '');
-
-      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,
-        },
-        token,
-      );
-
-      this.logger.verbose('hash: ' + hash + ' generated');
-
-      let getEvents: string[];
-
-      if (webhook) {
-        if (!isURL(webhook, { require_tld: false })) {
-          throw new BadRequestException('Invalid "url" property in webhook');
-        }
-
-        this.logger.verbose('creating webhook');
-        try {
-          this.webhookService.create(instance, {
-            enabled: true,
-            url: webhook,
-            events,
-            webhook_by_events,
-          });
-
-          getEvents = (await this.webhookService.find(instance)).events;
-        } catch (error) {
-          this.logger.log(error);
-        }
+      if (qrcode) {
+        this.logger.verbose('creating qrcode');
+        await instance.connectToWhatsapp(number);
+        await delay(5000);
+        getQrcode = instance.qrCode;
      }

-      if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
-        let getQrcode: wa.QrCode;
-
-        if (qrcode) {
-          this.logger.verbose('creating qrcode');
-          await instance.connectToWhatsapp();
-          await delay(2000);
-          getQrcode = instance.qrCode;
-        }
-
-        this.logger.verbose('instance created');
-        this.logger.verbose({
-          instance: {
-            instanceName: instance.instanceName,
-            status: 'created',
-          },
-          hash,
-          webhook,
-          webhook_by_events,
-          events: getEvents,
-          qrcode: getQrcode,
-        });
-
-        return {
-          instance: {
-            instanceName: instance.instanceName,
-            status: 'created',
-          },
-          hash,
-          webhook,
-          webhook_by_events,
-          events: getEvents,
-          qrcode: getQrcode,
-        };
-      }
-
-      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');
-      }
-
-      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,
-        });
-
-        this.chatwootService.initInstanceChatwoot(
-          instance,
-          instance.instanceName,
-          `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-          qrcode,
-        );
-      } catch (error) {
-        this.logger.log(error);
-      }
-
-      return {
+      const result = {
        instance: {
          instanceName: instance.instanceName,
          status: 'created',
@@ -319,20 +120,78 @@ export class InstanceController {
        webhook,
        webhook_by_events,
        events: getEvents,
-        chatwoot: {
-          enabled: true,
-          account_id: chatwoot_account_id,
-          token: chatwoot_token,
-          url: chatwoot_url,
-          sign_msg: chatwoot_sign_msg || false,
-          name_inbox: instance.instanceName,
-          webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-        },
+        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');
+    }
+
+    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,
+        number,
+      });
+
+      this.chatwootService.initInstanceChatwoot(
+        instance,
+        instance.instanceName,
+        `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+        qrcode,
+        number,
+      );
+    } catch (error) {
+      this.logger.log(error);
+    }
+
+    return {
+      instance: {
+        instanceName: instance.instanceName,
+        status: 'created',
+      },
+      hash,
+      webhook,
+      webhook_by_events,
+      events: getEvents,
+      chatwoot: {
+        enabled: true,
+        account_id: chatwoot_account_id,
+        token: chatwoot_token,
+        url: chatwoot_url,
+        sign_msg: chatwoot_sign_msg || false,
+        number,
+        name_inbox: instance.instanceName,
+        webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+      },
+    };
  }

-  public async connectToWhatsapp({ instanceName }: InstanceDto) {
+  public async connectToWhatsapp({ instanceName, number = null }: InstanceDto) {
    try {
      this.logger.verbose(
        'requested connectToWhatsapp from ' + instanceName + ' instance',
@@ -343,17 +202,29 @@ export class InstanceController {

      this.logger.verbose('state: ' + state);

-      switch (state) {
-        case 'close':
-          this.logger.verbose('connecting');
-          await instance.connectToWhatsapp();
-          await delay(2000);
-          return instance.qrCode;
-        case 'connecting':
-          return instance.qrCode;
-        default:
-          return await this.connectionState({ instanceName });
+      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);
+
+        await delay(5000);
+        return instance.qrCode;
+      }
+
+      return {
+        instance: {
+          instanceName: instanceName,
+          status: state,
+        },
+        qrcode: instance?.qrCode,
+      };
    } catch (error) {
      this.logger.error(error);
    }
@@ -374,7 +245,12 @@ export class InstanceController {

  public async connectionState({ instanceName }: InstanceDto) {
    this.logger.verbose('requested connectionState from ' + instanceName + ' instance');
-    return this.waMonitor.waInstances[instanceName]?.connectionStatus;
+    return {
+      instance: {
+        instanceName: instanceName,
+        state: this.waMonitor.waInstances[instanceName]?.connectionStatus?.state,
+      },
+    };
  }

  public async fetchInstances({ instanceName }: InstanceDto) {
@@ -389,9 +265,9 @@ export class InstanceController {

  public async logout({ instanceName }: InstanceDto) {
    this.logger.verbose('requested logout from ' + instanceName + ' instance');
-    const stateConn = await this.connectionState({ instanceName });
+    const { instance } = await this.connectionState({ instanceName });

-    if (stateConn.state === 'close') {
+    if (instance.state === 'close') {
      throw new BadRequestException(
        'The "' + instanceName + '" instance is not connected',
      );
@@ -414,15 +290,15 @@ export class InstanceController {

  public async deleteInstance({ instanceName }: InstanceDto) {
    this.logger.verbose('requested deleteInstance from ' + instanceName + ' instance');
-    const stateConn = await this.connectionState({ instanceName });
+    const { instance } = await this.connectionState({ instanceName });

-    if (stateConn.state === 'open') {
+    if (instance.state === 'open') {
      throw new BadRequestException(
        'The "' + instanceName + '" instance needs to be disconnected',
      );
    }
    try {
-      if (stateConn.state === 'connecting') {
+      if (instance.state === 'connecting') {
        this.logger.verbose('logging out instance: ' + instanceName);

        await this.logout({ instanceName });
--- a/src/whatsapp/controllers/settings.controller.ts
+++ b/src/whatsapp/controllers/settings.controller.ts
@@ -0,0 +1,29 @@
+import { isURL } from 'class-validator';
+import { BadRequestException } from '../../exceptions';
+import { InstanceDto } from '../dto/instance.dto';
+import { SettingsDto } from '../dto/settings.dto';
+import { SettingsService } from '../services/settings.service';
+import { Logger } from '../../config/logger.config';
+
+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',
+    );
+
+    if (data.reject_call && data.msg_call.trim() == '') {
+      throw new BadRequestException('msg_call is required');
+    }
+
+    return this.settingsService.create(instance, data);
+  }
+
+  public async findSettings(instance: InstanceDto) {
+    logger.verbose('requested findSettings from ' + instance.instanceName + ' instance');
+    return this.settingsService.find(instance);
+  }
+}
--- a/src/whatsapp/dto/chat.dto.ts
+++ b/src/whatsapp/dto/chat.dto.ts
@@ -26,6 +26,19 @@ export class NumberDto {
  number: string;
 }

+export class NumberBusiness {
+  wid?: string;
+  jid?: string;
+  exists?: boolean;
+  isBusiness: boolean;
+  name?: string;
+  message?: string;
+  description?: string;
+  email?: string;
+  website?: string[];
+  address?: string;
+}
+
 export class ProfileNameDto {
  name: string;
 }
--- a/src/whatsapp/dto/chatwoot.dto.ts
+++ b/src/whatsapp/dto/chatwoot.dto.ts
@@ -5,4 +5,5 @@ export class ChatwootDto {
  url?: string;
  name_inbox?: string;
  sign_msg?: boolean;
+  number?: string;
 }
--- a/src/whatsapp/dto/instance.dto.ts
+++ b/src/whatsapp/dto/instance.dto.ts
@@ -4,6 +4,7 @@ export class InstanceDto {
  webhook_by_events?: boolean;
  events?: string[];
  qrcode?: boolean;
+  number?: string;
  token?: string;
  chatwoot_account_id?: string;
  chatwoot_token?: string;
--- a/src/whatsapp/dto/sendMessage.dto.ts
+++ b/src/whatsapp/dto/sendMessage.dto.ts
@@ -15,6 +15,8 @@ export class Options {
  presence?: WAPresence;
  quoted?: Quoted;
  mentions?: Mentions;
+  linkPreview?: boolean;
+  encoding?: boolean;
 }
 class OptionsMessage {
  options: Options;
--- a/src/whatsapp/dto/settings.dto.ts
+++ b/src/whatsapp/dto/settings.dto.ts
@@ -0,0 +1,5 @@
+export class SettingsDto {
+  reject_call?: boolean;
+  msg_call?: string;
+  groups_ignore?: boolean;
+}
--- a/src/whatsapp/models/chatwoot.model.ts
+++ b/src/whatsapp/models/chatwoot.model.ts
@@ -9,6 +9,7 @@ export class ChatwootRaw {
  url?: string;
  name_inbox?: string;
  sign_msg?: boolean;
+  number?: string;
 }

 const chatwootSchema = new Schema<ChatwootRaw>({
@@ -19,6 +20,7 @@ const chatwootSchema = new Schema<ChatwootRaw>({
  url: { type: String, required: true },
  name_inbox: { type: String, required: true },
  sign_msg: { type: Boolean, required: true },
+  number: { type: String, required: true },
 });

 export const ChatwootModel = dbserver?.model(
--- a/src/whatsapp/models/index.ts
+++ b/src/whatsapp/models/index.ts
@@ -4,3 +4,4 @@ export * from './message.model';
 export * from './auth.model';
 export * from './webhook.model';
 export * from './chatwoot.model';
+export * from './settings.model';
--- a/src/whatsapp/models/settings.model.ts
+++ b/src/whatsapp/models/settings.model.ts
@@ -0,0 +1,23 @@
+import { Schema } from 'mongoose';
+import { dbserver } from '../../db/db.connect';
+
+export class SettingsRaw {
+  _id?: string;
+  reject_call?: boolean;
+  msg_call?: string;
+  groups_ignore?: boolean;
+}
+
+const settingsSchema = new Schema<SettingsRaw>({
+  _id: { type: String, _id: true },
+  reject_call: { type: Boolean, required: true },
+  msg_call: { type: String, required: true },
+  groups_ignore: { type: Boolean, required: true },
+});
+
+export const SettingsModel = dbserver?.model(
+  SettingsRaw.name,
+  settingsSchema,
+  'settings',
+);
+export type ISettingsModel = typeof SettingsModel;
--- a/src/whatsapp/repository/auth.repository.ts
+++ b/src/whatsapp/repository/auth.repository.ts
@@ -1,5 +1,5 @@
 import { join } from 'path';
-import { Auth, ConfigService } from '../../config/env.config';
+import { Auth, ConfigService, Database } from '../../config/env.config';
 import { IInsert, Repository } from '../abstract/abstract.repository';
 import { IAuthModel, AuthRaw } from '../models';
 import { readFileSync } from 'fs';
--- a/src/whatsapp/repository/repository.manager.ts
+++ b/src/whatsapp/repository/repository.manager.ts
@@ -5,10 +5,10 @@ import { MessageUpRepository } from './messageUp.repository';
 import { MongoClient } from 'mongodb';
 import { WebhookRepository } from './webhook.repository';
 import { ChatwootRepository } from './chatwoot.repository';
+import { SettingsRepository } from './settings.repository';

 import { AuthRepository } from './auth.repository';
 import { Auth, ConfigService, Database } from '../../config/env.config';
-import { execSync } from 'child_process';
 import { join } from 'path';
 import fs from 'fs';
 import { Logger } from '../../config/logger.config';
@@ -20,6 +20,7 @@ export class RepositoryBroker {
    public readonly messageUpdate: MessageUpRepository,
    public readonly webhook: WebhookRepository,
    public readonly chatwoot: ChatwootRepository,
+    public readonly settings: SettingsRepository,
    public readonly auth: AuthRepository,
    private configService: ConfigService,
    dbServer?: MongoClient,
@@ -53,9 +54,9 @@ export class RepositoryBroker {
        const messageUpDir = join(storePath, 'message-up');
        const webhookDir = join(storePath, 'webhook');
        const chatwootDir = join(storePath, 'chatwoot');
+        const settingsDir = join(storePath, 'settings');
        const tempDir = join(storePath, 'temp');

-        // Check if directories exist, create them if not
        if (!fs.existsSync(authDir)) {
          this.logger.verbose('creating auth dir: ' + authDir);
          fs.mkdirSync(authDir, { recursive: true });
@@ -84,6 +85,10 @@ export class RepositoryBroker {
          this.logger.verbose('creating chatwoot dir: ' + chatwootDir);
          fs.mkdirSync(chatwootDir, { recursive: true });
        }
+        if (!fs.existsSync(settingsDir)) {
+          this.logger.verbose('creating settings dir: ' + settingsDir);
+          fs.mkdirSync(settingsDir, { recursive: true });
+        }
        if (!fs.existsSync(tempDir)) {
          this.logger.verbose('creating temp dir: ' + tempDir);
          fs.mkdirSync(tempDir, { recursive: true });
@@ -91,6 +96,21 @@ export class RepositoryBroker {
      } catch (error) {
        this.logger.error(error);
      }
+    } else {
+      const storePath = join(process.cwd(), 'store');
+
+      this.logger.verbose('creating store path: ' + storePath);
+
+      const tempDir = join(storePath, 'temp');
+
+      if (!fs.existsSync(tempDir)) {
+        this.logger.verbose('creating temp dir: ' + tempDir);
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+      try {
+      } catch (error) {
+        this.logger.error(error);
+      }
    }
  }
 }
--- a/src/whatsapp/repository/settings.repository.ts
+++ b/src/whatsapp/repository/settings.repository.ts
@@ -0,0 +1,75 @@
+import { IInsert, Repository } from '../abstract/abstract.repository';
+import { ConfigService } from '../../config/env.config';
+import { join } from 'path';
+import { readFileSync } from 'fs';
+import { ISettingsModel, SettingsRaw } from '../models';
+import { Logger } from '../../config/logger.config';
+
+export class SettingsRepository extends Repository {
+  constructor(
+    private readonly settingsModel: ISettingsModel,
+    private readonly configService: ConfigService,
+  ) {
+    super(configService);
+  }
+
+  private readonly logger = new Logger('SettingsRepository');
+
+  public async create(data: SettingsRaw, instance: string): Promise<IInsert> {
+    try {
+      this.logger.verbose('creating settings');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('saving settings to db');
+        const insert = await this.settingsModel.replaceOne(
+          { _id: instance },
+          { ...data },
+          { upsert: true },
+        );
+
+        this.logger.verbose(
+          'settings saved to db: ' + insert.modifiedCount + ' settings',
+        );
+        return { insertCount: insert.modifiedCount };
+      }
+
+      this.logger.verbose('saving settings to store');
+
+      this.writeStore<SettingsRaw>({
+        path: join(this.storePath, 'settings'),
+        fileName: instance,
+        data,
+      });
+
+      this.logger.verbose(
+        'settings saved to store in path: ' +
+          join(this.storePath, 'settings') +
+          '/' +
+          instance,
+      );
+
+      this.logger.verbose('settings created');
+      return { insertCount: 1 };
+    } catch (error) {
+      return error;
+    }
+  }
+
+  public async find(instance: string): Promise<SettingsRaw> {
+    try {
+      this.logger.verbose('finding settings');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('finding settings in db');
+        return await this.settingsModel.findOne({ _id: instance });
+      }
+
+      this.logger.verbose('finding settings in store');
+      return JSON.parse(
+        readFileSync(join(this.storePath, 'settings', instance + '.json'), {
+          encoding: 'utf-8',
+        }),
+      ) as SettingsRaw;
+    } catch (error) {
+      return {};
+    }
+  }
+}
--- a/src/whatsapp/routers/chat.router.ts
+++ b/src/whatsapp/routers/chat.router.ts
@@ -8,6 +8,7 @@ import {
  privacySettingsSchema,
  profileNameSchema,
  profilePictureSchema,
+  profileSchema,
  profileStatusSchema,
  readMessageSchema,
  whatsappNumberSchema,
@@ -129,6 +130,23 @@ export class ChatRouter extends RouterBroker {

        return res.status(HttpStatus.OK).json(response);
      })
+      .post(this.routerPath('fetchProfile'), ...guards, async (req, res) => {
+        logger.verbose('request received in fetchProfile');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+
+        const response = await this.dataValidate<NumberDto>({
+          request: req,
+          schema: profileSchema,
+          ClassRef: NumberDto,
+          execute: (instance, data) => chatController.fetchProfile(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
      .post(this.routerPath('findContacts'), ...guards, async (req, res) => {
        logger.verbose('request received in findContacts');
        logger.verbose('request body: ');
--- a/src/whatsapp/routers/index.router.ts
+++ b/src/whatsapp/routers/index.router.ts
@@ -10,6 +10,7 @@ import { ViewsRouter } from './view.router';
 import { WebhookRouter } from './webhook.router';
 import { ChatwootRouter } from './chatwoot.router';
 import fs from 'fs';
+import { SettingsRouter } from './settings.router';

 enum HttpStatus {
  OK = 200,
@@ -44,6 +45,7 @@ router
  .use('/chat', new ChatRouter(...guards).router)
  .use('/group', new GroupRouter(...guards).router)
  .use('/webhook', new WebhookRouter(...guards).router)
-  .use('/chatwoot', new ChatwootRouter(...guards).router);
+  .use('/chatwoot', new ChatwootRouter(...guards).router)
+  .use('/settings', new SettingsRouter(...guards).router);

 export { router, HttpStatus };
--- a/src/whatsapp/routers/settings.router.ts
+++ b/src/whatsapp/routers/settings.router.ts
@@ -0,0 +1,52 @@
+import { RequestHandler, Router } from 'express';
+import { instanceNameSchema, settingsSchema } from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import { InstanceDto } from '../dto/instance.dto';
+import { SettingsDto } from '../dto/settings.dto';
+import { settingsController } from '../whatsapp.module';
+import { SettingsService } from '../services/settings.service';
+import { HttpStatus } from './index.router';
+import { Logger } from '../../config/logger.config';
+
+const logger = new Logger('SettingsRouter');
+
+export class SettingsRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        logger.verbose('request received in setSettings');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<SettingsDto>({
+          request: req,
+          schema: settingsSchema,
+          ClassRef: SettingsDto,
+          execute: (instance, data) => settingsController.createSettings(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        logger.verbose('request received in findSettings');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => settingsController.findSettings(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}
--- a/src/whatsapp/services/chatwoot.service.ts
+++ b/src/whatsapp/services/chatwoot.service.ts
@@ -154,6 +154,7 @@ export class ChatwootService {
    inboxName: string,
    webhookUrl: string,
    qrcode: boolean,
+    number: string,
  ) {
    this.logger.verbose('init instance chatwoot: ' + instance.instanceName);

@@ -243,11 +244,18 @@ export class ChatwootService {
      }

      this.logger.verbose('create message for init instance in chatwoot');
+
+      let contentMsg = '/init';
+
+      if (number) {
+        contentMsg = `/init:${number}`;
+      }
+
      const message = await client.messages.create({
        accountId: this.provider.account_id,
        conversationId: conversation.id,
        data: {
-          content: '/init',
+          content: contentMsg,
          message_type: 'outgoing',
        },
      });
@@ -428,10 +436,12 @@ export class ChatwootService {
        );

        if (findParticipant) {
-          await this.updateContact(instance, findParticipant.id, {
-            name: body.pushName,
-            avatar_url: picture_url.profilePictureUrl || null,
-          });
+          if (!findParticipant.name || findParticipant.name === chatId) {
+            await this.updateContact(instance, findParticipant.id, {
+              name: body.pushName,
+              avatar_url: picture_url.profilePictureUrl || null,
+            });
+          }
        } else {
          await this.createContact(
            instance,
@@ -454,13 +464,28 @@ export class ChatwootService {

      let contact: any;
      if (body.key.fromMe) {
-        contact = findContact;
+        if (findContact) {
+          contact = findContact;
+        } else {
+          contact = await this.createContact(
+            instance,
+            chatId,
+            filterInbox.id,
+            isGroup,
+            nameContact,
+            picture_url.profilePictureUrl || null,
+          );
+        }
      } else {
        if (findContact) {
-          contact = await this.updateContact(instance, findContact.id, {
-            name: nameContact,
-            avatar_url: picture_url.profilePictureUrl || null,
-          });
+          if (!findContact.name || findContact.name === chatId) {
+            contact = await this.updateContact(instance, findContact.id, {
+              name: nameContact,
+              avatar_url: picture_url.profilePictureUrl || null,
+            });
+          } else {
+            contact = findContact;
+          }
        } else {
          contact = await this.createContact(
            instance,
@@ -936,13 +961,14 @@ export class ChatwootService {

        const command = messageReceived.replace('/', '');

-        if (command === 'init' || command === 'iniciar') {
+        if (command.includes('init') || command.includes('iniciar')) {
          this.logger.verbose('command init found');
          const state = waInstance?.connectionStatus?.state;

          if (state !== 'open') {
            this.logger.verbose('connect to whatsapp');
-            await waInstance.connectToWhatsapp();
+            const number = command.split(':')[1];
+            await waInstance.connectToWhatsapp(number);
          } else {
            this.logger.verbose('whatsapp already connected');
            await this.createBotMessage(
@@ -990,7 +1016,7 @@ export class ChatwootService {
          await waInstance?.client?.ws?.close();
        }

-        if (command.includes('#inbox_whatsapp')) {
+        if (command.includes('new_instance')) {
          const urlServer = this.configService.get<HttpServer>('SERVER').URL;
          const apiKey = this.configService.get('AUTHENTICATION').API_KEY.KEY;

@@ -1003,6 +1029,10 @@ export class ChatwootService {
            chatwoot_sign_msg: this.provider.sign_msg,
          };

+          if (command.split(':')[2]) {
+            data['number'] = command.split(':')[2];
+          }
+
          const config = {
            method: 'post',
            maxBodyLength: Infinity,
@@ -1094,11 +1124,7 @@ export class ChatwootService {
        }
      }

-      if (
-        body.message_type === 'template' &&
-        body.content_type === 'input_csat' &&
-        body.event === 'message_created'
-      ) {
+      if (body.message_type === 'template' && body.event === 'message_created') {
        this.logger.verbose('check if is csat');

        const data: SendTextDto = {
@@ -1173,6 +1199,10 @@ export class ChatwootService {

    const result = typeKey ? types[typeKey] : undefined;

+    if (typeKey === 'stickerMessage') {
+      return null;
+    }
+
    if (typeKey === 'contactMessage') {
      const vCardData = result.split('\n');
      const contactInfo = {};
@@ -1276,6 +1306,16 @@ export class ChatwootService {
          return;
        }

+        this.logger.verbose('get conversation message');
+        const bodyMessage = await this.getConversationMessage(body.message);
+
+        const isMedia = this.isMediaMessage(body.message);
+
+        if (!bodyMessage && !isMedia) {
+          this.logger.warn('no body message found');
+          return;
+        }
+
        this.logger.verbose('get conversation in chatwoot');
        const getConversion = await this.createConversation(instance, body);

@@ -1288,18 +1328,8 @@ export class ChatwootService {

        this.logger.verbose('message type: ' + messageType);

-        const isMedia = this.isMediaMessage(body.message);
-
        this.logger.verbose('is media: ' + isMedia);

-        this.logger.verbose('get conversation message');
-        const bodyMessage = await this.getConversationMessage(body.message);
-
-        if (!bodyMessage && !isMedia) {
-          this.logger.warn('no body message found');
-          return;
-        }
-
        this.logger.verbose('check if is media');
        if (isMedia) {
          this.logger.verbose('message is media');
@@ -1539,7 +1569,16 @@ export class ChatwootService {
            fileName,
          );

-          const msgQrCode = `⚡️ QRCode successfully generated!\n\nScan this QR code within the next 40 seconds:`;
+          let msgQrCode = `⚡️ QRCode successfully generated!\n\nScan this QR code within the next 40 seconds.`;
+
+          if (body?.qrcode?.pairingCode) {
+            msgQrCode =
+              msgQrCode +
+              `\n\n*Pairing Code:* ${body.qrcode.pairingCode.substring(
+                0,
+                4,
+              )}-${body.qrcode.pairingCode.substring(4, 8)}`;
+          }

          this.logger.verbose('send message to chatwoot');
          await this.createBotMessage(instance, msgQrCode, 'incoming');
@@ -1549,4 +1588,49 @@ export class ChatwootService {
      this.logger.error(error);
    }
  }
+
+  public async newInstance(data: any) {
+    try {
+      const instanceName = data.instanceName;
+      const qrcode = true;
+      const number = data.number;
+      const accountId = data.accountId;
+      const chatwootToken = data.token;
+      const chatwootUrl = data.url;
+      const signMsg = true;
+      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+      const apiKey = this.configService.get('AUTHENTICATION').API_KEY.KEY;
+
+      const requestData = {
+        instanceName,
+        qrcode,
+        chatwoot_account_id: accountId,
+        chatwoot_token: chatwootToken,
+        chatwoot_url: chatwootUrl,
+        chatwoot_sign_msg: signMsg,
+      };
+
+      if (number) {
+        requestData['number'] = number;
+      }
+
+      const config = {
+        method: 'post',
+        maxBodyLength: Infinity,
+        url: `${urlServer}/instance/create`,
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: apiKey,
+        },
+        data: requestData,
+      };
+
+      // await axios.request(config);
+
+      return true;
+    } catch (error) {
+      this.logger.error(error);
+      return null;
+    }
+  }
 }
--- a/src/whatsapp/services/monitor.service.ts
+++ b/src/whatsapp/services/monitor.service.ts
@@ -15,9 +15,19 @@ import {
 import { RepositoryBroker } from '../repository/repository.manager';
 import { NotFoundException } from '../../exceptions';
 import { Db } from 'mongodb';
-import { initInstance } from '../whatsapp.module';
 import { RedisCache } from '../../db/redis.client';
 import { execSync } from 'child_process';
+import { dbserver } from '../../db/db.connect';
+import mongoose from 'mongoose';
+import {
+  AuthModel,
+  ChatwootModel,
+  ContactModel,
+  MessageModel,
+  MessageUpModel,
+  SettingsModel,
+  WebhookModel,
+} from '../models';

 export class WAMonitoringService {
  constructor(
@@ -45,6 +55,8 @@ export class WAMonitoringService {

  private dbInstance: Db;

+  private dbStore = dbserver;
+
  private readonly logger = new Logger(WAMonitoringService.name);
  public readonly waInstances: Record<string, WAStartupService> = {};

@@ -90,7 +102,7 @@ export class WAMonitoringService {

        const findChatwoot = await this.waInstances[key].findChatwoot();

-        if (findChatwoot.enabled) {
+        if (findChatwoot && findChatwoot.enabled) {
          chatwoot = {
            ...findChatwoot,
            webhook_url: `${urlServer}/chatwoot/webhook/${key}`,
@@ -218,11 +230,8 @@ export class WAMonitoringService {
  }

  public async cleaningStoreFiles(instanceName: string) {
-    this.logger.verbose('cleaning store files instance: ' + instanceName);
-
    if (!this.db.ENABLED) {
-      const instance = this.waInstances[instanceName];
-
+      this.logger.verbose('cleaning store files instance: ' + instanceName);
      rmSync(join(INSTANCE_DIR, instanceName), { recursive: true, force: true });

      execSync(`rm -rf ${join(STORE_DIR, 'chats', instanceName)}`);
@@ -233,7 +242,23 @@ export class WAMonitoringService {
      execSync(`rm -rf ${join(STORE_DIR, 'auth', 'apikey', instanceName + '.json')}`);
      execSync(`rm -rf ${join(STORE_DIR, 'webhook', instanceName + '.json')}`);
      execSync(`rm -rf ${join(STORE_DIR, 'chatwoot', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'settings', instanceName + '*')}`);
+
+      return;
    }
+
+    this.logger.verbose('cleaning store database instance: ' + instanceName);
+
+    await AuthModel.deleteMany({ owner: instanceName });
+    await ContactModel.deleteMany({ owner: instanceName });
+    await MessageModel.deleteMany({ owner: instanceName });
+    await MessageUpModel.deleteMany({ owner: instanceName });
+    await AuthModel.deleteMany({ _id: instanceName });
+    await WebhookModel.deleteMany({ _id: instanceName });
+    await ChatwootModel.deleteMany({ _id: instanceName });
+    await SettingsModel.deleteMany({ _id: instanceName });
+
+    return;
  }

  public async loadInstance() {
@@ -264,7 +289,6 @@ export class WAMonitoringService {
          keys.forEach(async (k) => await set(k.split(':')[1]));
        } else {
          this.logger.verbose('no instance keys found');
-          initInstance();
        }
        return;
      }
@@ -280,7 +304,6 @@ export class WAMonitoringService {
          );
        } else {
          this.logger.verbose('no collections found');
-          initInstance();
        }
        return;
      }
@@ -301,7 +324,6 @@ export class WAMonitoringService {
          await set(dirent.name);
        } else {
          this.logger.verbose('no instance files found');
-          initInstance();
        }
      }
    } catch (error) {
--- a/src/whatsapp/services/settings.service.ts
+++ b/src/whatsapp/services/settings.service.ts
@@ -0,0 +1,34 @@
+import { InstanceDto } from '../dto/instance.dto';
+import { SettingsDto } from '../dto/settings.dto';
+import { WAMonitoringService } from './monitor.service';
+import { Logger } from '../../config/logger.config';
+
+export class SettingsService {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  private readonly logger = new Logger(SettingsService.name);
+
+  public create(instance: InstanceDto, data: SettingsDto) {
+    this.logger.verbose('create settings: ' + instance.instanceName);
+    this.waMonitor.waInstances[instance.instanceName].setSettings(data);
+
+    return { settings: { ...instance, settings: data } };
+  }
+
+  public async find(instance: InstanceDto): Promise<SettingsDto> {
+    try {
+      this.logger.verbose('find settings: ' + instance.instanceName);
+      const result = await this.waMonitor.waInstances[
+        instance.instanceName
+      ].findSettings();
+
+      if (Object.keys(result).length === 0) {
+        throw new Error('Settings not found');
+      }
+
+      return result;
+    } catch (error) {
+      return { reject_call: false, msg_call: '', groups_ignore: false };
+    }
+  }
+}
--- a/src/whatsapp/services/whatsapp.service.ts
+++ b/src/whatsapp/services/whatsapp.service.ts
@@ -84,6 +84,7 @@ import { arrayUnique, isBase64, isURL } from 'class-validator';
 import {
  ArchiveChatDto,
  DeleteMessage,
+  NumberBusiness,
  OnWhatsAppDto,
  PrivacySettingDto,
  ReadMessageDto,
@@ -124,6 +125,7 @@ import { Log } from '../../config/env.config';
 import ProxyAgent from 'proxy-agent';
 import { ChatwootService } from './chatwoot.service';
 import { waMonitor } from '../whatsapp.module';
+import { SettingsRaw } from '../models';

 export class WAStartupService {
  constructor(
@@ -142,6 +144,7 @@ export class WAStartupService {
  public client: WASocket;
  private readonly localWebhook: wa.LocalWebHook = {};
  private readonly localChatwoot: wa.LocalChatwoot = {};
+  private readonly localSettings: wa.LocalSettings = {};
  private stateConnection: wa.StateConnection = { state: 'close' };
  public readonly storePath = join(ROOT_DIR, 'store');
  private readonly msgRetryCounterCache: CacheStore = new NodeCache();
@@ -149,6 +152,8 @@ export class WAStartupService {
  private endSession = false;
  private logBaileys = this.configService.get<Log>('LOG').BAILEYS;

+  private phoneNumber: string;
+
  private chatwootService = new ChatwootService(waMonitor, this.configService);

  public set instanceName(name: string) {
@@ -238,6 +243,12 @@ export class WAStartupService {

  public get qrCode(): wa.QrCode {
    this.logger.verbose('Getting qrcode');
+    if (this.instance.qrcode?.pairingCode) {
+      return {
+        pairingCode: this.instance.qrcode?.pairingCode,
+      };
+    }
+
    return {
      code: this.instance.qrcode?.code,
      base64: this.instance.qrcode?.base64,
@@ -328,7 +339,7 @@ export class WAStartupService {

    if (!data) {
      this.logger.verbose('Chatwoot not found');
-      throw new NotFoundException('Chatwoot not found');
+      return null;
    }

    this.logger.verbose(`Chatwoot account id: ${data.account_id}`);
@@ -340,22 +351,61 @@ export class WAStartupService {
    return data;
  }

+  private async loadSettings() {
+    this.logger.verbose('Loading settings');
+    const data = await this.repository.settings.find(this.instanceName);
+    this.localSettings.reject_call = data?.reject_call;
+    this.logger.verbose(`Settings reject_call: ${this.localSettings.reject_call}`);
+
+    this.localSettings.msg_call = data?.msg_call;
+    this.logger.verbose(`Settings msg_call: ${this.localSettings.msg_call}`);
+
+    this.localSettings.groups_ignore = data?.groups_ignore;
+    this.logger.verbose(`Settings groups_ignore: ${this.localSettings.groups_ignore}`);
+
+    this.logger.verbose('Settings loaded');
+  }
+
+  public async setSettings(data: SettingsRaw) {
+    this.logger.verbose('Setting settings');
+    await this.repository.settings.create(data, this.instanceName);
+    this.logger.verbose(`Settings reject_call: ${data.reject_call}`);
+    this.logger.verbose(`Settings msg_call: ${data.msg_call}`);
+    this.logger.verbose(`Settings groups_ignore: ${data.groups_ignore}`);
+    Object.assign(this.localSettings, data);
+    this.logger.verbose('Settings set');
+  }
+
+  public async findSettings() {
+    this.logger.verbose('Finding settings');
+    const data = await this.repository.settings.find(this.instanceName);
+
+    if (!data) {
+      this.logger.verbose('Settings not found');
+      throw new NotFoundException('Settings not found');
+    }
+
+    this.logger.verbose(`Settings url: ${data.reject_call}`);
+    this.logger.verbose(`Settings msg_call: ${data.msg_call}`);
+    this.logger.verbose(`Settings groups_ignore: ${data.groups_ignore}`);
+    return data;
+  }
+
  public async sendDataWebhook<T = any>(event: Events, data: T, local = true) {
    const webhookGlobal = this.configService.get<Webhook>('WEBHOOK');
    const webhookLocal = this.localWebhook.events;
    const serverUrl = this.configService.get<HttpServer>('SERVER').URL;
    const we = event.replace(/[\.-]/gm, '_').toUpperCase();
    const transformedWe = we.replace(/_/gm, '-').toLowerCase();
-    const instance = this.configService.get<Auth>('AUTHENTICATION').INSTANCE;

    const expose =
      this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES;
    const tokenStore = await this.repository.auth.find(this.instanceName);
-    const instanceApikey = tokenStore.apikey || 'Apikey not found';
+    const instanceApikey = tokenStore?.apikey || 'Apikey not found';

    const globalApiKey = this.configService.get<Auth>('AUTHENTICATION').API_KEY.KEY;

-    if (local && instance.MODE !== 'container') {
+    if (local) {
      if (Array.isArray(webhookLocal) && webhookLocal.includes(we)) {
        this.logger.verbose('Sending data to webhook local');
        let baseURL;
@@ -432,13 +482,7 @@ export class WAStartupService {
          globalURL = globalWebhook.URL;
        }

-        let localUrl;
-
-        if (instance.MODE === 'container') {
-          localUrl = instance.WEBHOOK_URL;
-        } else {
-          localUrl = this.localWebhook.url;
-        }
+        const localUrl = this.localWebhook.url;

        if (this.configService.get<Log>('LOG').LEVEL.includes('WEBHOOKS')) {
          const logData = {
@@ -562,6 +606,16 @@ export class WAStartupService {
        color: { light: '#ffffff', dark: '#198754' },
      };

+      console.log(this.phoneNumber);
+      if (this.phoneNumber) {
+        await delay(2000);
+        this.instance.qrcode.pairingCode = await this.client.requestPairingCode(
+          this.phoneNumber,
+        );
+      } else {
+        this.instance.qrcode.pairingCode = null;
+      }
+
      this.logger.verbose('Generating QR code');
      qrcode.toDataURL(qr, optsQrcode, (error, base64) => {
        if (error) {
@@ -573,7 +627,12 @@ export class WAStartupService {
        this.instance.qrcode.code = qr;

        this.sendDataWebhook(Events.QRCODE_UPDATED, {
-          qrcode: { instance: this.instance.name, code: qr, base64 },
+          qrcode: {
+            instance: this.instance.name,
+            pairingCode: this.instance.qrcode.pairingCode,
+            code: qr,
+            base64,
+          },
        });

        if (this.localChatwoot.enabled) {
@@ -581,7 +640,12 @@ export class WAStartupService {
            Events.QRCODE_UPDATED,
            { instanceName: this.instance.name },
            {
-              qrcode: { instance: this.instance.name, code: qr, base64 },
+              qrcode: {
+                instance: this.instance.name,
+                pairingCode: this.instance.qrcode.pairingCode,
+                code: qr,
+                base64,
+              },
            },
          );
        }
@@ -590,7 +654,7 @@ export class WAStartupService {
      this.logger.verbose('Generating QR code in terminal');
      qrcodeTerminal.generate(qr, { small: true }, (qrcode) =>
        this.logger.log(
-          `\n{ instance: ${this.instance.name}, qrcodeCount: ${this.instance.qrcode.count} }\n` +
+          `\n{ instance: ${this.instance.name} pairingCode: ${this.instance.qrcode.pairingCode}, qrcodeCount: ${this.instance.qrcode.count} }\n` +
            qrcode,
        ),
      );
@@ -757,11 +821,12 @@ export class WAStartupService {
    return await useMultiFileAuthState(join(INSTANCE_DIR, this.instance.name));
  }

-  public async connectToWhatsapp(): Promise<WASocket> {
+  public async connectToWhatsapp(number?: string): Promise<WASocket> {
    this.logger.verbose('Connecting to whatsapp');
    try {
      this.loadWebhook();
      this.loadChatwoot();
+      this.loadSettings();

      this.instance.authState = await this.defineAuthState();

@@ -830,6 +895,8 @@ export class WAStartupService {

      this.logger.verbose('Socket event handler initialized');

+      this.phoneNumber = number;
+
      return this.client;
    } catch (error) {
      this.logger.error(error);
@@ -1044,13 +1111,14 @@ export class WAStartupService {
        type: MessageUpsertType;
      },
      database: Database,
+      settings: SettingsRaw,
    ) => {
      this.logger.verbose('Event received: messages.upsert');
      const received = messages[0];

      if (
        type !== 'notify' ||
-        received.message?.protocolMessage ||
+        // received.message?.protocolMessage ||
        received.message?.pollUpdateMessage
      ) {
        this.logger.verbose('message rejected');
@@ -1061,6 +1129,11 @@ export class WAStartupService {
        received.messageTimestamp = received.messageTimestamp?.toNumber();
      }

+      if (settings.groups_ignore && received.key.remoteJid.includes('@g.us')) {
+        this.logger.verbose('group ignored');
+        return;
+      }
+
      const messageRaw: MessageRaw = {
        key: received.key,
        pushName: received.pushName,
@@ -1152,7 +1225,11 @@ export class WAStartupService {
      );
    },

-    'messages.update': async (args: WAMessageUpdate[], database: Database) => {
+    'messages.update': async (
+      args: WAMessageUpdate[],
+      database: Database,
+      settings: SettingsRaw,
+    ) => {
      this.logger.verbose('Event received: messages.update');
      const status: Record<number, wa.StatusMessage> = {
        0: 'ERROR',
@@ -1163,6 +1240,10 @@ export class WAStartupService {
        5: 'PLAYED',
      };
      for await (const { key, update } of args) {
+        if (settings.groups_ignore && key.remoteJid.includes('@g.us')) {
+          this.logger.verbose('group ignored');
+          return;
+        }
        if (key.remoteJid !== 'status@broadcast' && !key?.remoteJid?.match(/(:\d+)/)) {
          this.logger.verbose('Message update is valid');

@@ -1190,6 +1271,22 @@ export class WAStartupService {

            this.logger.verbose('Sending data to webhook in event MESSAGE_DELETE');
            await this.sendDataWebhook(Events.MESSAGES_DELETE, key);
+
+            const message: MessageUpdateRaw = {
+              ...key,
+              status: 'DELETED',
+              datetime: Date.now(),
+              owner: this.instance.name,
+            };
+
+            this.logger.verbose(message);
+
+            this.logger.verbose('Inserting message in database');
+            await this.repository.messageUpdate.insert(
+              [message],
+              this.instance.name,
+              database.SAVE_DATA.MESSAGE_UPDATE,
+            );
            return;
          }

@@ -1246,9 +1343,32 @@ export class WAStartupService {

  private eventHandler() {
    this.logger.verbose('Initializing event handler');
-    this.client.ev.process((events) => {
+    this.client.ev.process(async (events) => {
      if (!this.endSession) {
        const database = this.configService.get<Database>('DATABASE');
+        const settings = await this.findSettings();
+
+        if (events.call) {
+          this.logger.verbose('Listening event: call');
+          const call = events.call[0];
+
+          if (settings?.reject_call && call.status == 'offer') {
+            this.logger.verbose('Rejecting call');
+            this.client.rejectCall(call.id, call.from);
+          }
+
+          if (settings?.msg_call.trim().length > 0 && call.status == 'offer') {
+            this.logger.verbose('Sending message in call');
+            const msg = await this.client.sendMessage(call.from, {
+              text: settings.msg_call,
+            });
+
+            this.client.ev.emit('messages.upsert', {
+              messages: [msg],
+              type: 'notify',
+            });
+          }
+        }

        if (events['connection.update']) {
          this.logger.verbose('Listening event: connection.update');
@@ -1269,37 +1389,44 @@ export class WAStartupService {
        if (events['messages.upsert']) {
          this.logger.verbose('Listening event: messages.upsert');
          const payload = events['messages.upsert'];
-          this.messageHandle['messages.upsert'](payload, database);
+          this.messageHandle['messages.upsert'](payload, database, settings);
        }

        if (events['messages.update']) {
          this.logger.verbose('Listening event: messages.update');
          const payload = events['messages.update'];
-          this.messageHandle['messages.update'](payload, database);
+          this.messageHandle['messages.update'](payload, database, settings);
        }

        if (events['presence.update']) {
          this.logger.verbose('Listening event: presence.update');
          const payload = events['presence.update'];
+
+          if (settings.groups_ignore && payload.id.includes('@g.us')) {
+            this.logger.verbose('group ignored');
+            return;
+          }
          this.sendDataWebhook(Events.PRESENCE_UPDATE, payload);
        }

-        if (events['groups.upsert']) {
-          this.logger.verbose('Listening event: groups.upsert');
-          const payload = events['groups.upsert'];
-          this.groupHandler['groups.upsert'](payload);
-        }
+        if (!settings?.groups_ignore) {
+          if (events['groups.upsert']) {
+            this.logger.verbose('Listening event: groups.upsert');
+            const payload = events['groups.upsert'];
+            this.groupHandler['groups.upsert'](payload);
+          }

-        if (events['groups.update']) {
-          this.logger.verbose('Listening event: groups.update');
-          const payload = events['groups.update'];
-          this.groupHandler['groups.update'](payload);
-        }
+          if (events['groups.update']) {
+            this.logger.verbose('Listening event: groups.update');
+            const payload = events['groups.update'];
+            this.groupHandler['groups.update'](payload);
+          }

-        if (events['group-participants.update']) {
-          this.logger.verbose('Listening event: group-participants.update');
-          const payload = events['group-participants.update'];
-          this.groupHandler['group-participants.update'](payload);
+          if (events['group-participants.update']) {
+            this.logger.verbose('Listening event: group-participants.update');
+            const payload = events['group-participants.update'];
+            this.groupHandler['group-participants.update'](payload);
+          }
        }

        if (events['chats.upsert']) {
@@ -1382,38 +1509,22 @@ export class WAStartupService {
      return number;
    }

-    const countryCode = number.substring(0, 2);
+    number = number
+      ?.replace(/\s/g, '')
+      .replace(/\+/g, '')
+      .replace(/\(/g, '')
+      .replace(/\)/g, '')
+      .split(/\:/)[0]
+      .split('@')[0];

-    if (Number(countryCode) === 55) {
-      const formattedBRNumber = this.formatBRNumber(number);
-      if (formattedBRNumber !== number) {
-        this.logger.verbose(
-          'Jid created is whatsapp in format BR: ' +
-            `${formattedBRNumber}@s.whatsapp.net`,
-        );
-        return `${formattedBRNumber}@s.whatsapp.net`;
-      }
-    }
-
-    if (Number(countryCode) === 52 || Number(countryCode) === 54) {
-      console.log('numero mexicano');
-
-      const formattedMXARNumber = this.formatMXOrARNumber(number);
-
-      if (formattedMXARNumber !== number) {
-        this.logger.verbose(
-          'Jid created is whatsapp in format MXAR: ' +
-            `${formattedMXARNumber}@s.whatsapp.net`,
-        );
-        return `${formattedMXARNumber}@s.whatsapp.net`;
-      }
-    }
-
-    if (number.includes('-')) {
+    if (number.length >= 18) {
      this.logger.verbose('Jid created is group: ' + `${number}@g.us`);
+      number = number.replace(/[^\d-]/g, '');
      return `${number}@g.us`;
    }

+    number = number.replace(/\D/g, '');
+
    this.logger.verbose('Jid created is whatsapp: ' + `${number}@s.whatsapp.net`);
    return `${number}@s.whatsapp.net`;
  }
@@ -1437,6 +1548,78 @@ export class WAStartupService {
    }
  }

+  public async getStatus(number: string) {
+    const jid = this.createJid(number);
+
+    this.logger.verbose('Getting profile status with jid:' + jid);
+    try {
+      this.logger.verbose('Getting status');
+      return {
+        wuid: jid,
+        status: (await this.client.fetchStatus(jid))?.status,
+      };
+    } catch (error) {
+      this.logger.verbose('Status not found');
+      return {
+        wuid: jid,
+        status: null,
+      };
+    }
+  }
+
+  public async fetchProfile(instanceName: string, number?: string) {
+    const jid = number ? this.createJid(number) : this.client?.user?.id;
+
+    this.logger.verbose('Getting profile with jid: ' + jid);
+    try {
+      this.logger.verbose('Getting profile info');
+      const info = await waMonitor.instanceInfo(instanceName);
+      const business = await this.fetchBusinessProfile(jid);
+
+      if (number) {
+        const info = (await this.whatsappNumber({ numbers: [jid] }))?.shift();
+        const picture = await this.profilePicture(jid);
+        const status = await this.getStatus(jid);
+
+        return {
+          wuid: jid,
+          name: info?.name,
+          numberExists: info?.exists,
+          picture: picture?.profilePictureUrl,
+          status: status?.status,
+          isBusiness: business.isBusiness,
+          email: business?.email,
+          description: business?.description,
+          website: business?.website?.shift(),
+        };
+      } else {
+        const info = await waMonitor.instanceInfo(instanceName);
+
+        return {
+          wuid: jid,
+          name: info?.instance?.profileName,
+          numberExists: true,
+          picture: info?.instance?.profilePictureUrl,
+          status: info?.instance?.profileStatus,
+          isBusiness: business.isBusiness,
+          email: business?.email,
+          description: business?.description,
+          website: business?.website?.shift(),
+        };
+      }
+    } catch (error) {
+      this.logger.verbose('Profile not found');
+      return {
+        wuid: jid,
+        name: null,
+        picture: null,
+        status: null,
+        os: null,
+        isBusiness: false,
+      };
+    }
+  }
+
  private async sendMessageWithTyping<T = proto.IMessage>(
    number: string,
    message: T,
@@ -1444,15 +1627,14 @@ export class WAStartupService {
  ) {
    this.logger.verbose('Sending message with typing');

-    const jid = this.createJid(number);
-    const numberWA = await this.whatsappNumber({ numbers: [jid] });
+    const numberWA = await this.whatsappNumber({ numbers: [number] });
    const isWA = numberWA[0];

    if (!isWA.exists && !isJidGroup(isWA.jid) && !isWA.jid.includes('@broadcast')) {
      throw new BadRequestException(isWA);
    }

-    const sender = isJidGroup(jid) ? jid : isWA.jid;
+    const sender = isWA.jid;

    try {
      if (options?.delay) {
@@ -1461,7 +1643,7 @@ export class WAStartupService {
        await this.client.presenceSubscribe(sender);
        this.logger.verbose('Subscribing to presence');

-        await this.client.sendPresenceUpdate(options?.presence ?? 'composing', jid);
+        await this.client.sendPresenceUpdate(options?.presence ?? 'composing', sender);
        this.logger.verbose(
          'Sending presence update: ' + options?.presence ?? 'composing',
        );
@@ -1473,6 +1655,8 @@ export class WAStartupService {
        this.logger.verbose('Sending presence update: paused');
      }

+      const linkPreview = options?.linkPreview != false ? undefined : false;
+
      let quoted: WAMessage;

      if (options?.quoted) {
@@ -1520,7 +1704,8 @@ export class WAStartupService {
              mentions = options.mentions.mentioned.map((mention) => {
                const jid = this.createJid(mention);
                if (isJidGroup(jid)) {
-                  throw new BadRequestException('Mentions must be a number');
+                  return null;
+                  // throw new BadRequestException('Mentions must be a number');
                }
                return jid;
              });
@@ -1566,6 +1751,7 @@ export class WAStartupService {
            {
              text: message['conversation'],
              mentions,
+              linkPreview: linkPreview,
            } as unknown as AnyMessageContent,
            option as unknown as MiscMessageGenerationOptions,
          );
@@ -1986,26 +2172,45 @@ export class WAStartupService {

  public async audioWhatsapp(data: SendAudioDto) {
    this.logger.verbose('Sending audio whatsapp');
-    const convert = await this.processAudio(data.audioMessage.audio, data.number);
-    if (typeof convert === 'string') {
-      const audio = fs.readFileSync(convert).toString('base64');
-      const result = this.sendMessageWithTyping<AnyMessageContent>(
-        data.number,
-        {
-          audio: Buffer.from(audio, 'base64'),
-          ptt: true,
-          mimetype: 'audio/mp4',
-        },
-        { presence: 'recording', delay: data?.options?.delay },
-      );

-      fs.unlinkSync(convert);
-      this.logger.verbose('Converted audio deleted');
-
-      return result;
-    } else {
-      throw new InternalServerErrorException(convert);
+    if (!data.options?.encoding && data.options?.encoding !== false) {
+      data.options.encoding = true;
    }
+
+    if (data.options?.encoding) {
+      const convert = await this.processAudio(data.audioMessage.audio, data.number);
+      if (typeof convert === 'string') {
+        const audio = fs.readFileSync(convert).toString('base64');
+        const result = this.sendMessageWithTyping<AnyMessageContent>(
+          data.number,
+          {
+            audio: Buffer.from(audio, 'base64'),
+            ptt: true,
+            mimetype: 'audio/mp4',
+          },
+          { presence: 'recording', delay: data?.options?.delay },
+        );
+
+        fs.unlinkSync(convert);
+        this.logger.verbose('Converted audio deleted');
+
+        return result;
+      } else {
+        throw new InternalServerErrorException(convert);
+      }
+    }
+
+    return await this.sendMessageWithTyping<AnyMessageContent>(
+      data.number,
+      {
+        audio: isURL(data.audioMessage.audio)
+          ? { url: data.audioMessage.audio }
+          : Buffer.from(data.audioMessage.audio, 'base64'),
+        ptt: true,
+        mimetype: 'audio/ogg; codecs=opus',
+      },
+      { presence: 'recording', delay: data?.options?.delay },
+    );
  }

  public async buttonMessage(data: SendButtonDto) {
@@ -2118,6 +2323,11 @@ export class WAStartupService {
        result += `URL:${contact.url}\n`;
      }

+      if (!contact.wuid) {
+        this.logger.verbose('Wuid defined');
+        contact.wuid = this.createJid(contact.phoneNumber);
+      }
+
      result +=
        `item1.TEL;waid=${contact.wuid}:${contact.phoneNumber}\n` +
        'item1.X-ABLabel:Celular\n' +
@@ -2163,8 +2373,8 @@ export class WAStartupService {

    const onWhatsapp: OnWhatsAppDto[] = [];
    for await (const number of data.numbers) {
-      const jid = this.createJid(number);
-      // const jid = `${number}@s.whatsapp.net`;
+      let jid = this.createJid(number);
+
      if (isJidGroup(jid)) {
        const group = await this.findGroup({ groupJid: jid }, 'inner');

@@ -2172,6 +2382,7 @@ export class WAStartupService {

        onWhatsapp.push(new OnWhatsAppDto(group.id, !!group?.id, group?.subject));
      } else {
+        jid = !jid.startsWith('+') ? `+${jid}` : jid;
        const verify = await this.client.onWhatsApp(jid);

        const result = verify[0];
@@ -2351,6 +2562,9 @@ export class WAStartupService {
    this.logger.verbose('Fetching contacts');
    if (query?.where) {
      query.where.owner = this.instance.name;
+      if (query.where?.id) {
+        query.where.id = this.createJid(query.where.id);
+      }
    } else {
      query = {
        where: {
@@ -2364,6 +2578,9 @@ export class WAStartupService {
  public async fetchMessages(query: MessageQuery) {
    this.logger.verbose('Fetching messages');
    if (query?.where) {
+      if (query.where?.key?.remoteJid) {
+        query.where.key.remoteJid = this.createJid(query.where.key.remoteJid);
+      }
      query.where.owner = this.instance.name;
    } else {
      query = {
@@ -2379,6 +2596,9 @@ export class WAStartupService {
  public async fetchStatusMessage(query: MessageUpQuery) {
    this.logger.verbose('Fetching status messages');
    if (query?.where) {
+      if (query.where?.remoteJid) {
+        query.where.remoteJid = this.createJid(query.where.remoteJid);
+      }
      query.where.owner = this.instance.name;
    } else {
      query = {
@@ -2423,8 +2643,19 @@ export class WAStartupService {
      this.logger.verbose('Groups add privacy updated');

      // reinicia a instancia
+      this.client?.ws?.close();

-      return { update: 'success', data: await this.client.fetchPrivacySettings() };
+      return {
+        update: 'success',
+        data: {
+          readreceipts: settings.privacySettings.readreceipts,
+          profile: settings.privacySettings.profile,
+          status: settings.privacySettings.status,
+          online: settings.privacySettings.online,
+          last: settings.privacySettings.last,
+          groupadd: settings.privacySettings.groupadd,
+        },
+      };
    } catch (error) {
      throw new InternalServerErrorException(
        'Error updating privacy settings',
@@ -2433,29 +2664,29 @@ export class WAStartupService {
    }
  }

-  public async fetchBusinessProfile(number: string) {
+  public async fetchBusinessProfile(number: string): Promise<NumberBusiness> {
    this.logger.verbose('Fetching business profile');
    try {
-      let jid;
-
-      if (!number) {
-        jid = this.instance.wuid;
-      } else {
-        jid = this.createJid(number);
-      }
+      const jid = number ? this.createJid(number) : this.instance.wuid;

      const profile = await this.client.getBusinessProfile(jid);
      this.logger.verbose('Trying to get business profile');

      if (!profile) {
+        const info = await this.whatsappNumber({ numbers: [jid] });
+
        return {
-          exists: false,
-          message: 'Business profile not found',
+          isBusiness: false,
+          message: 'Not is business profile',
+          ...info?.shift(),
        };
      }

      this.logger.verbose('Business profile fetched');
-      return profile;
+      return {
+        isBusiness: true,
+        ...profile,
+      };
    } catch (error) {
      throw new InternalServerErrorException(
        'Error updating profile name',
--- a/src/whatsapp/types/wa.types.ts
+++ b/src/whatsapp/types/wa.types.ts
@@ -25,9 +25,15 @@ export enum Events {
 }

 export declare namespace wa {
-  export type QrCode = { count?: number; base64?: string; code?: string };
+  export type QrCode = {
+    count?: number;
+    pairingCode?: string;
+    base64?: string;
+    code?: string;
+  };
  export type Instance = {
    qrcode?: QrCode;
+    pairingCode?: string;
    authState?: { state: AuthenticationState; saveCreds: () => void };
    name?: string;
    wuid?: string;
@@ -51,6 +57,12 @@ export declare namespace wa {
    sign_msg?: boolean;
  };

+  export type LocalSettings = {
+    reject_call?: boolean;
+    msg_call?: string;
+    groups_ignore?: boolean;
+  };
+
  export type StateConnection = {
    instance?: string;
    state?: WAConnectionState | 'refused';
@@ -63,6 +75,7 @@ export declare namespace wa {
    | 'SERVER_ACK'
    | 'DELIVERY_ACK'
    | 'READ'
+    | 'DELETED'
    | 'PLAYED';
 }

--- a/src/whatsapp/whatsapp.module.ts
+++ b/src/whatsapp/whatsapp.module.ts
@@ -25,6 +25,7 @@ import {
  MessageUpModel,
  ChatwootModel,
  WebhookModel,
+  SettingsModel,
 } from './models';
 import { dbserver } from '../db/db.connect';
 import { WebhookRepository } from './repository/webhook.repository';
@@ -34,6 +35,9 @@ import { WAStartupService } from './services/whatsapp.service';
 import { delay } from '@whiskeysockets/baileys';
 import { Events } from './types/wa.types';
 import { RedisCache } from '../db/redis.client';
+import { SettingsRepository } from './repository/settings.repository';
+import { SettingsService } from './services/settings.service';
+import { SettingsController } from './controllers/settings.controller';

 const logger = new Logger('WA MODULE');

@@ -43,6 +47,7 @@ const contactRepository = new ContactRepository(ContactModel, configService);
 const messageUpdateRepository = new MessageUpRepository(MessageUpModel, configService);
 const webhookRepository = new WebhookRepository(WebhookModel, configService);
 const chatwootRepository = new ChatwootRepository(ChatwootModel, configService);
+const settingsRepository = new SettingsRepository(SettingsModel, configService);
 const authRepository = new AuthRepository(AuthModel, configService);

 export const repository = new RepositoryBroker(
@@ -52,6 +57,7 @@ export const repository = new RepositoryBroker(
  messageUpdateRepository,
  webhookRepository,
  chatwootRepository,
+  settingsRepository,
  authRepository,
  configService,
  dbserver?.getClient(),
@@ -76,6 +82,10 @@ const chatwootService = new ChatwootService(waMonitor, configService);

 export const chatwootController = new ChatwootController(chatwootService, configService);

+const settingsService = new SettingsService(waMonitor);
+
+export const settingsController = new SettingsController(settingsService);
+
 export const instanceController = new InstanceController(
  waMonitor,
  configService,
@@ -91,111 +101,4 @@ export const sendMessageController = new SendMessageController(waMonitor);
 export const chatController = new ChatController(waMonitor);
 export const groupController = new GroupController(waMonitor);

-export async function initInstance() {
-  const instance = new WAStartupService(configService, eventEmitter, repository, cache);
-
-  const mode = configService.get<Auth>('AUTHENTICATION').INSTANCE.MODE;
-
-  logger.verbose('Sending data webhook for event: ' + Events.APPLICATION_STARTUP);
-  instance.sendDataWebhook(
-    Events.APPLICATION_STARTUP,
-    {
-      message: 'Application startup',
-      mode,
-    },
-    false,
-  );
-
-  if (mode === 'container') {
-    logger.verbose('Application startup in container mode');
-
-    const instanceName = configService.get<Auth>('AUTHENTICATION').INSTANCE.NAME;
-    logger.verbose('Instance name: ' + instanceName);
-
-    const instanceWebhook =
-      configService.get<Auth>('AUTHENTICATION').INSTANCE.WEBHOOK_URL;
-    logger.verbose('Instance webhook: ' + instanceWebhook);
-
-    // const chatwootAccountId =
-    //   configService.get<Auth>('AUTHENTICATION').INSTANCE.CHATWOOT_ACCOUNT_ID;
-    // logger.verbose('Chatwoot account id: ' + chatwootAccountId);
-
-    // const chatwootToken =
-    //   configService.get<Auth>('AUTHENTICATION').INSTANCE.CHATWOOT_TOKEN;
-    // logger.verbose('Chatwoot token: ' + chatwootToken);
-
-    // const chatwootUrl = configService.get<Auth>('AUTHENTICATION').INSTANCE.CHATWOOT_URL;
-    // logger.verbose('Chatwoot url: ' + chatwootUrl);
-
-    instance.instanceName = instanceName;
-
-    waMonitor.waInstances[instance.instanceName] = instance;
-    waMonitor.delInstanceTime(instance.instanceName);
-
-    const hash = await authService.generateHash({
-      instanceName: instance.instanceName,
-      token: configService.get<Auth>('AUTHENTICATION').API_KEY.KEY,
-    });
-    logger.verbose('Hash generated: ' + hash);
-
-    if (instanceWebhook) {
-      logger.verbose('Creating webhook for instance: ' + instanceName);
-      try {
-        webhookService.create(instance, { enabled: true, url: instanceWebhook });
-        logger.verbose('Webhook created');
-      } catch (error) {
-        logger.log(error);
-      }
-    }
-
-    // if (chatwootUrl && chatwootToken && chatwootAccountId) {
-    //   logger.verbose('Creating chatwoot for instance: ' + instanceName);
-    //   try {
-    //     chatwootService.create(instance, {
-    //       enabled: true,
-    //       url: chatwootUrl,
-    //       token: chatwootToken,
-    //       account_id: chatwootAccountId,
-    //       sign_msg: false,
-    //     });
-    //     logger.verbose('Chatwoot created');
-    //   } catch (error) {
-    //     logger.log(error);
-    //   }
-    // }
-
-    try {
-      const state = instance.connectionStatus?.state;
-
-      switch (state) {
-        case 'close':
-          await instance.connectToWhatsapp();
-          await delay(2000);
-          return instance.qrCode;
-        case 'connecting':
-          return instance.qrCode;
-        default:
-          return await this.connectionState({ instanceName });
-      }
-    } catch (error) {
-      logger.log(error);
-    }
-
-    const result = {
-      instance: {
-        instanceName: instance.instanceName,
-        status: 'created',
-      },
-      hash,
-      webhook: instanceWebhook,
-    };
-
-    logger.info(result);
-
-    return result;
-  }
-
-  return null;
-}
-
 logger.info('Module - ON');
Author	SHA1	Message	Date
Davidson Gomes	cc91f2e5db	Merge branch 'release/1.4.1'	2023-07-24 18:28:45 -03:00
Davidson Gomes	8d1f2313ac	version: 1.4.1	2023-07-24 18:28:39 -03:00
Davidson Gomes	f9abd90cc9	fix: connection state	2023-07-24 18:28:01 -03:00
Davidson Gomes	f7293255cf	fix: Fixed reconnect with pairing code or qrcode	2023-07-24 18:21:11 -03:00
Davidson Gomes	7d6a130cf9	Merge tag '1.4.0' into develop * Added connection functionality via pairing code * Added fetch profile endpoint in chat controller * Created settings controller * Added reject call and send text message when receiving a call * Added setting to ignore group messages * Added connection with pairing code in chatwoot with command /init:{NUMBER} * Added encoding option in endpoint sendWhatsAppAudio * Added link preview option in send text message * Fixed problem with fileSha256 appearing when sending a sticker in chatwoot * Fixed issue where it was not possible to open a conversation when sent at first by me on my cell phone in chatwoot * Now it only updates the contact name if it is the same as the phone number in chatwoot * Now accepts all chatwoot inbox templates * Command to create new instances set to /new_instance:{NAME}:{NUMBER} * Fix in chatwoot set, sign msg can now be disabled - Chatwoot: v2.18.0 - v3.0.0 (Beta)	2023-07-24 17:05:43 -03:00
Davidson Gomes	be7bb2e39f	Merge branch 'release/1.4.0'	2023-07-24 17:05:33 -03:00
Davidson Gomes	1c30728880	version: 1.4.0	2023-07-24 17:05:18 -03:00
Davidson Gomes	8d91e7cb1d	feat: Added encoding option in endpoint sendWhatsAppAudio	2023-07-24 16:21:29 -03:00
Davidson Gomes	68d980795a	fix: fix in chatwoot set, sign msg can now be disabled	2023-07-24 15:13:46 -03:00
Davidson Gomes	45c11a5a8e	fix: fix in chatwoot set, sign msg can now be disabled	2023-07-24 15:12:13 -03:00
Davidson Gomes	4d00351db7	fix: command to create new instances set to /new_instance:<NAME>:<NUMBER>	2023-07-24 15:05:26 -03:00
Davidson Gomes	fff420b652	fix: command to create new instances set to /new_instance:<NAME>:<NUMBER>	2023-07-24 15:05:03 -03:00
Davidson Gomes	7103a95305	feat: Added connection with pairing code in chatwoot	2023-07-24 13:43:18 -03:00
Davidson Gomes	bcada5d553	fix: Now accepts all chatwoot inbox templates	2023-07-24 13:03:40 -03:00
Davidson Gomes	c9b24ff612	fix: adjusts for chatwoot v3	2023-07-24 12:55:27 -03:00
Davidson Gomes	854c7ed04d	fix: Improvement for Validation of Numbers and Groups	2023-07-24 12:02:38 -03:00
Davidson Gomes	c0054959cd	fix: Improvement for Validation of Numbers and Groups Improvement for Validation of Numbers and Groups	2023-07-24 12:00:33 -03:00
Davidson Gomes	1aa837d220	fix: Adjusts in chatwoot integration	2023-07-24 11:58:52 -03:00
Alan Mosko	95df402c4c	wip	2023-07-24 11:57:15 -03:00
Davidson Gomes	2f3d6f7e63	fix: Fixed problem with fileSha256 appearing when sending a sticker in chatwoot	2023-07-24 11:48:10 -03:00
Alan Mosko	ffe1523170	Update whatsapp.service.ts	2023-07-24 11:42:06 -03:00
Davidson Gomes	a73d5f4b4d	Merge branch 'develop' of github.com:EvolutionAPI/evolution-api into develop	2023-07-24 11:18:12 -03:00
Davidson Gomes	f35b62ed12	fix: Adjusts in createJid	2023-07-24 11:18:08 -03:00
Davidson Gomes	20abdd2908	fix: Adjusts in createJid to sendContact Adjusts in createJid to sendContact	2023-07-24 11:17:35 -03:00
Alan Mosko	28c2c7285c	Gerar Wuid no SendContact	2023-07-24 11:15:58 -03:00
Davidson Gomes	3ca8ab12a4	fix: Adjusts in createJid Adjusts in createJid	2023-07-24 11:13:30 -03:00
Alan Mosko	fd82aa143c	wip	2023-07-24 11:10:32 -03:00
Davidson Gomes	1fcbd4f9fd	feat: Added reject call and send text message when receiving a call and Added setting to ignore group messages	2023-07-24 10:18:16 -03:00
Davidson Gomes	73d9cd62a5	feat: Created settings Controller	2023-07-24 09:42:29 -03:00
Davidson Gomes	be699d24a1	feat: Added fetch profile endpoint in chat controller and link preview option in send text message	2023-07-23 22:26:38 -03:00
Davidson Gomes	798eb90bed	feat: Added fetch profile endpoint in chat controller and link preview option in send text message	2023-07-23 22:24:21 -03:00
Davidson Gomes	c252f5f8d9	Merge pull request #20 from EvolutionAPI/revert-18-fetch-profile Revert "Adição de FetchProfile"	2023-07-23 22:05:38 -03:00
Davidson Gomes	76d77ad76f	Revert "Adição de FetchProfile"	2023-07-23 22:05:21 -03:00
Davidson Gomes	69f5cdd61a	feat: added fetchProfile endpoint in chat controller Added fetchProfile endpoint in chat controller	2023-07-23 21:30:11 -03:00
Davidson Gomes	9f52f20660	feat: Add LinkPreview Option Add LinkPreview Option	2023-07-23 21:25:20 -03:00
Alan Mosko	90048afa9d	Add LinkPreview Option	2023-07-23 11:24:16 -03:00
Alan Mosko	1ec3ed32ee	Melhorias	2023-07-23 10:18:00 -03:00
Davidson Gomes	16ed5821e2	Added connection functionality via pairing code	2023-07-21 20:58:37 -03:00
Davidson Gomes	b681e33944	Added connection functionality via pairing code	2023-07-21 20:38:10 -03:00
Davidson Gomes	8f4d44a212	Added connection functionality via pairing code	2023-07-21 20:37:58 -03:00
Davidson Gomes	93a5d07f9a	Merge tag '1.3.2' into develop * Fix in update settings that needed to restart after updated * Correction in the use of the api with mongodb * Adjustments to search endpoint for contacts, chats, messages and Status messages * Now when deleting the instance, the data referring to it in mongodb is also deleted * It is now validated if the instance name contains uppercase and special characters * For compatibility reasons, container mode has been removed * Added docker-compose files example	2023-07-21 17:20:19 -03:00
Davidson Gomes	40c230c7db	Merge branch 'release/1.3.2'	2023-07-21 17:20:08 -03:00
Davidson Gomes	d0fa3b92f8	version: 1.3.2	2023-07-21 17:19:59 -03:00
Davidson Gomes	2a7727cf5f	Merge tag '1.3.2' into develop * Fix in update settings that needed to restart after updated * Correction in the use of the api with mongodb * Adjustments to search endpoint for contacts, chats, messages and Status messages * Now when deleting the instance, the data referring to it in mongodb is also deleted * It is now validated if the instance name contains uppercase and special characters * For compatibility reasons, container mode has been removed * Added docker-compose files example	2023-07-21 17:18:50 -03:00
Davidson Gomes	98722e7acf	Merge branch 'release/1.3.2'	2023-07-21 17:18:40 -03:00
Davidson Gomes	683fe4c3db	fix: added docker-compose files example	2023-07-21 16:00:58 -03:00
Alan Mosko	e851696430	Adição de Profile Route	2023-07-21 15:32:28 -03:00
Davidson Gomes	b2ccf965bb	fix: added docker-compose files example	2023-07-21 15:14:46 -03:00
Davidson Gomes	f847f38812	fix: added docker-compose files example	2023-07-21 15:13:49 -03:00
Davidson Gomes	19039aa281	fix: For compatibility reasons, container mode has been removed	2023-07-21 13:12:55 -03:00
Davidson Gomes	091b920a22	fix: It is now validated if the instance name contains uppercase and special characters	2023-07-21 12:40:58 -03:00
Davidson Gomes	d7f264c1c2	fix: It is now validated if the instance name contains uppercase and special characters	2023-07-21 12:26:43 -03:00
Davidson Gomes	897f8164b9	fix: Now when deleting the instance, the data referring to it in mongodb is also deleted	2023-07-21 12:13:03 -03:00
Davidson Gomes	796287a776	fix: Adjustments to search endpoint for contacts, chats, messages and Status messages	2023-07-21 11:38:36 -03:00
Davidson Gomes	763e30bd1d	fix: fix in update settings that needed to restart after updated	2023-07-21 09:34:39 -03:00
Davidson Gomes	5121374d60	Merge tag '1.3.1' into develop version: 1.3.1	2023-07-21 08:26:24 -03:00