@cexy/hoonfca 1.0.1 → 1.0.2

package/src/getUserInfo.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatData(ctx, data) {
+  var retObj = {};
+
+  for (var prop in data) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (data.hasOwnProperty(prop)) {
+      var innerObj = data[prop];
+      let udata = {
+        _id: 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,
+      };
+      utils.usersCache.addOne(udata);
+      setInterval(
+        () => utils.usersCache.deleteOneUsingId(`${prop}`),
+        ctx.globalOptions.cacheTime,
+      );
+      retObj[prop] = udata;
+    }
+  }
+
+  return retObj;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getUserInfo(id, callback, no_cache) {
+    if (utils.getType(id) !== "Array") {
+      id = [id];
+    }
+
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!no_cache && typeof callback == "boolean") no_cache = callback;
+    if (!callback || (callback && typeof callback != "function")) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    if (!no_cache) {
+      let dataCache = [];
+      let noCache = [];
+
+      for (let uid of id) {
+        const cache = utils.usersCache.findOneById(`${uid}`);
+        if (!cache) {
+          noCache.push(uid);
+          continue;
+        }
+        dataCache.push(cache);
+      }
+
+      if (noCache.length != 0) {
+        var form = {};
+        noCache.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;
+            }
+            let data = formatData(ctx, resData.payload.profiles);
+            for (let cdata of dataCache) {
+              data[cdata._id] = cdata;
+            }
+            return callback(null, data);
+          })
+          .catch(function (err) {
+            log.error("getUserInfo", err);
+            return callback(err);
+          });
+
+        return returnPromise;
+      } else {
+        let data = {};
+        for (let cdata of dataCache) {
+          data[cdata._id] = cdata;
+        }
+        callback(null, data);
+        return returnPromise;
+      }
+    } else {
+      var form = {};
+      id.map(function (v, i) {
+        form["ids[" + i + "]"] = v;
+      });
+      console.log(form);
+      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", err);
+          return callback(err);
+        });
+
+      return returnPromise;
+    }
+  };
+};

package/src/handleFriendRequest.js

@@ -0,0 +1,57 @@
+"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, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    var form = {
+      viewer_id: ctx.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,65 @@
+"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, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    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/{apis/httpGet.js → httpGet.js}

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

package/src/httpPost.js

@@ -0,0 +1,58 @@
+"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(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          log.error("httpPost", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .post(url, ctx.jar, form, {})
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          log.error("httpPost", err);
+          return callback(err);
+        });
+    }
+
+    return returnPromise;
+  };
+};