wip: refacor sockets

helpers/buffer.js

@@ -0,0 +1,23 @@
+const messageBuffer = {
+  jz0ahj: [
+    {
+      chatId: "-388078727",
+      name: "jim",
+      text: "helloo",
+      from: "jims",
+      adminName: "admin",
+    },
+  ],
+};
+
+module.exports.getMessages = function getMessages(userId) {
+  return messageBuffer[userId] || [];
+};
+
+module.exports.getMessageCount = function getMessageCount(userId) {
+  return messageBuffer[userId] ? messageBuffer[userId].length : 0;
+};
+
+module.exports.deleteBuffer = function deleteBuffer(userId) {
+  delete messageBuffer[userId];
+};

helpers/socket.js

@@ -0,0 +1,214 @@
+const { getMessages, deleteBuffer } = require("./buffer");
+const { sendMessageToTelegram, sendTypingAction } = require("./telegram");
+const socketIo = require("socket.io");
+
+const connectedSockets = {};
+
+module.exports.createSocketServer = function createSocketServer(server) {
+  const io = socketIo(server);
+
+  io.on("connection", (socket) => {
+    socket.on("register", async function (registerMsg) {
+      const { isNewUser, chatId, userId, oldId, userData, currentUrl } =
+        registerMsg;
+      console.info("a user connected", userId);
+      socket.userId = userId;
+      socket.userData = userData;
+      connectedSockets[userId] = socket;
+      const messages = getMessages(userId);
+
+      if (messages.length) {
+        console.info(`${userId} has ${messages.length} messages in the buffer`);
+        for (let msg of messages) {
+          const { chatId, name, text, from, adminName } = msg;
+          console.info("sending buffered message to user", text);
+          socket.emit(chatId + "-" + userId, {
+            name,
+            text,
+            from,
+            adminName,
+          });
+        }
+        deleteBuffer(userId);
+      }
+    });
+
+    socket.on("message", (data) => {
+      if (!connectedSockets[socket.userId]) {
+        console.log(
+          `Message received on disconnected socket - ${socket.userId}`
+        );
+        connectedSockets[socket.userId] = socket;
+      }
+      const { action, msg } = data;
+      console.log("Message received:", data);
+      if (action === "typing") {
+        sendTypingAction();
+      } else if (action === "message") {
+        connectedSockets[socket.userId].messageReceived = true;
+        const text = `[${socket.userId}]: ${socket.userData?.email}\n${data.msg.text}`;
+        sendMessageToTelegram(text);
+      }
+    });
+
+    socket.on("disconnect", () => {
+      if (connectedSockets[socket.userId].messageReceived) {
+        sendTelegramMessage(chatId, socket.userId + " has left");
+      }
+      delete connectedSockets[socket.userId];
+    });
+  });
+};
+
+// export function sendMessageToUser({ chatId, userId, message }) {
+//   const { name, text, from } = message;
+//   // check if connected, if not then buffer
+//   if (connectedSockets[userId]) {
+//     console.log("client connected sending message");
+//     const sock = connectedSockets[userId];
+//     sock.emit(chatId + "-" + userId, {
+//       name,
+//       text,
+//       from: "admin",
+//       adminName: from,
+//     });
+//   } else {
+//     if (!messageBuffer[userId]) {
+//       messageBuffer[userId] = [];
+//     }
+//     console.log("client not connected buffering message");
+//     messageBuffer[userId].unshift({
+//       chatId,
+//       name,
+//       text,
+//       from: "admin",
+//       adminName: from,
+//     });
+//   }
+// }
+
+// export async function onConnectionStart(client) {
+//   client.on("register", async function (registerMsg) {
+//     const { isNewUser, chatId, userId, oldId, userData, currentUrl } =
+//       registerMsg;
+//     console.log("register user", userId);
+//     connectedSockets[userId] = client;
+//     let messageReceived = false;
+//     // check the buffer and send anything in there
+//     if (messageBuffer[userId]) {
+//       const buffered = messageBuffer[userId];
+//       let msg = buffered.pop();
+//       console.log(`sending ${buffered.length} buffered messages`);
+//       while (msg) {
+//         const { chatId, name, text, from, adminName } = msg;
+//         client.emit(chatId + "-" + userId, {
+//           name,
+//           text,
+//           from,
+//           adminName,
+//         });
+//         msg = buffered.pop();
+//       }
+//       delete messageBuffer[userId];
+//     }
+
+//     console.log("userId " + userId + " connected to chatId " + chatId);
+
+//     if (oldId) {
+//       await sendMessage(
+//         chatId,
+//         userId,
+//         `Lead ${oldId} has logged in as ${userData.email}`
+//       );
+//       await sendStartMessage(chatId, { ...userData, currentUrl });
+//     }
+
+//     client.on("message", async function (data) {
+//       if (data.action === "typing") {
+//         return setTyping(chatId);
+//       }
+//       const { msg } = data;
+//       if (isNewUser && !messageReceived) {
+//         // enrich user data
+//         await sendStartMessage(chatId, {
+//           ...userData,
+//           currentUrl,
+//         });
+//       }
+
+//       messageReceived = true;
+//       client.emit(chatId + "-" + userId, msg);
+//       return sendMessage(
+//         chatId,
+//         userId,
+//         msg.text,
+//         userData ? userData.email : ""
+//       );
+//     });
+
+//     client.on("disconnect", function () {
+//       if (messageReceived) {
+//         sendTelegramMessage(chatId, userId + " has left");
+//       }
+//       delete connectedSockets[userId];
+//     });
+//   });
+// }
+
+// function sendStartMessage(chatId, userData = {}) {
+//   const { id, email, currentUrl } = userData;
+//   console.log(userData);
+//   const isLead = !email;
+//   let text = "";
+
+//   if (isLead) {
+//     text = `<b>New Lead</b>
+// <b>URL:</b>\t ${currentUrl || "unknown"}
+// `;
+//   } else {
+//     text = `A user has started a chat.
+// <b>ID:</b>\t ${id}
+// <b>Email:</b>\t ${email}
+// <b>URL:</b>\t ${currentUrl || "unknown"}
+// <b>Stripe:</b>\t https://dashboard.stripe.com/search?query=${email}
+// `;
+//   }
+//   text = `${text}`;
+//   return sendTelegramMessage(chatId, text, "HTML");
+// }
+
+// function sendMessage(chatId, userId, text, email = "") {
+//   return sendTelegramMessage(
+//     chatId,
+//     `<b>[${userId}]</b> ${email}:\n${text}`,
+//     "HTML"
+//   );
+// }
+
+// function setTyping(chatId) {
+//   return new Promise((resolve, reject) => {
+//     request
+//       .post(
+//         "https://api.telegram.org/bot" +
+//           process.env.TELEGRAM_TOKEN +
+//           "/sendChatAction",
+//         function (err, resp, body) {
+//           if (err) {
+//             console.error(err);
+//             return reject(err);
+//           }
+//           resolve(body);
+//         }
+//       )
+//       .form({
+//         chat_id: chatId,
+//         action: "typing",
+//       });
+//   });
+// }
+
+// export function connectSocket(http) {
+//   const io = require("socket.io")(http);
+//   // handle chat visitors websocket messages
+//   io.on("connection", onConnectionStart);
+// }

helpers/telegram.js

@@ -0,0 +1,28 @@
+const { Telegraf } = require("telegraf");
+
+const bot = new Telegraf(process.env.TELEGRAM_TOKEN);
+const channelId = process.env.CHANNEL_ID;
+
+bot.on("message", (ctx) => {
+  console.log(`Message in group: ${ctx.message.text}`);
+  if (ctx.chat.type === "group" || ctx.chat.type === "supergroup") {
+    console.log(`Message in group: ${ctx.message.text}`);
+    // Add your logic here
+  }
+});
+
+module.exports.sendMessageToTelegram = function sendMessageToTelegram(message) {
+  bot.telegram.sendMessage(channelId, message);
+};
+
+module.exports.sendTypingAction = function sendTypingAction() {
+  bot.telegram.sendChatAction(channelId, "typing");
+};
+
+module.exports.startBot = function startBot() {
+  bot.launch();
+  console.info("Launched Squarechat.");
+};
+
+process.once("SIGINT", () => bot.stop("SIGINT"));
+process.once("SIGTERM", () => bot.stop("SIGTERM"));

index.js

@@ -0,0 +1,39 @@
+const express = require("express");
+const { Telegraf } = require("telegraf");
+const http = require("http");
+
+const cors = require("cors");
+const { sendMessageToTelegram, startBot } = require("./helpers/telegram");
+const { getMessageCount } = require("./helpers/buffer");
+const { createSocketServer } = require("./helpers/socket");
+
+const { PORT } = process.env;
+
+const app = express();
+const server = http.createServer(app);
+
+createSocketServer(server);
+
+app.post("/usage-start", cors(), function (req, res) {
+  console.log("usage from", req.query.host);
+  const unreadCount = getMessageCount(req.query.userId);
+  res.status(200).send(unreadCount.toString());
+});
+
+app.post("/unreads", cors(), function (req, res) {
+  const unreadCount = getMessageCount(req.query.userId);
+  res.status(200).send(unreadCount.toString());
+});
+
+// left here until the cache expires
+app.post("/usage-end", cors(), function (req, res) {
+  res.statusCode = 200;
+  res.end();
+});
+
+app.use(express.static("dist"));
+
+server.listen(PORT, () => {
+  console.log(`Server is running on port ${PORT}`);
+});
+startBot();

package.json

@@ -36,9 +36,10 @@
     "preact": "^7.1.0",
     "request": "^2.79.0",
     "shx": "^0.2.2",
-    "socket.io": "^1.7.3",
-    "socket.io-client": "^1.7.3",
+    "socket.io": "^4.8.0",
+    "socket.io-client": "^4.8.0",
     "store": "^1.3.20",
+    "telegraf": "^4.16.3",
     "webpack": "^1.14.0"
   }
 }