@dongdev/fca-unofficial 1.0.20 → 2.0.0

package/src/api/threads/changeThreadEmoji.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const utils = require("../../utils");
+const log = require("npmlog");
+
+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) {
+        log.error("changeThreadEmoji", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/threads/getThreadInfo.js

@@ -0,0 +1,572 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+const fs = require("fs");
+const path = require("path");
+const logger = require("../lib/logger");
+
+function formatEventReminders(reminder) {
+  return {
+    reminderID: reminder?.id,
+    eventCreatorID: reminder?.lightweight_event_creator?.id,
+    time: reminder?.time,
+    eventType: String(reminder?.lightweight_event_type || "").toLowerCase(),
+    locationName: reminder?.location_name,
+    locationCoordinates: reminder?.location_coordinates,
+    locationPage: reminder?.location_page,
+    eventStatus: String(reminder?.lightweight_event_status || "").toLowerCase(),
+    note: reminder?.note,
+    repeatMode: String(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: Array.isArray(reminder?.event_reminder_members?.edges) ? reminder.event_reminder_members.edges.map(m => ({
+      memberID: m?.node?.id,
+      state: String(m?.guest_list_state || "").toLowerCase(),
+    })) : [],
+  };
+}
+
+function formatThreadGraphQLResponse(data) {
+  if (!data) return null;
+  if (data?.errors) return null;
+  const t = data.message_thread;
+  if (!t) return null;
+  const threadID = t?.thread_key?.thread_fbid || t?.thread_key?.other_user_id || null;
+  const lastM = t?.last_message;
+  const lastNode = Array.isArray(lastM?.nodes) && lastM.nodes[0] ? lastM.nodes[0] : null;
+  const snippetID = lastNode?.message_sender?.messaging_actor?.id || null;
+  const snippetText = lastNode?.snippet || null;
+  const lastRNode = Array.isArray(t?.last_read_receipt?.nodes) && t.last_read_receipt.nodes[0] ? t.last_read_receipt.nodes[0] : null;
+  const lastReadTimestamp = lastRNode?.timestamp_precise || null;
+  const participants = Array.isArray(t?.all_participants?.edges) ? t.all_participants.edges : [];
+  const approvals = Array.isArray(t?.group_approval_queue?.nodes) ? t.group_approval_queue.nodes : [];
+  const customInfo = t?.customization_info || {};
+  const bubble = customInfo?.outgoing_bubble_color;
+  const participantCustoms = Array.isArray(customInfo?.participant_customizations) ? customInfo.participant_customizations : [];
+  const nicknames = participantCustoms.reduce((res, val) => {
+    if (val?.nickname && val?.participant_id) res[val.participant_id] = val.nickname;
+    return res;
+  }, {});
+  return {
+    threadID,
+    threadName: t?.name || null,
+    participantIDs: participants.map(d => d?.node?.messaging_actor?.id).filter(Boolean),
+    userInfo: participants.map(d => ({
+      id: d?.node?.messaging_actor?.id || null,
+      name: d?.node?.messaging_actor?.name || null,
+      firstName: d?.node?.messaging_actor?.short_name || null,
+      vanity: d?.node?.messaging_actor?.username || null,
+      url: d?.node?.messaging_actor?.url || null,
+      thumbSrc: d?.node?.messaging_actor?.big_image_src?.uri || null,
+      profileUrl: d?.node?.messaging_actor?.big_image_src?.uri || null,
+      gender: d?.node?.messaging_actor?.gender || null,
+      type: d?.node?.messaging_actor?.__typename || null,
+      isFriend: !!d?.node?.messaging_actor?.is_viewer_friend,
+      isBirthday: !!d?.node?.messaging_actor?.is_birthday,
+    })),
+    unreadCount: t?.unread_count ?? 0,
+    messageCount: t?.messages_count ?? 0,
+    timestamp: t?.updated_time_precise || null,
+    muteUntil: t?.mute_until || null,
+    isGroup: t?.thread_type === "GROUP",
+    isSubscribed: !!t?.is_viewer_subscribed,
+    isArchived: !!t?.has_viewer_archived,
+    folder: t?.folder || null,
+    cannotReplyReason: t?.cannot_reply_reason || null,
+    eventReminders: Array.isArray(t?.event_reminders?.nodes) ? t.event_reminders.nodes.map(formatEventReminders) : [],
+    emoji: customInfo?.emoji || null,
+    color: bubble ? String(bubble).slice(2) : null,
+    threadTheme: t?.thread_theme || null,
+    nicknames,
+    adminIDs: Array.isArray(t?.thread_admins) ? t.thread_admins : [],
+    approvalMode: !!t?.approval_mode,
+    approvalQueue: approvals.map(a => ({
+      inviterID: a?.inviter?.id || null,
+      requesterID: a?.requester?.id || null,
+      timestamp: a?.request_timestamp || null,
+      request_source: a?.request_source || null,
+    })),
+    reactionsMuteMode: String(t?.reactions_mute_mode || "").toLowerCase(),
+    mentionsMuteMode: String(t?.mentions_mute_mode || "").toLowerCase(),
+    isPinProtected: !!t?.is_pin_protected,
+    relatedPageThread: t?.related_page_thread || null,
+    name: t?.name || null,
+    snippet: snippetText,
+    snippetSender: snippetID,
+    snippetAttachments: [],
+    serverTimestamp: t?.updated_time_precise || null,
+    imageSrc: t?.image?.uri || null,
+    isCanonicalUser: !!t?.is_canonical_neo_user,
+    isCanonical: t?.thread_type !== "GROUP",
+    recipientsLoadable: true,
+    hasEmailParticipant: false,
+    readOnly: false,
+    canReply: t?.cannot_reply_reason == null,
+    lastMessageTimestamp: t?.last_message ? t.last_message.timestamp_precise : null,
+    lastMessageType: "message",
+    lastReadTimestamp,
+    threadType: t?.thread_type === "GROUP" ? 2 : 1,
+    inviteLink: {
+      enable: t?.joinable_mode ? t.joinable_mode.mode == 1 : false,
+      link: t?.joinable_mode ? t.joinable_mode.link : null,
+    },
+  };
+}
+
+const queue = [];
+let isProcessingQueue = false;
+const processingThreads = new Set();
+const queuedThreads = new Set();
+const cooldown = new Map();
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const getMultiInfo = async function (threadIDs) {
+    const buildQueries = () => {
+      const form = {};
+      threadIDs.forEach((x, y) => {
+        form["o" + y] = {
+          doc_id: "3449967031715030",
+          query_params: {
+            id: x,
+            message_limit: 0,
+            load_messages: false,
+            load_read_receipts: false,
+            before: null,
+          },
+        };
+      });
+      return {
+        queries: JSON.stringify(form),
+        batch_name: "MessengerGraphQLThreadFetcher",
+      };
+    };
+    const maxAttempts = 3;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const Submit = buildQueries();
+        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, Submit).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        if (!Array.isArray(resData) || resData.length === 0) throw new Error("EmptyGraphBatch");
+        const tail = resData[resData.length - 1];
+        if (tail?.error_results && tail.error_results !== 0) throw new Error("GraphErrorResults");
+        const body = resData.slice(0, -1).sort((a, b) => Object.keys(a)[0].localeCompare(Object.keys(b)[0]));
+        const out = [];
+        body.forEach((x, y) => out.push(formatThreadGraphQLResponse(x["o" + y]?.data)));
+        const valid = out.some(d => !!d && !!d.threadID);
+        if (!valid) throw new Error("GraphNoData");
+        return { Success: true, Data: out };
+      } catch (e) {
+        lastErr = e;
+        if (attempt < maxAttempts) await new Promise(r => setTimeout(r, 300 * attempt));
+      }
+    }
+    return { Success: false, Data: null, Error: lastErr ? String(lastErr.message || lastErr) : "Unknown" };
+  };
+
+  const dbFiles = fs.readdirSync(path.join(__dirname, "../lib/database")).filter(f => path.extname(f) === ".js").reduce((acc, file) => {
+    acc[path.basename(file, ".js")] = require(path.join(__dirname, "../lib/database", file))(api);
+    return acc;
+  }, {});
+  const { threadData } = dbFiles;
+  const { create, get, update, getAll } = threadData;
+
+  function isValidThread(d) {
+    return d && d.threadID;
+  }
+
+  async function fetchThreadInfo(tID, isNew) {
+    try {
+      const response = await getMultiInfo([tID]);
+      if (!response.Success || !response.Data || !isValidThread(response.Data[0])) {
+        cooldown.set(tID, Date.now() + 5 * 60 * 1000);
+        logger(`GraphQL empty for ${tID}, cooldown applied`, "warn");
+        return;
+      }
+      const threadInfo = response.Data[0];
+      if (isNew) {
+        await create(tID, { data: threadInfo });
+        logger(`Success create data thread: ${tID}`, "info");
+      } else {
+        await update(tID, { data: threadInfo });
+        logger(`Success update data thread: ${tID}`, "info");
+      }
+    } catch (err) {
+      cooldown.set(tID, Date.now() + 5 * 60 * 1000);
+      logger(`fetchThreadInfo error ${tID}: ${err?.message || err}`, "error");
+    } finally {
+      queuedThreads.delete(tID);
+    }
+  }
+
+  async function checkAndUpdateThreads() {
+    try {
+      const allThreads = await getAll("threadID");
+      const existingThreadIDs = new Set(allThreads.map(t => t.threadID));
+      const now = Date.now();
+      for (const t of existingThreadIDs) {
+        const cd = cooldown.get(t);
+        if (cd && now < cd) continue;
+        const result = await get(t);
+        if (!result) continue;
+        const lastUpdated = new Date(result.updatedAt).getTime();
+        if ((now - lastUpdated) / (1000 * 60) > 10 && !queuedThreads.has(t)) {
+          queuedThreads.add(t);
+          logger(`ThreadID ${t} queued for refresh`, "info");
+          queue.push(() => fetchThreadInfo(t, false));
+        }
+      }
+    } catch (err) {
+      logger(`checkAndUpdateThreads error: ${err?.message || err}`, "error");
+    }
+  }
+
+  async function processQueue() {
+    if (isProcessingQueue) return;
+    isProcessingQueue = true;
+    while (queue.length > 0) {
+      const task = queue.shift();
+      try {
+        await task();
+      } catch (err) {
+        logger(`Queue processing error: ${err?.message || err}`, "error");
+      }
+    }
+    isProcessingQueue = false;
+  }
+
+  setInterval(() => {
+    checkAndUpdateThreads();
+    processQueue();
+  }, 10000);
+
+  return async function getThreadInfoGraphQL(threadID, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const 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);
+      };
+    }
+    if (utils.getType(threadID) !== "Array") threadID = [threadID];
+    try {
+      const cached = await get(threadID[0]);
+      if (cached?.data && isValidThread(cached.data)) {
+        callback(null, cached.data);
+        return returnPromise;
+      }
+      if (!processingThreads.has(threadID[0])) {
+        processingThreads.add(threadID[0]);
+        logger(`Created new thread data: ${threadID[0]}`, "info");
+        const response = await getMultiInfo(threadID);
+        if (response.Success && response.Data && isValidThread(response.Data[0])) {
+          const data = response.Data[0];
+          await create(threadID[0], { data });
+          callback(null, data);
+        } else {
+          const stub = {
+            threadID: threadID[0],
+            threadName: null,
+            participantIDs: [],
+            userInfo: [],
+            unreadCount: 0,
+            messageCount: 0,
+            timestamp: null,
+            muteUntil: null,
+            isGroup: false,
+            isSubscribed: false,
+            isArchived: false,
+            folder: null,
+            cannotReplyReason: null,
+            eventReminders: [],
+            emoji: null,
+            color: null,
+            threadTheme: null,
+            nicknames: {},
+            adminIDs: [],
+            approvalMode: false,
+            approvalQueue: [],
+            reactionsMuteMode: "",
+            mentionsMuteMode: "",
+            isPinProtected: false,
+            relatedPageThread: null,
+            name: null,
+            snippet: null,
+            snippetSender: null,
+            snippetAttachments: [],
+            serverTimestamp: null,
+            imageSrc: null,
+            isCanonicalUser: false,
+            isCanonical: true,
+            recipientsLoadable: false,
+            hasEmailParticipant: false,
+            readOnly: false,
+            canReply: false,
+            lastMessageTimestamp: null,
+            lastMessageType: "message",
+            lastReadTimestamp: null,
+            threadType: 1,
+            inviteLink: { enable: false, link: null },
+            __status: "unavailable",
+          };
+          cooldown.set(threadID[0], Date.now() + 5 * 60 * 1000);
+          callback(null, stub);
+        }
+        processingThreads.delete(threadID[0]);
+      }
+    } catch (err) {
+      callback(err);
+    }
+    return returnPromise;
+  };
+};
+
+// "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,
+//     // @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) {
+//   if (data.errors) return data.errors;
+//   const messageThread = data.message_thread;
+//   if (!messageThread) return null;
+//   const threadID = messageThread.thread_key.thread_fbid
+//     ? messageThread.thread_key.thread_fbid
+//     : messageThread.thread_key.other_user_id;
+
+//   // Remove me
+//   const lastM = messageThread.last_message;
+//   const 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;
+//   const snippetText =
+//     lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+//   const lastR = messageThread.last_read_receipt;
+//   const 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,
+//       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 //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,
+//     threadTheme: messageThread.thread_theme,
+//     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,
+//     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,
+
+//     // update in Wed, 13 Jul 2022 19:41:12 +0700
+//     inviteLink: {
+//       enable: messageThread.joinable_mode
+//         ? messageThread.joinable_mode.mode == 1
+//         : false,
+//       link: messageThread.joinable_mode
+//         ? messageThread.joinable_mode.link
+//         : null
+//     }
+//   };
+// }
+
+// module.exports = function(defaultFuncs, api, ctx) {
+//   return function getThreadInfoGraphQL(threadID, callback) {
+//     let resolveFunc = function() {};
+//     let rejectFunc = function() {};
+//     const 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);
+//       };
+//     }
+
+//     if (utils.getType(threadID) !== "Array") {
+//       threadID = [threadID];
+//     }
+
+//     let form = {};
+//     // `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.
+//     threadID.map(function(t, i) {
+//       form["o" + i] = {
+//         doc_id: "3449967031715030",
+//         query_params: {
+//           id: t,
+//           message_limit: 0,
+//           load_messages: false,
+//           load_read_receipts: false,
+//           before: null
+//         }
+//       };
+//     });
+
+//     form = {
+//       queries: JSON.stringify(form),
+//       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 resData[0].o0.errors[0];
+//         // }
+//         // if (!resData[0].o0.data.message_thread) {
+//         // 	throw new Error("can't find this thread");
+//         // }
+//         const threadInfos = {};
+//         for (let i = resData.length - 2; i >= 0; i--) {
+//           const threadInfo = formatThreadGraphQLResponse(
+//             resData[i][Object.keys(resData[i])[0]].data
+//           );
+//           threadInfos[
+//             threadInfo?.threadID || threadID[threadID.length - 1 - i]
+//           ] = threadInfo;
+//         }
+//         if (Object.values(threadInfos).length == 1) {
+//           callback(null, Object.values(threadInfos)[0]);
+//         } else {
+//           callback(null, threadInfos);
+//         }
+//       })
+//       .catch(function(err) {
+//         log.error("getThreadInfoGraphQL", err);
+//         return callback(err);
+//       });
+
+//     return returnPromise;
+//   };
+// };