alicezetion 1.8.2 → 1.8.4

package/{leiamnash → src}/getThreadInfo.js

@@ -31,8 +31,10 @@ function formatEventReminders(reminder) {
 }
 
 function formatThreadGraphQLResponse(data) {
-  var messageThread = data.o0.data.message_thread;
-  var threadID = messageThread.thread_key.thread_fbid ? messageThread.thread_key.thread_fbid : messageThread.thread_key.other_user_id;
+  var messageThread = data.message_thread;
+	if (!messageThread) return {};
+	
+  var threadID = messageThread.thread_key.thread_fbid || messageThread.thread_key.other_user_id;
 
   // Remove me
   var lastM = messageThread.last_message;
@@ -108,64 +110,78 @@ function formatThreadGraphQLResponse(data) {
     lastMessageTimestamp: messageThread.last_message ? messageThread.last_message.timestamp_precise : null,
     lastMessageType: "message",
     lastReadTimestamp: lastReadTimestamp,
-    threadType: messageThread.thread_type == "GROUP" ? 2 : 1
+    threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
+    inviteLink: {
+			enable: messageThread.joinable_mode ? messageThread.joinable_mode.mode == 1 : false,
+			link: messageThread.joinable_mode ? messageThread.joinable_mode.link : null
+		}
   };
 }
 
 module.exports = function (defaultFuncs, api, ctx) {
-  return function getThreadInfoGraphQL(threadID, callback) {
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
+  return function getThreadInfoGraphQL(threadIDs, callback) {
+		var cb;
+    var rtPromise = new Promise(function (resolve, reject) {
+      cb = function (error, data) {
+        data ? resolve(data) : reject(error);
+      }
     });
 
-    if (utils.getType(callback) != "Function" && utils.getType(callback) != "AsyncFunction") {
-      callback = function (err, data) {
-        if (err) return rejectFunc(err);
-        resolveFunc(data);
-      };
-    }
+		if (typeof callback == 'function') cb = callback;
+    if (Array.isArray(threadIDs) == false) threadIDs = [threadIDs];
 
-    // `queries` has to be a string. I couldn't tell from the dev console. This
-    // took me a really long time to figure out. I deserve a cookie for this.
-    var form = {
-      queries: JSON.stringify({
-        o0: {
-          // This doc_id is valid as of July 20th, 2020
-          doc_id: "3449967031715030",
-          query_params: {
-            id: threadID,
-            message_limit: 0,
-            load_messages: false,
-            load_read_receipts: false,
-            before: null
-          }
-        }
-      }),
-      batch_name: "MessengerGraphQLThreadFetcher"
-    };
+		var form = {};
+		// `queries` has to be a string. I couldn't tell from the dev console. This
+		// took me a really long time to figure out. I deserve a cookie for this.
+		threadIDs.map(function (t, i) {
+			form["o" + i] = {
+				doc_id: "3449967031715030",
+				query_params: {
+					id: t,
+					message_limit: 0,
+					load_messages: false,
+					load_read_receipts: false,
+					before: null
+				}
+			};
+		});
 
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(function (resData) {
-        if (resData.error) throw resData;
-        // This returns us an array of things. The last one is the success /
-        // failure one.
-        // @TODO What do we do in this case?
-        if (resData[resData.length - 1].error_results !== 0) {
-          console.log(resData); //Log more info
-          throw new Error("well darn there was an error_result");
-        }
-        callback(null, formatThreadGraphQLResponse(resData[0]));
-      })
-      .catch(function (err) {
-        log.error("getThreadInfoGraphQL", "Can't get thread info");
-        return callback(err);
-      });
+		form = {
+			queries: JSON.stringify(form),
+			batch_name: "MessengerGraphQLThreadFetcher"
+		};
 
-    return returnPromise;
-  };
-};
+		defaultFuncs
+			.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+			.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+			.then(function (resData) {
+				if (resData.error) throw resData;
+				// This returns us an array of things. The last one is the success /
+				// failure one.
+				// @TODO What do we do in this case?
+				// if (resData[resData.length - 1].error_results !== 0) {
+				// 	throw resData[0].o0.errors[0];
+				// }
+				// if (!resData[0].o0.data.message_thread) {
+				// 	throw new Error("can't find this thread");
+				// }
+				const threadInfos = {};
+				for (let i = resData.length - 2; i >= 0; i--) {
+					const threadInfo = formatThreadGraphQLResponse(resData[i][Object.keys(resData[i])[0]].data);
+					threadInfos[threadInfo?.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
+				}
+				if (Object.values(threadInfos).length == 1) {
+					cb(null, Object.values(threadInfos)[0]);
+				}
+				else {
+					cb(null, threadInfos);
+				}
+			})
+			.catch(function (err) {
+				log.error("getThreadInfoGraphQL", err);
+				return cb(err);
+			});
+
+		return rtPromise;
+	};
+};

package/src/getThreadList.js

@@ -0,0 +1,237 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+function formatEventReminders(reminder) {
+	return {
+		reminderID: reminder.id,
+		eventCreatorID: reminder.lightweight_event_creator.id,
+		time: reminder.time,
+		eventType: reminder.lightweight_event_type.toLowerCase(),
+		locationName: reminder.location_name,
+		// @TODO verify this
+		locationCoordinates: reminder.location_coordinates,
+		locationPage: reminder.location_page,
+		eventStatus: reminder.lightweight_event_status.toLowerCase(),
+		note: reminder.note,
+		repeatMode: reminder.repeat_mode.toLowerCase(),
+		eventTitle: reminder.event_title,
+		triggerMessage: reminder.trigger_message,
+		secondsToNotifyBefore: reminder.seconds_to_notify_before,
+		allowsRsvp: reminder.allows_rsvp,
+		relatedEvent: reminder.related_event,
+		members: reminder.event_reminder_members.edges.map(function (member) {
+			return {
+				memberID: member.node.id,
+				state: member.guest_list_state.toLowerCase()
+			};
+		})
+	};
+}
+
+function formatThreadGraphQLResponse(messageThread) {
+	var threadID = messageThread.thread_key.thread_fbid
+		? messageThread.thread_key.thread_fbid
+		: messageThread.thread_key.other_user_id;
+
+	// Remove me
+	var lastM = messageThread.last_message;
+	var snippetID =
+		lastM &&
+			lastM.nodes &&
+			lastM.nodes[0] &&
+			lastM.nodes[0].message_sender &&
+			lastM.nodes[0].message_sender.messaging_actor
+			? lastM.nodes[0].message_sender.messaging_actor.id
+			: null;
+	var snippetText =
+		lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+	var lastR = messageThread.last_read_receipt;
+	var lastReadTimestamp =
+		lastR && lastR.nodes && lastR.nodes[0] && lastR.nodes[0].timestamp_precise
+			? lastR.nodes[0].timestamp_precise
+			: null;
+
+	return {
+		threadID: threadID,
+		threadName: messageThread.name,
+		participantIDs: messageThread.all_participants.edges.map(d => d.node.messaging_actor.id),
+		userInfo: messageThread.all_participants.edges.map(d => ({
+			id: d.node.messaging_actor.id,
+			name: d.node.messaging_actor.name,
+			firstName: d.node.messaging_actor.short_name,
+			vanity: d.node.messaging_actor.username,
+			url: d.node.messaging_actor.url,
+			thumbSrc: d.node.messaging_actor.big_image_src.uri,
+			profileUrl: d.node.messaging_actor.big_image_src.uri,
+			gender: d.node.messaging_actor.gender,
+			type: d.node.messaging_actor.__typename,
+			isFriend: d.node.messaging_actor.is_viewer_friend,
+			isBirthday: !!d.node.messaging_actor.is_birthday //not sure?
+		})),
+		unreadCount: messageThread.unread_count,
+		messageCount: messageThread.messages_count,
+		timestamp: messageThread.updated_time_precise,
+		muteUntil: messageThread.mute_until,
+		isGroup: messageThread.thread_type == "GROUP",
+		isSubscribed: messageThread.is_viewer_subscribed,
+		isArchived: messageThread.has_viewer_archived,
+		folder: messageThread.folder,
+		cannotReplyReason: messageThread.cannot_reply_reason,
+		eventReminders: messageThread.event_reminders
+			? messageThread.event_reminders.nodes.map(formatEventReminders)
+			: null,
+		emoji: messageThread.customization_info
+			? messageThread.customization_info.emoji
+			: null,
+		color:
+			messageThread.customization_info &&
+				messageThread.customization_info.outgoing_bubble_color
+				? messageThread.customization_info.outgoing_bubble_color.slice(2)
+				: null,
+		threadTheme: messageThread.thread_theme,
+		nicknames:
+			messageThread.customization_info &&
+				messageThread.customization_info.participant_customizations
+				? messageThread.customization_info.participant_customizations.reduce(
+					function (res, val) {
+						if (val.nickname) res[val.participant_id] = val.nickname;
+						return res;
+					},
+					{}
+				)
+				: {},
+		adminIDs: messageThread.thread_admins,
+		approvalMode: Boolean(messageThread.approval_mode),
+		approvalQueue: messageThread.group_approval_queue.nodes.map(a => ({
+			inviterID: a.inviter.id,
+			requesterID: a.requester.id,
+			timestamp: a.request_timestamp,
+			request_source: a.request_source // @Undocumented
+		})),
+
+		// @Undocumented
+		reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
+		mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
+		isPinProtected: messageThread.is_pin_protected,
+		relatedPageThread: messageThread.related_page_thread,
+
+		// @Legacy
+		name: messageThread.name,
+		snippet: snippetText,
+		snippetSender: snippetID,
+		snippetAttachments: [],
+		serverTimestamp: messageThread.updated_time_precise,
+		imageSrc: messageThread.image ? messageThread.image.uri : null,
+		isCanonicalUser: messageThread.is_canonical_neo_user,
+		isCanonical: messageThread.thread_type != "GROUP",
+		recipientsLoadable: true,
+		hasEmailParticipant: false,
+		readOnly: false,
+		canReply: messageThread.cannot_reply_reason == null,
+		lastMessageTimestamp: messageThread.last_message
+			? messageThread.last_message.timestamp_precise
+			: null,
+		lastMessageType: "message",
+		lastReadTimestamp: lastReadTimestamp,
+		threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
+
+		// update in Wed, 13 Jul 2022 19:41:12 +0700
+		inviteLink: {
+			enable: messageThread.joinable_mode ? messageThread.joinable_mode.mode == 1 : false,
+			link: messageThread.joinable_mode ? messageThread.joinable_mode.link : null
+		}
+	};
+}
+
+function formatThreadList(data) {
+	// console.log(JSON.stringify(data.find(t => t.thread_key.thread_fbid === "5095817367161431"), null, 2));
+	return data.map(t => formatThreadGraphQLResponse(t));
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function getThreadList(limit, timestamp, tags, callback) {
+		if (!callback && (utils.getType(tags) === "Function" || utils.getType(tags) === "AsyncFunction")) {
+			callback = tags;
+			tags = [""];
+		}
+		if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) {
+			throw { error: "getThreadList: limit must be a positive integer" };
+		}
+		if (utils.getType(timestamp) !== "Null" &&
+			(utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))) {
+			throw { error: "getThreadList: timestamp must be an integer or null" };
+		}
+		if (utils.getType(tags) === "String") {
+			tags = [tags];
+		}
+		if (utils.getType(tags) !== "Array") {
+			throw { error: "getThreadList: tags must be an array" };
+		}
+
+		var resolveFunc = function () { };
+		var rejectFunc = function () { };
+		var returnPromise = new Promise(function (resolve, reject) {
+			resolveFunc = resolve;
+			rejectFunc = reject;
+		});
+
+		if (utils.getType(callback) !== "Function" && utils.getType(callback) !== "AsyncFunction") {
+			callback = function (err, data) {
+				if (err) {
+					return rejectFunc(err);
+				}
+				resolveFunc(data);
+			};
+		}
+
+		const form = {
+			"av": ctx.globalOptions.pageID,
+			"queries": JSON.stringify({
+				"o0": {
+					// This doc_id was valid on 2020-07-20
+					"doc_id": "3336396659757871",
+					"query_params": {
+						"limit": limit + (timestamp ? 1 : 0),
+						"before": timestamp,
+						"tags": tags,
+						"includeDeliveryReceipts": true,
+						"includeSeqID": false
+					}
+				}
+			}),
+			"batch_name": "MessengerGraphQLThreadlistFetcher"
+		};
+
+		defaultFuncs
+			.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+			.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+			.then((resData) => {
+				if (resData[resData.length - 1].error_results > 0) {
+					throw resData[0].o0.errors;
+				}
+
+				if (resData[resData.length - 1].successful_results === 0) {
+					throw { error: "getThreadList: there was no successful_results", res: resData };
+				}
+
+				// When we ask for threads using timestamp from the previous request,
+				// we are getting the last thread repeated as the first thread in this response.
+				// .shift() gets rid of it
+				// It is also the reason for increasing limit by 1 when timestamp is set
+				// this way user asks for 10 threads, we are asking for 11,
+				// but after removing the duplicated one, it is again 10
+				if (timestamp) {
+					resData[0].o0.data.viewer.message_threads.nodes.shift();
+				}
+				callback(null, formatThreadList(resData[0].o0.data.viewer.message_threads.nodes));
+			})
+			.catch((err) => {
+				log.error("getThreadList", err);
+				return callback(err);
+			});
+
+		return returnPromise;
+	};
+};

package/src/getThreadPictures.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function getThreadPictures(threadID, offset, limit, 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);
+			};
+		}
+
+		let 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
+								const queryThreadID =
+									resData.jsmods.require[0][3][1].query_metadata.query_path[0]
+										.message_thread;
+								const imageData =
+									resData.jsmods.require[0][3][1].query_results[queryThreadID]
+										.message_images.edges[0].node.image2;
+								return imageData;
+							});
+					})
+				);
+			})
+			.then(function (resData) {
+				callback(null, resData);
+			})
+			.catch(function (err) {
+				log.error("Error in getThreadPictures", err);
+				callback(err);
+			});
+		return returnPromise;
+	};
+};

package/src/getUserID.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const utils = require("../utils");
+const 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) {
+		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 = {
+			value: name.toLowerCase(),
+			viewer: ctx.i_userID || 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;
+				}
+
+				const 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,163 @@
+"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,
+				searchTokens: innerObj.searchTokens,
+				alternateName: innerObj.alternateName,
+        isBlocked: innerObj.is_blocked
+      };
+    }
+  }
+
+  return retObj;
+}
+
+function formatDataGraph(userData, userIDs) {
+  var Obj = {};
+
+  userIDs.map(function (c, i) {
+    var res = userData[i];
+    return !res.data ? Obj[c] = {
+      id: c,
+      name: res.name,
+      shortName: res.short_name || null,
+      verified: res.is_verified,
+      email: res.email || null,
+      website: res.website || null,
+      follower: !!res.subscribers ? res.subscribers.summary.total_count : null,
+      lover: res.significant_other || null,
+      cover: !!res.cover ? res.cover.source : null,
+      first_name: res.first_name || null,
+      middle_name: res.middle_name || null,
+      last_name: res.last_name || null,
+      about: res.about || null,
+      birthday: res.birthday || null,
+      locale: res.locale,
+      languages: res.languages || [],
+      gender: res.gender || null,
+      hometown: !!res.hometown ? res.hometown.name : null,
+      profileUrl: res.link || null,
+      location: !!res.location ? res.location.name : null,
+      username: res.username || null,
+      avatar: !!res.picture ? res.picture.data.url : null,
+      relationship_status: !!res.relationship_status ? res.relationship_status : null,
+      subscribers: !!res.subscribers ? res.subscribers.data : null,
+      favorite_athletes: !!res.favorite_athletes ? res.favorite_athletes.map(function (v) {
+        return {
+          name: v.name
+        }
+      }) : [],
+      education: !!res.education ? res.education.map(function(v) {
+        return {
+          type: v.type,
+          school: v.school.name
+        }
+      }) : [],
+      work: !!res.work ? res.work : []
+    } : null;
+  });
+  
+  return Obj;
+}
+
+module.exports = function (http, api, ctx) {
+  function handleGetData(userIDs) {
+    var cb;
+    var uploads = [];
+    var rtPromise = new Promise(function (resolve, reject) {
+      cb = (error, data) => data ? resolve(data) : reject(error);
+    });
+
+    // Getting User Data From GraphAPI In The Loop
+    userIDs.map(function (c) {
+      var mainPromise = utils
+        .get('https://graph.facebook.com/' + c, ctx.jar, {
+          fields: 'name,is_verified,cover,first_name,email,about,birthday,gender,website,hometown,link,location,quotes,relationship_status,significant_other,username,subscribers.limite(0),short_name,last_name,middle_name,education,picture,work,languages,favorite_athletes,locale',
+          access_token: ctx.access_token
+        }, ctx.globalOptions)
+        .then(function (res) {
+          return res.body.indexOf('<') < 0 ? JSON.parse(res.body) : { data: 404 };
+        })
+        .catch(cb);
+      return uploads.push(mainPromise);
+    });
+
+    // resolve all promise
+    Promise
+      .all(uploads)
+      .then(function (userData) {
+        return cb(null, formatDataGraph(userData, userIDs));
+      })
+      .catch(function (err) {
+        return cb(err);
+      });
+ 
+    return rtPromise;
+  }
+  
+  return function getUserInfo(userIDs, useGraph, callback) {
+    var cb;
+    var rtPromise = new Promise(function (resolve, reject) {
+      cb = (error, data) => data ? resolve(data) : reject(error);
+    });
+
+    if (typeof useGraph == 'function') {
+      callback = useGraph;
+      useGraph = false;
+    }
+    if (typeof callback == 'function') cb = callback;
+    if (Array.isArray(userIDs) == false) userIDs = [userIDs];
+
+    if (useGraph) {
+      if (!ctx.access_token) {
+        var err = 'Cant get access_token, please let the "useGraph" feature is false';
+        log.error('getUserInfo', err);
+        return cb(err);
+      }
+      handleGetData(userIDs)
+        .then(function (res) {
+          return cb(null, res);
+        })
+        .catch(function (err) {
+          log.error('getUserInfo', err);
+          return cb(err);
+        });
+    } else {
+      var form = {};
+      userIDs.map(function(v, i) {
+        form["ids[" + i + "]"] = v;
+      });
+      http
+        .post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, http))
+        .then(function(res) {
+          if (res.error || res.errors) throw res;
+          return cb(null, formatData(res.payload.profiles));
+        })
+        .catch(function(err) {
+          log.error("getUserInfo", err);
+          return cb(err);
+        });
+    }
+
+    return rtPromise;
+  }
+}