@vangbanlanhat/fca-unofficial 1.4.2

package/src/actions/sendMessageMqtt.js

@@ -0,0 +1,235 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+var createUploadAttachment = require("../service/uploadAttachment");
+
+module.exports = function (defaultFuncs, _api, ctx) {
+  var mqttVariance = 0;
+
+  var uploadAttachment = createUploadAttachment(defaultFuncs, ctx, log);
+
+  function mqttEpochID() {
+    mqttVariance = (mqttVariance + 0.1) % 5;
+    return Math.floor(Date.now() * (4194304 + mqttVariance));
+  }
+
+  return function sendMessageMqtt(msg, threadID, callback, replyToMessage) {
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      return callback({ error: "MQTT client is not connected. Call listenMqtt first." });
+    }
+
+    var emojiSizes = { small: 1, medium: 2, large: 3 };
+    var threadIDString = threadID.toString();
+    var timestamp = Date.now();
+    var epoch = timestamp << 22;
+    var otid = epoch + Math.floor(Math.random() * 4194304);
+
+    var form = {
+      app_id: "2220391788200892",
+      payload: {
+        tasks: [
+          {
+            label: "46",
+            payload: {
+              thread_id: threadIDString,
+              otid: otid.toString(),
+              source: 0,
+              send_type: 1,
+              sync_group: 1,
+              text: msg.body != null ? msg.body.toString() : "",
+              initiating_source: 1,
+              skip_url_preview_gen: 0
+            },
+            queue_name: threadIDString,
+            task_id: 0,
+            failure_count: null
+          },
+          {
+            label: "21",
+            payload: {
+              thread_id: threadIDString,
+              last_read_watermark_ts: Date.now(),
+              sync_group: 1
+            },
+            queue_name: threadIDString,
+            task_id: 1,
+            failure_count: null
+          }
+        ],
+        epoch_id: mqttEpochID(),
+        version_id: "6120284488008082",
+        data_trace_id: null
+      },
+      request_id: 1,
+      type: 3
+    };
+
+    if (msg.emoji) {
+      var emojiSize = msg.emojiSize || "small";
+      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(emojiSize)
+        ? emojiSize
+        : emojiSizes[emojiSize];
+    }
+
+    if (msg.location) {
+      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
+      };
+    }
+
+    if (msg.mentions && msg.body) {
+      var mentionIds = [];
+      var mentionOffsets = [];
+      var mentionLengths = [];
+      var mentionTypes = [];
+
+      for (var i = 0; i < msg.mentions.length; i++) {
+        var mention = msg.mentions[i];
+        var tag = mention.tag;
+        if (typeof tag !== "string") {
+          return callback({ error: "Mention tags must be strings." });
+        }
+
+        var offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+        if (offset < 0) {
+          log.warn("sendMessage", 'Mention for "' + tag + '" not found in message string.');
+        }
+
+        mentionIds.push(mention.id || 0);
+        mentionOffsets.push(offset);
+        mentionLengths.push(tag.length);
+        mentionTypes.push("p");
+      }
+
+      form.payload.tasks[0].payload.send_type = 1;
+      form.payload.tasks[0].payload.mention_data = {
+        mention_ids: mentionIds.join(","),
+        mention_offsets: mentionOffsets.join(","),
+        mention_lengths: mentionLengths.join(","),
+        mention_types: mentionTypes.join(",")
+      };
+    }
+
+    if (msg.sticker) {
+      form.payload.tasks[0].payload.send_type = 2;
+      form.payload.tasks[0].payload.sticker_id = msg.sticker;
+    }
+
+    function publish() {
+      if (replyToMessage) {
+        form.payload.tasks[0].payload.reply_metadata = {
+          reply_source_id: replyToMessage,
+          reply_source_type: 1,
+          reply_type: 0
+        };
+      }
+
+      form.payload.tasks.forEach(function (task) {
+        task.payload = JSON.stringify(task.payload);
+      });
+      form.payload = JSON.stringify(form.payload);
+
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(form), {}, function (err, data) {
+        if (err) {
+          log.error("sendMessageMqtt", err);
+          return callback(err);
+        }
+        callback(null, data);
+      });
+    }
+
+    if (!msg.attachment) {
+      return publish();
+    }
+
+    var baseSendTask = form.payload.tasks[0];
+    var readTask = form.payload.tasks[1];
+    var hasText = !!(baseSendTask.payload.text && String(baseSendTask.payload.text).trim());
+
+    if (hasText) {
+      var attachmentTask = {
+        label: "46",
+        payload: {
+          thread_id: threadIDString,
+          otid: (otid + 1).toString(),
+          source: 0,
+          send_type: 3,
+          sync_group: 1,
+          text: null,
+          initiating_source: 1,
+          skip_url_preview_gen: 0,
+          attachment_fbids: []
+        },
+        queue_name: threadIDString,
+        task_id: 1,
+        failure_count: null
+      };
+
+      baseSendTask.payload.send_type = 1;
+      baseSendTask.task_id = 0;
+      readTask.task_id = 2;
+      form.payload.tasks = [baseSendTask, attachmentTask, readTask];
+    } else {
+      baseSendTask.payload.send_type = 3;
+      baseSendTask.payload.attachment_fbids = [];
+      if (!baseSendTask.payload.text) {
+        baseSendTask.payload.text = null;
+      }
+    }
+
+    if (utils.getType(msg.attachment) !== "Array") {
+      msg.attachment = [msg.attachment];
+    }
+
+    uploadAttachment(msg.attachment, function (err, files) {
+      if (err) {
+        return callback(err);
+      }
+
+      var attachmentPayload = hasText
+        ? form.payload.tasks[1].payload
+        : form.payload.tasks[0].payload;
+
+      files.forEach(function (file) {
+        if (!file || typeof file !== "object") {
+          return;
+        }
+
+        var type = ["image_id", "gif_id", "file_id", "video_id", "audio_id"].find(
+          function (candidate) {
+            return file[candidate] != null;
+          }
+        );
+
+        if (!type) {
+          var key = Object.keys(file);
+          if (!key.length) {
+            return;
+          }
+          type = key[0];
+        }
+
+        if (file[type] == null) {
+          return;
+        }
+
+        attachmentPayload.attachment_fbids.push(file[type]);
+      });
+
+      if (!attachmentPayload.attachment_fbids.length) {
+        return callback({ error: "Attachment upload failed: no attachment id returned." });
+      }
+
+      publish();
+    });
+  };
+};

package/src/actions/sendTypingIndicator.js

@@ -0,0 +1,59 @@
+"use strict";
+
+module.exports = function (_defaultFuncs, _api, ctx) {
+  function publishTypingPacket(wsContent) {
+    return new Promise(function (resolve, reject) {
+      ctx.mqttClient.publish(
+        "/ls_req",
+        JSON.stringify(wsContent),
+        {},
+        function (err, packet) {
+          if (err) return reject(err);
+          resolve(packet);
+        }
+      );
+    });
+  }
+
+  return async function sendTypingIndicatorMqtt(sendTyping, threadID, callback, isGroup) {
+    var done = typeof callback === "function" ? callback : function () {};
+
+    try {
+      if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+        throw new Error("MQTT client is not connected. Call listenMqtt first.");
+      }
+
+      if (!threadID) {
+        throw new Error("sendTypingIndicatorMqtt requires threadID");
+      }
+
+      var isGroupThread =
+        typeof isGroup === "boolean"
+          ? isGroup
+          : String(threadID).length >= 16;
+
+      var wsContent = {
+        app_id: 2220391788200892,
+        payload: JSON.stringify({
+          label: 3,
+          payload: JSON.stringify({
+            thread_key: String(threadID),
+            is_group_thread: +isGroupThread,
+            is_typing: +!!sendTyping,
+            attribution: 0
+          }),
+          version: 5849951561777440
+        }),
+        request_id: 1,
+        type: 4
+      };
+
+      var packet = await publishTypingPacket(wsContent);
+      done(null, packet);
+      return packet;
+    } catch (err) {
+      done(err);
+      throw err;
+    }
+  };
+};

package/src/actions/setMessageReaction.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function setMessageReaction(reaction, messageID, callback, forceCustomReaction) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    var threadID = null;
+
+    if (utils.getType(callback) === "String" || utils.getType(callback) === "Number") {
+      threadID = callback.toString();
+      callback = null;
+    }
+
+    if (utils.getType(forceCustomReaction) === "String" || utils.getType(forceCustomReaction) === "Number") {
+      threadID = forceCustomReaction.toString();
+      forceCustomReaction = false;
+    }
+
+    if (utils.getType(forceCustomReaction) === "Object") {
+      threadID = forceCustomReaction.threadID || forceCustomReaction.threadId || threadID;
+      forceCustomReaction = !!forceCustomReaction.forceCustomReaction;
+    }
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    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." });
+    }
+
+    if (ctx.mqttClient && threadID && !ctx.globalOptions.pageID) {
+      api.setMessageReactionMqtt(reaction, messageID, threadID, callback);
+      return returnPromise;
+    }
+
+    var variables = {
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction: reaction
+      }
+    };
+
+    var 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.jar, defaultFuncs))
+      .then(function(resData) {
+        if (!resData) {
+          throw { error: "setReaction returned empty object." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        callback(null);
+      })
+      .catch(function(err) {
+        log.error("setReaction", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/actions/setMessageReactionMqtt.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (_defaultFuncs, _api, ctx) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      return callback(new Error("Not connected to MQTT"));
+    }
+
+    var reqID = ctx.wsReqNumber + 1;
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    var taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: Date.now(),
+      message_id: messageID,
+      reaction: reaction,
+      actor_id: ctx.userID,
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289
+    };
+
+    var task = {
+      failure_count: null,
+      label: "29",
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(["reaction", messageID]),
+      task_id: ctx.wsTaskNumber
+    };
+
+    var content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID(), 10),
+        tasks: [task],
+        version_id: "7158486590867448"
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3
+    };
+
+    var mqttClient = ctx.mqttClient;
+    var timeout = setTimeout(function () {
+      mqttClient.removeListener("message", handleRes);
+      callback(new Error("setMessageReactionMqtt response timeout"));
+    }, 10000);
+
+    function handleRes(topic, message) {
+      if (topic !== "/ls_resp") return;
+
+      var jsonMsg;
+      try {
+        jsonMsg = JSON.parse(message.toString());
+      } catch (_) {
+        return;
+      }
+
+      if (jsonMsg.request_id !== reqID) return;
+
+      clearTimeout(timeout);
+      mqttClient.removeListener("message", handleRes);
+      callback(null, jsonMsg);
+    }
+
+    mqttClient.on("message", handleRes);
+    mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/actions/setPostReaction.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function unsendMessage(postID, type, callback) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    var map = {
+      like: 1,
+      heart: 2,
+      wow: 3,
+      haha: 4,
+      sad: 7,
+      angry: 8
+    };
+    if (typeof type != "number") {
+      type = map[type.toLocaleLowerCase()];
+      if (!type) {
+        type = 1;
+      }
+    }
+    var form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "UFI2FeedbackReactMutation",
+      //This doc_id is valid as of January 17th, 2020
+      doc_id: "2580813318646067",
+      variables: JSON.stringify({
+        input: {
+          client_mutation_id: "7",
+          actor_id: ctx.userID,
+          feedback_reaction: type,
+          
+        },
+        useDefaultActor: true
+      })
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/api/graphql/",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("setPostReaction", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/actions/setTitle.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function setTitle(newTitle, threadID, callback) {
+    if (
+      !callback &&
+      (utils.getType(threadID) === "Function" ||
+        utils.getType(threadID) === "AsyncFunction")
+    ) {
+      throw { error: "please pass a threadID as a second argument." };
+    }
+
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    var messageAndOTID = utils.generateOfflineThreadingID();
+    var form = {
+      client: "mercury",
+      action_type: "ma-type:log-message",
+      author: "fbid:" + ctx.userID,
+      author_email: "",
+      coordinates: "",
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      manual_retry_cnt: "0",
+      thread_fbid: threadID,
+      thread_name: newTitle,
+      thread_id: threadID,
+      log_message_type: "log:thread-name"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/set_thread_name/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error && resData.error === 1545012) {
+          throw { error: "Cannot change chat title: Not member of chat." };
+        }
+
+        if (resData.error && resData.error === 1545003) {
+          throw { error: "Cannot set title of single-user chat." };
+        }
+
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("setTitle", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};