@cexy/hoonfca 1.0.0

package/src/sendMessageMqtt.js

@@ -0,0 +1,326 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function uploadAttachment(attachments, callback) {
+    callback = callback || function () {};
+    var uploads = [];
+
+    // create an array of promises
+    for (var i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw {
+          error:
+            "Attachment should be a readable stream and not " +
+            utils.getType(attachments[i]) +
+            ".",
+        };
+      }
+
+      var form = {
+        upload_1024: attachments[i],
+        voice_clip: "true",
+      };
+
+      uploads.push(
+        defaultFuncs
+          .postFormData(
+            "https://upload.facebook.com/ajax/mercury/upload.php",
+            ctx.jar,
+            form,
+            {},
+          )
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(function (resData) {
+            if (resData.error) {
+              throw resData;
+            }
+
+            // We have to return the data unformatted unless we want to change it
+            // back in sendMessage.
+            return resData.payload.metadata[0];
+          }),
+      );
+    }
+
+    // resolve all promises
+    Promise.all(uploads)
+      .then(function (resData) {
+        callback(null, resData);
+      })
+      .catch(function (err) {
+        utils.error("uploadAttachment", err);
+        return callback(err);
+      });
+  }
+
+  let variance = 0;
+  const epoch_id = () =>
+    Math.floor(Date.now() * (4194304 + (variance = (variance + 0.1) % 5)));
+  const emojiSizes = {
+    small: 1,
+    medium: 2,
+    large: 3,
+  };
+
+  function handleEmoji(msg, form, callback, cb) {
+    if (msg.emojiSize != null && msg.emoji == null) {
+      return callback({ error: "emoji property is empty" });
+    }
+    if (msg.emoji) {
+      if (!msg.emojiSize) {
+        msg.emojiSize = "small";
+      }
+      if (
+        msg.emojiSize !== "small" &&
+        msg.emojiSize !== "medium" &&
+        msg.emojiSize !== "large" &&
+        (isNaN(msg.emojiSize) || msg.emojiSize < 1 || msg.emojiSize > 3)
+      ) {
+        return callback({ error: "emojiSize property is invalid" });
+      }
+
+      form.payload.tasks[0].payload.send_type = 1;
+      form.payload.tasks[0].payload.text = msg.emoji;
+      form.payload.tasks[0].payload.hot_emoji_size = !isNaN(msg.emojiSize)
+        ? Number(msg.emojiSize)
+        : emojiSizes[msg.emojiSize];
+    }
+    cb();
+  }
+
+  function handleSticker(msg, form, callback, cb) {
+    if (msg.sticker) {
+      form.payload.tasks[0].payload.send_type = 2;
+      form.payload.tasks[0].payload.sticker_id = msg.sticker;
+    }
+    cb();
+  }
+
+  function handleAttachment(msg, form, callback, cb) {
+    if (msg.attachment) {
+      form.payload.tasks[0].payload.send_type = 3;
+      form.payload.tasks[0].payload.attachment_fbids = [];
+      if (form.payload.tasks[0].payload.text == "") {
+        form.payload.tasks[0].payload.text = null;
+      }
+      if (utils.getType(msg.attachment) !== "Array") {
+        msg.attachment = [msg.attachment];
+      }
+
+      uploadAttachment(msg.attachment, function (err, files) {
+        if (err) {
+          return callback(err);
+        }
+
+        files.forEach(function (file) {
+          var key = Object.keys(file);
+          var type = key[0]; // image_id, file_id, etc
+          form.payload.tasks[0].payload.attachment_fbids.push(file[type]); // push the id
+        });
+        cb();
+      });
+    } else {
+      cb();
+    }
+  }
+
+  function handleMention(msg, form, callback, cb) {
+    if (msg.mentions) {
+      form.payload.tasks[0].payload.send_type = 1;
+
+      const arrayIds = [];
+      const arrayOffsets = [];
+      const arrayLengths = [];
+      const mention_types = [];
+      const bodyText = msg.body ? msg.body.toString() : "";
+
+      for (let i = 0; i < msg.mentions.length; i++) {
+        const mention = msg.mentions[i];
+
+        const tag = mention.tag;
+        if (typeof tag !== "string") {
+          return callback({ error: "Mention tags must be strings." });
+        }
+
+        const offset = bodyText.indexOf(tag, mention.fromIndex || 0);
+
+        if (offset < 0) {
+          utils.warn(
+            "handleMention",
+            'Mention for "' + tag + '" not found in message string.',
+          );
+        }
+
+        if (mention.id == null) {
+          utils.warn("handleMention", "Mention id should be non-null.");
+        }
+
+        const id = mention.id || 0;
+        arrayIds.push(id);
+        arrayOffsets.push(offset);
+        arrayLengths.push(tag.length);
+        mention_types.push("p");
+      }
+
+      form.payload.tasks[0].payload.mention_data = {
+        mention_ids: arrayIds.join(","),
+        mention_offsets: arrayOffsets.join(","),
+        mention_lengths: arrayLengths.join(","),
+        mention_types: mention_types.join(","),
+      };
+    }
+    cb();
+  }
+
+  function handleLocation(msg, form, callback, cb) {
+    if (msg.location) {
+      if (msg.location.latitude == null || msg.location.longitude == null) {
+        return callback({
+          error: "location property needs both latitude and longitude",
+        });
+      }
+
+      form.payload.tasks[0].payload.send_type = 1;
+      form.payload.tasks[0].payload.location_data = {
+        coordinates: {
+          latitude: msg.location.latitude,
+          longitude: msg.location.longitude,
+        },
+        is_current_location: !!msg.location.current,
+        is_live_location: !!msg.location.live,
+      };
+    }
+
+    cb();
+  }
+
+  function send(form, threadID, callback, replyToMessage) {
+    if (replyToMessage) {
+      form.payload.tasks[0].payload.reply_metadata = {
+        reply_source_id: replyToMessage.toString(),
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+    const mqttClient = ctx.mqttClient;
+    if (!mqttClient) {
+      return callback({ error: "MQTT Client is not initialized." });
+    }
+
+    form.payload.tasks.forEach((task) => {
+      task.payload = JSON.stringify(task.payload);
+    });
+    form.payload = JSON.stringify(form.payload);
+
+    return mqttClient.publish(
+      "/ls_req",
+      JSON.stringify(form),
+      { qos: 1, retain: false },
+      function (err, data) {
+        if (err) {
+          utils.error("Error publishing message: ", err);
+          return callback(err);
+        } else {
+          return callback(null, data);
+        }
+      },
+    );
+  }
+
+  return function sendMessageMqtt(msg, threadID, callback, replyToMessage) {
+    if (
+      !callback &&
+      (utils.getType(threadID) === "Function" ||
+        utils.getType(threadID) === "AsyncFunction")
+    ) {
+      return threadID({ error: "Pass a threadID as a second argument." });
+    }
+    if (!replyToMessage && utils.getType(callback) === "String") {
+      replyToMessage = callback;
+      callback = function () {};
+    }
+
+    if (!callback) {
+      callback = function (err, data) {};
+    }
+
+    var msgType = utils.getType(msg);
+    var threadIDType = utils.getType(threadID);
+
+    if (msgType !== "String" && msgType !== "Object") {
+      return callback({
+        error:
+          "Message should be of type string or object and not " + msgType + ".",
+      });
+    }
+
+    if (!threadID) {
+      return callback({ error: "ThreadID is required." });
+    }
+
+    if (msgType === "String") {
+      msg = { body: msg };
+    }
+
+    const timestamp = Date.now();
+    const epoch = timestamp << 22;
+    const otid = epoch + Math.floor(Math.random() * 4194304);
+
+    const form = {
+      app_id: "2220391788200892",
+      payload: {
+        tasks: [
+          {
+            label: "46",
+            payload: {
+              thread_id: threadID.toString(),
+              otid: otid.toString(),
+              source: 0,
+              send_type: 1,
+              sync_group: 1,
+              text:
+                msg.body != null && msg.body !== undefined
+                  ? msg.body.toString()
+                  : "",
+              initiating_source: 1,
+              skip_url_preview_gen: 0,
+            },
+            queue_name: threadID.toString(),
+            task_id: 0,
+            failure_count: null,
+          },
+          {
+            label: "21",
+            payload: {
+              thread_id: threadID.toString(),
+              last_read_watermark_ts: Date.now(),
+              sync_group: 1,
+            },
+            queue_name: threadID.toString(),
+            task_id: 1,
+            failure_count: null,
+          },
+        ],
+        epoch_id: epoch_id(),
+        version_id: "6120284488008082",
+        data_trace_id: null,
+      },
+      request_id: 1,
+      type: 3,
+    };
+
+    handleEmoji(msg, form, callback, function () {
+      handleLocation(msg, form, callback, function () {
+        handleMention(msg, form, callback, function () {
+          handleSticker(msg, form, callback, function () {
+            handleAttachment(msg, form, callback, function () {
+              send(form, threadID, callback, replyToMessage);
+            });
+          });
+        });
+      });
+    });
+  };
+};

package/src/sendTypingIndicator.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var utils = require("../utils");
+// @NethWs3Dev
+
+module.exports = function (defaultFuncs, api, ctx) {
+	let count_req = 0;
+
+	return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
+		if (typeof callback !== "function") {
+			callback = function () {};
+		}
+
+		if (!threadID) {
+			return callback({ error: "ThreadID is required." });
+		}
+
+		if (!ctx.mqttClient) {
+			return callback({ error: "MQTT Client is not initialized." });
+		}
+
+		var wsContent = {
+			app_id: 2220391788200892,
+			payload: JSON.stringify({
+				label: 3,
+				payload: JSON.stringify({
+					thread_key: threadID.toString(),
+					is_group_thread: +(threadID.toString().length >= 16),
+					is_typing: +sendTyping,
+					attribution: 0
+				}),
+				version: 5849951561777440
+			}),
+			request_id: ++count_req,
+			type: 4
+		};
+
+		try {
+			await new Promise((resolve, reject) => {
+				ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), { qos: 1, retain: false }, (err, _packet) => {
+					if (err) {
+						reject(err);
+					} else {
+						resolve();
+					}
+				});
+			});
+			callback(null);
+		} catch (err) {
+			utils.error("sendTypingIndicatorV2", err);
+			callback(err);
+		}
+	};
+};

package/src/setMessageReaction.js

@@ -0,0 +1,126 @@
+"use strict";
+
+const utils = require("../utils");
+// @NethWs3Dev
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReaction(
+    reaction,
+    messageID,
+    callback,
+    forceCustomReaction,
+  ) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    if (!messageID) {
+      return callback({ error: "MessageID is required." });
+    }
+
+    switch (reaction) {
+      case "\uD83D\uDE0D": //:heart_eyes:
+      case "\uD83D\uDE06": //:laughing:
+      case "\uD83D\uDE2E": //:open_mouth:
+      case "\uD83D\uDE22": //:cry:
+      case "\uD83D\uDE20": //:angry:
+      case "\uD83D\uDC4D": //:thumbsup:
+      case "\uD83D\uDC4E": //:thumbsdown:
+      case "\u2764": //:heart:
+      case "\uD83D\uDC97": //:glowingheart:
+      case "":
+        //valid
+        break;
+      case ":heart_eyes:":
+      case ":love:":
+        reaction = "\uD83D\uDE0D";
+        break;
+      case ":laughing:":
+      case ":haha:":
+        reaction = "\uD83D\uDE06";
+        break;
+      case ":open_mouth:":
+      case ":wow:":
+        reaction = "\uD83D\uDE2E";
+        break;
+      case ":cry:":
+      case ":sad:":
+        reaction = "\uD83D\uDE22";
+        break;
+      case ":angry:":
+        reaction = "\uD83D\uDE20";
+        break;
+      case ":thumbsup:":
+      case ":like:":
+        reaction = "\uD83D\uDC4D";
+        break;
+      case ":thumbsdown:":
+      case ":dislike:":
+        reaction = "\uD83D\uDC4E";
+        break;
+      case ":heart:":
+        reaction = "\u2764";
+        break;
+      case ":glowingheart:":
+        reaction = "\uD83D\uDC97";
+        break;
+      default:
+        if (forceCustomReaction) {
+          break;
+        }
+        return callback({ error: "Reaction is not a valid emoji." });
+    }
+
+    const variables = {
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction: reaction,
+      },
+    };
+
+    const qs = {
+      doc_id: "1491398900900362",
+      variables: JSON.stringify(variables),
+      dpr: 1,
+    };
+
+    defaultFuncs
+      .postFormData(
+        "https://www.facebook.com/webgraphql/mutation/",
+        ctx.jar,
+        {},
+        qs,
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (!resData) {
+          throw { error: "setReaction returned empty object." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        callback(null);
+      })
+      .catch(function (err) {
+        utils.error("setReaction", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/setMessageReactionMqtt.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    // safe callback check
+    if (typeof callback !== 'function') {
+      callback = function () {};
+    }
+
+    if (!ctx.mqttClient) {
+      return callback({ error: 'Not connected to MQTT' });
+    }
+
+    if (!messageID || !threadID) {
+      return callback({ error: 'messageID and threadID are required.' });
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskPayload = {
+      thread_key: threadID.toString(),
+      timestamp_ms: Date.now(),
+      message_id: messageID.toString(),
+      reaction: reaction || "", // reaction খালি হলে রিমুভ হবে
+      actor_id: ctx.userID.toString(),
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289
+    };
+
+    const task = {
+      failure_count: null,
+      label: '29',
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(['reaction', messageID.toString()]),
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: '7158486590867448',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    if (ctx.reqCallbacks) {
+      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    }
+
+    ctx.mqttClient.publish(
+      '/ls_req', 
+      JSON.stringify(content), 
+      { qos: 1, retain: false }, 
+      function (err, data) {
+        if (err) {
+          utils.error("setMessageReactionMqtt", err);
+          return callback(err);
+        }
+        // যদি reqCallbacks রেজিস্টার্ড না থাকে, তবে পাবলিশের সাথে সাথে কলব্যাক ফায়ার করবে
+        if (!ctx.reqCallbacks) {
+          callback(null, data);
+        }
+      }
+    );
+  };
+};

package/src/setPostReaction.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const utils = require("../utils");
+
+function formatData(resData) {
+  return {
+    viewer_feedback_reaction_info: resData.feedback_react.feedback.viewer_feedback_reaction_info,
+    supported_reactions: resData.feedback_react.feedback.supported_reactions,
+    top_reactions: resData.feedback_react.feedback.top_reactions.edges,
+    reaction_count: resData.feedback_react.feedback.reaction_count,
+  };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setPostReaction(postID, type, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction") {
+        callback = type;
+        type = 0;
+      } else {
+        callback = function (err, data) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc(data);
+        };
+      }
+    }
+
+    if (!postID) {
+      return callback({ error: "setPostReaction: postID is required" });
+    }
+
+    const map = {
+      unlike: 0,
+      like: 1,
+      heart: 2,
+      love: 16,
+      haha: 4,
+      wow: 3,
+      sad: 7,
+      angry: 8,
+    };
+
+    const originalType = type;
+    if (utils.getType(type) === "String") {
+      type = map[type.toLowerCase()];
+    }
+
+    if (type === undefined || (utils.getType(type) !== "Number" && utils.getType(type) !== "String")) {
+      return callback({
+        error: "setPostReaction: Invalid reaction type (" + originalType + ")",
+      });
+    }
+
+    const form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "CometUFIFeedbackReactMutation",
+      doc_id: "4769042373179384",
+      variables: JSON.stringify({
+        input: {
+          actor_id: ctx.userID,
+          feedback_id: Buffer.from("feedback:" + postID).toString("base64"),
+          feedback_reaction: type,
+          feedback_source: "OBJECT",
+          is_tracking_encrypted: true,
+          tracking: [],
+          session_id: "f7dd50dd-db6e-4598-8cd9-561d5002b423",
+          client_mutation_id: Math.round(Math.random() * 19).toString(),
+        },
+        useDefaultActor: false,
+        scale: 3,
+      }),
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (!resData) {
+          throw { error: "setPostReaction returned empty response." };
+        }
+        if (resData.errors) {
+          throw resData;
+        }
+        return callback(null, formatData(resData.data));
+      })
+      .catch(function (err) {
+        utils.error("setPostReaction", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};