@cexy/hoonfca 1.0.7 → 2.0.1

package/src/apis/changeArchivedStatus.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeArchivedStatus(threadIDs, archive, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(archive) === "Function") {
+        callback = archive;
+        archive = true;
+      }
+
+      if (utils.getType(archive) !== "Boolean") {
+        throw new Error("archive parameter must be a boolean");
+      }
+
+      if (!Array.isArray(threadIDs)) {
+        threadIDs = [threadIDs];
+      }
+
+      const form = {
+        should_archive: archive
+      };
+      
+      threadIDs.forEach(id => {
+        form[`thread_fbids[${id}]`] = true;
+      });
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/change_archived_status.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("changeArchivedStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeAvatar.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  async function handleUpload(image) {
+    const form = {
+      profile_id: ctx.userID,
+      photo_source: 57,
+      av: ctx.userID,
+      file: image
+    };
+
+    return defaultFuncs.postFormData(
+      "https://www.facebook.com/profile/picture/upload/",
+      ctx.jar,
+      form,
+      {}
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+    .then(resData => {
+      if (resData.error) throw resData;
+      return resData;
+    });
+  }
+
+  return async function changeAvatar(image, caption, timestamp, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!timestamp && utils.getType(caption) === "Number") {
+      timestamp = caption;
+      caption = "";
+    }
+
+    if (!timestamp && !callback && (utils.getType(caption) === "Function")) {
+      callback = caption;
+      caption = "";
+      timestamp = null;
+    }
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (!utils.isReadableStream(image)) {
+        throw new Error("Image is not a readable stream");
+      }
+
+      const payload = await handleUpload(image);
+      
+      const form = {
+        av: ctx.i_userID || ctx.userID,
+        fb_api_req_friendly_name: "ProfileCometProfilePictureSetMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "5066134240065849",
+        variables: JSON.stringify({
+          input: {
+            caption: caption || "",
+            existing_photo_id: payload.payload.fbid,
+            expiration_time: timestamp,
+            profile_id: ctx.i_userID || ctx.userID,
+            profile_pic_method: "EXISTING",
+            profile_pic_source: "TIMELINE",
+            scaled_crop_rect: {
+              height: 1,
+              width: 1,
+              x: 0,
+              y: 0
+            },
+            skip_cropping: true,
+            actor_id: ctx.i_userID || ctx.userID,
+            client_mutation_id: Math.round(Math.random() * 19).toString()
+          },
+          isPage: false,
+          isProfile: true,
+          scale: 3
+        })
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      callback(null, res[0].data.profile_picture_set);
+    } catch (err) {
+      utils.error("changeAvatar", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeBio.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeBio(bio, publish, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (utils.getType(publish) === "Function") {
+        callback = publish;
+        publish = false;
+      } else {
+        callback = (err) => {
+          if (err) return rejectFunc(err);
+          resolveFunc();
+        };
+      }
+    }
+
+    if (utils.getType(publish) !== "Boolean") {
+      publish = false;
+    }
+
+    if (utils.getType(bio) !== "String") {
+      bio = "";
+      publish = false;
+    }
+
+    try {
+      const form = {
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "ProfileCometSetBioMutation",
+        doc_id: "2725043627607610",
+        variables: JSON.stringify({
+          input: {
+            bio: bio,
+            publish_bio_feed_story: publish,
+            actor_id: ctx.i_userID || ctx.userID,
+            client_mutation_id: Math.round(Math.random() * 1024).toString()
+          },
+          hasProfileTileViewID: false,
+          profileTileViewID: null,
+          scale: 1
+        }),
+        av: ctx.i_userID || ctx.userID
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("changeBio", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeBlockedStatus.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeBlockedStatus(userID, block, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(block) === "Function") {
+        callback = block;
+        block = true;
+      }
+
+      if (utils.getType(block) !== "Boolean") {
+        throw new Error("block parameter must be a boolean");
+      }
+
+      const form = {
+        fbid: userID,
+        block: block
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/profile/manage_blocking.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, { success: true, blocked: block });
+    } catch (err) {
+      utils.error("changeBlockedStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeGroupImage.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  async 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(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) throw resData;
+        return resData.payload.metadata[0];
+      });
+  }
+
+  return async function changeGroupImage(image, threadID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (!threadID || typeof threadID !== "string") {
+        throw new Error("Invalid threadID");
+      }
+
+      if (!utils.isReadableStream(image)) {
+        throw new Error("image must be a readable stream");
+      }
+
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+
+      let responseHandled = false;
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp" || responseHandled) return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        responseHandled = true;
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback(null, { success: true, response: jsonMsg.payload });
+        resolveFunc({ success: true, response: jsonMsg.payload });
+      };
+
+      const timeout = setTimeout(() => {
+        if (!responseHandled) {
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", onResponse);
+          const err = new Error("MQTT request timeout");
+          callback(err);
+          rejectFunc(err);
+        }
+      }, 30000);
+
+      ctx.mqttClient.on("message", onResponse);
+
+      const payload = await handleUpload(image);
+      const imageID = payload.image_id;
+
+      const taskPayload = {
+        thread_key: threadID,
+        image_id: imageID,
+        sync_group: 1
+      };
+
+      const mqttPayload = {
+        epoch_id: utils.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
+      }, (err) => {
+        if (err && !responseHandled) {
+          responseHandled = true;
+          clearTimeout(timeout);
+          ctx.mqttClient.removeListener("message", onResponse);
+          callback(err);
+          rejectFunc(err);
+        }
+      });
+    } catch (err) {
+      if (!responseHandled) {
+        responseHandled = true;
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", onResponse);
+        utils.error("changeGroupImage", err);
+        callback(err);
+        rejectFunc(err);
+      }
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeThreadColor.js

@@ -0,0 +1,116 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeThreadColor(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);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      const content = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify({
+          data_trace_id: null,
+          epoch_id: parseInt(utils.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
+      };
+
+      let responseHandled = false;
+      
+      const handleRes = (topic, message) => {
+        if (responseHandled) return;
+        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;
+        responseHandled = true;
+        clearTimeout(timeout);
+        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
+          };
+          callback(null, bodies);
+          resolveFunc(bodies);
+        } catch (err) {
+          callback(null, { success: true });
+          resolveFunc({ success: true });
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        if (!responseHandled) {
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          const err = new Error("MQTT request timeout");
+          callback(err);
+          rejectFunc(err);
+        }
+      }, 30000);
+
+      ctx.mqttClient.on("message", handleRes);
+      
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+        qos: 1,
+        retain: false
+      }, (err) => {
+        if (err && !responseHandled) {
+          responseHandled = true;
+          clearTimeout(timeout);
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(err);
+          rejectFunc(err);
+        }
+      });
+    } catch (err) {
+      utils.error("changeThreadColor", err);
+      callback(err);
+      rejectFunc(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeThreadEmoji.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeThreadEmoji(emoji, threadID, 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();
+      };
+    }
+    const 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(utils.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) {
+        utils.error("changeThreadEmoji", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};