jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -1,9 +1,17 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema, TournamentManyTablesRoomsRepository } from 'jp.db.schemas';
-import { GamePlayer, ManyTablesTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import {
+  ManyTablesTournamentRoom,
+  ManyTablesTournamentRoomSchema,
+  ManyTablesTournamentRoomsRepository,
+} from 'jp.db.schemas';
+import {
+  GamePlayer,
+  ManyTablesTournamentUpdateStatusWsEvent,
+  RoomUpdateStateEvent,
+} from 'jp.ms.common.engine';
 
-import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
+import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager';
 import { EventsBusManyTablesTournamentSubscribeService } from '../event-bus';
 
 import { ManyTablesTournamentController } from './many-tables-tournament.controller';
@@ -12,42 +20,61 @@ import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constan
 import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
-    ],
-    controllers: [ManyTablesTournamentController],
-    providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: ManyTablesTournamentRoom.name,
+        schema: ManyTablesTournamentRoomSchema,
+      },
+    ]),
+  ],
+  controllers: [ManyTablesTournamentController],
+  providers: [ManyTablesTournamentService, ManyTablesTournamentRoomsRepository],
 })
 export class ManyTablesTournamentModule {
-    constructor(
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
-        private readonly manyTablesTournamentService: ManyTablesTournamentService,
-    ) { }
+  constructor(
+    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    private readonly manyTablesTournamentService: ManyTablesTournamentService,
+  ) {}
 
-    static forRootAsync(options: ManyTablesTournamentModuleOptions): DynamicModule {
-        return {
-            module: ManyTablesTournamentModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: MANY_TABLES_TOURNAMENT_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(
+    options: ManyTablesTournamentModuleOptions,
+  ): DynamicModule {
+    return {
+      module: ManyTablesTournamentModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: MANY_TABLES_TOURNAMENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit() {
-        this.eventsBusManyTablesTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
-    }
+  onModuleInit() {
+    this.eventsBusManyTablesTournamentSubscribeService.subscribe(
+      this.onHandleStatusRoomChange,
+    );
+  }
 
-    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
-        this.manyTablesRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
-            const screen = this.manyTablesTournamentService.getStatusScreen(event.roomId, subscriber.language);
-            subscriber.sendMessage(new ManyTablesTournamentUpdateStatusWsEvent(event.game, screen.screen));
-        });
-    }
+  private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+    this.manyTablesRoomsManagerService
+      .getRoomById(event.roomId)
+      ?.getStatusScreenWatchers()
+      .forEach((subscriber: GamePlayer) => {
+        const screen = this.manyTablesTournamentService.getStatusScreen(
+          event.roomId,
+          subscriber.language,
+        );
+        subscriber.sendMessage(
+          new ManyTablesTournamentUpdateStatusWsEvent(
+            event.game,
+            screen.screen,
+          ),
+        );
+      });
+  };
 }
-

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

@@ -1,13 +1,20 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IBaseMoveData,
-    IAppTableState,
-    AppScreenRouter,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  IBaseMoveData,
+  IAppTableState,
+  AppScreenRouter,
 } from 'jp.common.models';
-import { ManyTablesTournamentMaster, TournamentMaster } from 'jp.ms.common.engine';
+import {
+  ManyTablesTournamentMaster,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
 
 import { BaseAppScreenDto } from '../../dto';
-import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
+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';
@@ -20,154 +27,182 @@ import { ManyTablesTournamentTablesListScreenView } from './many-tables-tourname
 
 @Injectable()
 export class ManyTablesTournamentService {
-    constructor(
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(MANY_TABLES_TOURNAMENT_OPTIONS) private readonly options: ManyTablesTournamentFactoryOptions,
-    ) {
+  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();
     }
 
-    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()
-        );
+    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();
     }
 
-    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+    tournament.addToStatusScreenWatchers(player);
+  }
 
-        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();
     }
 
-    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+    tournament.removeFromStatusScreenWatchers(player);
+  }
 
-        if (!player || !tournament) {
-            throw new InternalServerErrorException();
-        }
+  getTableListScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
-        tournament.removeFromStatusScreenWatchers(player);
+    if (!tournament) {
+      throw new InternalServerErrorException();
     }
 
-    async getTableListScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-        if (!tournament) {
-            throw new InternalServerErrorException();
-        }
+    return new BaseAppScreenDto(
+      new ManyTablesTournamentTablesListScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+      ).buildBS(),
+    );
+  }
 
-        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);
 
-    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);
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
-
-            return master.createGameStateDto(player);
-        }
-
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    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);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  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);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleMoveOnTheTable(player, tableId, moveDto);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    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();
+  }
+
+  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,
+          );
         }
-
-        throw new InternalServerErrorException();
+      } else {
+        return JoinTournamentDto.fromEntities(
+          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          player.id,
+        );
+      }
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (!player || !tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        tournament.handleLeaveTournament(player);
-    }
+  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
 
-    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
-        return this.manyTablesRoomsManagerService.createTournament(createTournamentDto);
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
     }
 
-    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
-        return this.manyTablesRoomsManagerService.updateTournament(tournamentId, updateTournamentDto);
-    }
-
-    async removeTournament (tournamentId: string) {
-        return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
-    }
+    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);
+  }
 }

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,35 @@
+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;
+}

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

@@ -0,0 +1,84 @@
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+  ManyTablesTournamentRoom,
+  ManyTablesTournamentRoomSchema,
+  ManyTablesTournamentRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
+  Purchase,
+  PurchaseSchema,
+  PurchaseRepository,
+} from 'jp.db.schemas';
+
+import { ManyTablesTournamentRoomsManagerService } from './many-tables-tournament-rooms-manager.service';
+import { ManyTablesTournamentRoomsManagerOptions } from './many-tables-tournament-rooms-manager.interfaces';
+import { MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './many-tables-tournament-rooms-manager.constants';
+import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournament-rooms-manager.interfaces';
+
+@Global()
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: ManyTablesTournamentRoom.name,
+        schema: ManyTablesTournamentRoomSchema,
+      },
+    ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
+    MongooseModule.forFeature([
+      { name: GameResult.name, schema: GameResultSchema },
+    ]),
+  ],
+  providers: [
+    ManyTablesTournamentRoomsRepository,
+    UsersRepository,
+    ManyTablesTournamentRoomsManagerService,
+    GameResultRepository,
+    PurchaseRepository,
+  ],
+  exports: [ManyTablesTournamentRoomsManagerService],
+})
+export class ManyTablesTournamentRoomsManagerModule {
+  constructor(
+    private readonly managerService: ManyTablesTournamentRoomsManagerService,
+    @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: ManyTablesTournamentRoomsFactoryOptions,
+  ) {}
+
+  static forRootAsync(
+    options: ManyTablesTournamentRoomsManagerOptions,
+  ): DynamicModule {
+    return {
+      module: ManyTablesTournamentRoomsManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+
+  async onModuleInit() {
+    if (this.options.dailyTournamentScheduleJobEnabled) {
+      await this.managerService.runDailyTournamentJob();
+    }
+    await this.managerService.hydrateTournamentsFromDB();
+  }
+}