jp.ms.common.modules 1.0.54 → 1.0.56

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/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,
@@ -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),