jp.ms.common.modules 1.0.41 → 1.0.43

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

@@ -1,331 +1,333 @@
-import { InjectConnection } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-import dayjs from 'dayjs';
-import schedule, { Job } from 'node-schedule';
-import {
-  Inject,
-  Injectable,
-  InternalServerErrorException,
-} from '@nestjs/common';
-import {
-  BaseGameEvent,
-  GameMaster,
-  GamePlayer,
-  GameTableFinishedEvent,
-  GameTournamentCancelledEvent,
-  GameTournamentFinishedEvent,
-  GameTournamentPlayerJoinedTheTournamentEvent,
-  GameTournamentPlayerLeavedTheTournamentEvent,
-  GameTournamentStartedEvent,
-  GameTournamentWaitedEvent,
-  LocalService,
-  ManyTablesTournamentRoom,
-  ManyTablesTournamentRoomConfig,
-  NoStartStrategy,
-  RoomUpdateStateEvent,
-  TournamentMaster,
-} from 'jp.ms.common.engine';
-import {
-  GameResultRepository,
-  PurchaseRepository,
-  ManyTablesTournamentRoomDocument,
-  ManyTablesTournamentRoomsRepository,
-  UsersRepository,
-} from 'jp.db.schemas';
-
-import {
-  saveGameTablesResult,
-  saveTournamentResult,
-} from '../../utils/game-table-result';
-import { JpLoggerService } from '../logger';
-import { getHours, getMinutes } from '../../utils/date';
-import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
-import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
-import {
-  EventsBusMainTablesSubscribeService,
-  EventsBusManyTablesTournamentSubscribeService,
-} from '../event-bus';
-
-import { MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './many-tables-tournament-rooms-manager.constants';
-import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournament-rooms-manager.interfaces';
-
-@Injectable()
-export class ManyTablesTournamentRoomsManagerService {
-  private readonly rooms: Map<string, ManyTablesTournamentRoom>;
-  private createDailyTournamentJob: Job | null;
-
-  constructor(
-    private readonly tournamentRepository: ManyTablesTournamentRoomsRepository,
-    private readonly usersRepository: UsersRepository,
-    private readonly gameResultRepository: GameResultRepository,
-    private readonly purchaseRepository: PurchaseRepository,
-    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
-    @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
-    private readonly options: ManyTablesTournamentRoomsFactoryOptions,
-    @InjectConnection() private readonly connection: Connection,
-    @Inject() private readonly logger: JpLoggerService,
-  ) {
-    this.rooms = new Map<string, ManyTablesTournamentRoom>();
-    this.createDailyTournamentJob = null;
-  }
-
-  get gameType() {
-    return this.options.gameType;
-  }
-
-  getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
-    return this.rooms.get(roomId);
-  }
-
-  getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
-    const { roomId } = GameMaster.parseTableId(tableId);
-
-    return this.getRoomById(roomId);
-  }
-
-  getRooms(): Array<ManyTablesTournamentRoom> {
-    return Array.from(this.rooms.values());
-  }
-
-  getTables(): Array<GameMaster> {
-    return this.getRooms().reduce((result, currentValue) => {
-      return [...result, ...currentValue.getMasters()];
-    }, [] as Array<GameMaster>);
-  }
-
-  addRoom(room: ManyTablesTournamentRoom) {
-    this.rooms.set(room.getId(), room);
-  }
-
-  async hydrateTournamentsFromDB() {
-    const templates = await this.tournamentRepository.findActualTournaments(
-      this.gameType,
-    );
-    templates.forEach((item) => {
-      this.addRoom(
-        this.options.createTournamentRoom(
-          this.manyTablesTournamentDocumentToTournamentRoom(item),
-        ),
-      );
-    });
-  }
-
-  async runDailyTournamentJob() {
-    if (
-      this.options.dailyTournamentScheduleTaskTime &&
-      this.options.dailyTournamentTime
-    ) {
-      await this.createDailyTournament(this.options.dailyTournamentTime);
-
-      this.createDailyTournamentJob = schedule.scheduleJob(
-        this.options.dailyTournamentScheduleTaskTime,
-        () => this.createDailyTournament(this.options.dailyTournamentTime),
-      );
-    }
-  }
-
-  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
-    const newTournament =
-      await this.tournamentRepository.createTournament(createTournamentDto);
-
-    this.addRoom(
-      this.options.createTournamentRoom(
-        this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
-      ),
-    );
-  }
-
-  async updateTournament(
-    tournamentId: string,
-    updateTournamentDto: ManyTablesTournamentUpdateDto,
-  ) {
-    const updatedTournament = await this.tournamentRepository.updateTournament(
-      tournamentId,
-      updateTournamentDto,
-    );
-
-    this.getRoomById(tournamentId)
-      ?.getRoomMaster<TournamentMaster>()
-      .cancelTournament();
-
-    this.addRoom(
-      this.options.createTournamentRoom(
-        this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament),
-      ),
-    );
-  }
-
-  async removeTournament(tournamentId: string) {
-    await this.tournamentRepository.removeTournament(tournamentId);
-  }
-
-  async buyTicket(tournamentId: string, player: GamePlayer) {
-    const tournament = this.getRoomById(tournamentId);
-    const user = await this.usersRepository.findById(player.id);
-
-    if (!tournament || !user) {
-      throw new InternalServerErrorException();
-    }
-
-    const session = await this.connection.startSession();
-    session.startTransaction();
-
-    try {
-      player.decreaseBalance(tournament.getTicketPrice());
-      tournament.addParticipant(player);
-      void this.purchaseRepository.addManyTablesTournamentTicketPurchase(
-        player.id,
-        player.fullName,
-        tournamentId,
-        tournament.getTicketPrice(),
-        tournament.getGameType(),
-      );
-      void this.usersRepository.subtractFromBalance(
-        player.id,
-        tournament.getTicketPrice(),
-      );
-
-      await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
-        playerId: player.id,
-        playerAvatarUrl: player.avatarUrl,
-        playerName: player.fullName,
-      });
-
-      await session.commitTransaction();
-    } catch (error) {
-      await session.abortTransaction();
-      throw error;
-    } finally {
-      await session.endSession();
-    }
-  }
-
-  private manyTablesTournamentDocumentToTournamentRoom(
-    tournamentDocument: ManyTablesTournamentRoomDocument,
-  ): ManyTablesTournamentRoomConfig {
-    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,
-      scheduleDate: tournamentDocument.scheduleDate,
-      turnTimeout: this.options.playersTurnTimeout,
-      restartTimeout: this.options.restartGameTimeout,
-      instantFinishMode: this.options.instantFinishMode,
-      minPlayersForMergeTables: this.options.minPlayersForMergeTables,
-      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) => {
-    await this.tournamentRepository.startTournament(master.getTournamentId());
-  };
-
-  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.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
-  };
-
-  private createDailyTournament = async (dailyTournamentTime: string) => {
-    const hour = getHours(dailyTournamentTime);
-    const minutes = getMinutes(dailyTournamentTime);
-    const jobEveningDate = dayjs()
-      .set('hour', hour)
-      .set('minute', minutes)
-      .set('second', 0);
-    const addingDay = dayjs().isBefore(jobEveningDate) ? 0 : 1;
-
-    const startDate = dayjs().add(addingDay, 'day').startOf('day');
-    const endDate = dayjs().add(addingDay, 'day').endOf('day');
-
-    const tournamentDate = dayjs()
-      .add(addingDay, 'day')
-      .set('hour', hour)
-      .set('minute', minutes);
-
-    const waitedTournament =
-      await this.tournamentRepository.findWaitingTournamentByDate(
-        this.gameType,
-        startDate.toDate(),
-        endDate.toDate(),
-      );
-
-    if (!waitedTournament) {
-      const newTournament =
-        await this.tournamentRepository.scheduleTournamentFromMasterTemplate(
-          this.gameType,
-          tournamentDate.toDate(),
-        );
-
-      this.addRoom(
-        this.options.createTournamentRoom(
-          this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
-        ),
-      );
-    }
-  };
-}
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import dayjs from 'dayjs';
+import schedule, { Job } from 'node-schedule';
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  BaseGameEvent,
+  GameMaster,
+  GamePlayer,
+  GameTableFinishedEvent,
+  GameTournamentCancelledEvent,
+  GameTournamentFinishedEvent,
+  GameTournamentPlayerJoinedTheTournamentEvent,
+  GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentStartedEvent,
+  GameTournamentWaitedEvent,
+  LocalService,
+  ManyTablesTournamentRoom,
+  ManyTablesTournamentRoomConfig,
+  NoStartStrategy,
+  RoomUpdateStateEvent,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
+import {
+  GameResultRepository,
+  PurchaseRepository,
+  ManyTablesTournamentRoomDocument,
+  ManyTablesTournamentRoomsRepository,
+  UsersRepository,
+  RatingRepository,
+} from 'jp.db.schemas';
+
+import {
+  saveGameTablesResultForTournamentRoom,
+  saveTournamentResult,
+} from '../../utils/game-table-result';
+import { JpLoggerService } from '../logger';
+import { getHours, getMinutes } from '../../utils/date';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+import {
+  EventsBusMainTablesSubscribeService,
+  EventsBusManyTablesTournamentSubscribeService,
+} from '../event-bus';
+
+import { MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './many-tables-tournament-rooms-manager.constants';
+import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournament-rooms-manager.interfaces';
+
+@Injectable()
+export class ManyTablesTournamentRoomsManagerService {
+  private readonly rooms: Map<string, ManyTablesTournamentRoom>;
+  private createDailyTournamentJob: Job | null;
+
+  constructor(
+    private readonly tournamentRepository: ManyTablesTournamentRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly purchaseRepository: PurchaseRepository,
+    private readonly ratingRepository: RatingRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: ManyTablesTournamentRoomsFactoryOptions,
+    @InjectConnection() private readonly connection: Connection,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.rooms = new Map<string, ManyTablesTournamentRoom>();
+    this.createDailyTournamentJob = null;
+  }
+
+  get gameType() {
+    return this.options.gameType;
+  }
+
+  getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  getRooms(): Array<ManyTablesTournamentRoom> {
+    return Array.from(this.rooms.values());
+  }
+
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
+  }
+
+  addRoom(room: ManyTablesTournamentRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
+    templates.forEach((item) => {
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(item),
+        ),
+      );
+    });
+  }
+
+  async runDailyTournamentJob() {
+    if (
+      this.options.dailyTournamentScheduleTaskTime &&
+      this.options.dailyTournamentTime
+    ) {
+      await this.createDailyTournament(this.options.dailyTournamentTime);
+
+      this.createDailyTournamentJob = schedule.scheduleJob(
+        this.options.dailyTournamentScheduleTaskTime,
+        () => this.createDailyTournament(this.options.dailyTournamentTime),
+      );
+    }
+  }
+
+  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    const newTournament =
+      await this.tournamentRepository.createTournament(createTournamentDto);
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+      ),
+    );
+  }
+
+  async updateTournament(
+    tournamentId: string,
+    updateTournamentDto: ManyTablesTournamentUpdateDto,
+  ) {
+    const updatedTournament = await this.tournamentRepository.updateTournament(
+      tournamentId,
+      updateTournamentDto,
+    );
+
+    this.getRoomById(tournamentId)
+      ?.getRoomMaster<TournamentMaster>()
+      .cancelTournament();
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament),
+      ),
+    );
+  }
+
+  async removeTournament(tournamentId: string) {
+    await this.tournamentRepository.removeTournament(tournamentId);
+  }
+
+  async buyTicket(tournamentId: string, player: GamePlayer) {
+    const tournament = this.getRoomById(tournamentId);
+    const user = await this.usersRepository.findById(player.id);
+
+    if (!tournament || !user) {
+      throw new InternalServerErrorException();
+    }
+
+    const session = await this.connection.startSession();
+    session.startTransaction();
+
+    try {
+      player.decreaseBalance(tournament.getTicketPrice());
+      tournament.addParticipant(player);
+      void this.purchaseRepository.addManyTablesTournamentTicketPurchase(
+        player.id,
+        player.fullName,
+        tournamentId,
+        tournament.getTicketPrice(),
+        tournament.getGameType(),
+      );
+      void this.usersRepository.subtractFromBalance(
+        player.id,
+        tournament.getTicketPrice(),
+      );
+
+      await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+        playerId: player.id,
+        playerAvatarUrl: player.avatarUrl,
+        playerName: player.fullName,
+      });
+
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  private manyTablesTournamentDocumentToTournamentRoom(
+    tournamentDocument: ManyTablesTournamentRoomDocument,
+  ): ManyTablesTournamentRoomConfig {
+    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,
+      scheduleDate: tournamentDocument.scheduleDate,
+      turnTimeout: this.options.playersTurnTimeout,
+      restartTimeout: this.options.restartGameTimeout,
+      instantFinishMode: this.options.instantFinishMode,
+      minPlayersForMergeTables: this.options.minPlayersForMergeTables,
+      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 saveGameTablesResultForTournamentRoom(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+    );
+  };
+
+  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+    await this.tournamentRepository.startTournament(master.getTournamentId());
+  };
+
+  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,
+      this.ratingRepository,
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  };
+
+  private createDailyTournament = async (dailyTournamentTime: string) => {
+    const hour = getHours(dailyTournamentTime);
+    const minutes = getMinutes(dailyTournamentTime);
+    const jobEveningDate = dayjs()
+      .set('hour', hour)
+      .set('minute', minutes)
+      .set('second', 0);
+    const addingDay = dayjs().isBefore(jobEveningDate) ? 0 : 1;
+
+    const startDate = dayjs().add(addingDay, 'day').startOf('day');
+    const endDate = dayjs().add(addingDay, 'day').endOf('day');
+
+    const tournamentDate = dayjs()
+      .add(addingDay, 'day')
+      .set('hour', hour)
+      .set('minute', minutes);
+
+    const waitedTournament =
+      await this.tournamentRepository.findWaitingTournamentByDate(
+        this.gameType,
+        startDate.toDate(),
+        endDate.toDate(),
+      );
+
+    if (!waitedTournament) {
+      const newTournament =
+        await this.tournamentRepository.scheduleTournamentFromMasterTemplate(
+          this.gameType,
+          tournamentDate.toDate(),
+        );
+
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+        ),
+      );
+    }
+  };
+}