Merge branch 'release/1.4.2'

Group validation

.gitignore

@@ -16,6 +16,8 @@ lerna-debug.log*
 /docker-compose-data
 /docker-data
 
+docker-compose.yaml
+
 # Package
 /yarn.lock
 /package-lock.json

CHANGELOG.md

@@ -1,4 +1,119 @@
-# 1.2.1 (homolog)
+# 1.4.2 (2023-07-24 20:52)
+
+### Fixed
+
+* Fixed validation is set settings 
+* Adjusts in group validations
+* Ajusts in sticker message to chatwoot
+
+# 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}
+* Change Baileys version to: 6.4.0
+* Send contact in chatwoot
+* Send contact array in chatwoot
+* Added apiKey in webhook and serverUrl in fetchInstance if EXPOSE_IN_FETCH_INSTANCES: true
+* Translation set to default (english) in chatwoot
+
+### Fixed
+ 
+* Fixed error to send message in large groups
+* Docker files adjusted
+* Fixed in the postman collection the webhookByEvent parameter by webhook_by_events
+* Added validations in create instance
+* Removed link preview endpoint, now it's done automatically from sending conventional text
+* Added group membership validation before sending message to groups
+* Adjusts in docker files
+* Adjusts in returns in endpoints chatwoot and webhook
+* Fixed ghost mentions in send text message
+* Fixed bug that saved contacts from groups came without number in chatwoot
+* Fixed problem to receive csat in chatwoot
+* Fixed require fileName for document only in base64 for send media message
+* Bug fix when sending mobile message change contact name to number in chatwoot
+* Bug fix when connecting whatsapp does not send confirmation message
+* Fixed quoted message with id or message directly
+* Adjust in validation for mexican and argentine numbers
+* Adjust in create store files
+
+### Integrations
+
+- Chatwoot: v2.18.0
+
+# 1.2.2 (2023-07-15 09:36)
+
+### Fixed
+
+* Tweak in route "/" with version info
+* Adjusts chatwoot version
+
+### Integrations
+
+- Chatwoot: v2.18.0
+
+# 1.2.1 (2023-07-14 19:04)
 
 ### Fixed
 

Docker/.env.example

@@ -1,13 +1,16 @@
-SERVER_URL='<url>' # ex.: http://localhost:3333
+# Server URL - Set your application url
+SERVER_URL=http://localhost:8080
 
-CORS_ORIGIN='*' # Or separate by commas -  ex.: 'yourdomain1.com, yourdomain2.com'
+# Cors - * for all or set separate by commas -  ex.: 'yourdomain1.com, yourdomain2.com'
-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=error # "fatal" | "error" | "warn" | "info" | "debug" | "trace"
+# Log Baileys - "fatal" | "error" | "warn" | "info" | "debug" | "trace"
+LOG_BAILEYS=error
 
 # Determine how long the instance should be deleted from memory in case of no connection.
 # Default time: 5 minutes
@@ -20,16 +23,17 @@ STORE_MESSAGE_UP=true
 STORE_CONTACTS=true
 STORE_CHATS=true
 
-CLEAN_STORE_CLEANING_INTERVAL=7200 # seconds === 2h
+# Set Store Interval in Seconds (7200 = 2h)
+CLEAN_STORE_CLEANING_INTERVAL=7200
 CLEAN_STORE_MESSAGES=true
 CLEAN_STORE_MESSAGE_UP=true
 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
@@ -38,14 +42,14 @@ 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
 ## Define a global webhook that will listen for enabled events from all instances
-WEBHOOK_GLOBAL_URL='<url>'
+WEBHOOK_GLOBAL_URL=''
 WEBHOOK_GLOBAL_ENABLED=false
 # With this option activated, you work with a url per webhook event, respecting the global url and the name of each event
 WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=false
@@ -55,6 +59,7 @@ WEBHOOK_EVENTS_QRCODE_UPDATED=true
 WEBHOOK_EVENTS_MESSAGES_SET=true
 WEBHOOK_EVENTS_MESSAGES_UPSERT=true
 WEBHOOK_EVENTS_MESSAGES_UPDATE=true
+WEBHOOK_EVENTS_MESSAGES_DELETE=true
 WEBHOOK_EVENTS_SEND_MESSAGE=true
 WEBHOOK_EVENTS_CONTACTS_SET=true
 WEBHOOK_EVENTS_CONTACTS_UPSERT=true
@@ -72,8 +77,9 @@ 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
-CONFIG_SESSION_PHONE_NAME=chrome # chrome | firefox | edge | opera | safari
+# Browser Name = chrome | firefox | edge | opera | safari
+CONFIG_SESSION_PHONE_NAME=chrome
 
 # Set qrcode display limit
 QRCODE_LIMIT=30
@@ -81,20 +87,13 @@ QRCODE_LIMIT=30
 # Defines an authentication type for the api
 # 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
-AUTHENTICATION_TYPE='apikey' # jwt or 'apikey'
+# jwt or '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
-AUTHENTICATION_JWT_EXPIRIN_IN=0 # seconds - 3600s ===1h | zero (0) - never expires
+# seconds - 3600s ===1h | zero (0) - never expires
-AUTHENTICATION_JWT_SECRET='L0YWtjb2w554WFqPG'
+AUTHENTICATION_JWT_EXPIRIN_IN=0
-# Set the instance name and webhook url to create an instance in init the application
+AUTHENTICATION_JWT_SECRET='L=0YWt]b2w[WF>#>:&E`'
-# With this option activated, you work with a url per webhook event, respecting the local url and the name of each event
-AUTHENTICATION_INSTANCE_MODE=server # container or 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='<url>'
-AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
-AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
-AUTHENTICATION_INSTANCE_CHATWOOT_URL='<url>'

Docker/mongodb/docker-compose.yaml

@@ -15,8 +15,6 @@ services:
     volumes:
       - evolution_mongodb_data:/data/db
       - evolution_mongodb_configdb:/data/configdb
-    networks:
-      - evolution-net
     expose:
       - 27017
 
@@ -38,6 +36,6 @@ volumes:
   evolution_mongodb_configdb:
 
 networks:
-  default:
+  evolution-net:
-    name: evolution-net
+    external: true
     

Docker/redis/docker-compose.yaml

@@ -13,16 +13,9 @@ services:
     ports:
       - 6379:6379
     
-  rebrow:
-    image: marian/rebrow
-    ports: 
-      - 5001:5001
-    links:
-      - redis
-    
 volumes:
   evolution_redis:
 
 networks:
-  default:
+  evolution-net:
-    name: evolution-net
+    external: true

Dockerfile

@@ -13,86 +13,90 @@ COPY ./package.json .
 
 ENV DOCKER_ENV=true
 
-ENV SERVER_TYPE="http"
+ENV SERVER_URL=http://localhost:8080
-ENV SERVER_PORT=8080
-ENV SERVER_URL=$SERVER_URL
 
-ENV CORS_ORIGIN="*"
+ENV CORS_ORIGIN=*
-ENV CORS_METHODS="POST,GET,PUT,DELETE"
+ENV CORS_METHODS=POST,GET,PUT,DELETE
 ENV CORS_CREDENTIALS=true
 
-ENV LOG_LEVEL=$LOG_LEVEL
+ENV LOG_LEVEL=ERROR,WARN,DEBUG,INFO,LOG,VERBOSE,DARK,WEBHOOKS
-ENV LOG_COLOR=$LOG_COLOR
+ENV LOG_COLOR=true
+ENV LOG_BAILEYS=error
 
-ENV DEL_INSTANCE=$DEL_INSTANCE
+ENV DEL_INSTANCE=false
 
-ENV STORE_MESSAGES=$STORE_MESSAGE
+ENV STORE_MESSAGES=true
-ENV STORE_MESSAGE_UP=$STORE_MESSAGE_UP
+ENV STORE_MESSAGE_UP=true
-ENV STORE_CONTACTS=$STORE_CONTACTS
+ENV STORE_CONTACTS=true
-ENV STORE_CHATS=$STORE_CHATS
+ENV STORE_CHATS=true
 
-ENV CLEAN_STORE_CLEANING_INTERVAL=$CLEAN_STORE_CLEANING_INTERVAL
+ENV CLEAN_STORE_CLEANING_INTERVAL=7200
-ENV CLEAN_STORE_MESSAGES=$CLEAN_STORE_MESSAGE
+ENV CLEAN_STORE_MESSAGES=true
-ENV CLEAN_STORE_MESSAGE_UP=$CLEAN_STORE_MESSAGE_UP
+ENV CLEAN_STORE_MESSAGE_UP=true
-ENV CLEAN_STORE_CONTACTS=$CLEAN_STORE_CONTACTS
+ENV CLEAN_STORE_CONTACTS=true
-ENV CLEAN_STORE_CHATS=$CLEAN_STORE_CHATS
+ENV CLEAN_STORE_CHATS=true
 
-ENV DATABASE_ENABLED=$DATABASE_ENABLED
+ENV DATABASE_ENABLED=false
-ENV DATABASE_CONNECTION_URI=$DATABASE_CONNECTION_URI
+ENV DATABASE_CONNECTION_URI=mongodb://root:root@mongodb:27017/?authSource=admin&readPreference=primary&ssl=false&directConnection=true
-ENV DATABASE_CONNECTION_DB_PREFIX_NAME=$DATABASE_CONNECTION_DB_PREFIX_NAME
+ENV DATABASE_CONNECTION_DB_PREFIX_NAME=evolution
-ENV DATABASE_SAVE_DATA_INSTANCE=$DATABASE_SAVE_DATA_INSTANCE
-ENV DATABASE_SAVE_DATA_NEW_MESSAGE=$DATABASE_SAVE_DATA_NEW_MESSAGE
-ENV DATABASE_SAVE_MESSAGE_UPDATE=$DATABASE_SAVE_MESSAGE_UPDATE
-ENV DATABASE_SAVE_DATA_CONTACTS=$DATABASE_SAVE_DATA_CONTACTS
-ENV DATABASE_SAVE_DATA_CHATS=$DATABASE_SAVE_DATA_CHATS
 
-ENV REDIS_ENABLED=$REDIS_ENABLED
+ENV DATABASE_SAVE_DATA_INSTANCE=false
-ENV REDIS_URI=$REDIS_URI
+ENV DATABASE_SAVE_DATA_NEW_MESSAGE=false
-ENV REDIS_PREFIX_KEY=$REDIS_PREFIX_KEY
+ENV DATABASE_SAVE_MESSAGE_UPDATE=false
+ENV DATABASE_SAVE_DATA_CONTACTS=false
+ENV DATABASE_SAVE_DATA_CHATS=false
 
-ENV WEBHOOK_GLOBAL_URL=$WEBHOOK_GLOBAL_URL
+ENV REDIS_ENABLED=false
-ENV WEBHOOK_GLOBAL_ENABLED=$WEBHOOK_GLOBAL_ENABLED
+ENV REDIS_URI=redis://redis:6379
-ENV WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=$WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS
+ENV REDIS_PREFIX_KEY=evolution
 
-ENV WEBHOOK_EVENTS_APPLICATION_STARTUP=$WEBHOOK_EVENTS_APPLICATION_STARTUP
+ENV WEBHOOK_GLOBAL_URL=<url>
-ENV WEBHOOK_EVENTS_QRCODE_UPDATED=$WEBHOOK_EVENTS_QRCODE_UPDATED
+ENV WEBHOOK_GLOBAL_ENABLED=false
-ENV WEBHOOK_EVENTS_MESSAGES_SET=$WEBHOOK_EVENTS_MESSAGES_SET
-ENV WEBHOOK_EVENTS_MESSAGES_UPSERT=$WEBHOOK_EVENTS_MESSAGES_UPSERT
-ENV WEBHOOK_EVENTS_MESSAGES_UPDATE=$WEBHOOK_EVENTS_MESSAGES_UPDATE
-ENV WEBHOOK_EVENTS_SEND_MESSAGE=$WEBHOOK_EVENTS_SEND_MESSAGE
-ENV WEBHOOK_EVENTS_CONTACTS_SET=$WEBHOOK_EVENTS_CONTACTS_SET
-ENV WEBHOOK_EVENTS_CONTACTS_UPSERT=$WEBHOOK_EVENTS_CONTACTS_UPSERT
-ENV WEBHOOK_EVENTS_CONTACTS_UPDATE=$WEBHOOK_EVENTS_CONTACTS_UPDATE
-ENV WEBHOOK_EVENTS_PRESENCE_UPDATE=$WEBHOOK_EVENTS_PRESENCE_UPDATE
-ENV WEBHOOK_EVENTS_CHATS_SET=$WEBHOOK_EVENTS_CHATS_SET
-ENV WEBHOOK_EVENTS_CHATS_UPSERT=$WEBHOOK_EVENTS_CHATS_UPSERT
-ENV WEBHOOK_EVENTS_CHATS_UPDATE=$WEBHOOK_EVENTS_CHATS_UPDATE
-ENV WEBHOOK_EVENTS_CONNECTION_UPDATE=$WEBHOOK_EVENTS_CONNECTION_UPDATE
-ENV WEBHOOK_EVENTS_GROUPS_UPSERT=$WEBHOOK_EVENTS_GROUPS_UPSERT
-ENV WEBHOOK_EVENTS_GROUPS_UPDATE=$WEBHOOK_EVENTS_GROUPS_UPDATE
-ENV WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE=$WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE
 
-ENV WEBHOOK_EVENTS_NEW_JWT_TOKEN=$WEBHOOK_EVENTS_NEW_JWT_TOKEN
+ENV WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=false
 
-ENV CONFIG_SESSION_PHONE_CLIENT=$CONFIG_SESSION_PHONE_CLIENT
+ENV WEBHOOK_EVENTS_APPLICATION_STARTUP=false
-ENV CONFIG_SESSION_PHONE_NAME=$CONFIG_SESSION_PHONE_NAME
+ENV WEBHOOK_EVENTS_QRCODE_UPDATED=true
+ENV WEBHOOK_EVENTS_MESSAGES_SET=true
+ENV WEBHOOK_EVENTS_MESSAGES_UPSERT=true
+ENV WEBHOOK_EVENTS_MESSAGES_UPDATE=true
+ENV WEBHOOK_EVENTS_MESSAGES_DELETE=true
+ENV WEBHOOK_EVENTS_SEND_MESSAGE=true
+ENV WEBHOOK_EVENTS_CONTACTS_SET=true
+ENV WEBHOOK_EVENTS_CONTACTS_UPSERT=true
+ENV WEBHOOK_EVENTS_CONTACTS_UPDATE=true
+ENV WEBHOOK_EVENTS_PRESENCE_UPDATE=true
+ENV WEBHOOK_EVENTS_CHATS_SET=true
+ENV WEBHOOK_EVENTS_CHATS_UPSERT=true
+ENV WEBHOOK_EVENTS_CHATS_UPDATE=true
+ENV WEBHOOK_EVENTS_CHATS_DELETE=true
+ENV WEBHOOK_EVENTS_GROUPS_UPSERT=true
+ENV WEBHOOK_EVENTS_GROUPS_UPDATE=true
+ENV WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE=true
+ENV WEBHOOK_EVENTS_CONNECTION_UPDATE=true
 
-ENV QRCODE_LIMIT=$QRCODE_LIMIT
+ENV WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
 
-ENV AUTHENTICATION_TYPE=$AUTHENTICATION_TYPE
+ENV CONFIG_SESSION_PHONE_CLIENT=EvolutionAPI
+ENV CONFIG_SESSION_PHONE_NAME=chrome
 
-ENV AUTHENTICATION_API_KEY=$AUTHENTICATION_API_KEY
+ENV QRCODE_LIMIT=30
-ENV AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES=$AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES
 
-ENV AUTHENTICATION_JWT_EXPIRIN_IN=$AUTHENTICATION_JWT_EXPIRIN_IN
+ENV AUTHENTICATION_TYPE=apikey
-ENV AUTHENTICATION_JWT_SECRET="L=0YWt]b2w[WF>#>:&E`"
 
-ENV AUTHENTICATION_INSTANCE_NAME=$AUTHENTICATION_INSTANCE_NAME
+ENV AUTHENTICATION_API_KEY=B6D711FCDE4D4FD5936544120E713976
-ENV AUTHENTICATION_INSTANCE_WEBHOOK_URL=$AUTHENTICATION_INSTANCE_WEBHOOK_URL
+ENV AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES=true
-ENV AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=$AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID
+
-ENV AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=$AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN
+ENV AUTHENTICATION_JWT_EXPIRIN_IN=0
-ENV AUTHENTICATION_INSTANCE_CHATWOOT_URL=$AUTHENTICATION_INSTANCE_CHATWOOT_URL
+ENV AUTHENTICATION_JWT_SECRET='L=0YWt]b2w[WF>#>:&E`'
-ENV AUTHENTICATION_INSTANCE_MODE=$AUTHENTICATION_INSTANCE_MODE
+
+ENV AUTHENTICATION_INSTANCE_MODE=server
+
+ENV AUTHENTICATION_INSTANCE_NAME=evolution
+ENV AUTHENTICATION_INSTANCE_WEBHOOK_URL=<url>
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_URL=<url>
 
 RUN npm install
 

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']
@@ -21,6 +23,6 @@ volumes:
   evolution_store:
 
 networks:
-  default:
+  evolution-net:
-    name: evolution-net
+    external: true
   

docker-compose.yaml.example.complete

@@ -1,36 +1,46 @@
 version: '3.3'
 
 services:
-  redis:
+  api:
-    image: redis:latest
+    container_name: evolution_api
-    container_name: redis
+    image: evolution/api:local
+    restart: always
     ports:
-      - 6379:6379
+      - 8080:8080
-  
+    volumes:
-  rebrow:
+      - evolution_instances:/evolution/instances
-    image: marian/rebrow
+      - evolution_store:/evolution/store
-    ports: 
+    networks:
-      - 5001:5001
+      - evolution-net
-    links:
+    env_file:
-      - redis
+      - ./Docker/.env
+    command: ['node', './dist/src/main.js']
+    expose:
+      - 8080
 
   mongodb:
     container_name: mongodb
     image: mongo
     restart: always
-    volumes:
-      - evolution_mongodb_data:/data/db
-      - evolution_mongodb_configdb:/data/configdb
     ports:
       - 27017:27017
     environment:
-      MONGO_INITDB_ROOT_USERNAME: root
+      - MONGO_INITDB_ROOT_USERNAME=root
-      MONGO_INITDB_ROOT_PASSWORD: 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
@@ -41,23 +51,20 @@ services:
       - 8081:8081
     links:
       - mongodb
-  api:
+
-    container_name: evolution_api
+  redis:
-    image: evolution/api:local
+    image: redis:latest
-    restart: always
+    container_name: redis
-    ports:
+    command: >
-      - 8080:8080
+      redis-server
+      --port 6379
+      --appendonly yes
     volumes:
-      - evolution_instances:/evolution/instances
+      - evolution_redis:/data
-      - evolution_store:/evolution/store
+    networks:
-    env_file:
+      - evolution-net
-      - ./Docker/.env
+    ports:
-    command: ['node', './dist/src/main.js']
+      - 6379:6379
-    expose:
-      - 8080
-    links:
-      - mongodb
-      - redis
 
 volumes:
   evolution_instances:
@@ -67,6 +74,6 @@ volumes:
   evolution_redis:
 
 networks:
-  default:
+  evolution-net:
-    name: evolution-net
+    external: true
   

package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolution-api",
-  "version": "1.2.1",
+  "version": "1.4.2",
   "description": "Rest api for communication with WhatsApp",
   "main": "./dist/src/main.js",
   "scripts": {
@@ -42,9 +42,10 @@
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "github:DavidsonGomes/Baileys",
     "@figuro/chatwoot-sdk": "^1.1.14",
+    "@hapi/boom": "^10.0.1",
+    "@sentry/node": "^7.59.2",
+    "@whiskeysockets/baileys": "^6.4.0",
     "axios": "^1.3.5",
     "class-validator": "^0.13.2",
     "compression": "^1.7.4",

src/config/env.config.ts

@@ -1,7 +1,6 @@
 import { readFileSync } from 'fs';
 import { load } from 'js-yaml';
 import { join } from 'path';
-import { SRC_DIR } from './path.config';
 import { isBooleanString } from 'class-validator';
 
 export type HttpServer = { TYPE: 'http' | 'https'; PORT: number; URL: string };
@@ -76,6 +75,7 @@ export type EventsWebhook = {
   MESSAGES_SET: boolean;
   MESSAGES_UPSERT: boolean;
   MESSAGES_UPDATE: boolean;
+  MESSAGES_DELETE: boolean;
   SEND_MESSAGE: boolean;
   CONTACTS_SET: boolean;
   CONTACTS_UPDATE: boolean;
@@ -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;
@@ -193,7 +185,7 @@ export class ConfigService {
       CLEAN_STORE: {
         CLEANING_INTERVAL: Number.isInteger(process.env?.CLEAN_STORE_CLEANING_TERMINAL)
           ? Number.parseInt(process.env.CLEAN_STORE_CLEANING_TERMINAL)
-          : undefined,
+          : 7200,
         MESSAGES: process.env?.CLEAN_STORE_MESSAGES === 'true',
         MESSAGE_UP: process.env?.CLEAN_STORE_MESSAGE_UP === 'true',
         CONTACTS: process.env?.CLEAN_STORE_CONTACTS === 'true',
@@ -225,7 +217,7 @@ export class ConfigService {
       },
       DEL_INSTANCE: isBooleanString(process.env?.DEL_INSTANCE)
         ? process.env.DEL_INSTANCE === 'true'
-        : Number.parseInt(process.env.DEL_INSTANCE),
+        : Number.parseInt(process.env.DEL_INSTANCE) || false,
       WEBHOOK: {
         GLOBAL: {
           URL: process.env?.WEBHOOK_GLOBAL_URL,
@@ -238,6 +230,7 @@ export class ConfigService {
           MESSAGES_SET: process.env?.WEBHOOK_EVENTS_MESSAGES_SET === 'true',
           MESSAGES_UPSERT: process.env?.WEBHOOK_EVENTS_MESSAGES_UPSERT === 'true',
           MESSAGES_UPDATE: process.env?.WEBHOOK_EVENTS_MESSAGES_UPDATE === 'true',
+          MESSAGES_DELETE: process.env?.WEBHOOK_EVENTS_MESSAGES_DELETE === 'true',
           SEND_MESSAGE: process.env?.WEBHOOK_EVENTS_SEND_MESSAGE === 'true',
           CONTACTS_SET: process.env?.WEBHOOK_EVENTS_CONTACTS_SET === 'true',
           CONTACTS_UPDATE: process.env?.WEBHOOK_EVENTS_CONTACTS_UPDATE === 'true',
@@ -256,11 +249,11 @@ export class ConfigService {
         },
       },
       CONFIG_SESSION_PHONE: {
-        CLIENT: process.env?.CONFIG_SESSION_PHONE_CLIENT,
+        CLIENT: process.env?.CONFIG_SESSION_PHONE_CLIENT || 'Evolution API',
-        NAME: process.env?.CONFIG_SESSION_PHONE_NAME,
+        NAME: process.env?.CONFIG_SESSION_PHONE_NAME || 'chrome',
       },
       QRCODE: {
-        LIMIT: Number.parseInt(process.env.QRCODE_LIMIT),
+        LIMIT: Number.parseInt(process.env.QRCODE_LIMIT) || 30,
       },
       AUTHENTICATION: {
         TYPE: process.env.AUTHENTICATION_TYPE as 'jwt',
@@ -275,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 || '',
-        },
       },
     };
   }

src/dev-env.yml

@@ -39,7 +39,7 @@ LOG:
     - DARK
     - WEBHOOKS
   COLOR: true
-  BAILEYS: error # "fatal" | "error" | "warn" | "info" | "debug" | "trace"
+  BAILEYS: error # fatal | error | warn | info | debug | trace
 
 # Determine how long the instance should be deleted from memory in case of no connection.
 # Default time: 5 minutes
@@ -96,6 +96,7 @@ WEBHOOK:
     MESSAGES_SET: true
     MESSAGES_UPSERT: true
     MESSAGES_UPDATE: true
+    MESSAGES_DELETE: true
     SEND_MESSAGE: true
     CONTACTS_SET: true
     CONTACTS_UPSERT: true
@@ -136,13 +137,3 @@ AUTHENTICATION:
   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>

src/main.ts

@@ -10,6 +10,7 @@ import { waMonitor } from './whatsapp/whatsapp.module';
 import { HttpStatus, router } from './whatsapp/routers/index.router';
 import 'express-async-errors';
 import { ServerUP } from './utils/server-up';
+import * as Sentry from '@sentry/node';
 
 function initWA() {
   waMonitor.loadInstance();
@@ -19,6 +20,27 @@ function bootstrap() {
   const logger = new Logger('SERVER');
   const app = express();
 
+  // Sentry.init({
+  //   dsn: '',
+  //   integrations: [
+  //     // enable HTTP calls tracing
+  //     new Sentry.Integrations.Http({ tracing: true }),
+  //     // enable Express.js middleware tracing
+  //     new Sentry.Integrations.Express({ app }),
+  //     // Automatically instrument Node.js libraries and frameworks
+  //     ...Sentry.autoDiscoverNodePerformanceMonitoringIntegrations(),
+  //   ],
+
+  //   // Set tracesSampleRate to 1.0 to capture 100%
+  //   // of transactions for performance monitoring.
+  //   // We recommend adjusting this value in production
+  //   tracesSampleRate: 1.0,
+  // });
+
+  // app.use(Sentry.Handlers.requestHandler());
+
+  // app.use(Sentry.Handlers.tracingHandler());
+
   app.use(
     cors({
       origin(requestOrigin, callback) {
@@ -43,6 +65,13 @@ function bootstrap() {
 
   app.use('/', router);
 
+  // app.use(Sentry.Handlers.errorHandler());
+
+  // app.use(function onError(err, req, res, next) {
+  //   res.statusCode = 500;
+  //   res.end(res.sentry + '\n');
+  // });
+
   app.use(
     (err: Error, req: Request, res: Response, next: NextFunction) => {
       if (err) {

src/validate/validate.schema.ts

@@ -39,6 +39,7 @@ export const instanceNameSchema: JSONSchema7 = {
           'MESSAGES_SET',
           'MESSAGES_UPSERT',
           'MESSAGES_UPDATE',
+          'MESSAGES_DELETE',
           'SEND_MESSAGE',
           'CONTACTS_SET',
           'CONTACTS_UPSERT',
@@ -57,6 +58,7 @@ export const instanceNameSchema: JSONSchema7 = {
       },
     },
     qrcode: { type: 'boolean', enum: [true, false] },
+    number: { type: 'string', pattern: '^\\d+[\\.@\\w-]+' },
     token: { type: 'string' },
   },
   ...isNotEmpty('instanceName'),
@@ -81,8 +83,8 @@ const quotedOptionsSchema: JSONSchema7 = {
         remoteJid: { type: 'string' },
         fromMe: { type: 'boolean', enum: [true, false] },
       },
-      required: ['id', 'remoteJid', 'fromMe'],
+      required: ['id'],
-      ...isNotEmpty('id', 'remoteJid'),
+      ...isNotEmpty('id'),
     },
     message: { type: 'object' },
   },
@@ -122,7 +124,6 @@ const optionsSchema: JSONSchema7 = {
 
 const numberDefinition: JSONSchema7Definition = {
   type: 'string',
-  pattern: '^\\d+[\\.@\\w-]+',
   description: 'Invalid format',
 };
 
@@ -144,24 +145,6 @@ export const textMessageSchema: JSONSchema7 = {
   required: ['textMessage', 'number'],
 };
 
-export const linkPreviewSchema: JSONSchema7 = {
-  $id: v4(),
-  type: 'object',
-  properties: {
-    number: { ...numberDefinition },
-    options: { ...optionsSchema },
-    linkPreview: {
-      type: 'object',
-      properties: {
-        text: { type: 'string' },
-      },
-      required: ['text'],
-      ...isNotEmpty('text'),
-    },
-  },
-  required: ['linkPreview', 'number'],
-};
-
 export const pollMessageSchema: JSONSchema7 = {
   $id: v4(),
   type: 'object',
@@ -415,7 +398,7 @@ export const contactMessageSchema: JSONSchema7 = {
           email: { type: 'string' },
           url: { type: 'string' },
         },
-        required: ['fullName', 'wuid', 'phoneNumber'],
+        required: ['fullName', 'phoneNumber'],
         ...isNotEmpty('fullName'),
       },
       minItems: 1,
@@ -462,7 +445,6 @@ export const whatsappNumberSchema: JSONSchema7 = {
       uniqueItems: true,
       items: {
         type: 'string',
-        pattern: '^\\d+',
         description: '"numbers" must be an array of numeric strings',
       },
     },
@@ -604,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',
@@ -674,6 +667,7 @@ export const createGroupSchema: JSONSchema7 = {
     subject: { type: 'string' },
     description: { type: 'string' },
     profilePicture: { type: 'string' },
+    promoteParticipants: { type: 'boolean', enum: [true, false] },
     participants: {
       type: 'array',
       minItems: 1,
@@ -846,6 +840,7 @@ export const webhookSchema: JSONSchema7 = {
           'MESSAGES_SET',
           'MESSAGES_UPSERT',
           'MESSAGES_UPDATE',
+          'MESSAGES_DELETE',
           'SEND_MESSAGE',
           'CONTACTS_SET',
           'CONTACTS_UPSERT',
@@ -881,3 +876,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'),
+};

src/whatsapp/abstract/abstract.router.ts

@@ -160,8 +160,6 @@ export abstract class RouterBroker {
 
     const v = validate(ref, schema);
 
-    console.log(v, '@checkei aqui');
-
     if (!v.valid) {
       const message: any[] = v.errors.map(({ property, stack, schema }) => {
         let message: string;
@@ -203,8 +201,6 @@ export abstract class RouterBroker {
 
     const v = validate(ref, schema);
 
-    console.log(v, '@checkei aqui');
-
     if (!v.valid) {
       const message: any[] = v.errors.map(({ property, stack, schema }) => {
         let message: string;

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);

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');
       }
     }
@@ -66,6 +66,18 @@ export class ChatwootController {
 
     const urlServer = this.configService.get<HttpServer>('SERVER').URL;
 
+    if (Object.keys(result).length === 0) {
+      return {
+        enabled: false,
+        url: '',
+        account_id: '',
+        token: '',
+        sign_msg: false,
+        name_inbox: '',
+        webhook_url: '',
+      };
+    }
+
     const response = {
       ...result,
       webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
@@ -78,8 +90,14 @@ export class ChatwootController {
     logger.verbose(
       'requested receiveWebhook from ' + instance.instanceName + ' instance',
     );
-    const chatwootService = new ChatwootService(waMonitor);
+    const chatwootService = new ChatwootService(waMonitor, this.configService);
 
     return chatwootService.receiveWebhook(instance, data);
   }
+
+  public async newInstance(data: any) {
+    const chatwootService = new ChatwootService(waMonitor, this.configService);
+
+    return chatwootService.newInstance(data);
+  }
 }

src/whatsapp/controllers/instance.controller.ts

@@ -12,6 +12,7 @@ import { ChatwootService } from '../services/chatwoot.service';
 import { Logger } from '../../config/logger.config';
 import { wa } from '../types/wa.types';
 import { RedisCache } from '../../db/redis.client';
+import { isURL } from 'class-validator';
 
 export class InstanceController {
   constructor(
@@ -33,146 +34,22 @@ export class InstanceController {
     webhook_by_events,
     events,
     qrcode,
+    number,
     token,
     chatwoot_account_id,
     chatwoot_token,
     chatwoot_url,
     chatwoot_sign_msg,
   }: InstanceDto) {
-    this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
+    try {
+      this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
 
-    const mode = this.configService.get<Auth>('AUTHENTICATION').INSTANCE.MODE;
+      if (instanceName !== instanceName.toLowerCase().replace(/[^a-z0-9]/g, '')) {
-
+        throw new BadRequestException(
-    if (mode === 'container') {
+          'The instance name must be lowercase and without special characters',
-      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,
-      );
-      instance.instanceName = instanceName;
-      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) {
-        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 (!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');
-      }
-
-      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 {
-        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');
-
       this.logger.verbose('checking duplicate token');
       await this.authService.checkDuplicateToken(token);
 
@@ -183,7 +60,10 @@ export class InstanceController {
         this.repository,
         this.cache,
       );
-      instance.instanceName = instanceName;
+      instance.instanceName = instanceName
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '')
+        .replace(' ', '');
 
       this.logger.verbose('instance: ' + instance.instanceName + ' created');
 
@@ -203,6 +83,10 @@ export class InstanceController {
       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, {
@@ -223,25 +107,12 @@ export class InstanceController {
 
         if (qrcode) {
           this.logger.verbose('creating qrcode');
-          await instance.connectToWhatsapp();
+          await instance.connectToWhatsapp(number);
-          await delay(2000);
+          await delay(5000);
           getQrcode = instance.qrCode;
         }
 
-        this.logger.verbose('instance created');
+        const result = {
-        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',
@@ -252,6 +123,11 @@ export class InstanceController {
           events: getEvents,
           qrcode: getQrcode,
         };
+
+        this.logger.verbose('instance created');
+        this.logger.verbose(result);
+
+        return result;
       }
 
       if (!chatwoot_account_id) {
@@ -266,6 +142,10 @@ export class InstanceController {
         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 {
@@ -276,6 +156,7 @@ export class InstanceController {
           url: chatwoot_url,
           sign_msg: chatwoot_sign_msg || false,
           name_inbox: instance.instanceName,
+          number,
         });
 
         this.chatwootService.initInstanceChatwoot(
@@ -283,6 +164,7 @@ export class InstanceController {
           instance.instanceName,
           `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
           qrcode,
+          number,
         );
       } catch (error) {
         this.logger.log(error);
@@ -303,14 +185,18 @@ export class InstanceController {
           token: chatwoot_token,
           url: chatwoot_url,
           sign_msg: chatwoot_sign_msg || false,
+          number,
           name_inbox: instance.instanceName,
           webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
         },
       };
+    } catch (error) {
+      console.log(error);
+      return { error: true, message: error.toString() };
     }
   }
 
-  public async connectToWhatsapp({ instanceName }: InstanceDto) {
+  public async connectToWhatsapp({ instanceName, number = null }: InstanceDto) {
     try {
       this.logger.verbose(
         'requested connectToWhatsapp from ' + instanceName + ' instance',
@@ -321,17 +207,29 @@ export class InstanceController {
 
       this.logger.verbose('state: ' + state);
 
-      switch (state) {
+      if (state == 'open') {
-        case 'close':
+        return await this.connectionState({ instanceName });
-          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 == '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);
     }
@@ -341,24 +239,8 @@ export class InstanceController {
     try {
       this.logger.verbose('requested restartInstance from ' + instanceName + ' instance');
 
-      this.logger.verbose('deleting instance: ' + instanceName);
+      this.logger.verbose('logging out instance: ' + instanceName);
-      delete this.waMonitor.waInstances[instanceName];
+      this.waMonitor.waInstances[instanceName]?.client?.ws?.close();
-
-      this.logger.verbose('creating instance: ' + instanceName);
-      const instance = new WAStartupService(
-        this.configService,
-        this.eventEmitter,
-        this.repository,
-        this.cache,
-      );
-
-      instance.instanceName = instanceName;
-
-      this.logger.verbose('instance: ' + instance.instanceName + ' created');
-
-      this.logger.verbose('connecting instance: ' + instanceName);
-      await instance.connectToWhatsapp();
-      this.waMonitor.waInstances[instance.instanceName] = instance;
 
       return { error: false, message: 'Instance restarted' };
     } catch (error) {
@@ -368,7 +250,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) {
@@ -383,9 +270,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',
       );
@@ -408,15 +295,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 });

src/whatsapp/controllers/sendMessage.controller.ts

@@ -5,7 +5,6 @@ import {
   SendAudioDto,
   SendButtonDto,
   SendContactDto,
-  SendLinkPreviewDto,
   SendListDto,
   SendLocationDto,
   SendMediaDto,
@@ -31,9 +30,15 @@ export class SendMessageController {
 
   public async sendMedia({ instanceName }: InstanceDto, data: SendMediaDto) {
     logger.verbose('requested sendMedia from ' + instanceName + ' instance');
-    if (isBase64(data?.mediaMessage?.media) && !data?.mediaMessage?.fileName) {
+
-      throw new BadRequestException('For bse64 the file name must be informed.');
+    if (
+      isBase64(data?.mediaMessage?.media) &&
+      !data?.mediaMessage?.fileName &&
+      data?.mediaMessage?.mediatype === 'document'
+    ) {
+      throw new BadRequestException('For base64 the file name must be informed.');
     }
+
     logger.verbose(
       'isURL: ' +
         isURL(data?.mediaMessage?.media) +
@@ -119,9 +124,4 @@ export class SendMessageController {
     logger.verbose('requested sendStatus from ' + instanceName + ' instance');
     return await this.waMonitor.waInstances[instanceName].statusMessage(data);
   }
-
-  public async sendLinkPreview({ instanceName }: InstanceDto, data: SendLinkPreviewDto) {
-    logger.verbose('requested sendLinkPreview from ' + instanceName + ' instance');
-    return await this.waMonitor.waInstances[instanceName].linkPreview(data);
-  }
 }

src/whatsapp/controllers/settings.controller.ts

@@ -0,0 +1,25 @@
+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',
+    );
+
+    return this.settingsService.create(instance, data);
+  }
+
+  public async findSettings(instance: InstanceDto) {
+    logger.verbose('requested findSettings from ' + instance.instanceName + ' instance');
+    return this.settingsService.find(instance);
+  }
+}

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;
 }

src/whatsapp/dto/chatwoot.dto.ts

@@ -5,4 +5,5 @@ export class ChatwootDto {
   url?: string;
   name_inbox?: string;
   sign_msg?: boolean;
+  number?: string;
 }

src/whatsapp/dto/group.dto.ts

@@ -1,7 +1,8 @@
 export class CreateGroupDto {
   subject: string;
-  description?: string;
   participants: string[];
+  description?: string;
+  promoteParticipants?: boolean;
 }
 
 export class GroupPictureDto {

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;

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;
@@ -28,10 +30,6 @@ class TextMessage {
   text: string;
 }
 
-class linkPreviewMessage {
-  text: string;
-}
-
 export class StatusMessage {
   type: string;
   content: string;
@@ -52,10 +50,6 @@ export class SendTextDto extends Metadata {
   textMessage: TextMessage;
 }
 
-export class SendLinkPreviewDto extends Metadata {
-  linkPreview: linkPreviewMessage;
-}
-
 export class SendStatusDto extends Metadata {
   statusMessage: StatusMessage;
 }

src/whatsapp/dto/settings.dto.ts

@@ -0,0 +1,5 @@
+export class SettingsDto {
+  reject_call?: boolean;
+  msg_call?: string;
+  groups_ignore?: boolean;
+}

src/whatsapp/guards/instance.guard.ts

@@ -11,7 +11,6 @@ import {
 import { InstanceDto } from '../dto/instance.dto';
 import { cache, waMonitor } from '../whatsapp.module';
 import { Database, Redis, configService } from '../../config/env.config';
-import { RedisCache } from '../../db/redis.client';
 
 async function getInstance(instanceName: string) {
   const db = configService.get<Database>('DATABASE');

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(

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';

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;

src/whatsapp/models/webhook.model.ts

@@ -14,6 +14,7 @@ const webhookSchema = new Schema<WebhookRaw>({
   url: { type: String, required: true },
   enabled: { type: Boolean, required: true },
   events: { type: [String], required: true },
+  webhook_by_events: { type: Boolean, required: true },
 });
 
 export const WebhookModel = dbserver?.model(WebhookRaw.name, webhookSchema, 'webhook');

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';

src/whatsapp/repository/repository.manager.ts

@@ -5,12 +5,13 @@ 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';
-
 export class RepositoryBroker {
   constructor(
     public readonly message: MessageRepository,
@@ -19,11 +20,11 @@ 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,
   ) {
-    this.logger.verbose('initializing repository broker');
     this.dbClient = dbServer;
     this.__init_repo_without_db__();
   }
@@ -38,39 +39,83 @@ export class RepositoryBroker {
   private __init_repo_without_db__() {
     this.logger.verbose('initializing repository without db');
     if (!this.configService.get<Database>('DATABASE').ENABLED) {
-      this.logger.verbose('database is disabled');
-
       const storePath = join(process.cwd(), 'store');
 
       this.logger.verbose('creating store path: ' + storePath);
-      execSync(
+      try {
-        `mkdir -p ${join(
+        const authDir = join(
           storePath,
           'auth',
           this.configService.get<Auth>('AUTHENTICATION').TYPE,
-        )}`,
+        );
-      );
+        const chatsDir = join(storePath, 'chats');
+        const contactsDir = join(storePath, 'contacts');
+        const messagesDir = join(storePath, 'messages');
+        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');
 
-      this.logger.verbose('creating chats path: ' + join(storePath, 'chats'));
+        if (!fs.existsSync(authDir)) {
-      execSync(`mkdir -p ${join(storePath, 'chats')}`);
+          this.logger.verbose('creating auth dir: ' + authDir);
+          fs.mkdirSync(authDir, { recursive: true });
+        }
+        if (!fs.existsSync(chatsDir)) {
+          this.logger.verbose('creating chats dir: ' + chatsDir);
+          fs.mkdirSync(chatsDir, { recursive: true });
+        }
+        if (!fs.existsSync(contactsDir)) {
+          this.logger.verbose('creating contacts dir: ' + contactsDir);
+          fs.mkdirSync(contactsDir, { recursive: true });
+        }
+        if (!fs.existsSync(messagesDir)) {
+          this.logger.verbose('creating messages dir: ' + messagesDir);
+          fs.mkdirSync(messagesDir, { recursive: true });
+        }
+        if (!fs.existsSync(messageUpDir)) {
+          this.logger.verbose('creating message-up dir: ' + messageUpDir);
+          fs.mkdirSync(messageUpDir, { recursive: true });
+        }
+        if (!fs.existsSync(webhookDir)) {
+          this.logger.verbose('creating webhook dir: ' + webhookDir);
+          fs.mkdirSync(webhookDir, { recursive: true });
+        }
+        if (!fs.existsSync(chatwootDir)) {
+          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 });
+        }
+      } catch (error) {
+        this.logger.error(error);
+      }
+    } else {
+      const storePath = join(process.cwd(), 'store');
 
-      this.logger.verbose('creating contacts path: ' + join(storePath, 'contacts'));
+      this.logger.verbose('creating store path: ' + storePath);
-      execSync(`mkdir -p ${join(storePath, 'contacts')}`);
 
-      this.logger.verbose('creating messages path: ' + join(storePath, 'messages'));
+      const tempDir = join(storePath, 'temp');
-      execSync(`mkdir -p ${join(storePath, 'messages')}`);
+      const chatwootDir = join(storePath, 'chatwoot');
 
-      this.logger.verbose('creating message-up path: ' + join(storePath, 'message-up'));
+      if (!fs.existsSync(chatwootDir)) {
-      execSync(`mkdir -p ${join(storePath, 'message-up')}`);
+        this.logger.verbose('creating chatwoot dir: ' + chatwootDir);
-
+        fs.mkdirSync(chatwootDir, { recursive: true });
-      this.logger.verbose('creating webhook path: ' + join(storePath, 'webhook'));
+      }
-      execSync(`mkdir -p ${join(storePath, 'webhook')}`);
+      if (!fs.existsSync(tempDir)) {
-
+        this.logger.verbose('creating temp dir: ' + tempDir);
-      this.logger.verbose('creating chatwoot path: ' + join(storePath, 'chatwoot'));
+        fs.mkdirSync(tempDir, { recursive: true });
-      execSync(`mkdir -p ${join(storePath, 'chatwoot')}`);
+      }
-
+      try {
-      this.logger.verbose('creating temp path: ' + join(storePath, 'temp'));
+      } catch (error) {
-      execSync(`mkdir -p ${join(storePath, 'temp')}`);
+        this.logger.error(error);
+      }
     }
   }
 }

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 {};
+    }
+  }
+}

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: ');

src/whatsapp/routers/index.router.ts

@@ -9,6 +9,8 @@ import { MessageRouter } from './sendMessage.router';
 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,
@@ -24,11 +26,14 @@ const router = Router();
 const authType = configService.get<Auth>('AUTHENTICATION').TYPE;
 const guards = [instanceExistsGuard, instanceLoggedGuard, authGuard[authType]];
 
+const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+
 router
   .get('/', (req, res) => {
     res.status(HttpStatus.OK).json({
       status: HttpStatus.OK,
       message: 'Welcome to the Evolution API, it is working!',
+      version: packageJson.version,
     });
   })
   .use(
@@ -40,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 };

src/whatsapp/routers/instance.router.ts

@@ -23,6 +23,7 @@ export class InstanceRouter extends RouterBroker {
 
         logger.verbose('request query: ');
         logger.verbose(req.query);
+
         const response = await this.dataValidate<InstanceDto>({
           request: req,
           schema: instanceNameSchema,

src/whatsapp/routers/sendMessage.router.ts

@@ -3,7 +3,6 @@ import {
   audioMessageSchema,
   buttonMessageSchema,
   contactMessageSchema,
-  linkPreviewSchema,
   listMessageSchema,
   locationMessageSchema,
   mediaMessageSchema,
@@ -17,7 +16,6 @@ import {
   SendAudioDto,
   SendButtonDto,
   SendContactDto,
-  SendLinkPreviewDto,
   SendListDto,
   SendLocationDto,
   SendMediaDto,
@@ -199,23 +197,6 @@ export class MessageRouter extends RouterBroker {
 
         return res.status(HttpStatus.CREATED).json(response);
       })
-      .post(this.routerPath('sendLinkPreview'), ...guards, async (req, res) => {
-        logger.verbose('request received in sendLinkPreview');
-        logger.verbose('request body: ');
-        logger.verbose(req.body);
-
-        logger.verbose('request query: ');
-        logger.verbose(req.query);
-        const response = await this.dataValidate<SendLinkPreviewDto>({
-          request: req,
-          schema: linkPreviewSchema,
-          ClassRef: SendLinkPreviewDto,
-          execute: (instance, data) =>
-            sendMessageController.sendLinkPreview(instance, data),
-        });
-
-        return res.status(HttpStatus.CREATED).json(response);
-      })
       .post(this.routerPath('sendSticker'), ...guards, async (req, res) => {
         logger.verbose('request received in sendSticker');
         logger.verbose('request body: ');

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();
+}

src/whatsapp/services/chatwoot.service.ts

@@ -12,6 +12,7 @@ import mimeTypes from 'mime-types';
 import { SendAudioDto } from '../dto/sendMessage.dto';
 import { SendMediaDto } from '../dto/sendMessage.dto';
 import { ROOT_DIR } from '../../config/path.config';
+import { ConfigService, HttpServer } from '../../config/env.config';
 
 export class ChatwootService {
   private messageCacheFile: string;
@@ -21,7 +22,10 @@ export class ChatwootService {
 
   private provider: any;
 
-  constructor(private readonly waMonitor: WAMonitoringService) {
+  constructor(
+    private readonly waMonitor: WAMonitoringService,
+    private readonly configService: ConfigService,
+  ) {
     this.messageCache = new Set();
   }
 
@@ -150,6 +154,7 @@ export class ChatwootService {
     inboxName: string,
     webhookUrl: string,
     qrcode: boolean,
+    number: string,
   ) {
     this.logger.verbose('init instance chatwoot: ' + instance.instanceName);
 
@@ -239,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: '/iniciar',
+          content: contentMsg,
           message_type: 'outgoing',
         },
       });
@@ -424,16 +436,18 @@ export class ChatwootService {
         );
 
         if (findParticipant) {
-          await this.updateContact(instance, findParticipant.id, {
+          if (!findParticipant.name || findParticipant.name === chatId) {
-            name: body.pushName,
+            await this.updateContact(instance, findParticipant.id, {
-            avatar_url: picture_url.profilePictureUrl || null,
+              name: body.pushName,
-          });
+              avatar_url: picture_url.profilePictureUrl || null,
+            });
+          }
         } else {
           await this.createContact(
             instance,
             body.key.participant.split('@')[0],
             filterInbox.id,
-            isGroup,
+            false,
             body.pushName,
             picture_url.profilePictureUrl || null,
           );
@@ -449,21 +463,39 @@ export class ChatwootService {
       const findContact = await this.findContact(instance, chatId);
 
       let contact: any;
-
+      if (body.key.fromMe) {
-      if (findContact) {
+        if (findContact) {
-        contact = await this.updateContact(instance, findContact.id, {
+          contact = findContact;
-          name: nameContact,
+        } else {
-          avatar_url: picture_url.profilePictureUrl || null,
+          contact = await this.createContact(
-        });
+            instance,
+            chatId,
+            filterInbox.id,
+            isGroup,
+            nameContact,
+            picture_url.profilePictureUrl || null,
+          );
+        }
       } else {
-        contact = await this.createContact(
+        if (findContact) {
-          instance,
+          if (!findContact.name || findContact.name === chatId) {
-          chatId,
+            contact = await this.updateContact(instance, findContact.id, {
-          filterInbox.id,
+              name: nameContact,
-          isGroup,
+              avatar_url: picture_url.profilePictureUrl || null,
-          nameContact,
+            });
-          picture_url.profilePictureUrl || null,
+          } else {
-        );
+            contact = findContact;
+          }
+        } else {
+          contact = await this.createContact(
+            instance,
+            chatId,
+            filterInbox.id,
+            isGroup,
+            nameContact,
+            picture_url.profilePictureUrl || null,
+          );
+        }
       }
 
       if (!contact) {
@@ -471,9 +503,8 @@ export class ChatwootService {
         return null;
       }
 
-      console.log(contact);
+      const contactId =
-
+        contact?.payload?.id || contact?.payload?.contact?.id || contact?.id;
-      const contactId = contact.payload.id || contact.payload.contact.id;
 
       if (!body.key.fromMe && contact.name === chatId && nameContact !== chatId) {
         this.logger.verbose('update contact name in chatwoot');
@@ -930,18 +961,19 @@ export class ChatwootService {
 
         const command = messageReceived.replace('/', '');
 
-        if (command === 'iniciar') {
+        if (command.includes('init') || command.includes('iniciar')) {
-          this.logger.verbose('command iniciar found');
+          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(
               instance,
-              `🚨 Instância ${body.inbox.name} já está conectada.`,
+              `🚨 ${body.inbox.name} instance is connected.`,
               'incoming',
             );
           }
@@ -956,7 +988,7 @@ export class ChatwootService {
             this.logger.verbose('state not found');
             await this.createBotMessage(
               instance,
-              `⚠️ Instância ${body.inbox.name} não existe.`,
+              `⚠️ ${body.inbox.name} instance not found.`,
               'incoming',
             );
           }
@@ -965,16 +997,16 @@ export class ChatwootService {
             this.logger.verbose('state: ' + state + ' found');
             await this.createBotMessage(
               instance,
-              `⚠️ Status da instância ${body.inbox.name}: *${state}*`,
+              `⚠️ ${body.inbox.name} instance status: *${state}*`,
               'incoming',
             );
           }
         }
 
-        if (command === 'desconectar') {
+        if (command === 'disconnect' || command === 'desconectar') {
-          this.logger.verbose('command desconectar found');
+          this.logger.verbose('command disconnect found');
 
-          const msgLogout = `🚨 Desconectando Whatsapp da caixa de entrada *${body.inbox.name}*: `;
+          const msgLogout = `🚨 Disconnecting Whatsapp from inbox *${body.inbox.name}*: `;
 
           this.logger.verbose('send message to chatwoot');
           await this.createBotMessage(instance, msgLogout, 'incoming');
@@ -983,6 +1015,37 @@ export class ChatwootService {
           await waInstance?.client?.logout('Log out instance: ' + instance.instanceName);
           await waInstance?.client?.ws?.close();
         }
+
+        if (command.includes('new_instance')) {
+          const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+          const apiKey = this.configService.get('AUTHENTICATION').API_KEY.KEY;
+
+          const data = {
+            instanceName: command.split(':')[1],
+            qrcode: true,
+            chatwoot_account_id: this.provider.account_id,
+            chatwoot_token: this.provider.token,
+            chatwoot_url: this.provider.url,
+            chatwoot_sign_msg: this.provider.sign_msg,
+          };
+
+          if (command.split(':')[2]) {
+            data['number'] = command.split(':')[2];
+          }
+
+          const config = {
+            method: 'post',
+            maxBodyLength: Infinity,
+            url: `${urlServer}/instance/create`,
+            headers: {
+              'Content-Type': 'application/json',
+              apikey: apiKey,
+            },
+            data: data,
+          };
+
+          await axios.request(config);
+        }
       }
 
       if (
@@ -1061,7 +1124,7 @@ export class ChatwootService {
         }
       }
 
-      if (body.message_type === 'template' && body.content_type === 'input_csat') {
+      if (body.message_type === 'template' && body.event === 'message_created') {
         this.logger.verbose('check if is csat');
 
         const data: SendTextDto = {
@@ -1116,11 +1179,13 @@ export class ChatwootService {
       videoMessage: msg.videoMessage?.caption,
       extendedTextMessage: msg.extendedTextMessage?.text,
       messageContextInfo: msg.messageContextInfo?.stanzaId,
-      stickerMessage: msg.stickerMessage?.fileSha256.toString('base64'),
+      stickerMessage: undefined,
       documentMessage: msg.documentMessage?.caption,
       documentWithCaptionMessage:
         msg.documentWithCaptionMessage?.message?.documentMessage?.caption,
       audioMessage: msg.audioMessage?.caption,
+      contactMessage: msg.contactMessage?.vcard,
+      contactsArrayMessage: msg.contactsArrayMessage,
     };
 
     this.logger.verbose('type message: ' + types);
@@ -1134,6 +1199,67 @@ export class ChatwootService {
 
     const result = typeKey ? types[typeKey] : undefined;
 
+    if (typeKey === 'contactMessage') {
+      const vCardData = result.split('\n');
+      const contactInfo = {};
+
+      vCardData.forEach((line) => {
+        const [key, value] = line.split(':');
+        if (key && value) {
+          contactInfo[key] = value;
+        }
+      });
+
+      let formattedContact = `**Contact:**
+        **name:** ${contactInfo['FN']}`;
+
+      let numberCount = 1;
+      Object.keys(contactInfo).forEach((key) => {
+        if (key.startsWith('item') && key.includes('TEL')) {
+          const phoneNumber = contactInfo[key];
+          formattedContact += `\n**number ${numberCount}:** ${phoneNumber}`;
+          numberCount++;
+        }
+      });
+
+      this.logger.verbose('message content: ' + formattedContact);
+      return formattedContact;
+    }
+
+    if (typeKey === 'contactsArrayMessage') {
+      const formattedContacts = result.contacts.map((contact) => {
+        const vCardData = contact.vcard.split('\n');
+        const contactInfo = {};
+
+        vCardData.forEach((line) => {
+          const [key, value] = line.split(':');
+          if (key && value) {
+            contactInfo[key] = value;
+          }
+        });
+
+        let formattedContact = `**Contact:**
+            **name:** ${contact.displayName}`;
+
+        let numberCount = 1;
+        Object.keys(contactInfo).forEach((key) => {
+          if (key.startsWith('item') && key.includes('TEL')) {
+            const phoneNumber = contactInfo[key];
+            formattedContact += `\n**number ${numberCount}:** ${phoneNumber}`;
+            numberCount++;
+          }
+        });
+
+        return formattedContact;
+      });
+
+      const formattedContactsArray = formattedContacts.join('\n\n');
+
+      this.logger.verbose('formatted contacts: ' + formattedContactsArray);
+
+      return formattedContactsArray;
+    }
+
     this.logger.verbose('message content: ' + result);
 
     return result;
@@ -1169,7 +1295,6 @@ export class ChatwootService {
       }
 
       if (event === 'messages.upsert') {
-        console.log(body);
         this.logger.verbose('event messages.upsert');
 
         if (body.key.remoteJid === 'status@broadcast') {
@@ -1177,6 +1302,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);
 
@@ -1189,18 +1324,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');
@@ -1389,7 +1514,7 @@ export class ChatwootService {
           return;
         }
 
-        const msgStatus = `⚡️ Status da instância ${inbox.name}: ${data.status}`;
+        const msgStatus = `⚡️ Instance status ${inbox.name}: ${data.status}`;
 
         this.logger.verbose('send message to chatwoot');
         await this.createBotMessage(instance, msgStatus, 'incoming');
@@ -1397,43 +1522,20 @@ export class ChatwootService {
 
       if (event === 'connection.update') {
         this.logger.verbose('event connection.update');
-        if (body.state === 'open') {
+
-          const msgConnection = `🚀 Conexão realizada com sucesso!`;
+        if (body.status === 'open') {
+          const msgConnection = `🚀 Connection successfully established!`;
 
           this.logger.verbose('send message to chatwoot');
           await this.createBotMessage(instance, msgConnection, 'incoming');
         }
       }
 
-      if (event === 'contacts.update') {
-        this.logger.verbose('event contacts.update');
-        const data = body;
-
-        if (data.length) {
-          this.logger.verbose('contacts found');
-          for (const item of data) {
-            const number = item.id.split('@')[0];
-            const photo = item.profilePictureUrl || null;
-            this.logger.verbose('find contact in chatwoot');
-            const find = await this.findContact(instance, number);
-
-            if (find) {
-              this.logger.verbose('contact found');
-
-              this.logger.verbose('update contact in chatwoot');
-              await this.updateContact(instance, find.id, {
-                avatar_url: photo,
-              });
-            }
-          }
-        }
-      }
-
       if (event === 'qrcode.updated') {
         this.logger.verbose('event qrcode.updated');
         if (body.statusCode === 500) {
           this.logger.verbose('qrcode error');
-          const erroQRcode = `🚨 Limite de geração de QRCode atingido, para gerar um novo QRCode, envie a mensagem /iniciar novamente.`;
+          const erroQRcode = `🚨 QRCode generation limit reached, to generate a new QRCode, send the /init message again.`;
 
           this.logger.verbose('send message to chatwoot');
           return await this.createBotMessage(instance, erroQRcode, 'incoming');
@@ -1458,12 +1560,21 @@ export class ChatwootService {
           this.logger.verbose('send qrcode to chatwoot');
           await this.createBotQr(
             instance,
-            'QRCode gerado com sucesso!',
+            'QRCode successfully generated!',
             'incoming',
             fileName,
           );
 
-          const msgQrCode = `⚡️ QRCode gerado com sucesso!\n\nDigitalize este código QR nos próximos 40 segundos:`;
+          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');
@@ -1473,4 +1584,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;
+    }
+  }
 }

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}`,
@@ -99,72 +111,54 @@ export class WAMonitoringService {
 
         if (value.connectionStatus.state === 'open') {
           this.logger.verbose('instance: ' + key + ' - connectionStatus: open');
-          let apikey: string;
-          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
-            this.logger.verbose(
-              'instance: ' + key + ' - hash exposed in fetch instances',
-            );
-            const tokenStore = await this.repository.auth.find(key);
-            apikey = tokenStore.apikey || 'Apikey not found';
 
-            instances.push({
+          const instanceData = {
-              instance: {
+            instance: {
-                instanceName: key,
+              instanceName: key,
-                owner: value.wuid,
+              owner: value.wuid,
-                profileName: (await value.getProfileName()) || 'not loaded',
+              profileName: (await value.getProfileName()) || 'not loaded',
-                profilePictureUrl: value.profilePictureUrl,
+              profilePictureUrl: value.profilePictureUrl,
-                profileStatus: (await value.getProfileStatus()) || '',
+              profileStatus: (await value.getProfileStatus()) || '',
-                status: value.connectionStatus.state,
+              status: value.connectionStatus.state,
-                apikey,
+            },
-                chatwoot,
+          };
-              },
+
-            });
+          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
-          } else {
+            instanceData.instance['serverUrl'] =
-            this.logger.verbose(
+              this.configService.get<HttpServer>('SERVER').URL;
-              'instance: ' + key + ' - hash not exposed in fetch instances',
+
-            );
+            instanceData.instance['apikey'] = (
-            instances.push({
+              await this.repository.auth.find(key)
-              instance: {
+            ).apikey;
-                instanceName: key,
+
-                owner: value.wuid,
+            instanceData.instance['chatwoot'] = chatwoot;
-                profileName: (await value.getProfileName()) || 'not loaded',
-                profilePictureUrl: value.profilePictureUrl,
-                profileStatus: (await value.getProfileStatus()) || '',
-                status: value.connectionStatus.state,
-              },
-            });
           }
+
+          instances.push(instanceData);
         } else {
           this.logger.verbose(
             'instance: ' + key + ' - connectionStatus: ' + value.connectionStatus.state,
           );
-          let apikey: string;
-          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
-            this.logger.verbose(
-              'instance: ' + key + ' - hash exposed in fetch instances',
-            );
-            const tokenStore = await this.repository.auth.find(key);
-            apikey = tokenStore.apikey || 'Apikey not found';
 
-            instances.push({
+          const instanceData = {
-              instance: {
+            instance: {
-                instanceName: key,
+              instanceName: key,
-                status: value.connectionStatus.state,
+              status: value.connectionStatus.state,
-                apikey,
+            },
-                chatwoot,
+          };
-              },
+
-            });
+          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
-          } else {
+            instanceData.instance['serverUrl'] =
-            this.logger.verbose(
+              this.configService.get<HttpServer>('SERVER').URL;
-              'instance: ' + key + ' - hash not exposed in fetch instances',
+
-            );
+            instanceData.instance['apikey'] = (
-            instances.push({
+              await this.repository.auth.find(key)
-              instance: {
+            ).apikey;
-                instanceName: key,
+
-                status: value.connectionStatus.state,
+            instanceData.instance['chatwoot'] = chatwoot;
-              },
-            });
           }
+
+          instances.push(instanceData);
         }
       }
     }
@@ -236,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)}`);
@@ -251,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() {
@@ -282,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;
       }
@@ -298,7 +304,6 @@ export class WAMonitoringService {
           );
         } else {
           this.logger.verbose('no collections found');
-          initInstance();
         }
         return;
       }
@@ -319,7 +324,6 @@ export class WAMonitoringService {
           await set(dirent.name);
         } else {
           this.logger.verbose('no instance files found');
-          initInstance();
         }
       }
     } catch (error) {

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 };
+    }
+  }
+}

src/whatsapp/services/webhook.service.ts

@@ -18,9 +18,17 @@ export class WebhookService {
   public async find(instance: InstanceDto): Promise<WebhookDto> {
     try {
       this.logger.verbose('find webhook: ' + instance.instanceName);
-      return await this.waMonitor.waInstances[instance.instanceName].findWebhook();
+      const result = await this.waMonitor.waInstances[
+        instance.instanceName
+      ].findWebhook();
+
+      if (Object.keys(result).length === 0) {
+        throw new Error('Webhook not found');
+      }
+
+      return result;
     } catch (error) {
-      return { enabled: null, url: '' };
+      return { enabled: false, url: '', events: [], webhook_by_events: false };
     }
   }
 }

src/whatsapp/types/wa.types.ts

@@ -9,6 +9,7 @@ export enum Events {
   MESSAGES_SET = 'messages.set',
   MESSAGES_UPSERT = 'messages.upsert',
   MESSAGES_UPDATE = 'messages.update',
+  MESSAGES_DELETE = 'messages.delete',
   SEND_MESSAGE = 'send.message',
   CONTACTS_SET = 'contacts.set',
   CONTACTS_UPSERT = 'contacts.upsert',
@@ -24,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;
@@ -50,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';
@@ -62,6 +75,7 @@ export declare namespace wa {
     | 'SERVER_ACK'
     | 'DELIVERY_ACK'
     | 'READ'
+    | 'DELETED'
     | 'PLAYED';
 }
 

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(),
@@ -72,10 +78,14 @@ const webhookService = new WebhookService(waMonitor);
 
 export const webhookController = new WebhookController(webhookService);
 
-const chatwootService = new ChatwootService(waMonitor);
+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');

start.sh

@@ -6,6 +6,7 @@ then
   echo "DOCKER_ENV=$DOCKER_ENV"
   echo
 else
+  mkdir -p ./dist/src
   cp ./src/env.yml ./dist/src
 fi
 echo "> removing dist"