Merge pull request #46 from CS3219-AY2324S1/refactor-backend

Refactor backend

Author: charltonator

backend/package-lock.json

@@ -14,7 +14,10 @@
     "dotenv": "^16.3.1",
     "express": "~4.16.1",
     "firebase": "^10.4.0",
-    "http-errors": "~1.6.3"
+    "firebase-admin": "^11.11.0",
+    "http": "^0.0.1-security",
+    "http-errors": "~1.6.3",
+    "socket.io": "^4.7.2"
   },
   "devDependencies": {
     "@types/express": "^4.17.18",

backend/package.json

@@ -6,22 +6,51 @@ import {
   handleSignUp,
 } from "./auth/auth.controller";
 import { handleCreateUser, handleGetUser } from "./user/user.controller";
+import { initializeApp } from 'firebase/app';
+import { getFirestore } from 'firebase/firestore';
+import { firebaseConfig } from "./firebase/firebase.config";
+import { initializeMatchingService } from './matching/matching.service'; // Import the matching service function
+import { Socket, Server } from 'socket.io';
+import { Server as ServerHttp } from 'http';
+import { handleCreateUser, handleGetUser, handleUpdateUser } from "./user/user.controller";
 const app = express();
 const port = 3001;
-
 app.use(cors());
 app.use(express.json());
 
+const httpServer = new ServerHttp(app);
+const io = new Server(httpServer, {
+  cors: {
+    origin: '*',
+  },
+}); 
+
 app.get("/", (req, res) => {
   res.send("Hello World!");
 });
 
+// Initialize Firebase Firestore and other configurations here
+initializeApp(firebaseConfig);
+const db = getFirestore();
+
 app.post("/signup", handleSignUp);
 app.post("/login", handleLogin);
 app.delete("/logout", handleLogout);
 app.post("/user", handleCreateUser);
 app.get("/user", handleGetUser);
+app.put("/user", handleUpdateUser);
+
+//Socket logic
+// Maintain an array to store active users seeking a match
+const activeUsers: { socket: Socket; preferences: any }[] = [];
+
+// Initialize the matching service by passing the io object
+initializeMatchingService(io);
+
+// httpServer.listen(socketPort, () => {
+//   console.log(`socket listening on port ${socketPort}`);
+// });
 
-app.listen(port, () => {
+httpServer.listen(port, () => {
   console.log(`Peerprep listening on port ${port}`);
 });

backend/src/index.ts

@@ -0,0 +1,62 @@
+import { Server, Socket } from 'socket.io';
+
+// Your existing matching service logic
+export function initializeMatchingService(io: Server) {
+  // Maintain an array to store active users seeking a match
+  const activeUsers: { socket: Socket; preferences: any }[] = [];
+
+  io.on('connection', (socket: Socket) => {
+    console.log('A user connected');
+
+    socket.on('startMatching', (preferences: any) => {
+      // Add the user to the list of active users with their preferences
+      activeUsers.push({ socket, preferences });
+
+      // Attempt to find a match for the user
+      tryMatchForUser(socket, preferences);
+    });
+
+    socket.on('disconnect', () => {
+      console.log('A user disconnected');
+
+      // Remove the user from the list of active users when they disconnect
+      removeUserFromActiveList(socket);
+    });
+
+    // Other event handlers as needed
+  });
+
+  function tryMatchForUser(socket: Socket, preferences: any) {
+    const { difficulty, category } = preferences;
+
+    // Iterate through active users to find a match
+    const matchedUser = activeUsers.find((user) => {
+      return (
+        user.socket !== socket && // Exclude the current user from matching with themselves
+        user.preferences.difficulty === difficulty &&
+        user.preferences.category === category
+      );
+    });
+
+    if (matchedUser) {
+      // Remove both users from the active list
+      removeUserFromActiveList(socket);
+      removeUserFromActiveList(matchedUser.socket);
+
+      // Emit "matchFound" to both users
+      socket.emit('matchFound', matchedUser.preferences);
+      matchedUser.socket.emit('matchFound', preferences);
+    } else {
+      // Handle the case when no match is found for the user
+      // You can emit a "noMatchFound" event or handle it differently
+    }
+  }
+
+  function removeUserFromActiveList(socket: Socket) {
+    // Remove the user from the list of active users by socket ID
+    const index = activeUsers.findIndex((user) => user.socket === socket);
+    if (index !== -1) {
+      activeUsers.splice(index, 1);
+    }
+  }
+}

backend/src/matching/matching.service.ts

@@ -1,5 +1,5 @@
 import { Request, Response } from "express";
-import { createUser, getUser } from "./user.service";
+import { createUser, getUser, updateUser } from "./user.service";
 
 export async function handleCreateUser(req: Request, res: Response) {
   try {
@@ -29,3 +29,19 @@ export async function handleGetUser(req: Request, res: Response) {
     res.status(500).send(error);
   }
 }
+
+export async function handleUpdateUser(req: Request, res: Response) {
+  try {
+    const email = req.body.params.email;
+    if (typeof email === "string") {
+      console.log(`updating user ${email}`);
+      const user = await updateUser(email, req.body.params)
+      res.status(200).send(user);
+    } else {
+      res.status(500).send("no params");
+    }
+  } catch (error) {
+    console.error(error);
+    res.status(500).send(error);
+  }
+}

backend/src/user/user.controller.ts

@@ -1,5 +1,5 @@
 import { initializeApp } from "firebase/app";
-import { doc, getDoc, getFirestore, setDoc } from "firebase/firestore";
+import { doc, getDoc, getFirestore, setDoc, updateDoc } from "firebase/firestore";
 import { firebaseConfig } from "../firebase/firebase.config";
 
 initializeApp(firebaseConfig);
@@ -18,11 +18,17 @@ export async function createUser(email: string): Promise<User> {
   try {
     await setDoc(doc(db, "users", email), {
       email: email,
+      name: "-",
+      year: "-",
+      major: "-",
       role: "user",
       completed: 0,
     });
     return Promise.resolve({
       email: email,
+      name: "-",
+      year: "-",
+      major: "-",
       role: "user",
       completed: 0,
     });
@@ -50,3 +56,29 @@ export async function getUser(email: string): Promise<User> {
     return Promise.reject(error);
   }
 }
+
+export async function updateUser(email: string, params: any): Promise<User> {
+  try {
+    const document = doc(db, "users", email);
+    await updateDoc(document, {
+      name: params.name,
+      year: params.year,
+      major: params.major
+    })
+    const data = await getDoc(doc(db, "users", email));
+    const user = data.data();
+    if (user) {
+      return Promise.resolve({
+        email: email,
+        name: user.name ? user.name : undefined,
+        year: user.year ? user.year : undefined,
+        major: user.major ? user.major : undefined,
+        role: user.role,
+        completed: user.completed,
+      });
+    }
+    return Promise.reject("no such user");
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}

backend/src/user/user.service.ts

@@ -10,4 +10,4 @@
   },
   "include": ["./**/*.ts"],
   "exclue": ["node_modules"]
-}
+}

backend/tsconfig.json

@@ -23,6 +23,7 @@
     "react-router-dom": "^6.16.0",
     "react-scripts": "5.0.1",
     "react-simple-code-editor": "^0.13.1",
+    "socket.io-client": "^4.7.2",
     "typescript": "^4.9.5",
     "web-vitals": "^2.1.4"
   },

frontend/package-lock.json

@@ -1,8 +1,12 @@
 import {httpClient} from "../axios/config";
-import { UserModel } from "./model";
+import { UserModel, Values } from "./model";
+
 
 export const createUser = (email: string) =>
   httpClient.post<UserModel>("/user", { email: email });
 
 export const getUser = (email: string) =>
   httpClient.get<UserModel>("/user", { params: { email: email } });
+
+  export const updateUser = (params: Values) =>
+  httpClient.put<UserModel>("/user", { params });