rapido-fca 0.0.3 → 0.0.4

package/src/sendMessageMqtt.js

@@ -0,0 +1,322 @@
+var utils = require("../utils");
+// @NethWs3Dev
+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) {
+        console.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) {
+          console.warn(
+            "handleMention",
+            'Mention for "' + tag + '" not found in message string.',
+          );
+        }
+
+        if (mention.id == null) {
+          console.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

@@ -1,103 +1,101 @@
 "use strict";
 
 const utils = require("../utils");
-const log = require("npmlog");
+// @NethWs3Dev
 
 module.exports = function (defaultFuncs, api, ctx) {
-	function makeTypingIndicator(typ, threadID, callback, isGroup) {
-		const form = {
-			typ: +typ,
-			to: "",
-			source: "mercury-chat",
-			thread: threadID
-		};
+  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;
-					}
+    // 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);
-				}
+          return callback();
+        })
+        .catch(function (err) {
+          console.error("sendTypingIndicator", err);
+          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;
-				}
+        // 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;
-						}
+        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 callback();
+          })
+          .catch(function (err) {
+            console.error("sendTypingIndicator", err);
+            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 = () => { };
-		}
+  return function sendTypingIndicator(threadID, callback, isGroup) {
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      if (callback) {
+        console.warn(
+          "sendTypingIndicator",
+          "callback is not a function - ignoring.",
+        );
+      }
+      callback = () => {};
+    }
 
-		makeTypingIndicator(true, threadID, callback, isGroup);
+    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 = () => { };
-			}
+    return function end(cb) {
+      if (
+        utils.getType(cb) !== "Function" &&
+        utils.getType(cb) !== "AsyncFunction"
+      ) {
+        if (cb) {
+          console.warn(
+            "sendTypingIndicator",
+            "callback is not a function - ignoring.",
+          );
+        }
+        cb = () => {};
+      }
 
-			makeTypingIndicator(false, threadID, cb, isGroup);
-		};
-	};
+      makeTypingIndicator(false, threadID, cb, isGroup);
+    };
+  };
 };

package/src/sendTypingIndicatorV2.js

@@ -0,0 +1,28 @@
+"use strict";
+
+
+
+var utils = require("../utils");
+// @NethWs3Dev
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return async function sendTypingIndicatorV2(sendTyping,threadID, callback) {
+		let count_req = 0
+		var wsContent = {
+			app_id: 2220391788200892,
+			payload: JSON.stringify({
+				label: 3,
+				payload: JSON.stringify({
+					thread_key: threadID.toString(),
+					is_group_thread: +(threadID.toString().length >= 16),
+					is_typing: +sendTyping,
+					attribution: 0
+				}),
+				version: 5849951561777440
+			}),
+			request_id: ++count_req,
+			type: 4
+		};
+			await new Promise((resolve, reject) => mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => err ? reject(err) : resolve()));
+	};
+};