jp.ms.common.modules 1.0.54 → 1.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "dayjs": "1.11.18",
     "jp.common.models": "1.1.61",
     "jp.common.utils": "1.0.9",
-    "jp.db.schemas": "2.2.17",
-    "jp.ms.common.engine": "3.0.33",
+    "jp.db.schemas": "2.2.25",
+    "jp.ms.common.engine": "3.0.35",
     "mongoose": "9.1.5",
     "nestjs-i18n": "10.5.1",
     "node-schedule": "2.1.1",

package/src/exception/global-exception-filter.ts

@@ -23,16 +23,10 @@ export class GlobalExceptionFilter implements ExceptionFilter {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
 
-    switch (exception.constructor.name) {
-      case HttpExceptionWithSnackbar.name: {
-        return this.processHttpExceptionWithSnackbar(
-          exception as HttpExceptionWithSnackbar,
-          response,
-        );
-      }
-      case HttpException.name: {
-        return this.processHttpException(exception as HttpException, response);
-      }
+    if (exception instanceof HttpExceptionWithSnackbar) {
+      return this.processHttpExceptionWithSnackbar(exception, response);
+    } else if (exception instanceof HttpException) {
+      return this.processHttpException(exception, response);
     }
 
     response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({

package/src/modules/main/main-tables-list-screen.view.ts

@@ -123,7 +123,11 @@ export class MainTablesListScreenView extends UniversalScreenView {
           this.getOneTableTournamentIcon(room),
           true,
           true,
-          AppScreenRouter.getOneTableTournamentStatusPath(room.getId()),
+          room.getRoomMaster<TournamentMaster>().isInProgress()
+            ? AppScreenRouter.getOneTableTournamentTablePath(
+                room.getFirstMaster()?.getTable().getId() ?? '',
+              )
+            : AppScreenRouter.getOneTableTournamentStatusPath(room.getId()),
         ),
     );
   }
@@ -251,7 +255,10 @@ export class MainTablesListScreenView extends UniversalScreenView {
   }
 
   private getManyTablesTournamenButtons(tournament: ManyTablesTournamentRoom) {
-    if (tournament.isParticipant(this.playerId)) {
+    if (
+      tournament.isParticipant(this.playerId) ||
+      tournament.getRoomMaster<TournamentMaster>().isInProgress()
+    ) {
       return new PrimaryButtonButtonsComponent(
         new TextButtonComponent(
           this.localeService.t(

package/src/modules/main/main.controller.ts

@@ -43,7 +43,7 @@ export class MainController {
   }
 
   @Get('find_free_table')
-  findFreeTable(@Headers() headers: IAppHeaders): FindFreeTableDto {
+  findFreeTable(@Headers() headers: IAppHeaders): Promise<FindFreeTableDto> {
     return this.mainService.findFreeTable(
       headers.client_auth_token,
       headers.client_language,

package/src/modules/main/main.service.ts

@@ -29,6 +29,7 @@ import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tourname
 import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
 import {
   ErrorCodeEnum,
+  NotEnoughMoneyForPurchaseException,
   NotFoundFreeRoomForFastGameException,
 } from '../../exception';
 
@@ -140,11 +141,16 @@ export class MainService {
     return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
   }
 
-  findFreeTable(clientAuthToken: string, lang: string): FindFreeTableDto {
+  async findFreeTable(
+    clientAuthToken: string,
+    lang: string,
+  ): Promise<FindFreeTableDto> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
+    const table = this.simpleRoomsManager.getFreeFastGameRoom();
+    const tableId = table?.getId();
+    const user = await this.usersRepository.findById(player?.id ?? '');
 
-    if (!player || !tableId) {
+    if (!player || !table || !tableId || !user) {
       throw new NotFoundFreeRoomForFastGameException(
         new ErrorSnackbarComponent(
           ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
@@ -153,6 +159,17 @@ export class MainService {
       );
     }
 
+    if (user.balance < table.room.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', {
+            lang,
+          }),
+        ),
+      );
+    }
+
     return FindFreeTableDto.fromEntities(
       AppScreenRouter.getSimpleRoomTablePath(tableId),
       player.id,

package/src/modules/many-tables-tournament/many-tables-tournament.controller.ts

@@ -104,7 +104,7 @@ export class ManyTablesTournamentController {
   joinTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): JoinTournamentDto {
+  ): Promise<JoinTournamentDto> {
     return this.tournamentService.joinTournament(
       tournamentId,
       headers.client_auth_token,
@@ -116,7 +116,7 @@ export class ManyTablesTournamentController {
   leaveTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): void {
+  ): Promise<void> {
     return this.tournamentService.leaveTournament(
       tournamentId,
       headers.client_auth_token,

package/src/modules/many-tables-tournament/many-tables-tournament.module.ts

@@ -4,6 +4,9 @@ import {
   ManyTablesTournamentRoom,
   ManyTablesTournamentRoomSchema,
   ManyTablesTournamentRoomsRepository,
+  Purchase,
+  PurchaseRepository,
+  PurchaseSchema,
   User,
   UserSchema,
   UsersRepository,
@@ -31,12 +34,16 @@ import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.inte
       },
     ]),
     MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
   ],
   controllers: [ManyTablesTournamentController],
   providers: [
     ManyTablesTournamentService,
     ManyTablesTournamentRoomsRepository,
     UsersRepository,
+    PurchaseRepository,
   ],
 })
 export class ManyTablesTournamentModule {

package/src/modules/many-tables-tournament/many-tables-tournament.service.ts

@@ -9,11 +9,8 @@ import {
   AppScreenRouter,
   ErrorSnackbarComponent,
 } from 'jp.common.models';
-import {
-  ManyTablesTournamentMaster,
-  TournamentMaster,
-} from 'jp.ms.common.engine';
-import { UsersRepository } from 'jp.db.schemas';
+import { TournamentMaster } from 'jp.ms.common.engine';
+import { PurchaseRepository, UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
 import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
@@ -39,6 +36,7 @@ export class ManyTablesTournamentService {
     @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
     private readonly options: ManyTablesTournamentFactoryOptions,
     private readonly usersRepository: UsersRepository,
+    private readonly purchaseRepository: PurchaseRepository,
   ) {}
 
   getStatusScreen(
@@ -139,54 +137,58 @@ export class ManyTablesTournamentService {
     throw new InternalServerErrorException();
   }
 
-  joinTournament(
+  async joinTournament(
     tournamentId: string,
     clientAuthToken: string,
-  ): JoinTournamentDto {
+  ): Promise<JoinTournamentDto> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
     const tournament =
       this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    const ticket = await this.purchaseRepository.getManyTablesTournamentTicket(
+      tournamentId,
+      player?.id ?? '',
+    );
 
-    if (player && tournament) {
-      tournament.handleJoinTournament(player);
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
+    }
 
-      if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
-        if (player.isPlayer() || player.isTableQueuer()) {
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTablePath(
-              player.tableId ?? '',
-            ),
-            player.id,
-          );
-        } else if (tournament.isParticipant(player.id)) {
-          tournament
-            .getRoomMaster<ManyTablesTournamentMaster>()
-            .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
-
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTablePath(
-              player.tableId ?? '',
-            ),
-            player.id,
-          );
-        } else {
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
-            player.id,
-          );
-        }
+    if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+      if (tournament.isParticipant(player.id) && ticket?.amount) {
+        player.stack = ticket.amount;
+        tournament.handleJoinTournament(player);
+
+        return JoinTournamentDto.fromEntities(
+          AppScreenRouter.getManyTablesTournamentTablePath(
+            player.tableId ?? '',
+          ),
+          player.id,
+        );
       } else {
         return JoinTournamentDto.fromEntities(
-          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
           player.id,
         );
       }
-    }
+    } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+      tournament.handleJoinTournament(player);
 
-    throw new InternalServerErrorException();
+      return JoinTournamentDto.fromEntities(
+        AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+        player.id,
+      );
+    } else {
+      return JoinTournamentDto.fromEntities(
+        AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+        player.id,
+      );
+    }
   }
 
-  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+  async leaveTournament(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): Promise<void> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
     const tournament =
       this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
@@ -195,6 +197,20 @@ export class ManyTablesTournamentService {
       throw new InternalServerErrorException();
     }
 
+    if (tournament.isParticipant(player.id) && player.isPlayer()) {
+      const ticket =
+        await this.purchaseRepository.getManyTablesTournamentTicket(
+          tournament.getId(),
+          player.id,
+        );
+
+      if (ticket) {
+        await this.purchaseRepository.cancelManyTablesTournamentTicket(
+          ticket.purchaseId,
+        );
+      }
+    }
+
     tournament.handleLeaveTournament(player);
   }
 

package/src/modules/many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.interfaces.ts

@@ -35,4 +35,6 @@ export interface ManyTablesTournamentRoomsFactoryOptions {
   dailyTournamentTime: string;
   minPlayersForMergeTables: number;
   levelUpBonus: number;
+  purgeRoomsEnabled: boolean;
+  purgeRoomsTime: string;
 }

package/src/modules/many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.module.ts

@@ -91,6 +91,9 @@ export class ManyTablesTournamentRoomsManagerModule {
     if (this.options.dailyTournamentScheduleJobEnabled) {
       await this.managerService.runDailyTournamentJob();
     }
+    if (this.options.purgeRoomsEnabled) {
+      this.managerService.runPurgeRoomsJob();
+    }
     await this.managerService.hydrateTournamentsFromDB();
   }
 }

package/src/modules/many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service.ts

@@ -18,6 +18,7 @@ import {
   GameTournamentFinishedEvent,
   GameTournamentPlayerJoinedTheTournamentEvent,
   GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentPlayerLostTournamentEvent,
   GameTournamentStartedEvent,
   GameTournamentWaitedEvent,
   LocalService,
@@ -55,6 +56,7 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
 export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, ManyTablesTournamentRoom>;
   private createDailyTournamentJob: Job | null;
+  private purgeRoomsJob: Job;
 
   constructor(
     private readonly tournamentRepository: ManyTablesTournamentRoomsRepository,
@@ -84,6 +86,10 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     return this.rooms.get(roomId);
   }
 
+  removeRoom(roomId: string) {
+    this.rooms.delete(roomId);
+  }
+
   getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
@@ -131,6 +137,31 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     }
   }
 
+  runPurgeRoomsJob() {
+    const purgeRoomsTime = this.options.purgeRoomsTime;
+
+    if (purgeRoomsTime) {
+      this.logger.log(
+        `${ManyTablesTournamentRoomsManagerService.name}: runPurgeRoomsJob`,
+      );
+
+      this.purgeRoomsJob = schedule.scheduleJob(purgeRoomsTime, () =>
+        this.purgeRooms(),
+      );
+    }
+  }
+
+  purgeRooms() {
+    for (const room of this.getRooms()) {
+      if (!room.isActual()) {
+        this.removeRoom(room.getId());
+        this.logger.log(
+          `${ManyTablesTournamentRoomsManagerService.name}: removeRoom: ${room.getId()}`,
+        );
+      }
+    }
+  }
+
   async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
     const newTournament =
       await this.tournamentRepository.createTournament(createTournamentDto);
@@ -237,6 +268,7 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
       tournamentWinners: tournamentDocument.winners,
       maxParticipants: tournamentDocument.maxParticipants,
       participants: tournamentDocument.participants,
+      finishDate: tournamentDocument.finishDate,
     };
   }
 
@@ -284,7 +316,19 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
         this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
         break;
       }
-      case GamePlayerKickedOutTheTableEvent.name:
+      case GamePlayerKickedOutTheTableEvent.name: {
+        void this.handleGamePlayerKickedOutTheTable(
+          event as GamePlayerKickedOutTheTableEvent,
+        );
+        this.handleRoomStatusUpdated(event as GamePlayerKickedOutTheTableEvent);
+        break;
+      }
+      case GameTournamentPlayerLostTournamentEvent.name: {
+        void this.handleGameTournamentPlayerLostTournamentEvent(
+          event as GameTournamentPlayerLostTournamentEvent,
+        );
+        break;
+      }
       case GameTournamentPlayerJoinedTheTournamentEvent.name:
       case GameTournamentPlayerLeavedTheTournamentEvent.name:
       case GameTournamentWaitedEvent.name: {
@@ -292,8 +336,7 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
           event as
             | GameTournamentPlayerJoinedTheTournamentEvent
             | GameTournamentPlayerLeavedTheTournamentEvent
-            | GameTournamentCancelledEvent
-            | GamePlayerKickedOutTheTableEvent,
+            | GameTournamentCancelledEvent,
         );
         break;
       }
@@ -327,6 +370,41 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     );
   };
 
+  private handleGamePlayerKickedOutTheTable = async (
+    event: GamePlayerKickedOutTheTableEvent,
+  ) => {
+    await this.cancelTicket(event);
+  };
+
+  private handleGameTournamentPlayerLostTournamentEvent = async (
+    event: GameTournamentPlayerLostTournamentEvent,
+  ) => {
+    await this.cancelTicket(event);
+  };
+
+  private async cancelTicket(
+    event:
+      | GamePlayerKickedOutTheTableEvent
+      | GameTournamentPlayerLostTournamentEvent,
+  ) {
+    const tournament = this.getRoomById(event.roomId);
+    if (tournament?.isParticipant(event.playerId)) {
+      const ticket =
+        await this.purchaseRepository.getManyTablesTournamentTicket(
+          event.roomId,
+          event.playerId,
+        );
+
+      if (ticket) {
+        await this.purchaseRepository.cancelManyTablesTournamentTicket(
+          ticket.purchaseId,
+        );
+      }
+
+      tournament.handleLeaveTournament(event.player);
+    }
+  }
+
   private handleRoomStatusUpdated = (
     event:
       | GameTournamentPlayerJoinedTheTournamentEvent

package/src/modules/one-table-tournament/one-table-tournament.controller.ts

@@ -86,7 +86,7 @@ export class OneTableTournamentController {
   joinTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): IBaseAppScreen {
+  ): Promise<IBaseAppScreen> {
     return this.tournamentService.joinTournament(tournamentId, headers);
   }
 

package/src/modules/one-table-tournament/one-table-tournament.module.ts

@@ -4,6 +4,9 @@ import {
   OneTableTournamentRoom,
   OneTableTournamentRoomSchema,
   OneTableTournamentRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
 } from 'jp.db.schemas';
 import {
   GamePlayer,
@@ -27,9 +30,14 @@ import { OneTableTournamentModuleOptions } from './one-table-tournament.interfac
         schema: OneTableTournamentRoomSchema,
       },
     ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
   ],
   controllers: [OneTableTournamentController],
-  providers: [OneTableTournamentService, OneTableTournamentRoomsRepository],
+  providers: [
+    OneTableTournamentService,
+    OneTableTournamentRoomsRepository,
+    UsersRepository,
+  ],
 })
 export class OneTableTournamentModule {
   constructor(

package/src/modules/one-table-tournament/one-table-tournament.service.ts

@@ -8,11 +8,17 @@ import {
   IBaseAppScreen,
   IBaseMoveData,
   IAppTableState,
+  ErrorSnackbarComponent,
 } from 'jp.common.models';
+import { UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
 import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
 import { PlayersManagerService } from '../players-manager/players-manager.service';
+import {
+  NotEnoughMoneyForPurchaseException,
+  ErrorCodeEnum,
+} from '../../exception';
 
 import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
 import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
@@ -23,6 +29,7 @@ export class OneTableTournamentService {
   constructor(
     private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
     private readonly playersManager: PlayersManagerService,
+    private readonly usersRepository: UsersRepository,
     @Inject(ONE_TABLE_TOURNAMENT_OPTIONS)
     private readonly options: OneTableTournamentFactoryOptions,
   ) {}
@@ -112,22 +119,37 @@ export class OneTableTournamentService {
     throw new InternalServerErrorException();
   }
 
-  joinTournament(tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
+  async joinTournament(
+    tournamentId: string,
+    headers: IAppHeaders,
+  ): Promise<IBaseAppScreen> {
     const player = this.playersManager.getPlayerById(headers.client_auth_token);
     const tournament =
       this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
 
-    if (player && tournament) {
-      tournament.handleJoinTournament(player);
+    if (!player || !tournament || !user) {
+      throw new InternalServerErrorException();
+    }
 
-      return this.getStatusScreen(
-        tournamentId,
-        headers.client_language,
-        headers.client_auth_token,
+    if (user.balance < tournament.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', {
+            lang: headers.client_language,
+          }),
+        ),
       );
     }
 
-    throw new InternalServerErrorException();
+    tournament.handleJoinTournament(player);
+
+    return this.getStatusScreen(
+      tournamentId,
+      headers.client_language,
+      headers.client_auth_token,
+    );
   }
 
   leaveTournament(tournamentId: string, clientAuthToken: string): void {

package/src/modules/one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.interfaces.ts

@@ -29,4 +29,6 @@ export interface OneTableTournamentRoomsFactoryOptions {
   instantFinishMode: boolean;
   tournamentPrizeTable: IPrizeTableData;
   levelUpBonus: number;
+  purgeRoomsEnabled: boolean;
+  purgeRoomsTime: string;
 }

package/src/modules/one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.module.ts

@@ -1,4 +1,10 @@
-import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
   OneTableTournamentRoom,
@@ -16,10 +22,16 @@ import {
   ActivityLog,
   ActivityLogRepository,
   ActivityLogSchema,
+  Purchase,
+  PurchaseRepository,
+  PurchaseSchema,
 } from 'jp.db.schemas';
 
 import { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';
-import { OneTableTournamentRoomsManagerOptions } from './one-table-tournament-rooms-manager.interfaces';
+import {
+  OneTableTournamentRoomsFactoryOptions,
+  OneTableTournamentRoomsManagerOptions,
+} from './one-table-tournament-rooms-manager.interfaces';
 import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
 
 @Global()
@@ -39,6 +51,9 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     MongooseModule.forFeature([
       { name: ActivityLog.name, schema: ActivityLogSchema },
     ]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
   ],
   providers: [
     OneTableTournamentRoomsRepository,
@@ -47,12 +62,15 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     GameResultRepository,
     RatingRepository,
     ActivityLogRepository,
+    PurchaseRepository,
   ],
   exports: [OneTableTournamentRoomsManagerService],
 })
 export class OneTableTournamentRoomsManagerModule {
   constructor(
     private readonly managerService: OneTableTournamentRoomsManagerService,
+    @Inject(ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: OneTableTournamentRoomsFactoryOptions,
   ) {}
 
   static forRootAsync(
@@ -74,5 +92,9 @@ export class OneTableTournamentRoomsManagerModule {
   async onModuleInit() {
     await this.managerService.createMasterTournament();
     await this.managerService.hydrateTournamentsFromDB();
+
+    if (this.options.purgeRoomsEnabled) {
+      this.managerService.runPurgeRoomsJob();
+    }
   }
 }