@cexy/hoonfca 1.0.1 → 1.0.3

package/src/getThreadInfo.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatEventReminders(reminder) {
+  return {
+    reminderID: reminder.id,
+    eventCreatorID: reminder.lightweight_event_creator.id,
+    time: reminder.time,
+    eventType: reminder.lightweight_event_type.toLowerCase(),
+    locationName: reminder.location_name,
+    // @TODO verify this
+    locationCoordinates: reminder.location_coordinates,
+    locationPage: reminder.location_page,
+    eventStatus: reminder.lightweight_event_status.toLowerCase(),
+    note: reminder.note,
+    repeatMode: reminder.repeat_mode.toLowerCase(),
+    eventTitle: reminder.event_title,
+    triggerMessage: reminder.trigger_message,
+    secondsToNotifyBefore: reminder.seconds_to_notify_before,
+    allowsRsvp: reminder.allows_rsvp,
+    relatedEvent: reminder.related_event,
+    members: reminder.event_reminder_members.edges.map(function (member) {
+      return {
+        memberID: member.node.id,
+        state: member.guest_list_state.toLowerCase(),
+      };
+    }),
+  };
+}
+
+function formatThreadGraphQLResponse(data) {
+  var messageThread = data.o0.data.message_thread;
+  var threadID = messageThread.thread_key.thread_fbid
+    ? messageThread.thread_key.thread_fbid
+    : messageThread.thread_key.other_user_id;
+
+  // Remove me
+  var lastM = messageThread.last_message;
+  var snippetID =
+    lastM &&
+    lastM.nodes &&
+    lastM.nodes[0] &&
+    lastM.nodes[0].message_sender &&
+    lastM.nodes[0].message_sender.messaging_actor
+      ? lastM.nodes[0].message_sender.messaging_actor.id
+      : null;
+  var snippetText =
+    lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+  var lastR = messageThread.last_read_receipt;
+  var lastReadTimestamp =
+    lastR && lastR.nodes && lastR.nodes[0] && lastR.nodes[0].timestamp_precise
+      ? lastR.nodes[0].timestamp_precise
+      : null;
+
+  return {
+    threadID: threadID,
+    threadName: messageThread.name,
+    participantIDs: messageThread.all_participants.edges.map(
+      (d) => d.node.messaging_actor.id,
+    ),
+    userInfo: messageThread.all_participants.edges.map((d) => ({
+      id: d.node.messaging_actor.id,
+      name: d.node.messaging_actor.name,
+      firstName: d.node.messaging_actor.short_name,
+      vanity: d.node.messaging_actor.username,
+      thumbSrc: d.node.messaging_actor.big_image_src.uri,
+      profileUrl: d.node.messaging_actor.url,
+      gender: d.node.messaging_actor.gender,
+      type: d.node.messaging_actor.__typename,
+      isFriend: d.node.messaging_actor.is_viewer_friend,
+      isBirthday: !!d.node.messaging_actor.is_birthday, //not sure?
+    })),
+    unreadCount: messageThread.unread_count,
+    messageCount: messageThread.messages_count,
+    timestamp: messageThread.updated_time_precise,
+    muteUntil: messageThread.mute_until,
+    isGroup: messageThread.thread_type == "GROUP",
+    isSubscribed: messageThread.is_viewer_subscribed,
+    isArchived: messageThread.has_viewer_archived,
+    folder: messageThread.folder,
+    cannotReplyReason: messageThread.cannot_reply_reason,
+    eventReminders: messageThread.event_reminders
+      ? messageThread.event_reminders.nodes.map(formatEventReminders)
+      : null,
+    emoji: messageThread.customization_info
+      ? messageThread.customization_info.emoji
+      : null,
+    color:
+      messageThread.customization_info &&
+      messageThread.customization_info.outgoing_bubble_color
+        ? messageThread.customization_info.outgoing_bubble_color.slice(2)
+        : null,
+    nicknames:
+      messageThread.customization_info &&
+      messageThread.customization_info.participant_customizations
+        ? messageThread.customization_info.participant_customizations.reduce(
+            function (res, val) {
+              if (val.nickname) res[val.participant_id] = val.nickname;
+              return res;
+            },
+            {},
+          )
+        : {},
+    adminIDs: messageThread.thread_admins.map((el) => el.id),
+    approvalMode: Boolean(messageThread.approval_mode),
+    approvalQueue: messageThread.group_approval_queue.nodes.map((a) => ({
+      inviterID: a.inviter.id,
+      requesterID: a.requester.id,
+      timestamp: a.request_timestamp,
+      request_source: a.request_source, // @Undocumented
+    })),
+
+    // @Undocumented
+    reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
+    mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
+    isPinProtected: messageThread.is_pin_protected,
+    relatedPageThread: messageThread.related_page_thread,
+
+    // @Legacy
+    name: messageThread.name,
+    snippet: snippetText,
+    snippetSender: snippetID,
+    snippetAttachments: [],
+    serverTimestamp: messageThread.updated_time_precise,
+    imageSrc: messageThread.image ? messageThread.image.uri : null,
+    isCanonicalUser: messageThread.is_canonical_neo_user,
+    isCanonical: messageThread.thread_type != "GROUP",
+    recipientsLoadable: true,
+    hasEmailParticipant: false,
+    readOnly: false,
+    canReply: messageThread.cannot_reply_reason == null,
+    lastMessageTimestamp: messageThread.last_message
+      ? messageThread.last_message.timestamp_precise
+      : null,
+    lastMessageType: "message",
+    lastReadTimestamp: lastReadTimestamp,
+    threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
+  };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadInfoGraphQL(threadID, callback, no_cache) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!no_cache && typeof callback == "boolean") no_cache = callback;
+    if (
+      utils.getType(callback) != "Function" &&
+      utils.getType(callback) != "AsyncFunction"
+    ) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    const cache = utils.groupsCache.findOneById(`${threadID}`);
+
+    if (!no_cache && cache) {
+      callback(null, cache);
+      return returnPromise;
+    } else {
+      // `queries` has to be a string. I couldn't tell from the dev console. This
+      // took me a really long time to figure out. I deserve a cookie for this.
+      var form = {
+        queries: JSON.stringify({
+          o0: {
+            // This doc_id is valid as of July 20th, 2020
+            doc_id: "3449967031715030",
+            query_params: {
+              id: threadID,
+              message_limit: 0,
+              load_messages: false,
+              load_read_receipts: false,
+              before: null,
+            },
+          },
+        }),
+        batch_name: "MessengerGraphQLThreadFetcher",
+      };
+
+      defaultFuncs
+        .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) {
+            throw resData;
+          }
+          // This returns us an array of things. The last one is the success /
+          // failure one.
+          // @TODO What do we do in this case?
+          if (resData[resData.length - 1].error_results !== 0) {
+            throw new Error("well darn there was an error_result");
+          }
+
+          let data = formatThreadGraphQLResponse(resData[0]);
+          data._id = threadID;
+
+          utils.groupsCache.addOne(data);
+          setInterval(
+            () => utils.groupsCache.deleteOneUsingId(`${threadID}`),
+            ctx.globalOptions.cacheTime,
+          );
+          callback(null, data);
+        })
+        .catch(function (err) {
+          log.error("getThreadInfoGraphQL", err);
+          return callback(err);
+        });
+
+      return returnPromise;
+    }
+  };
+};

package/src/getThreadList.js

@@ -0,0 +1,292 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+function createProfileUrl(url, username, id) {
+  if (url) return url;
+  return (
+    "https://www.facebook.com/" + (username || utils.formatID(id.toString()))
+  );
+}
+
+function formatParticipants(participants) {
+  return participants.edges.map((p) => {
+    p = p.node.messaging_actor;
+    switch (p["__typename"]) {
+      case "User":
+        return {
+          accountType: p["__typename"],
+          userID: utils.formatID(p.id.toString()), // do we need .toString()? when it is not a string?
+          name: p.name,
+          shortName: p.short_name,
+          gender: p.gender,
+          url: p.url, // how about making it profileURL
+          profilePicture: p.big_image_src.uri,
+          username: p.username || null,
+          // TODO: maybe better names for these?
+          isViewerFriend: p.is_viewer_friend, // true/false
+          isMessengerUser: p.is_messenger_user, // true/false
+          isVerified: p.is_verified, // true/false
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+          isViewerCoworker: p.is_viewer_coworker, // true/false
+          isEmployee: p.is_employee, // null? when it is something other? can someone check?
+        };
+      case "Page":
+        return {
+          accountType: p["__typename"],
+          userID: utils.formatID(p.id.toString()), // or maybe... pageID?
+          name: p.name,
+          url: p.url,
+          profilePicture: p.big_image_src.uri,
+          username: p.username || null,
+          // uhm... better names maybe?
+          acceptsMessengerUserFeedback: p.accepts_messenger_user_feedback, // true/false
+          isMessengerUser: p.is_messenger_user, // true/false
+          isVerified: p.is_verified, // true/false
+          isMessengerPlatformBot: p.is_messenger_platform_bot, // true/false
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+        };
+      case "ReducedMessagingActor":
+        return {
+          accountType: p["__typename"],
+          userID: utils.formatID(p.id.toString()),
+          name: p.name,
+          url: createProfileUrl(p.url, p.username, p.id), // in this case p.url is null all the time
+          profilePicture: p.big_image_src.uri, // in this case it is default facebook photo, we could determine gender using it
+          username: p.username || null, // maybe we could use it to generate profile URL?
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+        };
+      case "UnavailableMessagingActor":
+        return {
+          accountType: p["__typename"],
+          userID: utils.formatID(p.id.toString()),
+          name: p.name, // "Facebook User" in user's language
+          url: createProfileUrl(p.url, p.username, p.id), // in this case p.url is null all the time
+          profilePicture: p.big_image_src.uri, // default male facebook photo
+          username: p.username || null, // maybe we could use it to generate profile URL?
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+        };
+      default:
+        log.warn(
+          "getThreadList",
+          "Found participant with unsupported typename. Please open an issue at https://github.com/Schmavery/fca-unofficial/issues\n" +
+            JSON.stringify(p, null, 2),
+        );
+        return {
+          accountType: p["__typename"],
+          userID: utils.formatID(p.id.toString()),
+          name: p.name || `[unknown ${p["__typename"]}]`, // probably it will always be something... but fallback to [unknown], just in case
+        };
+    }
+  });
+}
+
+// "FF8C0077" -> "8C0077"
+function formatColor(color) {
+  if (color && color.match(/^(?:[0-9a-fA-F]{8})$/g)) {
+    return color.slice(2);
+  }
+  return color;
+}
+
+function getThreadName(t) {
+  if (t.name || t.thread_key.thread_fbid) return t.name;
+
+  for (let po of t.all_participants.edges) {
+    let p = po.node;
+    if (p.messaging_actor.id === t.thread_key.other_user_id)
+      return p.messaging_actor.name;
+  }
+}
+
+function mapNicknames(customizationInfo) {
+  return customizationInfo && customizationInfo.participant_customizations
+    ? customizationInfo.participant_customizations.map((u) => {
+        return {
+          userID: u.participant_id,
+          nickname: u.nickname,
+        };
+      })
+    : [];
+}
+
+function formatThreadList(data) {
+  return data.map((t) => {
+    let lastMessageNode =
+      t.last_message && t.last_message.nodes && t.last_message.nodes.length > 0
+        ? t.last_message.nodes[0]
+        : null;
+    return {
+      threadID: t.thread_key
+        ? utils.formatID(t.thread_key.thread_fbid || t.thread_key.other_user_id)
+        : null, // shall never be null
+      name: getThreadName(t),
+      unreadCount: t.unread_count,
+      messageCount: t.messages_count,
+      imageSrc: t.image ? t.image.uri : null,
+      emoji: t.customization_info ? t.customization_info.emoji : null,
+      color: formatColor(
+        t.customization_info
+          ? t.customization_info.outgoing_bubble_color
+          : null,
+      ),
+      nicknames: mapNicknames(t.customization_info),
+      muteUntil: t.mute_until,
+      participants: formatParticipants(t.all_participants),
+      adminIDs: t.thread_admins.map((a) => a.id),
+      folder: t.folder,
+      isGroup: t.thread_type === "GROUP",
+      // rtc_call_data: t.rtc_call_data, // TODO: format and document this
+      // isPinProtected: t.is_pin_protected, // feature from future? always false (2018-04-04)
+      customizationEnabled: t.customization_enabled, // false for ONE_TO_ONE with Page or ReducedMessagingActor
+      participantAddMode: t.participant_add_mode_as_string, // "ADD" if "GROUP" and null if "ONE_TO_ONE"
+      montageThread: t.montage_thread
+        ? Buffer.from(t.montage_thread.id, "base64").toString()
+        : null, // base64 encoded string "message_thread:0000000000000000"
+      // it is not userID nor any other ID known to me...
+      // can somebody inspect it? where is it used?
+      // probably Messenger Day uses it
+      reactionsMuteMode: t.reactions_mute_mode,
+      mentionsMuteMode: t.mentions_mute_mode,
+      isArchived: t.has_viewer_archived,
+      isSubscribed: t.is_viewer_subscribed,
+      timestamp: t.updated_time_precise, // in miliseconds
+      // isCanonicalUser: t.is_canonical_neo_user, // is it always false?
+      // TODO: how about putting snippet in another object? current implementation does not handle every possibile message type etc.
+      snippet: lastMessageNode ? lastMessageNode.snippet : null,
+      snippetAttachments: lastMessageNode
+        ? lastMessageNode.extensible_attachment
+        : null, // TODO: not sure if it works
+      snippetSender: lastMessageNode
+        ? utils.formatID(
+            (
+              lastMessageNode.message_sender.messaging_actor.id || ""
+            ).toString(),
+          )
+        : null,
+      lastMessageTimestamp: lastMessageNode
+        ? lastMessageNode.timestamp_precise
+        : null, // timestamp in miliseconds
+      lastReadTimestamp:
+        t.last_read_receipt && t.last_read_receipt.nodes.length > 0
+          ? t.last_read_receipt.nodes[0]
+            ? t.last_read_receipt.nodes[0].timestamp_precise
+            : null
+          : null, // timestamp in miliseconds
+      cannotReplyReason: t.cannot_reply_reason, // TODO: inspect possible values
+      approvalMode: Boolean(t.approval_mode),
+
+      // @Legacy
+      participantIDs: formatParticipants(t.all_participants).map(
+        (participant) => participant.userID,
+      ),
+      threadType: t.thread_type === "GROUP" ? 2 : 1, // "GROUP" or "ONE_TO_ONE"
+    };
+  });
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadList(limit, timestamp, tags, callback) {
+    if (
+      !callback &&
+      (utils.getType(tags) === "Function" ||
+        utils.getType(tags) === "AsyncFunction")
+    ) {
+      callback = tags;
+      tags = [""];
+    }
+    if (
+      utils.getType(limit) !== "Number" ||
+      !Number.isInteger(limit) ||
+      limit <= 0
+    ) {
+      throw { error: "getThreadList: limit must be a positive integer" };
+    }
+    if (
+      utils.getType(timestamp) !== "Null" &&
+      (utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))
+    ) {
+      throw { error: "getThreadList: timestamp must be an integer or null" };
+    }
+    if (utils.getType(tags) === "String") {
+      tags = [tags];
+    }
+    if (utils.getType(tags) !== "Array") {
+      throw { error: "getThreadList: tags must be an array" };
+    }
+
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    const form = {
+      av: ctx.globalOptions.pageID,
+      queries: JSON.stringify({
+        o0: {
+          // This doc_id was valid on 2020-07-20
+          doc_id: "3336396659757871",
+          query_params: {
+            limit: limit + (timestamp ? 1 : 0),
+            before: timestamp,
+            tags: tags,
+            includeDeliveryReceipts: true,
+            includeSeqID: false,
+          },
+        },
+      }),
+      batch_name: "MessengerGraphQLThreadlistFetcher",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData[resData.length - 1].error_results > 0) {
+          throw resData[0].o0.errors;
+        }
+
+        if (resData[resData.length - 1].successful_results === 0) {
+          throw {
+            error: "getThreadList: there was no successful_results",
+            res: resData,
+          };
+        }
+
+        // When we ask for threads using timestamp from the previous request,
+        // we are getting the last thread repeated as the first thread in this response.
+        // .shift() gets rid of it
+        // It is also the reason for increasing limit by 1 when timestamp is set
+        // this way user asks for 10 threads, we are asking for 11,
+        // but after removing the duplicated one, it is again 10
+        if (timestamp) {
+          resData[0].o0.data.viewer.message_threads.nodes.shift();
+        }
+        callback(
+          null,
+          formatThreadList(resData[0].o0.data.viewer.message_threads.nodes),
+        );
+      })
+      .catch((err) => {
+        log.error("getThreadList", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/getThreadPictures.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadPictures(threadID, offset, limit, 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 form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit,
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+        ctx.jar,
+        form,
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) {
+          throw resData;
+        }
+        return Promise.all(
+          resData.payload.imagesData.map(function (image) {
+            form = {
+              thread_id: threadID,
+              image_id: image.fbid,
+            };
+            return defaultFuncs
+              .post(
+                "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+                ctx.jar,
+                form,
+              )
+              .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+              .then(function (resData) {
+                if (resData.error) {
+                  throw resData;
+                }
+                // the response is pretty messy
+                var queryThreadID =
+                  resData.jsmods.require[0][3][1].query_metadata.query_path[0]
+                    .message_thread;
+                var imageData =
+                  resData.jsmods.require[0][3][1].query_results[queryThreadID]
+                    .message_images.edges[0].node.image2;
+                return imageData;
+              });
+          }),
+        );
+      })
+      .then(function (resData) {
+        callback(null, resData);
+      })
+      .catch(function (err) {
+        log.error("Error in getThreadPictures", err);
+        callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/getUserID.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatData(data) {
+  return {
+    userID: utils.formatID(data.uid.toString()),
+    photoUrl: data.photo,
+    indexRank: data.index_rank,
+    name: data.text,
+    isVerified: data.is_verified,
+    profileUrl: data.path,
+    category: data.category,
+    score: data.score,
+    type: data.type,
+  };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getUserID(name, 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 form = {
+      value: name.toLowerCase(),
+      viewer: ctx.userID,
+      rsp: "search",
+      context: "search",
+      path: "/home.php",
+      request_id: utils.getGUID(),
+    };
+
+    defaultFuncs
+      .get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        var data = resData.payload.entries;
+
+        callback(null, data.map(formatData));
+      })
+      .catch(function (err) {
+        log.error("getUserID", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};