jp.ms.common.modules 1.0.18 → 1.0.21

package/src/modules/simple-rooms-manager/simple-rooms-manager.module.ts

@@ -1,9 +1,9 @@
-import { DynamicModule, Global, Inject, Module, Provider } from '@nestjs/common';
-import { MongooseModule, InjectConnection } from '@nestjs/mongoose';
+import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
 import {
-    Room,
-    RoomSchema,
-    RoomsRepository,
+    SimpleRoom,
+    SimpleRoomSchema,
+    SimpleRoomsRepository,
     User,
     UserSchema,
     UsersRepository,
@@ -11,24 +11,20 @@ import {
     GameResultSchema,
     GameResultRepository,
 } from 'jp.db.schemas';
-import { BaseGameEvent, GameMaster, MinPlayersStartStrategy } from 'jp.ms.common.engine';
-import { Connection } from 'mongoose';
-
-import { JpLoggerService } from '../logger/jp-logger.service';
 
 import { SimpleRoomsManagerService } from './simple-rooms-manager.service';
-import { SimpleRoomsFactoryOptions, SimpleRoomsManagerOptions } from './simple-rooms-manager.interfaces';
+import { SimpleRoomsManagerOptions } from './simple-rooms-manager.interfaces';
 import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 
 @Global()
 @Module({
     imports: [
-        MongooseModule.forFeature([{ name: Room.name, schema: RoomSchema }]),
-        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-        MongooseModule.forFeature([{ name: GameResult.name, schema: GameResultSchema }]),
+        MongooseModule.forFeature([{name: SimpleRoom.name, schema: SimpleRoomSchema}]),
+        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
+        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
     ],
     providers: [
-        RoomsRepository,
+        SimpleRoomsRepository,
         UsersRepository,
         GameResultRepository,
         SimpleRoomsManagerService,
@@ -37,13 +33,7 @@ import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 })
 export class SimpleRoomsManagerModule {
     constructor (
-        private readonly roomsRepository: RoomsRepository,
-        private readonly usersRepository: UsersRepository,
-        private readonly gameResultRepository: GameResultRepository,
         private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
-        @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
-        @InjectConnection() private readonly connection: Connection,
-        @Inject() private readonly logger: JpLoggerService,
     ) {
     }
 
@@ -62,102 +52,7 @@ export class SimpleRoomsManagerModule {
     }
 
     async onModuleInit () {
-        const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
-        const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-        const game = this.options.configService.get<string>('GAME_TYPE') || '';
-
-        const templates = await this.roomsRepository.findRooms(game);
-
-        templates.forEach((item) => {
-            const newRoom = this.options.createRoom({
-                id: item.roomId,
-                gameType: item.gameType,
-                roomType: item.roomType,
-                rulesType: item.rulesType,
-                maxPlayers: item.maxPlayers,
-                bet: item.bet,
-                ticketPrice: item.limit / 2,
-                title: item.title,
-                subtitle: item.subtitle,
-                turnTimeout: playersTurnTimeout,
-                restartTimeout: restartGameTimeout,
-                localeService: this.options.i18n,
-                startStrategy: new MinPlayersStartStrategy(),
-                onRoomEvent: this.handleRoomEvent,
-                onRoomTableGameFinished: this.handleRoomTableGameFinished,
-                deckType: item.deckType,
-            });
-
-            newRoom.addMaster();
-
-            this.simpleRoomsManagerService.addRoom(newRoom);
-        });
+        await this.simpleRoomsManagerService.hydrateRoomsFromDB();
     }
-
-    private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
-    };
-
-    private handleRoomTableGameFinished = async (master: GameMaster) => {
-        const userGameResult = master.getTable().getPlayers().map((player) => {
-            return {
-                userId: player.id,
-                balanceAdding: player.profit,
-                experienceAdding: master.levelHelper.getNewExperienceAmount(player),
-                levelAdding: master.levelHelper.getNewLevelAdding(player.level, player.experience),
-            };
-        });
-
-        const gameResult = {
-            gameType: master.getRoom().getGameType(),
-            gameId: master.getGameRound()?.getId() ?? '',
-            roomId: master.getRoom().getId(),
-            date: new Date(),
-            pot: master.getGameRound()?.getPot() ?? 0,
-            extraData: { a: 1, b: false },
-            players: master.getTable().getPlayers().map((item) => ({
-                userId: item.id,
-                fullName: item.fullName,
-                profit: item.profit,
-                figures: [],
-            })),
-            winners: master.getGameResultHelper().getWinners().map((item) => ({
-                userId: item.id,
-                fullName: item.fullName,
-                profit: item.profit,
-                figures: [],
-            })),
-            history: master.getGameRound()?.getHistory().map((item) => ({
-                userId: item.userId,
-                fullName: item.fullName,
-                date: item.date,
-                actionType: item.actionType,
-                state: item.state,
-                turnNumber: item.turnNumber,
-                moveAction: item.move?.action,
-                moveData: item.move ?? undefined,
-                figures: item.figures?.map((item) => ({
-                    figureId: item.id,
-                    type: item.type,
-                    name: item.getName(),
-                })) ?? [],
-            })) ?? []
-        };
-
-        const session = await this.connection.startSession();
-        session.startTransaction();
-
-        try {
-            await this.gameResultRepository.createGameResult(gameResult);
-            await this.usersRepository.saveGameResult(userGameResult);
-
-            await session.commitTransaction();
-        } catch (error) {
-            await session.abortTransaction();
-            throw error;
-        } finally {
-            await session.endSession();
-        }
-    };
 }
 

package/src/modules/simple-rooms-manager/simple-rooms-manager.service.ts

@@ -1,29 +1,131 @@
-import { Injectable } from '@nestjs/common';
-import { GameMaster, SimpleRoom } from 'jp.ms.common.engine';
+import { Inject, Injectable } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import {
+    BaseGameEvent,
+    GameMaster,
+    MinPlayersStartStrategy,
+    SimpleRoom,
+    GameRoomConfig,
+    RoomUpdateStateEvent,
+    UserWonTheGameAppEvent,
+} from 'jp.ms.common.engine';
+import {
+    GameResultRepository,
+    SimpleRoomDocument,
+    SimpleRoomsRepository,
+    UsersRepository
+} from 'jp.db.schemas';
+
+import { JpLoggerService } from '../logger/jp-logger.service';
+import { saveGameTablesResult } from '../../utils/game-table-result';
+import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
+import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
+
+import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
+import { SimpleRoomsFactoryOptions } from './simple-rooms-manager.interfaces';
 
 @Injectable()
 export class SimpleRoomsManagerService {
-  private readonly rooms: Map<string, SimpleRoom>;
+    private readonly rooms: Map<string, SimpleRoom>;
+
+    constructor(
+        private readonly roomsRepository: SimpleRoomsRepository,
+        private readonly usersRepository: UsersRepository,
+        private readonly gameResultRepository: GameResultRepository,
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
+        @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
+        @InjectConnection() private readonly connection: Connection,
+        @Inject() private readonly logger: JpLoggerService,
+    ) {
+        this.rooms = new Map<string, SimpleRoom>();
+    }
+
+    get gameType() {
+        return this.options.configService.get<string>('GAME_TYPE') || '';
+    }
+
+    getRoomById(roomId: string): SimpleRoom | undefined {
+        return this.rooms.get(roomId);
+    }
+
+    getRoomByTableId(tableId: string): SimpleRoom | undefined {
+        const { roomId } = GameMaster.parseTableId(tableId);
+
+        return this.getRoomById(roomId);
+    }
+
+    getRooms(): Array<SimpleRoom> {
+        return Array.from(this.rooms.values());
+    }
+
+    getTables(): Array<GameMaster> {
+        return this.getRooms().reduce(
+            (result, currentValue) => {
+                return [...result, ...currentValue.getMasters()];
+            }, [] as Array<GameMaster>);
+    }
+
+    addRoom(room: SimpleRoom) {
+        this.rooms.set(room.getId(), room);
+    }
+
+    async hydrateRoomsFromDB() {
+        const templates = await this.roomsRepository.findRooms(this.gameType);
+
+        templates.forEach((item) => {
+            const newRoom = this.options.createRoom(
+                this.simpleRoomDocumentToTournamentRoom(item)
+            );
+            this.addRoom(newRoom);
+        });
+    }
 
-  constructor () {
-    this.rooms = new Map<string, SimpleRoom>();
-  }
+    private simpleRoomDocumentToTournamentRoom(room: SimpleRoomDocument): GameRoomConfig {
+        const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
+        const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
 
-  getRoomById (roomId: string): SimpleRoom | undefined {
-    return this.rooms.get(roomId);
-  }
+        return {
+            id: room.roomId,
+            gameType: room.gameType,
+            roomType: room.roomType,
+            rulesType: room.rulesType,
+            deckType: room.deckType,
+            tableSize: room.tableSize,
+            bet: room.bet,
+            ticketPrice: room.ticketPrice / 2,
+            title: room.title,
+            subtitle: room.subtitle,
+            description: room.description,
+            turnTimeout: playersTurnTimeout,
+            restartTimeout: restartGameTimeout,
+            localeService: this.options.i18n,
+            startStrategy: new MinPlayersStartStrategy(),
+            onRoomEvent: this.handleRoomEvent,
+            onRoomTableGameFinished: this.handleRoomTableGameFinished,
+            onRoomStatusUpdated: this.handleRoomStatusUpdated,
+        } as GameRoomConfig;
+    }
 
-  getRoomByTableId (tableId: string): SimpleRoom | undefined {
-    const { roomId } = GameMaster.parseTableId(tableId);
+    private handleRoomEvent = (event: BaseGameEvent) => {
+        this.logger.log(event.toLog());        
+    };
 
-    return this.getRoomById(roomId);
-  }
+    private handleRoomTableGameFinished = async (master: GameMaster) => {
+        await saveGameTablesResult(
+            master,
+            this.connection,
+            this.gameResultRepository,
+            this.usersRepository,
+            true,
+        );
 
-  getRooms (): Array<SimpleRoom> {
-    return Array.from(this.rooms.values());
-  }
+        // TODO: записать разные события для достижений
+        this.eventsBusAppSubscribeService.pushNewEvent(new UserWonTheGameAppEvent('123'));
+    };
 
-  addRoom (room: SimpleRoom) {
-    this.rooms.set(room.getId(), room);
-  }
+    private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+        this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    };
 }

package/src/modules/support/index.ts

@@ -0,0 +1 @@
+export { SupportModule } from './support.module';

package/src/modules/support/support.controller.ts

@@ -61,4 +61,10 @@ export class SupportController {
             });
         })
     }
+
+    @Post('techBreakOn')
+    @HttpCode(HttpStatus.OK)
+    techBreakOn (): boolean {
+        return this.supportService.techBreakOn();
+    }
 }

package/src/modules/support/support.service.ts

@@ -2,15 +2,23 @@ import { Injectable } from '@nestjs/common';
 
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 import { PlayerConnectedDto } from '../../dto/common/player-connected.dto';
+import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
 
 @Injectable()
 export class SupportService {
     constructor (
         private readonly playersManager: PlayersManagerService,
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
     ) {
     }
 
     async getUsers (): Promise<Array<PlayerConnectedDto>> {
         return this.playersManager.getPlayers().map((item) => PlayerConnectedDto.fromEntities(item));
     }
+
+    techBreakOn (): boolean {
+        this.simpleRoomsManager.getRooms().forEach((item) => item.handleTechBreakOn());
+
+        return true;
+    }
 }

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

@@ -0,0 +1,2 @@
+export { TournamentManyTablesRoomsManagerModule } from './tournament-many-tables-rooms-manager.module';
+export { TournamentManyTablesRoomsManagerService } from './tournament-many-tables-rooms-manager.service';

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

@@ -0,0 +1 @@
+export const TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS = Symbol('TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS');

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

@@ -0,0 +1,20 @@
+import { ModuleMetadata } from '@nestjs/common';
+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 { ManyTablesTournamentRoomConfig, ManyTablesTournamentRoom, IPrizeTableData } from 'jp.ms.common.engine';
+import { ConfigService } from '@nestjs/config';
+
+export interface TournamentManyTablesRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface TournamentManyTablesRoomsFactoryOptions {
+    i18n: I18nService;
+    configService: ConfigService;
+    tournamentPrizeTable: IPrizeTableData;
+    createTournamentRoom (room: ManyTablesTournamentRoomConfig): ManyTablesTournamentRoom;
+}

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

@@ -0,0 +1,61 @@
+import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+    TournamentManyTablesRoom,
+    TournamentManyTablesRoomSchema,
+    TournamentManyTablesRoomsRepository,
+    User,
+    UserSchema,
+    UsersRepository,
+    GameResult,
+    GameResultSchema,
+    GameResultRepository,
+} from 'jp.db.schemas';
+
+import { TournamentManyTablesRoomsManagerService } from './tournament-many-tables-rooms-manager.service';
+import {
+    TournamentManyTablesRoomsManagerOptions,
+} from './tournament-many-tables-rooms-manager.interfaces';
+import { TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS } from './tournament-many-tables-rooms-manager.constants';
+
+@Global()
+@Module({
+    imports: [
+        MongooseModule.forFeature([{name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema}]),
+        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
+        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
+    ],
+    providers: [
+        TournamentManyTablesRoomsRepository,
+        UsersRepository,
+        TournamentManyTablesRoomsManagerService,
+        GameResultRepository,
+    ],
+    exports: [TournamentManyTablesRoomsManagerService],
+})
+export class TournamentManyTablesRoomsManagerModule {
+    constructor (
+        private readonly managerService: TournamentManyTablesRoomsManagerService,
+    ) {
+    }
+
+    static forRootAsync (options: TournamentManyTablesRoomsManagerOptions): DynamicModule {
+        return {
+            module: TournamentManyTablesRoomsManagerModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+
+    async onModuleInit () {
+        await this.managerService.runDailyTournamentJob();
+        await this.managerService.hydrateTournamentsFromDB();
+    }
+}
+

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

@@ -0,0 +1,239 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+    BaseGameEvent,
+    GameMaster,
+    GamePlayer,
+    ManyTablesTournamentRoom,
+    ManyTablesTournamentRoomConfig,
+    NoStartStrategy,
+    RoomUpdateStateEvent,
+    TournamentMaster
+} from 'jp.ms.common.engine';
+import {
+    GameResultRepository,
+    TournamentManyTablesRoomDocument,
+    TournamentManyTablesRoomsRepository,
+    UsersRepository
+} from 'jp.db.schemas';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import * as dayjs from 'dayjs';
+import * as schedule from 'node-schedule';
+import { Job } from 'node-schedule';
+
+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 { 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;
+
+    constructor(
+        private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
+        private readonly usersRepository: UsersRepository,
+        private readonly gameResultRepository: GameResultRepository,
+        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>();
+    }
+
+    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.findTournaments(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)?.getTournamentMaster().cancelTournament();
+
+        this.addRoom(this.options.createTournamentRoom(
+            this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament)
+        ));
+    }
+
+    async removeTournament(tournamentId: string) {
+        await this.tournamentRepository.removeTournament(tournamentId);
+    }
+
+    async buyTicket(tournamentId: string, player: GamePlayer) {
+        // TODO списать деньги у игрока
+        await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+            playerId: player.id,
+            playerAvatarUrl: player.avatarUrl,
+            playerName: player.avatarUrl,
+        });
+    }
+
+    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<number>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES') || 0;
+
+        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,
+            scheduleDate: tournamentDocument.scheduleDate,
+            turnTimeout: playersTurnTimeout,
+            restartTimeout: restartGameTimeout,
+            minPlayersForMergeTables: minPlayersForMergeTables,
+            localeService: this.options.i18n,
+            startStrategy: new NoStartStrategy(),
+            onRoomEvent: this.handleRoomEvent,
+            onRoomTableGameFinished: this.handleRoomTableGameFinished,
+            onTournamentRoomStarted: this.handleTournamentRoomStarted,
+            onTournamentRoomFinished: this.handleTournamentRoomFinished,
+            onTournamentRoomCancelled: this.handleTournamentRoomCancelled,
+            onRoomStatusUpdated: this.handleRoomStatusUpdated,
+            tournamentPrizeTable: this.options.tournamentPrizeTable,
+            tournamentInitialStatus: tournamentDocument.status,
+        } as ManyTablesTournamentRoomConfig;
+    }
+
+    private handleRoomEvent = (event: BaseGameEvent) => {
+        this.logger.log(event.toLog());
+    };
+
+    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 = async (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(),
+            );
+
+            this.addRoom(this.options.createTournamentRoom(
+                this.manyTablesTournamentDocumentToTournamentRoom(newTournament)
+            ));
+        }
+    }
+}