jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -1,15 +1,15 @@
 import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
-    TournamentOneTableRoom,
-    TournamentOneTableRoomSchema,
-    TournamentOneTableRoomsRepository,
-    User,
-    UserSchema,
-    UsersRepository,
-    GameResult,
-    GameResultSchema,
-    GameResultRepository,
+  TournamentOneTableRoom,
+  TournamentOneTableRoomSchema,
+  TournamentOneTableRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
 } from 'jp.db.schemas';
 
 import { TournamentOneTableRoomsManagerService } from './tournament-one-table-rooms-manager.service';
@@ -18,42 +18,49 @@ import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-tab
 
 @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],
+  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,
-    ) {
-    }
+  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,
-            ],
-        };
-    }
+  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();
-    }
+  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

@@ -19,14 +19,20 @@ import {
   GameResultRepository,
   TournamentOneTableRoomDocument,
   TournamentOneTableRoomsRepository,
-  UsersRepository
+  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 { EventsBusMainTablesSubscribeService, EventsBusOneTableTournamentSubscribeService } from '../event-bus';
+import {
+  saveGameTablesResult,
+  saveTournamentResult,
+} from '../../utils/game-table-result';
+import {
+  EventsBusMainTablesSubscribeService,
+  EventsBusOneTableTournamentSubscribeService,
+} from '../event-bus';
 
 import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
 import { TournamentOneTableRoomsFactoryOptions } from './tournament-one-table-rooms-manager.interfaces';
@@ -41,63 +47,72 @@ export class TournamentOneTableRoomsManagerService {
     private readonly gameResultRepository: GameResultRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
-    @Inject(TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentOneTableRoomsFactoryOptions,
+    @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 () {
+  get gameType() {
     return this.options.configService.get<string>('GAME_TYPE') || '';
   }
 
-  getRoomById (roomId: string): OneTableTournamentRoom | undefined {
+  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
     return this.rooms.get(roomId);
   }
 
-  getRoomByTableId (tableId: string): OneTableTournamentRoom | undefined {
+  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
     return this.getRoomById(roomId);
   }
 
-  getRooms (): Array<OneTableTournamentRoom> {
+  getRooms(): Array<OneTableTournamentRoom> {
     return Array.from(this.rooms.values());
   }
 
-  getTables (): Array<GameMaster> {
-    return this.getRooms().reduce(
-      (result, currentValue) => {
-        return [...result, ...currentValue.getMasters()];
-      },
-      [] as Array<GameMaster>
-    );
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
   }
 
-  addRoom (room: OneTableTournamentRoom) {
+  addRoom(room: OneTableTournamentRoom) {
     this.rooms.set(room.getId(), room);
   }
 
-  async createMasterTournament () {
-    const waitingTournament = await this.tournamentRepository.findWaitingTournament(this.gameType);
+  async createMasterTournament() {
+    const waitingTournament =
+      await this.tournamentRepository.findWaitingTournament(this.gameType);
     if (!waitingTournament) {
-      await this.tournamentRepository.createTournamentFromMasterTemplate(this.gameType);
+      await this.tournamentRepository.createTournamentFromMasterTemplate(
+        this.gameType,
+      );
     }
   }
 
-  async hydrateTournamentsFromDB () {
-    const templates = await this.tournamentRepository.findActualTournaments(this.gameType);
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
     templates.forEach((item) => {
-      this.addRoom(this.options.createTournamentRoom(
-        this.oneTableTournamentDocumentToTournamentRoom(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;
+  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,
@@ -122,20 +137,20 @@ export class TournamentOneTableRoomsManagerService {
       tournamentWinners: tournamentDocument.winners,
       maxParticipants: tournamentDocument.maxParticipants,
       participants: tournamentDocument.participants,
-    } as TournamentRoomConfig;
+    };
   }
 
   private handleRoomEvent = (event: BaseGameEvent) => {
     this.logger.log(event.toLog());
 
     if (event instanceof GameTableFinishedEvent) {
-      this.handleRoomTableGameFinished(event.master!!);
+      void this.handleRoomTableGameFinished(event.master);
     } else if (event instanceof GameTournamentStartedEvent) {
-      this.handleTournamentRoomStarted(event.room.getRoomMaster());
+      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
     } else if (event instanceof GameTournamentCancelledEvent) {
-      this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
     } else if (event instanceof GameTournamentFinishedEvent) {
-      this.handleTournamentRoomFinished(event.room.getRoomMaster());
+      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
     } else if (
       event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
       event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
@@ -144,7 +159,9 @@ export class TournamentOneTableRoomsManagerService {
       event instanceof GameTournamentStartedEvent ||
       event instanceof GameTournamentFinishedEvent
     ) {
-      this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
+      void this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
     }
   };
 
@@ -167,12 +184,15 @@ export class TournamentOneTableRoomsManagerService {
         master.getTournamentId(),
         master.getRoom().getParticipants(),
       );
-      const newTournament = await this.tournamentRepository.createTournamentFromMasterTemplate(
-        master.getRoom().getGameType()
+      const newTournament =
+        await this.tournamentRepository.createTournamentFromMasterTemplate(
+          master.getRoom().getGameType(),
+        );
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(newTournament),
+        ),
       );
-      this.addRoom(this.options.createTournamentRoom(
-        this.oneTableTournamentDocumentToTournamentRoom(newTournament)
-      ));
 
       await session.commitTransaction();
     } catch (error) {
@@ -181,11 +201,11 @@ export class TournamentOneTableRoomsManagerService {
     } finally {
       await session.endSession();
     }
-  }
+  };
 
   private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
-  }
+  };
 
   private handleTournamentRoomFinished = async (master: TournamentMaster) => {
     await saveTournamentResult(
@@ -194,10 +214,10 @@ export class TournamentOneTableRoomsManagerService {
       this.tournamentRepository,
       this.usersRepository,
     );
-  }
+  };
 
-  private handleRoomStatusUpdated = async (event: RoomUpdateStateEvent) => {
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
     this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
     this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
-  }
+  };
 }

package/src/utils/date.ts

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

package/src/utils/game-table-result.ts

@@ -1,110 +1,129 @@
 import { Connection } from 'mongoose';
 import {
-    GameResultRepository,
-    TournamentManyTablesRoomsRepository,
-    TournamentOneTableRoomsRepository,
-    UsersRepository
+  GameResultRepository,
+  TournamentManyTablesRoomsRepository,
+  TournamentOneTableRoomsRepository,
+  UsersRepository,
 } from 'jp.db.schemas';
 import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
 
-export function getGameTableResults (master: GameMaster) {
-    return {
-        gameType: master.getRoom().getGameType(),
-        gameId: master.getGameRound()?.getId() ?? '',
-        roomId: master.getRoom().getId(),
-        date: new Date(),
-        pot: master.getGameRound()?.getPot() ?? 0,
-        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(),
+export function getGameTableResults(master: GameMaster) {
+  return {
+    gameType: master.getRoom().getGameType(),
+    gameId: master.getGameRound()?.getId() ?? '',
+    roomId: master.getRoom().getId(),
+    date: new Date(),
+    pot: master.getGameRound()?.getPot() ?? 0,
+    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(),
             })) ?? [],
-        })) ?? []
-    };
+        })) ?? [],
+  };
 }
 
-export async function saveGameTablesResult (
-    master: GameMaster,
-    connection: Connection,
-    gameResultRepository: GameResultRepository,
-    usersRepository: UsersRepository,
-    saveNewBalance: boolean,
+export async function saveGameTablesResult(
+  master: GameMaster,
+  connection: Connection,
+  gameResultRepository: GameResultRepository,
+  usersRepository: UsersRepository,
+  saveNewBalance: boolean,
 ) {
-    const userGameResult = master.getTable().getPlayers().map((player) => {
-        return {
-            userId: player.id,
-            balanceAdding: saveNewBalance ? player.profit : 0,
-            experienceAdding: master.levelHelper.getNewExperienceAmount(player),
-            levelAdding: master.levelHelper.getNewLevelAdding(player.level, player.experience),
-        };
+  const userGameResult = master
+    .getTable()
+    .getPlayers()
+    .map((player) => {
+      return {
+        userId: player.id,
+        balanceAdding: saveNewBalance ? player.profit : 0,
+        experienceAdding: master.levelHelper.getNewExperienceAmount(player),
+        levelAdding: master.levelHelper.getNewLevelAdding(
+          player.level,
+          player.experience,
+        ),
+      };
     });
 
-    const session = await connection.startSession();
-    session.startTransaction();
+  const session = await connection.startSession();
+  session.startTransaction();
 
-    try {
-        await gameResultRepository.createGameResult(getGameTableResults(master));
-        await usersRepository.saveGameResult(userGameResult);
+  try {
+    await gameResultRepository.createGameResult(getGameTableResults(master));
+    await usersRepository.saveGameResult(userGameResult);
 
-        await session.commitTransaction();
-    } catch (error) {
-        await session.abortTransaction();
-        throw error;
-    } finally {
-        await session.endSession();
-    }
+    await session.commitTransaction();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    await session.endSession();
+  }
 }
 
-export async function saveTournamentResult (
-    master: TournamentMaster,
-    connection: Connection,
-    tournamentRepository: TournamentManyTablesRoomsRepository | TournamentOneTableRoomsRepository,
-    usersRepository: UsersRepository,
+export async function saveTournamentResult(
+  master: TournamentMaster,
+  connection: Connection,
+  tournamentRepository:
+    | TournamentManyTablesRoomsRepository
+    | TournamentOneTableRoomsRepository,
+  usersRepository: UsersRepository,
 ) {
-    const userTournamentResult = master.getTournamentResult().map((player) => {
-        return {
-            userId: player.playerId,
-            balanceAdding: player.profit,
-            experienceAdding: 0,
-            levelAdding: 0,
-        };
-    });
+  const userTournamentResult = master.getTournamentResult().map((player) => {
+    return {
+      userId: player.playerId,
+      balanceAdding: player.profit,
+      experienceAdding: 0,
+      levelAdding: 0,
+    };
+  });
 
-    const session = await connection.startSession();
-    session.startTransaction();
+  const session = await connection.startSession();
+  session.startTransaction();
 
-    try {
-        await usersRepository.saveGameResult(userTournamentResult);
-        await tournamentRepository.finishTournament(
-            master.getTournamentId(),
-            master.getTournamentResult(),
-        );
-        await session.commitTransaction();
-    } catch (error) {
-        await session.abortTransaction();
-        throw error;
-    } finally {
-        await session.endSession();
-    }
+  try {
+    await usersRepository.saveGameResult(userTournamentResult);
+    await tournamentRepository.finishTournament(
+      master.getTournamentId(),
+      master.getTournamentResult(),
+    );
+    await session.commitTransaction();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    await session.endSession();
+  }
 }

package/src/views/index.ts

@@ -2,4 +2,4 @@ export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.vi
 export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dialog.view';
 export { ManyTablesTournamentConfirmExitDialogView } from './many-tables-tournament-conifrm-exit-dialog.view';
 export { OneTableTournamentConfirmExitDialogView } from './one-table-tournament-conifrm-exit-dialog.view';
-export { TableSummaryView } from './table-summary.view'
+export { TableSummaryView } from './table-summary.view';

package/src/views/many-tables-tournament-conifrm-exit-dialog.view.ts

@@ -1,21 +1,37 @@
 import {
-    UniversalScreenDialogView,
-    AppScreenDialogIdEnum,
-    StandardDialogComponent,
-    FullButtonsButtonsComponent,
-    TextButtonComponent,
-} from "jp.common.models";
+  UniversalScreenDialogView,
+  AppScreenDialogIdEnum,
+  StandardDialogComponent,
+  FullButtonsButtonsComponent,
+  TextButtonComponent,
+} from 'jp.common.models';
 
 export class ManyTablesTournamentConfirmExitDialogView extends UniversalScreenDialogView {
-    build () {
-        return new StandardDialogComponent(
-            AppScreenDialogIdEnum.DIALOG_MANY_TABLES_TOURNAMENT_CONFIRM_EXIT,
-            this.localeService.t('common.many.tables.tournament.screen.dialog.confirm.exit.game.title', { lang: this.lang }),
-            this.localeService.t('common.many.tables.tournament.screen.dialog.confirm.exit.game.message', { lang: this.lang }),
-            new FullButtonsButtonsComponent(
-                new TextButtonComponent(this.localeService.t('common.many.tables.tournament.screen.dialog.confirm.exit.game.ok', { lang: this.lang })),
-                new TextButtonComponent(this.localeService.t('common.many.tables.tournament.screen.dialog.confirm.exit.game.cancel', { lang: this.lang })),
-            ),
-        );
-    }
+  build() {
+    return new StandardDialogComponent(
+      AppScreenDialogIdEnum.DIALOG_MANY_TABLES_TOURNAMENT_CONFIRM_EXIT,
+      this.localeService.t(
+        'common.many.tables.tournament.screen.dialog.confirm.exit.game.title',
+        { lang: this.lang },
+      ),
+      this.localeService.t(
+        'common.many.tables.tournament.screen.dialog.confirm.exit.game.message',
+        { lang: this.lang },
+      ),
+      new FullButtonsButtonsComponent(
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.many.tables.tournament.screen.dialog.confirm.exit.game.ok',
+            { lang: this.lang },
+          ),
+        ),
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.many.tables.tournament.screen.dialog.confirm.exit.game.cancel',
+            { lang: this.lang },
+          ),
+        ),
+      ),
+    );
+  }
 }

package/src/views/one-table-tournament-conifrm-exit-dialog.view.ts

@@ -1,21 +1,37 @@
 import {
-    UniversalScreenDialogView,
-    AppScreenDialogIdEnum,
-    StandardDialogComponent,
-    FullButtonsButtonsComponent,
-    TextButtonComponent,
-} from "jp.common.models";
+  UniversalScreenDialogView,
+  AppScreenDialogIdEnum,
+  StandardDialogComponent,
+  FullButtonsButtonsComponent,
+  TextButtonComponent,
+} from 'jp.common.models';
 
 export class OneTableTournamentConfirmExitDialogView extends UniversalScreenDialogView {
-    build () {
-        return new StandardDialogComponent(
-            AppScreenDialogIdEnum.DIALOG_ONE_TABLE_TOURNAMENT_CONFIRM_EXIT,
-            this.localeService.t('common.one.table.tournament.screen.dialog.confirm.exit.game.title', { lang: this.lang }),
-            this.localeService.t('common.one.table.tournament.screen.dialog.confirm.exit.game.message', { lang: this.lang }),
-            new FullButtonsButtonsComponent(
-                new TextButtonComponent(this.localeService.t('common.one.table.tournament.screen.dialog.confirm.exit.game.ok', { lang: this.lang })),
-                new TextButtonComponent(this.localeService.t('common.one.table.tournament.screen.dialog.confirm.exit.game.cancel', { lang: this.lang })),
-            ),
-        );
-    }
+  build() {
+    return new StandardDialogComponent(
+      AppScreenDialogIdEnum.DIALOG_ONE_TABLE_TOURNAMENT_CONFIRM_EXIT,
+      this.localeService.t(
+        'common.one.table.tournament.screen.dialog.confirm.exit.game.title',
+        { lang: this.lang },
+      ),
+      this.localeService.t(
+        'common.one.table.tournament.screen.dialog.confirm.exit.game.message',
+        { lang: this.lang },
+      ),
+      new FullButtonsButtonsComponent(
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.one.table.tournament.screen.dialog.confirm.exit.game.ok',
+            { lang: this.lang },
+          ),
+        ),
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.one.table.tournament.screen.dialog.confirm.exit.game.cancel',
+            { lang: this.lang },
+          ),
+        ),
+      ),
+    );
+  }
 }