feat: Integration with Dify

Adds support for Dify integration, including new routes, services, and controllers. The configuration for Dify has been added to the environment file, and the necessary changes have been made to the `.env.example` file. Additionally, the WhatsApp Baileys service has been updated to handle Dify notifications.

Modified files:
- `.env.example`
- `package.json`
- `src/api/integrations/openai/services/openai.service.ts`
- `src/api/routes/index.router.ts`
- `src/api/server.module.ts`
- `src/api/services/channel.service.ts`
- `src/api/services/channels/whatsapp.baileys.service.ts`
- `src/config/env.config.ts`
- `src/validate/validate.schema.ts`

Introduced files:
- `src/api/integrations/dify/`
- `src/api/integrations/dify/controllers/dify.controller.ts`
- `src/api/integrations/dify/dto/dify.dto.ts`
- `src/api/integrations/dify/routes/dify.router.ts`
- `src/api/integrations/dify/services/dify.service.ts`
- `src/api/integrations/dify/validate/dify.schema.ts`

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

@@ -0,0 +1,69 @@
+import { configService, Dify } from '../../../../config/env.config';
+import { BadRequestException } from '../../../../exceptions';
+import { InstanceDto } from '../../../dto/instance.dto';
+import { DifyDto, DifyIgnoreJidDto } from '../dto/dify.dto';
+import { DifyService } from '../services/dify.service';
+
+export class DifyController {
+  constructor(private readonly difyService: DifyService) {}
+
+  public async createDify(instance: InstanceDto, data: DifyDto) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.create(instance, data);
+  }
+
+  public async findDify(instance: InstanceDto) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.find(instance);
+  }
+
+  public async fetchDify(instance: InstanceDto, difyId: string) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.fetch(instance, difyId);
+  }
+
+  public async updateDify(instance: InstanceDto, difyId: string, data: DifyDto) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.update(instance, difyId, data);
+  }
+
+  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);
+  }
+
+  public async settings(instance: InstanceDto, data: any) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.setDefaultSettings(instance, data);
+  }
+
+  public async fetchSettings(instance: InstanceDto) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.fetchDefaultSettings(instance);
+  }
+
+  public async changeStatus(instance: InstanceDto, data: any) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.changeStatus(instance, data);
+  }
+
+  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);
+  }
+
+  public async ignoreJid(instance: InstanceDto, data: DifyIgnoreJidDto) {
+    if (!configService.get<Dify>('DIFY').ENABLED) throw new BadRequestException('Dify is disabled');
+
+    return this.difyService.ignoreJid(instance, data);
+  }
+}

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

@@ -0,0 +1,46 @@
+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;
+  botType?: $Enums.DifyBotType;
+  apiUrl?: string;
+  apiKey?: string;
+  expire?: number;
+  keywordFinish?: string;
+  delayMessage?: number;
+  unknownMessage?: string;
+  listeningFromMe?: boolean;
+  stopBotFromMe?: boolean;
+  keepOpen?: boolean;
+  debounceTime?: number;
+  triggerType?: TriggerType;
+  triggerOperator?: TriggerOperator;
+  triggerValue?: string;
+  ignoreJids?: any;
+}
+
+export class DifySettingDto {
+  expire?: number;
+  keywordFinish?: string;
+  delayMessage?: number;
+  unknownMessage?: string;
+  listeningFromMe?: boolean;
+  stopBotFromMe?: boolean;
+  keepOpen?: boolean;
+  debounceTime?: number;
+  difyIdFallback?: string;
+  ignoreJids?: any;
+}
+
+export class DifyIgnoreJidDto {
+  remoteJid?: string;
+  action?: string;
+}

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

@@ -0,0 +1,123 @@
+import { RequestHandler, Router } from 'express';
+
+import {
+  difyIgnoreJidSchema,
+  difySchema,
+  difySettingSchema,
+  difyStatusSchema,
+  instanceSchema,
+} from '../../../../validate/validate.schema';
+import { RouterBroker } from '../../../abstract/abstract.router';
+import { InstanceDto } from '../../../dto/instance.dto';
+import { HttpStatus } from '../../../routes/index.router';
+import { difyController } from '../../../server.module';
+import { DifyDto, DifyIgnoreJidDto, DifySettingDto } from '../dto/dify.dto';
+
+export class DifyRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('create'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<DifyDto>({
+          request: req,
+          schema: difySchema,
+          ClassRef: DifyDto,
+          execute: (instance, data) => difyController.createDify(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => difyController.findDify(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('fetch/:difyId'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => difyController.fetchDify(instance, req.params.difyId),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .put(this.routerPath('update/:difyId'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<DifyDto>({
+          request: req,
+          schema: difySchema,
+          ClassRef: DifyDto,
+          execute: (instance, data) => difyController.updateDify(instance, req.params.difyId, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .delete(this.routerPath('delete/:difyId'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => difyController.deleteDify(instance, req.params.difyId),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('settings'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<DifySettingDto>({
+          request: req,
+          schema: difySettingSchema,
+          ClassRef: DifySettingDto,
+          execute: (instance, data) => difyController.settings(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('fetchSettings'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => difyController.fetchSettings(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('changeStatus'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: difyStatusSchema,
+          ClassRef: InstanceDto,
+          execute: (instance, data) => difyController.changeStatus(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('fetchSessions/:difyId'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => difyController.fetchSessions(instance, req.params.difyId),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('ignoreJid'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<DifyIgnoreJidDto>({
+          request: req,
+          schema: difyIgnoreJidSchema,
+          ClassRef: DifyIgnoreJidDto,
+          execute: (instance, data) => difyController.ignoreJid(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/api/integrations/dify/validate/dify.schema.ts

@@ -0,0 +1,107 @@
+import { JSONSchema7 } from 'json-schema';
+import { v4 } from 'uuid';
+
+const isNotEmpty = (...propertyNames: string[]): JSONSchema7 => {
+  const properties = {};
+  propertyNames.forEach(
+    (property) =>
+      (properties[property] = {
+        minLength: 1,
+        description: `The "${property}" cannot be empty`,
+      }),
+  );
+  return {
+    if: {
+      propertyNames: {
+        enum: [...propertyNames],
+      },
+    },
+    then: { properties },
+  };
+};
+
+export const difySchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean' },
+    botType: { type: 'string', enum: ['chatBot', 'textGenerator', 'agent', 'workflow'] },
+    apiUrl: { type: 'string' },
+    apiKey: { type: 'string' },
+    triggerType: { type: 'string', enum: ['all', 'keyword', 'none'] },
+    triggerOperator: { type: 'string', enum: ['equals', 'contains', 'startsWith', 'endsWith', 'regex'] },
+    triggerValue: { type: 'string' },
+    expire: { type: 'integer' },
+    keywordFinish: { type: 'string' },
+    delayMessage: { type: 'integer' },
+    unknownMessage: { type: 'string' },
+    listeningFromMe: { type: 'boolean' },
+    stopBotFromMe: { type: 'boolean' },
+    keepOpen: { type: 'boolean' },
+    debounceTime: { type: 'integer' },
+    ignoreJids: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['enabled', 'botType', 'triggerType'],
+  ...isNotEmpty('enabled', 'botType', 'triggerType'),
+};
+
+export const difyStatusSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    remoteJid: { type: 'string' },
+    status: { type: 'string', enum: ['opened', 'closed', 'paused', 'delete'] },
+  },
+  required: ['remoteJid', 'status'],
+  ...isNotEmpty('remoteJid', 'status'),
+};
+
+export const difySettingSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    expire: { type: 'integer' },
+    keywordFinish: { type: 'string' },
+    delayMessage: { type: 'integer' },
+    unknownMessage: { type: 'string' },
+    listeningFromMe: { type: 'boolean' },
+    stopBotFromMe: { type: 'boolean' },
+    keepOpen: { type: 'boolean' },
+    debounceTime: { type: 'integer' },
+    ignoreJids: { type: 'array', items: { type: 'string' } },
+    difyIdFallback: { type: 'string' },
+  },
+  required: [
+    'expire',
+    'keywordFinish',
+    'delayMessage',
+    'unknownMessage',
+    'listeningFromMe',
+    'stopBotFromMe',
+    'keepOpen',
+    'debounceTime',
+    'ignoreJids',
+  ],
+  ...isNotEmpty(
+    'expire',
+    'keywordFinish',
+    'delayMessage',
+    'unknownMessage',
+    'listeningFromMe',
+    'stopBotFromMe',
+    'keepOpen',
+    'debounceTime',
+    'ignoreJids',
+  ),
+};
+
+export const difyIgnoreJidSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    remoteJid: { type: 'string' },
+    action: { type: 'string', enum: ['add', 'remove'] },
+  },
+  required: ['remoteJid', 'action'],
+  ...isNotEmpty('remoteJid', 'action'),
+};

src/api/integrations/openai/services/openai.service.ts

@@ -730,7 +730,7 @@ export class OpenaiService {
         })
         .then((instance) => instance.id);
 
-      const defaultSettingCheck = await this.prismaRepository.typebotSetting.findFirst({
+      const defaultSettingCheck = await this.prismaRepository.openaiSetting.findFirst({
         where: {
           instanceId,
         },