@fer2809fl/baileys 7.0.0 → 7.0.2

package/lib/Socket/dugong.js

@@ -0,0 +1,772 @@
+import crypto from "crypto";
+import { proto } from "../../WAProto/index.js";
+import {
+  delay,
+  generateMessageID,
+  generateWAMessage,
+  generateWAMessageContent,
+  generateWAMessageFromContent,
+  getUrlFromDirectPath,
+  normalizeMessageContent,
+  prepareWAMessageMedia,
+} from "../Utils/index.js";
+import {
+  isJidGroup,
+  isPnUser,
+  jidNormalizedUser,
+  STORIES_JID,
+} from "../WABinary/index.js";
+export class Dugong {
+  constructor(waUploadToServer, relayMessageFn, config, sock) {
+    this.relayMessage = relayMessageFn;
+    this.waUploadToServer = waUploadToServer;
+    this.config = config;
+    this.sock = sock;
+  }
+  detectType(content) {
+    if (content.requestPaymentMessage) return "PAYMENT";
+    if (content.productMessage) return "PRODUCT";
+    if (content.interactiveButtons) return "INTERACTIVE_BUTTONS";
+    if (content.interactiveMessage?.carouselMessage) return "CAROUSEL";
+    if (content.interactiveMessage) return "INTERACTIVE";
+    if (content.albumMessage || content.album) return "ALBUM";
+    if (content.eventMessage) return "EVENT";
+    if (content.pollResultMessage) return "POLL_RESULT";
+    if (content.groupStatusMessage) return "GROUP_STORY";
+    return null;
+  }
+  async handlePayment(content, quoted) {
+    const data = content.requestPaymentMessage;
+    let notes = {};
+    if (data.sticker?.stickerMessage) {
+      notes = {
+        stickerMessage: {
+          ...data.sticker.stickerMessage,
+          contextInfo: {
+            stanzaId: quoted?.key?.id,
+            participant: quoted?.key?.participant || content.sender,
+            quotedMessage: quoted?.message,
+          },
+        },
+      };
+    } else if (data.note) {
+      notes = {
+        extendedTextMessage: {
+          text: data.note,
+          contextInfo: {
+            stanzaId: quoted?.key?.id,
+            participant: quoted?.key?.participant || content.sender,
+            quotedMessage: quoted?.message,
+          },
+        },
+      };
+    }
+    return {
+      requestPaymentMessage: proto.Message.RequestPaymentMessage.fromObject({
+        expiryTimestamp: data.expiry || 0,
+        amount1000: data.amount || 0,
+        currencyCodeIso4217: data.currency || "IDR",
+        requestFrom: data.from || "0@s.whatsapp.net",
+        noteMessage: notes,
+        background: data.background ?? {
+          id: "DEFAULT",
+          placeholderArgb: 0xfff0f0f0,
+        },
+      }),
+    };
+  }
+  async handleProduct(content, _jid, _quoted) {
+    const {
+      title,
+      description,
+      thumbnail,
+      productId,
+      retailerId,
+      url,
+      body = "",
+      footer = "",
+      buttons = [],
+      priceAmount1000 = null,
+      currencyCode = "IDR",
+    } = content.productMessage;
+    let productImage;
+    if (Buffer.isBuffer(thumbnail)) {
+      const { imageMessage } = await generateWAMessageContent(
+        { image: thumbnail },
+        { upload: this.waUploadToServer },
+      );
+      productImage = imageMessage;
+    } else if (typeof thumbnail === "object" && thumbnail.url) {
+      const { imageMessage } = await generateWAMessageContent(
+        { image: { url: thumbnail.url } },
+        { upload: this.waUploadToServer },
+      );
+      productImage = imageMessage;
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          interactiveMessage: {
+            body: { text: body },
+            footer: { text: footer },
+            header: {
+              title,
+              hasMediaAttachment: true,
+              productMessage: {
+                product: {
+                  productImage,
+                  productId,
+                  title,
+                  description,
+                  currencyCode,
+                  priceAmount1000,
+                  retailerId,
+                  url,
+                  productImageCount: 1,
+                },
+                businessOwnerJid: "0@s.whatsapp.net",
+              },
+            },
+            nativeFlowMessage: { buttons },
+          },
+        },
+      },
+    };
+  }
+  async handleInteractive(content, _jid, _quoted) {
+    const {
+      title,
+      footer,
+      thumbnail,
+      image,
+      video,
+      document,
+      mimetype,
+      fileName,
+      jpegThumbnail,
+      contextInfo,
+      externalAdReply,
+      buttons = [],
+      nativeFlowMessage,
+      header,
+    } = content.interactiveMessage;
+    let media = null;
+    let _mediaType = null;
+    if (thumbnail) {
+      media = await prepareWAMessageMedia(
+        { image: { url: thumbnail } },
+        { upload: this.waUploadToServer },
+      );
+      _mediaType = "image";
+    } else if (image) {
+      const src =
+        typeof image === "object" && image.url
+          ? { image: { url: image.url } }
+          : { image };
+      media = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      _mediaType = "image";
+    } else if (video) {
+      const src =
+        typeof video === "object" && video.url
+          ? { video: { url: video.url } }
+          : { video };
+      media = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      _mediaType = "video";
+    } else if (document) {
+      const docPayload = { document };
+      if (jpegThumbnail) {
+        docPayload.jpegThumbnail =
+          typeof jpegThumbnail === "object" && jpegThumbnail.url
+            ? { url: jpegThumbnail.url }
+            : jpegThumbnail;
+      }
+      media = await prepareWAMessageMedia(docPayload, {
+        upload: this.waUploadToServer,
+      });
+      if (fileName) media.documentMessage.fileName = fileName;
+      if (mimetype) media.documentMessage.mimetype = mimetype;
+      _mediaType = "document";
+    }
+    const interactiveMessage = {
+      body: { text: title || "" },
+      footer: { text: footer || "" },
+    };
+    if (buttons && buttons.length > 0) {
+      interactiveMessage.nativeFlowMessage = { buttons };
+      if (nativeFlowMessage) {
+        interactiveMessage.nativeFlowMessage = {
+          ...interactiveMessage.nativeFlowMessage,
+          ...nativeFlowMessage,
+        };
+      }
+    } else if (nativeFlowMessage) {
+      interactiveMessage.nativeFlowMessage = nativeFlowMessage;
+    }
+    if (media) {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: true,
+        ...media,
+      };
+    } else {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: false,
+      };
+    }
+    const finalContextInfo = {};
+    if (contextInfo) {
+      Object.assign(finalContextInfo, {
+        mentionedJid: contextInfo.mentionedJid || [],
+        forwardingScore: contextInfo.forwardingScore || 0,
+        isForwarded: contextInfo.isForwarded || false,
+        ...contextInfo,
+      });
+    }
+    if (externalAdReply) {
+      finalContextInfo.externalAdReply = {
+        title: externalAdReply.title || "",
+        body: externalAdReply.body || "",
+        mediaType: externalAdReply.mediaType || 1,
+        thumbnailUrl: externalAdReply.thumbnailUrl || "",
+        mediaUrl: externalAdReply.mediaUrl || "",
+        sourceUrl: externalAdReply.sourceUrl || "",
+        showAdAttribution: externalAdReply.showAdAttribution || false,
+        renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+        ...externalAdReply,
+      };
+    }
+    if (Object.keys(finalContextInfo).length > 0) {
+      interactiveMessage.contextInfo = finalContextInfo;
+    }
+    return { interactiveMessage };
+  }
+  async handleInteractiveButtons(content, _jid, _quoted) {
+    const {
+      text,
+      caption,
+      title,
+      subtitle,
+      footer,
+      interactiveButtons,
+      hasMediaAttachment,
+      image,
+      video,
+      document,
+      mimetype,
+      jpegThumbnail,
+      location,
+      product,
+      businessOwnerJid,
+      contextInfo,
+    } = content;
+    const bodyText = text || caption || "";
+    const buttons = interactiveButtons.map((btn) => ({
+      name: btn.name,
+      buttonParamsJson:
+        typeof btn.buttonParamsJson === "string"
+          ? btn.buttonParamsJson
+          : JSON.stringify(btn.buttonParamsJson),
+    }));
+    let headerContent = {};
+    let mediaAttached =
+      typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : false;
+    if (image) {
+      const src =
+        typeof image === "object" && image.url
+          ? { image: { url: image.url } }
+          : { image };
+      const uploaded = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (video) {
+      const src =
+        typeof video === "object" && video.url
+          ? { video: { url: video.url } }
+          : { video };
+      const uploaded = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (document) {
+      const docPayload =
+        typeof document === "object" && document.url
+          ? { document: { url: document.url } }
+          : { document };
+      if (mimetype) docPayload.mimetype = mimetype;
+      const uploaded = await prepareWAMessageMedia(docPayload, {
+        upload: this.waUploadToServer,
+      });
+      if (jpegThumbnail) {
+        uploaded.documentMessage.jpegThumbnail =
+          typeof jpegThumbnail === "string"
+            ? Buffer.from(jpegThumbnail, "base64")
+            : jpegThumbnail;
+      }
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (location) {
+      headerContent = {
+        locationMessage: {
+          degreesLatitude:
+            location.degressLatitude || location.degreesLatitude || 0,
+          degreesLongitude:
+            location.degressLongitude || location.degreesLongitude || 0,
+          name: location.name || "",
+        },
+      };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (product) {
+      let productImage;
+      if (product.productImage) {
+        const imgSrc =
+          typeof product.productImage === "object" && product.productImage.url
+            ? { image: { url: product.productImage.url } }
+            : { image: product.productImage };
+        const uploaded = await prepareWAMessageMedia(imgSrc, {
+          upload: this.waUploadToServer,
+        });
+        productImage = uploaded.imageMessage;
+      }
+      headerContent = {
+        productMessage: {
+          product: {
+            productImage,
+            productId: product.productId,
+            title: product.title,
+            description: product.description,
+            currencyCode: product.currencyCode || "IDR",
+            priceAmount1000: product.priceAmount1000,
+            retailerId: product.retailerId,
+            url: product.url,
+            productImageCount: product.productImageCount || 1,
+          },
+          businessOwnerJid: businessOwnerJid || "0@s.whatsapp.net",
+        },
+      };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    }
+    const interactiveMessage = {
+      body: { text: bodyText },
+      footer: { text: footer || "" },
+      header: {
+        title: title || "",
+        subtitle: subtitle || "",
+        hasMediaAttachment: mediaAttached,
+        ...headerContent,
+      },
+      nativeFlowMessage: { buttons },
+    };
+    if (contextInfo) {
+      interactiveMessage.contextInfo = contextInfo;
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            messageSecret: crypto.randomBytes(32),
+          },
+          interactiveMessage,
+        },
+      },
+    };
+  }
+  async handleCarousel(content, _jid, _quoted) {
+    const { interactiveMessage } = content;
+    const { body, footer, header, carouselMessage, contextInfo } =
+      interactiveMessage;
+    const processedCards = [];
+    for (const card of carouselMessage.cards) {
+      const cardMsg = {
+        body: card.body || { text: "" },
+        footer: card.footer || { text: "" },
+        header: {
+          title: card.header?.title || "",
+          hasMediaAttachment: false,
+        },
+      };
+      if (card.nativeFlowMessage) {
+        cardMsg.nativeFlowMessage = card.nativeFlowMessage;
+      }
+      if (
+        card.header?.imageMessage ||
+        card.header?.videoMessage ||
+        card.header?.documentMessage
+      ) {
+        let headerContent = {};
+        let mediaAttached = true;
+        if (card.header.imageMessage) {
+          const url = card.header.imageMessage.url || card.header.imageMessage;
+          const src =
+            typeof url === "string" ? { image: { url } } : { image: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        } else if (card.header.videoMessage) {
+          const url = card.header.videoMessage.url || card.header.videoMessage;
+          const src =
+            typeof url === "string" ? { video: { url } } : { video: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        } else if (card.header.documentMessage) {
+          const url =
+            card.header.documentMessage.url || card.header.documentMessage;
+          const src =
+            typeof url === "string" ? { document: { url } } : { document: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        }
+        cardMsg.header = {
+          title: card.header?.title || "",
+          hasMediaAttachment: mediaAttached,
+          ...headerContent,
+        };
+      }
+      processedCards.push(cardMsg);
+    }
+    const interactiveMsg = {
+      body: body || { text: "" },
+      footer: footer || { text: "" },
+      header: header || { title: "", hasMediaAttachment: false },
+      carouselMessage: {
+        cards: processedCards,
+        messageVersion: carouselMessage.messageVersion || 1,
+        carouselCardType: carouselMessage.carouselCardType ?? 1,
+      },
+    };
+    if (contextInfo) {
+      interactiveMsg.contextInfo = contextInfo;
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            messageSecret: crypto.randomBytes(32),
+          },
+          interactiveMessage: interactiveMsg,
+        },
+      },
+    };
+  }
+  async handleAlbum(content, jid, quoted) {
+    const array = content.albumMessage || content.album;
+    const ctxInfo = content.contextInfo || {};
+    const album = await generateWAMessageFromContent(
+      jid,
+      {
+        messageContextInfo: {
+          messageSecret: crypto.randomBytes(32),
+        },
+        albumMessage: {
+          expectedImageCount: array.filter((a) => "image" in a).length,
+          expectedVideoCount: array.filter((a) => "video" in a).length,
+        },
+      },
+      {
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+        quoted,
+        upload: this.waUploadToServer,
+      },
+    );
+    await this.relayMessage(jid, album.message, {
+      messageId: album.key.id,
+    });
+    for (let item of array) {
+      if (ctxInfo && Object.keys(ctxInfo).length > 0 && !item.contextInfo) {
+        item = { ...item, contextInfo: ctxInfo };
+      }
+      const img = await generateWAMessage(jid, item, {
+        upload: this.waUploadToServer,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      });
+      img.message.messageContextInfo = {
+        messageSecret: crypto.randomBytes(32),
+        messageAssociation: {
+          associationType: 1,
+          parentMessageKey: album.key,
+        },
+      };
+      await this.relayMessage(jid, img.message, {
+        messageId: img.key.id,
+      });
+    }
+    return album;
+  }
+  async handleEvent(content, jid, quoted) {
+    const eventData = content.eventMessage;
+    const msg = await generateWAMessageFromContent(
+      jid,
+      {
+        viewOnceMessage: {
+          message: {
+            messageContextInfo: {
+              deviceListMetadata: {},
+              deviceListMetadataVersion: 2,
+              messageSecret: crypto.randomBytes(32),
+            },
+            eventMessage: {
+              isCanceled: eventData.isCanceled || false,
+              name: eventData.name,
+              description: eventData.description,
+              location: eventData.location || {
+                degreesLatitude: 0,
+                degreesLongitude: 0,
+                name: "Location",
+              },
+              joinLink: eventData.joinLink || "",
+              startTime:
+                typeof eventData.startTime === "string"
+                  ? parseInt(eventData.startTime)
+                  : eventData.startTime || Date.now(),
+              endTime:
+                typeof eventData.endTime === "string"
+                  ? parseInt(eventData.endTime)
+                  : eventData.endTime || Date.now() + 3600000,
+              extraGuestsAllowed: eventData.extraGuestsAllowed !== false,
+            },
+          },
+        },
+      },
+      {
+        quoted,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      },
+    );
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id,
+    });
+    return msg;
+  }
+  async handlePollResult(content, jid, quoted) {
+    const pollData = content.pollResultMessage;
+    const msg = await generateWAMessageFromContent(
+      jid,
+      {
+        pollResultSnapshotMessage: {
+          name: pollData.name,
+          pollVotes: pollData.pollVotes.map((vote) => ({
+            optionName: vote.optionName,
+            optionVoteCount:
+              typeof vote.optionVoteCount === "number"
+                ? vote.optionVoteCount.toString()
+                : vote.optionVoteCount,
+          })),
+        },
+      },
+      {
+        quoted,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      },
+    );
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id,
+    });
+    return msg;
+  }
+  async handleGroupStory(content, jid, _quoted, options = {}) {
+    const storyData = content.groupStatusMessage;
+    let waMsgContent;
+    if (storyData.message) {
+      waMsgContent = storyData;
+    } else {
+      waMsgContent = await generateWAMessageContent(storyData, {
+        upload: this.waUploadToServer,
+      });
+    }
+    const innerMsg = waMsgContent.message || waMsgContent;
+    const msgKey = Object.keys(innerMsg).find(
+      (k) => innerMsg[k] && typeof innerMsg[k] === "object",
+    );
+    if (msgKey) {
+      innerMsg[msgKey].contextInfo = innerMsg[msgKey].contextInfo || {};
+      innerMsg[msgKey].contextInfo.isGroupStatus = true;
+      if (!innerMsg[msgKey].contextInfo.statusSourceType) {
+        if (innerMsg.imageMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 0;
+        else if (innerMsg.videoMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 1;
+        else if (innerMsg.audioMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 3;
+        else if (innerMsg.extendedTextMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 4;
+      }
+    }
+    const finalMsg = {
+      groupStatusMessageV2: {
+        message: innerMsg,
+      },
+    };
+    return await this.relayMessage(jid, finalMsg, {
+      messageId: generateMessageID(),
+    });
+  }
+  async sendStatusWhatsApp(content, jids = []) {
+    const userJid = jidNormalizedUser(this.sock.authState.creds.me.id);
+    const allUsers = new Set();
+    allUsers.add(userJid);
+    for (const id of jids) {
+      if (isJidGroup(id)) {
+        try {
+          const metadata = await this.sock.groupMetadata(id);
+          metadata.participants.forEach((p) =>
+            allUsers.add(jidNormalizedUser(p.id)),
+          );
+        } catch (error) {
+          this.config.logger.error(
+            `Error getting metadata for group ${id}: ${error}`,
+          );
+        }
+      } else if (isPnUser(id)) {
+        allUsers.add(jidNormalizedUser(id));
+      }
+    }
+    const uniqueUsers = Array.from(allUsers);
+    const getRandomHexColor = () =>
+      "#" +
+      Math.floor(Math.random() * 16777215)
+        .toString(16)
+        .padStart(6, "0");
+    const isMedia = content.image || content.video || content.audio;
+    const isAudio = !!content.audio;
+    const messageContent = { ...content };
+    if (isMedia && !isAudio) {
+      if (messageContent.text) {
+        messageContent.caption = messageContent.text;
+        delete messageContent.text;
+      }
+      delete messageContent.ptt;
+      delete messageContent.font;
+      delete messageContent.backgroundColor;
+      delete messageContent.textColor;
+    }
+    if (isAudio) {
+      delete messageContent.text;
+      delete messageContent.caption;
+      delete messageContent.font;
+      delete messageContent.textColor;
+    }
+    const font = !isMedia
+      ? content.font || Math.floor(Math.random() * 9)
+      : undefined;
+    const textColor = !isMedia
+      ? content.textColor || getRandomHexColor()
+      : undefined;
+    const backgroundColor =
+      !isMedia || isAudio
+        ? content.backgroundColor || getRandomHexColor()
+        : undefined;
+    const ptt = isAudio
+      ? typeof content.ptt === "boolean"
+        ? content.ptt
+        : true
+      : undefined;
+    const { getUrlInfo } = await import("../Utils/link-preview.js");
+    const msg = await generateWAMessage(STORIES_JID, messageContent, {
+      logger: this.config.logger,
+      userJid,
+      getUrlInfo: (text) =>
+        getUrlInfo(text, {
+          thumbnailWidth: this.config.linkPreviewImageThumbnailWidth,
+          fetchOpts: { timeout: 3000, ...(this.config.options || {}) },
+          logger: this.config.logger,
+          uploadImage: this.config.generateHighQualityLinkPreview
+            ? this.waUploadToServer
+            : undefined,
+        }),
+      upload: this.waUploadToServer,
+      mediaCache: this.config.mediaCache,
+      options: this.config.options,
+      font,
+      textColor,
+      backgroundColor,
+      ptt,
+    });
+    await this.relayMessage(STORIES_JID, msg.message, {
+      messageId: msg.key.id,
+      statusJidList: uniqueUsers,
+      additionalNodes: [
+        {
+          tag: "meta",
+          attrs: {},
+          content: [
+            {
+              tag: "mentioned_users",
+              attrs: {},
+              content: jids.map((jid) => ({
+                tag: "to",
+                attrs: { jid: jidNormalizedUser(jid) },
+              })),
+            },
+          ],
+        },
+      ],
+    });
+    for (const id of jids) {
+      try {
+        const normalizedId = jidNormalizedUser(id);
+        const isPrivate = isPnUser(normalizedId);
+        const type = isPrivate
+          ? "statusMentionMessage"
+          : "groupStatusMentionMessage";
+        const protocolMessage = {
+          [type]: {
+            message: {
+              protocolMessage: {
+                key: msg.key,
+                type: 25,
+              },
+            },
+          },
+          messageContextInfo: {
+            messageSecret: crypto.randomBytes(32),
+          },
+        };
+        const statusMsg = await generateWAMessageFromContent(
+          normalizedId,
+          protocolMessage,
+          {
+            userJid: jidNormalizedUser(
+              this.sock.authState?.creds?.me?.id || "",
+            ),
+          },
+        );
+        await this.relayMessage(normalizedId, statusMsg.message, {
+          additionalNodes: [
+            {
+              tag: "meta",
+              attrs: isPrivate
+                ? { is_status_mention: "true" }
+                : { is_group_status_mention: "true" },
+            },
+          ],
+        });
+        await delay(2000);
+      } catch (error) {
+        this.config.logger.error(`Error sending to ${id}: ${error}`);
+      }
+    }
+    return msg;
+  }
+}
+//# sourceMappingURL=dugong.js.map