Merge branch 'v2.0.0' into v2-webhook-fix

prisma/postgresql-schema.prisma

@@ -307,7 +307,6 @@ model Typebot {
   Instance        Instance         @relation(fields: [instanceId], references: [id], onDelete: Cascade)
   instanceId      String
   TypebotSetting  TypebotSetting[]
-  sessions        IntegrationSession[]
 }
 
 model TypebotSetting {
@@ -384,7 +383,6 @@ model OpenaiBot {
   Instance          Instance         @relation(fields: [instanceId], references: [id], onDelete: Cascade)
   instanceId        String
   OpenaiSetting     OpenaiSetting[]
-  sessions          IntegrationSession[]
 }
 
 model IntegrationSession {
@@ -402,14 +400,7 @@ model IntegrationSession {
   instanceId String
   parameters Json?         @db.JsonB
 
-  OpenaiBot   OpenaiBot? @relation(fields: [openaiBotId], references: [id], onDelete: Cascade)
-  openaiBotId String?
-
-  DifyBot Dify?   @relation(fields: [difyId], references: [id], onDelete: Cascade)
-  difyId  String?
-
-  Typebot   Typebot? @relation(fields: [typebotId], references: [id], onDelete: Cascade)
-  typebotId String?
+  botId String?
 }
 
 model OpenaiSetting {
@@ -470,7 +461,6 @@ model Dify {
   Instance        Instance         @relation(fields: [instanceId], references: [id], onDelete: Cascade)
   instanceId      String
   DifySetting     DifySetting[]
-  sessions        IntegrationSession[]
 }
 
 model DifySetting {

src/api/dto/chatbot.dto.ts

@@ -0,0 +1,12 @@
+export class Session {
+  remoteJid?: string;
+  sessionId?: string;
+  status?: string;
+  createdAt?: number;
+  updateAt?: number;
+}
+
+export class IgnoreJidDto {
+  remoteJid?: string;
+  action?: string;
+}

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

@@ -60,13 +60,11 @@ import {
   configService,
   ConfigSessionPhone,
   Database,
-  Dify,
   Log,
   Openai,
   ProviderSession,
   QrCode,
   S3,
-  Typebot,
 } from '@config/env.config';
 import { BadRequestException, InternalServerErrorException, NotFoundException } from '@exceptions';
 import ffmpegPath from '@ffmpeg-installer/ffmpeg';
@@ -2012,35 +2010,14 @@ export class BaileysStartupService extends ChannelStartupService {
         );
       }
 
-      if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED && this.localChatwoot.enabled && isIntegration) {
-        if (this.configService.get<Typebot>('TYPEBOT').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.typebotService.sendTypebot(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw,
-            );
-        }
-
-        if (this.configService.get<Openai>('OPENAI').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.openaiService.sendOpenai(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw.pushName,
-              messageRaw,
-            );
-        }
-
-        if (this.configService.get<Dify>('DIFY').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.difyService.sendDify(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw,
-            );
-        }
-      }
+      if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED && this.localChatwoot.enabled && isIntegration)
+        await chatbotController.emit({
+          instance: { instanceName: this.instance.name, instanceId: this.instanceId },
+          remoteJid: messageRaw.key.remoteJid,
+          msg: messageRaw,
+          pushName: messageRaw.pushName,
+          isIntegration,
+        });
 
       if (this.configService.get<Database>('DATABASE').SAVE_DATA.NEW_MESSAGE)
         await this.prismaRepository.message.create({

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

@@ -20,7 +20,7 @@ import { chatbotController } from '@api/server.module';
 import { CacheService } from '@api/services/cache.service';
 import { ChannelStartupService } from '@api/services/channel.service';
 import { Events, wa } from '@api/types/wa.types';
-import { Chatwoot, ConfigService, Database, Dify, Openai, S3, Typebot, WaBusiness } from '@config/env.config';
+import { Chatwoot, ConfigService, Database, Openai, S3, WaBusiness } from '@config/env.config';
 import { BadRequestException, InternalServerErrorException } from '@exceptions';
 import axios from 'axios';
 import { arrayUnique, isURL } from 'class-validator';
@@ -923,35 +923,13 @@ export class BusinessStartupService extends ChannelStartupService {
         );
       }
 
-      if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED && this.localChatwoot.enabled && isIntegration) {
-        if (this.configService.get<Typebot>('TYPEBOT').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.typebotService.sendTypebot(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw,
-            );
-        }
-
-        if (this.configService.get<Openai>('OPENAI').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.openaiService.sendOpenai(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw.pushName,
-              messageRaw,
-            );
-        }
-
-        if (this.configService.get<Dify>('DIFY').ENABLED) {
-          if (messageRaw.messageType !== 'reactionMessage')
-            await this.difyService.sendDify(
-              { instanceName: this.instance.name, instanceId: this.instanceId },
-              messageRaw.key.remoteJid,
-              messageRaw,
-            );
-        }
-      }
+      if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED && this.localChatwoot.enabled && isIntegration)
+        await chatbotController.emit({
+          instance: { instanceName: this.instance.name, instanceId: this.instanceId },
+          remoteJid: messageRaw.key.remoteJid,
+          msg: messageRaw,
+          pushName: messageRaw.pushName,
+        });
 
       await this.prismaRepository.message.create({
         data: messageRaw,

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

@@ -2,11 +2,46 @@ import { InstanceDto } from '@api/dto/instance.dto';
 import { PrismaRepository } from '@api/repository/repository.service';
 import { difyController, openaiController, typebotController, websocketController } from '@api/server.module';
 import { WAMonitoringService } from '@api/services/monitor.service';
+import { Logger } from '@config/logger.config';
+import { IntegrationSession } from '@prisma/client';
+import { findBotByTrigger } from '@utils/findBotByTrigger';
+
+export type EmitData = {
+  instance: InstanceDto;
+  remoteJid: string;
+  msg: any;
+  pushName?: string;
+};
+
+export interface ChatbotControllerInterface {
+  integrationEnabled: boolean;
+  botRepository: any;
+  settingsRepository: any;
+  sessionRepository: any;
+  userMessageDebounce: { [key: string]: { message: string; timeoutId: NodeJS.Timeout } };
+
+  createBot(instance: InstanceDto, data: any): Promise<any>;
+  findBot(instance: InstanceDto): Promise<any>;
+  fetchBot(instance: InstanceDto, botId: string): Promise<any>;
+  updateBot(instance: InstanceDto, botId: string, data: any): Promise<any>;
+  deleteBot(instance: InstanceDto, botId: string): Promise<any>;
+
+  settings(instance: InstanceDto, data: any): Promise<any>;
+  fetchSettings(instance: InstanceDto): Promise<any>;
+
+  changeStatus(instance: InstanceDto, botId: string, status: string): Promise<any>;
+  fetchSessions(instance: InstanceDto, botId: string, remoteJid?: string): Promise<any>;
+  ignoreJid(instance: InstanceDto, data: any): Promise<any>;
+
+  emit(data: EmitData): Promise<void>;
+}
 
 export class ChatbotController {
   public prismaRepository: PrismaRepository;
   public waMonitor: WAMonitoringService;
 
+  public readonly logger = new Logger(ChatbotController.name);
+
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     this.prisma = prismaRepository;
     this.monitor = waMonitor;
@@ -33,17 +68,20 @@ export class ChatbotController {
     remoteJid,
     msg,
     pushName,
+    isIntegration = false,
   }: {
     instance: InstanceDto;
     remoteJid: string;
     msg: any;
     pushName?: string;
+    isIntegration?: boolean;
   }): Promise<void> {
     const emitData = {
       instance,
       remoteJid,
       msg,
       pushName,
+      isIntegration,
     };
     // typebot
     await typebotController.emit(emitData);
@@ -63,4 +101,112 @@ export class ChatbotController {
         events: data.websocketEvents,
       });
   }
+
+  public processDebounce(
+    userMessageDebounce: any,
+    content: string,
+    remoteJid: string,
+    debounceTime: number,
+    callback: any,
+  ) {
+    if (userMessageDebounce[remoteJid]) {
+      userMessageDebounce[remoteJid].message += ` ${content}`;
+      this.logger.log('message debounced: ' + userMessageDebounce[remoteJid].message);
+      clearTimeout(userMessageDebounce[remoteJid].timeoutId);
+    } else {
+      userMessageDebounce[remoteJid] = {
+        message: content,
+        timeoutId: null,
+      };
+    }
+
+    userMessageDebounce[remoteJid].timeoutId = setTimeout(() => {
+      const myQuestion = userMessageDebounce[remoteJid].message;
+      this.logger.log('Debounce complete. Processing message: ' + myQuestion);
+
+      delete userMessageDebounce[remoteJid];
+      callback(myQuestion);
+    }, debounceTime * 1000);
+  }
+
+  public checkIgnoreJids(ignoreJids: any, remoteJid: string) {
+    if (ignoreJids && ignoreJids.length > 0) {
+      let ignoreGroups = false;
+      let ignoreContacts = false;
+
+      if (ignoreJids.includes('@g.us')) {
+        ignoreGroups = true;
+      }
+
+      if (ignoreJids.includes('@s.whatsapp.net')) {
+        ignoreContacts = true;
+      }
+
+      if (ignoreGroups && remoteJid.endsWith('@g.us')) {
+        this.logger.warn('Ignoring message from group: ' + remoteJid);
+        return true;
+      }
+
+      if (ignoreContacts && remoteJid.endsWith('@s.whatsapp.net')) {
+        this.logger.warn('Ignoring message from contact: ' + remoteJid);
+        return true;
+      }
+
+      if (ignoreJids.includes(remoteJid)) {
+        this.logger.warn('Ignoring message from jid: ' + remoteJid);
+        return true;
+      }
+
+      return false;
+    }
+
+    return false;
+  }
+
+  public async getSession(remoteJid: string, instance: InstanceDto) {
+    let session = await this.prismaRepository.integrationSession.findFirst({
+      where: {
+        remoteJid: remoteJid,
+        instanceId: instance.instanceId,
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+
+    if (session) {
+      if (session.status !== 'closed' && !session.botId) {
+        this.logger.warn('Session is already opened in another integration');
+        return;
+      } else if (!session.botId) {
+        session = null;
+      }
+    }
+
+    return session;
+  }
+
+  public async findBotTrigger(
+    botRepository: any,
+    settingsRepository: any,
+    content: string,
+    instance: InstanceDto,
+    session?: IntegrationSession,
+  ) {
+    let findBot = null;
+
+    if (!session) {
+      findBot = await findBotByTrigger(botRepository, settingsRepository, content, instance.instanceId);
+
+      if (!findBot) {
+        return;
+      }
+    } else {
+      findBot = await botRepository.findFirst({
+        where: {
+          id: session.botId,
+        },
+      });
+    }
+
+    return findBot;
+  }
 }

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

@@ -1,84 +1,825 @@
+import { IgnoreJidDto } from '@api/dto/chatbot.dto';
 import { InstanceDto } from '@api/dto/instance.dto';
-import { DifyDto, DifyIgnoreJidDto } from '@api/integrations/chatbot/dify/dto/dify.dto';
+import { DifyDto } from '@api/integrations/chatbot/dify/dto/dify.dto';
 import { DifyService } from '@api/integrations/chatbot/dify/services/dify.service';
+import { PrismaRepository } from '@api/repository/repository.service';
+import { WAMonitoringService } from '@api/services/monitor.service';
 import { configService, Dify } from '@config/env.config';
+import { Logger } from '@config/logger.config';
 import { BadRequestException } from '@exceptions';
+import { getConversationMessage } from '@utils/getConversationMessage';
 
-export class DifyController {
-  constructor(private readonly difyService: DifyService) {}
+import { ChatbotController, ChatbotControllerInterface, EmitData } from '../../chatbot.controller';
 
-  public async createDify(instance: InstanceDto, data: DifyDto) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+export class DifyController extends ChatbotController implements ChatbotControllerInterface {
+  constructor(
+    private readonly difyService: DifyService,
+    prismaRepository: PrismaRepository,
+    waMonitor: WAMonitoringService,
+  ) {
+    super(prismaRepository, waMonitor);
 
-    return this.difyService.create(instance, data);
+    this.botRepository = this.prismaRepository.dify;
+    this.settingsRepository = this.prismaRepository.difySetting;
+    this.sessionRepository = this.prismaRepository.integrationSession;
   }
 
-  public async findDify(instance: InstanceDto) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+  public readonly logger = new Logger(DifyController.name);
 
-    return this.difyService.find(instance);
+  integrationEnabled = configService.get<Dify>('DIFY').ENABLED;
+  botRepository: any;
+  settingsRepository: any;
+  sessionRepository: any;
+  userMessageDebounce: { [key: string]: { message: string; timeoutId: NodeJS.Timeout } } = {};
+
+  // Bots
+  public async createBot(instance: InstanceDto, data: DifyDto) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify is disabled');
+
+    const instanceId = await this.prismaRepository.instance
+      .findFirst({
+        where: {
+          name: instance.instanceName,
+        },
+      })
+      .then((instance) => instance.id);
+
+    if (
+      !data.expire ||
+      !data.keywordFinish ||
+      !data.delayMessage ||
+      !data.unknownMessage ||
+      !data.listeningFromMe ||
+      !data.stopBotFromMe ||
+      !data.keepOpen ||
+      !data.debounceTime ||
+      !data.ignoreJids
+    ) {
+      const defaultSettingCheck = await this.settingsRepository.findFirst({
+        where: {
+          instanceId: instanceId,
+        },
+      });
+
+      if (!data.expire) data.expire = defaultSettingCheck?.expire || 0;
+      if (!data.keywordFinish) data.keywordFinish = defaultSettingCheck?.keywordFinish || '';
+      if (!data.delayMessage) data.delayMessage = defaultSettingCheck?.delayMessage || 1000;
+      if (!data.unknownMessage) data.unknownMessage = defaultSettingCheck?.unknownMessage || '';
+      if (!data.listeningFromMe) data.listeningFromMe = defaultSettingCheck?.listeningFromMe || false;
+      if (!data.stopBotFromMe) data.stopBotFromMe = defaultSettingCheck?.stopBotFromMe || false;
+      if (!data.keepOpen) data.keepOpen = defaultSettingCheck?.keepOpen || false;
+      if (!data.debounceTime) data.debounceTime = defaultSettingCheck?.debounceTime || 0;
+      if (!data.ignoreJids) data.ignoreJids = defaultSettingCheck?.ignoreJids || [];
+
+      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,
+        });
+      }
     }
 
-  public async fetchDify(instance: InstanceDto, difyId: string) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+    const checkTriggerAll = await this.botRepository.findFirst({
+      where: {
+        enabled: true,
+        triggerType: 'all',
+        instanceId: instanceId,
+      },
+    });
 
-    return this.difyService.fetch(instance, difyId);
+    if (checkTriggerAll && data.triggerType === 'all') {
+      throw new Error('You already have a dify with an "All" trigger, you cannot have more bots while it is active');
     }
 
-  public async updateDify(instance: InstanceDto, difyId: string, data: DifyDto) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+    const checkDuplicate = await this.botRepository.findFirst({
+      where: {
+        instanceId: instanceId,
+        botType: data.botType,
+        apiUrl: data.apiUrl,
+        apiKey: data.apiKey,
+      },
+    });
 
-    return this.difyService.update(instance, difyId, data);
+    if (checkDuplicate) {
+      throw new Error('Dify already exists');
     }
 
-  public async deleteDify(instance: InstanceDto, difyId: string) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
-
-    return this.difyService.delete(instance, difyId);
+    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,
+          botType: data.botType,
+          apiUrl: data.apiUrl,
+          apiKey: data.apiKey,
+          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,
+        },
+      });
+
+      return bot;
+    } catch (error) {
+      this.logger.error(error);
+      throw new Error('Error creating dify');
+    }
+  }
+
+  public async findBot(instance: InstanceDto) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify is disabled');
+
+    const instanceId = await this.prismaRepository.instance
+      .findFirst({
+        where: {
+          name: instance.instanceName,
+        },
+      })
+      .then((instance) => instance.id);
+
+    const bots = await this.botRepository.findMany({
+      where: {
+        instanceId: instanceId,
+      },
+    });
+
+    if (!bots.length) {
+      return null;
+    }
+
+    return bots;
+  }
+
+  public async fetchBot(instance: InstanceDto, botId: string) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify 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('Dify not found');
+    }
+
+    if (bot.instanceId !== instanceId) {
+      throw new Error('Dify not found');
+    }
+
+    return bot;
+  }
+
+  public async updateBot(instance: InstanceDto, botId: string, data: DifyDto) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify 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('Dify not found');
+    }
+
+    if (bot.instanceId !== instanceId) {
+      throw new Error('Dify 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 a dify 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,
+        botType: data.botType,
+        apiUrl: data.apiUrl,
+        apiKey: data.apiKey,
+      },
+    });
+
+    if (checkDuplicate) {
+      throw new Error('Dify 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,
+          botType: data.botType,
+          apiUrl: data.apiUrl,
+          apiKey: data.apiKey,
+          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,
+        },
+      });
+
+      return bot;
+    } catch (error) {
+      this.logger.error(error);
+      throw new Error('Error updating dify');
+    }
+  }
+
+  public async deleteBot(instance: InstanceDto, botId: string) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify 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('Dify not found');
+    }
+
+    if (bot.instanceId !== instanceId) {
+      throw new Error('Dify 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 dify bot');
+    }
+  }
+
+  // Settings
   public async settings(instance: InstanceDto, data: any) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+    if (!this.integrationEnabled) throw new BadRequestException('Dify is disabled');
 
-    return this.difyService.setDefaultSettings(instance, data);
+    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,
+            difyIdFallback: data.difyIdFallback,
+            ignoreJids: data.ignoreJids,
+          },
+        });
+
+        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,
+          difyIdFallback: updateSettings.difyIdFallback,
+          ignoreJids: updateSettings.ignoreJids,
+        };
+      }
+
+      const newSetttings = 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,
+          difyIdFallback: data.difyIdFallback,
+          ignoreJids: data.ignoreJids,
+          instanceId: instanceId,
+        },
+      });
+
+      return {
+        expire: newSetttings.expire,
+        keywordFinish: newSetttings.keywordFinish,
+        delayMessage: newSetttings.delayMessage,
+        unknownMessage: newSetttings.unknownMessage,
+        listeningFromMe: newSetttings.listeningFromMe,
+        stopBotFromMe: newSetttings.stopBotFromMe,
+        keepOpen: newSetttings.keepOpen,
+        debounceTime: newSetttings.debounceTime,
+        difyIdFallback: newSetttings.difyIdFallback,
+        ignoreJids: newSetttings.ignoreJids,
+      };
+    } catch (error) {
+      this.logger.error(error);
+      throw new Error('Error setting default settings');
+    }
   }
 
   public async fetchSettings(instance: InstanceDto) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+    if (!this.integrationEnabled) throw new BadRequestException('Dify is disabled');
 
-    return this.difyService.fetchDefaultSettings(instance);
+    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: [],
+          difyIdFallback: '',
+          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,
+        difyIdFallback: settings.difyIdFallback,
+        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 (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+    if (!this.integrationEnabled) throw new BadRequestException('Dify is disabled');
 
-    return this.difyService.changeStatus(instance, data);
+    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 } };
       }
 
-  public async fetchSessions(instance: InstanceDto, difyId: string) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
-
-    return this.difyService.fetchSessions(instance, difyId);
+      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 },
+            },
+          });
         }
 
-  public async ignoreJid(instance: InstanceDto, data: DifyIgnoreJidDto) {
-    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+        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,
+          },
+        });
 
-    return this.difyService.ignoreJid(instance, data);
+        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 emit({
-    instance,
+  public async fetchSessions(instance: InstanceDto, botId: string, remoteJid?: string) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify 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('Dify not found');
+      }
+
+      return await this.sessionRepository.findMany({
+        where: {
+          instanceId: instanceId,
           remoteJid,
-    msg,
-  }: {
-    instance: InstanceDto;
-    remoteJid: string;
-    msg: any;
-    pushName?: string;
-  }) {
-    if (!configService.get<Dify>('DIFY').ENABLED) return;
+          botId: bot ? botId : { not: null },
+        },
+      });
+    } catch (error) {
+      this.logger.error(error);
+      throw new Error('Error fetching sessions');
+    }
+  }
 
-    await this.difyService.sendDify(instance, remoteJid, msg);
+  public async ignoreJid(instance: InstanceDto, data: IgnoreJidDto) {
+    if (!this.integrationEnabled) throw new BadRequestException('Dify 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.prismaRepository.difySetting.findFirst({
+        where: {
+          instanceId: instance.instanceId,
+        },
+      });
+
+      if (this.checkIgnoreJids(settings?.ignoreJids, remoteJid)) return;
+
+      const session = await this.getSession(remoteJid, instance);
+
+      const content = getConversationMessage(msg);
+
+      const findBot = await this.findBotTrigger(
+        this.botRepository,
+        this.settingsRepository,
+        content,
+        instance,
+        session,
+      );
+
+      if (!findBot) 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;
+
+      if (
+        !expire ||
+        !keywordFinish ||
+        !delayMessage ||
+        !unknownMessage ||
+        !listeningFromMe ||
+        !stopBotFromMe ||
+        !keepOpen ||
+        !debounceTime
+      ) {
+        if (!expire) expire = settings.expire;
+
+        if (!keywordFinish) keywordFinish = settings.keywordFinish;
+
+        if (!delayMessage) delayMessage = settings.delayMessage;
+
+        if (!unknownMessage) unknownMessage = settings.unknownMessage;
+
+        if (!listeningFromMe) listeningFromMe = settings.listeningFromMe;
+
+        if (!stopBotFromMe) stopBotFromMe = settings.stopBotFromMe;
+
+        if (!keepOpen) keepOpen = settings.keepOpen;
+
+        if (!debounceTime) debounceTime = settings.debounceTime;
+      }
+
+      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 (debounceTime && debounceTime > 0) {
+        this.processDebounce(this.userMessageDebounce, content, remoteJid, debounceTime, async (debouncedContent) => {
+          await this.difyService.processDify(
+            this.waMonitor.waInstances[instance.instanceName],
+            remoteJid,
+            findBot,
+            session,
+            settings,
+            debouncedContent,
+            msg?.pushName,
+          );
+        });
+      } else {
+        await this.difyService.processDify(
+          this.waMonitor.waInstances[instance.instanceName],
+          remoteJid,
+          findBot,
+          session,
+          settings,
+          content,
+          msg?.pushName,
+        );
+      }
+
+      return;
+    } catch (error) {
+      this.logger.error(error);
+      return;
+    }
   }
 }

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

@@ -1,13 +1,5 @@
 import { $Enums, TriggerOperator, TriggerType } from '@prisma/client';
 
-export class Session {
-  remoteJid?: string;
-  sessionId?: string;
-  status?: string;
-  createdAt?: number;
-  updateAt?: number;
-}
-
 export class DifyDto {
   enabled?: boolean;
   description?: string;
@@ -40,8 +32,3 @@ export class DifySettingDto {
   difyIdFallback?: string;
   ignoreJids?: any;
 }
-
-export class DifyIgnoreJidDto {
-  remoteJid?: string;
-  action?: string;
-}

src/api/integrations/chatbot/dify/routes/dify.router.ts

@@ -1,6 +1,7 @@
 import { RouterBroker } from '@api/abstract/abstract.router';
+import { IgnoreJidDto } from '@api/dto/chatbot.dto';
 import { InstanceDto } from '@api/dto/instance.dto';
-import { DifyDto, DifyIgnoreJidDto, DifySettingDto } from '@api/integrations/chatbot/dify/dto/dify.dto';
+import { DifyDto, DifySettingDto } from '@api/integrations/chatbot/dify/dto/dify.dto';
 import { HttpStatus } from '@api/routes/index.router';
 import { difyController } from '@api/server.module';
 import {
@@ -21,7 +22,7 @@ export class DifyRouter extends RouterBroker {
           request: req,
           schema: difySchema,
           ClassRef: DifyDto,
-          execute: (instance, data) => difyController.createDify(instance, data),
+          execute: (instance, data) => difyController.createBot(instance, data),
         });
 
         res.status(HttpStatus.CREATED).json(response);
@@ -31,7 +32,7 @@ export class DifyRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => difyController.findDify(instance),
+          execute: (instance) => difyController.findBot(instance),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -41,7 +42,7 @@ export class DifyRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => difyController.fetchDify(instance, req.params.difyId),
+          execute: (instance) => difyController.fetchBot(instance, req.params.difyId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -51,7 +52,7 @@ export class DifyRouter extends RouterBroker {
           request: req,
           schema: difySchema,
           ClassRef: DifyDto,
-          execute: (instance, data) => difyController.updateDify(instance, req.params.difyId, data),
+          execute: (instance, data) => difyController.updateBot(instance, req.params.difyId, data),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -61,7 +62,7 @@ export class DifyRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => difyController.deleteDify(instance, req.params.difyId),
+          execute: (instance) => difyController.deleteBot(instance, req.params.difyId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -107,10 +108,10 @@ export class DifyRouter extends RouterBroker {
         res.status(HttpStatus.OK).json(response);
       })
       .post(this.routerPath('ignoreJid'), ...guards, async (req, res) => {
-        const response = await this.dataValidate<DifyIgnoreJidDto>({
+        const response = await this.dataValidate<IgnoreJidDto>({
           request: req,
           schema: difyIgnoreJidSchema,
-          ClassRef: DifyIgnoreJidDto,
+          ClassRef: IgnoreJidDto,
           execute: (instance, data) => difyController.ignoreJid(instance, data),
         });
 

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

@@ -1,13 +1,5 @@
 import { TriggerOperator, TriggerType } from '@prisma/client';
 
-export class Session {
-  remoteJid?: string;
-  sessionId?: string;
-  status?: string;
-  createdAt?: number;
-  updateAt?: number;
-}
-
 export class OpenaiCredsDto {
   name: string;
   apiKey: string;
@@ -53,8 +45,3 @@ export class OpenaiSettingDto {
   ignoreJids?: any;
   speechToText?: boolean;
 }
-
-export class OpenaiIgnoreJidDto {
-  remoteJid?: string;
-  action?: string;
-}

src/api/integrations/chatbot/openai/routes/openai.router.ts

@@ -1,11 +1,7 @@
 import { RouterBroker } from '@api/abstract/abstract.router';
+import { IgnoreJidDto } from '@api/dto/chatbot.dto';
 import { InstanceDto } from '@api/dto/instance.dto';
-import {
-  OpenaiCredsDto,
-  OpenaiDto,
-  OpenaiIgnoreJidDto,
-  OpenaiSettingDto,
-} from '@api/integrations/chatbot/openai/dto/openai.dto';
+import { OpenaiCredsDto, OpenaiDto, OpenaiSettingDto } from '@api/integrations/chatbot/openai/dto/openai.dto';
 import { HttpStatus } from '@api/routes/index.router';
 import { openaiController } from '@api/server.module';
 import {
@@ -57,7 +53,7 @@ export class OpenaiRouter extends RouterBroker {
           request: req,
           schema: openaiSchema,
           ClassRef: OpenaiDto,
-          execute: (instance, data) => openaiController.createOpenai(instance, data),
+          execute: (instance, data) => openaiController.createBot(instance, data),
         });
 
         res.status(HttpStatus.CREATED).json(response);
@@ -67,7 +63,7 @@ export class OpenaiRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => openaiController.findOpenai(instance),
+          execute: (instance) => openaiController.findBot(instance),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -77,7 +73,7 @@ export class OpenaiRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => openaiController.fetchOpenai(instance, req.params.openaiBotId),
+          execute: (instance) => openaiController.fetchBot(instance, req.params.openaiBotId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -87,7 +83,7 @@ export class OpenaiRouter extends RouterBroker {
           request: req,
           schema: openaiSchema,
           ClassRef: OpenaiDto,
-          execute: (instance, data) => openaiController.updateOpenai(instance, req.params.openaiBotId, data),
+          execute: (instance, data) => openaiController.updateBot(instance, req.params.openaiBotId, data),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -97,7 +93,7 @@ export class OpenaiRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => openaiController.deleteOpenai(instance, req.params.openaiBotId),
+          execute: (instance) => openaiController.deleteBot(instance, req.params.openaiBotId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -143,10 +139,10 @@ export class OpenaiRouter extends RouterBroker {
         res.status(HttpStatus.OK).json(response);
       })
       .post(this.routerPath('ignoreJid'), ...guards, async (req, res) => {
-        const response = await this.dataValidate<OpenaiIgnoreJidDto>({
+        const response = await this.dataValidate<IgnoreJidDto>({
           request: req,
           schema: openaiIgnoreJidSchema,
-          ClassRef: OpenaiIgnoreJidDto,
+          ClassRef: IgnoreJidDto,
           execute: (instance, data) => openaiController.ignoreJid(instance, data),
         });
 

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

@@ -1,14 +1,5 @@
 import { TriggerOperator, TriggerType } from '@prisma/client';
 
-export class Session {
-  remoteJid?: string;
-  sessionId?: string;
-  status?: string;
-  createdAt?: number;
-  updateAt?: number;
-  prefilledVariables?: PrefilledVariables;
-}
-
 export class PrefilledVariables {
   remoteJid?: string;
   pushName?: string;
@@ -47,8 +38,3 @@ export class TypebotSettingDto {
   typebotIdFallback?: string;
   ignoreJids?: any;
 }
-
-export class TypebotIgnoreJidDto {
-  remoteJid?: string;
-  action?: string;
-}

src/api/integrations/chatbot/typebot/routes/typebot.router.ts

@@ -1,8 +1,9 @@
 import { RouterBroker } from '@api/abstract/abstract.router';
+import { IgnoreJidDto } from '@api/dto/chatbot.dto';
 import { InstanceDto } from '@api/dto/instance.dto';
-import { TypebotDto, TypebotIgnoreJidDto, TypebotSettingDto } from '@api/integrations/chatbot/typebot/dto/typebot.dto';
-import { typebotController } from '@api/server.module';
+import { TypebotDto, TypebotSettingDto } from '@api/integrations/chatbot/typebot/dto/typebot.dto';
 import { HttpStatus } from '@api/routes/index.router';
+import { typebotController } from '@api/server.module';
 import {
   instanceSchema,
   typebotIgnoreJidSchema,
@@ -22,7 +23,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: typebotSchema,
           ClassRef: TypebotDto,
-          execute: (instance, data) => typebotController.createTypebot(instance, data),
+          execute: (instance, data) => typebotController.createBot(instance, data),
         });
 
         res.status(HttpStatus.CREATED).json(response);
@@ -32,7 +33,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => typebotController.findTypebot(instance),
+          execute: (instance) => typebotController.findBot(instance),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -42,7 +43,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => typebotController.fetchTypebot(instance, req.params.typebotId),
+          execute: (instance) => typebotController.fetchBot(instance, req.params.typebotId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -52,7 +53,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: typebotSchema,
           ClassRef: TypebotDto,
-          execute: (instance, data) => typebotController.updateTypebot(instance, req.params.typebotId, data),
+          execute: (instance, data) => typebotController.updateBot(instance, req.params.typebotId, data),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -62,7 +63,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: instanceSchema,
           ClassRef: InstanceDto,
-          execute: (instance) => typebotController.deleteTypebot(instance, req.params.typebotId),
+          execute: (instance) => typebotController.deleteBot(instance, req.params.typebotId),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -92,7 +93,7 @@ export class TypebotRouter extends RouterBroker {
           request: req,
           schema: typebotStartSchema,
           ClassRef: InstanceDto,
-          execute: (instance, data) => typebotController.startTypebot(instance, data),
+          execute: (instance, data) => typebotController.startBot(instance, data),
         });
 
         res.status(HttpStatus.OK).json(response);
@@ -118,10 +119,10 @@ export class TypebotRouter extends RouterBroker {
         res.status(HttpStatus.OK).json(response);
       })
       .post(this.routerPath('ignoreJid'), ...guards, async (req, res) => {
-        const response = await this.dataValidate<TypebotIgnoreJidDto>({
+        const response = await this.dataValidate<IgnoreJidDto>({
           request: req,
           schema: typebotIgnoreJidSchema,
-          ClassRef: TypebotIgnoreJidDto,
+          ClassRef: IgnoreJidDto,
           execute: (instance, data) => typebotController.ignoreJid(instance, data),
         });
 

src/api/integrations/event/event.controller.ts

@@ -3,6 +3,25 @@ import { rabbitmqController, sqsController, webhookController, websocketControll
 import { WAMonitoringService } from '@api/services/monitor.service';
 import { Server } from 'http';
 
+export type EmitData = {
+  instanceName: string;
+  origin: string;
+  event: string;
+  data: Object;
+  serverUrl: string;
+  dateTime: string;
+  sender: string;
+  apiKey?: string;
+  local?: boolean;
+};
+
+export interface EventControllerInterface {
+  integrationEnabled: boolean;
+  set(instanceName: string, data: any): Promise<any>;
+  get(instanceName: string): Promise<any>;
+  emit({ instanceName, origin, event, data, serverUrl, dateTime, sender, apiKey, local }: EmitData): Promise<void>;
+}
+
 export class EventController {
   public prismaRepository: PrismaRepository;
   public waMonitor: WAMonitoringService;

src/api/integrations/event/rabbitmq/controllers/rabbitmq.controller.ts

@@ -7,19 +7,19 @@ import { Logger } from '@config/logger.config';
 import { NotFoundException } from '@exceptions';
 import * as amqp from 'amqplib/callback_api';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class RabbitmqController extends EventController {
+export class RabbitmqController extends EventController implements EventControllerInterface {
   public amqpChannel: amqp.Channel | null = null;
   private readonly logger = new Logger(RabbitmqController.name);
+  integrationEnabled = configService.get<Rabbitmq>('RABBITMQ')?.ENABLED;
+
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
 
   public async init(): Promise<void> {
-    if (!configService.get<Rabbitmq>('RABBITMQ')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     await new Promise<void>((resolve, reject) => {
       const uri = configService.get<Rabbitmq>('RABBITMQ').URI;
@@ -62,6 +62,8 @@ export class RabbitmqController extends EventController {
   }
 
   public async set(instanceName: string, data: RabbitmqDto): Promise<wa.LocalRabbitmq> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -91,6 +93,8 @@ export class RabbitmqController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -117,19 +121,8 @@ export class RabbitmqController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Rabbitmq>('RABBITMQ')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const instanceRabbitmq = await this.get(instanceName);
     const rabbitmqLocal = instanceRabbitmq?.events;

src/api/integrations/event/sqs/controllers/sqs.controller.ts

@@ -7,20 +7,19 @@ import { configService, Log, Sqs } from '@config/env.config';
 import { Logger } from '@config/logger.config';
 import { NotFoundException } from '@exceptions';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class SqsController extends EventController {
+export class SqsController extends EventController implements EventControllerInterface {
   private sqs: SQS;
   private readonly logger = new Logger(SqsController.name);
+  integrationEnabled = configService.get<Sqs>('SQS')?.ENABLED;
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
 
   public init(): void {
-    if (!configService.get<Sqs>('SQS')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     new Promise<void>((resolve, reject) => {
@@ -48,6 +47,8 @@ export class SqsController extends EventController {
   }
 
   public async set(instanceName: string, data: SqsDto): Promise<wa.LocalSqs> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -77,6 +78,8 @@ export class SqsController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalSqs> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -103,19 +106,8 @@ export class SqsController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Sqs>('SQS')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const instanceSqs = await this.get(instanceName);
     const sqsLocal = instanceSqs?.events;

src/api/integrations/event/webhook/controllers/webhook.controller.ts

@@ -7,15 +7,16 @@ import { BadRequestException, NotFoundException } from '@exceptions';
 import axios from 'axios';
 import { isURL } from 'class-validator';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 import { WebhookDto } from '../dto/webhook.dto';
 
-export class WebhookController extends EventController {
+export class WebhookController extends EventController implements EventControllerInterface {
   private readonly logger = new Logger(WebhookController.name);
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
   }
+  integrationEnabled: boolean;
 
   public async set(instanceName: string, data: WebhookDto): Promise<wa.LocalWebHook> {
     if (!isURL(data.url, { require_tld: false })) {
@@ -78,17 +79,7 @@ export class WebhookController extends EventController {
     sender,
     apiKey,
     local,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-    local?: boolean;
-  }): Promise<void> {
+  }: EmitData): Promise<void> {
     const instanceWebhook = await this.get(instanceName);
     if (!instanceWebhook || !instanceWebhook.enabled) {
       return;
@@ -110,6 +101,7 @@ export class WebhookController extends EventController {
       server_url: serverUrl,
       apikey: apiKey,
     };
+
     if (local) {
       if (Array.isArray(webhookLocal) && webhookLocal.includes(we)) {
         let baseURL: string;

src/api/integrations/event/websocket/controllers/websocket.controller.ts

@@ -8,12 +8,13 @@ import { NotFoundException } from '@exceptions';
 import { Server } from 'http';
 import { Server as SocketIO } from 'socket.io';
 
-import { EventController } from '../../event.controller';
+import { EmitData, EventController, EventControllerInterface } from '../../event.controller';
 
-export class WebsocketController extends EventController {
+export class WebsocketController extends EventController implements EventControllerInterface {
   private io: SocketIO;
   private corsConfig: Array<any>;
   private readonly logger = new Logger(WebsocketController.name);
+  integrationEnabled = configService.get<Websocket>('WEBSOCKET')?.ENABLED;
 
   constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
     super(prismaRepository, waMonitor);
@@ -21,9 +22,7 @@ export class WebsocketController extends EventController {
   }
 
   public init(httpServer: Server): void {
-    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
-      return;
-    }
+    if (!this.integrationEnabled) return;
 
     this.socket = new SocketIO(httpServer, {
       cors: {
@@ -59,6 +58,8 @@ export class WebsocketController extends EventController {
   }
 
   public async set(instanceName: string, data: WebsocketDto): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (!data.enabled) {
       data.events = [];
     } else {
@@ -88,6 +89,8 @@ export class WebsocketController extends EventController {
   }
 
   public async get(instanceName: string): Promise<wa.LocalWebsocket> {
+    if (!this.integrationEnabled) return;
+
     if (undefined === this.monitor.waInstances[instanceName]) {
       throw new NotFoundException('Instance not found');
     }
@@ -114,19 +117,8 @@ export class WebsocketController extends EventController {
     dateTime,
     sender,
     apiKey,
-  }: {
-    instanceName: string;
-    origin: string;
-    event: string;
-    data: Object;
-    serverUrl: string;
-    dateTime: string;
-    sender: string;
-    apiKey?: string;
-  }): Promise<void> {
-    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
-      return;
-    }
+  }: EmitData): Promise<void> {
+    if (!this.integrationEnabled) return;
 
     const configEv = event.replace(/[.-]/gm, '_').toUpperCase();
     const logEnabled = configService.get<Log>('LOG').LEVEL.includes('WEBSOCKET');

src/api/server.module.ts

@@ -108,12 +108,12 @@ export const webhookController = new WebhookController(prismaRepository, waMonit
 
 // chatbots
 const typebotService = new TypebotService(waMonitor, configService, prismaRepository);
-export const typebotController = new TypebotController(typebotService);
+export const typebotController = new TypebotController(typebotService, prismaRepository, waMonitor);
 
 const openaiService = new OpenaiService(waMonitor, configService, prismaRepository);
-export const openaiController = new OpenaiController(openaiService);
+export const openaiController = new OpenaiController(openaiService, prismaRepository, waMonitor);
 
 const difyService = new DifyService(waMonitor, configService, prismaRepository);
-export const difyController = new DifyController(difyService);
+export const difyController = new DifyController(difyService, prismaRepository, waMonitor);
 
 logger.info('Module - ON');

src/utils/findBotByTrigger.ts

@@ -0,0 +1,149 @@
+import { advancedOperatorsSearch } from './advancedOperatorsSearch';
+
+export const findBotByTrigger = async (
+  botRepository: any,
+  settingsRepository: any,
+  content: string,
+  instanceId: string,
+) => {
+  // Check for triggerType 'all'
+  const findTriggerAll = await botRepository.findFirst({
+    where: {
+      enabled: true,
+      triggerType: 'all',
+      instanceId: instanceId,
+    },
+  });
+
+  if (findTriggerAll) return findTriggerAll;
+
+  const findTriggerAdvanced = await botRepository.findMany({
+    where: {
+      enabled: true,
+      triggerType: 'advanced',
+      instanceId: instanceId,
+    },
+  });
+  for (const advanced of findTriggerAdvanced) {
+    if (advancedOperatorsSearch(content, advanced.triggerValue)) {
+      return advanced;
+    }
+  }
+
+  // Check for exact match
+  const findTriggerEquals = await botRepository.findFirst({
+    where: {
+      enabled: true,
+      triggerType: 'keyword',
+      triggerOperator: 'equals',
+      triggerValue: content,
+      instanceId: instanceId,
+    },
+  });
+
+  if (findTriggerEquals) return findTriggerEquals;
+
+  // Check for regex match
+  const findRegex = await botRepository.findMany({
+    where: {
+      enabled: true,
+      triggerType: 'keyword',
+      triggerOperator: 'regex',
+      instanceId: instanceId,
+    },
+  });
+
+  let findTriggerRegex = null;
+
+  for (const regex of findRegex) {
+    const regexValue = new RegExp(regex.triggerValue);
+
+    if (regexValue.test(content)) {
+      findTriggerRegex = regex;
+      break;
+    }
+  }
+
+  if (findTriggerRegex) return findTriggerRegex;
+
+  // Check for startsWith match
+  const findStartsWith = await botRepository.findMany({
+    where: {
+      enabled: true,
+      triggerType: 'keyword',
+      triggerOperator: 'startsWith',
+      instanceId: instanceId,
+    },
+  });
+
+  let findTriggerStartsWith = null;
+
+  for (const startsWith of findStartsWith) {
+    if (content.startsWith(startsWith.triggerValue)) {
+      findTriggerStartsWith = startsWith;
+      break;
+    }
+  }
+
+  if (findTriggerStartsWith) return findTriggerStartsWith;
+
+  // Check for endsWith match
+  const findEndsWith = await botRepository.findMany({
+    where: {
+      enabled: true,
+      triggerType: 'keyword',
+      triggerOperator: 'endsWith',
+      instanceId: instanceId,
+    },
+  });
+
+  let findTriggerEndsWith = null;
+
+  for (const endsWith of findEndsWith) {
+    if (content.endsWith(endsWith.triggerValue)) {
+      findTriggerEndsWith = endsWith;
+      break;
+    }
+  }
+
+  if (findTriggerEndsWith) return findTriggerEndsWith;
+
+  // Check for contains match
+  const findContains = await botRepository.findMany({
+    where: {
+      enabled: true,
+      triggerType: 'keyword',
+      triggerOperator: 'contains',
+      instanceId: instanceId,
+    },
+  });
+
+  let findTriggerContains = null;
+
+  for (const contains of findContains) {
+    if (content.includes(contains.triggerValue)) {
+      findTriggerContains = contains;
+      break;
+    }
+  }
+
+  if (findTriggerContains) return findTriggerContains;
+
+  const fallback = await settingsRepository.findFirst({
+    where: {
+      instanceId: instanceId,
+    },
+  });
+
+  if (fallback?.openaiIdFallback) {
+    const findFallback = await botRepository.findFirst({
+      where: {
+        id: fallback.openaiIdFallback,
+      },
+    });
+
+    if (findFallback) return findFallback;
+  }
+
+  return null;
+};

src/utils/getConversationMessage.ts

@@ -0,0 +1,65 @@
+import { configService, S3 } from '@config/env.config';
+
+const getTypeMessage = (msg: any) => {
+  let mediaId: string;
+
+  if (configService.get<S3>('S3').ENABLE) mediaId = msg.message.mediaUrl;
+  else mediaId = msg.key.id;
+
+  const types = {
+    conversation: msg?.message?.conversation,
+    extendedTextMessage: msg?.message?.extendedTextMessage?.text,
+    contactMessage: msg?.message?.contactMessage?.displayName,
+    locationMessage: msg?.message?.locationMessage?.degreesLatitude,
+    viewOnceMessageV2:
+      msg?.message?.viewOnceMessageV2?.message?.imageMessage?.url ||
+      msg?.message?.viewOnceMessageV2?.message?.videoMessage?.url ||
+      msg?.message?.viewOnceMessageV2?.message?.audioMessage?.url,
+    listResponseMessage: msg?.message?.listResponseMessage?.singleSelectReply?.selectedRowId,
+    responseRowId: msg?.message?.listResponseMessage?.singleSelectReply?.selectedRowId,
+    // Medias
+    audioMessage: msg?.message?.speechToText
+      ? msg?.message?.speechToText
+      : msg?.message?.audioMessage
+      ? `audioMessage|${mediaId}`
+      : undefined,
+    imageMessage: msg?.message?.imageMessage
+      ? `imageMessage|${mediaId}${msg?.message?.imageMessage?.caption ? `|${msg?.message?.imageMessage?.caption}` : ''}`
+      : undefined,
+    videoMessage: msg?.message?.videoMessage
+      ? `videoMessage|${mediaId}${msg?.message?.videoMessage?.caption ? `|${msg?.message?.videoMessage?.caption}` : ''}`
+      : undefined,
+    documentMessage: msg?.message?.documentMessage
+      ? `documentMessage|${mediaId}${
+          msg?.message?.documentMessage?.caption ? `|${msg?.message?.documentMessage?.caption}` : ''
+        }`
+      : undefined,
+    documentWithCaptionMessage: msg?.message?.documentWithCaptionMessage?.message?.documentMessage
+      ? `documentWithCaptionMessage|${mediaId}${
+          msg?.message?.documentWithCaptionMessage?.message?.documentMessage?.caption
+            ? `|${msg?.message?.documentWithCaptionMessage?.message?.documentMessage?.caption}`
+            : ''
+        }`
+      : undefined,
+  };
+
+  const messageType = Object.keys(types).find((key) => types[key] !== undefined) || 'unknown';
+
+  return { ...types, messageType };
+};
+
+const getMessageContent = (types: any) => {
+  const typeKey = Object.keys(types).find((key) => types[key] !== undefined);
+
+  const result = typeKey ? types[typeKey] : undefined;
+
+  return result;
+};
+
+export const getConversationMessage = (msg: any) => {
+  const types = getTypeMessage(msg);
+
+  const messageContent = getMessageContent(types);
+
+  return messageContent;
+};