Merge branch 'dev' of https://github.com/boostcampwm-2024/web04-RealTicket

Author: qkdl60

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

@@ -1,5 +1,5 @@
 import { RedisService } from '@liaoliaots/nestjs-redis';
-import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { Cron, SchedulerRegistry } from '@nestjs/schedule';
 import { CronJob } from 'cron';
 import Redis from 'ioredis';
@@ -20,6 +20,7 @@ import { WaitingQueueService } from './waiting-queue.service';
 @Injectable()
 export class OpenBookingService implements OnApplicationBootstrap {
   private readonly redis: Redis | null;
+  private readonly logger = new Logger(OpenBookingService.name);
 
   constructor(
     private redisService: RedisService,
@@ -48,9 +49,13 @@ export class OpenBookingService implements OnApplicationBootstrap {
 
   @Cron(ONE_MINUTE_BEFORE_THE_HOUR)
   async scheduleUpcomingReservations() {
-    const comingEvents = await this.eventRepository.selectUpcomingEvents();
-    await this.scheduleUpcomingReservationsToOpen(comingEvents);
-    await this.scheduleUpcomingReservationsToClose(comingEvents);
+    try {
+      const comingEvents = await this.eventRepository.selectUpcomingEvents();
+      await this.scheduleUpcomingReservationsToOpen(comingEvents);
+      await this.scheduleUpcomingReservationsToClose(comingEvents);
+    } catch (error) {
+      this.logger.error(error);
+    }
   }
 
   private async scheduleUpcomingReservationsToOpen(comingEvents: Event[]) {

back/src/domains/program/service/program.service.ts

@@ -1,5 +1,7 @@
 import { Inject, Injectable, NotFoundException } from '@nestjs/common';
 
+import { Event } from 'src/domains/event/entity/event.entity';
+
 import { PlaceMainPageDto } from '../dto/placeMainPage.dto';
 import { ProgramCreationDto } from '../dto/programCreation.dto';
 import { ProgramIdDto } from '../dto/programId.dto';
@@ -39,9 +41,12 @@ export class ProgramService {
   }
 
   private async convertProgramToSpecificDto(program: Program): Promise<ProgramSpecificDto> {
+    const now = new Date();
     const [place, events] = await Promise.all([program.place, program.events]);
-
-    return new ProgramSpecificDto({ ...program, place, events });
+    const openedEvents: Event[] = events.filter((event) => {
+      return event.reservationCloseDate >= now;
+    });
+    return new ProgramSpecificDto({ ...program, place, events: openedEvents });
   }
 
   async create(programCreationDto: ProgramCreationDto): Promise<void> {

back/src/domains/reservation/entity/reservedSeat.entity.ts

@@ -1,15 +1,26 @@
-import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, Unique } from 'typeorm';
+import {
+  Column,
+  DeleteDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Unique,
+} from 'typeorm';
 
 import { Event } from '../../event/entity/event.entity';
 
 import { Reservation } from './reservation.entity';
 
 @Entity({ name: 'Reserved_Seat' })
-@Unique(['row', 'col', 'sectionName', 'event'])
+@Unique(['row', 'col', 'sectionName', 'event', 'deletedAt'])
 export class ReservedSeat {
   @PrimaryGeneratedColumn('increment')
   id: number;
 
+  @DeleteDateColumn({ type: 'timestamp', name: 'deleted_at', nullable: true })
+  deletedAt: Date;
+
   @Column({ type: 'varchar', length: 255, name: 'section_name' })
   sectionName: string;
 

back/src/domains/reservation/repository/reservation.repository.ts

@@ -1,12 +1,18 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { MoreThanOrEqual, Repository } from 'typeorm';
+import { DataSource, MoreThanOrEqual, Repository } from 'typeorm';
 
 import { Reservation } from '../entity/reservation.entity';
 
+import { ReservedSeatRepository } from './reservedSeat.repository';
+
 @Injectable()
 export class ReservationRepository {
-  constructor(@InjectRepository(Reservation) private ReservationRepository: Repository<Reservation>) {}
+  constructor(
+    @InjectRepository(Reservation) private ReservationRepository: Repository<Reservation>,
+    private readonly reservedSeatRepository: ReservedSeatRepository,
+    private readonly dataSource: DataSource,
+  ) {}
 
   async selectAllReservationAfterNowByUserWithAll(userId: number): Promise<Reservation[]> {
     return await this.ReservationRepository.find({
@@ -28,9 +34,12 @@ export class ReservationRepository {
   }
 
   async deleteReservationByIdMatchedUserId(userId: number, reservationId: number) {
-    return await this.ReservationRepository.softDelete({
-      id: reservationId,
-      user: { id: userId },
+    await this.dataSource.transaction(async () => {
+      await this.reservedSeatRepository.deleteReservedSeatByReservation(reservationId);
+      await this.ReservationRepository.softDelete({
+        id: reservationId,
+        user: { id: userId },
+      });
     });
   }
 

back/src/domains/reservation/repository/reservedSeat.repository.ts

@@ -12,4 +12,10 @@ export class ReservedSeatRepository {
     const reservedSeat = this.reservedSeatRepository.create(reservedSeatData);
     return this.reservedSeatRepository.save(reservedSeat);
   }
+
+  async deleteReservedSeatByReservation(reservationId: number) {
+    return await this.reservedSeatRepository.softDelete({
+      reservation: { id: reservationId },
+    });
+  }
 }

back/src/domains/user/service/user.service.ts

@@ -10,12 +10,14 @@ import {
 import { Cron } from '@nestjs/schedule';
 import * as bcrypt from 'bcryptjs';
 import Redis from 'ioredis';
-import { DataSource } from 'typeorm';
+import { DataSource, In } from 'typeorm';
 import { v4 as uuidv4 } from 'uuid';
 
 import { USER_STATUS } from '../../../auth/const/userStatus.const';
 import { AuthService } from '../../../auth/service/auth.service';
 import { UserParamDto } from '../../../util/user-injection/userParamDto';
+import { Reservation } from '../../reservation/entity/reservation.entity';
+import { ReservedSeat } from '../../reservation/entity/reservedSeat.entity';
 import { USER_ROLE } from '../const/userRole';
 import { UserCreateDto } from '../dto/userCreate.dto';
 import { UserInfoDto } from '../dto/userInfo.dto';
@@ -183,14 +185,24 @@ export class UserService {
 
   @Cron('0 0 0 * * *', { name: 'removeGuestReservation' })
   async removeAllGuest() {
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
     try {
-      const queryRunner = this.dataSource.createQueryRunner();
-      await queryRunner.connect();
-      await queryRunner.startTransaction();
+      const user = await queryRunner.manager.find(User, { where: { checkGuest: true } });
+      const userIds = user.map((u) => u.id);
+
+      const reservationIds = await queryRunner.manager.find(Reservation, { where: { user: In(userIds) } });
+      await queryRunner.manager.delete(ReservedSeat, { reservation: In(reservationIds.map((r) => r.id)) });
+      await queryRunner.manager.delete(Reservation, { user: In(userIds) });
+      await queryRunner.manager.delete(User, { id: In(userIds) });
+
+      await queryRunner.commitTransaction();
 
       return this.userRepository.deleteAllGuest();
     } catch (err) {
       this.logger.error(err.name, err.stack);
+      await queryRunner.rollbackTransaction();
       throw new InternalServerErrorException('게스트 사용자 삭제에 실패하였습니다.');
     }
   }

front/src/components/Navbar/index.tsx

@@ -83,7 +83,7 @@ export default function Navbar() {
           const sliced = data.loginId.slice(0, 12);
           if (login) {
             login(sliced);
-            toast.success('geust로 로그인 되었습니다');
+            toast.success('guest로 로그인 되었습니다');
           }
         })
         .catch(() => {