Merge pull request #184 from CS3219-AY2425S1/collab

Collab

Author: TanPingZhi

.env.sample

@@ -22,6 +22,10 @@ EMAIL_PASSWORD=
 ## Matching service variables
 MATCHING_SVC_PORT=6969
 
+## Collab service variables
+COLLAB_SVC_PORT=3002
+COLLAB_SVC_DB_URI=
+
 ## Redis variables
 REDIS_PORT=6379
 

collab-service/.gitignore

@@ -0,0 +1 @@
+node_modules

collab-service/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": false
+}

collab-service/Dockerfile

@@ -0,0 +1,21 @@
+# Base image
+FROM node:20-alpine AS base
+WORKDIR /app
+COPY package*.json ./
+
+# Install dependencies in base stage
+RUN npm install
+
+# Development stage
+FROM base AS dev
+COPY . .
+# Run the JavaScript code directly in dev mode (useful for hot-reloading)
+CMD ["npm", "run", "dev"]
+
+# Production stage
+FROM node:20-alpine AS prod
+WORKDIR /app
+COPY --from=base /app/node_modules ./node_modules
+COPY . .
+# Start the server in production mode
+CMD ["npm", "start"]

collab-service/app/controller/collab-controller.js

@@ -0,0 +1,74 @@
+import {
+  newRoom,
+  getRoomId,
+  heartbeat,
+  getAllRooms,
+} from "../model/repository.js";
+import crypto from "crypto";
+
+// Create a room between two users
+export async function createRoom(req, res) {
+  const { user1, user2 } = req.body;
+
+  if (!user1 || !user2) {
+    return res.status(400).json({ error: "Both user1 and user2 are required" });
+  }
+
+  // Generate a unique room ID by hashing the two user IDs
+  const roomId = crypto
+    .createHash("sha256")
+    .update(user1 + user2)
+    .digest("hex");
+  const room = await newRoom(user1, user2, roomId);
+
+  if (room) {
+    res.status(201).json(room);
+  } else {
+    res.status(500).json({ error: "Failed to create room" });
+  }
+}
+
+// Get room ID by user
+export async function getRoomByUser(req, res) {
+  const { user } = req.params;
+
+  if (!user) {
+    return res.status(400).json({ error: "User is required" });
+  }
+
+  const room = await getRoomId(user);
+
+  if (room) {
+    res.status(200).json(room);
+  } else {
+    res.status(404).json({ error: `Room not found for user: ${user}` });
+  }
+}
+
+// Update heartbeat for a room
+export async function updateHeartbeat(req, res) {
+  const { roomId } = req.params;
+
+  if (!roomId) {
+    return res.status(400).json({ error: "Room ID is required" });
+  }
+
+  const updatedRoom = await heartbeat(roomId);
+
+  if (updatedRoom) {
+    res.status(200).json(updatedRoom);
+  } else {
+    res.status(404).json({ error: `Room with ID ${roomId} not found` });
+  }
+}
+
+// Get all rooms
+export async function getAllRoomsController(req, res) {
+  const rooms = await getAllRooms();
+
+  if (rooms) {
+    res.status(200).json(rooms);
+  } else {
+    res.status(500).json({ error: "Failed to retrieve rooms" });
+  }
+}

collab-service/app/index.js

@@ -0,0 +1,56 @@
+import express from "express";
+import cors from "cors";
+import collabRoutes from "./routes/collab-routes.js";
+
+const app = express();
+
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+app.use(cors()); // config cors so that front-end can use
+app.options("*", cors());
+
+// To handle CORS Errors
+app.use((req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "*"); // "*" -> Allow all links to access
+
+  res.header(
+    "Access-Control-Allow-Headers",
+    "Origin, X-Requested-With, Content-Type, Accept, Authorization"
+  );
+
+  // Browsers usually send this before PUT or POST Requests
+  if (req.method === "OPTIONS") {
+    res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, PATCH");
+    return res.status(200).json({});
+  }
+
+  // Continue Route Processing
+  next();
+});
+
+app.use("/collab", collabRoutes);
+
+app.get("/", (req, res, next) => {
+  console.log("Sending Greetings!");
+  res.json({
+    message: "Hello World from collab-service",
+  });
+});
+
+// Handle When No Route Match Is Found
+app.use((req, res, next) => {
+  const error = new Error("Route Not Found");
+  error.status = 404;
+  next(error);
+});
+
+app.use((error, req, res, next) => {
+  res.status(error.status || 500);
+  res.json({
+    error: {
+      message: error.message,
+    },
+  });
+});
+
+export default app;

collab-service/app/model/repository.js

@@ -0,0 +1,104 @@
+import { connect, mongoose } from "mongoose";
+import UsersSession from "./usersSession-model.js";
+
+export async function connectToMongo() {
+  await connect(process.env.DB_URI);
+}
+
+export async function newRoom(user1, user2, roomId) {
+  try {
+    const newRoom = new UsersSession({
+      users: [user1, user2],
+      roomId: roomId,
+      lastUpdated: new Date(),
+    });
+
+    const savedRoom = await newRoom.save();
+    return savedRoom;
+  } catch (error) {
+    console.error("Error creating room:", error);
+    return null;
+  }
+}
+
+export async function getRoomId(user) {
+  try {
+    const room = await UsersSession.findOne({ users: user });
+    return room;
+  } catch (error) {
+    console.error("Error finding room for ${user}:", error);
+    return null;
+  }
+}
+
+export async function heartbeat(roomId) {
+  try {
+    const room = await UsersSession.findOne({ roomId: roomId });
+    room.lastUpdated = new Date();
+    await room.save();
+    return room;
+  } catch (error) {
+    console.error("Error updating room ${roomId}:", error);
+    return null;
+  }
+}
+
+export async function getAllRooms() {
+  try {
+    const rooms = await UsersSession.find({});
+    return rooms;
+  } catch (error) {
+    console.error("Error getting all rooms:", error);
+    return null;
+  }
+}
+
+// Function to add a new message to chatHistory with transaction support
+export async function addMessageToChat(roomId, userId, text) {
+  // Start a session for the transaction
+  const session = await mongoose.startSession();
+
+  try {
+    session.startTransaction();
+
+    // Find the session document by roomId within the transaction
+    const sessionDoc = await UsersSession.findOne({ roomId }).session(session);
+
+    if (!sessionDoc) {
+      throw new Error("Room not found");
+    }
+
+    // Determine the next message index within the transaction
+    const lastMessageIndex =
+      sessionDoc.chatHistory.length > 0
+        ? sessionDoc.chatHistory[sessionDoc.chatHistory.length - 1].messageIndex
+        : -1;
+
+    // Create the new message with incremented messageIndex
+    const newMessage = {
+      messageIndex: lastMessageIndex + 1,
+      userId,
+      text,
+      timestamp: new Date(),
+    };
+
+    // Add the new message to chatHistory within the transaction
+    sessionDoc.chatHistory.push(newMessage);
+
+    // Save the document within the transaction
+    await sessionDoc.save({ session });
+
+    // Commit the transaction
+    await session.commitTransaction();
+
+    // End the session and return the new message
+    session.endSession();
+    return newMessage;
+  } catch (error) {
+    // If an error occurs, abort the transaction
+    await session.abortTransaction();
+    session.endSession();
+    console.error("Error adding message to chat:", error);
+    throw error;
+  }
+}

collab-service/app/model/usersSession-model.js

@@ -0,0 +1,45 @@
+import mongoose from "mongoose";
+
+const Schema = mongoose.Schema;
+
+const messageSchema = new Schema({
+  messageIndex: {
+    type: Number,
+    required: true,
+  },
+  userId: {
+    type: String,
+    required: true,
+  },
+  text: {
+    type: String,
+    required: true,
+  },
+  // timestamp: {
+  //   type: Date,
+  //   default: Date.now,
+  //   required: true
+  // }
+});
+
+const usersSessionSchema = new Schema({
+  users: {
+    type: [String],
+    required: true,
+  },
+  roomId: {
+    type: String,
+    required: true,
+  },
+  lastUpdated: {
+    type: Date,
+    required: true,
+    default: Date.now,
+  },
+  chatHistory: {
+    type: [messageSchema],
+    default: [],
+  },
+});
+
+export default mongoose.model("UsersSession", usersSessionSchema);

collab-service/app/routes/collab-routes.js

@@ -0,0 +1,19 @@
+import express from "express";
+import {
+  createRoom,
+  getRoomByUser,
+  updateHeartbeat,
+  getAllRoomsController,
+} from "../controller/collab-controller.js";
+
+const router = express.Router();
+
+router.post("/create-room", createRoom);
+
+router.get("/user/:user", getRoomByUser);
+
+router.patch("/heartbeat/:roomId", updateHeartbeat);
+
+router.get("/rooms", getAllRoomsController);
+
+export default router;

collab-service/app/server.js

@@ -0,0 +1,50 @@
+import { connectToMongo } from "./model/repository.js";
+import http from "http";
+import index from "./index.js";
+import { Server } from "socket.io";
+import { addMessageToChat } from "./model/repository.js";
+
+const PORT = process.env.PORT || 3002;
+const server = http.createServer(index);
+
+const io = new Server(server, {
+  cors: {
+    origin: "*", // Allow all origins; replace with specific origin if needed
+    methods: ["GET", "POST"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    credentials: true,
+  },
+});
+
+io.on("connection", (socket) => {
+  console.log("User connected to Socket.IO");
+
+  // Join a room based on roomId
+  socket.on("joinRoom", (roomId) => {
+    socket.join(roomId);
+    console.log(`User joined room: ${roomId}`);
+  });
+
+  // Handle incoming chat messages
+  socket.on("sendMessage", async (data) => {
+    const { roomId, userId, text } = data;
+    const newMessage = await addMessageToChat(roomId, userId, text);
+
+    // Broadcast the message to all clients in the same room
+    io.to(roomId).emit("chatMessage", newMessage);
+  });
+
+  socket.on("disconnect", () => {
+    console.log("User disconnected from Socket.IO");
+  });
+});
+
+connectToMongo()
+  .then(() => {
+    server.listen(PORT, () => {
+      console.log(`Server running on http://localhost:${PORT}`);
+    });
+  })
+  .catch((error) => {
+    console.error("Error connecting to MongoDB:", error);
+  });