jp.ms.common.modules 1.0.41 → 1.0.43

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

@@ -1,208 +1,241 @@
-import {
-  Inject,
-  Injectable,
-  InternalServerErrorException,
-} from '@nestjs/common';
-import {
-  IBaseMoveData,
-  IAppTableState,
-  AppScreenRouter,
-} from 'jp.common.models';
-import {
-  ManyTablesTournamentMaster,
-  TournamentMaster,
-} from 'jp.ms.common.engine';
-
-import { BaseAppScreenDto } from '../../dto';
-import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
-import { PlayersManagerService } from '../players-manager/players-manager.service';
-import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
-import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
-import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
-
-import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
-import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
-import { ManyTablesTournamentStatusScreenView } from './many-tables-tournament-status-screen.view';
-import { ManyTablesTournamentTablesListScreenView } from './many-tables-tournament-tables-list-screen.view';
-
-@Injectable()
-export class ManyTablesTournamentService {
-  constructor(
-    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
-    private readonly playersManager: PlayersManagerService,
-    @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
-    private readonly options: ManyTablesTournamentFactoryOptions,
-  ) {}
-
-  getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-    if (!tournament) {
-      throw new InternalServerErrorException();
-    }
-
-    return new BaseAppScreenDto(
-      new ManyTablesTournamentStatusScreenView(
-        this.options.i18n,
-        lang,
-        tournament,
-      ).buildBS(),
-    );
-  }
-
-  subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): void {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-    if (!player || !tournament) {
-      throw new InternalServerErrorException();
-    }
-
-    tournament.addToStatusScreenWatchers(player);
-  }
-
-  unsubscribeFromStatusScreen(
-    tournamentId: string,
-    clientAuthToken: string,
-  ): void {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-    if (!player || !tournament) {
-      throw new InternalServerErrorException();
-    }
-
-    tournament.removeFromStatusScreenWatchers(player);
-  }
-
-  getTableListScreen(tournamentId: string, lang: string): BaseAppScreenDto {
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-    if (!tournament) {
-      throw new InternalServerErrorException();
-    }
-
-    return new BaseAppScreenDto(
-      new ManyTablesTournamentTablesListScreenView(
-        this.options.i18n,
-        lang,
-        tournament,
-      ).buildBS(),
-    );
-  }
-
-  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
-    const master = room?.getMasterById(tableId);
-
-    if (player && room && master) {
-      room.handleWatchTheTable(player, tableId);
-
-      return master.createGameStateDto(player);
-    }
-
-    throw new InternalServerErrorException();
-  }
-
-  moveOnTheTable(
-    tableId: string,
-    clientAuthToken: string,
-    moveDto: IBaseMoveData,
-  ): IAppTableState {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
-    const master = room?.getMasterById(tableId);
-
-    if (player && room && master) {
-      room.handleMoveOnTheTable(player, tableId, moveDto);
-
-      return master.createGameStateDto(player);
-    }
-
-    throw new InternalServerErrorException();
-  }
-
-  joinTournament(
-    tournamentId: string,
-    clientAuthToken: string,
-  ): JoinTournamentDto {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-
-    if (player && tournament) {
-      tournament.handleJoinTournament(player);
-
-      if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
-        if (player.isPlayer() || player.isTableQueuer()) {
-          return JoinTournamentDto.fromEntities(
-            AppScreenRouter.getManyTablesTournamentTablePath(
-              player.tableId ?? '',
-            ),
-            player.id,
-          );
-        } else if (tournament.isParticipant(player.id)) {
-          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 {
-        return JoinTournamentDto.fromEntities(
-          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
-          player.id,
-        );
-      }
-    }
-
-    throw new InternalServerErrorException();
-  }
-
-  leaveTournament(tournamentId: string, clientAuthToken: string): void {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-
-    if (!player || !tournament) {
-      throw new InternalServerErrorException();
-    }
-
-    tournament.handleLeaveTournament(player);
-  }
-
-  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
-    return this.manyTablesRoomsManagerService.createTournament(
-      createTournamentDto,
-    );
-  }
-
-  async updateTournament(
-    tournamentId: string,
-    updateTournamentDto: ManyTablesTournamentUpdateDto,
-  ) {
-    return this.manyTablesRoomsManagerService.updateTournament(
-      tournamentId,
-      updateTournamentDto,
-    );
-  }
-
-  async removeTournament(tournamentId: string) {
-    return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
-  }
-}
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  IBaseMoveData,
+  IAppTableState,
+  AppScreenRouter,
+  ErrorSnackbarComponent,
+} from 'jp.common.models';
+import {
+  ManyTablesTournamentMaster,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
+import { UsersRepository } from 'jp.db.schemas';
+
+import { BaseAppScreenDto } from '../../dto';
+import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+import {
+  NotEnoughMoneyForPurchaseException,
+  ErrorCodeEnum,
+} from '../../exception';
+
+import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
+import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+import { ManyTablesTournamentStatusScreenView } from './many-tables-tournament-status-screen.view';
+import { ManyTablesTournamentTablesListScreenView } from './many-tables-tournament-tables-list-screen.view';
+
+@Injectable()
+export class ManyTablesTournamentService {
+  constructor(
+    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
+    private readonly options: ManyTablesTournamentFactoryOptions,
+    private readonly usersRepository: UsersRepository,
+  ) {}
+
+  getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    return new BaseAppScreenDto(
+      new ManyTablesTournamentStatusScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+      ).buildBS(),
+    );
+  }
+
+  subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    tournament.addToStatusScreenWatchers(player);
+  }
+
+  unsubscribeFromStatusScreen(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    tournament.removeFromStatusScreenWatchers(player);
+  }
+
+  getTableListScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    return new BaseAppScreenDto(
+      new ManyTablesTournamentTablesListScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+      ).buildBS(),
+    );
+  }
+
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
+
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
+
+      return master.createGameStateDto(player);
+    }
+
+    throw new InternalServerErrorException();
+  }
+
+  moveOnTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    moveDto: IBaseMoveData,
+  ): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
+
+    if (player && room && master) {
+      room.handleMoveOnTheTable(player, tableId, moveDto);
+
+      return master.createGameStateDto(player);
+    }
+
+    throw new InternalServerErrorException();
+  }
+
+  joinTournament(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): JoinTournamentDto {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+
+    if (player && tournament) {
+      tournament.handleJoinTournament(player);
+
+      if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+        if (player.isPlayer() || player.isTableQueuer()) {
+          return JoinTournamentDto.fromEntities(
+            AppScreenRouter.getManyTablesTournamentTablePath(
+              player.tableId ?? '',
+            ),
+            player.id,
+          );
+        } else if (tournament.isParticipant(player.id)) {
+          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 {
+        return JoinTournamentDto.fromEntities(
+          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          player.id,
+        );
+      }
+    }
+
+    throw new InternalServerErrorException();
+  }
+
+  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
+    }
+
+    tournament.handleLeaveTournament(player);
+  }
+
+  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    return this.manyTablesRoomsManagerService.createTournament(
+      createTournamentDto,
+    );
+  }
+
+  async updateTournament(
+    tournamentId: string,
+    updateTournamentDto: ManyTablesTournamentUpdateDto,
+  ) {
+    return this.manyTablesRoomsManagerService.updateTournament(
+      tournamentId,
+      updateTournamentDto,
+    );
+  }
+
+  async removeTournament(tournamentId: string) {
+    return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
+  }
+
+  async manyTablesTournamentbBuyTicket(
+    clientAuthToken: string,
+    lang: string,
+    tournamentId: string,
+  ): Promise<void> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
+
+    if (!player || !tournament || !user) {
+      throw new InternalServerErrorException();
+    }
+
+    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 }),
+        ),
+      );
+    }
+
+    await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+  }
+}

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

@@ -1,2 +1,2 @@
-export { ManyTablesTournamentRoomsManagerModule } from './many-tables-tournament-rooms-manager.module';
-export { ManyTablesTournamentRoomsManagerService } from './many-tables-tournament-rooms-manager.service';
+export { ManyTablesTournamentRoomsManagerModule } from './many-tables-tournament-rooms-manager.module';
+export { ManyTablesTournamentRoomsManagerService } from './many-tables-tournament-rooms-manager.service';

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

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

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

@@ -1,37 +1,37 @@
-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 {
-  ManyTablesTournamentRoomConfig,
-  ManyTablesTournamentRoom,
-  IPrizeTableData,
-} from 'jp.ms.common.engine';
-
-export interface ManyTablesTournamentRoomsManagerOptions extends Pick<
-  ModuleMetadata,
-  'imports'
-> {
-  imports?: Array<
-    Type | DynamicModule | Promise<DynamicModule> | ForwardReference
-  >;
-  inject?: any[];
-  useFactory?: (...args: any[]) => ManyTablesTournamentRoomsFactoryOptions;
-}
-
-export interface ManyTablesTournamentRoomsFactoryOptions {
-  i18n: I18nService | any;
-  createTournamentRoom(
-    room: ManyTablesTournamentRoomConfig,
-  ): ManyTablesTournamentRoom;
-  gameType: string;
-  restartGameTimeout: number;
-  playersTurnTimeout: number;
-  instantFinishMode: boolean;
-  tournamentPrizeTable: IPrizeTableData;
-  dailyTournamentScheduleJobEnabled: boolean;
-  dailyTournamentScheduleTaskTime: string;
-  dailyTournamentTime: string;
-  minPlayersForMergeTables: number;
-}
+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 {
+  ManyTablesTournamentRoomConfig,
+  ManyTablesTournamentRoom,
+  IPrizeTableData,
+} from 'jp.ms.common.engine';
+
+export interface ManyTablesTournamentRoomsManagerOptions extends Pick<
+  ModuleMetadata,
+  'imports'
+> {
+  imports?: Array<
+    Type | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => ManyTablesTournamentRoomsFactoryOptions;
+}
+
+export interface ManyTablesTournamentRoomsFactoryOptions {
+  i18n: I18nService | any;
+  createTournamentRoom(
+    room: ManyTablesTournamentRoomConfig,
+  ): ManyTablesTournamentRoom;
+  gameType: string;
+  restartGameTimeout: number;
+  playersTurnTimeout: number;
+  instantFinishMode: boolean;
+  tournamentPrizeTable: IPrizeTableData;
+  dailyTournamentScheduleJobEnabled: boolean;
+  dailyTournamentScheduleTaskTime: string;
+  dailyTournamentTime: string;
+  minPlayersForMergeTables: number;
+}