jp.ms.common.modules 1.0.29 → 1.0.31

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

@@ -1,10 +1,9 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    BaseAppScreen,
     IAppHeaders,
     IBaseAppScreen,
     IBaseMoveData,
-    IBaseTableGameState,
+    IAppTableState,
 } from 'jp.common.models';
 
 import { BaseAppScreenDto } from '../../dto';
@@ -32,14 +31,12 @@ export class OneTableTournamentService {
         }
 
         return new BaseAppScreenDto(
-            new BaseAppScreen(
-                new OneTableTournamentStatusScreenView(
-                    this.options.i18n,
-                    lang,
-                    tournament,
-                    playerId,
-                ).build()
-            )
+            new OneTableTournamentStatusScreenView(
+                this.options.i18n,
+                lang,
+                tournament,
+                playerId,
+            ).buildBS()
         );
     }
 
@@ -69,7 +66,7 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -83,7 +80,7 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);

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

@@ -1,5 +1,5 @@
 import { Body, Controller, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
-import { IAppHeaders, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+import { IAppHeaders, IBaseMoveData, IAppTableState } from 'jp.common.models';
 
 import { SimpleRoomsService } from './simple-rooms.service';
 
@@ -14,7 +14,7 @@ export class SimpleRoomsController {
     watchTheTable (
         @Param('tableId') tableId: string,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): IAppTableState {
         return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
     }
 
@@ -23,7 +23,7 @@ export class SimpleRoomsController {
     enterTheTable (
         @Param('tableId') tableId: string,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): IAppTableState {
         return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
     }
 
@@ -32,7 +32,7 @@ export class SimpleRoomsController {
     exitTheTable (
         @Param('tableId') tableId: string,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): IAppTableState {
         return this.roomsService.exitTheTable(tableId, headers.client_auth_token);
     }
 
@@ -42,7 +42,7 @@ export class SimpleRoomsController {
         @Param('tableId') tableId: string,
         @Body() baseMoveData: IBaseMoveData,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): IAppTableState {
         return this.roomsService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
     }
 

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

@@ -1,7 +1,7 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
     IBaseMoveData,
-    IBaseTableGameState,
+    IAppTableState,
 } from 'jp.common.models';
 
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
@@ -19,7 +19,7 @@ export class SimpleRoomsService {
     ) {
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.simpleRoomsManager.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -33,7 +33,7 @@ export class SimpleRoomsService {
         throw new InternalServerErrorException();
     }
 
-    enterTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    enterTheTable (tableId: string, clientAuthToken: string): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.simpleRoomsManager.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -47,7 +47,7 @@ export class SimpleRoomsService {
         throw new InternalServerErrorException();
     }
 
-    exitTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    exitTheTable (tableId: string, clientAuthToken: string): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.simpleRoomsManager.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -61,7 +61,7 @@ export class SimpleRoomsService {
         throw new InternalServerErrorException();
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IAppTableState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.simpleRoomsManager.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);

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

@@ -147,8 +147,6 @@ export class SimpleRoomsManagerService {
             localeService: this.options.i18n,
             startStrategy: new MinPlayersStartStrategy(),
             onRoomEvent: this.handleRoomEvent,
-            // onRoomTableGameFinished: this.handleRoomTableGameFinished,
-            // onRoomStatusUpdated: this.handleRoomStatusUpdated,
         } as GameRoomConfig;
     }
 

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

@@ -1,4 +1,4 @@
-import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import { DynamicModule, Global, Inject, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
     TournamentManyTablesRoom,
@@ -10,32 +10,37 @@ import {
     GameResult,
     GameResultSchema,
     GameResultRepository,
+    Purchase,
+    PurchaseSchema,
+    PurchaseRepository,
 } from 'jp.db.schemas';
 
 import { TournamentManyTablesRoomsManagerService } from './tournament-many-tables-rooms-manager.service';
-import {
-    TournamentManyTablesRoomsManagerOptions,
-} from './tournament-many-tables-rooms-manager.interfaces';
+import { TournamentManyTablesRoomsManagerOptions } from './tournament-many-tables-rooms-manager.interfaces';
 import { TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS } from './tournament-many-tables-rooms-manager.constants';
+import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-tables-rooms-manager.interfaces';
 
 @Global()
 @Module({
     imports: [
-        MongooseModule.forFeature([{name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema}]),
-        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
-        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
+        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
+        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+        MongooseModule.forFeature([{ name: Purchase.name, schema: PurchaseSchema }]),
+        MongooseModule.forFeature([{ name: GameResult.name, schema: GameResultSchema }]),
     ],
     providers: [
         TournamentManyTablesRoomsRepository,
         UsersRepository,
         TournamentManyTablesRoomsManagerService,
         GameResultRepository,
+        PurchaseRepository,
     ],
     exports: [TournamentManyTablesRoomsManagerService],
 })
 export class TournamentManyTablesRoomsManagerModule {
-    constructor (
+    constructor(
         private readonly managerService: TournamentManyTablesRoomsManagerService,
+        @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
     ) {
     }
 
@@ -54,7 +59,10 @@ export class TournamentManyTablesRoomsManagerModule {
     }
 
     async onModuleInit () {
-        await this.managerService.runDailyTournamentJob();
+        const dailyTournamentScheduleJobEnabled = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_JOB_ENABLED');
+        if (dailyTournamentScheduleJobEnabled === 'true') {
+            await this.managerService.runDailyTournamentJob();
+        }
         await this.managerService.hydrateTournamentsFromDB();
     }
 }

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

@@ -1,4 +1,8 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import dayjs from 'dayjs';
+import schedule, { Job } from 'node-schedule';
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
     BaseGameEvent,
     GameMaster,
@@ -18,15 +22,11 @@ import {
 } from 'jp.ms.common.engine';
 import {
     GameResultRepository,
+    PurchaseRepository,
     TournamentManyTablesRoomDocument,
     TournamentManyTablesRoomsRepository,
     UsersRepository
 } from 'jp.db.schemas';
-import { InjectConnection } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-import dayjs from 'dayjs';
-import schedule from 'node-schedule';
-import { Job } from 'node-schedule';
 
 import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
 import { JpLoggerService } from '../logger';
@@ -42,12 +42,13 @@ import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-table
 @Injectable()
 export class TournamentManyTablesRoomsManagerService {
     private readonly rooms: Map<string, ManyTablesTournamentRoom>;
-    private createDailyTournamentJob: Job;
+    private createDailyTournamentJob: Job | null;
 
     constructor(
         private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
         private readonly usersRepository: UsersRepository,
         private readonly gameResultRepository: GameResultRepository,
+        private readonly purchaseRepository: PurchaseRepository,
         private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
         private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
         @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
@@ -55,6 +56,7 @@ export class TournamentManyTablesRoomsManagerService {
         @Inject() private readonly logger: JpLoggerService,
     ) {
         this.rooms = new Map<string, ManyTablesTournamentRoom>();
+        this.createDailyTournamentJob = null;
     }
 
     get gameType () {
@@ -89,7 +91,7 @@ export class TournamentManyTablesRoomsManagerService {
     }
 
     async hydrateTournamentsFromDB () {
-        const templates = await this.tournamentRepository.findTournaments(this.gameType);
+        const templates = await this.tournamentRepository.findActualTournaments(this.gameType);
         templates.forEach((item) => {
             this.addRoom(this.options.createTournamentRoom(
                 this.manyTablesTournamentDocumentToTournamentRoom(item)
@@ -134,18 +136,47 @@ export class TournamentManyTablesRoomsManagerService {
     }
 
     async buyTicket (tournamentId: string, player: GamePlayer) {
-        // TODO списать деньги у игрока
-        await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
-            playerId: player.id,
-            playerAvatarUrl: player.avatarUrl,
-            playerName: player.avatarUrl,
-        });
+        const tournament = this.getRoomById(tournamentId);
+        const user = await this.usersRepository.findById(player.id);
+
+        if (!tournament || !user) {
+            throw new InternalServerErrorException();
+        }
+
+        const session = await this.connection.startSession();
+        session.startTransaction();
+
+        try {
+            player.decreaseBalance(tournament.getTicketPrice());
+            tournament.addParticipant(player);
+            this.purchaseRepository.addManyTablesTournamentTicketPurchase(
+                player.id,
+                player.fullName,
+                tournamentId,
+                tournament.getTicketPrice(),
+                tournament.getGameType(),
+            )
+            this.usersRepository.subtractFromBalance(player.id, tournament.getTicketPrice());
+
+            await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+                playerId: player.id,
+                playerAvatarUrl: player.avatarUrl,
+                playerName: player.fullName,
+            });
+
+            await session.commitTransaction();
+        } catch (error) {
+            await session.abortTransaction();
+            throw error;
+        } finally {
+            await session.endSession();
+        }
     }
 
     private manyTablesTournamentDocumentToTournamentRoom (tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
         const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
         const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-        const minPlayersForMergeTables = this.options.configService.get<number>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES') || 0;
+        const minPlayersForMergeTables = this.options.configService.get<string>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES');
 
         return {
             id: tournamentDocument.tournamentId,
@@ -163,21 +194,21 @@ export class TournamentManyTablesRoomsManagerService {
             scheduleDate: tournamentDocument.scheduleDate,
             turnTimeout: playersTurnTimeout,
             restartTimeout: restartGameTimeout,
-            minPlayersForMergeTables: minPlayersForMergeTables,
+            minPlayersForMergeTables: parseInt(minPlayersForMergeTables ?? '0', 10),
             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,
+            tournamentWinners: tournamentDocument.winners,
+            maxParticipants: tournamentDocument.maxParticipants,
+            participants: tournamentDocument.participants,
         } as ManyTablesTournamentRoomConfig;
     }
 
     private handleRoomEvent = (event: BaseGameEvent) => {
+        this.logger.log(event.toLog());
+
         if (event instanceof GameTableFinishedEvent) {
             this.handleRoomTableGameFinished(event.master!!);
         } else if (event instanceof GameTournamentStartedEvent) {
@@ -187,11 +218,11 @@ export class TournamentManyTablesRoomsManagerService {
         } else if (event instanceof GameTournamentFinishedEvent) {
             this.handleTournamentRoomFinished(event.room.getRoomMaster());
         } else if (
-            event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
-            event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
-            event instanceof GameTournamentCancelledEvent &&
-            event instanceof GameTournamentWaitedEvent &&
-            event instanceof GameTournamentStartedEvent &&
+            event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
+            event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
+            event instanceof GameTournamentCancelledEvent ||
+            event instanceof GameTournamentWaitedEvent ||
+            event instanceof GameTournamentStartedEvent ||
             event instanceof GameTournamentFinishedEvent
         ) {
             this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));

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

@@ -25,7 +25,7 @@ import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
-import { isUpdateTounrmanentRoomEvent, saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
+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';
@@ -87,7 +87,7 @@ export class TournamentOneTableRoomsManagerService {
   }
 
   async hydrateTournamentsFromDB () {
-    const templates = await this.tournamentRepository.findTournaments(this.gameType);
+    const templates = await this.tournamentRepository.findActualTournaments(this.gameType);
     templates.forEach((item) => {
       this.addRoom(this.options.createTournamentRoom(
         this.oneTableTournamentDocumentToTournamentRoom(item)
@@ -119,6 +119,9 @@ export class TournamentOneTableRoomsManagerService {
       onRoomEvent: this.handleRoomEvent,
       tournamentPrizeTable: this.options.tournamentPrizeTable,
       tournamentInitialStatus: tournamentDocument.status,
+      tournamentWinners: tournamentDocument.winners,
+      maxParticipants: tournamentDocument.maxParticipants,
+      participants: tournamentDocument.participants,
     } as TournamentRoomConfig;
   }
 
@@ -134,11 +137,11 @@ export class TournamentOneTableRoomsManagerService {
     } else if (event instanceof GameTournamentFinishedEvent) {
       this.handleTournamentRoomFinished(event.room.getRoomMaster());
     } else if (
-      event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
-      event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
-      event instanceof GameTournamentCancelledEvent &&
-      event instanceof GameTournamentWaitedEvent &&
-      event instanceof GameTournamentStartedEvent &&
+      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
+      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
+      event instanceof GameTournamentCancelledEvent ||
+      event instanceof GameTournamentWaitedEvent ||
+      event instanceof GameTournamentStartedEvent ||
       event instanceof GameTournamentFinishedEvent
     ) {
       this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));

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

@@ -1,11 +1,11 @@
 import { Connection } from 'mongoose';
-import { BaseGameEvent, GameMaster, GameTournamentCancelledEvent, GameTournamentFinishedEvent, GameTournamentPlayerJoinedTheTournamentEvent, GameTournamentPlayerLeavedTheTournamentEvent, GameTournamentStartedEvent, GameTournamentWaitedEvent, RoomUpdateStateEvent, TournamentMaster } from 'jp.ms.common.engine';
 import {
     GameResultRepository,
     TournamentManyTablesRoomsRepository,
     TournamentOneTableRoomsRepository,
     UsersRepository
 } from 'jp.db.schemas';
+import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
 
 export function getGameTableResults (master: GameMaster) {
     return {
@@ -108,18 +108,3 @@ export async function saveTournamentResult (
         await session.endSession();
     }
 }
-
-export function isUpdateTounrmanentRoomEvent (event: BaseGameEvent) {
-    if (
-        event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
-        event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
-        event instanceof GameTournamentCancelledEvent &&
-        event instanceof GameTournamentWaitedEvent &&
-        event instanceof GameTournamentStartedEvent &&
-        event instanceof GameTournamentFinishedEvent
-    ) {
-        return event
-    }
-
-    return null;
-}

package/src/views/index.ts

@@ -1,2 +1,5 @@
 export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';
-export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dialog.view';
+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'

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

@@ -0,0 +1,21 @@
+import {
+    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.room.screen.dialog.confirm.exit.game.title', { lang: this.lang }),
+            this.localeService.t('common.room.screen.dialog.confirm.exit.game.message', { lang: this.lang }),
+            new FullButtonsButtonsComponent(
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.ok', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.cancel', { lang: this.lang })),
+            ),
+        );
+    }
+}

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

@@ -0,0 +1,21 @@
+import {
+    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.room.screen.dialog.confirm.exit.game.title', { lang: this.lang }),
+            this.localeService.t('common.room.screen.dialog.confirm.exit.game.message', { lang: this.lang }),
+            new FullButtonsButtonsComponent(
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.ok', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.cancel', { lang: this.lang })),
+            ),
+        );
+    }
+}

package/src/views/table-summary.view.ts

@@ -0,0 +1,87 @@
+import {
+    BodyMdSummaryItemComponent,
+    BodySmSummaryItemComponent,
+    IAppTableSummary,
+    ILocaleService,
+    OneLineSummaryComponent,
+    SummaryComponent,
+    TitleMdSummaryItemComponent,
+    UniversalView,
+} from "jp.common.models";
+import { formatChips } from "jp.common.utils";
+import { GameMaster } from "jp.ms.common.engine";
+
+export class TableSummaryView extends UniversalView {
+    private readonly gameMaster: GameMaster;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        gameMaster: GameMaster,
+    ) {
+        super(localeService, lang);
+        this.gameMaster = gameMaster;
+    }
+
+    build (): IAppTableSummary {
+        if (this.gameMaster.isInProgress()) {
+            return this.getSummaryPlaying();
+        } else if (this.gameMaster.isTechBreak()) {
+            return this.getSummaryTechBreak();
+        } else if (this.gameMaster.isWaiting()) {
+            return this.getSummaryWaiting();
+        } else if (this.gameMaster.isFinish()) {
+            return this.getSummaryEnd();
+        }
+
+        return new SummaryComponent([]);
+    }
+
+
+    private getSummaryTechBreak () {
+        return new OneLineSummaryComponent(
+            new BodyMdSummaryItemComponent(
+                'tech-break',
+                this.localeService.t('room.screen.tech.break.message', { lang: this.lang }),
+            )
+        );
+    }
+
+    private getSummaryPlaying () {
+        return new OneLineSummaryComponent(
+            new TitleMdSummaryItemComponent(
+                'pot',
+                this.localeService.t('room.screen.summary.pot', {
+                    lang: this.lang,
+                    args: { POT: formatChips(this.gameMaster?.getGameRound()?.getPot() ?? 0, this.lang, true) },
+                }),
+            )
+        );
+    }
+
+    private getSummaryWaiting () {
+        return new OneLineSummaryComponent(
+            new BodyMdSummaryItemComponent(
+                'waiting',
+                this.localeService.t('room.screen.waiting.for.the.players', { lang: this.lang }),
+            )
+        );
+    }
+
+    private getSummaryEnd () {
+        return new SummaryComponent(
+            [
+                new BodySmSummaryItemComponent(
+                    'WINNER',
+                    this.localeService.t('room.screen.summary.winner', { lang: this.lang }),
+                    this.gameMaster.getGameResultHelper()?.getWinnersName() ?? '',
+                ),
+                new BodySmSummaryItemComponent(
+                    'NEW_GAME',
+                    this.localeService.t('room.screen.summary.new.game', { lang: this.lang }),
+                    this.localeService.t('room.screen.summary.new.game.value', { lang: this.lang }),
+                )
+            ]
+        );
+    }
+}

package/src/views/tournament-buy-ticket-dialog.view.ts

@@ -10,11 +10,11 @@ export class TournamentBuyTicketDialogView extends UniversalScreenDialogView {
     build () {
         return new StandardDialogComponent(
             AppScreenDialogIdEnum.DIALOG_TOURNAMENT_BUY_TICKET,
-            this.localeService.t('common.rooms.screen.buyTicket.title', { lang: this.lang }),
-            this.localeService.t('common.rooms.screen.buyTicket.description', { lang: this.lang }),
+            this.localeService.t('common.rooms.screen.dialog.buy.ticket.title', { lang: this.lang }),
+            this.localeService.t('common.rooms.screen.dialog.buy.ticket.description', { lang: this.lang }),
             new FullButtonsButtonsComponent(
-                new TextButtonComponent(this.localeService.t('common.rooms.screen.buyTicket.button.ok', { lang: this.lang })),
-                new TextButtonComponent(this.localeService.t('common.rooms.screen.buyTicket.button.cancel', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.rooms.screen.dialog.buy.ticket.ok', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.rooms.screen.dialog.buy.ticket.cancel', { lang: this.lang })),
             ),
         );
     }

package/dist/adapter/base-table-game-state-adapter.d.ts

@@ -1,36 +0,0 @@
-import { IBaseTableGameStateExtraButtons, IBaseTableGameStatePlayer, IBaseTableGameStateSummary, IBaseTableGameState, IBaseTableGameStateMovesPanel, IBaseTableGameStateYoursActionItem, BaseTableGameStateSummary, IAppScreenDialog } from 'jp.common.models';
-import { GameMaster, GamePlayer } from 'jp.ms.common.engine';
-export declare abstract class BaseTableGameStateAdapter {
-    private readonly _master;
-    private readonly _currentPlayer;
-    constructor(master: GameMaster, currentPlayer: GamePlayer);
-    getMaster<T extends GameMaster>(): T;
-    getCurrentPlayer<T extends GamePlayer>(): T;
-    get lang(): string;
-    t(key: string, options: object): string;
-    getRoomId(): string;
-    getTableTitle(): string;
-    getTableId(): string;
-    getGameId(): string;
-    getTableSize(): number;
-    getPlayerTurnTimerRemain(): number | undefined;
-    getRestartTimerRemain(): number | undefined;
-    getYoursMessage(): string;
-    getPlayerComment(player: GamePlayer): string;
-    getPlayerCommentInProgressActive(player: GamePlayer): string;
-    getPlayerCommentInProgressNotActive(player: GamePlayer): string;
-    getPlayerCommentFinish(player: GamePlayer): string;
-    getPlayer(item: GamePlayer): IBaseTableGameStatePlayer;
-    getPlayers(): Array<IBaseTableGameStatePlayer>;
-    getPlayerActions(): Array<IBaseTableGameStateYoursActionItem>;
-    getMovesPanelIsOpen(): boolean;
-    getMovesPanel(): IBaseTableGameStateMovesPanel;
-    getExtraButtons(): IBaseTableGameStateExtraButtons | undefined;
-    getSummary(): IBaseTableGameStateSummary;
-    getSummaryTechBreak(): BaseTableGameStateSummary;
-    getSummaryPlaying(): BaseTableGameStateSummary;
-    getSummaryWaiting(): BaseTableGameStateSummary;
-    getSummaryEnd(): BaseTableGameStateSummary;
-    getConfirmExitDialog(): IAppScreenDialog | undefined;
-    getState(): IBaseTableGameState;
-}