feat: send media with form-data

Author: DavidsonGomes

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 * Sync lost messages on chatwoot
 * Set the maximum number of listeners that can be registered for events
+* Now is possible send medias with form-data
 
 ### Fixed
 

package.json

@@ -71,6 +71,7 @@
     "link-preview-js": "^3.0.4",
     "long": "^5.2.3",
     "mime": "^3.0.0",
+    "multer": "^1.4.5-lts.1",
     "node-cache": "^5.1.2",
     "pino": "^8.11.0",
     "qrcode": "^1.5.1",

src/@types/express.d.ts

@@ -0,0 +1,9 @@
+import { Multer } from 'multer';
+
+declare global {
+  namespace Express {
+    interface Request {
+      file?: Multer.File;
+    }
+  }
+}

src/api/controllers/sendMessage.controller.ts

@@ -28,27 +28,27 @@ export class SendMessageController {
     return await this.waMonitor.waInstances[instanceName].textMessage(data);
   }
 
-  public async sendMedia({ instanceName }: InstanceDto, data: SendMediaDto) {
+  public async sendMedia({ instanceName }: InstanceDto, data: SendMediaDto, file?: any) {
     if (isBase64(data?.media) && !data?.fileName && data?.mediatype === 'document') {
       throw new BadRequestException('For base64 the file name must be informed.');
     }
 
-    if (isURL(data?.media) || isBase64(data?.media)) {
-      return await this.waMonitor.waInstances[instanceName].mediaMessage(data);
+    if (file || isURL(data?.media) || isBase64(data?.media)) {
+      return await this.waMonitor.waInstances[instanceName].mediaMessage(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
 
-  public async sendSticker({ instanceName }: InstanceDto, data: SendStickerDto) {
-    if (isURL(data.sticker) || isBase64(data.sticker)) {
-      return await this.waMonitor.waInstances[instanceName].mediaSticker(data);
+  public async sendSticker({ instanceName }: InstanceDto, data: SendStickerDto, file?: any) {
+    if (file || isURL(data.sticker) || isBase64(data.sticker)) {
+      return await this.waMonitor.waInstances[instanceName].mediaSticker(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
 
-  public async sendWhatsAppAudio({ instanceName }: InstanceDto, data: SendAudioDto) {
-    if (isURL(data.audio) || isBase64(data.audio)) {
-      return await this.waMonitor.waInstances[instanceName].audioWhatsapp(data);
+  public async sendWhatsAppAudio({ instanceName }: InstanceDto, data: SendAudioDto, file?: any) {
+    if (file || isURL(data.audio) || isBase64(data.audio)) {
+      return await this.waMonitor.waInstances[instanceName].audioWhatsapp(data, file);
     }
     throw new BadRequestException('Owned media must be a url or base64');
   }
@@ -80,7 +80,7 @@ export class SendMessageController {
     return await this.waMonitor.waInstances[instanceName].pollMessage(data);
   }
 
-  public async sendStatus({ instanceName }: InstanceDto, data: SendStatusDto) {
-    return await this.waMonitor.waInstances[instanceName].statusMessage(data);
+  public async sendStatus({ instanceName }: InstanceDto, data: SendStatusDto, file?: any) {
+    return await this.waMonitor.waInstances[instanceName].statusMessage(data, file);
   }
 }

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

@@ -1853,8 +1853,12 @@ export class BaileysStartupService extends ChannelStartupService {
     throw new BadRequestException('Type not found');
   }
 
-  public async statusMessage(data: SendStatusDto) {
-    const status = await this.formatStatusMessage(data);
+  public async statusMessage(data: SendStatusDto, file?: any) {
+    const mediaData: SendStatusDto = { ...data };
+
+    if (file) mediaData.content = file.buffer.toString('base64');
+
+    const status = await this.formatStatusMessage(mediaData);
 
     return await this.sendMessageWithTyping('status@broadcast', {
       status,
@@ -1982,8 +1986,12 @@ export class BaileysStartupService extends ChannelStartupService {
     }
   }
 
-  public async mediaSticker(data: SendStickerDto) {
-    const convert = await this.convertToWebP(data.sticker);
+  public async mediaSticker(data: SendStickerDto, file?: any) {
+    const mediaData: SendStickerDto = { ...data };
+
+    if (file) mediaData.sticker = file.buffer.toString('base64');
+
+    const convert = await this.convertToWebP(mediaData.sticker);
     const gifPlayback = data.sticker.includes('.gif');
     const result = await this.sendMessageWithTyping(
       data.number,
@@ -2003,8 +2011,12 @@ export class BaileysStartupService extends ChannelStartupService {
     return result;
   }
 
-  public async mediaMessage(data: SendMediaDto) {
-    const generate = await this.prepareMediaMessage(data);
+  public async mediaMessage(data: SendMediaDto, file?: any) {
+    const mediaData: SendMediaDto = { ...data };
+
+    if (file) mediaData.media = file.buffer.toString('base64');
+
+    const generate = await this.prepareMediaMessage(mediaData);
 
     return await this.sendMessageWithTyping(
       data.number,
@@ -2019,15 +2031,19 @@ export class BaileysStartupService extends ChannelStartupService {
     );
   }
 
-  public async audioWhatsapp(data: SendAudioDto) {
+  public async audioWhatsapp(data: SendAudioDto, file?: any) {
+    const mediaData: SendAudioDto = { ...data };
+
+    if (file) mediaData.audio = file.buffer.toString('base64');
+
     if (!data?.encoding && data?.encoding !== false) {
       data.encoding = true;
     }
 
     return await this.sendMessageWithTyping<AnyMessageContent>(
       data.number,
       {
-        audio: isURL(data.audio) ? { url: data.audio } : Buffer.from(data.audio, 'base64'),
+        audio: isURL(mediaData.audio) ? { url: mediaData.audio } : Buffer.from(mediaData.audio, 'base64'),
         ptt: true,
         mimetype: 'audio/ogg; codecs=opus',
       },

src/api/routes/sendMessage.router.ts

@@ -29,9 +29,12 @@ import {
   textMessageSchema,
 } from '@validate/validate.schema';
 import { RequestHandler, Router } from 'express';
+import multer from 'multer';
 
 import { HttpStatus } from './index.router';
 
+const upload = multer({ storage: multer.memoryStorage() });
+
 export class MessageRouter extends RouterBroker {
   constructor(...guards: RequestHandler[]) {
     super();
@@ -56,43 +59,51 @@ export class MessageRouter extends RouterBroker {
 
         return res.status(HttpStatus.CREATED).json(response);
       })
-      .post(this.routerPath('sendMedia'), ...guards, async (req, res) => {
+      .post(this.routerPath('sendMedia'), ...guards, upload.single('file'), async (req, res) => {
+        const bodyData = req.body;
+
         const response = await this.dataValidate<SendMediaDto>({
           request: req,
           schema: mediaMessageSchema,
           ClassRef: SendMediaDto,
-          execute: (instance, data) => sendMessageController.sendMedia(instance, data),
+          execute: (instance) => sendMessageController.sendMedia(instance, bodyData, req.file as any),
         });
 
         return res.status(HttpStatus.CREATED).json(response);
       })
-      .post(this.routerPath('sendWhatsAppAudio'), ...guards, async (req, res) => {
+      .post(this.routerPath('sendWhatsAppAudio'), ...guards, upload.single('file'), async (req, res) => {
+        const bodyData = req.body;
+
         const response = await this.dataValidate<SendAudioDto>({
           request: req,
           schema: audioMessageSchema,
           ClassRef: SendMediaDto,
-          execute: (instance, data) => sendMessageController.sendWhatsAppAudio(instance, data),
+          execute: (instance) => sendMessageController.sendWhatsAppAudio(instance, bodyData, req.file as any),
         });
 
         return res.status(HttpStatus.CREATED).json(response);
       })
       // TODO: Revisar funcionamento do envio de Status
-      .post(this.routerPath('sendStatus'), ...guards, async (req, res) => {
+      .post(this.routerPath('sendStatus'), ...guards, upload.single('file'), async (req, res) => {
+        const bodyData = req.body;
+
         const response = await this.dataValidate<SendStatusDto>({
           request: req,
           schema: statusMessageSchema,
           ClassRef: SendStatusDto,
-          execute: (instance, data) => sendMessageController.sendStatus(instance, data),
+          execute: (instance) => sendMessageController.sendStatus(instance, bodyData, req.file as any),
         });
 
         return res.status(HttpStatus.CREATED).json(response);
       })
-      .post(this.routerPath('sendSticker'), ...guards, async (req, res) => {
+      .post(this.routerPath('sendSticker'), ...guards, upload.single('file'), async (req, res) => {
+        const bodyData = req.body;
+
         const response = await this.dataValidate<SendStickerDto>({
           request: req,
           schema: stickerMessageSchema,
           ClassRef: SendStickerDto,
-          execute: (instance, data) => sendMessageController.sendSticker(instance, data),
+          execute: (instance) => sendMessageController.sendSticker(instance, bodyData, req.file as any),
         });
 
         return res.status(HttpStatus.CREATED).json(response);

src/validate/message.schema.ts

@@ -108,7 +108,7 @@ export const mediaMessageSchema: JSONSchema7 = {
       },
     },
   },
-  required: ['number', 'mediatype', 'media'],
+  required: ['number', 'mediatype'],
 };
 
 export const audioMessageSchema: JSONSchema7 = {
@@ -134,7 +134,7 @@ export const audioMessageSchema: JSONSchema7 = {
       },
     },
   },
-  required: ['number', 'audio'],
+  required: ['number'],
 };
 
 export const statusMessageSchema: JSONSchema7 = {
@@ -158,7 +158,7 @@ export const statusMessageSchema: JSONSchema7 = {
     },
     allContacts: { type: 'boolean', enum: [true, false] },
   },
-  required: ['type', 'content'],
+  required: ['type'],
 };
 
 export const stickerMessageSchema: JSONSchema7 = {