jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -2,294 +2,341 @@ import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
 import dayjs from 'dayjs';
 import schedule, { Job } from 'node-schedule';
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    BaseGameEvent,
-    GameMaster,
-    GamePlayer,
-    GameTableFinishedEvent,
-    GameTournamentCancelledEvent,
-    GameTournamentFinishedEvent,
-    GameTournamentPlayerJoinedTheTournamentEvent,
-    GameTournamentPlayerLeavedTheTournamentEvent,
-    GameTournamentStartedEvent,
-    GameTournamentWaitedEvent,
-    ManyTablesTournamentRoom,
-    ManyTablesTournamentRoomConfig,
-    NoStartStrategy,
-    RoomUpdateStateEvent,
-    TournamentMaster
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  BaseGameEvent,
+  GameMaster,
+  GamePlayer,
+  GameTableFinishedEvent,
+  GameTournamentCancelledEvent,
+  GameTournamentFinishedEvent,
+  GameTournamentPlayerJoinedTheTournamentEvent,
+  GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentStartedEvent,
+  GameTournamentWaitedEvent,
+  ManyTablesTournamentRoom,
+  ManyTablesTournamentRoomConfig,
+  NoStartStrategy,
+  RoomUpdateStateEvent,
+  TournamentMaster,
 } from 'jp.ms.common.engine';
 import {
-    GameResultRepository,
-    PurchaseRepository,
-    TournamentManyTablesRoomDocument,
-    TournamentManyTablesRoomsRepository,
-    UsersRepository
+  GameResultRepository,
+  PurchaseRepository,
+  TournamentManyTablesRoomDocument,
+  TournamentManyTablesRoomsRepository,
+  UsersRepository,
 } from 'jp.db.schemas';
 
-import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
+import {
+  saveGameTablesResult,
+  saveTournamentResult,
+} from '../../utils/game-table-result';
 import { JpLoggerService } from '../logger';
 import { getHours, getMinutes } from '../../utils/date';
 import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
 import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
-import { EventsBusMainTablesSubscribeService, EventsBusManyTablesTournamentSubscribeService } from '../event-bus';
+import {
+  EventsBusMainTablesSubscribeService,
+  EventsBusManyTablesTournamentSubscribeService,
+} from '../event-bus';
 
 import { TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS } from './tournament-many-tables-rooms-manager.constants';
 import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-tables-rooms-manager.interfaces';
 
-
 @Injectable()
 export class TournamentManyTablesRoomsManagerService {
-    private readonly rooms: Map<string, ManyTablesTournamentRoom>;
-    private createDailyTournamentJob: Job | null;
-
-    constructor(
-        private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
-        private readonly usersRepository: UsersRepository,
-        private readonly gameResultRepository: GameResultRepository,
-        private readonly purchaseRepository: PurchaseRepository,
-        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
-        @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
-        @InjectConnection() private readonly connection: Connection,
-        @Inject() private readonly logger: JpLoggerService,
-    ) {
-        this.rooms = new Map<string, ManyTablesTournamentRoom>();
-        this.createDailyTournamentJob = null;
-    }
-
-    get gameType () {
-        return this.options.configService.get<string>('GAME_TYPE') || '';
+  private readonly rooms: Map<string, ManyTablesTournamentRoom>;
+  private createDailyTournamentJob: Job | null;
+
+  constructor(
+    private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly purchaseRepository: PurchaseRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS)
+    private readonly options: TournamentManyTablesRoomsFactoryOptions,
+    @InjectConnection() private readonly connection: Connection,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.rooms = new Map<string, ManyTablesTournamentRoom>();
+    this.createDailyTournamentJob = null;
+  }
+
+  get gameType() {
+    return this.options.configService.get<string>('GAME_TYPE') || '';
+  }
+
+  getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  getRooms(): Array<ManyTablesTournamentRoom> {
+    return Array.from(this.rooms.values());
+  }
+
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
+  }
+
+  addRoom(room: ManyTablesTournamentRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
+    templates.forEach((item) => {
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(item),
+        ),
+      );
+    });
+  }
+
+  async runDailyTournamentJob() {
+    const dailyTournamentScheduleTaskTime =
+      this.options.configService.get<string>(
+        'DAILY_TOURNAMENT_SCHEDULE_TASK_TIME',
+      );
+    const dailyTournamentTime = this.options.configService.get<string>(
+      'DAILY_TOURNAMENT_TIME',
+    );
+
+    if (dailyTournamentScheduleTaskTime && dailyTournamentTime) {
+      await this.createDailyTournament(dailyTournamentTime);
+
+      this.createDailyTournamentJob = schedule.scheduleJob(
+        dailyTournamentScheduleTaskTime,
+        () => this.createDailyTournament(dailyTournamentTime),
+      );
     }
-
-    getRoomById (roomId: string): ManyTablesTournamentRoom | undefined {
-        return this.rooms.get(roomId);
-    }
-
-    getRoomByTableId (tableId: string): ManyTablesTournamentRoom | undefined {
-        const { roomId } = GameMaster.parseTableId(tableId);
-
-        return this.getRoomById(roomId);
+  }
+
+  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    const newTournament =
+      await this.tournamentRepository.createTournament(createTournamentDto);
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+      ),
+    );
+  }
+
+  async updateTournament(
+    tournamentId: string,
+    updateTournamentDto: ManyTablesTournamentUpdateDto,
+  ) {
+    const updatedTournament = await this.tournamentRepository.updateTournament(
+      tournamentId,
+      updateTournamentDto,
+    );
+
+    this.getRoomById(tournamentId)
+      ?.getRoomMaster<TournamentMaster>()
+      .cancelTournament();
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament),
+      ),
+    );
+  }
+
+  async removeTournament(tournamentId: string) {
+    await this.tournamentRepository.removeTournament(tournamentId);
+  }
+
+  async buyTicket(tournamentId: string, player: GamePlayer) {
+    const tournament = this.getRoomById(tournamentId);
+    const user = await this.usersRepository.findById(player.id);
+
+    if (!tournament || !user) {
+      throw new InternalServerErrorException();
     }
 
-    getRooms (): Array<ManyTablesTournamentRoom> {
-        return Array.from(this.rooms.values());
-    }
-
-    getTables (): Array<GameMaster> {
-        return this.getRooms().reduce(
-            (result, currentValue) => {
-                return [...result, ...currentValue.getMasters()];
-            },
-            [] as Array<GameMaster>
-        );
+    const session = await this.connection.startSession();
+    session.startTransaction();
+
+    try {
+      player.decreaseBalance(tournament.getTicketPrice());
+      tournament.addParticipant(player);
+      void this.purchaseRepository.addManyTablesTournamentTicketPurchase(
+        player.id,
+        player.fullName,
+        tournamentId,
+        tournament.getTicketPrice(),
+        tournament.getGameType(),
+      );
+      void this.usersRepository.subtractFromBalance(
+        player.id,
+        tournament.getTicketPrice(),
+      );
+
+      await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+        playerId: player.id,
+        playerAvatarUrl: player.avatarUrl,
+        playerName: player.fullName,
+      });
+
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
     }
-
-    addRoom (room: ManyTablesTournamentRoom) {
-        this.rooms.set(room.getId(), room);
-    }
-
-    async hydrateTournamentsFromDB () {
-        const templates = await this.tournamentRepository.findActualTournaments(this.gameType);
-        templates.forEach((item) => {
-            this.addRoom(this.options.createTournamentRoom(
-                this.manyTablesTournamentDocumentToTournamentRoom(item)
-            ));
-        });
-    }
-
-    async runDailyTournamentJob () {
-        const dailyTournamentScheduleTaskTime = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_TASK_TIME');
-        const dailyTournamentTime = this.options.configService.get<string>('DAILY_TOURNAMENT_TIME');
-
-        if (dailyTournamentScheduleTaskTime && dailyTournamentTime) {
-            await this.createDailyTournament(dailyTournamentTime);
-
-            this.createDailyTournamentJob = schedule.scheduleJob(
-                dailyTournamentScheduleTaskTime,
-                () => this.createDailyTournament(dailyTournamentTime),
-            );
-        }
-    }
-
-    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
-        const newTournament = await this.tournamentRepository.createTournament(createTournamentDto);
-
-        this.addRoom(this.options.createTournamentRoom(
-            this.manyTablesTournamentDocumentToTournamentRoom(newTournament)
-        ));
-    }
-
-    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
-        const updatedTournament = await this.tournamentRepository.updateTournament(tournamentId, updateTournamentDto);
-
-        this.getRoomById(tournamentId)?.getRoomMaster<TournamentMaster>().cancelTournament();
-
-        this.addRoom(this.options.createTournamentRoom(
-            this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament)
-        ));
-    }
-
-    async removeTournament (tournamentId: string) {
-        await this.tournamentRepository.removeTournament(tournamentId);
-    }
-
-    async buyTicket (tournamentId: string, player: GamePlayer) {
-        const tournament = this.getRoomById(tournamentId);
-        const user = await this.usersRepository.findById(player.id);
-
-        if (!tournament || !user) {
-            throw new InternalServerErrorException();
-        }
-
-        const session = await this.connection.startSession();
-        session.startTransaction();
-
-        try {
-            player.decreaseBalance(tournament.getTicketPrice());
-            tournament.addParticipant(player);
-            this.purchaseRepository.addManyTablesTournamentTicketPurchase(
-                player.id,
-                player.fullName,
-                tournamentId,
-                tournament.getTicketPrice(),
-                tournament.getGameType(),
-            )
-            this.usersRepository.subtractFromBalance(player.id, tournament.getTicketPrice());
-
-            await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
-                playerId: player.id,
-                playerAvatarUrl: player.avatarUrl,
-                playerName: player.fullName,
-            });
-
-            await session.commitTransaction();
-        } catch (error) {
-            await session.abortTransaction();
-            throw error;
-        } finally {
-            await session.endSession();
-        }
-    }
-
-    private manyTablesTournamentDocumentToTournamentRoom (tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
-        const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
-        const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-        const minPlayersForMergeTables = this.options.configService.get<string>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES');
-
-        return {
-            id: tournamentDocument.tournamentId,
-            gameType: tournamentDocument.gameType,
-            roomType: tournamentDocument.roomType,
-            rulesType: tournamentDocument.rulesType,
-            deckType: tournamentDocument.deckType,
-            tableSize: tournamentDocument.tableSize,
-            bet: tournamentDocument.bet,
-            ticketPrice: tournamentDocument.ticketPrice,
-            title: tournamentDocument.title,
-            subtitle: tournamentDocument.subtitle,
-            description: tournamentDocument.description,
-            enableForFastGame: false,
-            scheduleDate: tournamentDocument.scheduleDate,
-            turnTimeout: playersTurnTimeout,
-            restartTimeout: restartGameTimeout,
-            minPlayersForMergeTables: parseInt(minPlayersForMergeTables ?? '0', 10),
-            localeService: this.options.i18n,
-            startStrategy: new NoStartStrategy(),
-            onRoomEvent: this.handleRoomEvent,
-            tournamentPrizeTable: this.options.tournamentPrizeTable,
-            tournamentInitialStatus: tournamentDocument.status,
-            tournamentWinners: tournamentDocument.winners,
-            maxParticipants: tournamentDocument.maxParticipants,
-            participants: tournamentDocument.participants,
-        } as ManyTablesTournamentRoomConfig;
-    }
-
-    private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
-
-        if (event instanceof GameTableFinishedEvent) {
-            this.handleRoomTableGameFinished(event.master!!);
-        } else if (event instanceof GameTournamentStartedEvent) {
-            this.handleTournamentRoomStarted(event.room.getRoomMaster());
-        } else if (event instanceof GameTournamentCancelledEvent) {
-            this.handleTournamentRoomCancelled(event.room.getRoomMaster());
-        } else if (event instanceof GameTournamentFinishedEvent) {
-            this.handleTournamentRoomFinished(event.room.getRoomMaster());
-        } else if (
-            event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
-            event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
-            event instanceof GameTournamentCancelledEvent ||
-            event instanceof GameTournamentWaitedEvent ||
-            event instanceof GameTournamentStartedEvent ||
-            event instanceof GameTournamentFinishedEvent
-        ) {
-            this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
-        }
-    };
-
-    private handleRoomTableGameFinished = async (master: GameMaster) => {
-        await saveGameTablesResult(
-            master,
-            this.connection,
-            this.gameResultRepository,
-            this.usersRepository,
-            false,
-        );
+  }
+
+  private manyTablesTournamentDocumentToTournamentRoom(
+    tournamentDocument: TournamentManyTablesRoomDocument,
+  ): ManyTablesTournamentRoomConfig {
+    const restartGameTimeout =
+      this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
+    const playersTurnTimeout =
+      this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
+    const minPlayersForMergeTables = this.options.configService.get<string>(
+      'TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES',
+    );
+
+    return {
+      id: tournamentDocument.tournamentId,
+      gameType: tournamentDocument.gameType,
+      roomType: tournamentDocument.roomType,
+      rulesType: tournamentDocument.rulesType,
+      deckType: tournamentDocument.deckType,
+      tableSize: tournamentDocument.tableSize,
+      bet: tournamentDocument.bet,
+      ticketPrice: tournamentDocument.ticketPrice,
+      title: tournamentDocument.title,
+      subtitle: tournamentDocument.subtitle,
+      description: tournamentDocument.description,
+      enableForFastGame: false,
+      scheduleDate: tournamentDocument.scheduleDate,
+      turnTimeout: playersTurnTimeout,
+      restartTimeout: restartGameTimeout,
+      minPlayersForMergeTables: parseInt(minPlayersForMergeTables ?? '0', 10),
+      localeService: this.options.i18n,
+      startStrategy: new NoStartStrategy(),
+      onRoomEvent: this.handleRoomEvent,
+      tournamentPrizeTable: this.options.tournamentPrizeTable,
+      tournamentInitialStatus: tournamentDocument.status,
+      tournamentWinners: tournamentDocument.winners,
+      maxParticipants: tournamentDocument.maxParticipants,
+      participants: tournamentDocument.participants,
     };
-
-    private handleTournamentRoomStarted = async (master: TournamentMaster) => {
-        await this.tournamentRepository.startTournament(master.getTournamentId());
-    }
-
-    private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
-        await this.tournamentRepository.cancelTournament(master.getTournamentId());
-    }
-
-    private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-        await saveTournamentResult(
-            master,
-            this.connection,
-            this.tournamentRepository,
-            this.usersRepository,
-        );
-    }
-
-    private handleRoomStatusUpdated = async (event: RoomUpdateStateEvent) => {
-        this.eventsBusMainTablesSubscribeService.pushNewRoomState(event)
-        this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  }
+
+  private handleRoomEvent = (event: BaseGameEvent) => {
+    this.logger.log(event.toLog());
+
+    if (event instanceof GameTableFinishedEvent) {
+      void this.handleRoomTableGameFinished(event.master);
+    } else if (event instanceof GameTournamentStartedEvent) {
+      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentCancelledEvent) {
+      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentFinishedEvent) {
+      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
+    } else if (
+      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
+      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
+      event instanceof GameTournamentCancelledEvent ||
+      event instanceof GameTournamentWaitedEvent ||
+      event instanceof GameTournamentStartedEvent ||
+      event instanceof GameTournamentFinishedEvent
+    ) {
+      void this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
     }
-
-    private createDailyTournament = async (dailyTournamentTime: string) => {
-        const hour = getHours(dailyTournamentTime);
-        const minutes = getMinutes(dailyTournamentTime);
-        const jobEveningDate = dayjs().set('hour', hour).set('minute', minutes).set('second', 0);
-        const addingDay = dayjs().isBefore(jobEveningDate) ? 0 : 1;
-
-        const startDate = dayjs().add(addingDay, 'day').startOf('day');
-        const endDate = dayjs().add(addingDay, 'day').endOf('day');
-
-        const tournamentDate = dayjs()
-            .add(addingDay, 'day')
-            .set('hour', hour)
-            .set('minute', minutes);
-
-        const waitedTournament = await this.tournamentRepository.findWaitingTournamentByDate(
-            this.gameType,
-            startDate.toDate(),
-            endDate.toDate(),
+  };
+
+  private handleRoomTableGameFinished = async (master: GameMaster) => {
+    await saveGameTablesResult(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      false,
+    );
+  };
+
+  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+    await this.tournamentRepository.startTournament(master.getTournamentId());
+  };
+
+  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+    await this.tournamentRepository.cancelTournament(master.getTournamentId());
+  };
+
+  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
+    await saveTournamentResult(
+      master,
+      this.connection,
+      this.tournamentRepository,
+      this.usersRepository,
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  };
+
+  private createDailyTournament = async (dailyTournamentTime: string) => {
+    const hour = getHours(dailyTournamentTime);
+    const minutes = getMinutes(dailyTournamentTime);
+    const jobEveningDate = dayjs()
+      .set('hour', hour)
+      .set('minute', minutes)
+      .set('second', 0);
+    const addingDay = dayjs().isBefore(jobEveningDate) ? 0 : 1;
+
+    const startDate = dayjs().add(addingDay, 'day').startOf('day');
+    const endDate = dayjs().add(addingDay, 'day').endOf('day');
+
+    const tournamentDate = dayjs()
+      .add(addingDay, 'day')
+      .set('hour', hour)
+      .set('minute', minutes);
+
+    const waitedTournament =
+      await this.tournamentRepository.findWaitingTournamentByDate(
+        this.gameType,
+        startDate.toDate(),
+        endDate.toDate(),
+      );
+
+    if (!waitedTournament) {
+      const newTournament =
+        await this.tournamentRepository.scheduleTournamentFromMasterTemplate(
+          this.gameType,
+          tournamentDate.toDate(),
         );
 
-        if (!waitedTournament) {
-            const newTournament = await this.tournamentRepository.scheduleTournamentFromMasterTemplate(
-                this.gameType,
-                tournamentDate.toDate(),
-            );
-
-            this.addRoom(this.options.createTournamentRoom(
-                this.manyTablesTournamentDocumentToTournamentRoom(newTournament)
-            ));
-        }
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+        ),
+      );
     }
+  };
 }

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

@@ -1 +1,3 @@
-export const TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS = Symbol('TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS');
+export const TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS = Symbol(
+  'TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS',
+);

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

@@ -3,18 +3,25 @@ import { I18nService } from 'nestjs-i18n';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
 import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
-import { TournamentRoomConfig, OneTableTournamentRoom, IPrizeTableData } from 'jp.ms.common.engine';
+import {
+  TournamentRoomConfig,
+  OneTableTournamentRoom,
+  IPrizeTableData,
+} from 'jp.ms.common.engine';
 import { ConfigService } from '@nestjs/config';
 
-export interface TournamentOneTableRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface TournamentOneTableRoomsManagerOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface TournamentOneTableRoomsFactoryOptions {
-    i18n: I18nService;
-    configService: ConfigService;
-    tournamentPrizeTable: IPrizeTableData;
-    createTournamentRoom (room: TournamentRoomConfig): OneTableTournamentRoom;
+  i18n: I18nService;
+  configService: ConfigService;
+  tournamentPrizeTable: IPrizeTableData;
+  createTournamentRoom(room: TournamentRoomConfig): OneTableTournamentRoom;
 }