Merge branch 'dev' of https://github.com/boostcampwm-2024/web04-RealTicket into feat/#226-layout-api

Author: qkdl60

back/src/auth/const/userStatus.const.ts

@@ -1,13 +1,15 @@
 export const USER_STATUS = {
   LOGIN: 'LOGIN',
   WAITING: 'WAITING',
+  ENTERING: 'ENTERING',
   SELECTING_SEAT: 'SELECTING_SEAT',
   ADMIN: 'ADMIN',
 };
 
 export const USER_LEVEL = {
   LOGIN: 0,
   WAITING: 1,
-  SELECTING_SEAT: 2,
-  ADMIN: 3,
+  ENTERING: 2,
+  SELECTING_SEAT: 3,
+  ADMIN: 4,
 };

back/src/auth/guard/session.guard.ts

@@ -7,7 +7,7 @@ import { USER_LEVEL, USER_STATUS } from '../const/userStatus.const';
 
 const EXPIRE_TIME = 3600;
 
-export function SessionAuthGuard(userStatus: string = USER_STATUS.LOGIN) {
+export function SessionAuthGuard(requiredStatuses: string | string[] = USER_STATUS.LOGIN) {
   @Injectable()
   class SessionGuard {
     readonly redis: Redis;
@@ -18,21 +18,27 @@ export function SessionAuthGuard(userStatus: string = USER_STATUS.LOGIN) {
 
     async canActivate(context: ExecutionContext): Promise<boolean> {
       const request: Request = context.switchToHttp().getRequest();
-
       const sessionId = request.cookies.SID;
-      const session = JSON.parse(await this.redis.get(`user:${sessionId}`));
-      // TODO
-      // userStatus, target_event를 비교하여 접근 허용 여부를 판단
-      if (session && USER_LEVEL[session.userStatus] >= USER_LEVEL[userStatus]) {
-        this.redis.expireat(`user:${sessionId}`, Math.round(Date.now() / 1000) + EXPIRE_TIME);
-        return true;
-      } else if (!session) {
+
+      const sessionData = await this.redis.get(`user:${sessionId}`);
+      if (!sessionData) {
         throw new ForbiddenException('접근 권한이 없습니다.');
-      } else if (USER_LEVEL[session.userStatus] < USER_LEVEL[userStatus]) {
-        throw new UnauthorizedException('해당 페이지에 접근할 수 없습니다.');
-      } else {
+      }
+
+      const session = JSON.parse(sessionData);
+      if (!session) {
         throw new UnauthorizedException('세션이 만료되었습니다.');
       }
+
+      const statusesToCheck = Array.isArray(requiredStatuses) ? requiredStatuses : [requiredStatuses];
+
+      for (const requiredStatus of statusesToCheck) {
+        if (USER_LEVEL[session.userStatus] >= USER_LEVEL[requiredStatus]) {
+          await this.redis.expireat(`user:${sessionId}`, Math.round(Date.now() / 1000) + EXPIRE_TIME);
+          return true;
+        }
+      }
+      throw new UnauthorizedException('해당 페이지에 접근할 수 없습니다.');
     }
   }
 

back/src/auth/service/auth.service.ts

@@ -35,6 +35,13 @@ export class AuthService {
     this.redis.set(`user:${sid}`, JSON.stringify({ ...session, userStatus: USER_STATUS.WAITING }));
   }
 
+  async setUserStatusEntering(sid: string) {
+    const session = JSON.parse(await this.redis.get(`user:${sid}`));
+    if (session.userStatus === USER_STATUS.ADMIN) return;
+
+    this.redis.set(`user:${sid}`, JSON.stringify({ ...session, userStatus: USER_STATUS.ENTERING }));
+  }
+
   async setUserStatusSelectingSeat(sid: string) {
     const session = JSON.parse(await this.redis.get(`user:${sid}`));
     if (session.userStatus === USER_STATUS.ADMIN) return;

back/src/domains/booking/booking.module.ts

@@ -9,14 +9,22 @@ import { UserModule } from '../user/user.module';
 import { BookingController } from './controller/booking.controller';
 import { BookingSeatsService } from './service/booking-seats.service';
 import { BookingService } from './service/booking.service';
+import { EnterBookingService } from './service/enter-booking.service';
 import { InBookingService } from './service/in-booking.service';
 import { OpenBookingService } from './service/open-booking.service';
 import { WaitingQueueService } from './service/waiting-queue.service';
 
 @Module({
   imports: [EventEmitterModule.forRoot(), EventModule, AuthModule, PlaceModule, UserModule],
   controllers: [BookingController],
-  providers: [BookingService, InBookingService, OpenBookingService, BookingSeatsService, WaitingQueueService],
+  providers: [
+    BookingService,
+    InBookingService,
+    OpenBookingService,
+    BookingSeatsService,
+    WaitingQueueService,
+    EnterBookingService,
+  ],
   exports: [InBookingService],
 })
 export class BookingModule {}

back/src/domains/booking/const/enterBooking.const.ts

@@ -0,0 +1,2 @@
+export const ENTERING_SESSION_EXPIRY = 30 * 1000;
+export const ENTERING_GC_INTERVAL = 10 * 1000;

back/src/domains/booking/controller/booking.controller.ts

@@ -26,6 +26,7 @@ import { Request } from 'express';
 
 import { USER_STATUS } from '../../../auth/const/userStatus.const';
 import { SessionAuthGuard } from '../../../auth/guard/session.guard';
+import { AuthService } from '../../../auth/service/auth.service';
 import { SeatStatus } from '../const/seatStatus.enum';
 import { BookingAmountReqDto } from '../dto/bookingAmountReq.dto';
 import { BookingAmountResDto } from '../dto/bookingAmountRes.dto';
@@ -45,6 +46,7 @@ import { WaitingQueueService } from '../service/waiting-queue.service';
 export class BookingController {
   constructor(
     private readonly eventEmitter: EventEmitter2,
+    private readonly authService: AuthService,
     private readonly bookingService: BookingService,
     private readonly inBookingService: InBookingService,
     private readonly bookingSeatsService: BookingSeatsService,
@@ -73,8 +75,8 @@ export class BookingController {
     return this.waitingQueueService.subscribeQueue(eventId);
   }
 
-  @UseGuards(SessionAuthGuard(USER_STATUS.SELECTING_SEAT))
   @Post('count')
+  @UseGuards(SessionAuthGuard([USER_STATUS.ENTERING, USER_STATUS.SELECTING_SEAT]))
   @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
   @ApiOperation({ summary: '예매 인원 설정', description: '예매할 인원 수를 설정한다.' })
   @ApiBody({ type: BookingAmountReqDto })
@@ -83,22 +85,24 @@ export class BookingController {
   @ApiBadRequestResponse({ description: '잘못된 요청' })
   async setBookingAmount(@Req() req: Request, @Body() dto: BookingAmountReqDto) {
     const sid = req.cookies['SID'];
-    const result = await this.inBookingService.setBookingAmount(sid, dto.bookingAmount);
+    const result = await this.bookingService.setBookingAmount(sid, dto.bookingAmount);
     return new BookingAmountResDto(result);
   }
 
   @Sse('seat/:eventId')
-  @UseGuards(SessionAuthGuard(USER_STATUS.SELECTING_SEAT))
+  @UseGuards(SessionAuthGuard([USER_STATUS.ENTERING, USER_STATUS.SELECTING_SEAT]))
   @ApiOperation({
     summary: '실시간 좌석 예약 현황 SSE',
     description: '실시간으로 좌석 예약 현황을 조회한다.',
   })
   @ApiOkResponse({ description: 'SSE 연결 성공', type: SeatsSseDto })
   @ApiUnauthorizedResponse({ description: '인증 실패' })
   async getReservationStatusByEventId(@Param('eventId') eventId: number, @Req() req: Request) {
+    const sid = req.cookies['SID'];
+    await this.bookingService.setInBookingFromEntering(sid);
+
     const observable = this.bookingSeatsService.subscribeSeats(eventId);
 
-    const sid = req.cookies['SID'];
     req.on('close', () => {
       this.eventEmitter.emit('seats-sse-close', { sid });
     });

back/src/domains/booking/service/booking.service.ts

@@ -1,12 +1,16 @@
+import { RedisService } from '@liaoliaots/nestjs-redis';
 import { BadRequestException, Injectable, InternalServerErrorException, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
+import Redis from 'ioredis';
 
 import { AuthService } from '../../../auth/service/auth.service';
 import { EventService } from '../../event/service/event.service';
 import { UserService } from '../../user/service/user.service';
 import { BookingAdmissionStatusDto } from '../dto/bookingAdmissionStatus.dto';
 import { ServerTimeDto } from '../dto/serverTime.dto';
 
+import { BookingSeatsService } from './booking-seats.service';
+import { EnterBookingService } from './enter-booking.service';
 import { InBookingService } from './in-booking.service';
 import { OpenBookingService } from './open-booking.service';
 import { WaitingQueueService } from './waiting-queue.service';
@@ -16,30 +20,84 @@ const OFFSET = 1000 * 60 * 60 * 9;
 @Injectable()
 export class BookingService {
   private logger = new Logger(BookingService.name);
+  private readonly redis: Redis | null;
   constructor(
+    private readonly redisService: RedisService,
     private readonly eventService: EventService,
     private readonly authService: AuthService,
+    private readonly bookingSeatsService: BookingSeatsService,
     private readonly inBookingService: InBookingService,
     private readonly openBookingService: OpenBookingService,
     private readonly waitingQueueService: WaitingQueueService,
     private readonly userService: UserService,
-  ) {}
+    private readonly enterBookingService: EnterBookingService,
+  ) {
+    this.redis = this.redisService.getOrThrow();
+  }
 
   @OnEvent('seats-sse-close')
-  async letInNextWaiting(event: { sid: string }) {
-    const eventId = await this.userService.getUserEventTarget(event.sid);
-    if ((await this.waitingQueueService.getQueueSize(eventId)) < 1) {
-      return;
+  async onSeatsSseDisconnected(event: { sid: string }) {
+    const sid = event.sid;
+    const eventId = await this.userService.getUserEventTarget(sid);
+    await this.collectSeatsIfNotSaved(eventId, sid);
+    await this.inBookingService.emitSession(sid);
+    await this.letInNextWaiting(eventId);
+  }
+
+  private async collectSeatsIfNotSaved(eventId: number, sid: string) {
+    const inBookingSession = await this.inBookingService.getSession(eventId, sid);
+    if (inBookingSession && !inBookingSession.saved) {
+      const bookedSeats = inBookingSession.bookedSeats;
+      bookedSeats.forEach((seat) => {
+        this.bookingSeatsService.updateSeatDeleted(eventId, seat);
+      });
+      inBookingSession.bookedSeats = [];
+      await this.inBookingService.setSession(eventId, inBookingSession);
     }
-    if (await this.inBookingService.isInsertable(eventId)) {
+  }
+
+  @OnEvent('entering-sessions-gc')
+  async onEnteringSessionsGc(event: { eventId: number }) {
+    await this.letInNextWaiting(event.eventId);
+  }
+
+  @OnEvent('in-booking-max-size-changed')
+  async onSpecificInBookingMaxSizeChanged(event: { eventId: number }) {
+    await this.letInNextWaiting(event.eventId);
+  }
+
+  @OnEvent('all-in-booking-max-size-changed')
+  async onAllInBookingMaxSizeChanged() {
+    const eventIds = await this.openBookingService.getOpenedEventIds();
+    await Promise.all(
+      eventIds.map(async (eventId) => {
+        await this.letInNextWaiting(eventId);
+      }),
+    );
+  }
+
+  private async letInNextWaiting(eventId: number) {
+    const isQueueEmpty = async (eventId: number) =>
+      (await this.waitingQueueService.getQueueSize(eventId)) < 1;
+    while (!(await isQueueEmpty(eventId)) && (await this.isInsertableInBooking(eventId))) {
       const item = await this.waitingQueueService.popQueue(eventId);
       if (!item) {
-        return;
+        break;
       }
-      await this.authService.setUserStatusSelectingSeat(item.sid);
+      await this.enterBookingService.addEnteringSession(item.sid);
+      await this.authService.setUserStatusEntering(item.sid);
     }
   }
 
+  async setInBookingFromEntering(sid: string) {
+    const eventId = await this.userService.getUserEventTarget(sid);
+    const bookingAmount = await this.enterBookingService.getBookingAmount(sid);
+
+    await this.enterBookingService.removeEnteringSession(sid);
+    await this.inBookingService.insertInBooking(eventId, sid, bookingAmount);
+    await this.authService.setUserStatusSelectingSeat(sid);
+  }
+
   // 함수 이름 생각하기
   async isAdmission(eventId: number, sid: string): Promise<BookingAdmissionStatusDto> {
     // eventId를 받아서 해당 이벤트가 존재하는지 확인한다.
@@ -61,10 +119,12 @@ export class BookingService {
   }
 
   private async getForwarded(sid: string) {
-    const isEntered = await this.inBookingService.insertIfPossible(sid);
+    const eventId = await this.userService.getUserEventTarget(sid);
+    const isInsertable = await this.isInsertableInBooking(eventId);
 
-    if (isEntered) {
-      await this.authService.setUserStatusSelectingSeat(sid);
+    if (isInsertable) {
+      await this.enterBookingService.addEnteringSession(sid);
+      await this.authService.setUserStatusEntering(sid);
       return {
         waitingStatus: false,
         enteringStatus: true,
@@ -80,6 +140,21 @@ export class BookingService {
     };
   }
 
+  private async isInsertableInBooking(eventId: number): Promise<boolean> {
+    const inBookingCount = await this.inBookingService.getInBookingSessionCount(eventId);
+    const enteringCount = await this.enterBookingService.getEnteringSessionCount(eventId);
+    const maxSize = await this.inBookingService.getInBookingSessionsMaxSize(eventId);
+    return inBookingCount + enteringCount < maxSize;
+  }
+
+  async setBookingAmount(sid: string, bookingAmount: number) {
+    const isInBooking = await this.inBookingService.isInBooking(sid);
+    if (isInBooking) {
+      return await this.inBookingService.setBookingAmount(sid, bookingAmount);
+    }
+    return await this.enterBookingService.setBookingAmount(sid, bookingAmount);
+  }
+
   async getTimeMs(): Promise<ServerTimeDto> {
     try {
       return {

back/src/domains/booking/service/enter-booking.service.ts

@@ -0,0 +1,67 @@
+import { RedisService } from '@liaoliaots/nestjs-redis';
+import { Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import Redis from 'ioredis';
+
+import { UserService } from '../../user/service/user.service';
+import { ENTERING_GC_INTERVAL, ENTERING_SESSION_EXPIRY } from '../const/enterBooking.const';
+
+@Injectable()
+export class EnterBookingService {
+  private readonly redis: Redis | null;
+  constructor(
+    private readonly redisService: RedisService,
+    private readonly userService: UserService,
+    private readonly eventEmitter: EventEmitter2,
+  ) {
+    this.redis = this.redisService.getOrThrow();
+  }
+
+  async gcEnteringSessions(eventId: number) {
+    setInterval(() => {
+      this.removeExpiredSessions(eventId);
+      this.eventEmitter.emit('entering-sessions-gc', { eventId });
+    }, ENTERING_GC_INTERVAL);
+  }
+
+  async addEnteringSession(sid: string) {
+    const eventId = await this.userService.getUserEventTarget(sid);
+    const timestamp = Date.now();
+    await this.redis.zadd(`entering:${eventId}`, timestamp, sid);
+    return true;
+  }
+
+  async removeEnteringSession(sid: string) {
+    const eventId = await this.userService.getUserEventTarget(sid);
+    await this.redis.zrem(`entering:${eventId}`, sid);
+    await this.removeBookingAmount(sid);
+    return true;
+  }
+
+  async getEnteringSessionCount(eventId: number) {
+    return this.redis.zcard(`entering:${eventId}`);
+  }
+
+  async setBookingAmount(sid: string, bookingAmount: number) {
+    await this.redis.set(`entering:${sid}:temp-booking-amount`, bookingAmount);
+    return parseInt(await this.redis.get(`entering:${sid}:temp-booking-amount`));
+  }
+
+  async getBookingAmount(sid: string) {
+    const bookingAmountData = await this.redis.get(`entering:${sid}:temp-booking-amount`);
+    if (!bookingAmountData) {
+      return 0;
+    }
+    return parseInt(await this.redis.get(`entering:${sid}:temp-booking-amount`));
+  }
+
+  async removeBookingAmount(sid: string) {
+    await this.redis.del(`entering:${sid}:temp-booking-amount`);
+    return true;
+  }
+
+  private async removeExpiredSessions(eventId: number) {
+    const expiryTimestamp = Date.now() - ENTERING_SESSION_EXPIRY;
+    await this.redis.zremrangebyscore(`entering:${eventId}`, 0, expiryTimestamp);
+  }
+}