jp.ms.common.modules 1.0.54 → 1.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.54",
+  "version": "1.0.55",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "dayjs": "1.11.18",
     "jp.common.models": "1.1.61",
     "jp.common.utils": "1.0.9",
-    "jp.db.schemas": "2.2.17",
-    "jp.ms.common.engine": "3.0.33",
+    "jp.db.schemas": "2.2.25",
+    "jp.ms.common.engine": "3.0.34",
     "mongoose": "9.1.5",
     "nestjs-i18n": "10.5.1",
     "node-schedule": "2.1.1",

package/src/modules/main/main-tables-list-screen.view.ts

@@ -123,7 +123,11 @@ export class MainTablesListScreenView extends UniversalScreenView {
           this.getOneTableTournamentIcon(room),
           true,
           true,
-          AppScreenRouter.getOneTableTournamentStatusPath(room.getId()),
+          room.getRoomMaster<TournamentMaster>().isInProgress()
+            ? AppScreenRouter.getOneTableTournamentTablePath(
+                room.getFirstMaster()?.getTable().getId() ?? '',
+              )
+            : AppScreenRouter.getOneTableTournamentStatusPath(room.getId()),
         ),
     );
   }
@@ -251,7 +255,10 @@ export class MainTablesListScreenView extends UniversalScreenView {
   }
 
   private getManyTablesTournamenButtons(tournament: ManyTablesTournamentRoom) {
-    if (tournament.isParticipant(this.playerId)) {
+    if (
+      tournament.isParticipant(this.playerId) ||
+      tournament.getRoomMaster<TournamentMaster>().isInProgress()
+    ) {
       return new PrimaryButtonButtonsComponent(
         new TextButtonComponent(
           this.localeService.t(

package/src/modules/many-tables-tournament/many-tables-tournament.controller.ts

@@ -104,7 +104,7 @@ export class ManyTablesTournamentController {
   joinTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): JoinTournamentDto {
+  ): Promise<JoinTournamentDto> {
     return this.tournamentService.joinTournament(
       tournamentId,
       headers.client_auth_token,
@@ -116,7 +116,7 @@ export class ManyTablesTournamentController {
   leaveTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): void {
+  ): Promise<void> {
     return this.tournamentService.leaveTournament(
       tournamentId,
       headers.client_auth_token,

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

@@ -4,6 +4,9 @@ import {
   ManyTablesTournamentRoom,
   ManyTablesTournamentRoomSchema,
   ManyTablesTournamentRoomsRepository,
+  Purchase,
+  PurchaseRepository,
+  PurchaseSchema,
   User,
   UserSchema,
   UsersRepository,
@@ -31,12 +34,16 @@ import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.inte
       },
     ]),
     MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
   ],
   controllers: [ManyTablesTournamentController],
   providers: [
     ManyTablesTournamentService,
     ManyTablesTournamentRoomsRepository,
     UsersRepository,
+    PurchaseRepository,
   ],
 })
 export class ManyTablesTournamentModule {

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

@@ -13,7 +13,7 @@ import {
   ManyTablesTournamentMaster,
   TournamentMaster,
 } from 'jp.ms.common.engine';
-import { UsersRepository } from 'jp.db.schemas';
+import { PurchaseRepository, UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
 import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
@@ -39,6 +39,7 @@ export class ManyTablesTournamentService {
     @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
     private readonly options: ManyTablesTournamentFactoryOptions,
     private readonly usersRepository: UsersRepository,
+    private readonly purchaseRepository: PurchaseRepository,
   ) {}
 
   getStatusScreen(
@@ -139,26 +140,32 @@ export class ManyTablesTournamentService {
     throw new InternalServerErrorException();
   }
 
-  joinTournament(
+  async joinTournament(
     tournamentId: string,
     clientAuthToken: string,
-  ): JoinTournamentDto {
+  ): Promise<JoinTournamentDto> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
     const tournament =
       this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    const ticket = await this.purchaseRepository.getManyTablesTournamentTicket(
+      tournamentId,
+      player?.id ?? '',
+    );
 
     if (player && tournament) {
-      tournament.handleJoinTournament(player);
-
       if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
         if (player.isPlayer() || player.isTableQueuer()) {
+          tournament.handleJoinTournament(player);
+
           return JoinTournamentDto.fromEntities(
             AppScreenRouter.getManyTablesTournamentTablePath(
               player.tableId ?? '',
             ),
             player.id,
           );
-        } else if (tournament.isParticipant(player.id)) {
+        } else if (tournament.isParticipant(player.id) && ticket?.amount) {
+          player.stack = ticket.amount;
+
           tournament
             .getRoomMaster<ManyTablesTournamentMaster>()
             .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
@@ -175,6 +182,13 @@ export class ManyTablesTournamentService {
             player.id,
           );
         }
+      } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+        tournament.handleJoinTournament(player);
+
+        return JoinTournamentDto.fromEntities(
+          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          player.id,
+        );
       } else {
         return JoinTournamentDto.fromEntities(
           AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
@@ -186,7 +200,10 @@ export class ManyTablesTournamentService {
     throw new InternalServerErrorException();
   }
 
-  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+  async leaveTournament(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): Promise<void> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
     const tournament =
       this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
@@ -195,6 +212,20 @@ export class ManyTablesTournamentService {
       throw new InternalServerErrorException();
     }
 
+    if (tournament.isParticipant(player.id) && player.isPlayer()) {
+      const ticket =
+        await this.purchaseRepository.getManyTablesTournamentTicket(
+          tournament.getId(),
+          player.id,
+        );
+
+      if (ticket) {
+        await this.purchaseRepository.cancelManyTablesTournamentTicket(
+          ticket.purchaseId,
+        );
+      }
+    }
+
     tournament.handleLeaveTournament(player);
   }
 

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

@@ -35,4 +35,6 @@ export interface ManyTablesTournamentRoomsFactoryOptions {
   dailyTournamentTime: string;
   minPlayersForMergeTables: number;
   levelUpBonus: number;
+  purgeRoomsEnabled: boolean;
+  purgeRoomsTime: string;
 }

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

@@ -91,6 +91,9 @@ export class ManyTablesTournamentRoomsManagerModule {
     if (this.options.dailyTournamentScheduleJobEnabled) {
       await this.managerService.runDailyTournamentJob();
     }
+    if (this.options.purgeRoomsEnabled) {
+      this.managerService.runPurgeRoomsJob();
+    }
     await this.managerService.hydrateTournamentsFromDB();
   }
 }

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

@@ -55,6 +55,7 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
 export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, ManyTablesTournamentRoom>;
   private createDailyTournamentJob: Job | null;
+  private purgeRoomsJob: Job;
 
   constructor(
     private readonly tournamentRepository: ManyTablesTournamentRoomsRepository,
@@ -84,6 +85,10 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     return this.rooms.get(roomId);
   }
 
+  removeRoom(roomId: string) {
+    this.rooms.delete(roomId);
+  }
+
   getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
@@ -131,6 +136,31 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     }
   }
 
+  runPurgeRoomsJob() {
+    const purgeRoomsTime = this.options.purgeRoomsTime;
+
+    if (purgeRoomsTime) {
+      this.logger.log(
+        `${ManyTablesTournamentRoomsManagerService.name}: runPurgeRoomsJob`,
+      );
+
+      this.purgeRoomsJob = schedule.scheduleJob(purgeRoomsTime, () =>
+        this.purgeRooms(),
+      );
+    }
+  }
+
+  purgeRooms() {
+    for (const room of this.getRooms()) {
+      if (!room.isActual()) {
+        this.removeRoom(room.getId());
+        this.logger.log(
+          `${ManyTablesTournamentRoomsManagerService.name}: removeRoom: ${room.getId()}`,
+        );
+      }
+    }
+  }
+
   async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
     const newTournament =
       await this.tournamentRepository.createTournament(createTournamentDto);
@@ -237,6 +267,7 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
       tournamentWinners: tournamentDocument.winners,
       maxParticipants: tournamentDocument.maxParticipants,
       participants: tournamentDocument.participants,
+      finishDate: tournamentDocument.finishDate,
     };
   }
 
@@ -284,7 +315,13 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
         this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
         break;
       }
-      case GamePlayerKickedOutTheTableEvent.name:
+      case GamePlayerKickedOutTheTableEvent.name: {
+        void this.handleGamePlayerKickedOutTheTable(
+          event as GamePlayerKickedOutTheTableEvent,
+        );
+        this.handleRoomStatusUpdated(event as GamePlayerKickedOutTheTableEvent);
+        break;
+      }
       case GameTournamentPlayerJoinedTheTournamentEvent.name:
       case GameTournamentPlayerLeavedTheTournamentEvent.name:
       case GameTournamentWaitedEvent.name: {
@@ -292,8 +329,7 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
           event as
             | GameTournamentPlayerJoinedTheTournamentEvent
             | GameTournamentPlayerLeavedTheTournamentEvent
-            | GameTournamentCancelledEvent
-            | GamePlayerKickedOutTheTableEvent,
+            | GameTournamentCancelledEvent,
         );
         break;
       }
@@ -327,6 +363,27 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
     );
   };
 
+  private handleGamePlayerKickedOutTheTable = async (
+    event: GamePlayerKickedOutTheTableEvent,
+  ) => {
+    const tournament = this.getRoomById(event.roomId);
+    if (tournament?.isParticipant(event.playerId)) {
+      const ticket =
+        await this.purchaseRepository.getManyTablesTournamentTicket(
+          event.roomId,
+          event.playerId,
+        );
+
+      if (ticket) {
+        await this.purchaseRepository.cancelManyTablesTournamentTicket(
+          ticket.purchaseId,
+        );
+      }
+
+      tournament.handleLeaveTournament(event.player);
+    }
+  };
+
   private handleRoomStatusUpdated = (
     event:
       | GameTournamentPlayerJoinedTheTournamentEvent

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

@@ -29,4 +29,6 @@ export interface OneTableTournamentRoomsFactoryOptions {
   instantFinishMode: boolean;
   tournamentPrizeTable: IPrizeTableData;
   levelUpBonus: number;
+  purgeRoomsEnabled: boolean;
+  purgeRoomsTime: string;
 }

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

@@ -1,4 +1,10 @@
-import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
   OneTableTournamentRoom,
@@ -16,10 +22,16 @@ import {
   ActivityLog,
   ActivityLogRepository,
   ActivityLogSchema,
+  Purchase,
+  PurchaseRepository,
+  PurchaseSchema,
 } from 'jp.db.schemas';
 
 import { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';
-import { OneTableTournamentRoomsManagerOptions } from './one-table-tournament-rooms-manager.interfaces';
+import {
+  OneTableTournamentRoomsFactoryOptions,
+  OneTableTournamentRoomsManagerOptions,
+} from './one-table-tournament-rooms-manager.interfaces';
 import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
 
 @Global()
@@ -39,6 +51,9 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     MongooseModule.forFeature([
       { name: ActivityLog.name, schema: ActivityLogSchema },
     ]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
   ],
   providers: [
     OneTableTournamentRoomsRepository,
@@ -47,12 +62,15 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     GameResultRepository,
     RatingRepository,
     ActivityLogRepository,
+    PurchaseRepository,
   ],
   exports: [OneTableTournamentRoomsManagerService],
 })
 export class OneTableTournamentRoomsManagerModule {
   constructor(
     private readonly managerService: OneTableTournamentRoomsManagerService,
+    @Inject(ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: OneTableTournamentRoomsFactoryOptions,
   ) {}
 
   static forRootAsync(
@@ -74,5 +92,9 @@ export class OneTableTournamentRoomsManagerModule {
   async onModuleInit() {
     await this.managerService.createMasterTournament();
     await this.managerService.hydrateTournamentsFromDB();
+
+    if (this.options.purgeRoomsEnabled) {
+      this.managerService.runPurgeRoomsJob();
+    }
   }
 }

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

@@ -1,4 +1,8 @@
-import { Inject, Injectable } from '@nestjs/common';
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
 import {
   BaseGameEvent,
   GameMaster,
@@ -23,11 +27,13 @@ import {
   GameResultRepository,
   OneTableTournamentRoomDocument,
   OneTableTournamentRoomsRepository,
+  PurchaseRepository,
   RatingRepository,
   UsersRepository,
 } from 'jp.db.schemas';
 import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
+import schedule, { Job } from 'node-schedule';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
 import {
@@ -36,6 +42,7 @@ import {
   EventsBusOneTableTournamentSubscribeService,
 } from '../event-bus';
 import { TournamentRoomsManagerService } from '../../common/tournament-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager';
 
 import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
 import { OneTableTournamentRoomsFactoryOptions } from './one-table-tournament-rooms-manager.interfaces';
@@ -43,6 +50,7 @@ import { OneTableTournamentRoomsFactoryOptions } from './one-table-tournament-ro
 @Injectable()
 export class OneTableTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, OneTableTournamentRoom>;
+  private purgeRoomsJob: Job;
 
   constructor(
     private readonly tournamentRepository: OneTableTournamentRoomsRepository,
@@ -50,6 +58,7 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
     private readonly gameResultRepository: GameResultRepository,
     private readonly ratingRepository: RatingRepository,
     private readonly activityLogRepository: ActivityLogRepository,
+    private readonly purchaseRepository: PurchaseRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
     private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
@@ -57,6 +66,7 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
     private readonly options: OneTableTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
+    private readonly playersManager: PlayersManagerService,
   ) {
     super();
     this.rooms = new Map<string, OneTableTournamentRoom>();
@@ -90,6 +100,10 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
     this.rooms.set(room.getId(), room);
   }
 
+  removeRoom(roomId: string) {
+    this.rooms.delete(roomId);
+  }
+
   async createMasterTournament() {
     const waitingTournament =
       await this.tournamentRepository.findWaitingTournament(this.gameType);
@@ -113,6 +127,31 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
     });
   }
 
+  runPurgeRoomsJob() {
+    const purgeRoomsTime = this.options.purgeRoomsTime;
+
+    if (purgeRoomsTime) {
+      this.logger.log(
+        `${OneTableTournamentRoomsManagerService.name}: runPurgeRoomsJob`,
+      );
+
+      this.purgeRoomsJob = schedule.scheduleJob(purgeRoomsTime, () =>
+        this.purgeRooms(),
+      );
+    }
+  }
+
+  purgeRooms() {
+    for (const room of this.getRooms()) {
+      if (!room.isActual()) {
+        this.removeRoom(room.getId());
+        this.logger.log(
+          `${OneTableTournamentRoomsManagerService.name}: removeRoom: ${room.getId()}`,
+        );
+      }
+    }
+  }
+
   private oneTableTournamentDocumentToTournamentRoom(
     tournamentDocument: OneTableTournamentRoomDocument,
   ): TournamentRoomConfig {
@@ -141,6 +180,7 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
       tournamentWinners: tournamentDocument.winners,
       maxParticipants: tournamentDocument.maxParticipants,
       participants: tournamentDocument.participants,
+      finishDate: tournamentDocument.finishDate,
     };
   }
 
@@ -212,6 +252,10 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
     const master = event.room.getRoomMaster<TournamentMaster>();
 
     try {
+      for (const participant of master.getRoom().getParticipants()) {
+        await this.buyTicket(master.getTournamentId(), participant.playerId);
+      }
+
       await this.tournamentRepository.startTournament(
         master.getTournamentId(),
         master.getRoom().getParticipants(),
@@ -272,4 +316,28 @@ export class OneTableTournamentRoomsManagerService extends TournamentRoomsManage
       updateEvent,
     );
   };
+
+  private async buyTicket(tournamentId: string, playerId: string) {
+    const tournament = this.getRoomById(tournamentId);
+    const user = await this.usersRepository.findById(playerId);
+    const player = this.playersManager.getPlayerById(playerId);
+
+    if (!tournament || !user || !player) {
+      throw new InternalServerErrorException();
+    }
+
+    player.decreaseBalance(tournament.getTicketPrice());
+
+    void this.purchaseRepository.addOneTableTournamentTicketPurchase(
+      player.id,
+      player.fullName,
+      tournamentId,
+      tournament.getTicketPrice(),
+      tournament.getGameType(),
+    );
+    void this.usersRepository.subtractFromBalance(
+      player.id,
+      tournament.getTicketPrice(),
+    );
+  }
 }

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

@@ -216,7 +216,7 @@ export class SimpleRoomsManagerService extends RoomsManagerService {
       await this.gameResultRepository.createGameResult(
         this.getGameTableResults(master),
       );
-      const userGameResults = this.getUserGameResults(master, false);
+      const userGameResults = this.getUserGameResults(master, true);
       await this.usersRepository.saveGameResult(userGameResults);
       await this.ratingRepository.addBulkPlayerRating(
         this.getUserRatings(master),