jp.ms.common.modules 1.0.40 → 1.0.41

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

@@ -1,220 +1,220 @@
-import { Inject, Injectable } from '@nestjs/common';
-import {
-  BaseGameEvent,
-  GameMaster,
-  GameTableFinishedEvent,
-  GameTournamentCancelledEvent,
-  GameTournamentFinishedEvent,
-  GameTournamentPlayerJoinedTheTournamentEvent,
-  GameTournamentPlayerLeavedTheTournamentEvent,
-  GameTournamentStartedEvent,
-  GameTournamentWaitedEvent,
-  LocalService,
-  NoStartStrategy,
-  OneTableTournamentRoom,
-  RoomUpdateStateEvent,
-  TournamentMaster,
-  TournamentRoomConfig,
-} from 'jp.ms.common.engine';
-import {
-  GameResultRepository,
-  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 { 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 OneTableTournamentRoomsManagerService {
-  private readonly rooms: Map<string, OneTableTournamentRoom>;
-
-  constructor(
-    private readonly tournamentRepository: OneTableTournamentRoomsRepository,
-    private readonly usersRepository: UsersRepository,
-    private readonly gameResultRepository: GameResultRepository,
-    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-    private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
-    @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.gameType;
-  }
-
-  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
-    return this.rooms.get(roomId);
-  }
-
-  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
-    const { roomId } = GameMaster.parseTableId(tableId);
-
-    return this.getRoomById(roomId);
-  }
-
-  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>);
-  }
-
-  addRoom(room: OneTableTournamentRoom) {
-    this.rooms.set(room.getId(), room);
-  }
-
-  async createMasterTournament() {
-    const waitingTournament =
-      await this.tournamentRepository.findWaitingTournament(this.gameType);
-    if (!waitingTournament) {
-      await this.tournamentRepository.createTournamentFromMasterTemplate(
-        this.gameType,
-      );
-    }
-  }
-
-  async hydrateTournamentsFromDB() {
-    const templates = await this.tournamentRepository.findActualTournaments(
-      this.gameType,
-    );
-    templates.forEach((item) => {
-      this.addRoom(
-        this.options.createTournamentRoom(
-          this.oneTableTournamentDocumentToTournamentRoom(item),
-        ),
-      );
-    });
-  }
-
-  private oneTableTournamentDocumentToTournamentRoom(
-    tournamentDocument: OneTableTournamentRoomDocument,
-  ): TournamentRoomConfig {
-    return {
-      id: tournamentDocument.tournamentId,
-      gameType: tournamentDocument.gameType,
-      roomType: tournamentDocument.roomType,
-      rulesType: tournamentDocument.rulesType,
-      deckType: tournamentDocument.deckType,
-      tableSize: tournamentDocument.tableSize,
-      bet: tournamentDocument.bet,
-      ticketPrice: tournamentDocument.ticketPrice,
-      title: tournamentDocument.title,
-      subtitle: tournamentDocument.subtitle,
-      description: tournamentDocument.description,
-      enableForFastGame: false,
-      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,
-      tournamentInitialStatus: tournamentDocument.status,
-      tournamentWinners: tournamentDocument.winners,
-      maxParticipants: tournamentDocument.maxParticipants,
-      participants: tournamentDocument.participants,
-    };
-  }
-
-  private handleRoomEvent = (event: BaseGameEvent) => {
-    this.logger.log(event.toLog());
-
-    if (event instanceof GameTableFinishedEvent) {
-      void this.handleRoomTableGameFinished(event.master);
-    } else if (event instanceof GameTournamentStartedEvent) {
-      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentCancelledEvent) {
-      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentFinishedEvent) {
-      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
-    } else if (
-      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
-      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
-      event instanceof GameTournamentCancelledEvent ||
-      event instanceof GameTournamentWaitedEvent ||
-      event instanceof GameTournamentStartedEvent ||
-      event instanceof GameTournamentFinishedEvent
-    ) {
-      void this.handleRoomStatusUpdated(
-        new RoomUpdateStateEvent(event.gameType, event.roomId),
-      );
-    }
-  };
-
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResult(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-      false,
-    );
-  };
-
-  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
-    const session = await this.connection.startSession();
-    session.startTransaction();
-
-    try {
-      await this.tournamentRepository.startTournament(
-        master.getTournamentId(),
-        master.getRoom().getParticipants(),
-      );
-      const newTournament =
-        await this.tournamentRepository.createTournamentFromMasterTemplate(
-          master.getRoom().getGameType(),
-        );
-      this.addRoom(
-        this.options.createTournamentRoom(
-          this.oneTableTournamentDocumentToTournamentRoom(newTournament),
-        ),
-      );
-
-      await session.commitTransaction();
-    } catch (error) {
-      await session.abortTransaction();
-      throw error;
-    } finally {
-      await session.endSession();
-    }
-  };
-
-  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
-    await this.tournamentRepository.cancelTournament(master.getTournamentId());
-  };
-
-  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-    await saveTournamentResult(
-      master,
-      this.connection,
-      this.tournamentRepository,
-      this.usersRepository,
-    );
-  };
-
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
-  };
-}
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  BaseGameEvent,
+  GameMaster,
+  GameTableFinishedEvent,
+  GameTournamentCancelledEvent,
+  GameTournamentFinishedEvent,
+  GameTournamentPlayerJoinedTheTournamentEvent,
+  GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentStartedEvent,
+  GameTournamentWaitedEvent,
+  LocalService,
+  NoStartStrategy,
+  OneTableTournamentRoom,
+  RoomUpdateStateEvent,
+  TournamentMaster,
+  TournamentRoomConfig,
+} from 'jp.ms.common.engine';
+import {
+  GameResultRepository,
+  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 { 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 OneTableTournamentRoomsManagerService {
+  private readonly rooms: Map<string, OneTableTournamentRoom>;
+
+  constructor(
+    private readonly tournamentRepository: OneTableTournamentRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    @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.gameType;
+  }
+
+  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  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>);
+  }
+
+  addRoom(room: OneTableTournamentRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async createMasterTournament() {
+    const waitingTournament =
+      await this.tournamentRepository.findWaitingTournament(this.gameType);
+    if (!waitingTournament) {
+      await this.tournamentRepository.createTournamentFromMasterTemplate(
+        this.gameType,
+      );
+    }
+  }
+
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
+    templates.forEach((item) => {
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(item),
+        ),
+      );
+    });
+  }
+
+  private oneTableTournamentDocumentToTournamentRoom(
+    tournamentDocument: OneTableTournamentRoomDocument,
+  ): TournamentRoomConfig {
+    return {
+      id: tournamentDocument.tournamentId,
+      gameType: tournamentDocument.gameType,
+      roomType: tournamentDocument.roomType,
+      rulesType: tournamentDocument.rulesType,
+      deckType: tournamentDocument.deckType,
+      tableSize: tournamentDocument.tableSize,
+      bet: tournamentDocument.bet,
+      ticketPrice: tournamentDocument.ticketPrice,
+      title: tournamentDocument.title,
+      subtitle: tournamentDocument.subtitle,
+      description: tournamentDocument.description,
+      enableForFastGame: false,
+      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,
+      tournamentInitialStatus: tournamentDocument.status,
+      tournamentWinners: tournamentDocument.winners,
+      maxParticipants: tournamentDocument.maxParticipants,
+      participants: tournamentDocument.participants,
+    };
+  }
+
+  private handleRoomEvent = (event: BaseGameEvent) => {
+    this.logger.log(event.toLog());
+
+    if (event instanceof GameTableFinishedEvent) {
+      void this.handleRoomTableGameFinished(event.master);
+    } else if (event instanceof GameTournamentStartedEvent) {
+      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentCancelledEvent) {
+      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentFinishedEvent) {
+      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
+    } else if (
+      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
+      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
+      event instanceof GameTournamentCancelledEvent ||
+      event instanceof GameTournamentWaitedEvent ||
+      event instanceof GameTournamentStartedEvent ||
+      event instanceof GameTournamentFinishedEvent
+    ) {
+      void this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
+    }
+  };
+
+  private handleRoomTableGameFinished = async (master: GameMaster) => {
+    await saveGameTablesResult(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      false,
+    );
+  };
+
+  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+    const session = await this.connection.startSession();
+    session.startTransaction();
+
+    try {
+      await this.tournamentRepository.startTournament(
+        master.getTournamentId(),
+        master.getRoom().getParticipants(),
+      );
+      const newTournament =
+        await this.tournamentRepository.createTournamentFromMasterTemplate(
+          master.getRoom().getGameType(),
+        );
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.oneTableTournamentDocumentToTournamentRoom(newTournament),
+        ),
+      );
+
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  };
+
+  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+    await this.tournamentRepository.cancelTournament(master.getTournamentId());
+  };
+
+  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
+    await saveTournamentResult(
+      master,
+      this.connection,
+      this.tournamentRepository,
+      this.usersRepository,
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
+  };
+}

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

@@ -1,2 +1,2 @@
-export { PlayersManagerModule } from './players-manager.module';
-export { PlayersManagerService } from './players-manager.service';
+export { PlayersManagerModule } from './players-manager.module';
+export { PlayersManagerService } from './players-manager.service';

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

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

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

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

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

@@ -1 +1 @@
-export { SimpleRoomsModule } from './simple-rooms.module';
+export { SimpleRoomsModule } from './simple-rooms.module';

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

@@ -1 +1 @@
-export const SIMPLE_ROOMS_OPTIONS = Symbol('SIMPLE_ROOMS_OPTIONS');
+export const SIMPLE_ROOMS_OPTIONS = Symbol('SIMPLE_ROOMS_OPTIONS');

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

@@ -1,63 +1,63 @@
-import {
-  Body,
-  Controller,
-  Param,
-  Post,
-  Headers,
-  HttpStatus,
-  HttpCode,
-} from '@nestjs/common';
-import { IAppHeaders, IBaseMoveData, IAppTableState } from 'jp.common.models';
-
-import { SimpleRoomsService } from './simple-rooms.service';
-
-@Controller('simple-rooms')
-export class SimpleRoomsController {
-  constructor(private readonly roomsService: SimpleRoomsService) {}
-  @Post('table/watch/:tableId')
-  @HttpCode(HttpStatus.OK)
-  watchTheTable(
-    @Param('tableId') tableId: string,
-    @Headers() headers: IAppHeaders,
-  ): IAppTableState {
-    return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
-  }
-
-  @Post('table/enter/:tableId')
-  @HttpCode(HttpStatus.OK)
-  enterTheTable(
-    @Param('tableId') tableId: string,
-    @Headers() headers: IAppHeaders,
-  ): IAppTableState {
-    return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
-  }
-
-  @Post('table/exit/:tableId')
-  @HttpCode(HttpStatus.OK)
-  exitTheTable(
-    @Param('tableId') tableId: string,
-    @Headers() headers: IAppHeaders,
-  ): IAppTableState {
-    return this.roomsService.exitTheTable(tableId, headers.client_auth_token);
-  }
-
-  @Post('table/move/:tableId')
-  @HttpCode(HttpStatus.OK)
-  moveOnTheTable(
-    @Param('tableId') tableId: string,
-    @Body() baseMoveData: IBaseMoveData,
-    @Headers() headers: IAppHeaders,
-  ): IAppTableState {
-    return this.roomsService.moveOnTheTable(
-      tableId,
-      headers.client_auth_token,
-      baseMoveData,
-    );
-  }
-
-  @Post('table/restart/:tableId')
-  @HttpCode(HttpStatus.OK)
-  restartTable(@Param('tableId') tableId: string): boolean {
-    return this.roomsService.restartTable(tableId);
-  }
-}
+import {
+  Body,
+  Controller,
+  Param,
+  Post,
+  Headers,
+  HttpStatus,
+  HttpCode,
+} from '@nestjs/common';
+import { IAppHeaders, IBaseMoveData, IAppTableState } from 'jp.common.models';
+
+import { SimpleRoomsService } from './simple-rooms.service';
+
+@Controller('simple-rooms')
+export class SimpleRoomsController {
+  constructor(private readonly roomsService: SimpleRoomsService) {}
+  @Post('table/watch/:tableId')
+  @HttpCode(HttpStatus.OK)
+  watchTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
+  }
+
+  @Post('table/enter/:tableId')
+  @HttpCode(HttpStatus.OK)
+  enterTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
+  }
+
+  @Post('table/exit/:tableId')
+  @HttpCode(HttpStatus.OK)
+  exitTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.exitTheTable(tableId, headers.client_auth_token);
+  }
+
+  @Post('table/move/:tableId')
+  @HttpCode(HttpStatus.OK)
+  moveOnTheTable(
+    @Param('tableId') tableId: string,
+    @Body() baseMoveData: IBaseMoveData,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.moveOnTheTable(
+      tableId,
+      headers.client_auth_token,
+      baseMoveData,
+    );
+  }
+
+  @Post('table/restart/:tableId')
+  @HttpCode(HttpStatus.OK)
+  restartTable(@Param('tableId') tableId: string): boolean {
+    return this.roomsService.restartTable(tableId);
+  }
+}