@lazyneoaz/nkxchat 1.0.0

package/src/apis/handleFriendRequest.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Accepts or declines an incoming friend request.
+ *
+ * @example
+ * await api.handleFriendRequest(userID, true);   // accept
+ * await api.handleFriendRequest(userID, false);  // decline
+ *
+ * @param {string}   userID    The Facebook user ID of the person who sent the request.
+ * @param {boolean}  accept    true = accept, false = decline.
+ * @param {Function} [callback]
+ * @returns {Promise<void>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function handleFriendRequest(userID, accept, callback) {
+    if (typeof accept !== "boolean") {
+      throw new Error("handleFriendRequest: second argument must be a boolean (true = accept, false = decline).");
+    }
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!callback) {
+      callback = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    if (!userID) return callback(new Error("userID is required"));
+
+    const form = {
+      viewer_id:    ctx.userID,
+      "frefs[0]":   "jwl",
+      floc:         "friend_center_requests",
+      ref:          "/reqs.php",
+      action:       accept ? "confirm" : "reject",
+      friend_requester_id: String(userID),
+      fb_dtsg:      ctx.fb_dtsg,
+      lsd:          ctx.lsd || ctx.fb_dtsg,
+      jazoest:      ctx.jazoest,
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/requests/friends/ajax/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.payload && resData.payload.err) {
+          throw new Error(JSON.stringify(resData.payload.err));
+        }
+        callback(null, {
+          userID,
+          action: accept ? "accepted" : "declined",
+          success: true,
+        });
+      })
+      .catch((err) => {
+        utils.error("handleFriendRequest", err.message || err);
+        callback(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};

package/src/apis/handleMessageRequest.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function handleMessageRequest(threadID, accept, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(accept) === "Function") {
+        callback = accept;
+        accept = true;
+      }
+
+      const form = {
+        ids: `ids[${threadID}]=${threadID}`,
+        action: accept ? "accept" : "reject"
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/handle_message_requests.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, { success: true, accepted: accept });
+    } catch (err) {
+      utils.error("handleMessageRequest", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/httpGet.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function httpGet(url, form, customHeader, callback, notAPI) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      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 || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    if (notAPI) {
+      utils
+        .get(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpGet", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .get(url, ctx.jar, form, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpGet", err);
+          return callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};

package/src/apis/httpPost.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function httpPost(url, form, customHeader, callback, notAPI) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      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 || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    const normalizeBody = function(body) {
+      if (body === null || body === undefined) {
+        return String(body);
+      }
+
+      if (Buffer.isBuffer(body) || body instanceof Uint8Array) {
+        return body.toString('utf8');
+      }
+
+      if (typeof body === 'string') {
+        return body;
+      }
+
+      if (typeof body === 'object') {
+        try {
+          return JSON.stringify(body);
+        } catch (err) {
+          return String(body);
+        }
+      }
+
+      return String(body);
+    };
+
+    if (notAPI) {
+      utils
+        .post(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          const body = normalizeBody(resData.body);
+          callback(null, body);
+        })
+        .catch(function (err) {
+          utils.error("httpPost", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .post(url, ctx.jar, form, ctx, customHeader)
+        .then(function (resData) {
+          const body = normalizeBody(resData.body);
+          callback(null, body);
+          })
+        .catch(function (err) {
+          utils.error("httpPost", err);
+          return callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};

package/src/apis/httpPostFormData.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function httpPostFormData(url, form, customHeader, callback, notAPI) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      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 || {};
+
+    if (utils.getType(callback) == "Boolean") {
+      notAPI = callback;
+      callback = null;
+    }
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    if (notAPI) {
+      utils
+        .postFormData(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpPostFormData", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .postFormData(url, ctx.jar, form, null, ctx)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpPostFormData", err);
+          return callback(err);
+        });
+    }
+
+    return returnPromise;
+  };
+};