alicezetion 1.0.0

package/alice/nickname.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function changeNickname(nickname, threadID, participantID, callback) {
+    callback = callback || function() {};
+
+    var form = {
+      nickname: nickname,
+      participant_id: participantID,
+      thread_or_other_fbid: threadID
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/save_thread_nickname/?source=thread_settings&dpr=1",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error === 1545014) {
+          throw { error: "Trying to change nickname of user isn't in thread" };
+        }
+        if (resData.error === 1357031) {
+          throw {
+            error:
+              "Trying to change user nickname of a thread that doesn't exist. Have at least one message in the thread before trying to change the user nickname."
+          };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("changeNickname", err);
+        return callback(err);
+      });
+  };
+};

package/alice/poll.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function createPoll(title, threadID, options, callback) {
+    if (!callback) {
+      if (utils.getType(options) == "Function") {
+        callback = options;
+      } else {
+        callback = function() {};
+      }
+    }
+    if (!options) {
+      options = {}; // Initial poll options are optional
+    }
+
+    var form = {
+      target_id: threadID,
+      question_text: title
+    };
+
+    // Set fields for options (and whether they are selected initially by the posting user)
+    var ind = 0;
+    for (var opt in options) {
+      if (options.hasOwnProperty(opt)) {
+        form["option_text_array[" + ind + "]"] = opt;
+        form["option_is_selected_array[" + ind + "]"] = options[opt]
+          ? "1"
+          : "0";
+        ind++;
+      }
+    }
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/group_polling/create_poll/?dpr=1",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.payload.status != "success") {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("createPoll", err);
+        return callback(err);
+      });
+  };
+};

package/alice/react.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function setMessageReaction(reaction, messageID, callback) {
+    if (!callback) {
+      callback = function() {};
+    }
+
+    switch (reaction) {
+      case ":heart_eyes:":
+      case ":love:":
+        reaction = "\uD83D\uDE0D";
+        break;
+      case ":laughing:":
+      case ":haha:":
+        reaction = "\uD83D\uDE06";
+        break;
+      case ":open_mouth:":
+      case ":wow:":
+        reaction = "\uD83D\uDE2E";
+        break;
+      case ":cry:":
+      case ":sad:":
+        reaction = "\uD83D\uDE22";
+        break;
+      case ":angry:":
+        reaction = "\uD83D\uDE20";
+        break;
+      case ":thumbsup:":
+      case ":like:":
+        reaction = "\uD83D\uDC4D";
+        break;
+      case ":thumbsdown:":
+      case ":dislike:":
+        reaction = "\uD83D\uDC4E";
+        break;
+      default:
+        break;
+    }
+
+    var variables = {
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction: reaction
+      }
+    };
+
+    var qs = {
+      doc_id: "1491398900900362",
+      variables: JSON.stringify(variables),
+      dpr: 1
+    };
+
+    defaultFuncs
+      .postFormData(
+        "https://www.facebook.com/webgraphql/mutation/",
+        ctx.jar,
+        {},
+        qs
+      )
+      .then(utils.parseAndCheckLogin(ctx.jar, defaultFuncs))
+      .then(function(resData) {
+        if (!resData) {
+          throw { error: "setReaction returned empty object." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        callback(null);
+      })
+      .catch(function(err) {
+        log.error("setReaction", err);
+        return callback(err);
+      });
+  };
+};

package/alice/read.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function markAsRead(threadID, read, callback) {
+    if (utils.getType(read) === 'Function' || utils.getType(read) === 'AsyncFunction') {
+      callback = read;
+      read = true;
+    }
+    if (read == undefined) {
+      read = true;
+    }
+    if (!callback) {
+      callback = function() {};
+    }
+
+    var 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"] = "non_ad";
+    form["titanOriginatedThreadId"] = utils.generateThreadingID(ctx.clientID);
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/change_read_status.php",
+        ctx.jar,
+        form
+      )
+      .then(utils.saveCookies(ctx.jar))
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("markAsRead", err);
+        return callback(err);
+      });
+  };
+};

package/alice/resolveimgurl.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function resolvePhotoUrl(photoID, callback) {
+    if (!callback) {
+      throw { error: "resolvePhotoUrl: need callback" };
+    }
+
+    defaultFuncs
+      .get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+        photo_id: photoID
+      })
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) {
+          throw resData;
+        }
+
+        var photoUrl = resData.jsmods.require[0][3][0];
+
+        return callback(null, photoUrl);
+      })
+      .catch(err => {
+        log.error("resolvePhotoUrl", err);
+        return callback(err);
+      });
+  };
+};

package/alice/seen.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function markAsReadAll(callback) {
+    if (!callback) {
+      callback = function() {};
+    }
+
+    var form = {
+      folder: 'inbox'
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/mark_folder_as_read.php",
+        ctx.jar,
+        form
+      )
+      .then(utils.saveCookies(ctx.jar))
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("markAsReadAll", err);
+        return callback(err);
+      });
+  };
+};

package/alice/title.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function setTitle(newTitle, threadID, callback) {
+    if (
+      !callback &&
+      (utils.getType(threadID) === "Function" ||
+        utils.getType(threadID) === "AsyncFunction")
+    ) {
+      throw { error: "please pass a threadID as a second argument." };
+    }
+
+    if (!callback) {
+      callback = function() {};
+    }
+
+    var messageAndOTID = utils.generateOfflineThreadingID();
+    var form = {
+      client: "mercury",
+      action_type: "ma-type:log-message",
+      author: "fbid:" + ctx.userID,
+      thread_id: "",
+      author_email: "",
+      coordinates: "",
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      manual_retry_cnt: "0",
+      thread_fbid: threadID,
+      thread_name: newTitle,
+      thread_id: threadID,
+      log_message_type: "log:thread-name"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/set_thread_name/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error && resData.error === 1545012) {
+          throw { error: "Cannot change chat title: Not member of chat." };
+        }
+
+        if (resData.error && resData.error === 1545003) {
+          throw { error: "Cannot set title of single-user chat." };
+        }
+
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("setTitle", err);
+        return callback(err);
+      });
+  };
+};

package/alice/typeindicator.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  function makeTypingIndicator(typ, threadID, callback) {
+    var form = {
+      typ: +typ,
+      to: "",
+      source: "mercury-chat",
+      thread: threadID
+    };
+
+    // Check if thread is a single person chat or a group chat
+    // More info on this is in api.sendMessage
+    api.getUserInfo(threadID, function(err, res) {
+      if (err) {
+        return callback(err);
+      }
+
+      // If id is single person chat
+      if (Object.keys(res).length > 0) {
+        form.to = threadID;
+      }
+
+      defaultFuncs
+        .post("https://www.facebook.com/ajax/messaging/typ.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function(resData) {
+          if (resData.error) {
+            throw resData;
+          }
+
+          return callback();
+        })
+        .catch(function(err) {
+          log.error("sendTypingIndicator", err);
+          return callback(err);
+        });
+    });
+  }
+
+  return function sendTypingIndicator(threadID, callback) {
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      if (callback) {
+        log.warn(
+          "sendTypingIndicator",
+          "callback is not a function - ignoring."
+        );
+      }
+      callback = () => {};
+    }
+
+    makeTypingIndicator(true, threadID, callback);
+
+    return function end(cb) {
+      if (
+        utils.getType(cb) !== "Function" &&
+        utils.getType(cb) !== "AsyncFunction"
+      ) {
+        if (cb) {
+          log.warn(
+            "sendTypingIndicator",
+            "callback is not a function - ignoring."
+          );
+        }
+        cb = () => {};
+      }
+
+      makeTypingIndicator(false, threadID, cb);
+    };
+  };
+};

package/alice/unsend.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, bot, ctx) {
+  return function unsendMessage(messageID, callback) {
+    if (!callback) {
+      callback = function() {};
+    }
+
+    var form = {
+      message_id: messageID
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/unsend_message/",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("unsendMessage", err);
+        return callback(err);
+      });
+  };
+};

package/alice/userid.js

@@ -0,0 +1,52 @@
+"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, bot, ctx) {
+  return function getUserID(name, callback) {
+    if (!callback) {
+      throw { error: "getUserID: need callback" };
+    }
+
+    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);
+      });
+  };
+};

package/alice/userinfo.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+function formatData(data) {
+  var retObj = {};
+
+  for (var prop in data) {
+    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, bot, ctx) {
+  return function getUserInfo(id, callback) {
+    if (!callback) {
+      throw { error: "getUserInfo: need callback" };
+    }
+
+    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", err);
+        return callback(err);
+      });
+  };
+};