jp.ms.common.modules 1.0.55 → 1.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.55",
+  "version": "1.0.56",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "jp.common.models": "1.1.61",
     "jp.common.utils": "1.0.9",
     "jp.db.schemas": "2.2.25",
-    "jp.ms.common.engine": "3.0.34",
+    "jp.ms.common.engine": "3.0.35",
     "mongoose": "9.1.5",
     "nestjs-i18n": "10.5.1",
     "node-schedule": "2.1.1",

package/src/exception/global-exception-filter.ts

@@ -23,16 +23,10 @@ export class GlobalExceptionFilter implements ExceptionFilter {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
 
-    switch (exception.constructor.name) {
-      case HttpExceptionWithSnackbar.name: {
-        return this.processHttpExceptionWithSnackbar(
-          exception as HttpExceptionWithSnackbar,
-          response,
-        );
-      }
-      case HttpException.name: {
-        return this.processHttpException(exception as HttpException, response);
-      }
+    if (exception instanceof HttpExceptionWithSnackbar) {
+      return this.processHttpExceptionWithSnackbar(exception, response);
+    } else if (exception instanceof HttpException) {
+      return this.processHttpException(exception, response);
     }
 
     response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({

package/src/modules/main/main.controller.ts

@@ -43,7 +43,7 @@ export class MainController {
   }
 
   @Get('find_free_table')
-  findFreeTable(@Headers() headers: IAppHeaders): FindFreeTableDto {
+  findFreeTable(@Headers() headers: IAppHeaders): Promise<FindFreeTableDto> {
     return this.mainService.findFreeTable(
       headers.client_auth_token,
       headers.client_language,

package/src/modules/main/main.service.ts

@@ -29,6 +29,7 @@ import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tourname
 import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
 import {
   ErrorCodeEnum,
+  NotEnoughMoneyForPurchaseException,
   NotFoundFreeRoomForFastGameException,
 } from '../../exception';
 
@@ -140,11 +141,16 @@ export class MainService {
     return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
   }
 
-  findFreeTable(clientAuthToken: string, lang: string): FindFreeTableDto {
+  async findFreeTable(
+    clientAuthToken: string,
+    lang: string,
+  ): Promise<FindFreeTableDto> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
+    const table = this.simpleRoomsManager.getFreeFastGameRoom();
+    const tableId = table?.getId();
+    const user = await this.usersRepository.findById(player?.id ?? '');
 
-    if (!player || !tableId) {
+    if (!player || !table || !tableId || !user) {
       throw new NotFoundFreeRoomForFastGameException(
         new ErrorSnackbarComponent(
           ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
@@ -153,6 +159,17 @@ export class MainService {
       );
     }
 
+    if (user.balance < table.room.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', {
+            lang,
+          }),
+        ),
+      );
+    }
+
     return FindFreeTableDto.fromEntities(
       AppScreenRouter.getSimpleRoomTablePath(tableId),
       player.id,

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

@@ -9,10 +9,7 @@ import {
   AppScreenRouter,
   ErrorSnackbarComponent,
 } from 'jp.common.models';
-import {
-  ManyTablesTournamentMaster,
-  TournamentMaster,
-} from 'jp.ms.common.engine';
+import { TournamentMaster } from 'jp.ms.common.engine';
 import { PurchaseRepository, UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
@@ -152,52 +149,40 @@ export class ManyTablesTournamentService {
       player?.id ?? '',
     );
 
-    if (player && tournament) {
-      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) && ticket?.amount) {
-          player.stack = ticket.amount;
-
-          tournament
-            .getRoomMaster<ManyTablesTournamentMaster>()
-            .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
-
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTablePath(
-              player.tableId ?? '',
-            ),
-            player.id,
-          );
-        } else {
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
-            player.id,
-          );
-        }
-      } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+      if (tournament.isParticipant(player.id) && ticket?.amount) {
+        player.stack = ticket.amount;
         tournament.handleJoinTournament(player);
 
         return JoinTournamentDto.fromEntities(
-          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          AppScreenRouter.getManyTablesTournamentTablePath(
+            player.tableId ?? '',
+          ),
           player.id,
         );
       } else {
         return JoinTournamentDto.fromEntities(
-          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
           player.id,
         );
       }
-    }
+    } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+      tournament.handleJoinTournament(player);
 
-    throw new InternalServerErrorException();
+      return JoinTournamentDto.fromEntities(
+        AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+        player.id,
+      );
+    } else {
+      return JoinTournamentDto.fromEntities(
+        AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+        player.id,
+      );
+    }
   }
 
   async leaveTournament(

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

@@ -18,6 +18,7 @@ import {
   GameTournamentFinishedEvent,
   GameTournamentPlayerJoinedTheTournamentEvent,
   GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentPlayerLostTournamentEvent,
   GameTournamentStartedEvent,
   GameTournamentWaitedEvent,
   LocalService,
@@ -322,6 +323,12 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
         this.handleRoomStatusUpdated(event as GamePlayerKickedOutTheTableEvent);
         break;
       }
+      case GameTournamentPlayerLostTournamentEvent.name: {
+        void this.handleGameTournamentPlayerLostTournamentEvent(
+          event as GameTournamentPlayerLostTournamentEvent,
+        );
+        break;
+      }
       case GameTournamentPlayerJoinedTheTournamentEvent.name:
       case GameTournamentPlayerLeavedTheTournamentEvent.name:
       case GameTournamentWaitedEvent.name: {
@@ -366,6 +373,20 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
   private handleGamePlayerKickedOutTheTable = async (
     event: GamePlayerKickedOutTheTableEvent,
   ) => {
+    await this.cancelTicket(event);
+  };
+
+  private handleGameTournamentPlayerLostTournamentEvent = async (
+    event: GameTournamentPlayerLostTournamentEvent,
+  ) => {
+    await this.cancelTicket(event);
+  };
+
+  private async cancelTicket(
+    event:
+      | GamePlayerKickedOutTheTableEvent
+      | GameTournamentPlayerLostTournamentEvent,
+  ) {
     const tournament = this.getRoomById(event.roomId);
     if (tournament?.isParticipant(event.playerId)) {
       const ticket =
@@ -382,7 +403,7 @@ export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsMana
 
       tournament.handleLeaveTournament(event.player);
     }
-  };
+  }
 
   private handleRoomStatusUpdated = (
     event:

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

@@ -86,7 +86,7 @@ export class OneTableTournamentController {
   joinTournament(
     @Param('tournamentId') tournamentId: string,
     @Headers() headers: IAppHeaders,
-  ): IBaseAppScreen {
+  ): Promise<IBaseAppScreen> {
     return this.tournamentService.joinTournament(tournamentId, headers);
   }
 

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

@@ -4,6 +4,9 @@ import {
   OneTableTournamentRoom,
   OneTableTournamentRoomSchema,
   OneTableTournamentRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
 } from 'jp.db.schemas';
 import {
   GamePlayer,
@@ -27,9 +30,14 @@ import { OneTableTournamentModuleOptions } from './one-table-tournament.interfac
         schema: OneTableTournamentRoomSchema,
       },
     ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
   ],
   controllers: [OneTableTournamentController],
-  providers: [OneTableTournamentService, OneTableTournamentRoomsRepository],
+  providers: [
+    OneTableTournamentService,
+    OneTableTournamentRoomsRepository,
+    UsersRepository,
+  ],
 })
 export class OneTableTournamentModule {
   constructor(

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

@@ -8,11 +8,17 @@ import {
   IBaseAppScreen,
   IBaseMoveData,
   IAppTableState,
+  ErrorSnackbarComponent,
 } from 'jp.common.models';
+import { UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
 import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
 import { PlayersManagerService } from '../players-manager/players-manager.service';
+import {
+  NotEnoughMoneyForPurchaseException,
+  ErrorCodeEnum,
+} from '../../exception';
 
 import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
 import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
@@ -23,6 +29,7 @@ export class OneTableTournamentService {
   constructor(
     private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
     private readonly playersManager: PlayersManagerService,
+    private readonly usersRepository: UsersRepository,
     @Inject(ONE_TABLE_TOURNAMENT_OPTIONS)
     private readonly options: OneTableTournamentFactoryOptions,
   ) {}
@@ -112,22 +119,37 @@ export class OneTableTournamentService {
     throw new InternalServerErrorException();
   }
 
-  joinTournament(tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
+  async joinTournament(
+    tournamentId: string,
+    headers: IAppHeaders,
+  ): Promise<IBaseAppScreen> {
     const player = this.playersManager.getPlayerById(headers.client_auth_token);
     const tournament =
       this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
 
-    if (player && tournament) {
-      tournament.handleJoinTournament(player);
+    if (!player || !tournament || !user) {
+      throw new InternalServerErrorException();
+    }
 
-      return this.getStatusScreen(
-        tournamentId,
-        headers.client_language,
-        headers.client_auth_token,
+    if (user.balance < tournament.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', {
+            lang: headers.client_language,
+          }),
+        ),
       );
     }
 
-    throw new InternalServerErrorException();
+    tournament.handleJoinTournament(player);
+
+    return this.getStatusScreen(
+      tournamentId,
+      headers.client_language,
+      headers.client_auth_token,
+    );
   }
 
   leaveTournament(tournamentId: string, clientAuthToken: string): void {

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

@@ -28,8 +28,12 @@ export class SimpleRoomsController {
   enterTheTable(
     @Param('tableId') tableId: string,
     @Headers() headers: IAppHeaders,
-  ): IAppTableState {
-    return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
+  ): Promise<IAppTableState> {
+    return this.roomsService.enterTheTable(
+      tableId,
+      headers.client_auth_token,
+      headers.client_language,
+    );
   }
 
   @Post('table/exit/:tableId')

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

@@ -4,6 +4,9 @@ import {
   SimpleRoom,
   SimpleRoomSchema,
   SimpleRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
 } from 'jp.db.schemas';
 
 import { SimpleRoomsController } from './simple-rooms.controller';
@@ -16,9 +19,10 @@ import { SimpleRoomsModuleOptions } from './simple-rooms.interfaces';
     MongooseModule.forFeature([
       { name: SimpleRoom.name, schema: SimpleRoomSchema },
     ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
   ],
   controllers: [SimpleRoomsController],
-  providers: [SimpleRoomsService, SimpleRoomsRepository],
+  providers: [SimpleRoomsService, SimpleRoomsRepository, UsersRepository],
 })
 export class SimpleRoomsModule {
   constructor() {}

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

@@ -3,10 +3,19 @@ import {
   Injectable,
   InternalServerErrorException,
 } from '@nestjs/common';
-import { IBaseMoveData, IAppTableState } from 'jp.common.models';
+import {
+  IBaseMoveData,
+  IAppTableState,
+  ErrorSnackbarComponent,
+} from 'jp.common.models';
+import { UsersRepository } from 'jp.db.schemas';
 
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 import { PlayersManagerService } from '../players-manager';
+import {
+  NotEnoughMoneyForPurchaseException,
+  ErrorCodeEnum,
+} from '../../exception';
 
 import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
 import { SimpleRoomsFactoryOptions } from './simple-rooms.interfaces';
@@ -16,6 +25,7 @@ export class SimpleRoomsService {
   constructor(
     private readonly simpleRoomsManager: SimpleRoomsManagerService,
     private readonly playersManager: PlayersManagerService,
+    private readonly usersRepository: UsersRepository,
     @Inject(SIMPLE_ROOMS_OPTIONS)
     private readonly options: SimpleRoomsFactoryOptions,
   ) {}
@@ -34,18 +44,34 @@ export class SimpleRoomsService {
     throw new InternalServerErrorException();
   }
 
-  enterTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+  async enterTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    clientLanguage: string,
+  ): Promise<IAppTableState> {
     const player = this.playersManager.getPlayerById(clientAuthToken);
     const room = this.simpleRoomsManager.getRoomByTableId(tableId);
     const master = room?.getMasterById(tableId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
 
-    if (player && room && master) {
-      room.handleEnterTheTable(player, tableId);
+    if (!player || !room || !master || !user) {
+      throw new InternalServerErrorException();
+    }
 
-      return master.createGameStateDto(player);
+    if (user.balance < room.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4002', {
+            lang: clientLanguage,
+          }),
+        ),
+      );
     }
 
-    throw new InternalServerErrorException();
+    room.handleEnterTheTable(player, tableId);
+
+    return master.createGameStateDto(player);
   }
 
   exitTheTable(tableId: string, clientAuthToken: string): IAppTableState {

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

@@ -149,7 +149,7 @@ export class SimpleRoomsManagerService extends RoomsManagerService {
       tableSize: room.tableSize,
       tableType: room.tableType,
       bet: room.bet,
-      ticketPrice: room.ticketPrice / 2,
+      ticketPrice: room.ticketPrice,
       title: room.title,
       subtitle: room.subtitle,
       description: room.description,