Merge branch 'release/1.4.5'

* Fixed problems in localization template in chatwoot
* Fix mids going duplicated in chatwoot

CHANGELOG.md

@@ -1,3 +1,36 @@
+# 1.4.5 (2023-07-26 09:32)
+
+### Fixed
+
+* Fixed problems in localization template in chatwoot
+* Fix mids going duplicated in chatwoot
+
+# 1.4.4 (2023-07-25 15:24)
+
+### Fixed
+
+* Fixed chatwoot line wrap issue
+* Solved receive location in chatwoot
+* When requesting the pairing code, it also brings the qr code
+* Option reopen_conversation in chatwoot endpoint
+* Option conversation_pending in chatwoot endpoint
+
+# 1.4.3 (2023-07-25 10:51)
+
+### Fixed
+
+* Adjusts in settings with options always_online, read_messages and read_status
+* Fixed send webhook for event CALL
+* Create instance with settings
+
+# 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

Docker/.env.example

@@ -73,6 +73,7 @@ WEBHOOK_EVENTS_GROUPS_UPSERT=true
 WEBHOOK_EVENTS_GROUPS_UPDATE=true
 WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE=true
 WEBHOOK_EVENTS_CONNECTION_UPDATE=true
+WEBHOOK_EVENTS_CALL=true
 # This event fires every time a new token is requested via the refresh route
 WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
 

Dockerfile

@@ -74,6 +74,7 @@ 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 WEBHOOK_EVENTS_CALL=true
 
 ENV WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolution-api",
-  "version": "1.4.1",
+  "version": "1.4.5",
   "description": "Rest api for communication with WhatsApp",
   "main": "./dist/src/main.js",
   "scripts": {

src/config/env.config.ts

@@ -89,6 +89,7 @@ export type EventsWebhook = {
   GROUPS_UPSERT: boolean;
   GROUP_UPDATE: boolean;
   GROUP_PARTICIPANTS_UPDATE: boolean;
+  CALL: boolean;
   NEW_JWT_TOKEN: boolean;
 };
 
@@ -245,6 +246,7 @@ export class ConfigService {
           GROUP_UPDATE: process.env?.WEBHOOK_EVENTS_GROUPS_UPDATE === 'true',
           GROUP_PARTICIPANTS_UPDATE:
             process.env?.WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE === 'true',
+          CALL: process.env?.WEBHOOK_EVENTS_CALL === 'true',
           NEW_JWT_TOKEN: process.env?.WEBHOOK_EVENTS_NEW_JWT_TOKEN === 'true',
         },
       },

src/dev-env.yml

@@ -110,6 +110,7 @@ WEBHOOK:
     GROUP_UPDATE: true
     GROUP_PARTICIPANTS_UPDATE: true
     CONNECTION_UPDATE: true
+    CALL: true
     # This event fires every time a new token is requested via the refresh route
     NEW_JWT_TOKEN: false
 

src/validate/validate.schema.ts

@@ -53,6 +53,7 @@ export const instanceNameSchema: JSONSchema7 = {
           'GROUP_UPDATE',
           'GROUP_PARTICIPANTS_UPDATE',
           'CONNECTION_UPDATE',
+          'CALL',
           'NEW_JWT_TOKEN',
         ],
       },
@@ -455,7 +456,7 @@ export const readMessageSchema: JSONSchema7 = {
   $id: v4(),
   type: 'object',
   properties: {
-    readMessages: {
+    read_messages: {
       type: 'array',
       minItems: 1,
       uniqueItems: true,
@@ -470,7 +471,7 @@ export const readMessageSchema: JSONSchema7 = {
       },
     },
   },
-  required: ['readMessages'],
+  required: ['read_messages'],
 };
 
 export const privacySettingsSchema: JSONSchema7 = {
@@ -667,6 +668,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,
@@ -853,6 +855,7 @@ export const webhookSchema: JSONSchema7 = {
           'GROUP_UPDATE',
           'GROUP_PARTICIPANTS_UPDATE',
           'CONNECTION_UPDATE',
+          'CALL',
           'NEW_JWT_TOKEN',
         ],
       },
@@ -871,9 +874,26 @@ export const chatwootSchema: JSONSchema7 = {
     token: { type: 'string' },
     url: { type: 'string' },
     sign_msg: { type: 'boolean', enum: [true, false] },
+    reopen_conversation: { type: 'boolean', enum: [true, false] },
+    conversation_pending: { type: 'boolean', enum: [true, false] },
   },
-  required: ['enabled', 'account_id', 'token', 'url', 'sign_msg'],
+  required: [
-  ...isNotEmpty('account_id', 'token', 'url', 'sign_msg'),
+    'enabled',
+    'account_id',
+    'token',
+    'url',
+    'sign_msg',
+    'reopen_conversation',
+    'conversation_pending',
+  ],
+  ...isNotEmpty(
+    'account_id',
+    'token',
+    'url',
+    'sign_msg',
+    'reopen_conversation',
+    'conversation_pending',
+  ),
 };
 
 export const settingsSchema: JSONSchema7 = {
@@ -883,7 +903,22 @@ export const settingsSchema: JSONSchema7 = {
     reject_call: { type: 'boolean', enum: [true, false] },
     msg_call: { type: 'string' },
     groups_ignore: { type: 'boolean', enum: [true, false] },
+    always_online: { type: 'boolean', enum: [true, false] },
+    read_messages: { type: 'boolean', enum: [true, false] },
+    read_status: { type: 'boolean', enum: [true, false] },
   },
-  required: ['reject_call'],
+  required: [
-  ...isNotEmpty('reject_call'),
+    'reject_call',
+    'groups_ignore',
+    'always_online',
+    'read_messages',
+    'read_status',
+  ],
+  ...isNotEmpty(
+    'reject_call',
+    'groups_ignore',
+    'always_online',
+    'read_messages',
+    'read_status',
+  ),
 };

src/whatsapp/controllers/chatwoot.controller.ts

@@ -44,6 +44,8 @@ export class ChatwootController {
       data.token = '';
       data.url = '';
       data.sign_msg = false;
+      data.reopen_conversation = false;
+      data.conversation_pending = false;
     }
 
     data.name_inbox = instance.instanceName;

src/whatsapp/controllers/instance.controller.ts

@@ -13,6 +13,7 @@ import { Logger } from '../../config/logger.config';
 import { wa } from '../types/wa.types';
 import { RedisCache } from '../../db/redis.client';
 import { isURL } from 'class-validator';
+import { SettingsService } from '../services/settings.service';
 
 export class InstanceController {
   constructor(
@@ -23,6 +24,7 @@ export class InstanceController {
     private readonly authService: AuthService,
     private readonly webhookService: WebhookService,
     private readonly chatwootService: ChatwootService,
+    private readonly settingsService: SettingsService,
     private readonly cache: RedisCache,
   ) {}
 
@@ -40,78 +42,180 @@ export class InstanceController {
     chatwoot_token,
     chatwoot_url,
     chatwoot_sign_msg,
+    chatwoot_reopen_conversation,
+    chatwoot_conversation_pending,
+    reject_call,
+    msg_call,
+    groups_ignore,
+    always_online,
+    read_messages,
+    read_status,
   }: InstanceDto) {
-    this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
+    try {
+      this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
 
-    if (instanceName !== instanceName.toLowerCase().replace(/[^a-z0-9]/g, '')) {
+      if (instanceName !== instanceName.toLowerCase().replace(/[^a-z0-9]/g, '')) {
-      throw new BadRequestException(
+        throw new BadRequestException(
-        'The instance name must be lowercase and without special characters',
+          'The instance name must be lowercase and without special characters',
-      );
+        );
-    }
-
-    this.logger.verbose('checking duplicate token');
-    await this.authService.checkDuplicateToken(token);
-
-    this.logger.verbose('creating instance');
-    const instance = new WAStartupService(
-      this.configService,
-      this.eventEmitter,
-      this.repository,
-      this.cache,
-    );
-    instance.instanceName = instanceName
-      .toLowerCase()
-      .replace(/[^a-z0-9]/g, '')
-      .replace(' ', '');
-
-    this.logger.verbose('instance: ' + instance.instanceName + ' created');
-
-    this.waMonitor.waInstances[instance.instanceName] = instance;
-    this.waMonitor.delInstanceTime(instance.instanceName);
-
-    this.logger.verbose('generating hash');
-    const hash = await this.authService.generateHash(
-      {
-        instanceName: instance.instanceName,
-      },
-      token,
-    );
-
-    this.logger.verbose('hash: ' + hash + ' generated');
-
-    let getEvents: string[];
-
-    if (webhook) {
-      if (!isURL(webhook, { require_tld: false })) {
-        throw new BadRequestException('Invalid "url" property in webhook');
       }
 
-      this.logger.verbose('creating webhook');
+      this.logger.verbose('checking duplicate token');
-      try {
+      await this.authService.checkDuplicateToken(token);
-        this.webhookService.create(instance, {
+
-          enabled: true,
+      this.logger.verbose('creating instance');
-          url: webhook,
+      const instance = new WAStartupService(
-          events,
+        this.configService,
+        this.eventEmitter,
+        this.repository,
+        this.cache,
+      );
+      instance.instanceName = instanceName
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '')
+        .replace(' ', '');
+
+      this.logger.verbose('instance: ' + instance.instanceName + ' created');
+
+      this.waMonitor.waInstances[instance.instanceName] = instance;
+      this.waMonitor.delInstanceTime(instance.instanceName);
+
+      this.logger.verbose('generating hash');
+      const hash = await this.authService.generateHash(
+        {
+          instanceName: instance.instanceName,
+        },
+        token,
+      );
+
+      this.logger.verbose('hash: ' + hash + ' generated');
+
+      let getEvents: string[];
+
+      if (webhook) {
+        if (!isURL(webhook, { require_tld: false })) {
+          throw new BadRequestException('Invalid "url" property in webhook');
+        }
+
+        this.logger.verbose('creating webhook');
+        try {
+          this.webhookService.create(instance, {
+            enabled: true,
+            url: webhook,
+            events,
+            webhook_by_events,
+          });
+
+          getEvents = (await this.webhookService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      this.logger.verbose('creating settings');
+      const settings: wa.LocalSettings = {
+        reject_call: reject_call || false,
+        msg_call: msg_call || '',
+        groups_ignore: groups_ignore || false,
+        always_online: always_online || false,
+        read_messages: read_messages || false,
+        read_status: read_status || false,
+      };
+
+      this.logger.verbose('settings: ' + JSON.stringify(settings));
+
+      this.settingsService.create(instance, settings);
+
+      if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
+        let getQrcode: wa.QrCode;
+
+        if (qrcode) {
+          this.logger.verbose('creating qrcode');
+          await instance.connectToWhatsapp(number);
+          await delay(5000);
+          getQrcode = instance.qrCode;
+        }
+
+        const result = {
+          instance: {
+            instanceName: instance.instanceName,
+            status: 'created',
+          },
+          hash,
+          webhook,
           webhook_by_events,
+          events: getEvents,
+          settings,
+          qrcode: getQrcode,
+        };
+
+        this.logger.verbose('instance created');
+        this.logger.verbose(result);
+
+        return result;
+      }
+
+      if (!chatwoot_account_id) {
+        throw new BadRequestException('account_id is required');
+      }
+
+      if (!chatwoot_token) {
+        throw new BadRequestException('token is required');
+      }
+
+      if (!chatwoot_url) {
+        throw new BadRequestException('url is required');
+      }
+
+      if (!isURL(chatwoot_url, { require_tld: false })) {
+        throw new BadRequestException('Invalid "url" property in chatwoot');
+      }
+
+      if (chatwoot_sign_msg !== true && chatwoot_sign_msg !== false) {
+        throw new BadRequestException('sign_msg is required');
+      }
+
+      if (
+        chatwoot_reopen_conversation !== true &&
+        chatwoot_reopen_conversation !== false
+      ) {
+        throw new BadRequestException('reopen_conversation is required');
+      }
+
+      if (
+        chatwoot_conversation_pending !== true &&
+        chatwoot_conversation_pending !== false
+      ) {
+        throw new BadRequestException('conversation_pending is required');
+      }
+
+      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+      try {
+        this.chatwootService.create(instance, {
+          enabled: true,
+          account_id: chatwoot_account_id,
+          token: chatwoot_token,
+          url: chatwoot_url,
+          sign_msg: chatwoot_sign_msg || false,
+          name_inbox: instance.instanceName,
+          number,
+          reopen_conversation: chatwoot_reopen_conversation || false,
+          conversation_pending: chatwoot_conversation_pending || false,
         });
 
-        getEvents = (await this.webhookService.find(instance)).events;
+        this.chatwootService.initInstanceChatwoot(
+          instance,
+          instance.instanceName,
+          `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+          qrcode,
+          number,
+        );
       } catch (error) {
         this.logger.log(error);
       }
-    }
 
-    if (!chatwoot_account_id || !chatwoot_token || !chatwoot_url) {
+      return {
-      let getQrcode: wa.QrCode;
-
-      if (qrcode) {
-        this.logger.verbose('creating qrcode');
-        await instance.connectToWhatsapp(number);
-        await delay(5000);
-        getQrcode = instance.qrCode;
-      }
-
-      const result = {
         instance: {
           instanceName: instance.instanceName,
           status: 'created',
@@ -120,75 +224,24 @@ export class InstanceController {
         webhook,
         webhook_by_events,
         events: getEvents,
-        qrcode: getQrcode,
+        settings,
+        chatwoot: {
+          enabled: true,
+          account_id: chatwoot_account_id,
+          token: chatwoot_token,
+          url: chatwoot_url,
+          sign_msg: chatwoot_sign_msg || false,
+          reopen_conversation: chatwoot_reopen_conversation || false,
+          conversation_pending: chatwoot_conversation_pending || false,
+          number,
+          name_inbox: instance.instanceName,
+          webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
+        },
       };
-
-      this.logger.verbose('instance created');
-      this.logger.verbose(result);
-
-      return result;
-    }
-
-    if (!chatwoot_account_id) {
-      throw new BadRequestException('account_id is required');
-    }
-
-    if (!chatwoot_token) {
-      throw new BadRequestException('token is required');
-    }
-
-    if (!chatwoot_url) {
-      throw new BadRequestException('url is required');
-    }
-
-    if (!isURL(chatwoot_url, { require_tld: false })) {
-      throw new BadRequestException('Invalid "url" property in chatwoot');
-    }
-
-    const urlServer = this.configService.get<HttpServer>('SERVER').URL;
-
-    try {
-      this.chatwootService.create(instance, {
-        enabled: true,
-        account_id: chatwoot_account_id,
-        token: chatwoot_token,
-        url: chatwoot_url,
-        sign_msg: chatwoot_sign_msg || false,
-        name_inbox: instance.instanceName,
-        number,
-      });
-
-      this.chatwootService.initInstanceChatwoot(
-        instance,
-        instance.instanceName,
-        `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-        qrcode,
-        number,
-      );
     } catch (error) {
-      this.logger.log(error);
+      console.log(error);
+      return { error: true, message: error.toString() };
     }
-
-    return {
-      instance: {
-        instanceName: instance.instanceName,
-        status: 'created',
-      },
-      hash,
-      webhook,
-      webhook_by_events,
-      events: getEvents,
-      chatwoot: {
-        enabled: true,
-        account_id: chatwoot_account_id,
-        token: chatwoot_token,
-        url: chatwoot_url,
-        sign_msg: chatwoot_sign_msg || false,
-        number,
-        name_inbox: instance.instanceName,
-        webhook_url: `${urlServer}/chatwoot/webhook/${instance.instanceName}`,
-      },
-    };
   }
 
   public async connectToWhatsapp({ instanceName, number = null }: InstanceDto) {

src/whatsapp/controllers/settings.controller.ts

@@ -15,10 +15,6 @@ export class SettingsController {
       'requested createSettings from ' + instance.instanceName + ' instance',
     );
 
-    if (data.reject_call && data.msg_call.trim() == '') {
-      throw new BadRequestException('msg_call is required');
-    }
-
     return this.settingsService.create(instance, data);
   }
 

src/whatsapp/dto/chat.dto.ts

@@ -59,7 +59,7 @@ class Key {
   remoteJid: string;
 }
 export class ReadMessageDto {
-  readMessages: Key[];
+  read_messages: Key[];
 }
 
 class LastMessage {

src/whatsapp/dto/chatwoot.dto.ts

@@ -6,4 +6,6 @@ export class ChatwootDto {
   name_inbox?: string;
   sign_msg?: boolean;
   number?: string;
+  reopen_conversation?: boolean;
+  conversation_pending?: boolean;
 }

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

@@ -1,13 +1,21 @@
 export class InstanceDto {
   instanceName: string;
-  webhook?: string;
-  webhook_by_events?: boolean;
-  events?: string[];
   qrcode?: boolean;
   number?: string;
   token?: string;
+  webhook?: string;
+  webhook_by_events?: boolean;
+  events?: string[];
+  reject_call?: boolean;
+  msg_call?: string;
+  groups_ignore?: boolean;
+  always_online?: boolean;
+  read_messages?: boolean;
+  read_status?: boolean;
   chatwoot_account_id?: string;
   chatwoot_token?: string;
   chatwoot_url?: string;
   chatwoot_sign_msg?: boolean;
+  chatwoot_reopen_conversation?: boolean;
+  chatwoot_conversation_pending?: boolean;
 }

src/whatsapp/dto/settings.dto.ts

@@ -2,4 +2,7 @@ export class SettingsDto {
   reject_call?: boolean;
   msg_call?: string;
   groups_ignore?: boolean;
+  always_online?: boolean;
+  read_messages?: boolean;
+  read_status?: boolean;
 }

src/whatsapp/models/chatwoot.model.ts

@@ -10,6 +10,8 @@ export class ChatwootRaw {
   name_inbox?: string;
   sign_msg?: boolean;
   number?: string;
+  reopen_conversation?: boolean;
+  conversation_pending?: boolean;
 }
 
 const chatwootSchema = new Schema<ChatwootRaw>({

src/whatsapp/models/settings.model.ts

@@ -6,6 +6,9 @@ export class SettingsRaw {
   reject_call?: boolean;
   msg_call?: string;
   groups_ignore?: boolean;
+  always_online?: boolean;
+  read_messages?: boolean;
+  read_status?: boolean;
 }
 
 const settingsSchema = new Schema<SettingsRaw>({
@@ -13,6 +16,9 @@ const settingsSchema = new Schema<SettingsRaw>({
   reject_call: { type: Boolean, required: true },
   msg_call: { type: String, required: true },
   groups_ignore: { type: Boolean, required: true },
+  always_online: { type: Boolean, required: true },
+  read_messages: { type: Boolean, required: true },
+  read_status: { type: Boolean, required: true },
 });
 
 export const SettingsModel = dbserver?.model(

src/whatsapp/repository/repository.manager.ts

@@ -102,7 +102,12 @@ export class RepositoryBroker {
       this.logger.verbose('creating store path: ' + storePath);
 
       const tempDir = join(storePath, 'temp');
+      const chatwootDir = join(storePath, 'chatwoot');
 
+      if (!fs.existsSync(chatwootDir)) {
+        this.logger.verbose('creating chatwoot dir: ' + chatwootDir);
+        fs.mkdirSync(chatwootDir, { recursive: true });
+      }
       if (!fs.existsSync(tempDir)) {
         this.logger.verbose('creating temp dir: ' + tempDir);
         fs.mkdirSync(tempDir, { recursive: true });

src/whatsapp/services/chatwoot.service.ts

@@ -13,6 +13,7 @@ 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';
+import { type } from 'os';
 
 export class ChatwootService {
   private messageCacheFile: string;
@@ -230,12 +231,18 @@ export class ChatwootService {
 
     if (qrcode) {
       this.logger.verbose('create conversation in chatwoot');
+      const data = {
+        contact_id: contactId.toString(),
+        inbox_id: inboxId.toString(),
+      };
+
+      if (this.provider.conversation_pending) {
+        data['status'] = 'pending';
+      }
+
       const conversation = await client.conversations.create({
         accountId: this.provider.account_id,
-        data: {
+        data,
-          contact_id: contactId.toString(),
-          inbox_id: inboxId.toString(),
-        },
       });
 
       if (!conversation) {
@@ -520,11 +527,20 @@ export class ChatwootService {
       })) as any;
 
       if (contactConversations) {
+        let conversation: any;
+        if (this.provider.reopen_conversation) {
+          conversation = contactConversations.payload.find(
+            (conversation) => conversation.inbox_id == filterInbox.id,
+          );
+        } else {
+          conversation = contactConversations.payload.find(
+            (conversation) =>
+              conversation.status !== 'resolved' &&
+              conversation.inbox_id == filterInbox.id,
+          );
+        }
         this.logger.verbose('return conversation if exists');
-        const conversation = contactConversations.payload.find(
+
-          (conversation) =>
-            conversation.status !== 'resolved' && conversation.inbox_id == filterInbox.id,
-        );
         if (conversation) {
           this.logger.verbose('conversation found');
           return conversation.id;
@@ -532,12 +548,18 @@ export class ChatwootService {
       }
 
       this.logger.verbose('create conversation in chatwoot');
+      const data = {
+        contact_id: contactId.toString(),
+        inbox_id: filterInbox.id.toString(),
+      };
+
+      if (this.provider.conversation_pending) {
+        data['status'] = 'pending';
+      }
+
       const conversation = await client.conversations.create({
         accountId: this.provider.account_id,
-        data: {
+        data,
-          contact_id: `${contactId}`,
-          inbox_id: `${filterInbox.id}`,
-        },
       });
 
       if (!conversation) {
@@ -1125,12 +1147,12 @@ export class ChatwootService {
       }
 
       if (body.message_type === 'template' && body.event === 'message_created') {
-        this.logger.verbose('check if is csat');
+        this.logger.verbose('check if is template');
 
         const data: SendTextDto = {
           number: chatId,
           textMessage: {
-            text: body.content,
+            text: body.content.replace(/\\\r\n|\\\n|\n/g, '\n'),
           },
           options: {
             delay: 1200,
@@ -1179,13 +1201,15 @@ 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,
+      locationMessage: msg.locationMessage,
+      liveLocationMessage: msg.liveLocationMessage,
     };
 
     this.logger.verbose('type message: ' + types);
@@ -1199,8 +1223,19 @@ export class ChatwootService {
 
     const result = typeKey ? types[typeKey] : undefined;
 
-    if (typeKey === 'stickerMessage') {
+    if (typeKey === 'locationMessage' || typeKey === 'liveLocationMessage') {
-      return null;
+      const latitude = result.degreesLatitude;
+      const longitude = result.degreesLongitude;
+
+      const formattedLocation = `**Location:**
+        **latitude:** ${latitude}
+        **longitude:** ${longitude}
+        https://www.google.com/maps/search/?api=1&query=${latitude},${longitude}
+        `;
+
+      this.logger.verbose('message content: ' + formattedLocation);
+
+      return formattedLocation;
     }
 
     if (typeKey === 'contactMessage') {

src/whatsapp/services/whatsapp.service.ts

@@ -116,16 +116,15 @@ import { useMultiFileAuthStateDb } from '../../utils/use-multi-file-auth-state-d
 import Long from 'long';
 import { WebhookRaw } from '../models/webhook.model';
 import { ChatwootRaw } from '../models/chatwoot.model';
+import { SettingsRaw } from '../models';
 import { dbserver } from '../../db/db.connect';
 import NodeCache from 'node-cache';
 import { useMultiFileAuthStateRedisDb } from '../../utils/use-multi-file-auth-state-redis-db';
 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';
-import { SettingsRaw } from '../models';
 
 export class WAStartupService {
   constructor(
@@ -243,13 +242,9 @@ export class WAStartupService {
 
   public get qrCode(): wa.QrCode {
     this.logger.verbose('Getting qrcode');
-    if (this.instance.qrcode?.pairingCode) {
-      return {
-        pairingCode: this.instance.qrcode?.pairingCode,
-      };
-    }
 
     return {
+      pairingCode: this.instance.qrcode?.pairingCode,
       code: this.instance.qrcode?.code,
       base64: this.instance.qrcode?.base64,
     };
@@ -317,6 +312,19 @@ export class WAStartupService {
     this.localChatwoot.sign_msg = data?.sign_msg;
     this.logger.verbose(`Chatwoot sign msg: ${this.localChatwoot.sign_msg}`);
 
+    this.localChatwoot.number = data?.number;
+    this.logger.verbose(`Chatwoot number: ${this.localChatwoot.number}`);
+
+    this.localChatwoot.reopen_conversation = data?.reopen_conversation;
+    this.logger.verbose(
+      `Chatwoot reopen conversation: ${this.localChatwoot.reopen_conversation}`,
+    );
+
+    this.localChatwoot.conversation_pending = data?.conversation_pending;
+    this.logger.verbose(
+      `Chatwoot conversation pending: ${this.localChatwoot.conversation_pending}`,
+    );
+
     this.logger.verbose('Chatwoot loaded');
   }
 
@@ -328,6 +336,8 @@ export class WAStartupService {
     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}`);
+    this.logger.verbose(`Chatwoot reopen conversation: ${data.reopen_conversation}`);
+    this.logger.verbose(`Chatwoot conversation pending: ${data.conversation_pending}`);
 
     Object.assign(this.localChatwoot, data);
     this.logger.verbose('Chatwoot set');
@@ -347,6 +357,8 @@ export class WAStartupService {
     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}`);
+    this.logger.verbose(`Chatwoot reopen conversation: ${data.reopen_conversation}`);
+    this.logger.verbose(`Chatwoot conversation pending: ${data.conversation_pending}`);
 
     return data;
   }
@@ -363,6 +375,15 @@ export class WAStartupService {
     this.localSettings.groups_ignore = data?.groups_ignore;
     this.logger.verbose(`Settings groups_ignore: ${this.localSettings.groups_ignore}`);
 
+    this.localSettings.always_online = data?.always_online;
+    this.logger.verbose(`Settings always_online: ${this.localSettings.always_online}`);
+
+    this.localSettings.read_messages = data?.read_messages;
+    this.logger.verbose(`Settings read_messages: ${this.localSettings.read_messages}`);
+
+    this.localSettings.read_status = data?.read_status;
+    this.logger.verbose(`Settings read_status: ${this.localSettings.read_status}`);
+
     this.logger.verbose('Settings loaded');
   }
 
@@ -372,8 +393,13 @@ export class WAStartupService {
     this.logger.verbose(`Settings reject_call: ${data.reject_call}`);
     this.logger.verbose(`Settings msg_call: ${data.msg_call}`);
     this.logger.verbose(`Settings groups_ignore: ${data.groups_ignore}`);
+    this.logger.verbose(`Settings always_online: ${data.always_online}`);
+    this.logger.verbose(`Settings read_messages: ${data.read_messages}`);
+    this.logger.verbose(`Settings read_status: ${data.read_status}`);
     Object.assign(this.localSettings, data);
     this.logger.verbose('Settings set');
+
+    this.client?.ws?.close();
   }
 
   public async findSettings() {
@@ -382,12 +408,15 @@ export class WAStartupService {
 
     if (!data) {
       this.logger.verbose('Settings not found');
-      throw new NotFoundException('Settings not found');
+      return null;
     }
 
     this.logger.verbose(`Settings url: ${data.reject_call}`);
     this.logger.verbose(`Settings msg_call: ${data.msg_call}`);
     this.logger.verbose(`Settings groups_ignore: ${data.groups_ignore}`);
+    this.logger.verbose(`Settings always_online: ${data.always_online}`);
+    this.logger.verbose(`Settings read_messages: ${data.read_messages}`);
+    this.logger.verbose(`Settings read_status: ${data.read_status}`);
     return data;
   }
 
@@ -606,7 +635,6 @@ export class WAStartupService {
         color: { light: '#ffffff', dark: '#198754' },
       };
 
-      console.log(this.phoneNumber);
       if (this.phoneNumber) {
         await delay(2000);
         this.instance.qrcode.pairingCode = await this.client.requestPairingCode(
@@ -848,6 +876,7 @@ export class WAStartupService {
         printQRInTerminal: false,
         browser,
         version,
+        markOnlineOnConnect: this.localSettings.always_online,
         connectTimeoutMs: 60_000,
         qrTimeout: 40_000,
         defaultQueryTimeoutMs: undefined,
@@ -1118,7 +1147,7 @@ export class WAStartupService {
 
       if (
         type !== 'notify' ||
-        // received.message?.protocolMessage ||
+        received.message?.protocolMessage ||
         received.message?.pollUpdateMessage
       ) {
         this.logger.verbose('message rejected');
@@ -1129,7 +1158,7 @@ export class WAStartupService {
         received.messageTimestamp = received.messageTimestamp?.toNumber();
       }
 
-      if (settings.groups_ignore && received.key.remoteJid.includes('@g.us')) {
+      if (settings?.groups_ignore && received.key.remoteJid.includes('@g.us')) {
         this.logger.verbose('group ignored');
         return;
       }
@@ -1144,6 +1173,14 @@ export class WAStartupService {
         source: getDevice(received.key.id),
       };
 
+      if (this.localSettings.read_messages && received.key.id !== 'status@broadcast') {
+        await this.client.readMessages([received.key]);
+      }
+
+      if (this.localSettings.read_status && received.key.id === 'status@broadcast') {
+        await this.client.readMessages([received.key]);
+      }
+
       this.logger.log(messageRaw);
 
       this.logger.verbose('Sending data to webhook in event MESSAGES_UPSERT');
@@ -1240,7 +1277,7 @@ export class WAStartupService {
         5: 'PLAYED',
       };
       for await (const { key, update } of args) {
-        if (settings.groups_ignore && key.remoteJid.includes('@g.us')) {
+        if (settings?.groups_ignore && key.remoteJid.includes('@g.us')) {
           this.logger.verbose('group ignored');
           return;
         }
@@ -1363,11 +1400,15 @@ export class WAStartupService {
               text: settings.msg_call,
             });
 
+            this.logger.verbose('Sending data to event messages.upsert');
             this.client.ev.emit('messages.upsert', {
               messages: [msg],
               type: 'notify',
             });
           }
+
+          this.logger.verbose('Sending data to webhook in event CALL');
+          this.sendDataWebhook(Events.CALL, call);
         }
 
         if (events['connection.update']) {
@@ -1517,7 +1558,7 @@ export class WAStartupService {
       .split(/\:/)[0]
       .split('@')[0];
 
-    if (number.length >= 18) {
+    if (number.includes('-') && number.length >= 24) {
       this.logger.verbose('Jid created is group: ' + `${number}@g.us`);
       number = number.replace(/[^\d-]/g, '');
       return `${number}@g.us`;
@@ -1525,6 +1566,12 @@ export class WAStartupService {
 
     number = number.replace(/\D/g, '');
 
+    if (number.length >= 18) {
+      this.logger.verbose('Jid created is group: ' + `${number}@g.us`);
+      number = number.replace(/[^\d-]/g, '');
+      return `${number}@g.us`;
+    }
+
     this.logger.verbose('Jid created is whatsapp: ' + `${number}@s.whatsapp.net`);
     return `${number}@s.whatsapp.net`;
   }
@@ -1686,20 +1733,13 @@ export class WAStartupService {
           if (options?.mentions) {
             this.logger.verbose('Mentions defined');
 
-            if (
+            if (options.mentions?.everyOne) {
-              !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');
 
               this.logger.verbose('Getting group metadata');
               mentions = groupMetadata.participants.map((participant) => participant.id);
               this.logger.verbose('Getting group metadata for mentions');
-            } else {
+            } else if (options.mentions?.mentioned?.length) {
               this.logger.verbose('Mentions manually defined');
               mentions = options.mentions.mentioned.map((mention) => {
                 const jid = this.createJid(mention);
@@ -2402,7 +2442,7 @@ export class WAStartupService {
     this.logger.verbose('Marking message as read');
     try {
       const keys: proto.IMessageKey[] = [];
-      data.readMessages.forEach((read) => {
+      data.read_messages.forEach((read) => {
         if (isJidGroup(read.remoteJid) || isJidUser(read.remoteJid)) {
           keys.push({
             remoteJid: read.remoteJid,
@@ -2642,7 +2682,6 @@ export class WAStartupService {
       await this.client.updateGroupsAddPrivacy(settings.privacySettings.groupadd);
       this.logger.verbose('Groups add privacy updated');
 
-      // reinicia a instancia
       this.client?.ws?.close();
 
       return {
@@ -2782,10 +2821,19 @@ export class WAStartupService {
         await this.client.groupUpdateDescription(id, create.description);
       }
 
+      if (create?.promoteParticipants) {
+        this.logger.verbose('Prometing group participants: ' + create.description);
+        await this.updateGParticipant({
+          groupJid: id,
+          action: 'promote',
+          participants: participants,
+        });
+      }
+
       const group = await this.client.groupMetadata(id);
       this.logger.verbose('Getting group metadata');
 
-      return { groupMetadata: group };
+      return group;
     } catch (error) {
       this.logger.error(error);
       throw new InternalServerErrorException('Error creating group', error.toString());

src/whatsapp/types/wa.types.ts

@@ -22,6 +22,7 @@ export enum Events {
   GROUPS_UPSERT = 'groups.upsert',
   GROUPS_UPDATE = 'groups.update',
   GROUP_PARTICIPANTS_UPDATE = 'group-participants.update',
+  CALL = 'call',
 }
 
 export declare namespace wa {
@@ -55,12 +56,18 @@ export declare namespace wa {
     url?: string;
     name_inbox?: string;
     sign_msg?: boolean;
+    number?: string;
+    reopen_conversation?: boolean;
+    conversation_pending?: boolean;
   };
 
   export type LocalSettings = {
     reject_call?: boolean;
     msg_call?: string;
     groups_ignore?: boolean;
+    always_online?: boolean;
+    read_messages?: boolean;
+    read_status?: boolean;
   };
 
   export type StateConnection = {

src/whatsapp/whatsapp.module.ts

@@ -94,6 +94,7 @@ export const instanceController = new InstanceController(
   authService,
   webhookService,
   chatwootService,
+  settingsService,
   cache,
 );
 export const viewsController = new ViewsController(waMonitor, configService);