fca-riyad 37.0.0

package/src/api/messaging/getThemePictures.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThemePictures(id, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (
+        getType(callback) == "Function" ||
+        getType(callback) == "AsyncFunction"
+      ) {
+        callback = callback;
+      } else {
+        callback = function (err, data) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc(data);
+        };
+      }
+    }
+
+    if (getType(id) != "String") {
+      id = "";
+    }
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWPThreadThemeProviderQuery",
+      doc_id: "9734829906576883",
+      server_timestamps: true,
+      variables: JSON.stringify({
+        id
+      }),
+      av: ctx.userID
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+
+        return callback(null, resData);
+      })
+      .catch(function (err) {
+        log.error("getThemePictures", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/handleMessageRequest.js

@@ -0,0 +1,65 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function handleMessageRequest(threadID, accept, callback) {
+    if (getType(accept) !== "Boolean") {
+      throw {
+        error: "Please pass a boolean as a second argument."
+      };
+    }
+
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      client: "mercury"
+    };
+
+    if (getType(threadID) !== "Array") {
+      threadID = [threadID];
+    }
+
+    const messageBox = accept ? "inbox" : "other";
+
+    for (let i = 0; i < threadID.length; i++) {
+      form[messageBox + "[" + i + "]"] = threadID[i];
+    }
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/move_thread.php",
+        ctx.jar,
+        form
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("handleMessageRequest", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/markAsDelivered.js

@@ -0,0 +1,57 @@
+"use strict";
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function markAsDelivered(threadID, messageID, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    if (!threadID || !messageID) {
+      return callback("Error: messageID or threadID is not defined");
+    }
+
+    const form = {};
+
+    form["message_ids[0]"] = messageID;
+    form["thread_ids[" + threadID + "][0]"] = messageID;
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/delivery_receipts.php",
+        ctx.jar,
+        form
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("markAsDelivered", err);
+        if (getType(err) == "Object" && err.error === "Not logged in.") {
+          ctx.loggedIn = false;
+        }
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/markAsRead.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return async function markAsRead(threadID, read, callback) {
+    if (
+      getType(read) === "Function" ||
+      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"] = "";
+      //form["titanOriginatedThreadId"] = utils.generateThreadingID(ctx.clientID);
+
+      let resData;
+      try {
+        resData = await defaultFuncs
+          .post(
+            "https://www.facebook.com/ajax/mercury/change_read_status.php",
+            ctx.jar,
+            form
+          )
+          .then(saveCookies(ctx.jar))
+          .then(parseAndCheckLogin(ctx, defaultFuncs));
+      } catch (e) {
+        callback(e);
+        return e;
+      }
+
+      if (resData.error) {
+        const err = resData.error;
+        log.error("markAsRead", err);
+        if (getType(err) == "Object" && err.error === "Not logged in.") {
+          ctx.loggedIn = false;
+        }
+        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/api/messaging/markAsReadAll.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function markAsReadAll(callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      folder: "inbox"
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/mark_folder_as_read.php",
+        ctx.jar,
+        form
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("markAsReadAll", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/markAsSeen.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function markAsRead(seen_timestamp, callback) {
+    if (
+      getType(seen_timestamp) == "Function" ||
+      getType(seen_timestamp) == "AsyncFunction"
+    ) {
+      callback = seen_timestamp;
+      seen_timestamp = Date.now();
+    }
+
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      seen_timestamp: seen_timestamp
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/mark_seen.php",
+        ctx.jar,
+        form
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("markAsSeen", err);
+        if (getType(err) == "Object" && err.error === "Not logged in.") {
+          ctx.loggedIn = false;
+        }
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/muteThread.js

@@ -0,0 +1,50 @@
+"use strict";
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  // muteSecond: -1=permanent mute, 0=unmute, 60=one minute, 3600=one hour, etc.
+  return function muteThread(threadID, muteSeconds, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      thread_fbid: threadID,
+      mute_settings: muteSeconds
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/change_mute_thread.php",
+        ctx.jar,
+        form
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("muteThread", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/pinMessage.js

@@ -0,0 +1,115 @@
+"use strict";
+
+/**
+ * Pin or unpin a message in a thread.
+ * @param {string} messageID - The ID of the message to pin/unpin.
+ * @param {string} threadID - The thread ID where the message is.
+ * @param {boolean} [pin=true] - true to pin, false to unpin.
+ * @param {function} [callback] - Optional callback(err, result).
+ * @returns {Promise}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function pinMessage(messageID, threadID, pin, callback) {
+    // Handle optional pin param
+    if (typeof pin === "function") {
+      callback = pin;
+      pin = true;
+    }
+    if (typeof pin !== "boolean") pin = true;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!messageID || !threadID) {
+      const err = { error: "messageID and threadID are required." };
+      callback(err);
+      return returnPromise;
+    }
+
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      const err = { error: "Not connected to MQTT. Please try again later." };
+      callback(err);
+      return returnPromise;
+    }
+
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    // label 682 = pin, label 683 = unpin
+    const label = pin ? "682" : "683";
+
+    const taskPayload = {
+      thread_id: String(threadID),
+      message_id: String(messageID)
+    };
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: String((BigInt(Date.now()) << 22n)),
+        tasks: [
+          {
+            failure_count: null,
+            label,
+            payload: JSON.stringify(taskPayload),
+            queue_name: String(threadID),
+            task_id: taskID
+          }
+        ],
+        version_id: "6903494529735864"
+      }),
+      request_id: reqID,
+      type: 3
+    };
+
+    try {
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false });
+    } catch (err) {
+      const e = { error: "Failed to publish pinMessage: " + (err && err.message ? err.message : String(err)) };
+      callback(e);
+      return returnPromise;
+    }
+
+    const timeout = setTimeout(() => {
+      ctx.mqttClient.removeListener("message", handleRes);
+      callback({ error: "pinMessage timed out." });
+    }, 15000);
+
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp") return;
+      try {
+        let jsonMsg = JSON.parse(message.toString());
+        if (!jsonMsg.payload) return;
+        jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        if (jsonMsg.request_id !== reqID) return;
+
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+
+        callback(null, {
+          messageID: String(messageID),
+          threadID: String(threadID),
+          pinned: pin
+        });
+      } catch (err) {
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+        callback({ error: "Failed to parse pinMessage response: " + (err && err.message ? err.message : String(err)) });
+      }
+    };
+
+    ctx.mqttClient.on("message", handleRes);
+    return returnPromise;
+  };
+};

package/src/api/messaging/removeUserFromGroup.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { getType, generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function removeUserFromGroup(userID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      if (callback) return callback(err);
+      return Promise.reject(err);
+    }
+    if (!callback && (getType(threadID) === "Function" || getType(threadID) === "AsyncFunction")) throw { error: "please pass a threadID as a second argument." };
+    if (getType(threadID) !== "Number" && getType(threadID) !== "String") throw { error: "threadID should be of type Number or String and not " + getType(threadID) + "." };
+    if (getType(userID) !== "Number" && getType(userID) !== "String") throw { error: "userID should be of type Number or String and not " + getType(userID) + "." };
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = ++ctx.wsReqNumber;
+    var form = JSON.stringify({
+      "app_id": "2220391788200892",
+      "payload": JSON.stringify({
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: '140',
+            payload: JSON.stringify({
+              "thread_id": threadID,
+              "contact_id": userID,
+              "sync_group": 1
+            }),
+            queue_name: 'remove_participant_v2',
+            task_id: Math.random() * 1001 << 0
+          }
+        ],
+        version_id: '25002366262773827'
+      }),
+      "request_id": reqID,
+      "type": 3
+    });
+    ctx.mqttClient.publish('/ls_req', form, (err, data) => {
+      if (err) {
+        callback(err, null);
+        rejectFunc(err);
+      } else {
+        callback(null, true);
+        resolveFunc(true);
+      }
+    });
+    return returnPromise;
+  };
+};

package/src/api/messaging/resolvePhotoUrl.js

@@ -0,0 +1,43 @@
+"use strict";
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function resolvePhotoUrl(photoID, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    defaultFuncs
+      .get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+        photo_id: photoID
+      })
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) {
+          throw resData;
+        }
+
+        const photoUrl = resData.jsmods.require[0][3][0];
+
+        return callback(null, photoUrl);
+      })
+      .catch(err => {
+        log.error("resolvePhotoUrl", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};