fca-riyad 37.0.0

package/src/api/action/setPostReaction.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+function formatData(resData) {
+  return {
+    viewer_feedback_reaction_info:
+      resData.feedback_react.feedback.viewer_feedback_reaction_info,
+    supported_reactions: resData.feedback_react.feedback.supported_reactions,
+    top_reactions: resData.feedback_react.feedback.top_reactions.edges,
+    reaction_count: resData.feedback_react.feedback.reaction_count
+  };
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function setPostReaction(postID, type, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (
+        getType(type) === "Function" ||
+        getType(type) === "AsyncFunction"
+      ) {
+        callback = type;
+        type = 0;
+      } else {
+        callback = function(err, data) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc(data);
+        };
+      }
+    }
+
+    const map = {
+      unlike: 0,
+      like: 1,
+      heart: 2,
+      love: 16,
+      haha: 4,
+      wow: 3,
+      sad: 7,
+      angry: 8
+    };
+
+    if (getType(type) !== "Number" && getType(type) === "String") {
+      type = map[type.toLowerCase()];
+    }
+
+    if (getType(type) !== "Number" && getType(type) !== "String") {
+      throw {
+        error: "setPostReaction: Invalid reaction type"
+      };
+    }
+
+    if (type != 0 && !type) {
+      throw {
+        error: "setPostReaction: Invalid reaction type"
+      };
+    }
+
+    const form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "CometUFIFeedbackReactMutation",
+      doc_id: "4769042373179384",
+      variables: JSON.stringify({
+        input: {
+          actor_id: ctx.userID,
+          feedback_id: Buffer.from("feedback:" + postID).toString("base64"),
+          feedback_reaction: type,
+          feedback_source: "OBJECT",
+          is_tracking_encrypted: true,
+          tracking: [],
+          session_id: "f7dd50dd-db6e-4598-8cd9-561d5002b423",
+          client_mutation_id: Math.round(Math.random() * 19).toString()
+        },
+        useDefaultActor: false,
+        scale: 3
+      })
+    };
+
+    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, formatData(resData.data));
+      })
+      .catch(function(err) {
+        log.error("setPostReaction", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/action/unfriend.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function unfriend(userID, 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 = {
+      uid: userID,
+      unref: "bd_friends_tab",
+      floc: "friends_tab",
+      "nctr[_mod]":
+        "pagelet_timeline_app_collection_" +
+        ctx.userID +
+        ":2356318349:2"
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/profile/removefriendconfirm.php",
+        ctx.jar,
+        form
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback(null, true);
+      })
+      .catch(function(err) {
+        log.error("unfriend", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/http/httpGet.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { getType } = require("../../utils/format");
+const { get } = require("../../utils/request");
+
+const httpGetFactory = function (defaultFuncs, api, ctx) {
+  return function httpGet(url, form, callback, notAPI) {
+    let resolveFunc = () => { };
+    let rejectFunc = () => { };
+
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      !callback &&
+      (getType(form) === "Function" || getType(form) === "AsyncFunction")
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    const executor = notAPI ? get : defaultFuncs.get;
+
+    executor(url, ctx.jar, form)
+      .then((resData) => callback(null, resData.data))
+      .catch(function (err) {
+        console.error("httpGet", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};
+
+module.exports = httpGetFactory;

package/src/api/http/httpPost.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { post } = require("../../utils/request");
+const { getType } = require("../../utils/format");
+
+const httpPostFactory = function (defaultFuncs, api, ctx) {
+  return function httpPost(url, form, callback, notAPI) {
+    let resolveFunc = () => { };
+    let rejectFunc = () => { };
+
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      !callback &&
+      (getType(form) === "Function" || getType(form) === "AsyncFunction")
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    const executor = notAPI ? post : defaultFuncs.post;
+
+    executor(url, ctx.jar, form, ctx.globalOptions)
+      .then((resData) => {
+        let data = resData.data;
+        if (typeof data === "object") {
+          data = JSON.stringify(data, null, 2);
+        }
+        callback(null, data);
+      })
+      .catch((err) => {
+        console.error("httpPost", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};
+
+module.exports = httpPostFactory;

package/src/api/http/postFormData.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var log = require("../../../func/logAdapter");
+const { getType } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function postFormData(url, form, callback) {
+    var resolveFunc = function() {};
+    var rejectFunc = function() {};
+
+    var returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      !callback &&
+      (getType(form) == "Function" ||
+        getType(form) == "AsyncFunction")
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback =
+      callback ||
+      function(err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    defaultFuncs
+      .postFormData(url, ctx.jar, form, {})
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        callback(null, resData);
+      })
+      .catch(function(err) {
+        log.error("postFormData", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/addUserToGroup.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const { generateOfflineThreadingID, getType } = require("../../utils/format");
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addUserToGroup(userID, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (getType(threadID) !== "Number" && getType(threadID) !== "String") {
+        const err = new Error("ThreadID should be of type Number or String.");
+        callback?.(err);
+        return reject(err);
+      }
+      if (getType(userID) !== "Array") userID = [userID];
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "23",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_ids: userID,
+              sync_group: 1
+            }),
+            queue_name: threadID.toString(),
+            task_id: taskID
+          }
+        ],
+        version_id: "24502707779384158"
+      };
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      });
+      const handleRes = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", handleRes);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", handleRes);
+      ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+        if (err) {
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback?.(err);
+          reject(err);
+        }
+      });
+    });
+  };
+};

package/src/api/messaging/changeAdminStatus.js

@@ -0,0 +1,126 @@
+"use strict";
+
+const { generateOfflineThreadingID, getType } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function changeAdminStatusNoMqtt(threadID, adminID, adminStatus) {
+    if (getType(threadID) !== "String") throw { error: "changeAdminStatus: threadID must be a string" };
+    if (getType(adminID) !== "String" && getType(adminID) !== "Array") throw { error: "changeAdminStatus: adminID must be a string or an array" };
+    if (getType(adminStatus) !== "Boolean") throw { error: "changeAdminStatus: adminStatus must be true or false" };
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = ++ctx.wsReqNumber;
+    let wsContent = {
+      request_id: reqID,
+      type: 3,
+      payload: {
+        version_id: '3816854585040595',
+        tasks: [],
+        epoch_id: generateOfflineThreadingID(),
+        data_trace_id: null
+      },
+      app_id: '772021112871879'
+    }
+    if (getType(adminID) === "Array") {
+      for (let i = 0; i < adminID.length; i++) {
+        wsContent.payload.tasks.push({
+          label: '25',
+          payload: JSON.stringify({ thread_key: threadID, contact_id: adminID[i], is_admin: adminStatus }),
+          queue_name: 'admin_status',
+          task_id: i + 1,
+          failure_count: null
+        });
+      }
+    } else {
+      wsContent.payload.tasks.push({
+        label: '25',
+        payload: JSON.stringify({ thread_key: threadID, contact_id: adminID, is_admin: adminStatus }),
+        queue_name: 'admin_status',
+        task_id: 1,
+        failure_count: null
+      });
+    }
+    wsContent.payload = JSON.stringify(wsContent.payload);
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        return reject(new Error("Not connected to MQTT"));
+      }
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(wsContent), {}, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  };
+  function changeAdminStatusMqtt(threadID, adminID, adminStatus) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    if (getType(threadID) !== "String") {
+      throw { error: "changeAdminStatus: threadID must be a string" };
+    }
+    if (getType(adminID) !== "String" && getType(adminID) !== "Array") {
+      throw { error: "changeAdminStatus: adminID must be a string or an array" };
+    }
+    if (getType(adminStatus) !== "Boolean") {
+      throw { error: "changeAdminStatus: adminStatus must be true or false" };
+    }
+    const tasks = [];
+    const isAdmin = adminStatus ? 1 : 0;
+    const epochID = generateOfflineThreadingID();
+    if (getType(adminID) === "Array") {
+      adminID.forEach((id, index) => {
+        tasks.push({
+          failure_count: null,
+          label: "25",
+          payload: JSON.stringify({
+            thread_key: threadID,
+            contact_id: id,
+            is_admin: isAdmin
+          }),
+          queue_name: "admin_status",
+          task_id: index + 1
+        });
+      });
+    } else {
+      tasks.push({
+        failure_count: null,
+        label: "25",
+        payload: JSON.stringify({
+          thread_key: threadID,
+          contact_id: adminID,
+          is_admin: isAdmin
+        }),
+        queue_name: "admin_status",
+        task_id: 1
+      });
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = ++ctx.wsReqNumber;
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: epochID,
+        tasks: tasks,
+        version_id: "8798795233522156"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+    return new Promise((resolve, reject) => {
+      ctx.mqttClient.publish("/ls_req", form, {}, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  };
+  return function changeAdminStatus(threadID, adminID, adminStatus) {
+    if (ctx.mqttClient) {
+      try {
+        return changeAdminStatusMqtt(threadID, adminID, adminStatus);
+      } catch (e) {
+        return changeAdminStatusNoMqtt(threadID, adminID, adminStatus);
+      }
+    } else {
+      return changeAdminStatusNoMqtt(threadID, adminID, adminStatus);
+    }
+  };
+};

package/src/api/messaging/changeArchivedStatus.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { formatID } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function changeArchivedStatus(threadOrThreads, archive, 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 = {};
+
+    if (Array.isArray(threadOrThreads)) {
+      for (let i = 0; i < threadOrThreads.length; i++) {
+        form["ids[" + formatID(threadOrThreads[i]) + "]"] = archive;
+      }
+    } else {
+      form["ids[" + formatID(threadOrThreads) + "]"] = archive;
+    }
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/change_archived_status.php",
+        ctx.jar,
+        form
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("changeArchivedStatus", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/changeBlockedStatus.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin, saveCookies } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function changeBlockedStatus(userID, block, 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();
+      };
+    }
+
+    defaultFuncs
+      .post(
+        `https://www.facebook.com/messaging/${
+          block ? "" : "un"
+        }block_messages/`,
+        ctx.jar,
+        {
+          fbid: userID
+        }
+      )
+      .then(saveCookies(ctx.jar))
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("changeBlockedStatus", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/api/messaging/changeGroupImage.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+const log = require("../../../func/logAdapter");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function handleUpload(image) {
+    const form = {
+      images_only: "true",
+      fb_dtsg: ctx.fb_dtsg,
+      "attachment[]": image
+    };
+    return defaultFuncs
+      .postFormData("https://www.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) throw resData;
+        return resData.payload.metadata[0];
+      });
+  }
+  return function changeGroupImage(image, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || typeof threadID !== "string") {
+        const err = new Error("Invalid threadID");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      handleUpload(image)
+        .then(payload => {
+          const imageID = payload.image_id;
+          const taskPayload = {
+            thread_key: threadID,
+            image_id: imageID,
+            sync_group: 1
+          };
+
+          const mqttPayload = {
+            epoch_id: generateOfflineThreadingID(),
+            tasks: [
+              {
+                failure_count: null,
+                label: "37",
+                payload: JSON.stringify(taskPayload),
+                queue_name: "thread_image",
+                task_id: taskID
+              }
+            ],
+            version_id: "8798795233522156"
+          };
+          const request = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify(mqttPayload),
+            request_id: reqID,
+            type: 3
+          };
+          ctx.mqttClient.publish("/ls_req", JSON.stringify(request), {
+            qos: 1,
+            retain: false
+          });
+        })
+        .catch(err => {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeGroupImageMqtt", err);
+          callback?.(err);
+          reject(err);
+        });
+    });
+  };
+};