jp.ms.common.modules 1.0.28 → 1.0.30

package/src/modules/one-table-tournament/one-table-tournament-status-screen.view.ts

@@ -15,6 +15,7 @@ import {
     MiniCardSectionListItemComponent,
     UrlImageComponent,
 } from "jp.common.models";
+import { formatChips } from "jp.common.utils";
 import { OneTableTournamentRoom, TournamentMaster } from "jp.ms.common.engine";
 
 export class OneTableTournamentStatusScreenView extends UniversalScreenView {
@@ -48,32 +49,57 @@ export class OneTableTournamentStatusScreenView extends UniversalScreenView {
             .addSection(
                 new CardListSectionComponent(
                     'id1',
-                    this.tournament.getParticipants().map((item) => (
-                        new MiniCardSectionListItemComponent(
-                            item.playerId,
-                            item.playerName,
-                            '',
-                            new UrlImageComponent(item.playerAvatarUrl),
-                            true,
-                            true,
-                            '',
-                        )
-                    ))
-                ),
+                    this.getPlayersList()
+                )
             );
     }
 
+    private getPlayersList (): Array<MiniCardSectionListItemComponent> {
+        if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return this.tournament.getWinners().map((item) => (
+                new MiniCardSectionListItemComponent(
+                    item.playerId,
+                    item.playerName,
+                    this.localeService.t('common.tournaments.status.screen.finish.description', {
+                        lang: this.lang,
+                        args: {
+                            RANK: item.rank.toString(),
+                            PRIZE: formatChips(item.profit, this.lang, true),
+                        }
+                    }),
+                    new UrlImageComponent(item.playerAvatarUrl),
+                    true,
+                    true,
+                    '',
+                )
+            ));
+        }
+
+        return this.tournament.getParticipants().map((item) => (
+            new MiniCardSectionListItemComponent(
+                item.playerId,
+                item.playerName,
+                '',
+                new UrlImageComponent(item.playerAvatarUrl),
+                true,
+                true,
+                '',
+            )
+        ));
+    }
+
     private getStatusHeader (): StatusHeaderSectionComponent {
-        // TODO разобраться с участниками для туринар
-        const foundPlayer = this.tournament.getParticipants().find((item) => item.playerId === this.playerId);
+        const foundPlayer = this.tournament.getParticipant(this.playerId)
 
         return new StatusHeaderSectionComponent(
             'status',
             this.getStatusDescription(),
             new IconImageComponent(this.getStatusIcon()),
-            !foundPlayer ?
+            !foundPlayer && this.tournament.getRoomMaster<TournamentMaster>().isWaiting() ?
                 new PrimaryButtonButtonsComponent(
-                    new TextButtonComponent('Join tournament')
+                    new TextButtonComponent(
+                        this.localeService.t('common.tournaments.screen.button.join.tournament', { lang: this.lang })
+                    )
                 ) : undefined,
         )
     }
@@ -92,7 +118,7 @@ export class OneTableTournamentStatusScreenView extends UniversalScreenView {
 
     private getStatusDescription (): string {
         if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
-            return this.localeService.t('common.tournaments.status.2', { lang: this.lang });
+            return this.localeService.t('common.tournaments.status.4', { lang: this.lang });
         } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
             return this.localeService.t('common.tournaments.status.3', { lang: this.lang });
         } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {

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

@@ -2,7 +2,6 @@ import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } fro
 import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
 
 import { OneTableTournamentService } from './one-table-tournament.service';
-import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
 
 @Controller('tournament/one_table')
 export class OneTableTournamentController {

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

@@ -1,6 +1,5 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    BaseAppScreen,
     IAppHeaders,
     IBaseAppScreen,
     IBaseMoveData,
@@ -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()
         );
     }
 

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/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 })),
             ),
         );
     }