@cexy/hoonfca 1.0.0 → 1.0.2

package/src/getThreadList.js

@@ -1,168 +1,233 @@
 "use strict";
 
 const utils = require("../utils");
+const 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,
-    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(member => ({
-      memberID: member.node?.id,
-      state: member.guest_list_state?.toLowerCase(),
-    })),
-  };
+function createProfileUrl(url, username, id) {
+  if (url) return url;
+  return (
+    "https://www.facebook.com/" + (username || utils.formatID(id.toString()))
+  );
 }
 
-// গ্রাফকিউএল থ্রেড রেসপন্স ক্লিন অবজেক্টে রূপান্তর করার ফাংশন
-function formatThreadGraphQLResponse(messageThread) {
-  const threadID = messageThread.thread_key?.thread_fbid || messageThread.thread_key?.other_user_id;
-
-  const lastM = messageThread.last_message;
-  const snippetID = lastM?.nodes?.[0]?.message_sender?.messaging_actor?.id || null;
-  const snippetText = lastM?.nodes?.[0]?.snippet || null;
-  const lastR = messageThread.last_read_receipt;
-  const lastReadTimestamp = 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,
-      url: d.node?.messaging_actor?.url,
-      thumbSrc: d.node?.messaging_actor?.big_image_src?.uri,
-      profileUrl: d.node?.messaging_actor?.big_image_src?.uri,
-      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,
-    })),
-    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?.emoji || null,
-    color: messageThread.customization_info?.outgoing_bubble_color
-      ? messageThread.customization_info.outgoing_bubble_color.slice(2)
-      : null,
-    threadTheme: messageThread.thread_theme,
-    nicknames: messageThread.customization_info?.participant_customizations
-      ? messageThread.customization_info.participant_customizations.reduce((res, val) => {
-          if (val.nickname) res[val.participant_id] = val.nickname;
-          return res;
-        }, {})
-      : {},
-    adminIDs: messageThread.thread_admins,
-    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,
-    })),
-    reactionsMuteMode: messageThread.reactions_mute_mode?.toLowerCase(),
-    mentionsMuteMode: messageThread.mentions_mute_mode?.toLowerCase(),
-    isPinProtected: messageThread.is_pin_protected,
-    relatedPageThread: messageThread.related_page_thread,
-    name: messageThread.name,
-    snippet: snippetText,
-    snippetSender: snippetID,
-    snippetAttachments: [],
-    serverTimestamp: messageThread.updated_time_precise,
-    imageSrc: 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?.timestamp_precise || null,
-    lastMessageType: "message",
-    lastReadTimestamp: lastReadTimestamp,
-    threadType: messageThread.thread_type === "GROUP" ? 2 : 1,
-    inviteLink: {
-      enable: messageThread.joinable_mode ? messageThread.joinable_mode.mode === 1 : false,
-      link: messageThread.joinable_mode ? messageThread.joinable_mode.link : null,
-    },
-  };
+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 => formatThreadGraphQLResponse(t));
+  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")
+      (utils.getType(tags) === "Function" ||
+        utils.getType(tags) === "AsyncFunction")
     ) {
       callback = tags;
       tags = [""];
     }
-    
-    if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) {
-      throw new utils.CustomError({
-        error: "getThreadList: limit must be a positive integer",
-      });
+    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 new utils.CustomError({
-        error: "getThreadList: timestamp must be an integer or null",
-      });
+      throw { error: "getThreadList: timestamp must be an integer or null" };
     }
-    
     if (utils.getType(tags) === "String") {
       tags = [tags];
     }
-    
     if (utils.getType(tags) !== "Array") {
-      throw new utils.CustomError({
-        error: "getThreadList: tags must be an array",
-        message: "getThreadList: tags must be an array",
-      });
+      throw { error: "getThreadList: tags must be an array" };
     }
 
-    let resolveFunc = () => {};
-    let rejectFunc = () => {};
-    const returnPromise = new Promise((resolve, reject) => {
+    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 = (err, data) => {
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      callback = function (err, data) {
         if (err) {
           return rejectFunc(err);
         }
@@ -171,10 +236,11 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     const form = {
-      av: ctx.i_userID || ctx.userID,
+      av: ctx.globalOptions.pageID,
       queries: JSON.stringify({
         o0: {
-          doc_id: "3426149104143726",
+          // This doc_id was valid on 2020-07-20
+          doc_id: "3336396659757871",
           query_params: {
             limit: limit + (timestamp ? 1 : 0),
             before: timestamp,
@@ -190,27 +256,34 @@ module.exports = function (defaultFuncs, api, ctx) {
     defaultFuncs
       .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
       .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
+      .then((resData) => {
         if (resData[resData.length - 1].error_results > 0) {
-          throw new utils.CustomError(resData[0].o0.errors);
+          throw resData[0].o0.errors;
         }
 
         if (resData[resData.length - 1].successful_results === 0) {
-          throw new utils.CustomError({
+          throw {
             error: "getThreadList: there was no successful_results",
             res: resData,
-          });
+          };
         }
 
-        const threads = resData[0].o0.data.viewer.message_threads.nodes;
-        if (timestamp && threads.length > 0) {
-          threads.shift();
+        // 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(threads));
+        callback(
+          null,
+          formatThreadList(resData[0].o0.data.viewer.message_threads.nodes),
+        );
       })
-      .catch(err => {
-        utils.error("getThreadList", err);
+      .catch((err) => {
+        log.error("getThreadList", err);
         return callback(err);
       });
 

package/src/getThreadPictures.js

@@ -1,18 +1,19 @@
 "use strict";
 
-const utils = require("../utils");
+var utils = require("../utils");
+var log = require("npmlog");
 
 module.exports = function (defaultFuncs, api, ctx) {
   return function getThreadPictures(threadID, offset, limit, callback) {
-    let resolveFunc = () => {};
-    let rejectFunc = () => {};
-    const returnPromise = new Promise((resolve, reject) => {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
     if (!callback) {
-      callback = (err, friendList) => {
+      callback = function (err, friendList) {
         if (err) {
           return rejectFunc(err);
         }
@@ -20,7 +21,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       };
     }
 
-    const initialForm = {
+    var form = {
       thread_id: threadID,
       offset: offset,
       limit: limit,
@@ -30,56 +31,49 @@ module.exports = function (defaultFuncs, api, ctx) {
       .post(
         "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
         ctx.jar,
-        initialForm,
+        form,
       )
       .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
+      .then(function (resData) {
         if (resData.error) {
           throw resData;
         }
-        
-        // প্রতিটি ইমেজের জন্য আলাদা আলাদা রিকোয়েস্ট পাঠানো হচ্ছে
         return Promise.all(
-          (resData.payload?.imagesData || []).map(image => {
-            // বাগ ফিক্স: ভেতরের ফর্মকে লোকাল কনস্ট্যান্ট করা হলো যেন ডাটা ওভাররাইট না হয়
-            const innerForm = {
+          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,
-                innerForm,
+                form,
               )
               .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-              .then(innerResData => {
-                if (innerResData.error) {
-                  throw innerResData;
+              .then(function (resData) {
+                if (resData.error) {
+                  throw resData;
                 }
-                
-                // অপশনাল চেইনিং ব্যবহার করে ক্র্যাশ সেফটি নিশ্চিত করা হলো
-                const requireData = innerResData.jsmods?.require?.[0]?.[3]?.[1];
-                if (!requireData) return null;
-
-                const queryThreadID = requireData.query_metadata?.query_path?.[0]?.message_thread;
-                const imageData = requireData.query_results?.[queryThreadID]?.message_images?.edges?.[0]?.node?.image2;
-                
+                // 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(resData => {
-        // নাল ভ্যালুগুলো ফিল্টার করে শুধু ভ্যালিড ইমেজ ডাটা পাঠানো হচ্ছে
-        callback(null, resData.filter(img => img !== null));
+      .then(function (resData) {
+        callback(null, resData);
       })
-      .catch(err => {
-        utils.error("Error in getThreadPictures", err);
+      .catch(function (err) {
+        log.error("Error in getThreadPictures", err);
         callback(err);
       });
-
     return returnPromise;
   };
 };

package/src/getUserID.js

@@ -1,11 +1,11 @@
 "use strict";
 
-const utils = require("../utils");
+var utils = require("../utils");
+var log = require("npmlog");
 
-// সার্চ রেজাল্টের ডাটা ফরম্যাট করার হেল্পার ফাংশন
 function formatData(data) {
   return {
-    userID: data.uid ? utils.formatID(data.uid.toString()) : null,
+    userID: utils.formatID(data.uid.toString()),
     photoUrl: data.photo,
     indexRank: data.index_rank,
     name: data.text,
@@ -19,15 +19,15 @@ function formatData(data) {
 
 module.exports = function (defaultFuncs, api, ctx) {
   return function getUserID(name, callback) {
-    let resolveFunc = () => {};
-    let rejectFunc = () => {};
-    const returnPromise = new Promise((resolve, reject) => {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
     if (!callback) {
-      callback = (err, friendList) => {
+      callback = function (err, friendList) {
         if (err) {
           return rejectFunc(err);
         }
@@ -35,7 +35,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       };
     }
 
-    const form = {
+    var form = {
       value: name.toLowerCase(),
       viewer: ctx.userID,
       rsp: "search",
@@ -47,18 +47,17 @@ module.exports = function (defaultFuncs, api, ctx) {
     defaultFuncs
       .get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
       .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
+      .then(function (resData) {
         if (resData.error) {
           throw resData;
         }
 
-        // অপশনাল চেইনিং ব্যবহার করে ক্র্যাশ সেফটি নিশ্চিত করা হলো
-        const entries = resData.payload?.entries || [];
+        var data = resData.payload.entries;
 
-        callback(null, entries.map(formatData));
+        callback(null, data.map(formatData));
       })
-      .catch(err => {
-        utils.error("getUserID", err);
+      .catch(function (err) {
+        log.error("getUserID", err);
         return callback(err);
       });