加回临时房间

src/room-manager/room-manager.controller.ts

@@ -20,7 +20,7 @@ export class RoomManagerController {
     private readonly roomManagerService: RoomManagerService,
     private readonly roomService: RoomService,
     private readonly usersService: UsersService,
-  ) { }
+  ) {}
 
   @Get('/danmaku/:id')
   @ApiOperation({ summary: '获取房间弹幕列表' })

src/room/actions/actions.service.ts

@@ -12,7 +12,7 @@ export class ActionsService {
     private roomService: RoomService,
     @Inject(forwardRef(() => UsersService))
     private userService: UsersService,
-  ) { }
+  ) {}
 
   async handleAllAction(socket: Socket, data: ActionsParams): Promise<void> {
     const isSocketLeader = () => {

src/room/delay/delay.service.ts

@@ -7,6 +7,7 @@ import * as duration from 'dayjs/plugin/duration';
 import { ConfigService } from '@nestjs/config';
 import { UsersService } from '../users/users.service';
 import { RoomService } from '../room.service';
+import { TempService } from '../temp/temp.service';
 dayjs.extend(duration);
 @Injectable()
 export class DelayService {
@@ -17,6 +18,7 @@ export class DelayService {
     private readonly userService: UsersService,
     @Inject(forwardRef(() => RoomService))
     public readonly roomService: RoomService,
+    public readonly tempService: TempService,
   ) {}
 
   init(): void {
@@ -28,40 +30,65 @@ export class DelayService {
     this.subRedis.subscribe(subscribeEvent);
     this.subRedis.on('message', (channel, key) => {
       if (channel === subscribeEvent) {
-        this.handleExpiredSubscribe(key);
+        this.handleExpiredKeys(key);
       }
     });
   }
-  async handleExpiredSubscribe(key: string) {
-    if (key.includes('kankan:socket:delay')) {
-      const tKey = key.replace('kankan:socket:delay:', '');
-      const params = tKey.split(':');
-      const RoomId = params[0];
-      const UserId = params[1];
-      const delayUser = await this.userService.getUsersBy(RoomId, UserId);
-      if (delayUser) {
-        const roomUsers = await this.userService.getRoomUsers(RoomId);
-        const filterRoomUser = roomUsers.filter((i) => i.UserId !== UserId);
-        console.log('delayUser', delayUser.UserId);
-        const res = await this.userService.deleteRoomUser(RoomId, UserId);
-        if (res) {
-          if (delayUser.Role === 'leader') {
-            this.roomService.handleRoomDismiss(RoomId);
-          } else {
-            this.roomService.socketGateway.server.to(RoomId).emit('action', {
-              type: 'user-exit',
-              user: delayUser,
-              members: filterRoomUser,
-            });
-          }
-          this.roomService.socketGateway.server.sockets.sockets.forEach(
-            (soc) => {
-              if (soc.id === delayUser.id) {
-                soc.disconnect(true);
-              }
-            },
-          );
+  async handleExpiredKeys(key: string) {
+    switch (true) {
+      //过期下线的
+      case this.isContainKeys(key, 'kankan:socket:delay'):
+        this.handleOfflineExpiredSubscribe(key);
+        break;
+      //临时房间下线的
+      case this.isContainKeys(key, 'kankan:socket:tempRoom'):
+        this.handleTempRoomExpiredSubscribe(key);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  isContainKeys(key: string, exist: string) {
+    return key.indexOf(exist) > -1;
+  }
+
+  async handleTempRoomExpiredSubscribe(key: string) {
+    const tKey = key.replace('kankan:socket:tempRoom:', '');
+    const params = tKey.split(':');
+    const RoomId = params[0];
+    // const UserId = params[1];
+    this.roomService.logger.warn(`解散临时房间 :${RoomId}`, 'temp-room');
+    await this.roomService.handleRoomDismiss(RoomId);
+    this.roomService.socketGateway.server.in(RoomId).disconnectSockets();
+  }
+  async handleOfflineExpiredSubscribe(key: string) {
+    const tKey = key.replace('kankan:socket:delay:', '');
+    const params = tKey.split(':');
+    const RoomId = params[0];
+    const UserId = params[1];
+    const delayUser = await this.userService.getUsersBy(RoomId, UserId);
+    if (delayUser) {
+      const roomUsers = await this.userService.getRoomUsers(RoomId);
+      const filterRoomUser = roomUsers.filter((i) => i.UserId !== UserId);
+      console.log('delayUser', delayUser.UserId);
+      const res = await this.userService.deleteRoomUser(RoomId, UserId);
+      if (res) {
+        if (delayUser.Role === 'leader') {
+          this.roomService.handleRoomDismiss(RoomId);
+        } else {
+          this.roomService.socketGateway.server.to(RoomId).emit('action', {
+            type: 'user-exit',
+            user: delayUser,
+            members: filterRoomUser,
+          });
         }
+        this.roomService.socketGateway.server.sockets.sockets.forEach((soc) => {
+          if (soc.id === delayUser.id) {
+            soc.disconnect(true);
+          }
+        });
       }
     }
   }

src/room/room.module.ts

@@ -5,6 +5,7 @@ import { RoomService } from './room.service';
 import { UsersService } from './users/users.service';
 import { ActionsService } from './actions/actions.service';
 import { DelayService } from './delay/delay.service';
+import { TempService } from './temp/temp.service';
 
 @Module({
   imports: [],
@@ -14,6 +15,7 @@ import { DelayService } from './delay/delay.service';
     UsersService,
     ActionsService,
     DelayService,
+    TempService,
   ],
   exports: [RoomService],
 })

src/room/room.service.ts

@@ -4,6 +4,7 @@ import { Socket } from 'socket.io';
 import { SocketGateway } from 'src/socket/socket.gateway';
 import { ActionsService } from './actions/actions.service';
 import { DelayService } from './delay/delay.service';
+import { TempService } from './temp/temp.service';
 import { UsersService } from './users/users.service';
 
 @Injectable()
@@ -15,7 +16,8 @@ export class RoomService {
     private readonly userService: UsersService,
     private readonly actionsService: ActionsService,
     private readonly delayService: DelayService,
-  ) { }
+    private readonly tempService: TempService,
+  ) {}
   public readonly logger = new Logger('user');
   public _sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
   public _userInfo = {} as UserInfoType;
@@ -154,6 +156,8 @@ export class RoomService {
             return;
           }
         }
+
+        await this.tempService.init(socket);
         const roomUsers = await this.userService.getRoomUsers(this._roomId);
         socket.emit('join', {
           user: socket.data.user,

src/room/temp/temp.service.ts

@@ -0,0 +1,49 @@
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { Socket } from 'socket.io';
+import { RoomService } from '../room.service';
+import * as dayjs from 'dayjs';
+import * as duration from 'dayjs/plugin/duration';
+import { InjectRedis } from '@liaoliaots/nestjs-redis';
+import { Redis } from 'ioredis';
+dayjs.extend(duration);
+
+@Injectable()
+export class TempService {
+  constructor(
+    @Inject(forwardRef(() => RoomService))
+    private roomService: RoomService,
+    @InjectRedis() private readonly redis: Redis,
+  ) {}
+  private isTempRoom = false;
+  get _isTempRoom(): boolean {
+    return this.isTempRoom;
+  }
+
+  init(socket: Socket) {
+    const { RoomId } = socket.data?.user;
+    if (RoomId && RoomId.indexOf('temp_') > -1) {
+      this.isTempRoom = true;
+      this.handleInitRoom(socket);
+    }
+  }
+  async handleInitRoom(socket: Socket) {
+    const { RoomId, UserId, Role } = socket.data.user;
+    const temp_key_init = `kankan:socket:tempRoom:${RoomId}:${UserId}`;
+    // const delayTime = 60 * 60;
+    const delayTime = 60 * 1;
+    const isExist = await this.redis.exists(temp_key_init);
+    if (!isExist) {
+      if (Role === 'leader') {
+        this.redis.set(temp_key_init, '', 'EX', delayTime);
+        this.roomService.socketGateway.server
+          .to(RoomId)
+          .emit('action', { type: 'room-valid-time', data: { delayTime } });
+      }
+    } else {
+      const ttl = await this.redis.ttl(temp_key_init);
+      this.roomService.socketGateway.server
+        .to(RoomId)
+        .emit('action', { type: 'room-valid-time', data: { ttl } });
+    }
+  }
+}