@cexy/hoonfca 1.0.1 → 1.0.2

package/src/sendTypingIndicator.js

@@ -0,0 +1,179 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function makeTypingIndicator(typ, threadID, callback, isGroup) {
+    var form = {
+      typ: +typ,
+      to: "",
+      source: "mercury-chat",
+      thread: threadID,
+    };
+
+    // Check if thread is a single person chat or a group chat
+    // More info on this is in api.sendMessage
+    if (utils.getType(isGroup) == "Boolean") {
+      if (!isGroup) {
+        form.to = threadID;
+      }
+      defaultFuncs
+        .post("https://www.facebook.com/ajax/messaging/typ.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) {
+            throw resData;
+          }
+
+          return callback();
+        })
+        .catch(function (err) {
+          log.error("sendTypingIndicator", err);
+          if (utils.getType(err) == "Object" && err.error === "Not logged in") {
+            ctx.loggedIn = false;
+          }
+          return callback(err);
+        });
+    } else {
+      api.getUserInfo(threadID, function (err, res) {
+        if (err) {
+          return callback(err);
+        }
+
+        // If id is single person chat
+        if (Object.keys(res).length > 0) {
+          form.to = threadID;
+        }
+
+        defaultFuncs
+          .post(
+            "https://www.facebook.com/ajax/messaging/typ.php",
+            ctx.jar,
+            form,
+          )
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(function (resData) {
+            if (resData.error) {
+              throw resData;
+            }
+
+            return callback();
+          })
+          .catch(function (err) {
+            log.error("sendTypingIndicator", err);
+            if (
+              utils.getType(err) == "Object" &&
+              err.error === "Not logged in."
+            ) {
+              ctx.loggedIn = false;
+            }
+            return callback(err);
+          });
+      });
+    }
+  }
+
+  function sendTypingIndicatorNoMqtt(threadID, callback, isGroup) {
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      if (callback) {
+        log.warn(
+          "sendTypingIndicator",
+          "callback is not a function - ignoring.",
+        );
+      }
+      callback = () => {};
+    }
+
+    makeTypingIndicator(true, threadID, callback, isGroup);
+
+    return function end(cb) {
+      if (
+        utils.getType(cb) !== "Function" &&
+        utils.getType(cb) !== "AsyncFunction"
+      ) {
+        if (cb) {
+          log.warn(
+            "sendTypingIndicator",
+            "callback is not a function - ignoring.",
+          );
+        }
+        cb = () => {};
+      }
+
+      makeTypingIndicator(false, threadID, cb, isGroup);
+    };
+  }
+
+  function sendTypingIndicatorMqtt(isTyping, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+
+    ctx.wsReqNumber += 1;
+
+    api
+      .getThreadInfo(threadID)
+      .then((threadData) => {
+        const label = "3";
+        const isGroupThread = threadData.isGroup ? 1 : 0;
+        const attribution = 0;
+
+        const taskPayload = {
+          thread_key: threadID,
+          is_group_thread: isGroupThread,
+          is_typing: isTyping ? 1 : 0,
+          attribution: attribution,
+        };
+
+        const payload = JSON.stringify(taskPayload);
+        const version = "25393437286970779";
+
+        const content = {
+          app_id: "2220391788200892",
+          payload: JSON.stringify({
+            label: label,
+            payload: payload,
+            version: version,
+          }),
+          request_id: ctx.wsReqNumber,
+          type: 4,
+        };
+
+        if (typeof callback == "function") {
+          // to be implemented
+        }
+
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+          qos: 1,
+          retain: false,
+        });
+      })
+      .catch((error) => {
+        // console.error(error);
+        // throw new Error("Failed to get thread info");
+      });
+  }
+
+  return function sendTypingIndicator(threadID, callback, delay, isGroup) {
+    if (ctx.mqttClient) {
+      if (typeof callback !== "function") delay = callback;
+      try {
+        sendTypingIndicatorMqtt(true, threadID, callback);
+        setTimeout(
+          function () {
+            sendTypingIndicatorMqtt(false, threadID, () => {});
+          },
+          delay ? delay : 30 * 1000,
+        );
+        callback();
+      } catch (e) {
+        // console.error(e);
+        sendTypingIndicatorNoMqtt(threadID, callback, isGroup);
+      }
+    } else sendTypingIndicatorNoMqtt(threadID, callback, isGroup);
+  };
+};

package/src/setBio.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Set user bio with enhanced options
+   * @param {string} bio - Bio text
+   * @param {object} options - Optional settings
+   * @param {function} callback - Callback function
+   */
+  return function setBio(bio, options, callback) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (
+        utils.getType(options) == "Function" ||
+        utils.getType(options) == "AsyncFunction"
+      ) {
+        callback = options;
+        options = {};
+      } else {
+        callback = function (err) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc();
+        };
+      }
+    }
+
+    options = options || {};
+
+    if (utils.getType(bio) != "String") {
+      return callback({ error: "Bio must be a string" });
+    }
+
+    var form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "ProfileCometSetBioMutation",
+      doc_id: "2725043627607610",
+      variables: JSON.stringify({
+        input: {
+          bio: bio,
+          change_type: options.changeType || "ADD",
+          should_update_bio_in_basic_info: true,
+          source: "profile_comet",
+        },
+      }),
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+
+        var bioData = null;
+        if (
+          resData.data &&
+          resData.data.profile_intro_card_set &&
+          resData.data.profile_intro_card_set.profile_intro_card
+        ) {
+          bioData = resData.data.profile_intro_card_set.profile_intro_card;
+        }
+
+        log.info("setBio", "Bio updated successfully");
+        return callback(null, bioData);
+      })
+      .catch(function (err) {
+        log.error("setBio", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/setMessageReaction.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+const { generateOfflineThreadingID } = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function setMessageReactionNoMqtt(
+    reaction,
+    messageID,
+    callback,
+    forceCustomReaction,
+  ) {
+    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);
+      };
+    }
+
+    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." });
+    }
+
+    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;
+  }
+  function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+
+    ctx.wsReqNumber += 1;
+    let taskNumber = ++ctx.wsTaskNumber;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: getCurrentTimestamp(),
+      message_id: messageID,
+      reaction: reaction,
+      actor_id: ctx.userID,
+      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]),
+      task_id: taskNumber,
+    };
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: "7158486590867448",
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    if (typeof callback === "function") {
+      ctx["tasks"].set(taskNumber, {
+        type: "set_message_reaction",
+        callback: callback,
+      });
+    }
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+      qos: 1,
+      retain: false,
+    });
+  }
+
+  return function setMessageReaction(reaction, messageID, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        setMessageReactionMqtt(reaction, messageID, threadID, callback);
+        callback();
+      } catch (e) {
+        setMessageReactionNoMqtt(reaction, messageID, callback, true);
+      }
+    } else {
+      setMessageReactionNoMqtt(reaction, messageID, callback, true);
+    }
+  };
+};

package/src/setPostReaction.js

@@ -0,0 +1,71 @@
+"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;
+  };
+};