Meetings fix + some refactoring

backend/src/data/importData.ts → backend/src/db.ts

@@ -1,12 +1,12 @@
 import { v4 as uuidv4 } from "uuid";
 
-import driver from "../driver/driver";
+import driver from "./driver/driver";
 import bcrypt from "bcrypt";
 
-import userData from "./users";
-import wordToVec from "../misc/wordToVec";
+import userData from "./data/users";
+import wordToVec from "./misc/wordToVec";
 
-async function isDatabaseEmpty() {
+export async function isDatabaseEmpty() {
   const session = driver.session();
   try {
     const result = await session.run(
@@ -22,7 +22,7 @@ async function isDatabaseEmpty() {
   }
 }
 
-async function importInitialData() {
+export async function importInitialData() {
   const isEmpty = await isDatabaseEmpty();
   if (!isEmpty) {
     return "Database is not empty";
@@ -97,4 +97,9 @@ async function importInitialData() {
   }
 }
 
-export default importInitialData;
+export async function cleanUpData() {
+  const session = driver.session();
+  await session.run(`MATCH (m:Meeting) DETACH DELETE m`);
+  await session.run(`MATCH (s:Socket) DETACH DELETE s`);
+  session.close();
+}

backend/src/httpServer.ts

@@ -3,11 +3,13 @@ import servers from "./server";
 import usersRouter from "./routes/usersRoute";
 import authRouter from "./routes/authRoute";
 import chatRouter from "./routes/chatRoute";
-import importInitialData from "./data/importData";
+import { cleanUpData, importInitialData } from "./db";
+
 const { app } = servers;
 
 dotenv.config();
 
+cleanUpData();
 importInitialData().then((res) => console.log(res));
 
 app.use("/users", usersRouter);

backend/src/meetings.ts

@@ -0,0 +1,61 @@
+import { Session } from "neo4j-driver";
+import { v4 as uuidv4 } from "uuid";
+import Meeting from "./models/Meeting";
+
+export async function isInMeeting(session: Session, userId: string) {
+  const result = await session.run(
+    `MATCH (u:User { id: $userId })-[:IS_IN_MEETING]->(m:Meeting) RETURN m`,
+    { userId },
+  );
+
+  if (result.records.length > 0) {
+    return result.records[0].get("m").properties as Meeting;
+  }
+
+  return null;
+}
+
+export async function createMeeting(session: Session, userId: string) {
+  const meetingId = uuidv4();
+  const createResult = await session.run(
+    `
+    MATCH (u:User { id: $userId })
+    MERGE (u)-[:IS_IN_MEETING]->(m:Meeting { id: $meetingId })
+    RETURN m
+    `,
+    { userId, meetingId },
+  );
+
+  return createResult.records[0].get("m").properties as Meeting;
+}
+
+export async function joinMeeting(
+  session: Session,
+  userId: string,
+  friendId: string,
+) {
+  const createResult = await session.run(
+    `
+    MATCH (u:User { id: $userId })-[:IS_FRIENDS_WITH]-(f:User { id: $friendId })
+    MATCH (f)-[:IS_IN_MEETING]->(m:Meeting)
+    MERGE (u)-[:IS_IN_MEETING]->(m)
+    RETURN m
+    `,
+    { userId, friendId },
+  );
+
+  return createResult.records[0]?.get("m").properties as Meeting;
+}
+
+export async function leaveMeeting(session: Session, userId: string) {
+  await session.run(
+    `
+    MATCH (:User { id: $userId })-[r:IS_IN_MEETING]->(m:Meeting)
+    DELETE r
+    WITH m
+    MATCH (m) WHERE NOT ()-[]->(m)
+    DELETE m
+    `,
+    { userId },
+  );
+}

backend/src/messages.ts

@@ -0,0 +1,10 @@
+import Message from "./models/Message";
+import MessageModel from "./mongoDB/MessageModel";
+
+export async function addMessageToDb(message: Message) {
+  try {
+    await MessageModel.create(message);
+  } catch (err) {
+    console.error(err);
+  }
+}

backend/src/models/Meeting.ts

@@ -0,0 +1,5 @@
+interface Meeting {
+  id: string;
+}
+
+export default Meeting;

backend/src/models/Message.ts

@@ -1,8 +1,7 @@
-import User from "./User";
-
 export default interface Message {
   type: "sent" | "received" | "info";
-  author: User;
-  receiverId?: string;
+  sentDate: Date;
+  fromUserId: string;
+  toUserId: string;
   content: string;
 }

backend/src/models/User.ts

@@ -1,5 +1,3 @@
-import Chat from "./Chat";
-
 export default interface User {
   id: string;
   first_name: string;
@@ -9,6 +7,5 @@ export default interface User {
   mail: string;
   password: string;
   friend_ids?: number[];
-  chats?: Chat[];
   socketId?: string;
 }

backend/src/mongoDB/MessageModel.ts

@@ -0,0 +1,14 @@
+import { model, Schema } from "mongoose";
+import Message from "../models/Message";
+
+const chatSchema = new Schema<Message>({
+  type: { type: String, required: true },
+  sentDate: { type: Date, required: true },
+  fromUserId: { type: String, required: true },
+  toUserId: { type: String, required: true },
+  content: { type: String, required: true },
+});
+
+const MessageModel = model("Chat", chatSchema, "messages");
+
+export default MessageModel;

backend/src/routes/authRoute.ts

@@ -3,11 +3,20 @@ import { Router, Request } from "express";
 import bcrypt from "bcrypt";
 
 import driver from "../driver/driver";
-import { generateAccessToken, generateRefreshToken } from "../misc/jwt";
+import {
+  JWTRequest,
+  authenticateToken,
+  generateAccessToken,
+  generateRefreshToken,
+} from "../misc/jwt";
 
 import jwt, { JwtPayload } from "jsonwebtoken";
 import { TokenErrorResponse } from "../types/authResponse";
 import { CustomResponse, OkResponse } from "../models/Response";
+import { OkErrorResponse } from "../types/userResponse";
+import User from "../models/User";
+import { leaveMeeting } from "../meetings";
+import { disconnectFromSocket } from "../sockets";
 
 const authRouter = Router();
 
@@ -57,11 +66,24 @@ authRouter.post("/login", async (req: Request, res: TokenErrorResponse) => {
 
 authRouter.post(
   "/logout",
-  async (_req: Request, res: CustomResponse<OkResponse>) => {
+  authenticateToken,
+  async (req: JWTRequest, res: OkErrorResponse) => {
     res.clearCookie("refreshToken", {
       secure: true,
       httpOnly: true,
     });
+
+    const userId = (req.token as any).userId;
+
+    try {
+      const session = driver.session();
+      await leaveMeeting(session, userId);
+      await session.close();
+    } catch (err) {
+      console.log("Error:", err);
+      return res.status(404).json({ status: "error", errors: err as object });
+    }
+
     res.json({ status: "ok" });
   },
 );

backend/src/routes/chatRoute.ts

@@ -1,26 +1,27 @@
 import { Router } from "express";
-import ChatModel from "../mongoDB/ChatModel";
+import Message from "../models/Message";
+import MessageModel from "../mongoDB/MessageModel";
 
 const chatRouter = Router();
 
 chatRouter.get("/:user1Id/:user2Id", async (req, res) => {
   try {
     const { user1Id, user2Id } = req.params;
-    const messageRequest = await ChatModel.find({
+    const messageRequest = await MessageModel.find({
       $or: [
-        { authorId: user1Id, receiverId: user2Id },
-        { authorId: user2Id, receiverId: user1Id },
+        { fromUserId: user1Id, toUserId: user2Id },
+        { fromUserId: user2Id, toUserId: user1Id },
       ],
     }).sort({ created_date: "asc" });
 
-    const messages = messageRequest.map((m) => {
-      const { authorId, receiverId, content, created_date } = m;
+    const messages = messageRequest.map((m: Message) => {
+      const { sentDate, fromUserId, toUserId, content } = m;
       return {
-        authorId,
-        receiverId,
+        type: fromUserId === user1Id ? "sent" : "received",
+        sentDate,
+        fromUserId,
+        toUserId,
         content,
-        created_date,
-        type: authorId === user1Id ? "sent" : "received",
       };
     });