✨ feat: 예약 마감 로직 구현

- 예약 마감 실행을 스케줄링
- 예약 진행과 관련된 모든 상태 초기화

Issue Resolved: #243

Author: kyu4583

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

@@ -10,7 +10,6 @@ import Redis from 'ioredis';
 import { BehaviorSubject } from 'rxjs';
 import { map } from 'rxjs/operators';
 
-import { AuthService } from '../../../auth/service/auth.service';
 import { UserService } from '../../user/service/user.service';
 import { SEATS_BROADCAST_INTERVAL } from '../const/seatsBroadcastInterval.const';
 import { SEATS_SSE_RETRY_TIME } from '../const/seatsSseRetryTime.const';
@@ -36,7 +35,6 @@ export class BookingSeatsService {
   constructor(
     private redisService: RedisService,
     private inBookingService: InBookingService,
-    private authService: AuthService,
     private eventEmitter: EventEmitter2,
     private readonly userService: UserService,
   ) {
@@ -58,6 +56,18 @@ export class BookingSeatsService {
     this.seatsSubscriptionMap.set(eventId, subscription);
   }
 
+  async clearSeatsSubscription(eventId: number) {
+    const subscription = this.seatsSubscriptionMap.get(eventId);
+    if (subscription) {
+      subscription.complete();
+      this.seatsSubscriptionMap.delete(eventId);
+    }
+    const keys = await this.redis.keys(`event:${eventId}:*`);
+    if (keys.length > 0) {
+      await this.redis.unlink(...keys);
+    }
+  }
+
   async bookSeat(sid: string, target: [number, number]) {
     const eventId = await this.userService.getUserEventTarget(sid);
     const bookedSeat = await this.inBookingService.getBookedSeats(sid);

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

@@ -4,7 +4,6 @@ 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';
@@ -21,7 +20,6 @@ export class BookingService {
   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,
@@ -37,9 +35,11 @@ export class BookingService {
   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);
+    if (await this.openBookingService.isEventOpened(eventId)) {
+      await this.collectSeatsIfNotSaved(eventId, sid);
+      await this.inBookingService.emitSession(sid);
+      await this.letInNextWaiting(eventId);
+    }
   }
 
   private async collectSeatsIfNotSaved(eventId: number, sid: string) {
@@ -98,18 +98,9 @@ export class BookingService {
 
   // 함수 이름 생각하기
   async isAdmission(eventId: number, sid: string): Promise<BookingAdmissionStatusDto> {
-    // eventId를 받아서 해당 이벤트가 존재하는지 확인한다.
-    const event = await this.eventService.findEvent({ eventId });
-    const now = new Date();
-
     const isOpened = await this.openBookingService.isEventOpened(eventId);
-
     if (!isOpened) {
-      throw new BadRequestException('아직 예약이 오픈되지 않았습니다.');
-    } else if (now >= event.reservationCloseDate) {
-      //event 시간 확인 이벤트 종료시간 이후인지
-      // 예약 시간이 아닙니다.
-      throw new BadRequestException('이미 예약 마감된 이벤트입니다.');
+      throw new BadRequestException('예약이 오픈되지 않았습니다.');
     }
 
     await this.userService.setUserEventTarget(sid, eventId);

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

@@ -1,6 +1,7 @@
 import { RedisService } from '@liaoliaots/nestjs-redis';
 import { Injectable } from '@nestjs/common';
 import { EventEmitter2 } from '@nestjs/event-emitter';
+import { SchedulerRegistry } from '@nestjs/schedule';
 import Redis from 'ioredis';
 
 import { UserService } from '../../user/service/user.service';
@@ -13,15 +14,30 @@ export class EnterBookingService {
     private readonly redisService: RedisService,
     private readonly userService: UserService,
     private readonly eventEmitter: EventEmitter2,
+    private readonly schedulerRegistry: SchedulerRegistry,
   ) {
     this.redis = this.redisService.getOrThrow();
   }
 
   async gcEnteringSessions(eventId: number) {
-    setInterval(() => {
+    this.deleteIntervalIfExists(`gc-entering-${eventId}`);
+
+    const interval = setInterval(() => {
       this.removeExpiredSessions(eventId);
       this.eventEmitter.emit('entering-sessions-gc', { eventId });
     }, ENTERING_GC_INTERVAL);
+
+    this.schedulerRegistry.addInterval(`gc-entering-${eventId}`, interval);
+  }
+
+  clearGCInterval(eventId: number) {
+    this.deleteIntervalIfExists(`gc-entering-${eventId}`);
+  }
+
+  private deleteIntervalIfExists(intervalName: string) {
+    if (this.schedulerRegistry.doesExist('interval', intervalName)) {
+      this.schedulerRegistry.deleteInterval(intervalName);
+    }
   }
 
   async addEnteringSession(sid: string) {
@@ -64,4 +80,16 @@ export class EnterBookingService {
     const expiryTimestamp = Date.now() - ENTERING_SESSION_EXPIRY;
     await this.redis.zremrangebyscore(`entering:${eventId}`, 0, expiryTimestamp);
   }
+
+  async getAllEnteringSids(eventId: number) {
+    return this.redis.zrange(`entering:${eventId}`, 0, -1);
+  }
+
+  async clearEnteringPool(eventId: number) {
+    this.clearGCInterval(eventId);
+    const keys = await this.redis.keys('entering:*');
+    if (keys.length > 0) {
+      await this.redis.unlink(...keys);
+    }
+  }
 }

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

@@ -179,4 +179,15 @@ export class InBookingService {
       bookedSeats: session.bookedSeats,
     };
   }
+
+  async getAllInBookingSids(eventId: number) {
+    return this.redis.smembers(this.getEventKey(eventId));
+  }
+
+  async clearInBookingPool(eventId: number) {
+    const keys = await this.redis.keys(`in-booking:${eventId}:*`);
+    if (keys.length > 0) {
+      await this.redis.unlink(...keys);
+    }
+  }
 }

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

@@ -4,15 +4,18 @@ import { Cron, SchedulerRegistry } from '@nestjs/schedule';
 import { CronJob } from 'cron';
 import Redis from 'ioredis';
 
+import { AuthService } from '../../../auth/service/auth.service';
 import { Event } from '../../event/entity/event.entity';
 import { EventRepository } from '../../event/repository/event.reposiotry';
 import { SectionRepository } from '../../place/repository/section.repository';
+import { UserService } from '../../user/service/user.service';
 import { ONE_MINUTE_BEFORE_THE_HOUR } from '../const/cronExpressions.const';
 import { IN_BOOKING_DEFAULT_MAX_SIZE } from '../const/inBookingDefaultMaxSize.const';
 
 import { BookingSeatsService } from './booking-seats.service';
 import { EnterBookingService } from './enter-booking.service';
 import { InBookingService } from './in-booking.service';
+import { WaitingQueueService } from './waiting-queue.service';
 
 @Injectable()
 export class OpenBookingService implements OnApplicationBootstrap {
@@ -22,8 +25,11 @@ export class OpenBookingService implements OnApplicationBootstrap {
     private redisService: RedisService,
     private eventRepository: EventRepository,
     private sectionRepository: SectionRepository,
+    private authService: AuthService,
+    private userService: UserService,
     private inBookingService: InBookingService,
     private seatsUpdateService: BookingSeatsService,
+    private waitingQueueService: WaitingQueueService,
     private enterBookingService: EnterBookingService,
     private schedulerRegistry: SchedulerRegistry,
   ) {
@@ -38,21 +44,35 @@ export class OpenBookingService implements OnApplicationBootstrap {
   @Cron(ONE_MINUTE_BEFORE_THE_HOUR)
   async scheduleUpcomingReservations() {
     const comingEvents = await this.eventRepository.selectUpcomingEvents();
-    const openedEventIds = new Set(await this.getOpenedEventIds());
+    await this.scheduleUpcomingReservationsToOpen(comingEvents);
+    await this.scheduleUpcomingReservationsToClose(comingEvents);
+  }
+
+  private async scheduleUpcomingReservationsToOpen(comingEvents: Event[]) {
     const now = new Date();
+    const openedEventIds = new Set(await this.getOpenedEventIds());
     const eventToOpen = comingEvents.filter((event) => event.reservationOpenDate <= now);
-    const eventsToSchedule = comingEvents.filter(
+    const eventsToScheduleOpen = comingEvents.filter(
       (event) => !openedEventIds.has(event.id) && event.reservationOpenDate > now,
     );
 
     for (const event of eventToOpen) {
       await this.openReservation(event);
     }
-    for (const event of eventsToSchedule) {
+    for (const event of eventsToScheduleOpen) {
       this.scheduleReservationOpen(event);
     }
   }
 
+  private async scheduleUpcomingReservationsToClose(comingEvents: Event[]) {
+    const now = new Date();
+    const eventsToScheduleClose = comingEvents.filter((event) => event.reservationCloseDate > now);
+
+    for (const event of eventsToScheduleClose) {
+      this.scheduleReservationClose(event);
+    }
+  }
+
   private scheduleReservationOpen(event: Event) {
     const jobName = `reservation-open-${event.id}`;
 
@@ -68,6 +88,21 @@ export class OpenBookingService implements OnApplicationBootstrap {
     job.start();
   }
 
+  private scheduleReservationClose(event: Event) {
+    const jobName = `reservation-close-${event.id}`;
+
+    if (this.schedulerRegistry.doesExist('cron', jobName)) {
+      this.schedulerRegistry.deleteCronJob(jobName);
+    }
+
+    const job = new CronJob(event.reservationCloseDate, async () => {
+      await this.closeReservation(event.id);
+    });
+
+    this.schedulerRegistry.addCronJob(jobName, job);
+    job.start();
+  }
+
   async isEventOpened(eventId: number) {
     return (await this.redis.get(`open-booking:${eventId}:opened`)) === 'true';
   }
@@ -107,22 +142,70 @@ export class OpenBookingService implements OnApplicationBootstrap {
     if (!event) {
       return false;
     }
-
     const openTime = event.reservationOpenDate;
     if (openTime > new Date()) {
-      const jobName = `reservation-open-${event.id}`;
-      const job = new CronJob(openTime, async () => {
-        await this.openReservationById(event.id);
-      });
-      this.schedulerRegistry.addCronJob(jobName, job);
-      job.start();
+      this.scheduleReservationOpen(event);
       return false;
     }
-
     return true;
   }
 
   private async registerOpenedEvent(eventId: number) {
     await this.redis.set(`open-booking:${eventId}:opened`, 'true');
   }
+
+  async closeReservation(eventId: number) {
+    await this.validateClosingEvent(eventId);
+    await this.unlinkOpenedEvent(eventId);
+    await this.clearWaitingService(eventId);
+    await this.clearEnteringService(eventId);
+    await this.seatsUpdateService.clearSeatsSubscription(eventId);
+    await this.clearInBookingService(eventId);
+  }
+
+  private async validateClosingEvent(eventId: number) {
+    const event = await this.eventRepository.selectEvent(eventId);
+    if (!event) {
+      return false;
+    }
+    const closeTime = event.reservationCloseDate;
+    if (closeTime > new Date()) {
+      this.scheduleReservationClose(event);
+      return false;
+    }
+    return true;
+  }
+
+  private async clearWaitingService(eventId: number) {
+    const waitingSids = await this.waitingQueueService.getAllWaitingSids(eventId);
+    for (const sid of waitingSids) {
+      await this.resetUserStatus(sid);
+    }
+    await this.waitingQueueService.clearQueue(eventId);
+  }
+
+  private async clearEnteringService(eventId: number) {
+    const enteringSids = await this.enterBookingService.getAllEnteringSids(eventId);
+    for (const sid of enteringSids) {
+      await this.resetUserStatus(sid);
+    }
+    await this.enterBookingService.clearEnteringPool(eventId);
+  }
+
+  private async clearInBookingService(eventId: number) {
+    const inBookingSids = await this.inBookingService.getAllInBookingSids(eventId);
+    for (const sid of inBookingSids) {
+      await this.resetUserStatus(sid);
+    }
+    await this.inBookingService.clearInBookingPool(eventId);
+  }
+
+  private async resetUserStatus(sid: string) {
+    await this.authService.setUserStatusLogin(sid);
+    await this.userService.setUserEventTarget(sid, 0);
+  }
+
+  private async unlinkOpenedEvent(eventId: number) {
+    await this.redis.unlink(`open-booking:${eventId}:opened`);
+  }
 }

back/src/domains/booking/service/waiting-queue.service.ts

@@ -96,4 +96,29 @@ export class WaitingQueueService {
     }
     return headOrder;
   }
+
+  async getAllWaitingSids(eventId: number) {
+    return (await this.redis.lrange(`waiting-queue:${eventId}`, 0, -1))
+      .map((item) => {
+        try {
+          const parsed = JSON.parse(item);
+          return parsed?.sid;
+        } catch (e) {
+          return e ? null : null;
+        }
+      })
+      .filter((sid) => sid != null);
+  }
+
+  async clearQueue(eventId: number) {
+    const subscription = this.queueSubscriptionMap.get(eventId);
+    if (subscription) {
+      subscription.complete();
+      this.queueSubscriptionMap.delete(eventId);
+    }
+    const keys = await this.redis.keys(`waiting-queue:${eventId}:*`);
+    if (keys.length > 0) {
+      await this.redis.unlink(...keys);
+    }
+  }
 }