capfb 0.0.1-security → 1.4.74-beta

package/src/getThreadListDeprecated.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadList(start, end, type, callback) {
+    if (utils.getType(callback) === "Undefined") {
+      if (utils.getType(end) !== "Number") throw { error: "Please pass a number as a second argument." };
+      else if (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction") {
+        callback = type;
+        type = "inbox"; //default to inbox
+      }
+      else if (utils.getType(type) !== "String") throw { error: "Please pass a String as a third argument. Your options are: inbox, pending, and archived" };
+      else throw { error: "getThreadList: need callback" };
+    }
+
+    if (type === "archived") type = "action:archived";
+    else if (type !== "inbox" && type !== "pending" && type !== "other") throw { error: "type can only be one of the following: inbox, pending, archived, other" };
+
+
+    if (end <= start) end = start + 20;
+
+    var form = {
+      client: "mercury"
+    };
+
+    form[type + "[offset]"] = start;
+    form[type + "[limit]"] = end - start;
+
+    if (ctx.globalOptions.pageID) form.request_user_id = ctx.globalOptions.pageID;
+
+    defaultFuncs
+      .post("https://www.facebook.com/ajax/mercury/threadlist_info.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) throw resData;
+        log.verbose("getThreadList", JSON.stringify(resData.payload.threads));
+        return callback(null, (resData.payload.threads || []).map(utils.formatThread));
+      })
+      .catch(function (err) {
+        log.error("getThreadList", err);
+        return callback(err);
+      });
+  };
+};

package/src/getThreadPictures.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadPictures(threadID, offset, limit, callback) {
+    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);
+      };
+    }
+
+    var form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) throw resData;
+        return Promise.all(
+          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, form)
+              .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+              .then(function (resData) {
+                if (resData.error) throw resData;
+                // 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))
+      .catch(function (err) {
+        log.error("Error in getThreadPictures", err);
+        callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/getUserID.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatData(data) {
+  return {
+    userID: utils.formatID(data.uid.toString()),
+    photoUrl: data.photo,
+    indexRank: data.index_rank,
+    name: data.text,
+    isVerified: data.is_verified,
+    profileUrl: data.path,
+    category: data.category,
+    score: data.score,
+    type: data.type
+  };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getUserID(name, callback) {
+    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);
+      };
+    }
+
+    var form = {
+      value: name.toLowerCase(),
+      viewer: ctx.userID,
+      rsp: "search",
+      context: "search",
+      path: "/home.php",
+      request_id: utils.getGUID()
+    };
+
+    defaultFuncs
+      .get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) throw resData;
+
+        var data = resData.payload.entries;
+
+        callback(null, data.map(formatData));
+      })
+      .catch(function (err) {
+        log.error("getUserID", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/getUserInfo.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatData(data) {
+  var retObj = {};
+
+  for (var prop in data) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (data.hasOwnProperty(prop)) {
+      var innerObj = data[prop];
+      retObj[prop] = {
+        name: innerObj.name,
+        firstName: innerObj.firstName,
+        vanity: innerObj.vanity,
+        thumbSrc: innerObj.thumbSrc,
+        profileUrl: innerObj.uri,
+        gender: innerObj.gender,
+        type: innerObj.type,
+        isFriend: innerObj.is_friend,
+        isBirthday: !!innerObj.is_birthday
+      };
+    }
+  }
+
+  return retObj;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getUserInfo(id, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, userInfo) {
+        if (err) return rejectFunc(err);
+        resolveFunc(userInfo);
+      };
+    }
+
+    if (utils.getType(id) !== "Array") id = [id];
+
+    var form = {};
+    id.map(function (v, i) {
+      form["ids[" + i + "]"] = v;
+    });
+    defaultFuncs
+      .post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) throw resData;
+        return callback(null, formatData(resData.payload.profiles));
+      })
+      .catch(function (err) {
+        log.error("getUserInfo", "Lỗi: getUserInfo Có Thể Do Bạn Spam Quá Nhiều !,Hãy Thử Lại !");
+        return callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/getUserInfoV2.js

@@ -0,0 +1,35 @@
+/* eslint-disable linebreak-style */
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getUserInfoV2(id, callback) {
+      var resolveFunc = function () { };
+      var rejectFunc = function () { };
+      var returnPromise = new Promise(function (resolve, reject) {
+        resolveFunc = resolve;
+        rejectFunc = reject;
+      });
+  
+      if (!callback) {
+        callback = function (err, userInfo) {
+          if (err) return rejectFunc(err);
+          resolveFunc(userInfo);
+        };
+      }
+    try {
+      var { getInfo } = require('../Extra/ExtraAddons');
+      getInfo(id)
+        .then(data => {
+        return callback(null, data);
+      });
+    }
+    catch (e) {
+      return callback(null, e);
+    }
+    return returnPromise;
+    };
+  };

package/src/handleFriendRequest.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function handleFriendRequest(userID, accept, callback) {
+    if (utils.getType(accept) !== "Boolean") throw { error: "Please pass a boolean as a second argument." };
+
+    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);
+      };
+    }
+
+    var form = {
+      viewer_id: userID,
+      "frefs[0]": "jwl",
+      floc: "friend_center_requests",
+      ref: "/reqs.php",
+      action: (accept ? "confirm" : "reject")
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/requests/friends/ajax/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.payload.err) throw { err: resData.payload.err };
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("handleFriendRequest", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/handleMessageRequest.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function handleMessageRequest(threadID, accept, callback) {
+    if (utils.getType(accept) !== "Boolean") throw { error: "Please pass a boolean as a second argument." };
+
+    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);
+      };
+    }
+
+    var form = {
+      client: "mercury"
+    };
+
+    if (utils.getType(threadID) !== "Array") threadID = [threadID];
+
+    var messageBox = accept ? "inbox" : "other";
+
+    for (var 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(utils.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/httpGet.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function httpGet(url, form, callback, notAPI) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback && (utils.getType(form) == "Function" || utils.getType(form) == "AsyncFunction")) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback = callback || function (err, data) {
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (notAPI) {
+      utils
+        .get(url, ctx.jar, form, ctx.globalOptions)
+        .then(resData => callback(null, resData.body.toString()))
+        .catch(function (err) {
+          log.error("httpGet", err);
+          return callback(err);
+        });
+    }
+    else {
+      defaultFuncs
+        .get(url, ctx.jar, form)
+        .then(resData => callback(null, resData.body.toString()))
+        .catch(function (err) {
+          log.error("httpGet", err);
+          return callback(err);
+        });
+    }
+
+    return returnPromise;
+  };
+};

package/src/httpPost.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function httpGet(url, form, callback, notAPI) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback && (utils.getType(form) == "Function" || utils.getType(form) == "AsyncFunction")) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback = callback || function (err, data) {
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (notAPI) {
+      utils
+        .post(url, ctx.jar, form, ctx.globalOptions)
+        .then(resData => callback(null, resData.body.toString()))
+        .catch(function (err) {
+          log.error("httpPost", err);
+          return callback(err);
+        });
+    }
+    else {
+      defaultFuncs
+        .post(url, ctx.jar, form, {})
+        .then(resData => callback(null, resData.body.toString()))
+        .catch(function (err) {
+          log.error("httpPost", err);
+          return callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};

package/src/httpPostFormData.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function httpPostFormData(url, form, callback) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback && (utils.getType(form) == "Function" || utils.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(function(resData) {
+        callback(null, resData.body.toString());
+      })
+      .catch(function(err) {
+        log.error("httpPostFormData", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};