jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -1,7 +1,15 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { TournamentOneTableRoom, TournamentOneTableRoomSchema, TournamentOneTableRoomsRepository } from 'jp.db.schemas';
-import { GamePlayer, OneTableTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import {
+  TournamentOneTableRoom,
+  TournamentOneTableRoomSchema,
+  TournamentOneTableRoomsRepository,
+} from 'jp.db.schemas';
+import {
+  GamePlayer,
+  OneTableTournamentUpdateStatusWsEvent,
+  RoomUpdateStateEvent,
+} from 'jp.ms.common.engine';
 
 import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
 import { EventsBusOneTableTournamentSubscribeService } from '../event-bus';
@@ -12,42 +20,57 @@ import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
 import { OneTableTournamentModuleOptions } from './one-table-tournament.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: TournamentOneTableRoom.name, schema: TournamentOneTableRoomSchema }]),
-    ],
-    controllers: [OneTableTournamentController],
-    providers: [OneTableTournamentService, TournamentOneTableRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: TournamentOneTableRoom.name,
+        schema: TournamentOneTableRoomSchema,
+      },
+    ]),
+  ],
+  controllers: [OneTableTournamentController],
+  providers: [OneTableTournamentService, TournamentOneTableRoomsRepository],
 })
 export class OneTableTournamentModule {
-    constructor(
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
-        private readonly oneTableTournamentService: OneTableTournamentService,
-    ) { }
+  constructor(
+    private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+    private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    private readonly oneTableTournamentService: OneTableTournamentService,
+  ) {}
 
-    static forRootAsync(options: OneTableTournamentModuleOptions): DynamicModule {
-        return {
-            module: OneTableTournamentModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: ONE_TABLE_TOURNAMENT_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: OneTableTournamentModuleOptions): DynamicModule {
+    return {
+      module: OneTableTournamentModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: ONE_TABLE_TOURNAMENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit() {
-        this.eventsBusOneTableTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
-    }
+  onModuleInit() {
+    this.eventsBusOneTableTournamentSubscribeService.subscribe(
+      this.onHandleStatusRoomChange,
+    );
+  }
 
-    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
-        this.oneTableRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
-            const screen = this.oneTableTournamentService.getStatusScreen(event.roomId, subscriber.language, subscriber.id);
-            subscriber.sendMessage(new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen));
-        });
-    }
+  private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+    this.oneTableRoomsManagerService
+      .getRoomById(event.roomId)
+      ?.getStatusScreenWatchers()
+      .forEach((subscriber: GamePlayer) => {
+        const screen = this.oneTableTournamentService.getStatusScreen(
+          event.roomId,
+          subscriber.language,
+          subscriber.id,
+        );
+        subscriber.sendMessage(
+          new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen),
+        );
+      });
+  };
 }
-

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

@@ -1,9 +1,13 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IAppHeaders,
-    IBaseAppScreen,
-    IBaseMoveData,
-    IAppTableState,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  IAppHeaders,
+  IBaseAppScreen,
+  IBaseMoveData,
+  IAppTableState,
 } from 'jp.common.models';
 
 import { BaseAppScreenDto } from '../../dto';
@@ -16,107 +20,127 @@ import { OneTableTournamentStatusScreenView } from './one-table-tournament-statu
 
 @Injectable()
 export class OneTableTournamentService {
-    constructor(
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(ONE_TABLE_TOURNAMENT_OPTIONS) private readonly options: OneTableTournamentFactoryOptions,
-    ) {
+  constructor(
+    private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(ONE_TABLE_TOURNAMENT_OPTIONS)
+    private readonly options: OneTableTournamentFactoryOptions,
+  ) {}
+
+  getStatusScreen(
+    tournamentId: string,
+    lang: string,
+    playerId: string,
+  ): BaseAppScreenDto {
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+    if (!tournament) {
+      throw new InternalServerErrorException();
     }
 
-    getStatusScreen (tournamentId: string, lang: string, playerId: string): BaseAppScreenDto {
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
-
-        if (!tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        return new BaseAppScreenDto(
-            new OneTableTournamentStatusScreenView(
-                this.options.i18n,
-                lang,
-                tournament,
-                playerId,
-            ).buildBS()
-        );
+    return new BaseAppScreenDto(
+      new OneTableTournamentStatusScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+        playerId,
+      ).buildBS(),
+    );
+  }
+
+  subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+    if (player && tournament) {
+      tournament.addToStatusScreenWatchers(player);
+
+      return;
     }
 
-    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.addToStatusScreenWatchers(player);
+  unsubscribeFromStatusScreen(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
-            return;
-        }
+    if (player && tournament) {
+      tournament.removeFromStatusScreenWatchers(player);
 
-        throw new InternalServerErrorException();
+      return;
     }
 
-    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.removeFromStatusScreenWatchers(player);
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return;
-        }
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
+  moveOnTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    moveDto: IBaseMoveData,
+  ): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.oneTableRoomsManagerService.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);
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  joinTournament(tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
+    const player = this.playersManager.getPlayerById(headers.client_auth_token);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && tournament) {
+      tournament.handleJoinTournament(player);
 
-        throw new InternalServerErrorException();
+      return this.getStatusScreen(
+        tournamentId,
+        headers.client_language,
+        headers.client_auth_token,
+      );
     }
 
-    joinTournament (tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
-        const player = this.playersManager.getPlayerById(headers.client_auth_token);
-        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && tournament) {
-            tournament.handleJoinTournament(player);
+  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
 
-            return this.getStatusScreen(tournamentId, headers.client_language, headers.client_auth_token);
-        }
+    if (player && tournament) {
+      tournament.handleLeaveTournament(player);
 
-        throw new InternalServerErrorException();
+      return;
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
-
-        if (player && tournament) {
-            tournament.handleLeaveTournament(player);
-
-            return;
-        }
-
-        throw new InternalServerErrorException();
-    }
+    throw new InternalServerErrorException();
+  }
 }

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

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

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

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

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

@@ -1,54 +1,63 @@
-import { Body, Controller, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+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);
-    }
+  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/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/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/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);
-    }
+  @Post('table/restart/:tableId')
+  @HttpCode(HttpStatus.OK)
+  restartTable(@Param('tableId') tableId: string): boolean {
+    return this.roomsService.restartTable(tableId);
+  }
 }

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

@@ -4,12 +4,15 @@ 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';
 
-export interface SimpleRoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface SimpleRoomsModuleOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface SimpleRoomsFactoryOptions {
-    i18n: I18nService
+  i18n: I18nService;
 }

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

@@ -1,6 +1,10 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { SimpleRoom, SimpleRoomSchema, SimpleRoomsRepository } from 'jp.db.schemas';
+import {
+  SimpleRoom,
+  SimpleRoomSchema,
+  SimpleRoomsRepository,
+} from 'jp.db.schemas';
 
 import { SimpleRoomsController } from './simple-rooms.controller';
 import { SimpleRoomsService } from './simple-rooms.service';
@@ -8,29 +12,28 @@ import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
 import { SimpleRoomsModuleOptions } from './simple-rooms.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: SimpleRoom.name, schema: SimpleRoomSchema }]),
-    ],
-    controllers: [SimpleRoomsController],
-    providers: [SimpleRoomsService, SimpleRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      { name: SimpleRoom.name, schema: SimpleRoomSchema },
+    ]),
+  ],
+  controllers: [SimpleRoomsController],
+  providers: [SimpleRoomsService, SimpleRoomsRepository],
 })
 export class SimpleRoomsModule {
-    constructor () {
+  constructor() {}
 
-    }
-
-    static forRootAsync (options: SimpleRoomsModuleOptions): DynamicModule {
-        return {
-            module: SimpleRoomsModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: SIMPLE_ROOMS_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: SimpleRoomsModuleOptions): DynamicModule {
+    return {
+      module: SimpleRoomsModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: SIMPLE_ROOMS_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 }
-