@dongdev/fca-unofficial 0.0.9 → 1.0.1

package/README.md

@@ -12,15 +12,13 @@ _Disclaimer_: We are not responsible if your account gets banned for spammy acti
 
 If you encounter errors on fca, you can contact me [here](https://www.facebook.com/minhdong.dev)
 
-`</div>`
-
 Facebook now has an official API for chat bots [here](https://developers.facebook.com/docs/messenger-platform).
 
 This API is the only way to automate chat functionalities on a user account. We do this by emulating the browser. This means doing the exact same GET/POST requests and tricking Facebook into thinking we're accessing the website normally. Because we're doing it this way, this API won't work with an auth token but requires the credentials of a Facebook account.
 
 ## Install
 
-If you just want to use ws3-fca, you should use this command:
+If you just want to use @dongdev/fca-unofficial, you should use this command:
 
 ```bash
 npm install @dongdev/fca-unofficial@latest
@@ -31,19 +29,19 @@ It will download @dongdev/fca-unofficial from NPM repositories
 ## Example Usage
 
 ```javascript
+
 const login = require("@dongdev/fca-unofficial");
 
-// Create simple echo bot
-login({
-  appState: []
-}, {
-    //setOptions will be here
-} (err, api) => {
-    if (err) return utils.error(err);
+login({ appState: [] }, (err, api) => {
+    if (err) return console.error(err);
+
     api.listenMqtt((err, event) => {
+        if (err) return console.error(err);
+
         api.sendMessage(event.body, event.threadID);
     });
 });
+
 ```
 
 Result:
@@ -73,35 +71,55 @@ __Example (Basic Message)__
 ```js
 const login = require("@dongdev/fca-unofficial");
 
-login({ 
-    appState: []
-}, (err, api) => {
-    if(err) return console.error(err);
+login({ appState: [] }, (err, api) => {
+    if (err) {
+        console.error("Login Error:", err);
+        return;
+    }
 
-    var yourID = "000000000000000";
-    var msg = "Hey!";
-    api.sendMessage(msg, yourID);
+    let yourID = "000000000000000"; // Replace with actual Facebook ID
+    let msg = "Hey!";
+  
+    api.sendMessage(msg, yourID, (err) => {
+        if (err) console.error("Message Sending Error:", err);
+        else console.log("Message sent successfully!");
+    });
 });
+
 ```
 
 __Example (File upload)__
 
 ```js
 const login = require("@dongdev/fca-unofficial");
+const fs = require("fs"); // ✅ Required the fs module
+
+login({ appState: [] }, (err, api) => {
+    if (err) {
+        console.error("Login Error:", err);
+        return;
+    }
 
-login({ 
-    appState: []
-}, (err, api) => {
-    if(err) return console.error(err);
+    let yourID = "000000000000000"; // Replace with actual Facebook ID
+    let imagePath = __dirname + "/image.jpg";
 
-    // Note this example uploads an image called image.jpg
-    var yourID = "000000000000000";
-    var msg = {
-        body: "Hey!",
-        attachment: fs.createReadStream(__dirname + '/image.jpg')
+    // Check if the file exists before sending
+    if (!fs.existsSync(imagePath)) {
+        console.error("Error: Image file not found!");
+        return;
     }
-    api.sendMessage(msg, yourID);
+
+    let msg = {
+        body: "Hey!",
+        attachment: fs.createReadStream(imagePath)
+    };
+
+    api.sendMessage(msg, yourID, (err) => {
+        if (err) console.error("Message Sending Error:", err);
+        else console.log("Message sent successfully!");
+    });
 });
+
 ```
 
 ---
@@ -116,15 +134,23 @@ __Example__
 const fs = require("fs");
 const login = require("@dongdev/fca-unofficial");
 
-var credentials = { 
-    appState: []
-};
+const credentials = { appState: [] };
 
 login(credentials, (err, api) => {
-    if(err) return console.error(err);
+    if (err) {
+        console.error("Login Error:", err);
+        return;
+    }
 
-    fs.writeFileSync('appstate.json', JSON.stringify(api.getAppState()));
+    try {
+        const appState = JSON.stringify(api.getAppState(), null, 2); // Pretty print for readability
+        fs.writeFileSync("appstate.json", appState);
+        console.log("✅ AppState saved successfully!");
+    } catch (error) {
+        console.error("Error saving AppState:", error);
+    }
 });
+
 ```
 
 Alternative: Use [c3c-fbstate](https://github.com/c3cbot/c3c-fbstate) to get fbstate.json (appstate.json)
@@ -143,34 +169,44 @@ __Example__
 const fs = require("fs");
 const login = require("@dongdev/fca-unofficial");
 
-// Simple echo bot. It will repeat everything that you say.
-// Will stop when you say '/stop'
-login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
-    if(err) return console.error(err);
+// Simple echo bot: Repeats everything you say. Stops when you say "/stop".
+login({ appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) }, (err, api) => {
+    if (err) {
+        console.error("Login Error:", err);
+        return;
+    }
 
-    api.setOptions({listenEvents: true});
+    api.setOptions({ listenEvents: true });
 
-    var stopListening = api.listenMqtt((err, event) => {
-        if( err) return console.error(err);
+    const stopListening = api.listenMqtt((err, event) => {
+        if (err) {
+            console.error("Listen Error:", err);
+            return;
+        }
 
+        // Mark message as read
         api.markAsRead(event.threadID, (err) => {
-            if(err) console.error(err);
+            if (err) console.error("Mark as read error:", err);
         });
 
-        switch(event.type) {
+        // Handle different event types
+        switch (event.type) {
             case "message":
-                if(event.body === '/stop') {
+                if (event.body && event.body.trim().toLowerCase() === "/stop") {
                     api.sendMessage("Goodbye…", event.threadID);
-                    return stopListening();
+                    stopListening();
+                    return;
                 }
-                api.sendMessage("TEST BOT: " + event.body, event.threadID);
+                api.sendMessage(`TEST BOT: ${event.body}`, event.threadID);
                 break;
+
             case "event":
-                console.log(event);
+                console.log("Event Received:", event);
                 break;
         }
     });
 });
+
 ```
 
 `<a name="projects-using-this-api"></a>`

package/index.js

@@ -130,33 +130,18 @@ function setOptions(globalOptions, options) {
   });
 }
 function buildAPI(globalOptions, html, jar) {
-  const maybeCookie = jar
-    .getCookies("https://www.facebook.com")
-    .filter(function(val) {
-      return val.cookieString().split("=")[0] === "c_user";
-    });
-  const objCookie = jar
-    .getCookies("https://www.facebook.com")
-    .reduce(function(obj, val) {
-      obj[val.cookieString().split("=")[0]] = val.cookieString().split("=")[1];
-      return obj;
-    }, {});
-  if (maybeCookie.length === 0) {
-    throw {
-      error:
-        "Error retrieving userID. This can be caused by a lot of things, including getting blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.",
-    };
-  }
-  if (html.indexOf("/checkpoint/block/?next") > -1 || html.indexOf("/checkpoint/?next") > -1) {
-    throw {
-      error: "Checkpoint detected. Please log in with a browser to verify.", 
-    }
+  const cookies = jar.getCookies("https://www.facebook.com");
+  const userCookie = cookies.find(c => c.cookieString().startsWith("c_user="));
+  const tiktikCookie = cookies.find(c => c.cookieString().startsWith("i_user="));
+  if (userCookie.length === 0 && tiktikCookie.length === 0) {
+    return log.error('login', "Không tìm thấy cookie cho người dùng, vui lòng kiểm tra lại thông tin đăng nhập")
+  } else if (!userCookie && !tiktikCookie) {
+    return log.error('login', "Không tìm thấy cookie cho người dùng, vui lòng kiểm tra lại thông tin đăng nhập")
+  } else if (html.includes("/checkpoint/block/?next")) {
+    return log.error('login', "Appstate die, vui lòng thay cái mới!", 'error');
   }
-  const userID = maybeCookie[0]
-    .cookieString()
-    .split("=")[1]
-    .toString();
-  const i_userID = objCookie.i_user || null;
+  const userID = (tiktikCookie || userCookie).cookieString().split("=")[1];
+  const i_userID = tiktikCookie ? tiktikCookie.cookieString().split("=")[1] : null;
   logger(`Logged in as ${userID}`, 'info');
   try {
     clearInterval(checkVerified);
@@ -204,6 +189,8 @@ function buildAPI(globalOptions, html, jar) {
     region,
     firstListen: true,
     fb_dtsg,
+    wsReqNumber: 0,
+    wsTaskNumber: 0
   };
   const api = {
     setOptions: setOptions.bind(null, globalOptions),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "0.0.9",
+  "version": "1.0.1",
   "description": "A Facebook chat API without XMPP, will not be deprecated after April 30th, 2015.",
   "main": "index.js",
   "repository": {
@@ -22,6 +22,7 @@
     "request": "^2.53.0",
     "sequelize": "^6.37.6",
     "sqlite3": "^5.1.7",
+    "totp-generator": "^1.0.0",
     "ws": "^8.18.1"
   },
   "devDependencies": {

package/src/getThreadInfo.js

@@ -1,5 +1,5 @@
 "use strict";
-
+/*
 const utils = require("../utils");
 const log = require("npmlog");
 const fs = require("fs");
@@ -299,4 +299,237 @@ module.exports = function(defaultFuncs, api, ctx) {
     }
     return returnPromise;
   };
+};
+*/
+"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(data) {
+	if (data.errors)
+		return data.errors;
+	const messageThread = data.message_thread;
+	if (!messageThread)
+		return null;
+	const threadID = messageThread.thread_key.thread_fbid
+		? messageThread.thread_key.thread_fbid
+		: messageThread.thread_key.other_user_id;
+
+	// Remove me
+	const lastM = messageThread.last_message;
+	const 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;
+	const snippetText =
+		lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+	const lastR = messageThread.last_read_receipt;
+	const 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
+		}
+	};
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function getThreadInfoGraphQL(threadID, callback) {
+		let resolveFunc = function () { };
+		let rejectFunc = function () { };
+		const 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);
+			};
+		}
+
+		if (utils.getType(threadID) !== "Array") {
+			threadID = [threadID];
+		}
+
+		let 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.
+		threadID.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
+				}
+			};
+		});
+
+		form = {
+			queries: JSON.stringify(form),
+			batch_name: "MessengerGraphQLThreadFetcher"
+		};
+
+		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) {
+					callback(null, Object.values(threadInfos)[0]);
+				}
+				else {
+					callback(null, threadInfos);
+				}
+			})
+			.catch(function (err) {
+				log.error("getThreadInfoGraphQL", err);
+				return callback(err);
+			});
+
+		return returnPromise;
+	};
 };

package/src/setMessageReaction.js

@@ -1,117 +1,119 @@
 "use strict";
 
-const utils = require("../utils");
-const log = require("npmlog");
+var utils = require("../utils");
+var log = require("npmlog");
+const { generateOfflineThreadingID } = require("../utils");
 
 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;
-		});
+  function setMessageReactionNoMqtt(reaction, messageID, callback) {
+    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 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);
+      });
 
-		if (!callback) {
-			callback = function (err, friendList) {
-				if (err) {
-					return rejectFunc(err);
-				}
-				resolveFunc(friendList);
-			};
-		}
+    return returnPromise;
+  }
 
-		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;
-	};
-};
+  function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    ctx.wsReqNumber += 1;
+    let taskNumber = ++ctx.wsTaskNumber;
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: getCurrentTimestamp(),
+      message_id: messageID,
+      reaction: reaction,
+      actor_id: ctx.userID,
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289,
+    };
+    const task = {
+      failure_count: null,
+      label: "29",
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(["reaction", messageID]),
+      task_id: taskNumber,
+    };
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: "7158486590867448",
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    if (typeof callback === "function") {
+      ctx["tasks"].set(taskNumber, {
+        type: "set_message_reaction",
+        callback: callback,
+      });
+    }
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+      qos: 1,
+      retain: false,
+    });
+  }
+  return function setMessageReaction(reaction, messageID, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        setMessageReactionMqtt(reaction, messageID, threadID, callback);
+        callback();
+      } catch (e) {
+        setMessageReactionNoMqtt(reaction, messageID, callback);
+      }
+    } else {
+      setMessageReactionNoMqtt(reaction, messageID, callback);
+    }
+  };
+};