alicezetion 1.8.2 → 1.8.4

package/src/sendMessageMqtt.js

@@ -0,0 +1,316 @@
+var utils = require("../utils");
+var log = require("npmlog");
+var bluebird = require("bluebird");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	function uploadAttachment(attachments, callback) {
+		callback = callback || function () { };
+		var uploads = [];
+
+		// create an array of promises
+		for (var i = 0; i < attachments.length; i++) {
+			if (!utils.isReadableStream(attachments[i])) {
+				throw {
+					error:
+						"Attachment should be a readable stream and not " +
+						utils.getType(attachments[i]) +
+						"."
+				};
+			}
+
+			var form = {
+				upload_1024: attachments[i],
+				voice_clip: "true"
+			};
+
+			uploads.push(
+				defaultFuncs
+					.postFormData(
+						"https://upload.facebook.com/ajax/mercury/upload.php",
+						ctx.jar,
+						form,
+						{}
+					)
+					.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+					.then(function (resData) {
+						if (resData.error) {
+							throw resData;
+						}
+
+						// We have to return the data unformatted unless we want to change it
+						// back in sendMessage.
+						return resData.payload.metadata[0];
+					})
+			);
+		}
+
+		// resolve all promises
+		bluebird
+			.all(uploads)
+			.then(function (resData) {
+				callback(null, resData);
+			})
+			.catch(function (err) {
+				log.error("uploadAttachment", err);
+				return callback(err);
+			});
+	}
+
+	let variance = 0;
+	const epoch_id = () => Math.floor(Date.now() * (4194304 + (variance = (variance + 0.1) % 5)));
+	const emojiSizes = {
+		small: 1,
+		medium: 2,
+		large: 3
+	};
+
+	function handleEmoji(msg, form, callback, cb) {
+		if (msg.emojiSize != null && msg.emoji == null) {
+			return callback({ error: "emoji property is empty" });
+		}
+		if (msg.emoji) {
+			if (!msg.emojiSize) {
+				msg.emojiSize = "small";
+			}
+			if (
+				msg.emojiSize !== "small" &&
+				msg.emojiSize !== "medium" &&
+				msg.emojiSize !== "large" &&
+				(isNaN(msg.emojiSize) || msg.emojiSize < 1 || msg.emojiSize > 3)
+			) {
+				return callback({ error: "emojiSize property is invalid" });
+			}
+
+			form.payload.tasks[0].payload.send_type = 1;
+			form.payload.tasks[0].payload.text = msg.emoji;
+			form.payload.tasks[0].payload.hot_emoji_size = !isNaN(msg.emojiSize) ? msg.emojiSize : emojiSizes[msg.emojiSize];
+		}
+		cb();
+	}
+
+	function handleSticker(msg, form, callback, cb) {
+		if (msg.sticker) {
+			form.payload.tasks[0].payload.send_type = 2;
+			form.payload.tasks[0].payload.sticker_id = msg.sticker;
+		}
+		cb();
+	}
+
+	function handleAttachment(msg, form, callback, cb) {
+		if (msg.attachment) {
+			form.payload.tasks[0].payload.send_type = 3;
+			form.payload.tasks[0].payload.attachment_fbids = [];
+			if (form.payload.tasks[0].payload.text == "")
+				form.payload.tasks[0].payload.text = null;
+			if (utils.getType(msg.attachment) !== "Array") {
+				msg.attachment = [msg.attachment];
+			}
+
+			uploadAttachment(msg.attachment, function (err, files) {
+				if (err) {
+					return callback(err);
+				}
+
+				files.forEach(function (file) {
+					var key = Object.keys(file);
+					var type = key[0]; // image_id, file_id, etc
+					form.payload.tasks[0].payload.attachment_fbids.push(file[type]); // push the id
+				});
+				cb();
+			});
+		} else {
+			cb();
+		}
+	}
+
+
+	function handleMention(msg, form, callback, cb) {
+		if (msg.mentions) {
+			form.payload.tasks[0].payload.send_type = 1;
+
+			const arrayIds = [];
+			const arrayOffsets = [];
+			const arrayLengths = [];
+			const mention_types = [];
+
+			for (let i = 0; i < msg.mentions.length; i++) {
+				const mention = msg.mentions[i];
+
+				const tag = mention.tag;
+				if (typeof tag !== "string") {
+					return callback({ error: "Mention tags must be strings." });
+				}
+
+				const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+
+				if (offset < 0) {
+					log.warn(
+						"handleMention",
+						'Mention for "' + tag + '" not found in message string.'
+					);
+				}
+
+				if (mention.id == null) {
+					log.warn("handleMention", "Mention id should be non-null.");
+				}
+
+				const id = mention.id || 0;
+				arrayIds.push(id);
+				arrayOffsets.push(offset);
+				arrayLengths.push(tag.length);
+				mention_types.push("p");
+			}
+
+			form.payload.tasks[0].payload.mention_data = {
+				mention_ids: arrayIds.join(","),
+				mention_offsets: arrayOffsets.join(","),
+				mention_lengths: arrayLengths.join(","),
+				mention_types: mention_types.join(",")
+			};
+		}
+		cb();
+	}
+
+	function handleLocation(msg, form, callback, cb) {
+		// this is not working yet
+		if (msg.location) {
+			if (msg.location.latitude == null || msg.location.longitude == null) {
+				return callback({ error: "location property needs both latitude and longitude" });
+			}
+
+			form.payload.tasks[0].payload.send_type = 1;
+			form.payload.tasks[0].payload.location_data = {
+				coordinates: {
+					latitude: msg.location.latitude,
+					longitude: msg.location.longitude
+				},
+				is_current_location: !!msg.location.current,
+				is_live_location: !!msg.location.live
+			};
+		}
+
+		cb();
+	}
+
+	function send(form, threadID, callback, replyToMessage) {
+		if (replyToMessage) {
+			form.payload.tasks[0].payload.reply_metadata = {
+				reply_source_id: replyToMessage,
+				reply_source_type: 1,
+				reply_type: 0
+			};
+		}
+		const mqttClient = ctx.mqttClient;
+		form.payload.tasks.forEach((task) => {
+			task.payload = JSON.stringify(task.payload);
+		});
+		form.payload = JSON.stringify(form.payload);
+		console.log(global.jsonStringifyColor(form, null, 2));
+
+		return mqttClient.publish("/ls_req", JSON.stringify(form), function (err, data) {
+			if (err) {
+				console.error('Error publishing message: ', err);
+				callback(err);
+			} else {
+				console.log('Message published successfully with data: ', data);
+				callback(null, data);
+			}
+		});
+	}
+
+	return function sendMessageMqtt(msg, threadID, callback, replyToMessage) {
+		if (
+			!callback &&
+			(utils.getType(threadID) === "Function" ||
+				utils.getType(threadID) === "AsyncFunction")
+		) {
+			return threadID({ error: "Pass a threadID as a second argument." });
+		}
+		if (
+			!replyToMessage &&
+			utils.getType(callback) === "String"
+		) {
+			replyToMessage = callback;
+			callback = function () { };
+		}
+
+
+		if (!callback) {
+			callback = function (err, friendList) {
+			};
+		}
+
+		var msgType = utils.getType(msg);
+		var threadIDType = utils.getType(threadID);
+		var messageIDType = utils.getType(replyToMessage);
+
+		if (msgType !== "String" && msgType !== "Object") {
+			return callback({
+				error:
+					"Message should be of type string or object and not " + msgType + "."
+			});
+		}
+
+		if (msgType === "String") {
+			msg = { body: msg };
+		}
+
+		const timestamp = Date.now();
+		// get full date time
+		const epoch = timestamp << 22;
+		//const otid = epoch + 0; // TODO replace with randomInt(0, 2**22)
+		const otid = epoch + Math.floor(Math.random() * 4194304);
+
+		const form = {
+			app_id: "2220391788200892",
+			payload: {
+				tasks: [
+					{
+						label: "46",
+						payload: {
+							thread_id: threadID.toString(),
+							otid: otid.toString(),
+							source: 0,
+							send_type: 1,
+							sync_group: 1,
+							text: msg.body != null && msg.body != undefined ? msg.body.toString() : "",
+							initiating_source: 1,
+							skip_url_preview_gen: 0
+						},
+						queue_name: threadID.toString(),
+						task_id: 0,
+						failure_count: null
+					},
+					{
+						label: "21",
+						payload: {
+							thread_id: threadID.toString(),
+							last_read_watermark_ts: Date.now(),
+							sync_group: 1
+						},
+						queue_name: threadID.toString(),
+						task_id: 1,
+						failure_count: null
+					}
+				],
+				epoch_id: epoch_id(),
+				version_id: "6120284488008082",
+				data_trace_id: null
+			},
+			request_id: 1,
+			type: 3
+		};
+
+		handleEmoji(msg, form, callback, function () {
+			handleLocation(msg, form, callback, function () {
+				handleMention(msg, form, callback, function () {
+					handleSticker(msg, form, callback, function () {
+						handleAttachment(msg, form, callback, function () {
+							send(form, threadID, callback, replyToMessage);
+						});
+					});
+				});
+			});
+		});
+	};
+};

package/src/sendTypingIndicator.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	function makeTypingIndicator(typ, threadID, callback, isGroup) {
+		const 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
+		if (utils.getType(isGroup) == "Boolean") {
+			if (!isGroup) {
+				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);
+					if (utils.getType(err) == "Object" && err.error === "Not logged in") {
+						ctx.loggedIn = false;
+					}
+					return callback(err);
+				});
+		} else {
+			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);
+						if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
+							ctx.loggedIn = false;
+						}
+						return callback(err);
+					});
+			});
+		}
+	}
+
+	return function sendTypingIndicator(threadID, callback, isGroup) {
+		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, isGroup);
+
+		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, isGroup);
+		};
+	};
+};

package/src/setMessageReaction.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function setMessageReaction(reaction, messageID, callback, forceCustomReaction) {
+		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);
+			};
+		}
+
+		switch (reaction) {
+			case "\uD83D\uDE0D": //:heart_eyes:
+			case "\uD83D\uDE06": //:laughing:
+			case "\uD83D\uDE2E": //:open_mouth:
+			case "\uD83D\uDE22": //:cry:
+			case "\uD83D\uDE20": //:angry:
+			case "\uD83D\uDC4D": //:thumbsup:
+			case "\uD83D\uDC4E": //:thumbsdown:
+			case "\u2764": //:heart:
+			case "\uD83D\uDC97": //:glowingheart:
+			case "":
+				//valid
+				break;
+			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;
+			case ":heart:":
+				reaction = "\u2764";
+				break;
+			case ":glowingheart:":
+				reaction = "\uD83D\uDC97";
+				break;
+			default:
+				if (forceCustomReaction) {
+					break;
+				}
+				return callback({ error: "Reaction is not a valid emoji." });
+		}
+
+		const variables = {
+			data: {
+				client_mutation_id: ctx.clientMutationId++,
+				actor_id: ctx.i_userID || ctx.userID,
+				action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+				message_id: messageID,
+				reaction: reaction
+			}
+		};
+
+		const 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);
+			});
+
+		return returnPromise;
+	};
+};

package/src/setPostReaction.js

@@ -0,0 +1,109 @@
+/**
+ * @fix by NTKhang
+ * update as Thursday, 10 February 2022
+ * do not remove the author name to get more updates
+ */
+
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+function formatData(resData) {
+	return {
+		viewer_feedback_reaction_info: resData.feedback_react.feedback.viewer_feedback_reaction_info,
+		supported_reactions: resData.feedback_react.feedback.supported_reactions,
+		top_reactions: resData.feedback_react.feedback.top_reactions.edges,
+		reaction_count: resData.feedback_react.feedback.reaction_count
+	};
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function setPostReaction(postID, type, callback) {
+		let resolveFunc = function () { };
+		let rejectFunc = function () { };
+		const returnPromise = new Promise(function (resolve, reject) {
+			resolveFunc = resolve;
+			rejectFunc = reject;
+		});
+
+		if (!callback) {
+			if (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction") {
+				callback = type;
+				type = 0;
+			}
+			else {
+				callback = function (err, data) {
+					if (err) {
+						return rejectFunc(err);
+					}
+					resolveFunc(data);
+				};
+			}
+		}
+
+		const map = {
+			unlike: 0,
+			like: 1,
+			heart: 2,
+			love: 16,
+			haha: 4,
+			wow: 3,
+			sad: 7,
+			angry: 8
+		};
+
+		if (utils.getType(type) !== "Number" && utils.getType(type) === "String") {
+			type = map[type.toLowerCase()];
+		}
+
+		if (utils.getType(type) !== "Number" && utils.getType(type) !== "String") {
+			throw {
+				error: "setPostReaction: Invalid reaction type"
+			};
+		}
+
+		if (type != 0 && !type) {
+			throw {
+				error: "setPostReaction: Invalid reaction type"
+			};
+		}
+
+		const form = {
+			av: ctx.i_userID || ctx.userID,
+			fb_api_caller_class: "RelayModern",
+			fb_api_req_friendly_name: "CometUFIFeedbackReactMutation",
+			doc_id: "4769042373179384",
+			variables: JSON.stringify({
+				input: {
+					actor_id: ctx.i_userID || ctx.userID,
+					feedback_id: (new Buffer.from("feedback:" + postID)).toString("base64"),
+					feedback_reaction: type,
+					feedback_source: "OBJECT",
+					is_tracking_encrypted: true,
+					tracking: [],
+					session_id: "f7dd50dd-db6e-4598-8cd9-561d5002b423",
+					client_mutation_id: Math.round(Math.random() * 19).toString()
+				},
+				useDefaultActor: false,
+				scale: 3
+			})
+		};
+
+		defaultFuncs
+			.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+			.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+			.then(function (resData) {
+				if (resData.errors) {
+					throw resData;
+				}
+				return callback(null, formatData(resData.data));
+			})
+			.catch(function (err) {
+				log.error("setPostReaction", err);
+				return callback(err);
+			});
+
+		return returnPromise;
+	};
+};