jp.ms.common.modules 1.0.18 → 1.0.20

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,216 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+    BaseGameEvent,
+    GameMaster,
+    ManyTablesTournamentRoom,
+    ManyTablesTournamentRoomConfig,
+    NoStartStrategy, 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 { 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,
+        @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()];
+            }, []);
+    }
+
+    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);
+    }
+
+    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,
+            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 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)
+            ));
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { TournamentOneTableRoomsManagerModule } from './tournament-one-table-rooms-manager.module';
+export { TournamentOneTableRoomsManagerService } from './tournament-one-table-rooms-manager.service';

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

@@ -0,0 +1 @@
+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

@@ -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 { 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 TournamentOneTableRoomsFactoryOptions {
+    i18n: I18nService;
+    configService: ConfigService;
+    tournamentPrizeTable: IPrizeTableData;
+    createTournamentRoom (room: TournamentRoomConfig): OneTableTournamentRoom;
+}

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

@@ -0,0 +1,59 @@
+import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+    TournamentOneTableRoom,
+    TournamentOneTableRoomSchema,
+    TournamentOneTableRoomsRepository,
+    User,
+    UserSchema,
+    UsersRepository,
+    GameResult,
+    GameResultSchema,
+    GameResultRepository,
+} from 'jp.db.schemas';
+
+import { TournamentOneTableRoomsManagerService } from './tournament-one-table-rooms-manager.service';
+import { TournamentOneTableRoomsManagerOptions } from './tournament-one-table-rooms-manager.interfaces';
+import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
+
+@Global()
+@Module({
+    imports: [
+        MongooseModule.forFeature([{name: TournamentOneTableRoom.name, schema: TournamentOneTableRoomSchema}]),
+        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
+        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
+    ],
+    providers: [
+        TournamentOneTableRoomsRepository,
+        UsersRepository,
+        TournamentOneTableRoomsManagerService,
+        GameResultRepository,
+    ],
+    exports: [TournamentOneTableRoomsManagerService],
+})
+export class TournamentOneTableRoomsManagerModule {
+    constructor (
+        private readonly managerService: TournamentOneTableRoomsManagerService,
+    ) {
+    }
+
+    static forRootAsync (options: TournamentOneTableRoomsManagerOptions): DynamicModule {
+        return {
+            module: TournamentOneTableRoomsManagerModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+
+    async onModuleInit () {
+        await this.managerService.createMasterTournament();
+        await this.managerService.hydrateTournamentsFromDB();
+    }
+}
+

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

@@ -0,0 +1,165 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  BaseGameEvent,
+  GameMaster,
+  NoStartStrategy,
+  OneTableTournamentRoom, TournamentMaster,
+  TournamentRoomConfig
+} from 'jp.ms.common.engine';
+import {
+  GameResultRepository,
+  TournamentOneTableRoomDocument,
+  TournamentOneTableRoomsRepository,
+  UsersRepository
+} from 'jp.db.schemas';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+
+import { JpLoggerService } from '../logger/jp-logger.service';
+import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
+
+import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
+import { TournamentOneTableRoomsFactoryOptions } from './tournament-one-table-rooms-manager.interfaces';
+
+@Injectable()
+export class TournamentOneTableRoomsManagerService {
+  private readonly rooms: Map<string, OneTableTournamentRoom>;
+
+  constructor (
+      private readonly tournamentRepository: TournamentOneTableRoomsRepository,
+      private readonly usersRepository: UsersRepository,
+      private readonly gameResultRepository: GameResultRepository,
+      @Inject(TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentOneTableRoomsFactoryOptions,
+      @InjectConnection() private readonly connection: Connection,
+      @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.rooms = new Map<string, OneTableTournamentRoom>();
+  }
+
+  get gameType () {
+    return this.options.configService.get<string>('GAME_TYPE') || '';
+  }
+
+  getRoomById (roomId: string): OneTableTournamentRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId (tableId: string): OneTableTournamentRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  getRooms (): Array<OneTableTournamentRoom> {
+    return Array.from(this.rooms.values());
+  }
+
+  getTables (): Array<GameMaster> {
+    return this.getRooms().reduce(
+        (result, currentValue) => {
+          return [...result, ...currentValue.getMasters()];
+        }, []);
+  }
+
+  addRoom (room: OneTableTournamentRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async createMasterTournament () {
+    const waitingTournament = await this.tournamentRepository.findWaitingTournament(this.gameType);
+    if (!waitingTournament) {
+      await this.tournamentRepository.createTournamentFromMasterTemplate(this.gameType);
+    }
+  }
+
+  async hydrateTournamentsFromDB () {
+    const templates = await this.tournamentRepository.findTournaments(this.gameType);
+    templates.forEach((item) => {
+      this.addRoom(this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(item)
+      ));
+    });
+  }
+
+  private oneTableTournamentDocumentToTournamentRoom (tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
+    const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
+    const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 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,
+      turnTimeout: playersTurnTimeout,
+      restartTimeout: restartGameTimeout,
+      localeService: this.options.i18n,
+      startStrategy: new NoStartStrategy(),
+      onRoomEvent: this.handleRoomEvent,
+      onRoomTableGameFinished: this.handleRoomTableGameFinished,
+      onTournamentRoomStarted: this.handleTournamentRoomStarted,
+      onTournamentRoomFinished: this.handleTournamentRoomFinished,
+      onTournamentRoomCancelled: this.handleTournamentRoomCancelled,
+      tournamentPrizeTable: this.options.tournamentPrizeTable,
+      tournamentInitialStatus: tournamentDocument.status,
+    } as TournamentRoomConfig;
+  }
+
+  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) => {
+    const session = await this.connection.startSession();
+    session.startTransaction();
+
+    try {
+      await this.tournamentRepository.startTournament(
+          master.getTournamentId(),
+          master.getRoom().getParticipants(),
+      );
+      const newTournament = await this.tournamentRepository.createTournamentFromMasterTemplate(
+          master.getRoom().getGameType()
+      );
+      this.addRoom(this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(newTournament)
+      ));
+
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  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,
+    );
+  }
+}

package/src/utils/date.ts

@@ -0,0 +1,7 @@
+export function getHours (timeStr: string) {
+    return parseInt(timeStr.substring(0, 2), 10);
+}
+
+export function getMinutes (timeStr: string) {
+    return parseInt(timeStr.substring(3, 5), 10);
+}