feat(chatbot): implement base chatbot structure and enhance integration capabilities

- Introduced a base structure for chatbot integrations, including BaseChatbotController and BaseChatbotService.
- Added common DTOs for chatbot settings and data to streamline integration processes.
- Updated existing chatbot controllers (Dify, Evoai, N8n) to extend from the new base classes, improving code reusability and maintainability.
- Enhanced media message handling across integrations, including audio transcription capabilities using OpenAI's Whisper API.
- Refactored service methods to accommodate new message structures and improve error handling.

src/api/integrations/chatbot/n8n/controllers/n8n.controller.ts

@@ -1,4 +1,3 @@
-import { IgnoreJidDto } from '@api/dto/chatbot.dto';
 import { InstanceDto } from '@api/dto/instance.dto';
 import { N8nDto } from '@api/integrations/chatbot/n8n/dto/n8n.dto';
 import { N8nService } from '@api/integrations/chatbot/n8n/services/n8n.service';
@@ -7,12 +6,11 @@ import { WAMonitoringService } from '@api/services/monitor.service';
 import { configService } from '@config/env.config';
 import { Logger } from '@config/logger.config';
 import { BadRequestException } from '@exceptions';
-import { N8n as N8nModel } from '@prisma/client';
-import { getConversationMessage } from '@utils/getConversationMessage';
+import { IntegrationSession, N8n as N8nModel } from '@prisma/client';
 
-import { ChatbotController, ChatbotControllerInterface, EmitData } from '../../chatbot.controller';
+import { BaseChatbotController } from '../../base-chatbot.controller';
 
-export class N8nController extends ChatbotController implements ChatbotControllerInterface {
+export class N8nController extends BaseChatbotController<N8nModel, N8nDto> {
   constructor(
     private readonly n8nService: N8nService,
     prismaRepository: PrismaRepository,
@@ -26,6 +24,7 @@ export class N8nController extends ChatbotController implements ChatbotControlle
   }
 
   public readonly logger = new Logger('N8nController');
+  protected readonly integrationName = 'N8n';
 
   integrationEnabled = configService.get('N8N').ENABLED;
   botRepository: any;
@@ -33,6 +32,54 @@ export class N8nController extends ChatbotController implements ChatbotControlle
   sessionRepository: any;
   userMessageDebounce: { [key: string]: { message: string; timeoutId: NodeJS.Timeout } } = {};
 
+  protected getFallbackBotId(settings: any): string | undefined {
+    return settings?.fallbackId;
+  }
+
+  protected getFallbackFieldName(): string {
+    return 'n8nIdFallback';
+  }
+
+  protected getIntegrationType(): string {
+    return 'n8n';
+  }
+
+  protected getAdditionalBotData(data: N8nDto): Record<string, any> {
+    return {
+      webhookUrl: data.webhookUrl,
+      basicAuthUser: data.basicAuthUser,
+      basicAuthPass: data.basicAuthPass,
+    };
+  }
+
+  // Implementation for bot-specific updates
+  protected getAdditionalUpdateFields(data: N8nDto): Record<string, any> {
+    return {
+      webhookUrl: data.webhookUrl,
+      basicAuthUser: data.basicAuthUser,
+      basicAuthPass: data.basicAuthPass,
+    };
+  }
+
+  // Implementation for bot-specific duplicate validation on update
+  protected async validateNoDuplicatesOnUpdate(botId: string, instanceId: string, data: N8nDto): Promise<void> {
+    const checkDuplicate = await this.botRepository.findFirst({
+      where: {
+        id: {
+          not: botId,
+        },
+        instanceId: instanceId,
+        webhookUrl: data.webhookUrl,
+        basicAuthUser: data.basicAuthUser,
+        basicAuthPass: data.basicAuthPass,
+      },
+    });
+
+    if (checkDuplicate) {
+      throw new Error('N8n already exists');
+    }
+  }
+
   // Bots
   public async createBot(instance: InstanceDto, data: N8nDto) {
     if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
@@ -45,74 +92,7 @@ export class N8nController extends ChatbotController implements ChatbotControlle
       })
       .then((instance) => instance.id);
 
-    if (
-      !data.expire ||
-      !data.keywordFinish ||
-      !data.delayMessage ||
-      !data.unknownMessage ||
-      !data.listeningFromMe ||
-      !data.stopBotFromMe ||
-      !data.keepOpen ||
-      !data.debounceTime ||
-      !data.ignoreJids ||
-      !data.splitMessages ||
-      !data.timePerChar
-    ) {
-      const defaultSettingCheck = await this.settingsRepository.findFirst({
-        where: {
-          instanceId: instanceId,
-        },
-      });
-
-      if (data.expire === undefined || data.expire === null) data.expire = defaultSettingCheck.expire;
-      if (data.keywordFinish === undefined || data.keywordFinish === null)
-        data.keywordFinish = defaultSettingCheck.keywordFinish;
-      if (data.delayMessage === undefined || data.delayMessage === null)
-        data.delayMessage = defaultSettingCheck.delayMessage;
-      if (data.unknownMessage === undefined || data.unknownMessage === null)
-        data.unknownMessage = defaultSettingCheck.unknownMessage;
-      if (data.listeningFromMe === undefined || data.listeningFromMe === null)
-        data.listeningFromMe = defaultSettingCheck.listeningFromMe;
-      if (data.stopBotFromMe === undefined || data.stopBotFromMe === null)
-        data.stopBotFromMe = defaultSettingCheck.stopBotFromMe;
-      if (data.keepOpen === undefined || data.keepOpen === null) data.keepOpen = defaultSettingCheck.keepOpen;
-      if (data.debounceTime === undefined || data.debounceTime === null)
-        data.debounceTime = defaultSettingCheck.debounceTime;
-      if (data.ignoreJids === undefined || data.ignoreJids === null) data.ignoreJids = defaultSettingCheck.ignoreJids;
-      if (data.splitMessages === undefined || data.splitMessages === null)
-        data.splitMessages = defaultSettingCheck?.splitMessages ?? false;
-      if (data.timePerChar === undefined || data.timePerChar === null)
-        data.timePerChar = defaultSettingCheck?.timePerChar ?? 0;
-
-      if (!defaultSettingCheck) {
-        await this.settings(instance, {
-          expire: data.expire,
-          keywordFinish: data.keywordFinish,
-          delayMessage: data.delayMessage,
-          unknownMessage: data.unknownMessage,
-          listeningFromMe: data.listeningFromMe,
-          stopBotFromMe: data.stopBotFromMe,
-          keepOpen: data.keepOpen,
-          debounceTime: data.debounceTime,
-          ignoreJids: data.ignoreJids,
-          splitMessages: data.splitMessages,
-          timePerChar: data.timePerChar,
-        });
-      }
-    }
-
-    const checkTriggerAll = await this.botRepository.findFirst({
-      where: {
-        enabled: true,
-        triggerType: 'all',
-        instanceId: instanceId,
-      },
-    });
-
-    if (checkTriggerAll && data.triggerType === 'all') {
-      throw new Error('You already have an n8n with an "All" trigger, you cannot have more bots while it is active');
-    }
-
+    // Check for N8n-specific duplicate
     const checkDuplicate = await this.botRepository.findFirst({
       where: {
         instanceId: instanceId,
@@ -126,72 +106,8 @@ export class N8nController extends ChatbotController implements ChatbotControlle
       throw new Error('N8n already exists');
     }
 
-    if (data.triggerType === 'keyword') {
-      if (!data.triggerOperator || !data.triggerValue) {
-        throw new Error('Trigger operator and value are required');
-      }
-
-      const checkDuplicate = await this.botRepository.findFirst({
-        where: {
-          triggerOperator: data.triggerOperator,
-          triggerValue: data.triggerValue,
-          instanceId: instanceId,
-        },
-      });
-
-      if (checkDuplicate) {
-        throw new Error('Trigger already exists');
-      }
-    }
-
-    if (data.triggerType === 'advanced') {
-      if (!data.triggerValue) {
-        throw new Error('Trigger value is required');
-      }
-
-      const checkDuplicate = await this.botRepository.findFirst({
-        where: {
-          triggerValue: data.triggerValue,
-          instanceId: instanceId,
-        },
-      });
-
-      if (checkDuplicate) {
-        throw new Error('Trigger already exists');
-      }
-    }
-
-    try {
-      const bot = await this.botRepository.create({
-        data: {
-          enabled: data?.enabled,
-          description: data.description,
-          webhookUrl: data.webhookUrl,
-          basicAuthUser: data.basicAuthUser,
-          basicAuthPass: data.basicAuthPass,
-          expire: data.expire,
-          keywordFinish: data.keywordFinish,
-          delayMessage: data.delayMessage,
-          unknownMessage: data.unknownMessage,
-          listeningFromMe: data.listeningFromMe,
-          stopBotFromMe: data.stopBotFromMe,
-          keepOpen: data.keepOpen,
-          debounceTime: data.debounceTime,
-          instanceId: instanceId,
-          triggerType: data.triggerType,
-          triggerOperator: data.triggerOperator,
-          triggerValue: data.triggerValue,
-          ignoreJids: data.ignoreJids,
-          splitMessages: data.splitMessages,
-          timePerChar: data.timePerChar,
-        },
-      });
-
-      return bot;
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error creating n8n');
-    }
+    // Let the base class handle the rest of the bot creation process
+    return super.createBot(instance, data);
   }
 
   public async findBot(instance: InstanceDto) {
@@ -246,643 +162,17 @@ export class N8nController extends ChatbotController implements ChatbotControlle
     return bot;
   }
 
-  public async updateBot(instance: InstanceDto, botId: string, data: N8nDto) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    const instanceId = await this.prismaRepository.instance
-      .findFirst({
-        where: {
-          name: instance.instanceName,
-        },
-      })
-      .then((instance) => instance.id);
-
-    const bot = await this.botRepository.findFirst({
-      where: {
-        id: botId,
-      },
-    });
-
-    if (!bot) {
-      throw new Error('N8n not found');
-    }
-
-    if (bot.instanceId !== instanceId) {
-      throw new Error('N8n not found');
-    }
-
-    if (data.triggerType === 'all') {
-      const checkTriggerAll = await this.botRepository.findFirst({
-        where: {
-          enabled: true,
-          triggerType: 'all',
-          id: {
-            not: botId,
-          },
-          instanceId: instanceId,
-        },
-      });
-
-      if (checkTriggerAll) {
-        throw new Error('You already have an n8n with an "All" trigger, you cannot have more bots while it is active');
-      }
-    }
-
-    const checkDuplicate = await this.botRepository.findFirst({
-      where: {
-        id: {
-          not: botId,
-        },
-        instanceId: instanceId,
-        webhookUrl: data.webhookUrl,
-        basicAuthUser: data.basicAuthUser,
-        basicAuthPass: data.basicAuthPass,
-      },
-    });
-
-    if (checkDuplicate) {
-      throw new Error('N8n already exists');
-    }
-
-    if (data.triggerType === 'keyword') {
-      if (!data.triggerOperator || !data.triggerValue) {
-        throw new Error('Trigger operator and value are required');
-      }
-
-      const checkDuplicate = await this.botRepository.findFirst({
-        where: {
-          triggerOperator: data.triggerOperator,
-          triggerValue: data.triggerValue,
-          id: { not: botId },
-          instanceId: instanceId,
-        },
-      });
-
-      if (checkDuplicate) {
-        throw new Error('Trigger already exists');
-      }
-    }
-
-    if (data.triggerType === 'advanced') {
-      if (!data.triggerValue) {
-        throw new Error('Trigger value is required');
-      }
-
-      const checkDuplicate = await this.botRepository.findFirst({
-        where: {
-          triggerValue: data.triggerValue,
-          id: { not: botId },
-          instanceId: instanceId,
-        },
-      });
-
-      if (checkDuplicate) {
-        throw new Error('Trigger already exists');
-      }
-    }
-
-    try {
-      const bot = await this.botRepository.update({
-        where: {
-          id: botId,
-        },
-        data: {
-          enabled: data?.enabled,
-          description: data.description,
-          webhookUrl: data.webhookUrl,
-          basicAuthUser: data.basicAuthUser,
-          basicAuthPass: data.basicAuthPass,
-          expire: data.expire,
-          keywordFinish: data.keywordFinish,
-          delayMessage: data.delayMessage,
-          unknownMessage: data.unknownMessage,
-          listeningFromMe: data.listeningFromMe,
-          stopBotFromMe: data.stopBotFromMe,
-          keepOpen: data.keepOpen,
-          debounceTime: data.debounceTime,
-          instanceId: instanceId,
-          triggerType: data.triggerType,
-          triggerOperator: data.triggerOperator,
-          triggerValue: data.triggerValue,
-          ignoreJids: data.ignoreJids,
-          splitMessages: data.splitMessages,
-          timePerChar: data.timePerChar,
-        },
-      });
-
-      return bot;
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error updating n8n');
-    }
-  }
-
-  public async deleteBot(instance: InstanceDto, botId: string) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    const instanceId = await this.prismaRepository.instance
-      .findFirst({
-        where: {
-          name: instance.instanceName,
-        },
-      })
-      .then((instance) => instance.id);
-
-    const bot = await this.botRepository.findFirst({
-      where: {
-        id: botId,
-      },
-    });
-
-    if (!bot) {
-      throw new Error('N8n not found');
-    }
-
-    if (bot.instanceId !== instanceId) {
-      throw new Error('N8n not found');
-    }
-    try {
-      await this.prismaRepository.integrationSession.deleteMany({
-        where: {
-          botId: botId,
-        },
-      });
-
-      await this.botRepository.delete({
-        where: {
-          id: botId,
-        },
-      });
-
-      return { bot: { id: botId } };
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error deleting n8n bot');
-    }
-  }
-
-  // Settings
-  public async settings(instance: InstanceDto, data: any) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    try {
-      const instanceId = await this.prismaRepository.instance
-        .findFirst({
-          where: {
-            name: instance.instanceName,
-          },
-        })
-        .then((instance) => instance.id);
-
-      const settings = await this.settingsRepository.findFirst({
-        where: {
-          instanceId: instanceId,
-        },
-      });
-
-      if (settings) {
-        const updateSettings = await this.settingsRepository.update({
-          where: {
-            id: settings.id,
-          },
-          data: {
-            expire: data.expire,
-            keywordFinish: data.keywordFinish,
-            delayMessage: data.delayMessage,
-            unknownMessage: data.unknownMessage,
-            listeningFromMe: data.listeningFromMe,
-            stopBotFromMe: data.stopBotFromMe,
-            keepOpen: data.keepOpen,
-            debounceTime: data.debounceTime,
-            n8nIdFallback: data.n8nIdFallback,
-            ignoreJids: data.ignoreJids,
-            splitMessages: data.splitMessages,
-            timePerChar: data.timePerChar,
-          },
-        });
-
-        return {
-          expire: updateSettings.expire,
-          keywordFinish: updateSettings.keywordFinish,
-          delayMessage: updateSettings.delayMessage,
-          unknownMessage: updateSettings.unknownMessage,
-          listeningFromMe: updateSettings.listeningFromMe,
-          stopBotFromMe: updateSettings.stopBotFromMe,
-          keepOpen: updateSettings.keepOpen,
-          debounceTime: updateSettings.debounceTime,
-          n8nIdFallback: updateSettings.n8nIdFallback,
-          ignoreJids: updateSettings.ignoreJids,
-          splitMessages: updateSettings.splitMessages,
-          timePerChar: updateSettings.timePerChar,
-        };
-      }
-
-      const newSettings = await this.settingsRepository.create({
-        data: {
-          expire: data.expire,
-          keywordFinish: data.keywordFinish,
-          delayMessage: data.delayMessage,
-          unknownMessage: data.unknownMessage,
-          listeningFromMe: data.listeningFromMe,
-          stopBotFromMe: data.stopBotFromMe,
-          keepOpen: data.keepOpen,
-          debounceTime: data.debounceTime,
-          n8nIdFallback: data.n8nIdFallback,
-          ignoreJids: data.ignoreJids,
-          instanceId: instanceId,
-          splitMessages: data.splitMessages,
-          timePerChar: data.timePerChar,
-        },
-      });
-
-      return {
-        expire: newSettings.expire,
-        keywordFinish: newSettings.keywordFinish,
-        delayMessage: newSettings.delayMessage,
-        unknownMessage: newSettings.unknownMessage,
-        listeningFromMe: newSettings.listeningFromMe,
-        stopBotFromMe: newSettings.stopBotFromMe,
-        keepOpen: newSettings.keepOpen,
-        debounceTime: newSettings.debounceTime,
-        n8nIdFallback: newSettings.n8nIdFallback,
-        ignoreJids: newSettings.ignoreJids,
-        splitMessages: newSettings.splitMessages,
-        timePerChar: newSettings.timePerChar,
-      };
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error setting default settings');
-    }
-  }
-
-  public async fetchSettings(instance: InstanceDto) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    try {
-      const instanceId = await this.prismaRepository.instance
-        .findFirst({
-          where: {
-            name: instance.instanceName,
-          },
-        })
-        .then((instance) => instance.id);
-
-      const settings = await this.settingsRepository.findFirst({
-        where: {
-          instanceId: instanceId,
-        },
-        include: {
-          Fallback: true,
-        },
-      });
-
-      if (!settings) {
-        return {
-          expire: 0,
-          keywordFinish: '',
-          delayMessage: 0,
-          unknownMessage: '',
-          listeningFromMe: false,
-          stopBotFromMe: false,
-          keepOpen: false,
-          ignoreJids: [],
-          splitMessages: false,
-          timePerChar: 0,
-          n8nIdFallback: '',
-          fallback: null,
-        };
-      }
-
-      return {
-        expire: settings.expire,
-        keywordFinish: settings.keywordFinish,
-        delayMessage: settings.delayMessage,
-        unknownMessage: settings.unknownMessage,
-        listeningFromMe: settings.listeningFromMe,
-        stopBotFromMe: settings.stopBotFromMe,
-        keepOpen: settings.keepOpen,
-        ignoreJids: settings.ignoreJids,
-        splitMessages: settings.splitMessages,
-        timePerChar: settings.timePerChar,
-        n8nIdFallback: settings.n8nIdFallback,
-        fallback: settings.Fallback,
-      };
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error fetching default settings');
-    }
-  }
-
-  // Sessions
-  public async changeStatus(instance: InstanceDto, data: any) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    try {
-      const instanceId = await this.prismaRepository.instance
-        .findFirst({
-          where: {
-            name: instance.instanceName,
-          },
-        })
-        .then((instance) => instance.id);
-
-      const defaultSettingCheck = await this.settingsRepository.findFirst({
-        where: {
-          instanceId,
-        },
-      });
-
-      const remoteJid = data.remoteJid;
-      const status = data.status;
-
-      if (status === 'delete') {
-        await this.sessionRepository.deleteMany({
-          where: {
-            remoteJid: remoteJid,
-            botId: { not: null },
-          },
-        });
-
-        return { bot: { remoteJid: remoteJid, status: status } };
-      }
-
-      if (status === 'closed') {
-        if (defaultSettingCheck?.keepOpen) {
-          await this.sessionRepository.updateMany({
-            where: {
-              remoteJid: remoteJid,
-              botId: { not: null },
-            },
-            data: {
-              status: 'closed',
-            },
-          });
-        } else {
-          await this.sessionRepository.deleteMany({
-            where: {
-              remoteJid: remoteJid,
-              botId: { not: null },
-            },
-          });
-        }
-
-        return { bot: { ...instance, bot: { remoteJid: remoteJid, status: status } } };
-      } else {
-        const session = await this.sessionRepository.updateMany({
-          where: {
-            instanceId: instanceId,
-            remoteJid: remoteJid,
-            botId: { not: null },
-          },
-          data: {
-            status: status,
-          },
-        });
-
-        const botData = {
-          remoteJid: remoteJid,
-          status: status,
-          session,
-        };
-
-        return { bot: { ...instance, bot: botData } };
-      }
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error changing status');
-    }
-  }
-
-  public async fetchSessions(instance: InstanceDto, botId: string, remoteJid?: string) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    try {
-      const instanceId = await this.prismaRepository.instance
-        .findFirst({
-          where: {
-            name: instance.instanceName,
-          },
-        })
-        .then((instance) => instance.id);
-
-      const bot = await this.botRepository.findFirst({
-        where: {
-          id: botId,
-        },
-      });
-
-      if (bot && bot.instanceId !== instanceId) {
-        throw new Error('N8n not found');
-      }
-
-      return await this.sessionRepository.findMany({
-        where: {
-          instanceId: instanceId,
-          remoteJid,
-          botId: bot ? botId : { not: null },
-          type: 'n8n',
-        },
-      });
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error fetching sessions');
-    }
-  }
-
-  public async ignoreJid(instance: InstanceDto, data: IgnoreJidDto) {
-    if (!this.integrationEnabled) throw new BadRequestException('N8n is disabled');
-
-    try {
-      const instanceId = await this.prismaRepository.instance
-        .findFirst({
-          where: {
-            name: instance.instanceName,
-          },
-        })
-        .then((instance) => instance.id);
-
-      const settings = await this.settingsRepository.findFirst({
-        where: {
-          instanceId: instanceId,
-        },
-      });
-
-      if (!settings) {
-        throw new Error('Settings not found');
-      }
-
-      let ignoreJids: any = settings?.ignoreJids || [];
-
-      if (data.action === 'add') {
-        if (ignoreJids.includes(data.remoteJid)) return { ignoreJids: ignoreJids };
-
-        ignoreJids.push(data.remoteJid);
-      } else {
-        ignoreJids = ignoreJids.filter((jid) => jid !== data.remoteJid);
-      }
-
-      const updateSettings = await this.settingsRepository.update({
-        where: {
-          id: settings.id,
-        },
-        data: {
-          ignoreJids: ignoreJids,
-        },
-      });
-
-      return {
-        ignoreJids: updateSettings.ignoreJids,
-      };
-    } catch (error) {
-      this.logger.error(error);
-      throw new Error('Error setting default settings');
-    }
-  }
-
-  // Emit
-  public async emit({ instance, remoteJid, msg }: EmitData) {
-    if (!this.integrationEnabled) return;
-
-    try {
-      const settings = await this.settingsRepository.findFirst({
-        where: {
-          instanceId: instance.instanceId,
-        },
-      });
-
-      if (this.checkIgnoreJids(settings?.ignoreJids, remoteJid)) return;
-
-      const session = await this.getSession(remoteJid, instance);
-
-      const content = getConversationMessage(msg);
-
-      let findBot = (await this.findBotTrigger(this.botRepository, content, instance, session)) as N8nModel;
-
-      if (!findBot) {
-        const fallback = await this.settingsRepository.findFirst({
-          where: {
-            instanceId: instance.instanceId,
-          },
-        });
-
-        if (fallback?.n8nIdFallback) {
-          const findFallback = await this.botRepository.findFirst({
-            where: {
-              id: fallback.n8nIdFallback,
-            },
-          });
-
-          findBot = findFallback;
-        } else {
-          return;
-        }
-      }
-
-      let expire = findBot?.expire;
-      let keywordFinish = findBot?.keywordFinish;
-      let delayMessage = findBot?.delayMessage;
-      let unknownMessage = findBot?.unknownMessage;
-      let listeningFromMe = findBot?.listeningFromMe;
-      let stopBotFromMe = findBot?.stopBotFromMe;
-      let keepOpen = findBot?.keepOpen;
-      let debounceTime = findBot?.debounceTime;
-      let ignoreJids = findBot?.ignoreJids;
-      let splitMessages = findBot?.splitMessages;
-      let timePerChar = findBot?.timePerChar;
-
-      if (expire === undefined || expire === null) expire = settings.expire;
-      if (keywordFinish === undefined || keywordFinish === null) keywordFinish = settings.keywordFinish;
-      if (delayMessage === undefined || delayMessage === null) delayMessage = settings.delayMessage;
-      if (unknownMessage === undefined || unknownMessage === null) unknownMessage = settings.unknownMessage;
-      if (listeningFromMe === undefined || listeningFromMe === null) listeningFromMe = settings.listeningFromMe;
-      if (stopBotFromMe === undefined || stopBotFromMe === null) stopBotFromMe = settings.stopBotFromMe;
-      if (keepOpen === undefined || keepOpen === null) keepOpen = settings.keepOpen;
-      if (debounceTime === undefined || debounceTime === null) debounceTime = settings.debounceTime;
-      if (ignoreJids === undefined || ignoreJids === null) ignoreJids = settings.ignoreJids;
-      if (splitMessages === undefined || splitMessages === null) splitMessages = settings?.splitMessages ?? false;
-      if (timePerChar === undefined || timePerChar === null) timePerChar = settings?.timePerChar ?? 0;
-
-      const key = msg.key as {
-        id: string;
-        remoteJid: string;
-        fromMe: boolean;
-        participant: string;
-      };
-
-      if (stopBotFromMe && key.fromMe && session) {
-        await this.prismaRepository.integrationSession.update({
-          where: {
-            id: session.id,
-          },
-          data: {
-            status: 'paused',
-          },
-        });
-        return;
-      }
-
-      if (!listeningFromMe && key.fromMe) {
-        return;
-      }
-
-      if (session && !session.awaitUser) {
-        return;
-      }
-
-      if (debounceTime && debounceTime > 0) {
-        this.processDebounce(this.userMessageDebounce, content, remoteJid, debounceTime, async (debouncedContent) => {
-          await this.n8nService.processN8n(
-            this.waMonitor.waInstances[instance.instanceName],
-            remoteJid,
-            findBot,
-            session,
-            {
-              ...settings,
-              expire,
-              keywordFinish,
-              delayMessage,
-              unknownMessage,
-              listeningFromMe,
-              stopBotFromMe,
-              keepOpen,
-              debounceTime,
-              ignoreJids,
-              splitMessages,
-              timePerChar,
-            },
-            debouncedContent,
-            msg?.pushName,
-          );
-        });
-      } else {
-        await this.n8nService.processN8n(
-          this.waMonitor.waInstances[instance.instanceName],
-          remoteJid,
-          findBot,
-          session,
-          {
-            ...settings,
-            expire,
-            keywordFinish,
-            delayMessage,
-            unknownMessage,
-            listeningFromMe,
-            stopBotFromMe,
-            keepOpen,
-            debounceTime,
-            ignoreJids,
-            splitMessages,
-            timePerChar,
-          },
-          content,
-          msg?.pushName,
-        );
-      }
-
-      return;
-    } catch (error) {
-      this.logger.error(error);
-      return;
-    }
+  // Process N8n-specific bot logic
+  protected async processBot(
+    instance: any,
+    remoteJid: string,
+    bot: N8nModel,
+    session: IntegrationSession,
+    settings: any,
+    content: string,
+    pushName?: string,
+    msg?: any,
+  ) {
+    this.n8nService.process(instance, remoteJid, bot, session, settings, content, pushName, msg);
   }
 }

src/api/integrations/chatbot/n8n/dto/n8n.dto.ts

@@ -1,18 +1,18 @@
 import { TriggerOperator, TriggerType } from '@prisma/client';
+import { BaseChatbotDto, BaseChatbotSettingDto } from '../../base-chatbot.dto';
 
-export class N8nDto {
-  enabled?: boolean;
-  description?: string;
+export class N8nDto extends BaseChatbotDto {
+  // N8n specific fields
   webhookUrl?: string;
   basicAuthUser?: string;
   basicAuthPass?: string;
 
   // Advanced bot properties (copied from DifyDto style)
-  triggerType?: TriggerType;
+  triggerType: TriggerType;
   triggerOperator?: TriggerOperator;
   triggerValue?: string;
   expire?: number;
-  keywordFinish?: string;
+  keywordFinish?: string[];
   delayMessage?: number;
   unknownMessage?: string;
   listeningFromMe?: boolean;
@@ -24,8 +24,8 @@ export class N8nDto {
   timePerChar?: number;
 }
 
-export class N8nSettingDto {
-  // Add settings fields here if needed for compatibility
+export class N8nSettingDto extends BaseChatbotSettingDto {
+  // N8n specific fields
 }
 
 export class N8nMessageDto {

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

@@ -1,22 +1,29 @@
 import { InstanceDto } from '@api/dto/instance.dto';
 import { PrismaRepository } from '@api/repository/repository.service';
 import { WAMonitoringService } from '@api/services/monitor.service';
-import { Logger } from '@config/logger.config';
+import { ConfigService } from '@config/env.config';
 import { IntegrationSession, N8n, N8nSetting } from '@prisma/client';
 import { sendTelemetry } from '@utils/sendTelemetry';
 import axios from 'axios';
+import { downloadMediaMessage } from 'baileys';
 
+import { BaseChatbotService } from '../../base-chatbot.service';
 import { N8nDto } from '../dto/n8n.dto';
 
-export class N8nService {
-  private readonly logger = new Logger('N8nService');
-  private readonly waMonitor: WAMonitoringService;
-
+export class N8nService extends BaseChatbotService<N8n, N8nSetting> {
   constructor(
     waMonitor: WAMonitoringService,
-    private readonly prismaRepository: PrismaRepository,
+    prismaRepository: PrismaRepository,
+    configService: ConfigService,
   ) {
-    this.waMonitor = waMonitor;
+    super(waMonitor, prismaRepository, 'N8nService', configService);
+  }
+
+  /**
+   * Return the bot type for N8n
+   */
+  protected getBotType(): string {
+    return 'n8n';
   }
 
   /**
@@ -122,40 +129,10 @@ export class N8nService {
   }
 
   public async createNewSession(instance: InstanceDto, data: any) {
-    try {
-      const session = await this.prismaRepository.integrationSession.create({
-        data: {
-          remoteJid: data.remoteJid,
-          pushName: data.pushName,
-          sessionId: data.remoteJid,
-          status: 'opened',
-          awaitUser: false,
-          botId: data.botId,
-          instanceId: instance.instanceId,
-          type: 'n8n',
-        },
-      });
-      return { session };
-    } catch (error) {
-      this.logger.error(error);
-      return;
-    }
+    return super.createNewSession(instance, data, 'n8n');
   }
 
-  private isImageMessage(content: string) {
-    return content.includes('imageMessage');
-  }
-
-  private isJSON(str: string): boolean {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  private async sendMessageToBot(
+  protected async sendMessageToBot(
     instance: any,
     session: IntegrationSession,
     settings: N8nSetting,
@@ -163,6 +140,7 @@ export class N8nService {
     remoteJid: string,
     pushName: string,
     content: string,
+    msg?: any,
   ) {
     try {
       const endpoint: string = n8n.webhookUrl;
@@ -170,6 +148,24 @@ export class N8nService {
         chatInput: content,
         sessionId: session.sessionId,
       };
+
+      // Handle audio messages
+      if (this.isAudioMessage(content) && msg) {
+        try {
+          this.logger.debug(`[N8n] Downloading audio for Whisper transcription`);
+          const mediaBuffer = await downloadMediaMessage({ key: msg.key, message: msg.message }, 'buffer', {});
+          const transcribedText = await this.speechToText(mediaBuffer);
+          if (transcribedText) {
+            payload.chatInput = transcribedText;
+          } else {
+            payload.chatInput = '[Audio message could not be transcribed]';
+          }
+        } catch (err) {
+          this.logger.error(`[N8n] Failed to transcribe audio: ${err}`);
+          payload.chatInput = '[Audio message could not be transcribed]';
+        }
+      }
+
       const headers: Record<string, string> = {};
       if (n8n.basicAuthUser && n8n.basicAuthPass) {
         const auth = Buffer.from(`${n8n.basicAuthUser}:${n8n.basicAuthPass}`).toString('base64');
@@ -193,45 +189,39 @@ export class N8nService {
     }
   }
 
-  private async sendMessageWhatsApp(instance: any, remoteJid: string, message: string, settings: N8nSetting) {
+  protected async sendMessageWhatsApp(instance: any, remoteJid: string, message: string, settings: N8nSetting) {
     const linkRegex = /(!?)\[(.*?)\]\((.*?)\)/g;
     let textBuffer = '';
     let lastIndex = 0;
     let match: RegExpExecArray | null;
-    const getMediaType = (url: string): string | null => {
-      const extension = url.split('.').pop()?.toLowerCase();
-      const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
-      const audioExtensions = ['mp3', 'wav', 'aac', 'ogg'];
-      const videoExtensions = ['mp4', 'avi', 'mkv', 'mov'];
-      const documentExtensions = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt'];
-      if (imageExtensions.includes(extension || '')) return 'image';
-      if (audioExtensions.includes(extension || '')) return 'audio';
-      if (videoExtensions.includes(extension || '')) return 'video';
-      if (documentExtensions.includes(extension || '')) return 'document';
-      return null;
-    };
+    
     while ((match = linkRegex.exec(message)) !== null) {
-      const [altText, url] = match;
-      const mediaType = getMediaType(url);
+      const [fullMatch, exclamation, altText, url] = match;
+      const mediaType = this.getMediaType(url);
       const beforeText = message.slice(lastIndex, match.index);
+      
       if (beforeText) {
         textBuffer += beforeText;
       }
+      
       if (mediaType) {
         const splitMessages = settings.splitMessages ?? false;
         const timePerChar = settings.timePerChar ?? 0;
         const minDelay = 1000;
         const maxDelay = 20000;
+        
         if (textBuffer.trim()) {
           if (splitMessages) {
             const multipleMessages = textBuffer.trim().split('\n\n');
             for (let index = 0; index < multipleMessages.length; index++) {
               const message = multipleMessages[index];
               const delay = Math.min(Math.max(message.length * timePerChar, minDelay), maxDelay);
+              
               if (instance.integration === 'WHATSAPP_BAILEYS') {
                 await instance.client.presenceSubscribe(remoteJid);
                 await instance.client.sendPresenceUpdate('composing', remoteJid);
               }
+              
               await new Promise<void>((resolve) => {
                 setTimeout(async () => {
                   await instance.textMessage(
@@ -245,67 +235,103 @@ export class N8nService {
                   resolve();
                 }, delay);
               });
+              
               if (instance.integration === 'WHATSAPP_BAILEYS') {
                 await instance.client.sendPresenceUpdate('paused', remoteJid);
               }
             }
           } else {
-            await instance.textMessage(
-              {
-                number: remoteJid.split('@')[0],
-                delay: settings?.delayMessage || 1000,
-                text: textBuffer.trim(),
-              },
-              false,
-            );
+            const delay = Math.min(Math.max(textBuffer.length * timePerChar, minDelay), maxDelay);
+            
+            if (instance.integration === 'WHATSAPP_BAILEYS') {
+              await instance.client.presenceSubscribe(remoteJid);
+              await instance.client.sendPresenceUpdate('composing', remoteJid);
+            }
+            
+            await new Promise<void>((resolve) => {
+              setTimeout(async () => {
+                await instance.textMessage(
+                  {
+                    number: remoteJid.split('@')[0],
+                    delay: settings?.delayMessage || 1000,
+                    text: textBuffer,
+                  },
+                  false,
+                );
+                resolve();
+              }, delay);
+            });
+            
+            if (instance.integration === 'WHATSAPP_BAILEYS') {
+              await instance.client.sendPresenceUpdate('paused', remoteJid);
+            }
           }
-          textBuffer = '';
         }
-        if (mediaType === 'audio') {
-          await instance.audioWhatsapp({
+        
+        textBuffer = '';
+        
+        if (mediaType === 'image') {
+          await instance.mediaMessage({
             number: remoteJid.split('@')[0],
             delay: settings?.delayMessage || 1000,
-            audio: url,
-            caption: altText,
+            caption: exclamation === '!' ? undefined : altText,
+            mediatype: 'image',
+            media: url,
+          });
+        } else if (mediaType === 'video') {
+          await instance.mediaMessage({
+            number: remoteJid.split('@')[0],
+            delay: settings?.delayMessage || 1000,
+            caption: exclamation === '!' ? undefined : altText,
+            mediatype: 'video',
+            media: url,
+          });
+        } else if (mediaType === 'audio') {
+          await instance.mediaMessage({
+            number: remoteJid.split('@')[0],
+            delay: settings?.delayMessage || 1000,
+            mediatype: 'audio',
+            media: url,
+          });
+        } else if (mediaType === 'document') {
+          await instance.mediaMessage({
+            number: remoteJid.split('@')[0],
+            delay: settings?.delayMessage || 1000,
+            caption: exclamation === '!' ? undefined : altText,
+            mediatype: 'document',
+            media: url,
+            fileName: altText || 'file',
           });
-        } else {
-          await instance.mediaMessage(
-            {
-              number: remoteJid.split('@')[0],
-              delay: settings?.delayMessage || 1000,
-              mediatype: mediaType,
-              media: url,
-              caption: altText,
-            },
-            null,
-            false,
-          );
         }
       } else {
         textBuffer += `[${altText}](${url})`;
       }
-      lastIndex = linkRegex.lastIndex;
+      
+      lastIndex = match.index + fullMatch.length;
     }
-    if (lastIndex < message.length) {
-      const remainingText = message.slice(lastIndex);
-      if (remainingText.trim()) {
-        textBuffer += remainingText;
-      }
+    
+    const remainingText = message.slice(lastIndex);
+    if (remainingText) {
+      textBuffer += remainingText;
     }
-    const splitMessages = settings.splitMessages ?? false;
-    const timePerChar = settings.timePerChar ?? 0;
-    const minDelay = 1000;
-    const maxDelay = 20000;
+    
     if (textBuffer.trim()) {
+      const splitMessages = settings.splitMessages ?? false;
+      const timePerChar = settings.timePerChar ?? 0;
+      const minDelay = 1000;
+      const maxDelay = 20000;
+      
       if (splitMessages) {
         const multipleMessages = textBuffer.trim().split('\n\n');
         for (let index = 0; index < multipleMessages.length; index++) {
           const message = multipleMessages[index];
           const delay = Math.min(Math.max(message.length * timePerChar, minDelay), maxDelay);
+          
           if (instance.integration === 'WHATSAPP_BAILEYS') {
             await instance.client.presenceSubscribe(remoteJid);
             await instance.client.sendPresenceUpdate('composing', remoteJid);
           }
+          
           await new Promise<void>((resolve) => {
             setTimeout(async () => {
               await instance.textMessage(
@@ -319,25 +345,41 @@ export class N8nService {
               resolve();
             }, delay);
           });
+          
           if (instance.integration === 'WHATSAPP_BAILEYS') {
             await instance.client.sendPresenceUpdate('paused', remoteJid);
           }
         }
       } else {
-        await instance.textMessage(
-          {
-            number: remoteJid.split('@')[0],
-            delay: settings?.delayMessage || 1000,
-            text: textBuffer.trim(),
-          },
-          false,
-        );
+        const delay = Math.min(Math.max(textBuffer.length * timePerChar, minDelay), maxDelay);
+        
+        if (instance.integration === 'WHATSAPP_BAILEYS') {
+          await instance.client.presenceSubscribe(remoteJid);
+          await instance.client.sendPresenceUpdate('composing', remoteJid);
+        }
+        
+        await new Promise<void>((resolve) => {
+          setTimeout(async () => {
+            await instance.textMessage(
+              {
+                number: remoteJid.split('@')[0],
+                delay: settings?.delayMessage || 1000,
+                text: textBuffer,
+              },
+              false,
+            );
+            resolve();
+          }, delay);
+        });
+        
+        if (instance.integration === 'WHATSAPP_BAILEYS') {
+          await instance.client.sendPresenceUpdate('paused', remoteJid);
+        }
       }
     }
-    sendTelemetry('/message/sendText');
   }
 
-  private async initNewSession(
+  protected async initNewSession(
     instance: any,
     remoteJid: string,
     n8n: N8n,
@@ -345,88 +387,97 @@ export class N8nService {
     session: IntegrationSession,
     content: string,
     pushName?: string,
+    msg?: any,
   ) {
-    const data = await this.createNewSession(instance, {
-      remoteJid,
-      pushName,
-      botId: n8n.id,
-    });
-    if (data.session) {
-      session = data.session;
-    }
-    await this.sendMessageToBot(instance, session, settings, n8n, remoteJid, pushName, content);
-    return;
-  }
-
-  public async processN8n(
-    instance: any,
-    remoteJid: string,
-    n8n: N8n,
-    session: IntegrationSession,
-    settings: N8nSetting,
-    content: string,
-    pushName?: string,
-  ) {
-    if (session && session.status !== 'opened') {
+    try {
+      await this.sendMessageToBot(instance, session, settings, n8n, remoteJid, pushName || '', content, msg);
+    } catch (error) {
+      this.logger.error(error);
       return;
     }
-    if (session && settings.expire && settings.expire > 0) {
-      const now = Date.now();
-      const sessionUpdatedAt = new Date(session.updatedAt).getTime();
-      const diff = now - sessionUpdatedAt;
-      const diffInMinutes = Math.floor(diff / 1000 / 60);
-      if (diffInMinutes > settings.expire) {
-        if (settings.keepOpen) {
+  }
+
+  public async process(
+    instance: any,
+    remoteJid: string,
+    n8n: N8n,
+    session: IntegrationSession,
+    settings: N8nSetting,
+    content: string,
+    pushName?: string,
+    msg?: any,
+  ) {
+    try {
+      // Handle keyword finish
+      if (settings?.keywordFinish?.includes(content.toLowerCase())) {
+        if (settings?.keepOpen) {
           await this.prismaRepository.integrationSession.update({
-            where: { id: session.id },
-            data: { status: 'closed' },
+            where: {
+              id: session.id,
+            },
+            data: {
+              status: 'closed',
+            },
           });
         } else {
-          await this.prismaRepository.integrationSession.deleteMany({
-            where: { botId: n8n.id, remoteJid: remoteJid },
+          await this.prismaRepository.integrationSession.delete({
+            where: {
+              id: session.id,
+            },
           });
         }
-        await this.initNewSession(instance, remoteJid, n8n, settings, session, content, pushName);
+
         return;
       }
-    }
-    if (!session) {
-      await this.initNewSession(instance, remoteJid, n8n, settings, session, content, pushName);
-      return;
-    }
-    await this.prismaRepository.integrationSession.update({
-      where: { id: session.id },
-      data: { status: 'opened', awaitUser: false },
-    });
-    if (!content) {
-      if (settings.unknownMessage) {
-        this.waMonitor.waInstances[instance.instanceName].textMessage(
-          {
-            number: remoteJid.split('@')[0],
-            delay: settings.delayMessage || 1000,
-            text: settings.unknownMessage,
-          },
-          false,
+
+      // If session is new or doesn't exist
+      if (!session) {
+        const data = {
+          remoteJid,
+          pushName,
+          botId: n8n.id,
+        };
+
+        const createSession = await this.createNewSession(
+          { instanceName: instance.instanceName, instanceId: instance.instanceId },
+          data,
         );
 
-        sendTelemetry('/message/sendText');
+        await this.initNewSession(
+          instance,
+          remoteJid,
+          n8n,
+          settings,
+          createSession.session,
+          content,
+          pushName,
+          msg,
+        );
+
+        await sendTelemetry('/n8n/session/start');
+        return;
       }
-      return;
-    }
-    if (settings.keywordFinish && content.toLowerCase() === settings.keywordFinish.toLowerCase()) {
-      if (settings.keepOpen) {
+
+      // If session exists but is paused
+      if (session.status === 'paused') {
         await this.prismaRepository.integrationSession.update({
-          where: { id: session.id },
-          data: { status: 'closed' },
-        });
-      } else {
-        await this.prismaRepository.integrationSession.deleteMany({
-          where: { botId: n8n.id, remoteJid: remoteJid },
+          where: {
+            id: session.id,
+          },
+          data: {
+            status: 'opened',
+            awaitUser: true,
+          },
         });
+
+        return;
       }
+
+      // Regular message for ongoing session
+      await this.sendMessageToBot(instance, session, settings, n8n, remoteJid, pushName || '', content, msg);
+    } catch (error) {
+      this.logger.error(error);
       return;
     }
-    await this.sendMessageToBot(instance, session, settings, n8n, remoteJid, pushName, content);
-    return;
   }
 }