fix(v1): rejoin a deleted room causes incorrect rtc uid (#737)

Co-authored-by: xuyunshi <405029644@qq.com>

Author: hyrious

src/v1/controller/room/info/__tests__/helpers/createUsersRequest.ts

@@ -28,11 +28,15 @@ export const createUsersRequest = (
     } as ControllerClassParams);
 };
 
-export const createRoom = async (ownerUUID: string, roomUUID: string): Promise<void> => {
+export const createRoom = async (
+    ownerUUID: string,
+    roomUUID: string,
+    roomStatus: RoomStatus = RoomStatus.Stopped,
+): Promise<void> => {
     await RoomDAO().insert({
         room_uuid: roomUUID,
         periodic_uuid: "",
-        room_status: RoomStatus.Stopped,
+        room_status: roomStatus,
         begin_time: new Date(),
         end_time: new Date(),
         title: "test",

src/v1/controller/room/join/Ordinary.ts

@@ -43,30 +43,34 @@ export const joinOrdinary = async (
     }
 
     const { whiteboard_room_uuid: whiteboardRoomUUID } = roomInfo;
-    let rtcUID: string;
+
+    // Either user is joinning a new room or rejoinning a (maybe deleted) room.
+    await RoomUserDAO().insert(
+        {
+            room_uuid: roomUUID,
+            user_uuid: userUUID,
+            rtc_uid: cryptoRandomString({ length: 6, type: "numeric" }),
+        },
+        {
+            orUpdate: {
+                is_delete: false,
+            },
+        },
+    );
 
     const roomUserInfo = await RoomUserDAO().findOne(["rtc_uid"], {
         room_uuid: roomUUID,
         user_uuid: userUUID,
     });
 
+    let rtcUID: string;
     if (roomUserInfo !== undefined) {
         rtcUID = roomUserInfo.rtc_uid;
     } else {
-        rtcUID = cryptoRandomString({ length: 6, type: "numeric" });
-
-        await RoomUserDAO().insert(
-            {
-                room_uuid: roomUUID,
-                user_uuid: userUUID,
-                rtc_uid: rtcUID,
-            },
-            {
-                orUpdate: {
-                    is_delete: false,
-                },
-            },
-        );
+        return {
+            status: Status.Failed,
+            code: ErrorCode.CurrentProcessFailed,
+        };
     }
 
     return {

src/v1/controller/room/join/Periodic.ts

@@ -54,52 +54,55 @@ export const joinPeriodic = async (
     }
 
     const { room_uuid: roomUUID, whiteboard_room_uuid: whiteboardRoomUUID } = roomInfo;
-    let rtcUID: string;
+
+    await dataSource.transaction(async t => {
+        const commands: Promise<unknown>[] = [];
+
+        commands.push(
+            RoomUserDAO(t).insert(
+                {
+                    room_uuid: roomUUID,
+                    user_uuid: userUUID,
+                    rtc_uid: cryptoRandomString({ length: 6, type: "numeric" }),
+                },
+                {
+                    orUpdate: {
+                        is_delete: false,
+                    },
+                },
+            ),
+        );
+
+        commands.push(
+            RoomPeriodicUserDAO(t).insert(
+                {
+                    periodic_uuid: periodicUUID,
+                    user_uuid: userUUID,
+                },
+                {
+                    orUpdate: {
+                        is_delete: false,
+                    },
+                },
+            ),
+        );
+
+        return await Promise.all(commands);
+    });
 
     const roomUserInfo = await RoomUserDAO().findOne(["rtc_uid"], {
         room_uuid: roomUUID,
         user_uuid: userUUID,
     });
 
+    let rtcUID: string;
     if (roomUserInfo !== undefined) {
         rtcUID = roomUserInfo.rtc_uid;
     } else {
-        rtcUID = cryptoRandomString({ length: 6, type: "numeric" });
-
-        await dataSource.transaction(async t => {
-            const commands: Promise<unknown>[] = [];
-
-            commands.push(
-                RoomUserDAO(t).insert(
-                    {
-                        room_uuid: roomUUID,
-                        user_uuid: userUUID,
-                        rtc_uid: rtcUID,
-                    },
-                    {
-                        orUpdate: {
-                            is_delete: false,
-                        },
-                    },
-                ),
-            );
-
-            commands.push(
-                RoomPeriodicUserDAO(t).insert(
-                    {
-                        periodic_uuid: periodicUUID,
-                        user_uuid: userUUID,
-                    },
-                    {
-                        orUpdate: {
-                            is_delete: false,
-                        },
-                    },
-                ),
-            );
-
-            return await Promise.all(commands);
-        });
+        return {
+            status: Status.Failed,
+            code: ErrorCode.CurrentProcessFailed,
+        };
     }
 
     return {

src/v1/controller/room/join/__tests__/helpers/createCancelOrdinary.ts

@@ -0,0 +1,18 @@
+import { Logger } from "../../../../../../logger";
+import { CancelOrdinary } from "../../../cancel/Ordinary";
+
+export const createCancel = (roomUUID: string, userUUID: string): CancelOrdinary => {
+    const logger = new Logger<any>("test", {}, []);
+    return new CancelOrdinary({
+        logger,
+        req: {
+            body: {
+                roomUUID,
+            },
+            user: {
+                userUUID,
+            },
+        },
+        reply: {},
+    } as any);
+};

src/v1/controller/room/join/__tests__/helpers/createJoinRoom.ts

@@ -0,0 +1,18 @@
+import { JoinRoom } from "../..";
+import { Logger } from "../../../../../../logger";
+
+export const createJoinRoom = (roomUUID: string, userUUID: string): JoinRoom => {
+    const logger = new Logger<any>("test", {}, []);
+    return new JoinRoom({
+        logger,
+        req: {
+            body: {
+                uuid: roomUUID,
+            },
+            user: {
+                userUUID,
+            },
+        },
+        reply: {},
+    } as any);
+};

src/v1/controller/room/join/__tests__/join.test.ts

@@ -0,0 +1,36 @@
+import test from "ava";
+import { dataSource } from "../../../../../thirdPartyService/TypeORMService";
+import { v4 } from "uuid";
+import { createRoom, createRoomUser } from "../../info/__tests__/helpers/createUsersRequest";
+import { createCancel } from "./helpers/createCancelOrdinary";
+import { createJoinRoom } from "./helpers/createJoinRoom";
+import { RoomStatus } from "../../../../../model/room/Constants";
+
+const namespace = "[api][api-v1][api-v1-room][api-v1-room-join]";
+
+test.before(`${namespace} - initialize dataSource`, async () => {
+    await dataSource.initialize();
+});
+
+test.after(`${namespace} - destroy dataSource`, async () => {
+    await dataSource.destroy();
+});
+
+test(`${namespace} - join after user cancel`, async ava => {
+    const [roomUUID] = [v4()];
+    const [ownerUUID, anotherUserUUID] = await createRoomUser(roomUUID, 2);
+    await createRoom(ownerUUID, roomUUID, RoomStatus.Started);
+
+    const joinRoom = createJoinRoom(roomUUID, anotherUserUUID);
+    const result = await joinRoom.execute();
+    const f: number = (result as any).data.rtcUID;
+
+    await createCancel(roomUUID, anotherUserUUID).execute();
+
+    const joinRoom1 = createJoinRoom(roomUUID, anotherUserUUID);
+    const join1Result = await joinRoom1.execute();
+    const f1: number = (join1Result as any).data.rtcUID;
+
+    ava.is(f > 0 && f1 > 0, true);
+    ava.is(f == f1, true);
+});