bb-fca 2.0.0

package/src/deltas/apis/messaging/markAsRead.ts

@@ -0,0 +1,94 @@
+// @ChoruOfficial
+import utils = require("../../../utils");
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Marks a thread as read.
+   * @param {string} threadID - The ID of the thread to mark as read.
+   * @param {boolean} [read=true] - Whether to mark as read (true) or unread (false). Defaults to true.
+   * @param {Function} [callback] - The callback function.
+   * @returns {Promise<null|Error>} A Promise that resolves with null on success, or rejects with an Error.
+   */
+  return async function markAsRead(threadID, read, callback) {
+    if (
+      utils.getType(read) === "Function" ||
+      utils.getType(read) === "AsyncFunction"
+    ) {
+      callback = read;
+      read = true;
+    }
+    if (read == undefined) {
+      read = true;
+    }
+
+    if (!callback) {
+      callback = () => {};
+    }
+
+    const form = {};
+
+    if (typeof ctx.globalOptions.pageID !== "undefined") {
+      form["source"] = "PagesManagerMessagesInterface";
+      form["request_user_id"] = ctx.globalOptions.pageID;
+      form["ids[" + threadID + "]"] = read;
+      form["watermarkTimestamp"] = new Date().getTime();
+      form["shouldSendReadReceipt"] = true;
+      form["commerce_last_message_type"] = "";
+
+      let resData;
+      try {
+        resData = await defaultFuncs
+          .post(
+            "https://www.facebook.com/ajax/mercury/change_read_status.php",
+            ctx.jar,
+            form,
+          )
+          .then(utils.saveCookies(ctx.jar))
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      } catch (e) {
+        callback(e);
+        return e;
+      }
+
+      if (resData.error) {
+        const err = resData.error;
+        utils.error("markAsRead", err);
+        callback(err);
+        return err;
+      }
+
+      callback();
+      return null;
+    } else {
+      try {
+        if (ctx.mqttClient) {
+          const err = await new Promise((r) =>
+            ctx.mqttClient.publish(
+              "/mark_thread",
+              JSON.stringify({
+                threadID,
+                mark: "read",
+                state: read,
+              }),
+              { qos: 1, retain: false },
+              r,
+            ),
+          );
+          if (err) throw err;
+        } else {
+          throw {
+            error: "You can only use this function after you start listening.",
+          };
+        }
+      } catch (e) {
+        callback(e);
+        return e;
+      }
+    }
+  };
+};

package/src/deltas/apis/messaging/markAsReadAll.ts

@@ -0,0 +1,38 @@
+import utils = require('../../../utils');
+
+// @ChoruOfficial
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(): Promise<void>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * @returns {Promise<void>}
+   */
+  return async function markAsReadAll() {
+    const form = {
+      folder: 'inbox',
+    };
+
+    try {
+      const resData = await defaultFuncs.post(
+        'https://www.facebook.com/ajax/mercury/mark_folder_as_read.php',
+        ctx.jar,
+        form,
+      );
+
+      const parsedData = utils.parseAndCheckLogin(resData, defaultFuncs) as any;
+
+      if (parsedData.error) {
+        throw parsedData;
+      }
+
+      return;
+    } catch (err) {
+      utils.error('markAsReadAll', err);
+      throw err;
+    }
+  };
+}

package/src/deltas/apis/messaging/markAsSeen.ts

@@ -0,0 +1,69 @@
+// @ChoruOfficial
+import utils = require("../../../utils");
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Marks all messages as "seen" up to a specific timestamp.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
+   * @param {Function} [callback] - The callback function.
+   * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
+   */
+  return async function markAsRead(seen_timestamp, callback) {
+    let resolveFunc: Function = function () {};
+    let rejectFunc: Function = function () {};
+    const returnPromise = new Promise<any>(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (utils.getType(seen_timestamp) == "Function" || utils.getType(seen_timestamp) == "AsyncFunction") {
+      callback = seen_timestamp;
+      seen_timestamp = Date.now();
+    } else if (seen_timestamp === undefined) {
+      seen_timestamp = Date.now();
+    }
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      seen_timestamp: seen_timestamp,
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/mark_seen.php",
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData.error) {
+        throw resData;
+      }
+
+      return callback();
+    } catch (err) {
+      utils.error("markAsSeen", err);
+      if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
+        ctx.loggedIn = false;
+      }
+      return callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/deltas/apis/messaging/nickname.ts

@@ -0,0 +1,153 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets a nickname for a participant in a Facebook thread via MQTT.
+   *
+   * @param {string} nickname The new nickname to set.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function setNickname(
+    nickname,
+    threadID,
+    participantID,
+    callback,
+    initiatorID,
+  ) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise<any>((resolve, reject) => {
+      _resolvePromise = resolve;
+      _rejectPromise = reject;
+    });
+
+    if (
+      utils.getType(callback) === 'Function' ||
+      utils.getType(callback) === 'AsyncFunction'
+    ) {
+      _callback = callback;
+      _initiatorID = initiatorID;
+    } else if (
+      utils.getType(threadID) === 'Function' ||
+      utils.getType(threadID) === 'AsyncFunction'
+    ) {
+      _callback = threadID;
+      threadID = null;
+      _initiatorID = callback;
+    } else if (
+      utils.getType(participantID) === 'Function' ||
+      utils.getType(participantID) === 'AsyncFunction'
+    ) {
+      _callback = participantID;
+      participantID = ctx.userID;
+      _initiatorID = callback;
+    } else if (utils.getType(callback) === 'string') {
+      _initiatorID = callback;
+      _callback = undefined;
+    } else {
+      _callback = undefined;
+      _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function(__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+    participantID = participantID || ctx.userID;
+
+    if (!threadID) {
+      return _callback(new Error('threadID is required to set a nickname.'));
+    }
+    if (typeof nickname !== 'string') {
+      return _callback(new Error('nickname must be a string.'));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error('Not connected to MQTT'));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      contact_id: participantID.toString(),
+      nickname: nickname,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '44',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_participant_nickname',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context: any = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+
+    ctx.mqttClient.publish(
+      '/ls_req',
+      JSON.stringify(context),
+      { qos: 1, retain: false },
+      (err) => {
+        if (err) {
+          return _callback(
+            new Error(
+              `MQTT publish failed for setNickname: ${err.message || err}`,
+            ),
+          );
+        }
+
+        const nicknameChangeEvent = {
+          type: 'thread_nickname_update',
+          threadID: threadID,
+          participantID: participantID,
+          newNickname: nickname,
+          senderID: _initiatorID,
+          BotID: ctx.userID,
+          timestamp: Date.now(),
+        };
+        _callback(null, nicknameChangeEvent);
+      },
+    );
+
+    return returnPromise;
+  };
+}

package/src/deltas/apis/messaging/notes.ts

@@ -0,0 +1,165 @@
+import utils = require('../../../utils');
+
+/**
+ * @ChoruOfficial
+ * @description A module for interacting with Facebook Messenger Notes. This is not for creating notes on a user's profile page, but rather the temporary status-like notes in Messenger.
+ * @param {Object} defaultFuncs The default functions provided by the API wrapper.
+ * @param {Object} api The full API object.
+ * @param {Object} ctx The context object containing the user's session state (e.g., userID, jar).
+ * @returns {Object} An object containing methods to create, delete, recreate, and check notes.
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * @callback notesCallback
+   * @param {Error|null} error An error object if the request fails, otherwise null.
+   * @param {Object} [data] The data returned from the API.
+   */
+
+  /**
+   * Checks for the currently active note for the logged-in user.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object representing the current note.
+   */
+  function checkNote(callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const form = {
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'MWInboxTrayNoteCreationDialogQuery',
+      variables: JSON.stringify({ scale: 2 }),
+      doc_id: '30899655739648624',
+    };
+
+    defaultFuncs
+      .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const currentNote = resData?.data?.viewer?.actor?.msgr_user_rich_status;
+        callback(null, currentNote);
+      })
+      .catch((err) => {
+        utils.error('notes.checkNote', err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Creates a new note with the provided text. The note lasts for 24 hours (86400 seconds).
+   * @param {string} text The content of the note.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the note's creation status.
+   */
+  function createNote(text, privacy = 'EVERYONE', callback?) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 10).toString(),
+        actor_id: ctx.userID,
+        description: text,
+        duration: 86400, // 24 hours in seconds
+        note_type: 'TEXT_NOTE',
+        privacy,
+        session_id: utils.getGUID(),
+      },
+    };
+    const form = {
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name:
+        'MWInboxTrayNoteCreationDialogCreationStepContentMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '24060573783603122',
+    };
+
+    defaultFuncs
+      .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const status = resData?.data?.xfb_rich_status_create?.status;
+        if (!status)
+          throw new Error('Could not find note status in the server response.');
+        callback(null, status);
+      })
+      .catch((err) => {
+        utils.error('notes.createNote', err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Deletes a specific note by its ID.
+   * @param {string} noteID The ID of the note to be deleted.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the deletion.
+   */
+  function deleteNote(noteID, callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 10).toString(),
+        actor_id: ctx.userID,
+        rich_status_id: noteID,
+      },
+    };
+    const form = {
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'useMWInboxTrayDeleteNoteMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '9532619970198958',
+    };
+
+    defaultFuncs
+      .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const deletedStatus = resData?.data?.xfb_rich_status_delete;
+        if (!deletedStatus)
+          throw new Error(
+            'Could not find deletion status in the server response.',
+          );
+        callback(null, deletedStatus);
+      })
+      .catch((err) => {
+        utils.error('notes.deleteNote', err);
+        callback(err);
+      });
+  }
+
+  /**
+   * A convenience function that first deletes an old note and then creates a new one.
+   * @param {string} oldNoteID The ID of the note to delete.
+   * @param {string} newText The text for the new note.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object containing the deletion and creation statuses.
+   */
+  function recreateNote(oldNoteID, newText, callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    deleteNote(oldNoteID, (err, deleted) => {
+      if (err) {
+        return callback(err);
+      }
+      createNote(newText, undefined, (err, created) => {
+        if (err) {
+          return callback(err);
+        }
+        callback(null, { deleted, created });
+      });
+    });
+  }
+
+  return {
+    create: createNote,
+    delete: deleteNote,
+    recreate: recreateNote,
+    check: checkNote,
+  };
+}

package/src/deltas/apis/messaging/resolvePhotoUrl.ts

@@ -0,0 +1,56 @@
+import utils = require("../../../utils");
+
+/**
+ * @module resolvePhotoUrl
+ * @description Fetches the direct URL of a Facebook photo using its photo ID.
+ * @param {Object} defaultFuncs - An object containing default request functions.
+ * @param {Object} api - Facebook API object (unused here but kept for compatibility).
+ * @param {Object} ctx - Context object containing cookies (jar) and other session info.
+ * @returns {Function} resolvePhotoUrl - A function that takes a photo ID and optional callback, and returns a Promise resolving to the photo URL.
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * @function resolvePhotoUrl
+   * @param {string} photoID - The ID of the Facebook photo to resolve.
+   * @param {Function} [callback] - Optional Node-style callback function `(err, photoUrl)`.
+   * @returns {Promise<string>} A Promise that resolves to the direct photo URL.
+   */
+  return function resolvePhotoUrl(photoID, callback) {
+    let resolveFunc: Function = function () {};
+    let rejectFunc: Function = function () {};
+    const returnPromise = new Promise<any>(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, photoUrl) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(photoUrl);
+      };
+    }
+
+    defaultFuncs
+      .get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+        photo_id: photoID,
+      })
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData.error) {
+          throw resData;
+        }
+
+        const photoUrl = resData.jsmods.require[0][3][0];
+
+        return callback(null, photoUrl);
+      })
+      .catch((err) => {
+        utils.error("resolvePhotoUrl", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};