jp.ms.common.modules 1.0.43 → 1.0.44

package/src/modules/main/main.service.ts

@@ -106,18 +106,20 @@ export class MainService {
     if (
       player &&
       (player.isPlayer() || player.isTableQueuer()) &&
-      player.tableId
+      player.tableId &&
+      player.room
     ) {
-      if (player.room instanceof SimpleRoom) {
-        redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
-      } else if (player.room instanceof OneTableTournamentRoom) {
+      const roomName = player.room.constructor.name;
+      if (roomName.includes(OneTableTournamentRoom.name)) {
         redirectUrl = AppScreenRouter.getOneTableTournamentTablePath(
           player.tableId,
         );
-      } else if (player.room instanceof ManyTablesTournamentRoom) {
+      } else if (roomName.includes(ManyTablesTournamentRoom.name)) {
         redirectUrl = AppScreenRouter.getManyTablesTournamentTablePath(
           player.tableId,
         );
+      } else if (roomName.includes(SimpleRoom.name)) {
+        redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
       }
     } else if (isNewbie) {
       redirectUrl = AppScreenRoutesEnum.WELCOME;

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

@@ -149,7 +149,7 @@ export class ManyTablesTournamentController {
     return this.tournamentService.removeTournament(tournamentId);
   }
 
-  @Post('many_tables_tournament/buy_ticket/:tournamentId')
+  @Post('buy_ticket/:tournamentId')
   @HttpCode(HttpStatus.OK)
   buyTicket(
     @Param('tournamentId') tournamentId: string,

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

@@ -34,4 +34,5 @@ export interface ManyTablesTournamentRoomsFactoryOptions {
   dailyTournamentScheduleTaskTime: string;
   dailyTournamentTime: string;
   minPlayersForMergeTables: number;
+  levelUpBonus: number;
 }

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

@@ -22,6 +22,9 @@ import {
   Rating,
   RatingSchema,
   RatingRepository,
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
 } from 'jp.db.schemas';
 
 import { ManyTablesTournamentRoomsManagerService } from './many-tables-tournament-rooms-manager.service';
@@ -46,6 +49,9 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
       { name: GameResult.name, schema: GameResultSchema },
     ]),
     MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     ManyTablesTournamentRoomsRepository,
@@ -54,6 +60,7 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
     GameResultRepository,
     PurchaseRepository,
     RatingRepository,
+    ActivityLogRepository,
   ],
   exports: [ManyTablesTournamentRoomsManagerService],
 })

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

@@ -11,6 +11,7 @@ import {
   BaseGameEvent,
   GameMaster,
   GamePlayer,
+  GamePlayerMovedOnTheTableEvent,
   GameTableFinishedEvent,
   GameTournamentCancelledEvent,
   GameTournamentFinishedEvent,
@@ -32,26 +33,25 @@ import {
   ManyTablesTournamentRoomsRepository,
   UsersRepository,
   RatingRepository,
+  ActivityLogRepository,
 } from 'jp.db.schemas';
+import { getHours, getMinutes } from 'jp.common.utils';
 
-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 {
+  EventsBusAppSubscribeService,
   EventsBusMainTablesSubscribeService,
   EventsBusManyTablesTournamentSubscribeService,
 } from '../event-bus';
+import { TournamentRoomsManagerService } from '../../common/tournament-rooms-manager.service';
 
 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 {
+export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, ManyTablesTournamentRoom>;
   private createDailyTournamentJob: Job | null;
 
@@ -61,13 +61,16 @@ export class ManyTablesTournamentRoomsManagerService {
     private readonly gameResultRepository: GameResultRepository,
     private readonly purchaseRepository: PurchaseRepository,
     private readonly ratingRepository: RatingRepository,
+    private readonly activityLogRepository: ActivityLogRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
     private readonly options: ManyTablesTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
+    super();
     this.rooms = new Map<string, ManyTablesTournamentRoom>();
     this.createDailyTournamentJob = null;
   }
@@ -213,6 +216,7 @@ export class ManyTablesTournamentRoomsManagerService {
       rulesType: tournamentDocument.rulesType,
       deckType: tournamentDocument.deckType,
       tableSize: tournamentDocument.tableSize,
+      tableType: tournamentDocument.tableType,
       bet: tournamentDocument.bet,
       ticketPrice: tournamentDocument.ticketPrice,
       title: tournamentDocument.title,
@@ -238,47 +242,80 @@ export class ManyTablesTournamentRoomsManagerService {
   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),
-      );
+    switch (event.constructor.name) {
+      case GameTableFinishedEvent.name: {
+        void this.handleRoomTableGameFinished(
+          event as GameTableFinishedEvent,
+          this.connection,
+          this.gameResultRepository,
+          this.usersRepository,
+          this.activityLogRepository,
+          this.eventsBusAppSubscribeService,
+          this.options.levelUpBonus,
+        );
+        break;
+      }
+      case GamePlayerMovedOnTheTableEvent.name: {
+        this.handleRoomTableGamePlayerMoved(
+          event as GamePlayerMovedOnTheTableEvent,
+          this.eventsBusAppSubscribeService,
+        );
+        break;
+      }
+      case GameTournamentStartedEvent.name: {
+        void this.handleTournamentRoomStarted(
+          event as GameTournamentStartedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentStartedEvent);
+        break;
+      }
+      case GameTournamentCancelledEvent.name: {
+        void this.handleTournamentRoomCancelled(
+          event as GameTournamentCancelledEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentCancelledEvent);
+        break;
+      }
+      case GameTournamentFinishedEvent.name: {
+        void this.handleTournamentRoomFinished(
+          event as GameTournamentFinishedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
+        break;
+      }
+      case GameTournamentPlayerJoinedTheTournamentEvent.name:
+      case GameTournamentPlayerLeavedTheTournamentEvent.name:
+      case GameTournamentWaitedEvent.name: {
+        this.handleRoomStatusUpdated(
+          event as
+          | GameTournamentPlayerJoinedTheTournamentEvent
+          | GameTournamentPlayerLeavedTheTournamentEvent
+          | GameTournamentCancelledEvent,
+        );
+        break;
+      }
     }
   };
 
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResultForTournamentRoom(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-    );
-  };
-
-  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+  private handleTournamentRoomStarted = async (
+    event: GameTournamentStartedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.startTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+  private handleTournamentRoomCancelled = async (
+    event: GameTournamentStartedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-    await saveTournamentResult(
+  private handleTournamentRoomFinished = async (
+    event: GameTournamentFinishedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
+    await this.saveTournamentResult(
       master,
       this.connection,
       this.tournamentRepository,
@@ -287,9 +324,20 @@ export class ManyTablesTournamentRoomsManagerService {
     );
   };
 
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  private handleRoomStatusUpdated = (
+    event:
+      | GameTournamentPlayerJoinedTheTournamentEvent
+      | GameTournamentPlayerLeavedTheTournamentEvent
+      | GameTournamentCancelledEvent
+      | GameTournamentWaitedEvent
+      | GameTournamentStartedEvent
+      | GameTournamentFinishedEvent,
+  ) => {
+    const updateEvent = new RoomUpdateStateEvent(event.gameType, event.roomId);
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(updateEvent);
+    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(
+      updateEvent,
+    );
   };
 
   private createDailyTournament = async (dailyTournamentTime: string) => {

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

@@ -28,4 +28,5 @@ export interface OneTableTournamentRoomsFactoryOptions {
   playersTurnTimeout: number;
   instantFinishMode: boolean;
   tournamentPrizeTable: IPrizeTableData;
+  levelUpBonus: number;
 }

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

@@ -13,6 +13,9 @@ import {
   Rating,
   RatingSchema,
   RatingRepository,
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
 } from 'jp.db.schemas';
 
 import { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';
@@ -33,6 +36,9 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
       { name: GameResult.name, schema: GameResultSchema },
     ]),
     MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     OneTableTournamentRoomsRepository,
@@ -40,6 +46,7 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     OneTableTournamentRoomsManagerService,
     GameResultRepository,
     RatingRepository,
+    ActivityLogRepository,
   ],
   exports: [OneTableTournamentRoomsManagerService],
 })

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

@@ -2,6 +2,7 @@ import { Inject, Injectable } from '@nestjs/common';
 import {
   BaseGameEvent,
   GameMaster,
+  GamePlayerMovedOnTheTableEvent,
   GameTableFinishedEvent,
   GameTournamentCancelledEvent,
   GameTournamentFinishedEvent,
@@ -17,6 +18,7 @@ import {
   TournamentRoomConfig,
 } from 'jp.ms.common.engine';
 import {
+  ActivityLogRepository,
   GameResultRepository,
   OneTableTournamentRoomDocument,
   OneTableTournamentRoomsRepository,
@@ -28,19 +30,17 @@ import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
 import {
-  saveGameTablesResultForTournamentRoom,
-  saveTournamentResult,
-} from '../../utils/game-table-result';
-import {
+  EventsBusAppSubscribeService,
   EventsBusMainTablesSubscribeService,
   EventsBusOneTableTournamentSubscribeService,
 } from '../event-bus';
+import { TournamentRoomsManagerService } from '../../common/tournament-rooms-manager.service';
 
 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 {
+export class OneTableTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, OneTableTournamentRoom>;
 
   constructor(
@@ -48,13 +48,16 @@ export class OneTableTournamentRoomsManagerService {
     private readonly usersRepository: UsersRepository,
     private readonly gameResultRepository: GameResultRepository,
     private readonly ratingRepository: RatingRepository,
+    private readonly activityLogRepository: ActivityLogRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     @Inject(ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
     private readonly options: OneTableTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
+    super();
     this.rooms = new Map<string, OneTableTournamentRoom>();
   }
 
@@ -119,6 +122,7 @@ export class OneTableTournamentRoomsManagerService {
       rulesType: tournamentDocument.rulesType,
       deckType: tournamentDocument.deckType,
       tableSize: tournamentDocument.tableSize,
+      tableType: tournamentDocument.tableType,
       bet: tournamentDocument.bet,
       ticketPrice: tournamentDocument.ticketPrice,
       title: tournamentDocument.title,
@@ -142,40 +146,67 @@ export class OneTableTournamentRoomsManagerService {
   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),
-      );
+    switch (event.constructor.name) {
+      case GameTableFinishedEvent.name: {
+        void this.handleRoomTableGameFinished(
+          event as GameTableFinishedEvent,
+          this.connection,
+          this.gameResultRepository,
+          this.usersRepository,
+          this.activityLogRepository,
+          this.eventsBusAppSubscribeService,
+          this.options.levelUpBonus,
+        );
+        break;
+      }
+      case GamePlayerMovedOnTheTableEvent.name: {
+        this.handleRoomTableGamePlayerMoved(
+          event as GamePlayerMovedOnTheTableEvent,
+          this.eventsBusAppSubscribeService,
+        );
+        break;
+      }
+      case GameTournamentStartedEvent.name: {
+        void this.handleTournamentRoomStarted(
+          event as GameTournamentStartedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentStartedEvent);
+        break;
+      }
+      case GameTournamentCancelledEvent.name: {
+        void this.handleTournamentRoomCancelled(
+          event as GameTournamentCancelledEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentCancelledEvent);
+        break;
+      }
+      case GameTournamentFinishedEvent.name: {
+        void this.handleTournamentRoomFinished(
+          event as GameTournamentFinishedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
+        break;
+      }
+      case GameTournamentPlayerJoinedTheTournamentEvent.name:
+      case GameTournamentPlayerLeavedTheTournamentEvent.name:
+      case GameTournamentWaitedEvent.name: {
+        this.handleRoomStatusUpdated(
+          event as
+            | GameTournamentPlayerJoinedTheTournamentEvent
+            | GameTournamentPlayerLeavedTheTournamentEvent
+            | GameTournamentCancelledEvent,
+        );
+        break;
+      }
     }
   };
 
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResultForTournamentRoom(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-    );
-  };
-
-  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+  private handleTournamentRoomStarted = async (
+    event: GameTournamentStartedEvent,
+  ) => {
     const session = await this.connection.startSession();
     session.startTransaction();
+    const master = event.room.getRoomMaster<TournamentMaster>();
 
     try {
       await this.tournamentRepository.startTournament(
@@ -201,12 +232,19 @@ export class OneTableTournamentRoomsManagerService {
     }
   };
 
-  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+  private handleTournamentRoomCancelled = async (
+    event: GameTournamentCancelledEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-    await saveTournamentResult(
+  private handleTournamentRoomFinished = async (
+    event: GameTournamentFinishedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
+
+    await this.saveTournamentResult(
       master,
       this.connection,
       this.tournamentRepository,
@@ -215,8 +253,19 @@ export class OneTableTournamentRoomsManagerService {
     );
   };
 
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
+  private handleRoomStatusUpdated = (
+    event:
+      | GameTournamentPlayerJoinedTheTournamentEvent
+      | GameTournamentPlayerLeavedTheTournamentEvent
+      | GameTournamentCancelledEvent
+      | GameTournamentWaitedEvent
+      | GameTournamentStartedEvent
+      | GameTournamentFinishedEvent,
+  ) => {
+    const updateEvent = new RoomUpdateStateEvent(event.gameType, event.roomId);
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(updateEvent);
+    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(
+      updateEvent,
+    );
   };
 }

package/src/modules/simple-rooms-manager/simple-rooms-manager.interfaces.ts

@@ -23,4 +23,5 @@ export interface SimpleRoomsFactoryOptions {
   restartGameTimeout: number;
   playersTurnTimeout: number;
   instantFinishMode: boolean;
+  levelUpBonus: number;
 }

package/src/modules/simple-rooms-manager/simple-rooms-manager.module.ts

@@ -13,6 +13,9 @@ import {
   Rating,
   RatingSchema,
   RatingRepository,
+  ActivityLog,
+  ActivityLogSchema,
+  ActivityLogRepository,
 } from 'jp.db.schemas';
 
 import { SimpleRoomsManagerService } from './simple-rooms-manager.service';
@@ -30,12 +33,16 @@ import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
       { name: GameResult.name, schema: GameResultSchema },
     ]),
     MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     SimpleRoomsRepository,
     UsersRepository,
     GameResultRepository,
     RatingRepository,
+    ActivityLogRepository,
     SimpleRoomsManagerService,
   ],
   exports: [SimpleRoomsManagerService],