Merge branch 'release/1.2.1'

v

CHANGELOG.md

@@ -1,3 +1,42 @@
+# 1.2.1 (homolog)
+
+### Fixed
+
+* Adjusts in docker files
+* Save picture url groups in chatwoot
+
+# 1.2.0 (2023-07-14 15:28)
+
+### Features
+
+* Native integration with chatwoot
+* Added returning or non-returning participants option in fetchAllGroups
+* Added group integration to chatwoot
+* Added automation on create instance to chatwoot
+* Added verbose logs and format chatwoot service
+
+### Fixed
+
+* Adjusts in docker-compose files
+* Adjusts in number validation for AR and MX numbers
+* Adjusts in env files, removed save old_messages
+* Fix when sending a message to a group I don't belong returns a bad request
+* Fits the format on return from the fetchAllGroups endpoint
+* Adjust in send document with caption from chatwoot
+* Fixed message with undefind in chatwoot
+* Changed message in path /
+* Test duplicate message media in groups chatwoot
+* Optimize send message from group with mentions
+* Fixed name of the profile status in fetchInstances
+* Fixed error 500 when logout in instance with status = close
+
+# 1.1.5 (2023-07-12 07:17)
+
+### Fixed
+
+* Adjusts in temp folder
+* Return with event send_message
+
 # 1.1.4 (2023-07-08 11:01)
 
 ### Features

Docker/.env.example

@@ -1,3 +1,5 @@
+SERVER_URL='<url>' # ex.: http://localhost:3333
+
 CORS_ORIGIN='*' # Or separate by commas -  ex.: 'yourdomain1.com, yourdomain2.com'
 CORS_METHODS='POST,GET,PUT,DELETE'
 CORS_CREDENTIALS=true
@@ -17,6 +19,7 @@ STORE_MESSAGES=true
 STORE_MESSAGE_UP=true
 STORE_CONTACTS=true
 STORE_CHATS=true
+
 CLEAN_STORE_CLEANING_INTERVAL=7200 # seconds === 2h
 CLEAN_STORE_MESSAGES=true
 CLEAN_STORE_MESSAGE_UP=true
@@ -29,18 +32,18 @@ DATABASE_CONNECTION_URI=mongodb://root:root@mongodb:27017/?authSource=admin&read
 DATABASE_CONNECTION_DB_PREFIX_NAME=evolution
 
 # Choose the data you want to save in the application's database or store
-DATABASE_SAVE_DATA_INSTANCE=true
-DATABASE_SAVE_DATA_OLD_MESSAGE=false
-DATABASE_SAVE_DATA_NEW_MESSAGE=true
-DATABASE_SAVE_MESSAGE_UPDATE=true
-DATABASE_SAVE_DATA_CONTACTS=true
-DATABASE_SAVE_DATA_CHATS=true
+DATABASE_SAVE_DATA_INSTANCE=false
+DATABASE_SAVE_DATA_NEW_MESSAGE=false
+DATABASE_SAVE_MESSAGE_UPDATE=false
+DATABASE_SAVE_DATA_CONTACTS=false
+DATABASE_SAVE_DATA_CHATS=false
 
 REDIS_ENABLED=false
-REDIS_URI=redis://redis:6379/1
+REDIS_URI=redis://redis:6379
 REDIS_PREFIX_KEY=evolution
 
-# Webhook Settings
+# 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_ENABLED=false
@@ -52,6 +55,7 @@ WEBHOOK_EVENTS_QRCODE_UPDATED=true
 WEBHOOK_EVENTS_MESSAGES_SET=true
 WEBHOOK_EVENTS_MESSAGES_UPSERT=true
 WEBHOOK_EVENTS_MESSAGES_UPDATE=true
+WEBHOOK_EVENTS_SEND_MESSAGE=true
 WEBHOOK_EVENTS_CONTACTS_SET=true
 WEBHOOK_EVENTS_CONTACTS_UPSERT=true
 WEBHOOK_EVENTS_CONTACTS_UPDATE=true
@@ -65,16 +69,18 @@ WEBHOOK_EVENTS_GROUPS_UPDATE=true
 WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE=true
 WEBHOOK_EVENTS_CONNECTION_UPDATE=true
 # This event fires every time a new token is requested via the refresh route
-WEBHOOK_EVENTS_NEW_JWT_TOKEN=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='Evolution API'
 CONFIG_SESSION_PHONE_NAME=chrome # chrome | firefox | edge | opera | safari
 
 # Set qrcode display limit
 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'
 ## Define a global apikey to access all instances.
 ### OBS: This key must be inserted in the request header to create an instance.
@@ -88,4 +94,7 @@ AUTHENTICATION_JWT_SECRET='L0YWtjb2w554WFqPG'
 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_WEBHOOK_URL='<url>'
+AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
+AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
+AUTHENTICATION_INSTANCE_CHATWOOT_URL='<url>'

Docker/mongodb/docker-compose.yaml

@@ -1,27 +1,43 @@
 version: '3.3'
 
-networks:
-  evolution-net:
-    driver: bridge
-
 services:
   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_PASSWORD: root
+      - MONGO_INITDB_ROOT_USERNAME=root
+      - MONGO_INITDB_ROOT_PASSWORD=root
+      - PUID=1000
+      - PGID=1000
+    volumes:
+      - evolution_mongodb_data:/data/db
+      - evolution_mongodb_configdb:/data/configdb
     networks:
       - evolution-net
     expose:
       - 27017
 
+  mongo-express:
+    image: mongo-express
+    environment:
+      ME_CONFIG_BASICAUTH_USERNAME: root
+      ME_CONFIG_BASICAUTH_PASSWORD: root
+      ME_CONFIG_MONGODB_SERVER: mongodb
+      ME_CONFIG_MONGODB_ADMINUSERNAME: root
+      ME_CONFIG_MONGODB_ADMINPASSWORD: root
+    ports:
+      - 8081:8081
+    links:
+      - mongodb
+
 volumes:
   evolution_mongodb_data:
-  evolution_mongodb_configdb:
+  evolution_mongodb_configdb:
+
+networks:
+  default:
+    name: evolution-net
+    

Docker/redis/docker-compose.yaml

@@ -1,17 +1,28 @@
 version: '3.3'
 
-networks:
-  evolution-net:
-    driver: bridge
-
 services:
   redis:
     image: redis:latest
     container_name: redis
+    command: >
+      redis-server
+      --port 6379
+      --appendonly yes
+    volumes:
+      - evolution_redis:/data
     ports:
       - 6379:6379
-    networks:
-      - evolution-net
-
+  
+  rebrow:
+    image: marian/rebrow
+    ports: 
+      - 5001:5001
+    links:
+      - redis
+    
 volumes:
   evolution_redis:
+
+networks:
+  default:
+    name: evolution-net

Dockerfile

@@ -15,13 +15,14 @@ ENV DOCKER_ENV=true
 
 ENV SERVER_TYPE="http"
 ENV SERVER_PORT=8080
+ENV SERVER_URL=$SERVER_URL
 
 ENV CORS_ORIGIN="*"
 ENV CORS_METHODS="POST,GET,PUT,DELETE"
 ENV CORS_CREDENTIALS=true
 
 ENV LOG_LEVEL=$LOG_LEVEL
-ENV LOG_COLOR=true
+ENV LOG_COLOR=$LOG_COLOR
 
 ENV DEL_INSTANCE=$DEL_INSTANCE
 
@@ -40,7 +41,6 @@ ENV DATABASE_ENABLED=$DATABASE_ENABLED
 ENV DATABASE_CONNECTION_URI=$DATABASE_CONNECTION_URI
 ENV DATABASE_CONNECTION_DB_PREFIX_NAME=$DATABASE_CONNECTION_DB_PREFIX_NAME
 ENV DATABASE_SAVE_DATA_INSTANCE=$DATABASE_SAVE_DATA_INSTANCE
-ENV DATABASE_SAVE_DATA_OLD_MESSAGE=$DATABASE_SAVE_DATA_OLD_MESSAGE
 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
@@ -57,8 +57,9 @@ ENV WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=$WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS
 ENV WEBHOOK_EVENTS_APPLICATION_STARTUP=$WEBHOOK_EVENTS_APPLICATION_STARTUP
 ENV WEBHOOK_EVENTS_QRCODE_UPDATED=$WEBHOOK_EVENTS_QRCODE_UPDATED
 ENV WEBHOOK_EVENTS_MESSAGES_SET=$WEBHOOK_EVENTS_MESSAGES_SET
-ENV WEBHOOK_EVENTS_MESSAGES_UPDATE=$WEBHOOK_EVENTS_MESSAGES_UPDATE
 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
@@ -88,6 +89,9 @@ ENV AUTHENTICATION_JWT_SECRET="L=0YWt]b2w[WF>#>:&E`"
 
 ENV AUTHENTICATION_INSTANCE_NAME=$AUTHENTICATION_INSTANCE_NAME
 ENV AUTHENTICATION_INSTANCE_WEBHOOK_URL=$AUTHENTICATION_INSTANCE_WEBHOOK_URL
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=$AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=$AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN
+ENV AUTHENTICATION_INSTANCE_CHATWOOT_URL=$AUTHENTICATION_INSTANCE_CHATWOOT_URL
 ENV AUTHENTICATION_INSTANCE_MODE=$AUTHENTICATION_INSTANCE_MODE
 
 RUN npm install

README.md

@@ -2,9 +2,10 @@
 
 <div align="center">
 
-[![Whatsapp Group](https://img.shields.io/badge/Group-WhatsApp-%2322BC18)](https://evolution-api.com/whatsapp) 
-[![Postman Collection](https://img.shields.io/badge/Postman-Collection-orange)](https://evolution-api.com/docs/evolution-documentation/getting-started/postman-collection/) 
-[![Documentation](https://img.shields.io/badge/Documentation-Official-green)](https://evolution-api.com)
+[![Whatsapp Group](https://img.shields.io/badge/Group-WhatsApp-%2322BC18)](https://evolution-api.com/whatsapp)
+[![Discord Community](https://img.shields.io/badge/Discord-Community-blue)](https://evolution-api.com/discord)
+[![Postman Collection](https://img.shields.io/badge/Postman-Collection-orange)](https://evolution-api.com/postman) 
+[![Documentation](https://img.shields.io/badge/Documentation-Official-green)](https://doc.evolution-api.com)
 [![License](https://img.shields.io/badge/license-GPL--3.0-orange)](./LICENSE)
 [![Support](https://img.shields.io/badge/Buy%20me-coffe-orange)](https://app.picpay.com/user/davidsongomes1998)
 

docker-compose-full.yaml

@@ -0,0 +1,72 @@
+version: '3.3'
+
+services:
+  redis:
+    image: redis:latest
+    container_name: redis
+    ports:
+      - 6379:6379
+  
+  rebrow:
+    image: marian/rebrow
+    ports: 
+      - 5001:5001
+    links:
+      - redis
+
+  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_PASSWORD: root
+    expose:
+      - 27017
+
+  mongo-express:
+    image: mongo-express
+    environment:
+      ME_CONFIG_BASICAUTH_USERNAME: root
+      ME_CONFIG_BASICAUTH_PASSWORD: root
+      ME_CONFIG_MONGODB_SERVER: mongodb
+      ME_CONFIG_MONGODB_ADMINUSERNAME: root
+      ME_CONFIG_MONGODB_ADMINPASSWORD: root
+    ports:
+      - 8081:8081
+    links:
+      - mongodb
+  api:
+    container_name: evolution_api
+    image: evolution/api:local
+    restart: always
+    ports:
+      - 8080:8080
+    volumes:
+      - evolution_instances:/evolution/instances
+      - evolution_store:/evolution/store
+    env_file:
+      - ./Docker/.env
+    command: ['node', './dist/src/main.js']
+    expose:
+      - 8080
+    links:
+      - mongodb
+      - redis
+
+volumes:
+  evolution_instances:
+  evolution_store:
+  evolution_mongodb_data:
+  evolution_mongodb_configdb:
+  evolution_redis:
+
+networks:
+  default:
+    name: evolution-net
+  

docker-compose.yaml

@@ -1,9 +1,5 @@
 version: '3.3'
 
-networks:
-  evolution-net:
-    driver: bridge
-
 services:
   api:
     container_name: evolution_api
@@ -17,11 +13,14 @@ services:
     env_file:
       - ./Docker/.env
     command: ['node', './dist/src/main.js']
-    networks:
-      - evolution-net
     expose:
       - 8080
 
 volumes:
   evolution_instances:
-  evolution_store:
+  evolution_store:
+
+networks:
+  default:
+    name: evolution-net
+  

docker.sh

@@ -8,13 +8,6 @@ then
   docker network create -d bridge ${NET}
 fi
 
-# sudo mkdir -p ./docker-data/instances
-# sudo mkdir -p ./docker-data/mongodb
-# sudo mkdir -p ./docker-data/mongodb/data
-# sudo mkdir -p ./docker-data/mongodb/configdb
-# sudo mkdir -p ./docker-data/redis
-# sudo mkdir -p ./docker-data/redis/data
-
 docker build -t ${IMAGE} .
 
 docker compose up -d

package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolution-api",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "description": "Rest api for communication with WhatsApp",
   "main": "./dist/src/main.js",
   "scripts": {
@@ -43,7 +43,8 @@
     "@adiwajshing/keyed-db": "^0.2.4",
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "github:EvolutionAPI/Baileys",
+    "@whiskeysockets/baileys": "github:vphelipe/WhiskeySockets-Baileys#master",
+    "@figuro/chatwoot-sdk": "^1.1.14",
     "axios": "^1.3.5",
     "class-validator": "^0.13.2",
     "compression": "^1.7.4",

src/config/env.config.ts

@@ -4,7 +4,7 @@ import { join } from 'path';
 import { SRC_DIR } from './path.config';
 import { isBooleanString } from 'class-validator';
 
-export type HttpServer = { TYPE: 'http' | 'https'; PORT: number };
+export type HttpServer = { TYPE: 'http' | 'https'; PORT: number; URL: string };
 
 export type HttpMethods = 'POST' | 'GET' | 'PUT' | 'DELETE';
 export type Cors = {
@@ -33,7 +33,6 @@ export type Log = {
 
 export type SaveData = {
   INSTANCE: boolean;
-  OLD_MESSAGE: boolean;
   NEW_MESSAGE: boolean;
   MESSAGE_UPDATE: boolean;
   CONTACTS: boolean;
@@ -77,6 +76,7 @@ export type EventsWebhook = {
   MESSAGES_SET: boolean;
   MESSAGES_UPSERT: boolean;
   MESSAGES_UPDATE: boolean;
+  SEND_MESSAGE: boolean;
   CONTACTS_SET: boolean;
   CONTACTS_UPDATE: boolean;
   CONTACTS_UPSERT: boolean;
@@ -98,6 +98,9 @@ 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;
@@ -170,6 +173,7 @@ export class ConfigService {
       SERVER: {
         TYPE: process.env.SERVER_TYPE as 'http' | 'https',
         PORT: Number.parseInt(process.env.SERVER_PORT),
+        URL: process.env.SERVER_URL,
       },
       CORS: {
         ORIGIN: process.env.CORS_ORIGIN.split(','),
@@ -203,7 +207,6 @@ export class ConfigService {
         ENABLED: process.env?.DATABASE_ENABLED === 'true',
         SAVE_DATA: {
           INSTANCE: process.env?.DATABASE_SAVE_DATA_INSTANCE === 'true',
-          OLD_MESSAGE: process.env?.DATABASE_SAVE_DATA_OLD_MESSAGE === 'true',
           NEW_MESSAGE: process.env?.DATABASE_SAVE_DATA_NEW_MESSAGE === 'true',
           MESSAGE_UPDATE: process.env?.DATABASE_SAVE_MESSAGE_UPDATE === 'true',
           CONTACTS: process.env?.DATABASE_SAVE_DATA_CONTACTS === 'true',
@@ -235,6 +238,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',
+          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',
           CONTACTS_UPSERT: process.env?.WEBHOOK_EVENTS_CONTACTS_UPSERT === 'true',
@@ -275,6 +279,10 @@ export class ConfigService {
           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

@@ -8,10 +8,11 @@
 SERVER:
   TYPE: http # https
   PORT: 8080 # 443
+  URL: localhost
 
 CORS:
   ORIGIN:
-    - '*'
+    - "*"
     # - yourdomain.com
   METHODS:
     - POST
@@ -61,40 +62,41 @@ CLEAN_STORE:
 
 # Permanent data storage
 DATABASE:
-  ENABLED: true
+  ENABLED: false
   CONNECTION:
-    URI: 'mongodb://root:root@localhost:27017/?authSource=admin&readPreference=primary&ssl=false&directConnection=true'
+    URI: "mongodb://root:root@localhost:27017/?authSource=admin&readPreference=primary&ssl=false&directConnection=true"
     DB_PREFIX_NAME: evolution
   # Choose the data you want to save in the application's database or store
   SAVE_DATA:
     INSTANCE: false
-    OLD_MESSAGE: false
-    NEW_MESSAGE: true
-    MESSAGE_UPDATE: true
-    CONTACTS: true
-    CHATS: true
+    NEW_MESSAGE: false
+    MESSAGE_UPDATE: false
+    CONTACTS: false
+    CHATS: false
 
 REDIS:
-  ENABLED: true
-  URI: 'redis://localhost:6379/1'
-  PREFIX_KEY: 'evolution'
+  ENABLED: false
+  URI: "redis://localhost:6379"
+  PREFIX_KEY: "evolution"
 
-# Webhook Settings
+# Global Webhook Settings
+# Each instance's Webhook URL and events will be requested at the time it is created
 WEBHOOK:
   # Define a global webhook that will listen for enabled events from all instances
   GLOBAL:
     URL: <url>
-    ENABLED: true
+    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_BY_EVENTS: false
   # Automatically maps webhook paths
-  # Set the events you want to hear  
+  # Set the events you want to hear
   EVENTS:
-    APPLICATION_STARTUP: true
+    APPLICATION_STARTUP: false
     QRCODE_UPDATED: true
     MESSAGES_SET: true
     MESSAGES_UPSERT: true
     MESSAGES_UPDATE: true
+    SEND_MESSAGE: true
     CONTACTS_SET: true
     CONTACTS_UPSERT: true
     CONTACTS_UPDATE: true
@@ -108,11 +110,11 @@ WEBHOOK:
     GROUP_PARTICIPANTS_UPDATE: true
     CONNECTION_UPDATE: true
     # This event fires every time a new token is requested via the refresh route
-    NEW_JWT_TOKEN: true
+    NEW_JWT_TOKEN: false
 
 CONFIG_SESSION_PHONE:
   # Name that will be displayed on smartphone connection
-  CLIENT: 'Evolution API'
+  CLIENT: "Evolution API"
   NAME: chrome # chrome | firefox | edge | opera | safari
 
 # Set qrcode display limit
@@ -120,6 +122,8 @@ 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
   # Define a global apikey to access all instances
@@ -134,8 +138,11 @@ AUTHENTICATION:
     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
+    # 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/validate/validate.schema.ts

@@ -39,6 +39,7 @@ export const instanceNameSchema: JSONSchema7 = {
           'MESSAGES_SET',
           'MESSAGES_UPSERT',
           'MESSAGES_UPDATE',
+          'SEND_MESSAGE',
           'CONTACTS_SET',
           'CONTACTS_UPSERT',
           'CONTACTS_UPDATE',
@@ -699,6 +700,16 @@ export const groupJidSchema: JSONSchema7 = {
   ...isNotEmpty('groupJid'),
 };
 
+export const getParticipantsSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    getParticipants: { type: 'string', enum: ['true', 'false'] },
+  },
+  required: ['getParticipants'],
+  ...isNotEmpty('getParticipants'),
+};
+
 export const groupSendInviteSchema: JSONSchema7 = {
   $id: v4(),
   type: 'object',
@@ -835,6 +846,7 @@ export const webhookSchema: JSONSchema7 = {
           'MESSAGES_SET',
           'MESSAGES_UPSERT',
           'MESSAGES_UPDATE',
+          'SEND_MESSAGE',
           'CONTACTS_SET',
           'CONTACTS_UPSERT',
           'CONTACTS_UPDATE',
@@ -855,3 +867,17 @@ export const webhookSchema: JSONSchema7 = {
   required: ['url', 'enabled'],
   ...isNotEmpty('url'),
 };
+
+export const chatwootSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean', enum: [true, false] },
+    account_id: { type: 'string' },
+    token: { type: 'string' },
+    url: { type: 'string' },
+    sign_msg: { type: 'boolean', enum: [true, false] },
+  },
+  required: ['enabled', 'account_id', 'token', 'url', 'sign_msg'],
+  ...isNotEmpty('account_id', 'token', 'url', 'sign_msg'),
+};

src/whatsapp/abstract/abstract.router.ts

@@ -5,7 +5,7 @@ import { validate } from 'jsonschema';
 import { BadRequestException } from '../../exceptions';
 import 'express-async-errors';
 import { Logger } from '../../config/logger.config';
-import { GroupInvite, GroupJid } from '../dto/group.dto';
+import { GetParticipant, GroupInvite, GroupJid } from '../dto/group.dto';
 
 type DataValidate<T> = {
   request: Request;
@@ -181,4 +181,47 @@ export abstract class RouterBroker {
 
     return await execute(instance, ref);
   }
+
+  public async getParticipantsValidate<T>(args: DataValidate<T>) {
+    const { request, ClassRef, schema, execute } = args;
+
+    const getParticipants = request.query as unknown as GetParticipant;
+
+    if (!getParticipants?.getParticipants) {
+      throw new BadRequestException(
+        'The getParticipants needs to be informed in the query',
+      );
+    }
+
+    const instance = request.params as unknown as InstanceDto;
+    const body = request.body;
+
+    const ref = new ClassRef();
+
+    Object.assign(body, getParticipants);
+    Object.assign(ref, body);
+
+    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;
+        if (schema['description']) {
+          message = schema['description'];
+        } else {
+          message = stack.replace('instance.', '');
+        }
+        return {
+          property: property.replace('instance.', ''),
+          message,
+        };
+      });
+      logger.error([...message]);
+      throw new BadRequestException(...message);
+    }
+
+    return await execute(instance, ref);
+  }
 }

src/whatsapp/controllers/chatwoot.controller.ts

@@ -0,0 +1,85 @@
+import { isURL } from 'class-validator';
+import { BadRequestException } from '../../exceptions';
+import { InstanceDto } from '../dto/instance.dto';
+import { ChatwootDto } from '../dto/chatwoot.dto';
+import { ChatwootService } from '../services/chatwoot.service';
+import { Logger } from '../../config/logger.config';
+import { waMonitor } from '../whatsapp.module';
+import { ConfigService, HttpServer } from '../../config/env.config';
+
+const logger = new Logger('ChatwootController');
+
+export class ChatwootController {
+  constructor(
+    private readonly chatwootService: ChatwootService,
+    private readonly configService: ConfigService,
+  ) {}
+
+  public async createChatwoot(instance: InstanceDto, data: ChatwootDto) {
+    logger.verbose(
+      'requested createChatwoot from ' + instance.instanceName + ' instance',
+    );
+
+    if (data.enabled) {
+      if (!isURL(data.url, { require_tld: false })) {
+        throw new BadRequestException('url is not valid');
+      }
+
+      if (!data.account_id) {
+        throw new BadRequestException('account_id is required');
+      }
+
+      if (!data.token) {
+        throw new BadRequestException('token is required');
+      }
+
+      if (!data.sign_msg) {
+        throw new BadRequestException('sign_msg is required');
+      }
+    }
+
+    if (!data.enabled) {
+      logger.verbose('chatwoot disabled');
+      data.account_id = '';
+      data.token = '';
+      data.url = '';
+      data.sign_msg = false;
+    }
+
+    data.name_inbox = instance.instanceName;
+
+    const result = this.chatwootService.create(instance, data);
+
+    const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+    const response = {
+      ...result,
+      webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+    };
+
+    return response;
+  }
+
+  public async findChatwoot(instance: InstanceDto) {
+    logger.verbose('requested findChatwoot from ' + instance.instanceName + ' instance');
+    const result = await this.chatwootService.find(instance);
+
+    const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+    const response = {
+      ...result,
+      webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+    };
+
+    return response;
+  }
+
+  public async receiveWebhook(instance: InstanceDto, data: any) {
+    logger.verbose(
+      'requested receiveWebhook from ' + instance.instanceName + ' instance',
+    );
+    const chatwootService = new ChatwootService(waMonitor);
+
+    return chatwootService.receiveWebhook(instance, data);
+  }
+}

src/whatsapp/controllers/group.controller.ts

@@ -1,5 +1,6 @@
 import {
   CreateGroupDto,
+  GetParticipant,
   GroupDescriptionDto,
   GroupInvite,
   GroupJid,
@@ -59,11 +60,13 @@ export class GroupController {
     return await this.waMonitor.waInstances[instance.instanceName].findGroup(groupJid);
   }
 
-  public async fetchAllGroups(instance: InstanceDto) {
+  public async fetchAllGroups(instance: InstanceDto, getPaticipants: GetParticipant) {
     logger.verbose(
       'requested fetchAllGroups from ' + instance.instanceName + ' instance',
     );
-    return await this.waMonitor.waInstances[instance.instanceName].fetchAllGroups();
+    return await this.waMonitor.waInstances[instance.instanceName].fetchAllGroups(
+      getPaticipants,
+    );
   }
 
   public async inviteCode(instance: InstanceDto, groupJid: GroupJid) {

src/whatsapp/controllers/instance.controller.ts

@@ -1,6 +1,6 @@
 import { delay } from '@whiskeysockets/baileys';
 import EventEmitter2 from 'eventemitter2';
-import { Auth, ConfigService } from '../../config/env.config';
+import { Auth, ConfigService, HttpServer } from '../../config/env.config';
 import { BadRequestException, InternalServerErrorException } from '../../exceptions';
 import { InstanceDto } from '../dto/instance.dto';
 import { RepositoryBroker } from '../repository/repository.manager';
@@ -8,6 +8,7 @@ import { AuthService, OldToken } from '../services/auth.service';
 import { WAMonitoringService } from '../services/monitor.service';
 import { WAStartupService } from '../services/whatsapp.service';
 import { WebhookService } from '../services/webhook.service';
+import { ChatwootService } from '../services/chatwoot.service';
 import { Logger } from '../../config/logger.config';
 import { wa } from '../types/wa.types';
 import { RedisCache } from '../../db/redis.client';
@@ -20,6 +21,7 @@ export class InstanceController {
     private readonly eventEmitter: EventEmitter2,
     private readonly authService: AuthService,
     private readonly webhookService: WebhookService,
+    private readonly chatwootService: ChatwootService,
     private readonly cache: RedisCache,
   ) {}
 
@@ -32,6 +34,10 @@ export class InstanceController {
     events,
     qrcode,
     token,
+    chatwoot_account_id,
+    chatwoot_token,
+    chatwoot_url,
+    chatwoot_sign_msg,
   }: InstanceDto) {
     this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
 
@@ -91,16 +97,62 @@ export class InstanceController {
         }
       }
 
-      this.logger.verbose('instance created');
-      this.logger.verbose({
-        instance: {
-          instanceName: instance.instanceName,
-          status: 'created',
-        },
-        hash,
-        webhook,
-        events: getEvents,
-      });
+      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: {
@@ -108,8 +160,15 @@ export class InstanceController {
           status: 'created',
         },
         hash,
-        webhook,
-        events: getEvents,
+        chatwoot: {
+          enabled: true,
+          account_id: chatwoot_account_id,
+          token: chatwoot_token,
+          url: chatwoot_url,
+          sign_msg: chatwoot_sign_msg || false,
+          name_inbox: instance.instanceName,
+          webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+        },
       };
     } else {
       this.logger.verbose('server mode');
@@ -159,27 +218,75 @@ export class InstanceController {
         }
       }
 
-      let getQrcode: wa.QrCode;
+      if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
+        let getQrcode: wa.QrCode;
 
-      if (qrcode) {
-        this.logger.verbose('creating qrcode');
-        await instance.connectToWhatsapp();
-        await delay(2000);
-        getQrcode = instance.qrCode;
+        if (qrcode) {
+          this.logger.verbose('creating qrcode');
+          await instance.connectToWhatsapp();
+          await delay(2000);
+          getQrcode = instance.qrCode;
+        }
+
+        this.logger.verbose('instance created');
+        this.logger.verbose({
+          instance: {
+            instanceName: instance.instanceName,
+            status: 'created',
+          },
+          hash,
+          webhook,
+          webhook_by_events,
+          events: getEvents,
+          qrcode: getQrcode,
+        });
+
+        return {
+          instance: {
+            instanceName: instance.instanceName,
+            status: 'created',
+          },
+          hash,
+          webhook,
+          webhook_by_events,
+          events: getEvents,
+          qrcode: getQrcode,
+        };
       }
 
-      this.logger.verbose('instance created');
-      this.logger.verbose({
-        instance: {
-          instanceName: instance.instanceName,
-          status: 'created',
-        },
-        hash,
-        webhook,
-        webhook_by_events,
-        events: getEvents,
-        qrcode: getQrcode,
-      });
+      if (!chatwoot_account_id) {
+        throw new BadRequestException('account_id is required');
+      }
+
+      if (!chatwoot_token) {
+        throw new BadRequestException('token is required');
+      }
+
+      if (!chatwoot_url) {
+        throw new BadRequestException('url is required');
+      }
+
+      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: {
@@ -190,7 +297,15 @@ export class InstanceController {
         webhook,
         webhook_by_events,
         events: getEvents,
-        qrcode: getQrcode,
+        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}`,
+        },
       };
     }
   }
@@ -268,6 +383,14 @@ export class InstanceController {
 
   public async logout({ instanceName }: InstanceDto) {
     this.logger.verbose('requested logout from ' + instanceName + ' instance');
+    const stateConn = await this.connectionState({ instanceName });
+
+    if (stateConn.state === 'close') {
+      throw new BadRequestException(
+        'The "' + instanceName + '" instance is not connected',
+      );
+    }
+
     try {
       this.logger.verbose('logging out instance: ' + instanceName);
       await this.waMonitor.waInstances[instanceName]?.client?.logout(
@@ -288,10 +411,9 @@ export class InstanceController {
     const stateConn = await this.connectionState({ instanceName });
 
     if (stateConn.state === 'open') {
-      throw new BadRequestException([
-        'Deletion failed',
-        'The instance needs to be disconnected',
-      ]);
+      throw new BadRequestException(
+        'The "' + instanceName + '" instance needs to be disconnected',
+      );
     }
     try {
       if (stateConn.state === 'connecting') {

src/whatsapp/dto/chatwoot.dto.ts

@@ -0,0 +1,8 @@
+export class ChatwootDto {
+  enabled?: boolean;
+  account_id?: string;
+  token?: string;
+  url?: string;
+  name_inbox?: string;
+  sign_msg?: boolean;
+}

src/whatsapp/dto/group.dto.ts

@@ -23,6 +23,10 @@ export class GroupJid {
   groupJid: string;
 }
 
+export class GetParticipant {
+  getParticipants: string;
+}
+
 export class GroupInvite {
   inviteCode: string;
 }

src/whatsapp/dto/instance.dto.ts

@@ -5,4 +5,8 @@ export class InstanceDto {
   events?: string[];
   qrcode?: boolean;
   token?: string;
+  chatwoot_account_id?: string;
+  chatwoot_token?: string;
+  chatwoot_url?: string;
+  chatwoot_sign_msg?: boolean;
 }

src/whatsapp/models/chatwoot.model.ts

@@ -0,0 +1,29 @@
+import { Schema } from 'mongoose';
+import { dbserver } from '../../db/db.connect';
+
+export class ChatwootRaw {
+  _id?: string;
+  enabled?: boolean;
+  account_id?: string;
+  token?: string;
+  url?: string;
+  name_inbox?: string;
+  sign_msg?: boolean;
+}
+
+const chatwootSchema = new Schema<ChatwootRaw>({
+  _id: { type: String, _id: true },
+  enabled: { type: Boolean, required: true },
+  account_id: { type: String, required: true },
+  token: { type: String, required: true },
+  url: { type: String, required: true },
+  name_inbox: { type: String, required: true },
+  sign_msg: { type: Boolean, required: true },
+});
+
+export const ChatwootModel = dbserver?.model(
+  ChatwootRaw.name,
+  chatwootSchema,
+  'chatwoot',
+);
+export type IChatwootModel = typeof ChatwootModel;

src/whatsapp/models/index.ts

@@ -3,3 +3,4 @@ export * from './contact.model';
 export * from './message.model';
 export * from './auth.model';
 export * from './webhook.model';
+export * from './chatwoot.model';

src/whatsapp/repository/chatwoot.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 { IChatwootModel, ChatwootRaw } from '../models';
+import { Logger } from '../../config/logger.config';
+
+export class ChatwootRepository extends Repository {
+  constructor(
+    private readonly chatwootModel: IChatwootModel,
+    private readonly configService: ConfigService,
+  ) {
+    super(configService);
+  }
+
+  private readonly logger = new Logger('ChatwootRepository');
+
+  public async create(data: ChatwootRaw, instance: string): Promise<IInsert> {
+    try {
+      this.logger.verbose('creating chatwoot');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('saving chatwoot to db');
+        const insert = await this.chatwootModel.replaceOne(
+          { _id: instance },
+          { ...data },
+          { upsert: true },
+        );
+
+        this.logger.verbose(
+          'chatwoot saved to db: ' + insert.modifiedCount + ' chatwoot',
+        );
+        return { insertCount: insert.modifiedCount };
+      }
+
+      this.logger.verbose('saving chatwoot to store');
+
+      this.writeStore<ChatwootRaw>({
+        path: join(this.storePath, 'chatwoot'),
+        fileName: instance,
+        data,
+      });
+
+      this.logger.verbose(
+        'chatwoot saved to store in path: ' +
+          join(this.storePath, 'chatwoot') +
+          '/' +
+          instance,
+      );
+
+      this.logger.verbose('chatwoot created');
+      return { insertCount: 1 };
+    } catch (error) {
+      return error;
+    }
+  }
+
+  public async find(instance: string): Promise<ChatwootRaw> {
+    try {
+      this.logger.verbose('finding chatwoot');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('finding chatwoot in db');
+        return await this.chatwootModel.findOne({ _id: instance });
+      }
+
+      this.logger.verbose('finding chatwoot in store');
+      return JSON.parse(
+        readFileSync(join(this.storePath, 'chatwoot', instance + '.json'), {
+          encoding: 'utf-8',
+        }),
+      ) as ChatwootRaw;
+    } catch (error) {
+      return {};
+    }
+  }
+}

src/whatsapp/repository/repository.manager.ts

@@ -4,6 +4,7 @@ import { ContactRepository } from './contact.repository';
 import { MessageUpRepository } from './messageUp.repository';
 import { MongoClient } from 'mongodb';
 import { WebhookRepository } from './webhook.repository';
+import { ChatwootRepository } from './chatwoot.repository';
 import { AuthRepository } from './auth.repository';
 import { Auth, ConfigService, Database } from '../../config/env.config';
 import { execSync } from 'child_process';
@@ -17,6 +18,7 @@ export class RepositoryBroker {
     public readonly contact: ContactRepository,
     public readonly messageUpdate: MessageUpRepository,
     public readonly webhook: WebhookRepository,
+    public readonly chatwoot: ChatwootRepository,
     public readonly auth: AuthRepository,
     private configService: ConfigService,
     dbServer?: MongoClient,
@@ -63,6 +65,12 @@ export class RepositoryBroker {
 
       this.logger.verbose('creating webhook path: ' + join(storePath, 'webhook'));
       execSync(`mkdir -p ${join(storePath, 'webhook')}`);
+
+      this.logger.verbose('creating chatwoot path: ' + join(storePath, 'chatwoot'));
+      execSync(`mkdir -p ${join(storePath, 'chatwoot')}`);
+
+      this.logger.verbose('creating temp path: ' + join(storePath, 'temp'));
+      execSync(`mkdir -p ${join(storePath, 'temp')}`);
     }
   }
 }

src/whatsapp/routers/chatwoot.router.ts

@@ -0,0 +1,68 @@
+import { RequestHandler, Router } from 'express';
+import { instanceNameSchema, chatwootSchema } from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import { InstanceDto } from '../dto/instance.dto';
+import { ChatwootDto } from '../dto/chatwoot.dto';
+import { chatwootController } from '../whatsapp.module';
+import { ChatwootService } from '../services/chatwoot.service';
+import { HttpStatus } from './index.router';
+import { Logger } from '../../config/logger.config';
+
+const logger = new Logger('ChatwootRouter');
+
+export class ChatwootRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        logger.verbose('request received in setChatwoot');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<ChatwootDto>({
+          request: req,
+          schema: chatwootSchema,
+          ClassRef: ChatwootDto,
+          execute: (instance, data) => chatwootController.createChatwoot(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        logger.verbose('request received in findChatwoot');
+        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) => chatwootController.findChatwoot(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('webhook'), async (req, res) => {
+        logger.verbose('request received in findChatwoot');
+        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, data) => chatwootController.receiveWebhook(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/group.router.ts

@@ -10,6 +10,7 @@ import {
   updateGroupDescriptionSchema,
   groupInviteSchema,
   groupSendInviteSchema,
+  getParticipantsSchema,
 } from '../../validate/validate.schema';
 import { RouterBroker } from '../abstract/abstract.router';
 import {
@@ -23,6 +24,7 @@ import {
   GroupUpdateSettingDto,
   GroupToggleEphemeralDto,
   GroupSendInvite,
+  GetParticipant,
 } from '../dto/group.dto';
 import { groupController } from '../whatsapp.module';
 import { HttpStatus } from './index.router';
@@ -123,11 +125,11 @@ export class GroupRouter extends RouterBroker {
 
         logger.verbose('request query: ');
         logger.verbose(req.query);
-        const response = await this.groupNoValidate<GroupJid>({
+        const response = await this.getParticipantsValidate<GetParticipant>({
           request: req,
-          schema: {},
-          ClassRef: GroupJid,
-          execute: (instance) => groupController.fetchAllGroups(instance),
+          schema: getParticipantsSchema,
+          ClassRef: GetParticipant,
+          execute: (instance, data) => groupController.fetchAllGroups(instance, data),
         });
 
         res.status(HttpStatus.OK).json(response);

src/whatsapp/routers/index.router.ts

@@ -8,6 +8,7 @@ import { InstanceRouter } from './instance.router';
 import { MessageRouter } from './sendMessage.router';
 import { ViewsRouter } from './view.router';
 import { WebhookRouter } from './webhook.router';
+import { ChatwootRouter } from './chatwoot.router';
 
 enum HttpStatus {
   OK = 200,
@@ -24,6 +25,12 @@ const authType = configService.get<Auth>('AUTHENTICATION').TYPE;
 const guards = [instanceExistsGuard, instanceLoggedGuard, authGuard[authType]];
 
 router
+  .get('/', (req, res) => {
+    res.status(HttpStatus.OK).json({
+      status: HttpStatus.OK,
+      message: 'Welcome to the Evolution API, it is working!',
+    });
+  })
   .use(
     '/instance',
     new InstanceRouter(configService, ...guards).router,
@@ -32,6 +39,7 @@ router
   .use('/message', new MessageRouter(...guards).router)
   .use('/chat', new ChatRouter(...guards).router)
   .use('/group', new GroupRouter(...guards).router)
-  .use('/webhook', new WebhookRouter(...guards).router);
+  .use('/webhook', new WebhookRouter(...guards).router)
+  .use('/chatwoot', new ChatwootRouter(...guards).router);
 
 export { router, HttpStatus };

src/whatsapp/services/monitor.service.ts

@@ -9,6 +9,7 @@ import {
   ConfigService,
   Database,
   DelInstance,
+  HttpServer,
   Redis,
 } from '../../config/env.config';
 import { RepositoryBroker } from '../repository/repository.manager';
@@ -83,6 +84,19 @@ export class WAMonitoringService {
     for await (const [key, value] of Object.entries(this.waInstances)) {
       if (value) {
         this.logger.verbose('get instance info: ' + key);
+        let chatwoot: any;
+
+        const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+        const findChatwoot = await this.waInstances[key].findChatwoot();
+
+        if (findChatwoot.enabled) {
+          chatwoot = {
+            ...findChatwoot,
+            webhook_url: `${urlServer}/chatwoot/webhook/${key}`,
+          };
+        }
+
         if (value.connectionStatus.state === 'open') {
           this.logger.verbose('instance: ' + key + ' - connectionStatus: open');
           let apikey: string;
@@ -99,8 +113,10 @@ export class WAMonitoringService {
                 owner: value.wuid,
                 profileName: (await value.getProfileName()) || 'not loaded',
                 profilePictureUrl: value.profilePictureUrl,
-                status: (await value.getProfileStatus()) || '',
+                profileStatus: (await value.getProfileStatus()) || '',
+                status: value.connectionStatus.state,
                 apikey,
+                chatwoot,
               },
             });
           } else {
@@ -113,7 +129,8 @@ export class WAMonitoringService {
                 owner: value.wuid,
                 profileName: (await value.getProfileName()) || 'not loaded',
                 profilePictureUrl: value.profilePictureUrl,
-                status: (await value.getProfileStatus()) || '',
+                profileStatus: (await value.getProfileStatus()) || '',
+                status: value.connectionStatus.state,
               },
             });
           }
@@ -134,6 +151,7 @@ export class WAMonitoringService {
                 instanceName: key,
                 status: value.connectionStatus.state,
                 apikey,
+                chatwoot,
               },
             });
           } else {
@@ -232,6 +250,7 @@ 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 + '*')}`);
     }
   }
 

src/whatsapp/services/whatsapp.service.ts

@@ -30,7 +30,6 @@ import makeWASocket, {
   WAMessageUpdate,
   WASocket,
   getAggregateVotesInPollMessage,
-  Browsers,
 } from '@whiskeysockets/baileys';
 import {
   Auth,
@@ -38,6 +37,7 @@ import {
   ConfigService,
   ConfigSessionPhone,
   Database,
+  HttpServer,
   QrCode,
   Redis,
   Webhook,
@@ -109,11 +109,13 @@ import {
   GroupSubjectDto,
   GroupDescriptionDto,
   GroupSendInvite,
+  GetParticipant,
 } from '../dto/group.dto';
 import { MessageUpQuery } from '../repository/messageUp.repository';
 import { useMultiFileAuthStateDb } from '../../utils/use-multi-file-auth-state-db';
 import Long from 'long';
 import { WebhookRaw } from '../models/webhook.model';
+import { ChatwootRaw } from '../models/chatwoot.model';
 import { dbserver } from '../../db/db.connect';
 import NodeCache from 'node-cache';
 import { useMultiFileAuthStateRedisDb } from '../../utils/use-multi-file-auth-state-redis-db';
@@ -121,6 +123,8 @@ import sharp from 'sharp';
 import { RedisCache } from '../../db/redis.client';
 import { Log } from '../../config/env.config';
 import ProxyAgent from 'proxy-agent';
+import { ChatwootService } from './chatwoot.service';
+import { waMonitor } from '../whatsapp.module';
 
 export class WAStartupService {
   constructor(
@@ -138,13 +142,16 @@ export class WAStartupService {
   private readonly instance: wa.Instance = {};
   public client: WASocket;
   private readonly localWebhook: wa.LocalWebHook = {};
+  private readonly localChatwoot: wa.LocalChatwoot = {};
   private stateConnection: wa.StateConnection = { state: 'close' };
-  private readonly storePath = join(ROOT_DIR, 'store');
+  public readonly storePath = join(ROOT_DIR, 'store');
   private readonly msgRetryCounterCache: CacheStore = new NodeCache();
   private readonly userDevicesCache: CacheStore = new NodeCache();
   private endSession = false;
   private logBaileys = this.configService.get<Log>('LOG').BAILEYS;
 
+  private chatwootService = new ChatwootService(waMonitor);
+
   public set instanceName(name: string) {
     this.logger.verbose(`Initializing instance '${name}'`);
     if (!name) {
@@ -159,6 +166,17 @@ export class WAStartupService {
       instance: this.instance.name,
       status: 'created',
     });
+
+    if (this.localChatwoot.enabled) {
+      this.chatwootService.eventWhatsapp(
+        Events.STATUS_INSTANCE,
+        { instanceName: this.instance.name },
+        {
+          instance: this.instance.name,
+          status: 'created',
+        },
+      );
+    }
   }
 
   public get instanceName() {
@@ -268,8 +286,64 @@ export class WAStartupService {
     return data;
   }
 
+  private async loadChatwoot() {
+    this.logger.verbose('Loading chatwoot');
+    const data = await this.repository.chatwoot.find(this.instanceName);
+    this.localChatwoot.enabled = data?.enabled;
+    this.logger.verbose(`Chatwoot enabled: ${this.localChatwoot.enabled}`);
+
+    this.localChatwoot.account_id = data?.account_id;
+    this.logger.verbose(`Chatwoot account id: ${this.localChatwoot.account_id}`);
+
+    this.localChatwoot.token = data?.token;
+    this.logger.verbose(`Chatwoot token: ${this.localChatwoot.token}`);
+
+    this.localChatwoot.url = data?.url;
+    this.logger.verbose(`Chatwoot url: ${this.localChatwoot.url}`);
+
+    this.localChatwoot.name_inbox = data?.name_inbox;
+    this.logger.verbose(`Chatwoot inbox name: ${this.localChatwoot.name_inbox}`);
+
+    this.localChatwoot.sign_msg = data?.sign_msg;
+    this.logger.verbose(`Chatwoot sign msg: ${this.localChatwoot.sign_msg}`);
+
+    this.logger.verbose('Chatwoot loaded');
+  }
+
+  public async setChatwoot(data: ChatwootRaw) {
+    this.logger.verbose('Setting chatwoot');
+    await this.repository.chatwoot.create(data, this.instanceName);
+    this.logger.verbose(`Chatwoot account id: ${data.account_id}`);
+    this.logger.verbose(`Chatwoot token: ${data.token}`);
+    this.logger.verbose(`Chatwoot url: ${data.url}`);
+    this.logger.verbose(`Chatwoot inbox name: ${data.name_inbox}`);
+    this.logger.verbose(`Chatwoot sign msg: ${data.sign_msg}`);
+
+    Object.assign(this.localChatwoot, data);
+    this.logger.verbose('Chatwoot set');
+  }
+
+  public async findChatwoot() {
+    this.logger.verbose('Finding chatwoot');
+    const data = await this.repository.chatwoot.find(this.instanceName);
+
+    if (!data) {
+      this.logger.verbose('Chatwoot not found');
+      throw new NotFoundException('Chatwoot not found');
+    }
+
+    this.logger.verbose(`Chatwoot account id: ${data.account_id}`);
+    this.logger.verbose(`Chatwoot token: ${data.token}`);
+    this.logger.verbose(`Chatwoot url: ${data.url}`);
+    this.logger.verbose(`Chatwoot inbox name: ${data.name_inbox}`);
+    this.logger.verbose(`Chatwoot sign msg: ${data.sign_msg}`);
+
+    return data;
+  }
+
   public async sendDataWebhook<T = any>(event: Events, data: T, local = true) {
     const webhookGlobal = this.configService.get<Webhook>('WEBHOOK');
+    const urlServer = this.configService.get<HttpServer>('SERVER').URL;
     const webhookLocal = this.localWebhook.events;
     const we = event.replace(/[\.-]/gm, '_').toUpperCase();
     const transformedWe = we.replace(/_/gm, '-').toLowerCase();
@@ -294,6 +368,7 @@ export class WAStartupService {
             instance: this.instance.name,
             data,
             destination: this.localWebhook.url,
+            urlServer,
           });
         }
 
@@ -305,6 +380,7 @@ export class WAStartupService {
               instance: this.instance.name,
               data,
               destination: this.localWebhook.url,
+              urlServer,
             });
           }
         } catch (error) {
@@ -352,6 +428,7 @@ export class WAStartupService {
             instance: this.instance.name,
             data,
             destination: localUrl,
+            urlServer,
           });
         }
 
@@ -363,6 +440,7 @@ export class WAStartupService {
               instance: this.instance.name,
               data,
               destination: localUrl,
+              urlServer,
             });
           }
         } catch (error) {
@@ -399,6 +477,17 @@ export class WAStartupService {
           statusCode: DisconnectReason.badSession,
         });
 
+        if (this.localChatwoot.enabled) {
+          this.chatwootService.eventWhatsapp(
+            Events.QRCODE_UPDATED,
+            { instanceName: this.instance.name },
+            {
+              message: 'QR code limit reached, please login again',
+              statusCode: DisconnectReason.badSession,
+            },
+          );
+        }
+
         this.logger.verbose('Sending data to webhook in event CONNECTION_UPDATE');
         this.sendDataWebhook(Events.CONNECTION_UPDATE, {
           instance: this.instance.name,
@@ -412,6 +501,17 @@ export class WAStartupService {
           status: 'removed',
         });
 
+        if (this.localChatwoot.enabled) {
+          this.chatwootService.eventWhatsapp(
+            Events.STATUS_INSTANCE,
+            { instanceName: this.instance.name },
+            {
+              instance: this.instance.name,
+              status: 'removed',
+            },
+          );
+        }
+
         this.logger.verbose('endSession defined as true');
         this.endSession = true;
 
@@ -442,6 +542,16 @@ export class WAStartupService {
         this.sendDataWebhook(Events.QRCODE_UPDATED, {
           qrcode: { instance: this.instance.name, code: qr, base64 },
         });
+
+        if (this.localChatwoot.enabled) {
+          this.chatwootService.eventWhatsapp(
+            Events.QRCODE_UPDATED,
+            { instanceName: this.instance.name },
+            {
+              qrcode: { instance: this.instance.name, code: qr, base64 },
+            },
+          );
+        }
       });
 
       this.logger.verbose('Generating QR code in terminal');
@@ -482,6 +592,17 @@ export class WAStartupService {
           status: 'removed',
         });
 
+        if (this.localChatwoot.enabled) {
+          this.chatwootService.eventWhatsapp(
+            Events.STATUS_INSTANCE,
+            { instanceName: this.instance.name },
+            {
+              instance: this.instance.name,
+              status: 'removed',
+            },
+          );
+        }
+
         this.logger.verbose('Emittin event logout.instance');
         this.eventEmitter.emit('logout.instance', this.instance.name, 'inner');
         this.client?.ws?.close();
@@ -596,14 +717,14 @@ export class WAStartupService {
     this.logger.verbose('Connecting to whatsapp');
     try {
       this.loadWebhook();
+      this.loadChatwoot();
 
       this.instance.authState = await this.defineAuthState();
 
       const { version } = await fetchLatestBaileysVersion();
       this.logger.verbose('Baileys version: ' + version);
       const session = this.configService.get<ConfigSessionPhone>('CONFIG_SESSION_PHONE');
-      // const browser: WABrowserDescription = [session.CLIENT, session.NAME, release()];
-      const browser: WABrowserDescription = Browsers.appropriate(session.CLIENT);
+      const browser: WABrowserDescription = [session.CLIENT, session.NAME, release()];
       this.logger.verbose('Browser: ' + JSON.stringify(browser));
 
       const socketConfig: UserFacingSocketConfig = {
@@ -787,6 +908,14 @@ export class WAStartupService {
       this.logger.verbose('Sending data to webhook in event CONTACTS_UPDATE');
       await this.sendDataWebhook(Events.CONTACTS_UPDATE, contactsRaw);
 
+      if (this.localChatwoot.enabled) {
+        await this.chatwootService.eventWhatsapp(
+          Events.CONTACTS_UPDATE,
+          { instanceName: this.instance.name },
+          contactsRaw,
+        );
+      }
+
       this.logger.verbose('Updating contacts in database');
       await this.repository.contact.update(
         contactsRaw,
@@ -910,6 +1039,14 @@ export class WAStartupService {
       this.logger.verbose('Sending data to webhook in event MESSAGES_UPSERT');
       await this.sendDataWebhook(Events.MESSAGES_UPSERT, messageRaw);
 
+      if (this.localChatwoot.enabled) {
+        await this.chatwootService.eventWhatsapp(
+          Events.MESSAGES_UPSERT,
+          { instanceName: this.instance.name },
+          messageRaw,
+        );
+      }
+
       this.logger.verbose('Inserting message in database');
       await this.repository.message.insert(
         [messageRaw],
@@ -948,6 +1085,14 @@ export class WAStartupService {
         this.logger.verbose('Sending data to webhook in event CONTACTS_UPDATE');
         await this.sendDataWebhook(Events.CONTACTS_UPDATE, contactRaw);
 
+        if (this.localChatwoot.enabled) {
+          await this.chatwootService.eventWhatsapp(
+            Events.CONTACTS_UPDATE,
+            { instanceName: this.instance.name },
+            contactRaw,
+          );
+        }
+
         this.logger.verbose('Updating contact in database');
         await this.repository.contact.update(
           [contactRaw],
@@ -984,12 +1129,20 @@ export class WAStartupService {
         if (
           key.remoteJid !== 'status@broadcast' &&
           !key?.remoteJid?.match(/(:\d+)/) &&
-          !key.fromMe
+          key.fromMe
         ) {
+          this.logger.verbose('Message update is valid');
+
           let pollUpdates: any;
           if (update.pollUpdates) {
+            this.logger.verbose('Poll update found');
+
+            this.logger.verbose('Getting poll message');
             const pollCreation = await this.getMessage(key);
+            this.logger.verbose(pollCreation);
+
             if (pollCreation) {
+              this.logger.verbose('Getting aggregate votes in poll message');
               pollUpdates = getAggregateVotesInPollMessage({
                 message: pollCreation as proto.IMessage,
                 pollUpdates: update.pollUpdates,
@@ -1005,6 +1158,8 @@ export class WAStartupService {
             pollUpdates,
           };
 
+          this.logger.verbose(message);
+
           this.logger.verbose('Sending data to webhook in event MESSAGES_UPDATE');
           await this.sendDataWebhook(Events.MESSAGES_UPDATE, message);
 
@@ -1150,6 +1305,8 @@ export class WAStartupService {
         }
         return match[1] === '52' ? '52' + match[3] : '54' + match[3];
       }
+
+      return jid;
     }
     return jid;
   }
@@ -1167,6 +1324,7 @@ export class WAStartupService {
         }
         return match[1] + match[2] + match[3];
       }
+      return jid;
     } else {
       return jid;
     }
@@ -1193,6 +1351,7 @@ export class WAStartupService {
     }
 
     const formattedMXARNumber = this.formatMXOrARNumber(number);
+
     if (formattedMXARNumber !== number) {
       this.logger.verbose(
         'Jid created is whatsapp in format MXAR: ' +
@@ -1237,22 +1396,15 @@ export class WAStartupService {
     this.logger.verbose('Sending message with typing');
 
     const jid = this.createJid(number);
-    const isWA = (await this.whatsappNumber({ numbers: [jid] }))[0];
+    const numberWA = await this.whatsappNumber({ numbers: [jid] });
+    const isWA = numberWA[0];
+
     if (!isWA.exists && !isJidGroup(isWA.jid) && !isWA.jid.includes('@broadcast')) {
       throw new BadRequestException(isWA);
     }
 
     const sender = isJidGroup(jid) ? jid : isWA.jid;
 
-    if (isJidGroup(sender)) {
-      try {
-        this.logger.verbose('Getting group metadata');
-        await this.client.groupMetadata(sender);
-      } catch (error) {
-        throw new NotFoundException('Group not found');
-      }
-    }
-
     try {
       if (options?.delay) {
         this.logger.verbose('Delaying message');
@@ -1280,29 +1432,38 @@ export class WAStartupService {
       }
 
       let mentions: string[];
+      if (isJidGroup(sender)) {
+        try {
+          if (options?.mentions) {
+            this.logger.verbose('Mentions defined');
 
-      if (options?.mentions) {
-        this.logger.verbose('Mentions defined');
-
-        if (!Array.isArray(options.mentions.mentioned) && !options.mentions.everyOne) {
-          throw new BadRequestException('Mentions must be an array');
-        }
-
-        if (options.mentions.everyOne) {
-          this.logger.verbose('Mentions everyone');
-
-          const groupMetadata = await this.client.groupMetadata(sender);
-          mentions = groupMetadata.participants.map((participant) => participant.id);
-          this.logger.verbose('Getting group metadata for mentions');
-        } else {
-          this.logger.verbose('Mentions manually defined');
-          mentions = options.mentions.mentioned.map((mention) => {
-            const jid = this.createJid(mention);
-            if (isJidGroup(jid)) {
-              throw new BadRequestException('Mentions must be a number');
+            if (
+              !Array.isArray(options.mentions.mentioned) &&
+              !options.mentions.everyOne
+            ) {
+              throw new BadRequestException('Mentions must be an array');
             }
-            return jid;
-          });
+
+            if (options.mentions.everyOne) {
+              this.logger.verbose('Mentions everyone');
+
+              this.logger.verbose('Getting group metadata');
+              const groupMetadata = await this.client.groupMetadata(sender);
+              mentions = groupMetadata.participants.map((participant) => participant.id);
+              this.logger.verbose('Getting group metadata for mentions');
+            } else {
+              this.logger.verbose('Mentions manually defined');
+              mentions = options.mentions.mentioned.map((mention) => {
+                const jid = this.createJid(mention);
+                if (isJidGroup(jid)) {
+                  throw new BadRequestException('Mentions must be a number');
+                }
+                return jid;
+              });
+            }
+          }
+        } catch (error) {
+          throw new NotFoundException('Group not found');
         }
       }
 
@@ -1347,7 +1508,6 @@ export class WAStartupService {
 
         if (sender.includes('@broadcast')) {
           this.logger.verbose('Sending message');
-          console.log(message['status']);
           return await this.client.sendMessage(
             sender,
             message['status'].content as unknown as AnyMessageContent,
@@ -1367,21 +1527,35 @@ export class WAStartupService {
         );
       })();
 
-      const messageRaw: proto.IWebMessageInfo = {
+      const messageRaw: MessageRaw = {
         key: messageSent.key,
-        messageTimestamp: Long.isLong(messageSent.messageTimestamp)
-          ? messageSent.messageTimestamp?.toNumber()
-          : messageSent.messageTimestamp,
         pushName: messageSent.pushName,
-        broadcast: messageSent.broadcast,
-        status: 2,
         message: { ...messageSent.message },
+        messageType: getContentType(messageSent.message),
+        messageTimestamp: messageSent.messageTimestamp as number,
+        owner: this.instance.name,
+        source: getDevice(messageSent.key.id),
       };
 
-      this.client.ev.emit('messages.upsert', {
-        messages: [messageRaw],
-        type: 'notify',
-      });
+      this.logger.log(messageRaw);
+
+      this.logger.verbose('Sending data to webhook in event SEND_MESSAGE');
+      await this.sendDataWebhook(Events.SEND_MESSAGE, messageRaw);
+
+      // if (this.localChatwoot.enabled) {
+      //   this.chatwootService.eventWhatsapp(
+      //     Events.SEND_MESSAGE,
+      //     { instanceName: this.instance.name },
+      //     messageRaw,
+      //   );
+      // }
+
+      this.logger.verbose('Inserting message in database');
+      await this.repository.message.insert(
+        [messageRaw],
+        this.instance.name,
+        this.configService.get<Database>('DATABASE').SAVE_DATA.NEW_MESSAGE,
+      );
 
       return messageSent;
     } catch (error) {
@@ -1628,7 +1802,7 @@ export class WAStartupService {
       const hash = `${number}-${new Date().getTime()}`;
       this.logger.verbose('Hash to image name: ' + hash);
 
-      const outputPath = `${join(process.cwd(), 'temp', `${hash}.webp`)}`;
+      const outputPath = `${join(this.storePath, 'temp', `${hash}.webp`)}`;
       this.logger.verbose('Output path: ' + outputPath);
 
       if (isBase64(image)) {
@@ -1636,7 +1810,7 @@ export class WAStartupService {
 
         const base64Data = image.replace(/^data:image\/(jpeg|png|gif);base64,/, '');
         const imageBuffer = Buffer.from(base64Data, 'base64');
-        imagePath = `${join(process.cwd(), 'temp', `temp-${hash}.png`)}`;
+        imagePath = `${join(this.storePath, 'temp', `temp-${hash}.png`)}`;
         this.logger.verbose('Image path: ' + imagePath);
 
         await sharp(imageBuffer).toFile(imagePath);
@@ -1652,7 +1826,7 @@ export class WAStartupService {
         this.logger.verbose('Getting image from url');
 
         const imageBuffer = Buffer.from(response.data, 'binary');
-        imagePath = `${join(process.cwd(), 'temp', `temp-${hash}.png`)}`;
+        imagePath = `${join(this.storePath, 'temp', `temp-${hash}.png`)}`;
         this.logger.verbose('Image path: ' + imagePath);
 
         await sharp(imageBuffer).toFile(imagePath);
@@ -1710,8 +1884,8 @@ export class WAStartupService {
     if (isURL(audio)) {
       this.logger.verbose('Audio is url');
 
-      outputAudio = `${join(process.cwd(), 'temp', `${hash}.mp4`)}`;
-      tempAudioPath = `${join(process.cwd(), 'temp', `temp-${hash}.mp3`)}`;
+      outputAudio = `${join(this.storePath, 'temp', `${hash}.mp4`)}`;
+      tempAudioPath = `${join(this.storePath, 'temp', `temp-${hash}.mp3`)}`;
 
       this.logger.verbose('Output audio path: ' + outputAudio);
       this.logger.verbose('Temp audio path: ' + tempAudioPath);
@@ -1725,12 +1899,11 @@ export class WAStartupService {
       this.logger.verbose('Getting audio from url');
 
       fs.writeFileSync(tempAudioPath, response.data);
-      this.logger.verbose('Temp audio created');
     } else {
       this.logger.verbose('Audio is base64');
 
-      outputAudio = `${join(process.cwd(), 'temp', `${hash}.mp4`)}`;
-      tempAudioPath = `${join(process.cwd(), 'temp', `temp-${hash}.mp3`)}`;
+      outputAudio = `${join(this.storePath, 'temp', `${hash}.mp4`)}`;
+      tempAudioPath = `${join(this.storePath, 'temp', `temp-${hash}.mp3`)}`;
 
       this.logger.verbose('Output audio path: ' + outputAudio);
       this.logger.verbose('Temp audio path: ' + tempAudioPath);
@@ -1939,13 +2112,19 @@ export class WAStartupService {
       const jid = this.createJid(number);
       if (isJidGroup(jid)) {
         const group = await this.findGroup({ groupJid: jid }, 'inner');
+
+        if (!group) throw new BadRequestException('Group not found');
+
         onWhatsapp.push(new OnWhatsAppDto(group.id, !!group?.id, group?.subject));
       } else {
-        try {
-          const result = (await this.client.onWhatsApp(jid))[0];
+        const verify = await this.client.onWhatsApp(jid);
+
+        const result = verify[0];
+
+        if (!result) {
+          onWhatsapp.push(new OnWhatsAppDto(jid, false));
+        } else {
           onWhatsapp.push(new OnWhatsAppDto(result.jid, result.exists));
-        } catch (error) {
-          onWhatsapp.push(new OnWhatsAppDto(number, false));
         }
       }
     }
@@ -2399,10 +2578,34 @@ export class WAStartupService {
     }
   }
 
-  public async fetchAllGroups() {
+  public async fetchAllGroups(getParticipants: GetParticipant) {
     this.logger.verbose('Fetching all groups');
     try {
-      return await this.client.groupFetchAllParticipating();
+      const fetch = Object.values(await this.client.groupFetchAllParticipating());
+
+      const groups = fetch.map((group) => {
+        const result = {
+          id: group.id,
+          subject: group.subject,
+          subjectOwner: group.subjectOwner,
+          subjectTime: group.subjectTime,
+          size: group.size,
+          creation: group.creation,
+          owner: group.owner,
+          desc: group.desc,
+          descId: group.descId,
+          restrict: group.restrict,
+          announce: group.announce,
+        };
+
+        if (getParticipants.getParticipants == 'true') {
+          result['participants'] = group.participants;
+        }
+
+        return result;
+      });
+
+      return groups;
     } catch (error) {
       throw new NotFoundException('Error fetching group', error.toString());
     }

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',
+  SEND_MESSAGE = 'send.message',
   CONTACTS_SET = 'contacts.set',
   CONTACTS_UPSERT = 'contacts.upsert',
   CONTACTS_UPDATE = 'contacts.update',
@@ -40,6 +41,15 @@ export declare namespace wa {
     webhook_by_events?: boolean;
   };
 
+  export type LocalChatwoot = {
+    enabled?: boolean;
+    account_id?: string;
+    token?: string;
+    url?: string;
+    name_inbox?: string;
+    sign_msg?: boolean;
+  };
+
   export type StateConnection = {
     instance?: string;
     state?: WAConnectionState | 'refused';

src/whatsapp/whatsapp.module.ts

@@ -14,6 +14,8 @@ import { GroupController } from './controllers/group.controller';
 import { ViewsController } from './controllers/views.controller';
 import { WebhookService } from './services/webhook.service';
 import { WebhookController } from './controllers/webhook.controller';
+import { ChatwootService } from './services/chatwoot.service';
+import { ChatwootController } from './controllers/chatwoot.controller';
 import { RepositoryBroker } from './repository/repository.manager';
 import {
   AuthModel,
@@ -21,10 +23,12 @@ import {
   ContactModel,
   MessageModel,
   MessageUpModel,
+  ChatwootModel,
+  WebhookModel,
 } from './models';
 import { dbserver } from '../db/db.connect';
 import { WebhookRepository } from './repository/webhook.repository';
-import { WebhookModel } from './models/webhook.model';
+import { ChatwootRepository } from './repository/chatwoot.repository';
 import { AuthRepository } from './repository/auth.repository';
 import { WAStartupService } from './services/whatsapp.service';
 import { delay } from '@whiskeysockets/baileys';
@@ -38,6 +42,7 @@ const chatRepository = new ChatRepository(ChatModel, configService);
 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 authRepository = new AuthRepository(AuthModel, configService);
 
 export const repository = new RepositoryBroker(
@@ -46,6 +51,7 @@ export const repository = new RepositoryBroker(
   contactRepository,
   messageUpdateRepository,
   webhookRepository,
+  chatwootRepository,
   authRepository,
   configService,
   dbserver?.getClient(),
@@ -66,6 +72,10 @@ const webhookService = new WebhookService(waMonitor);
 
 export const webhookController = new WebhookController(webhookService);
 
+const chatwootService = new ChatwootService(waMonitor);
+
+export const chatwootController = new ChatwootController(chatwootService, configService);
+
 export const instanceController = new InstanceController(
   waMonitor,
   configService,
@@ -73,6 +83,7 @@ export const instanceController = new InstanceController(
   eventEmitter,
   authService,
   webhookService,
+  chatwootService,
   cache,
 );
 export const viewsController = new ViewsController(waMonitor, configService);
@@ -105,6 +116,17 @@ export async function initInstance() {
       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;
@@ -126,6 +148,22 @@ export async function initInstance() {
       }
     }
 
+    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;