jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -1,13 +1,17 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IAppHeaders,
-    IBaseAppScreen,
-    IBaseMoveData,
-    IAppTableState,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  IAppHeaders,
+  IBaseAppScreen,
+  IBaseMoveData,
+  IAppTableState,
 } from 'jp.common.models';
 
 import { BaseAppScreenDto } from '../../dto';
-import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 
 import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
@@ -16,107 +20,127 @@ import { OneTableTournamentStatusScreenView } from './one-table-tournament-statu
 
 @Injectable()
 export class OneTableTournamentService {
-    constructor(
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(ONE_TABLE_TOURNAMENT_OPTIONS) private readonly options: OneTableTournamentFactoryOptions,
-    ) {
+  constructor(
+    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(ONE_TABLE_TOURNAMENT_OPTIONS)
+    private readonly options: OneTableTournamentFactoryOptions,
+  ) {}
+
+  getStatusScreen(
+    tournamentId: string,
+    lang: string,
+    playerId: string,
+  ): BaseAppScreenDto {
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+    if (!tournament) {
+      throw new InternalServerErrorException();
     }
 
-    getStatusScreen (tournamentId: string, lang: string, playerId: string): BaseAppScreenDto {
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
-
-        if (!tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        return new BaseAppScreenDto(
-            new OneTableTournamentStatusScreenView(
-                this.options.i18n,
-                lang,
-                tournament,
-                playerId,
-            ).buildBS()
-        );
+    return new BaseAppScreenDto(
+      new OneTableTournamentStatusScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+        playerId,
+      ).buildBS(),
+    );
+  }
+
+  subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+    if (player && tournament) {
+      tournament.addToStatusScreenWatchers(player);
+
+      return;
     }
 
-    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.addToStatusScreenWatchers(player);
+  unsubscribeFromStatusScreen(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
-            return;
-        }
+    if (player && tournament) {
+      tournament.removeFromStatusScreenWatchers(player);
 
-        throw new InternalServerErrorException();
+      return;
     }
 
-    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.removeFromStatusScreenWatchers(player);
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return;
-        }
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
+  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);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleMoveOnTheTable(player, tableId, moveDto);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    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);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  joinTournament(tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
+    const player = this.playersManager.getPlayerById(headers.client_auth_token);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && tournament) {
+      tournament.handleJoinTournament(player);
 
-        throw new InternalServerErrorException();
+      return this.getStatusScreen(
+        tournamentId,
+        headers.client_language,
+        headers.client_auth_token,
+      );
     }
 
-    joinTournament (tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
-        const player = this.playersManager.getPlayerById(headers.client_auth_token);
-        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.handleJoinTournament(player);
+  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
 
-            return this.getStatusScreen(tournamentId, headers.client_language, headers.client_auth_token);
-        }
+    if (player && tournament) {
+      tournament.handleLeaveTournament(player);
 
-        throw new InternalServerErrorException();
+      return;
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
-
-        if (player && tournament) {
-            tournament.handleLeaveTournament(player);
-
-            return;
-        }
-
-        throw new InternalServerErrorException();
-    }
+    throw new InternalServerErrorException();
+  }
 }

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

@@ -0,0 +1,2 @@
+export { OneTableTournamentRoomsManagerModule } from './one-table-tournament-rooms-manager.module';
+export { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';

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

@@ -0,0 +1,3 @@
+export const ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS = Symbol(
+  'ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS',
+);

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

@@ -0,0 +1,29 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { I18nService } from 'nestjs-i18n';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+import {
+  TournamentRoomConfig,
+  OneTableTournamentRoom,
+  IPrizeTableData,
+} from 'jp.ms.common.engine';
+
+export interface OneTableTournamentRoomsManagerOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => OneTableTournamentRoomsFactoryOptions;
+}
+
+export interface OneTableTournamentRoomsFactoryOptions {
+  i18n: I18nService | any;
+  createTournamentRoom(room: TournamentRoomConfig): OneTableTournamentRoom;
+  gameType: string;
+  restartGameTimeout: number;
+  playersTurnTimeout: number;
+  instantFinishMode: boolean;
+  tournamentPrizeTable: IPrizeTableData;
+}

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

@@ -0,0 +1,66 @@
+import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+  OneTableTournamentRoom,
+  OneTableTournamentRoomSchema,
+  OneTableTournamentRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
+} from 'jp.db.schemas';
+
+import { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';
+import { OneTableTournamentRoomsManagerOptions } from './one-table-tournament-rooms-manager.interfaces';
+import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
+
+@Global()
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: OneTableTournamentRoom.name,
+        schema: OneTableTournamentRoomSchema,
+      },
+    ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: GameResult.name, schema: GameResultSchema },
+    ]),
+  ],
+  providers: [
+    OneTableTournamentRoomsRepository,
+    UsersRepository,
+    OneTableTournamentRoomsManagerService,
+    GameResultRepository,
+  ],
+  exports: [OneTableTournamentRoomsManagerService],
+})
+export class OneTableTournamentRoomsManagerModule {
+  constructor(
+    private readonly managerService: OneTableTournamentRoomsManagerService,
+  ) {}
+
+  static forRootAsync(
+    options: OneTableTournamentRoomsManagerOptions,
+  ): DynamicModule {
+    return {
+      module: OneTableTournamentRoomsManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+
+  async onModuleInit() {
+    await this.managerService.createMasterTournament();
+    await this.managerService.hydrateTournamentsFromDB();
+  }
+}

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

@@ -9,6 +9,7 @@ import {
   GameTournamentPlayerLeavedTheTournamentEvent,
   GameTournamentStartedEvent,
   GameTournamentWaitedEvent,
+  LocalService,
   NoStartStrategy,
   OneTableTournamentRoom,
   RoomUpdateStateEvent,
@@ -17,88 +18,98 @@ import {
 } from 'jp.ms.common.engine';
 import {
   GameResultRepository,
-  TournamentOneTableRoomDocument,
-  TournamentOneTableRoomsRepository,
-  UsersRepository
+  OneTableTournamentRoomDocument,
+  OneTableTournamentRoomsRepository,
+  UsersRepository,
 } from 'jp.db.schemas';
 import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
-import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
-import { EventsBusMainTablesSubscribeService, EventsBusOneTableTournamentSubscribeService } from '../event-bus';
+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';
-import { TournamentOneTableRoomsFactoryOptions } from './tournament-one-table-rooms-manager.interfaces';
+import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
+import { OneTableTournamentRoomsFactoryOptions } from './one-table-tournament-rooms-manager.interfaces';
 
 @Injectable()
-export class TournamentOneTableRoomsManagerService {
+export class OneTableTournamentRoomsManagerService {
   private readonly rooms: Map<string, OneTableTournamentRoom>;
 
   constructor(
-    private readonly tournamentRepository: TournamentOneTableRoomsRepository,
+    private readonly tournamentRepository: OneTableTournamentRoomsRepository,
     private readonly usersRepository: UsersRepository,
     private readonly gameResultRepository: GameResultRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
-    @Inject(TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentOneTableRoomsFactoryOptions,
+    @Inject(ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: OneTableTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
     this.rooms = new Map<string, OneTableTournamentRoom>();
   }
 
-  get gameType () {
-    return this.options.configService.get<string>('GAME_TYPE') || '';
+  get gameType() {
+    return this.options.gameType;
   }
 
-  getRoomById (roomId: string): OneTableTournamentRoom | undefined {
+  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
     return this.rooms.get(roomId);
   }
 
-  getRoomByTableId (tableId: string): OneTableTournamentRoom | undefined {
+  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
     return this.getRoomById(roomId);
   }
 
-  getRooms (): Array<OneTableTournamentRoom> {
+  getRooms(): Array<OneTableTournamentRoom> {
     return Array.from(this.rooms.values());
   }
 
-  getTables (): Array<GameMaster> {
-    return this.getRooms().reduce(
-      (result, currentValue) => {
-        return [...result, ...currentValue.getMasters()];
-      },
-      [] as Array<GameMaster>
-    );
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
   }
 
-  addRoom (room: OneTableTournamentRoom) {
+  addRoom(room: OneTableTournamentRoom) {
     this.rooms.set(room.getId(), room);
   }
 
-  async createMasterTournament () {
-    const waitingTournament = await this.tournamentRepository.findWaitingTournament(this.gameType);
+  async createMasterTournament() {
+    const waitingTournament =
+      await this.tournamentRepository.findWaitingTournament(this.gameType);
     if (!waitingTournament) {
-      await this.tournamentRepository.createTournamentFromMasterTemplate(this.gameType);
+      await this.tournamentRepository.createTournamentFromMasterTemplate(
+        this.gameType,
+      );
     }
   }
 
-  async hydrateTournamentsFromDB () {
-    const templates = await this.tournamentRepository.findActualTournaments(this.gameType);
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
     templates.forEach((item) => {
-      this.addRoom(this.options.createTournamentRoom(
-        this.oneTableTournamentDocumentToTournamentRoom(item)
-      ));
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(item),
+        ),
+      );
     });
   }
 
-  private oneTableTournamentDocumentToTournamentRoom (tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
-    const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
-    const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-
+  private oneTableTournamentDocumentToTournamentRoom(
+    tournamentDocument: OneTableTournamentRoomDocument,
+  ): TournamentRoomConfig {
     return {
       id: tournamentDocument.tournamentId,
       gameType: tournamentDocument.gameType,
@@ -112,9 +123,10 @@ export class TournamentOneTableRoomsManagerService {
       subtitle: tournamentDocument.subtitle,
       description: tournamentDocument.description,
       enableForFastGame: false,
-      turnTimeout: playersTurnTimeout,
-      restartTimeout: restartGameTimeout,
-      localeService: this.options.i18n,
+      turnTimeout: this.options.playersTurnTimeout,
+      restartTimeout: this.options.restartGameTimeout,
+      instantFinishMode: this.options.instantFinishMode,
+      localeService: this.options.i18n as LocalService,
       startStrategy: new NoStartStrategy(),
       onRoomEvent: this.handleRoomEvent,
       tournamentPrizeTable: this.options.tournamentPrizeTable,
@@ -122,20 +134,20 @@ export class TournamentOneTableRoomsManagerService {
       tournamentWinners: tournamentDocument.winners,
       maxParticipants: tournamentDocument.maxParticipants,
       participants: tournamentDocument.participants,
-    } as TournamentRoomConfig;
+    };
   }
 
   private handleRoomEvent = (event: BaseGameEvent) => {
     this.logger.log(event.toLog());
 
     if (event instanceof GameTableFinishedEvent) {
-      this.handleRoomTableGameFinished(event.master!!);
+      void this.handleRoomTableGameFinished(event.master);
     } else if (event instanceof GameTournamentStartedEvent) {
-      this.handleTournamentRoomStarted(event.room.getRoomMaster());
+      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
     } else if (event instanceof GameTournamentCancelledEvent) {
-      this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
     } else if (event instanceof GameTournamentFinishedEvent) {
-      this.handleTournamentRoomFinished(event.room.getRoomMaster());
+      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
     } else if (
       event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
       event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
@@ -144,7 +156,9 @@ export class TournamentOneTableRoomsManagerService {
       event instanceof GameTournamentStartedEvent ||
       event instanceof GameTournamentFinishedEvent
     ) {
-      this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
+      void this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
     }
   };
 
@@ -167,12 +181,15 @@ export class TournamentOneTableRoomsManagerService {
         master.getTournamentId(),
         master.getRoom().getParticipants(),
       );
-      const newTournament = await this.tournamentRepository.createTournamentFromMasterTemplate(
-        master.getRoom().getGameType()
+      const newTournament =
+        await this.tournamentRepository.createTournamentFromMasterTemplate(
+          master.getRoom().getGameType(),
+        );
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(newTournament),
+        ),
       );
-      this.addRoom(this.options.createTournamentRoom(
-        this.oneTableTournamentDocumentToTournamentRoom(newTournament)
-      ));
 
       await session.commitTransaction();
     } catch (error) {
@@ -181,11 +198,11 @@ export class TournamentOneTableRoomsManagerService {
     } finally {
       await session.endSession();
     }
-  }
+  };
 
   private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
-  }
+  };
 
   private handleTournamentRoomFinished = async (master: TournamentMaster) => {
     await saveTournamentResult(
@@ -194,10 +211,10 @@ export class TournamentOneTableRoomsManagerService {
       this.tournamentRepository,
       this.usersRepository,
     );
-  }
+  };
 
-  private handleRoomStatusUpdated = async (event: RoomUpdateStateEvent) => {
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
     this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
     this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
-  }
+  };
 }

package/src/modules/players-manager/players-manager.module.ts

@@ -1,10 +1,9 @@
 import { Global, Module } from '@nestjs/common';
 import { PlayersManagerService } from './players-manager.service';
 
-
 @Global()
 @Module({
   providers: [PlayersManagerService],
-  exports: [PlayersManagerService]
+  exports: [PlayersManagerService],
 })
 export class PlayersManagerModule {}

package/src/modules/players-manager/players-manager.service.ts

@@ -5,23 +5,23 @@ import { GamePlayer } from 'jp.ms.common.engine';
 export class PlayersManagerService {
   private readonly players: Map<string, GamePlayer>;
 
-  constructor () {
+  constructor() {
     this.players = new Map<string, GamePlayer>();
   }
 
-  getPlayerById (playerId: string): GamePlayer | undefined {
+  getPlayerById(playerId: string): GamePlayer | undefined {
     return this.players.get(playerId);
   }
 
-  getPlayers (): Array<GamePlayer> {
+  getPlayers(): Array<GamePlayer> {
     return Array.from(this.players.values());
   }
 
-  addPlayer (player: GamePlayer): void {
+  addPlayer(player: GamePlayer): void {
     this.players.set(player.id, player);
   }
 
-  removePlayer (playerId: string): void {
+  removePlayer(playerId: string): void {
     this.players.delete(playerId);
   }
 }