chore: chatwoot verbose logs

Author: DavidsonGomes

CHANGELOG.md

@@ -18,6 +18,7 @@
 * Update baileys version
 * Update in Baileys version that fixes timeout when updating profile picture
 * Adjusts for fix timeout error on send status message
+* Chatwoot verbose logs
 
 # 2.1.1 (2024-09-22 10:31)
 

src/api/integrations/channel/whatsapp/whatsapp.baileys.service.ts

@@ -1195,10 +1195,11 @@ export class BaileysStartupService extends ChannelStartupService {
               );
             }
 
-            this.prismaRepository.contact.updateMany({
-              where: { remoteJid: received.key.remoteJid, instanceId: this.instanceId },
-              data: contactRaw,
-            });
+            if (this.configService.get<Database>('DATABASE').SAVE_DATA.CONTACTS)
+              await this.prismaRepository.contact.create({
+                data: contactRaw,
+              });
+
             return;
           }
 

src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts

@@ -538,26 +538,37 @@ export class ChatwootService {
 
   public async createConversation(instance: InstanceDto, body: any) {
     try {
+      this.logger.verbose('--- Start createConversation ---');
+      this.logger.verbose(`Instance: ${JSON.stringify(instance)}`);
+      this.logger.verbose(`Body: ${JSON.stringify(body)}`);
+
       const client = await this.clientCw(instance);
 
       if (!client) {
-        this.logger.warn('client not found');
+        this.logger.warn(`Client not found for instance: ${JSON.stringify(instance)}`);
         return null;
       }
 
       const cacheKey = `${instance.instanceName}:createConversation-${body.key.remoteJid}`;
+      this.logger.verbose(`Cache key: ${cacheKey}`);
+
       if (await this.cache.has(cacheKey)) {
+        this.logger.verbose(`Cache hit for key: ${cacheKey}`);
         const conversationId = (await this.cache.get(cacheKey)) as number;
+        this.logger.verbose(`Cached conversation ID: ${conversationId}`);
         let conversationExists: conversation | boolean;
         try {
           conversationExists = await client.conversations.get({
             accountId: this.provider.accountId,
             conversationId: conversationId,
           });
+          this.logger.verbose(`Conversation exists: ${JSON.stringify(conversationExists)}`);
         } catch (error) {
+          this.logger.error(`Error getting conversation: ${error}`);
           conversationExists = false;
         }
         if (!conversationExists) {
+          this.logger.verbose('Conversation does not exist, re-calling createConversation');
           this.cache.delete(cacheKey);
           return await this.createConversation(instance, body);
         }
@@ -566,30 +577,37 @@ export class ChatwootService {
       }
 
       const isGroup = body.key.remoteJid.includes('@g.us');
+      this.logger.verbose(`Is group: ${isGroup}`);
 
       const chatId = isGroup ? body.key.remoteJid : body.key.remoteJid.split('@')[0];
+      this.logger.verbose(`Chat ID: ${chatId}`);
 
       let nameContact: string;
 
       nameContact = !body.key.fromMe ? body.pushName : chatId;
+      this.logger.verbose(`Name contact: ${nameContact}`);
 
       const filterInbox = await this.getInbox(instance);
 
       if (!filterInbox) {
-        this.logger.warn('inbox not found');
+        this.logger.warn(`Inbox not found for instance: ${JSON.stringify(instance)}`);
         return null;
       }
 
       if (isGroup) {
+        this.logger.verbose('Processing group conversation');
         const group = await this.waMonitor.waInstances[instance.instanceName].client.groupMetadata(chatId);
+        this.logger.verbose(`Group metadata: ${JSON.stringify(group)}`);
 
         nameContact = `${group.subject} (GROUP)`;
 
         const picture_url = await this.waMonitor.waInstances[instance.instanceName].profilePicture(
           body.key.participant.split('@')[0],
         );
+        this.logger.verbose(`Participant profile picture URL: ${JSON.stringify(picture_url)}`);
 
         const findParticipant = await this.findContact(instance, body.key.participant.split('@')[0]);
+        this.logger.verbose(`Found participant: ${JSON.stringify(findParticipant)}`);
 
         if (findParticipant) {
           if (!findParticipant.name || findParticipant.name === chatId) {
@@ -612,8 +630,10 @@ export class ChatwootService {
       }
 
       const picture_url = await this.waMonitor.waInstances[instance.instanceName].profilePicture(chatId);
+      this.logger.verbose(`Contact profile picture URL: ${JSON.stringify(picture_url)}`);
 
       let contact = await this.findContact(instance, chatId);
+      this.logger.verbose(`Found contact: ${JSON.stringify(contact)}`);
 
       if (contact) {
         if (!body.key.fromMe) {
@@ -630,8 +650,10 @@ export class ChatwootService {
                 )
               : false);
 
-          const contactNeedsUpdate = pictureNeedsUpdate || nameNeedsUpdate;
-          if (contactNeedsUpdate) {
+          this.logger.verbose(`Picture needs update: ${pictureNeedsUpdate}`);
+          this.logger.verbose(`Name needs update: ${nameNeedsUpdate}`);
+
+          if (pictureNeedsUpdate || nameNeedsUpdate) {
             contact = await this.updateContact(instance, contact.id, {
               ...(nameNeedsUpdate && { name: nameContact }),
               ...(waProfilePictureFile === '' && { avatar: null }),
@@ -653,38 +675,50 @@ export class ChatwootService {
       }
 
       if (!contact) {
-        this.logger.warn('contact not found');
+        this.logger.warn('Contact not created or found');
         return null;
       }
 
       const contactId = contact?.payload?.id || contact?.payload?.contact?.id || contact?.id;
+      this.logger.verbose(`Contact ID: ${contactId}`);
 
       const contactConversations = (await client.contacts.listConversations({
         accountId: this.provider.accountId,
         id: contactId,
       })) as any;
+      this.logger.verbose(`Contact conversations: ${JSON.stringify(contactConversations)}`);
+
+      if (!contactConversations || !contactConversations.payload) {
+        this.logger.error('No conversations found or payload is undefined');
+        return null;
+      }
 
-      if (contactConversations?.payload?.length) {
+      if (contactConversations.payload.length) {
         let conversation: any;
         if (this.provider.reopenConversation) {
           conversation = contactConversations.payload.find((conversation) => conversation.inbox_id == filterInbox.id);
+          this.logger.verbose(`Found conversation in reopenConversation mode: ${JSON.stringify(conversation)}`);
 
           if (this.provider.conversationPending) {
-            await client.conversations.toggleStatus({
-              accountId: this.provider.accountId,
-              conversationId: conversation.id,
-              data: {
-                status: 'pending',
-              },
-            });
+            if (conversation) {
+              await client.conversations.toggleStatus({
+                accountId: this.provider.accountId,
+                conversationId: conversation.id,
+                data: {
+                  status: 'pending',
+                },
+              });
+            }
           }
         } else {
           conversation = contactConversations.payload.find(
             (conversation) => conversation.status !== 'resolved' && conversation.inbox_id == filterInbox.id,
           );
+          this.logger.verbose(`Found conversation: ${JSON.stringify(conversation)}`);
         }
 
         if (conversation) {
+          this.logger.verbose(`Returning existing conversation ID: ${conversation.id}`);
           this.cache.set(cacheKey, conversation.id);
           return conversation.id;
         }
@@ -705,14 +739,15 @@ export class ChatwootService {
       });
 
       if (!conversation) {
-        this.logger.warn('conversation not found');
+        this.logger.warn('Conversation not created or found');
         return null;
       }
 
+      this.logger.verbose(`New conversation created with ID: ${conversation.id}`);
       this.cache.set(cacheKey, conversation.id);
       return conversation.id;
     } catch (error) {
-      this.logger.error(error);
+      this.logger.error(`Error in createConversation: ${error}`);
     }
   }