jp.ms.common.modules 1.0.17 → 1.0.20

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

@@ -0,0 +1,140 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    BaseAppScreen,
+    IBaseMoveData,
+    IBaseTableGameState,
+    AppScreenIconEnum,
+    AppScreenSectionButtons, router,
+} from 'jp.common.models';
+
+import { BaseAppScreenDto } from '../../dto';
+import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+
+import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
+import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
+
+@Injectable()
+export class OneTableTournamentService {
+    constructor (
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(ONE_TABLE_TOURNAMENT_OPTIONS) private readonly options: OneTableTournamentFactoryOptions,
+    ) {
+    }
+
+    async getStatusScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        const screen =
+            AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
+                .addAppBar(
+                    AppScreenAppBar.CreateStatusAppBar(
+                        this.options.i18n.t('common.rooms.screen.title', { lang }),
+                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
+                    ),
+                )
+                .addSection((
+                    AppScreenSection.CreateStatusHeader(
+                        'status',
+                        'description',
+                        AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                        AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
+                    )
+                ))
+                .addSection(
+                    AppScreenSection.CreateCardListSection(
+                        'id1',
+                        tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
+                            item.playerId,
+                            item.playerName,
+                            '',
+                            AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
+                            true,
+                            '',
+                        ))
+                    ),
+                );
+
+        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    }
+
+    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleWatchTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleMoveOnTheTable(player, tableId, moveDto);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    joinTournament (tournamentId: string, clientAuthToken: string): JoinTournamentDto {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleJoinTournament(player);
+
+            if (tournament.getTournamentMaster().isInProgress()) {
+                const onlyTableId = tournament.getFirstMaster()?.getTable()?.getId() ?? '';
+                return JoinTournamentDto.fromEntities(
+                    router.getOneTableTournamentTablePath(onlyTableId),
+                    player.id,
+                );
+            } else {
+                return JoinTournamentDto.fromEntities(
+                    router.getOneTableTournamentStatusPath(tournament.getId()),
+                    player.id,
+                );
+            }
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    leaveTournament (tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleLeaveTournament(player);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+}

package/src/modules/players-manager/index.ts

@@ -0,0 +1,2 @@
+export { PlayersManagerModule } from './players-manager.module';
+export { PlayersManagerService } from './players-manager.service';

package/src/modules/simple-rooms/index.ts

@@ -0,0 +1 @@
+export { SimpleRoomsModule } from './simple-rooms.module';

package/src/modules/simple-rooms/simple-rooms.constants.ts

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

package/src/modules/{rooms/rooms.controller.ts → simple-rooms/simple-rooms.controller.ts}

@@ -1,27 +1,14 @@
-import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
-import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+import { Body, Controller, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+import { IAppHeaders, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
 
-import { PlayerCheckStateDto } from '../../dto';
+import { SimpleRoomsService } from './simple-rooms.service';
 
-import { RoomsService } from './rooms.service';
-
-@Controller('rooms')
-export class RoomsController {
+@Controller('simple-rooms')
+export class SimpleRoomsController {
     constructor (
-        private readonly roomsService: RoomsService,
+        private readonly roomsService: SimpleRoomsService,
     ) {
     }
-
-    @Get('player/check/state')
-    checkState (@Headers() headers: IAppHeaders): PlayerCheckStateDto {
-        return this.roomsService.playerCheckState(headers.client_auth_token);
-    }
-
-    @Get('tables')
-    getScreen (@Headers() headers: IAppHeaders): Promise<IBaseAppScreen> {
-        return this.roomsService.getScreen(headers.client_language);
-    }
-
     @Post('table/watch/:tableId')
     @HttpCode(HttpStatus.OK)
     watchTheTable (
@@ -64,10 +51,4 @@ export class RoomsController {
     restartTable (@Param('tableId') tableId: string): boolean {
         return this.roomsService.restartTable(tableId);
     }
-
-    @Post('techBreakOn')
-    @HttpCode(HttpStatus.OK)
-    techBreakOn (): boolean {
-        return this.roomsService.techBreakOn();
-    }
 }

package/src/modules/simple-rooms/simple-rooms.interfaces.ts

@@ -0,0 +1,15 @@
+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';
+
+export interface SimpleRoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface SimpleRoomsFactoryOptions {
+    i18n: I18nService
+}

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

@@ -0,0 +1,36 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { SimpleRoom, SimpleRoomSchema, SimpleRoomsRepository } from 'jp.db.schemas';
+
+import { SimpleRoomsController } from './simple-rooms.controller';
+import { SimpleRoomsService } from './simple-rooms.service';
+import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
+import { SimpleRoomsModuleOptions } from './simple-rooms.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: SimpleRoom.name, schema: SimpleRoomSchema }]),
+    ],
+    controllers: [SimpleRoomsController],
+    providers: [SimpleRoomsService, SimpleRoomsRepository],
+})
+export class SimpleRoomsModule {
+    constructor () {
+
+    }
+
+    static forRootAsync (options: SimpleRoomsModuleOptions): DynamicModule {
+        return {
+            module: SimpleRoomsModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: SIMPLE_ROOMS_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}
+

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

@@ -0,0 +1,90 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    IBaseMoveData,
+    IBaseTableGameState,
+} from 'jp.common.models';
+
+import { SimpleRoomsManagerService } from '../simple-rooms-manager';
+import { PlayersManagerService } from '../players-manager';
+
+import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
+import { SimpleRoomsFactoryOptions } from './simple-rooms.interfaces';
+
+@Injectable()
+export class SimpleRoomsService {
+    constructor (
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(SIMPLE_ROOMS_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
+    ) {
+    }
+
+    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleWatchTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    enterTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleEnterTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    exitTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleExitTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleMoveOnTheTable(player, tableId, moveDto);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    restartTable (tableId: string): boolean {
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (room && master) {
+            room.handleRestartTable(tableId);
+
+            return true;
+        }
+
+        throw new InternalServerErrorException();
+    }
+}

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

@@ -0,0 +1,2 @@
+export { SimpleRoomsManagerModule } from './simple-rooms-manager.module';
+export { SimpleRoomsManagerService } from './simple-rooms-manager.service';

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,118 @@
-import { Injectable } from '@nestjs/common';
-import { GameMaster, SimpleRoom } from 'jp.ms.common.engine';
+import { Inject, Injectable } from '@nestjs/common';
+import {
+    BaseGameEvent,
+    GameMaster,
+    MinPlayersStartStrategy,
+    SimpleRoom,
+    GameRoomConfig,
+} from 'jp.ms.common.engine';
+import {
+    GameResultRepository, SimpleRoomDocument,
+    SimpleRoomsRepository,
+    UsersRepository
+} from 'jp.db.schemas';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+
+import { JpLoggerService } from '../logger/jp-logger.service';
+import { saveGameTablesResult } from '../../utils/game-table-result';
+
+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,
+        @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()];
+            }, []);
+    }
+
+    addRoom (room: SimpleRoom) {
+        this.rooms.set(room.getId(), room);
+    }
+
+    async hydrateRoomsFromDB () {
+        const templates = await this.roomsRepository.findRooms(this.gameType);
 
-  constructor () {
-    this.rooms = new Map<string, SimpleRoom>();
-  }
+        templates.forEach((item) => {
+            const newRoom = this.options.createRoom(
+                this.simpleRoomDocumentToTournamentRoom(item)
+            );
 
-  getRoomById (roomId: string): SimpleRoom | undefined {
-    return this.rooms.get(roomId);
-  }
+            newRoom.addMaster();
+            this.addRoom(newRoom);
+        });
+    }
 
-  getRoomByTableId (tableId: string): SimpleRoom | undefined {
-    const { roomId } = GameMaster.parseTableId(tableId);
+    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;
 
-    return this.getRoomById(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,
+        } as GameRoomConfig;
+    }
 
-  getRooms (): Array<SimpleRoom> {
-    return Array.from(this.rooms.values());
-  }
+    private handleRoomEvent = (event: BaseGameEvent) => {
+        this.logger.log(event.toLog());
+    };
 
-  addRoom (room: SimpleRoom) {
-    this.rooms.set(room.getId(), room);
-  }
+    private handleRoomTableGameFinished = async (master: GameMaster) => {
+        await saveGameTablesResult(
+            master,
+            this.connection,
+            this.gameResultRepository,
+            this.usersRepository,
+            true,
+        );
+    };
 }

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();
+    }
 }