added new endpoint for marking the message as seen + added new field for the message model seenBy array holding the emails who seeing the message!

Author: BishoySedra

src/controllers/message.js

@@ -53,3 +53,20 @@ export const deleteMessage = async (req, res, next) => {
     next(error);
   }
 };
+
+export const markMessageAsSeen = async (req, res, next) => {
+  try {
+    const { email, chatID, messageID } = req.params;
+    await authorize(req, res, next, email);
+    await MessageService.markMessageAsSeen(email, chatID, messageID);
+    return res
+      .status(200)
+      .json({
+        body: null,
+        message: "Message marked as seen successfully",
+        status: 200,
+      });
+  } catch (error) {
+    next(error);
+  }
+};

src/db/models/message.js

@@ -36,6 +36,10 @@ const messageSchema = new Schema({
         type: Object,
         default: null,
     },
+    seenBy: {
+        type: [String],
+        default: [],
+    },
 },
     { timestamps: true }
 );

src/helpers/sockets.js

@@ -4,6 +4,7 @@ dotenv.config();
 export let loggedInUsers = []//{email: [array of socket ids]}
 let io
 
+console.log(loggedInUsers);
 
 const addLoggedInUser = (email, socketId) => {
   const user = loggedInUsers.find(user => user.email === email)
@@ -43,10 +44,15 @@ export const socketConnection = (server) => {
 
     socket.on("successfulLogin", ({ email }) => {
       addLoggedInUser(email, socket.id);
+      console.log(loggedInUsers);
+
     });
-    socket.on("succesfulLogout", ({ email }) => {
+
+    socket.on("successfulLogout", ({ email }) => {
       removeLoggedInUser(email, socket.id);
+      console.log(loggedInUsers);
     });
+
     socket.on("disconnect", () => {
       loggedInUsers = loggedInUsers
         .map((user) => {
@@ -55,5 +61,28 @@ export const socketConnection = (server) => {
         })
         .filter((user) => user.socketId.length > 0);
     });
+
+    // // Handle message seen event
+    // socket.on("messageSeen", ({ chatID, messageID, email }) => {
+    //   // Notify other users in the chat that the message has been seen
+    //   const user = loggedInUsers.find(user => user.email === email);
+    //   if (user) {
+    //     user.socketId.forEach((receiverSocket) => {
+    //       io.to(receiverSocket).emit("messageSeen", { chatID, messageID });
+    //     });
+    //   }
+    // });
+
+    // // Handle typing status event
+    // socket.on("typingStatus", ({ chatID, email, isTyping }) => {
+    //   // Broadcast typing status to other users in the chat
+    //   const user = loggedInUsers.find(user => user.email === email);
+    //   if (user) {
+    //     user.socketId.forEach((receiverSocket) => {
+    //       io.to(receiverSocket).emit("typingStatus", { chatID, email, isTyping });
+    //     });
+    //   }
+    // });
+
   });
 };

src/middlewares/validator/schemas/userSchema.js

@@ -204,4 +204,23 @@ export const chatIDSchema = Joi.object({
     "string.empty": "Chat ID cannot be empty",
     "any.required": "Chat ID is required",
   }),
+});
+
+export const markMessageAsSeenURLSchema = Joi.object({
+  email: Joi.string().email().required().messages({
+    "string.base": "Sender email must be a string",
+    "string.empty": "Sender email cannot be empty",
+    "string.email": "Sender email must be a valid email",
+    "any.required": "Sender email is required",
+  }),
+  chatID: Joi.string().required().messages({
+    "string.base": "Chat ID must be a string",
+    "string.empty": "Chat ID cannot be empty",
+    "any.required": "Chat ID is required",
+  }),
+  messageID: Joi.string().required().messages({
+    "string.base": "Message ID must be a string",
+    "string.empty": "Message ID cannot be empty",
+    "any.required": "Message ID is required",
+  }),
 });

src/routes/message.js

@@ -151,5 +151,62 @@ router.delete(
     messageController.deleteMessage                  // Controller to handle the logic
 );
 
+/**
+ * @swagger
+ * /mark-as-seen/{email}/{chatID}/{messageID}:
+ *   patch:
+ *     summary: Mark a message as seen in a chat
+ *     tags: [Messages]
+ *     parameters:
+ *       - in: path
+ *         name: email
+ *         schema:
+ *           type: string
+ *         required: true
+ *         description: Email of the user marking the message as seen
+ *       - in: path
+ *         name: chatID
+ *         schema:
+ *           type: string
+ *         required: true
+ *         description: ID of the chat containing the message
+ *       - in: path
+ *         name: messageID
+ *         schema:
+ *           type: string
+ *         required: true
+ *         description: ID of the message to mark as seen
+ *     responses:
+ *       200:
+ *         description: Message marked as seen successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 chatID:
+ *                   type: string
+ *                   description: ID of the chat
+ *                 messageID:
+ *                   type: string
+ *                   description: ID of the message marked as seen
+ *                 seenBy:
+ *                   type: array
+ *                   items:
+ *                     type: string
+ *                   description: List of users who have seen the message
+ *       404:
+ *         description: Chat or message not found
+ *       400:
+ *         description: Invalid input
+ */
+
+// Route to handle marking a message as seen
+router.patch(
+    "/mark-as-seen/:email/:chatID/:messageID",
+    validate(schemas.markMessageAsSeenURLSchema, false), // Validate URL parameters
+    messageController.markMessageAsSeen                 // Controller to handle the logic
+);
+
 // Export the router to be used in the application
 export default router;

src/services/chat.js

@@ -105,7 +105,6 @@ export const addUserToGroupChat = async (adminEmail, userEmail, chatID) => {
   await chat.save();
 };
 
-
 export const getUserGroupChats = async (email, token) => {
   const user = await User.findOne({ email: email });
   if (!user)
@@ -118,7 +117,6 @@ export const getUserGroupChats = async (email, token) => {
   return chats;
 }
 
-
 export const getGroupChatDetails = async (id, token) => {
   // check if chat_id is valid mongoose
   if (!mongoose.isValidObjectId(id)) {
@@ -153,3 +151,23 @@ export const deleteGroupChat = async (adminEmail, chatID) => {
   await chat.deleteOne();
   await groupChat.deleteOne();
 };
+
+export const updateTypingStatus = async (email, chatID, isTyping) => {
+  // Validate the chat
+  const chat = await Chat.findOne({ _id: chatID });
+  if (!chat) {
+    throw createCustomError("Chat not found!", 404, null);
+  }
+
+  // Emit the "typingStatus" event to notify other users
+  const receiversEmails = chat.users.filter((user) => user !== email);
+  receiversEmails.forEach((receiverEmail) => {
+    sockets.sendToOnlineReceivers(
+      { chatID, email, isTyping },
+      receiverEmail,
+      "typingStatus"
+    );
+  });
+
+  return { chatID, email, isTyping };
+};

src/services/message.js

@@ -152,10 +152,36 @@ export const deleteMessage = async (senderEmail, chatID, messageID) => {
   await chat.save();
 };
 
-const findMessageById = async (messageID) => {
-  let message = await Message.findById(messageID).select("-__v -createdAt -updatedAt");
+export const markMessageAsSeen = async (email, chatID, messageID) => {
+
+  // Find the chat
+  const chat = await Chat.findOne({ _id: chatID });
+
+  if (!chat) {
+    throw createCustomError("Chat not found!", 404, null);
+  }
+
+  // Find the message in the chat
+  const message = chat.messages.find((msg) => msg._id.toString() === messageID);
+
   if (!message) {
     throw createCustomError("Message not found!", 404, null);
   }
+
+  // Mark the message as seen
+  if (!message.seenBy.includes(email)) {
+    message.seenBy.push(email);
+  }
+
+  // Save the updated chat
+  await chat.save();
+
+  // Emit the "messageSeen" event to notify other users
+  sockets.sendToOnlineReceivers(
+    { chatID, messageID },
+    email,
+    "messageSeen"
+  );
+
   return message;
-}
+};