@cexy/hoonfca 1.0.4 → 1.0.5

package/src/api/messaging/changeBlockedStatus.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const log = require("npmlog");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function changeBlockedStatus(userID, block, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc();
+      };
+    }
+
+    defaultFuncs
+      .post(
+        `https://www.facebook.com/messaging/${
+          block ? "" : "un"
+        }block_messages/`,
+        ctx.jar,
+        {
+          fbid: userID
+        }
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("changeBlockedStatus", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/api/messaging/changeGroupImage.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function handleUpload(image) {
+    const form = {
+      images_only: "true",
+      "attachment[]": image
+    };
+    return defaultFuncs
+      .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) throw resData;
+        return resData.payload.metadata[0];
+      });
+  }
+  return function changeGroupImage(image, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || typeof threadID !== "string") {
+        const err = new Error("Invalid threadID");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      handleUpload(image)
+        .then(payload => {
+          const imageID = payload.image_id;
+          const taskPayload = {
+            thread_key: threadID,
+            image_id: imageID,
+            sync_group: 1
+          };
+
+          const mqttPayload = {
+            epoch_id: generateOfflineThreadingID(),
+            tasks: [
+              {
+                failure_count: null,
+                label: "37",
+                payload: JSON.stringify(taskPayload),
+                queue_name: "thread_image",
+                task_id: taskID
+              }
+            ],
+            version_id: "8798795233522156"
+          };
+          const request = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify(mqttPayload),
+            request_id: reqID,
+            type: 3
+          };
+          ctx.mqttClient.publish("/ls_req", JSON.stringify(request), {
+            qos: 1,
+            retain: false
+          });
+        })
+        .catch(err => {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeGroupImageMqtt", err);
+          callback?.(err);
+          reject(err);
+        });
+    });
+  };
+};

package/src/api/messaging/changeNickname.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeNickname(nickname, threadID, participantID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || !participantID) {
+        const err = new Error("Missing required parameters");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "44",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_id: participantID,
+              nickname: nickname || "",
+              sync_group: 1
+            }),
+            queue_name: "thread_participant_nickname",
+            task_id: taskID
+          }
+        ],
+        version_id: "8798795233522156"
+      };
+      const request = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      };
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(request), { qos: 1, retain: false }, (err) => {
+        if (err) {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeNicknameMqtt", err);
+          callback?.(err);
+          return reject(err);
+        }
+      });
+    });
+  };
+};

package/src/api/messaging/changeThreadColor.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+module.exports = (defaultFuncs, api, ctx) => {
+  return async (color, threadID, callback) => {
+    let reqID = ++ctx.wsReqNumber;
+    let resolveFunc = () => { };
+    let rejectFunc = () => { };
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [
+          {
+            failure_count: null,
+            label: "43",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              theme_fbid: color,
+              source: null,
+              sync_group: 1,
+              payload: null
+            }),
+            queue_name: "thread_theme",
+            task_id: ++ctx.wsTaskNumber
+          }
+        ],
+        version_id: "8798795233522156"
+      }),
+      request_id: reqID,
+      type: 3
+    };
+
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+      qos: 1,
+      retain: false
+    });
+
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp") return;
+      let jsonMsg;
+      try {
+        jsonMsg = JSON.parse(message.toString());
+        jsonMsg.payload = JSON.parse(jsonMsg.payload);
+      } catch (err) {
+        return;
+      }
+      if (jsonMsg.request_id !== reqID) return;
+      ctx.mqttClient.removeListener("message", handleRes);
+      try {
+        const msgID = jsonMsg.payload.step[1][2][2][1][2];
+        const msgReplace = jsonMsg.payload.step[1][2][2][1][4];
+        const bodies = {
+          body: msgReplace,
+          messageID: msgID
+        };
+        return callback(null, bodies);
+      } catch (err) {
+        return callback(null, { success: true });
+      }
+    };
+
+    ctx.mqttClient.on("message", handleRes);
+    return returnPromise;
+  };
+};

package/src/api/messaging/changeThreadEmoji.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function (defaultFuncs, api, ctx) {
+  function changeThreadEmojiNoMqtt(emoji, threadID, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc();
+      };
+    }
+    var form = {
+      emoji_choice: emoji,
+      thread_or_other_fbid: threadID,
+    };
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg",
+        ctx.jar,
+        form,
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error === 1357031) {
+          throw {
+            error:
+              "Trying to change emoji of a chat that doesn't exist. Have at least one message in the thread before trying to change the emoji.",
+          };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("changeThreadEmoji", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+  function changeThreadEmojiMqtt(emoji, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+        data
+      };
+    }
+    let count_req = 0
+    var form = JSON.stringify({
+      "app_id": "2220391788200892",
+      "payload": JSON.stringify({
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: '100003',
+            payload: JSON.stringify({
+              "thread_key": threadID,
+              "custom_emoji": emoji,
+              "avatar_sticker_instruction_key_id": null,
+              "sync_group": 1
+            }),
+            queue_name: 'thread_quick_reaction',
+            task_id: Math.random() * 1001 << 0
+          }
+        ],
+        version_id: '8798795233522156'
+      }),
+      "request_id": ++count_req,
+      "type": 3
+    });
+    mqttClient.publish('/ls_req', form);
+    return returnPromise;
+  };
+  return function changeThreadEmoji(emoji, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        changeThreadEmojiMqtt(emoji, threadID, callback);
+      } catch (e) {
+        changeThreadEmojiNoMqtt(emoji, threadID, callback);
+      }
+    } else {
+      changeThreadEmojiNoMqtt(emoji, threadID, callback);
+    }
+  };
+};

package/src/{createNewGroup.js → api/messaging/createNewGroup.js}

@@ -1,88 +1,88 @@
-"use strict";
-
-var utils = require("../utils");
-var log = require("npmlog");
-
-module.exports = function (defaultFuncs, api, ctx) {
-  return function createNewGroup(participantIDs, groupTitle, callback) {
-    if (utils.getType(groupTitle) == "Function") {
-      callback = groupTitle;
-      groupTitle = null;
-    }
-
-    if (utils.getType(participantIDs) !== "Array") {
-      throw { error: "createNewGroup: participantIDs should be an array." };
-    }
-
-    if (participantIDs.length < 2) {
-      throw {
-        error: "createNewGroup: participantIDs should have at least 2 IDs.",
-      };
-    }
-
-    var resolveFunc = function () {};
-    var rejectFunc = function () {};
-    var returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-
-    if (!callback) {
-      callback = function (err, threadID) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(threadID);
-      };
-    }
-
-    var pids = [];
-    for (var n in participantIDs) {
-      pids.push({
-        fbid: participantIDs[n],
-      });
-    }
-    pids.push({ fbid: ctx.userID });
-
-    var form = {
-      fb_api_caller_class: "RelayModern",
-      fb_api_req_friendly_name: "MessengerGroupCreateMutation",
-      av: ctx.userID,
-      //This doc_id is valid as of January 11th, 2020
-      doc_id: "577041672419534",
-      variables: JSON.stringify({
-        input: {
-          entry_point: "jewel_new_group",
-          actor_id: ctx.userID,
-          participants: pids,
-          client_mutation_id: Math.round(Math.random() * 1024).toString(),
-          thread_settings: {
-            name: groupTitle,
-            joinable_mode: "PRIVATE",
-            thread_image_fbid: null,
-          },
-        },
-      }),
-    };
-
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(function (resData) {
-        if (resData.errors) {
-          throw resData;
-        }
-        return callback(
-          null,
-          resData.data.messenger_group_thread_create.thread.thread_key
-            .thread_fbid,
-        );
-      })
-      .catch(function (err) {
-        log.error("createNewGroup", err);
-        return callback(err);
-      });
-
-    return returnPromise;
-  };
-};
+"use strict";
+
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function createNewGroup(participantIDs, groupTitle, callback) {
+    if (getType(groupTitle) == "Function") {
+      callback = groupTitle;
+      groupTitle = null;
+    }
+
+    if (getType(participantIDs) !== "Array") {
+      throw { error: "createNewGroup: participantIDs should be an array." };
+    }
+
+    if (participantIDs.length < 2) {
+      throw {
+        error: "createNewGroup: participantIDs should have at least 2 IDs."
+      };
+    }
+
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, threadID) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(threadID);
+      };
+    }
+
+    const pids = [];
+    for (const n in participantIDs) {
+      pids.push({
+        fbid: participantIDs[n]
+      });
+    }
+    pids.push({ fbid: ctx.i_userID || ctx.userID });
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MessengerGroupCreateMutation",
+      av: ctx.i_userID || ctx.userID,
+      //This doc_id is valid as of January 11th, 2020
+      doc_id: "577041672419534",
+      variables: JSON.stringify({
+        input: {
+          entry_point: "jewel_new_group",
+          actor_id: ctx.i_userID || ctx.userID,
+          participants: pids,
+          client_mutation_id: Math.round(Math.random() * 1024).toString(),
+          thread_settings: {
+            name: groupTitle,
+            joinable_mode: "PRIVATE",
+            thread_image_fbid: null
+          }
+        }
+      })
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+        return callback(
+          null,
+          resData.data.messenger_group_thread_create.thread.thread_key
+            .thread_fbid
+        );
+      })
+      .catch(function(err) {
+        log.error("createNewGroup", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/createPoll.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function createPoll(threadID, questionText, options) {
+    let count_req = 0
+    return new Promise((resolve, reject) => {
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "163",
+            payload: JSON.stringify({
+              question_text: questionText,
+              thread_key: threadID,
+              options: options,
+              sync_group: 1
+            }),
+            queue_name: "poll_creation",
+            task_id: Math.floor(Math.random() * 1001)
+          }
+        ],
+        version_id: "8768858626531631"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: ++count_req,
+        type: 3
+      });
+
+      try {
+        mqttClient.publish("/ls_req", form);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  };
+};