@cexy/hoonfca 1.0.0 → 1.0.2

package/src/sendTypingIndicator.js

@@ -1,54 +1,179 @@
 "use strict";
 
 var utils = require("../utils");
-// @NethWs3Dev
+var log = require("npmlog");
 
 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);
-		}
-	};
+  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

@@ -1,35 +1,32 @@
 "use strict";
 
-const utils = require("../utils");
-// @NethWs3Dev
+var utils = require("../utils");
+var log = require("npmlog");
+const { generateOfflineThreadingID } = require("../utils");
 
 module.exports = function (defaultFuncs, api, ctx) {
-  return function setMessageReaction(
+  function setMessageReactionNoMqtt(
     reaction,
     messageID,
     callback,
     forceCustomReaction,
   ) {
-    let resolveFunc = function () {};
-    let rejectFunc = function () {};
-    const returnPromise = new Promise(function (resolve, reject) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
     if (!callback) {
-      callback = function (err, data) {
+      callback = function (err, friendList) {
         if (err) {
           return rejectFunc(err);
         }
-        resolveFunc(data);
+        resolveFunc(friendList);
       };
     }
 
-    if (!messageID) {
-      return callback({ error: "MessageID is required." });
-    }
-
     switch (reaction) {
       case "\uD83D\uDE0D": //:heart_eyes:
       case "\uD83D\uDE06": //:laughing:
@@ -83,7 +80,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         return callback({ error: "Reaction is not a valid emoji." });
     }
 
-    const variables = {
+    var variables = {
       data: {
         client_mutation_id: ctx.clientMutationId++,
         actor_id: ctx.userID,
@@ -93,7 +90,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       },
     };
 
-    const qs = {
+    var qs = {
       doc_id: "1491398900900362",
       variables: JSON.stringify(variables),
       dpr: 1,
@@ -106,7 +103,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         {},
         qs,
       )
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(utils.parseAndCheckLogin(ctx.jar, defaultFuncs))
       .then(function (resData) {
         if (!resData) {
           throw { error: "setReaction returned empty object." };
@@ -117,10 +114,73 @@ module.exports = function (defaultFuncs, api, ctx) {
         callback(null);
       })
       .catch(function (err) {
-        utils.error("setReaction", 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

@@ -1,83 +1,53 @@
 "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,
-  };
-}
+var utils = require("../utils");
+var log = require("npmlog");
 
 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) {
+  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) {
-      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" });
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
     }
 
-    const map = {
-      unlike: 0,
+    var map = {
       like: 1,
       heart: 2,
-      love: 16,
-      haha: 4,
       wow: 3,
+      haha: 4,
       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 + ")",
-      });
+    if (typeof type != "number") {
+      type = map[type.toLocaleLowerCase()];
+      if (!type) {
+        type = 1;
+      }
     }
-
-    const form = {
+    var form = {
       av: ctx.userID,
       fb_api_caller_class: "RelayModern",
-      fb_api_req_friendly_name: "CometUFIFeedbackReactMutation",
-      doc_id: "4769042373179384",
+      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_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,
+        useDefaultActor: true,
       }),
     };
 
@@ -85,16 +55,14 @@ module.exports = function (defaultFuncs, api, ctx) {
       .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) {
+        if (resData.error) {
           throw resData;
         }
-        return callback(null, formatData(resData.data));
+
+        return callback();
       })
       .catch(function (err) {
-        utils.error("setPostReaction", err);
+        log.error("setPostReaction", err);
         return callback(err);
       });