jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -1,8 +1,9 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IBaseMoveData,
-    IAppTableState,
-} from 'jp.common.models';
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { IBaseMoveData, IAppTableState } from 'jp.common.models';
 
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 import { PlayersManagerService } from '../players-manager';
@@ -12,79 +13,83 @@ import { SimpleRoomsFactoryOptions } from './simple-rooms.interfaces';
 
 @Injectable()
 export class SimpleRoomsService {
-    constructor (
-        private readonly simpleRoomsManager: SimpleRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(SIMPLE_ROOMS_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
-    ) {
+  constructor(
+    private readonly simpleRoomsManager: SimpleRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(SIMPLE_ROOMS_OPTIONS)
+    private readonly options: SimpleRoomsFactoryOptions,
+  ) {}
+
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
+
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
+
+      return master.createGameStateDto(player);
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
+  enterTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleEnterTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    enterTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleEnterTheTable(player, tableId);
+  exitTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleExitTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    exitTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleExitTheTable(player, tableId);
+  moveOnTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    moveDto: IBaseMoveData,
+  ): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.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.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  restartTable(tableId: string): boolean {
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (room && master) {
+      room.handleRestartTable(tableId);
 
-        throw new InternalServerErrorException();
+      return true;
     }
 
-    restartTable (tableId: string): boolean {
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
-
-        if (room && master) {
-            room.handleRestartTable(tableId);
-
-            return true;
-        }
-
-        throw new InternalServerErrorException();
-    }
+    throw new InternalServerErrorException();
+  }
 }

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

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

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

@@ -6,14 +6,17 @@ import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-refe
 import { GameRoomConfig, SimpleRoom } from 'jp.ms.common.engine';
 import { ConfigService } from '@nestjs/config';
 
-export interface SimpleRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface SimpleRoomsManagerOptions
+  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;
-    configService: ConfigService;
-    createRoom (room: GameRoomConfig): SimpleRoom;
+  i18n: I18nService;
+  configService: ConfigService;
+  createRoom(room: GameRoomConfig): SimpleRoom;
 }

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

@@ -1,15 +1,15 @@
 import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
-    SimpleRoom,
-    SimpleRoomSchema,
-    SimpleRoomsRepository,
-    User,
-    UserSchema,
-    UsersRepository,
-    GameResult,
-    GameResultSchema,
-    GameResultRepository,
+  SimpleRoom,
+  SimpleRoomSchema,
+  SimpleRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
 } from 'jp.db.schemas';
 
 import { SimpleRoomsManagerService } from './simple-rooms-manager.service';
@@ -18,41 +18,43 @@ import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 
 @Global()
 @Module({
-    imports: [
-        MongooseModule.forFeature([{name: SimpleRoom.name, schema: SimpleRoomSchema}]),
-        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
-        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
-    ],
-    providers: [
-        SimpleRoomsRepository,
-        UsersRepository,
-        GameResultRepository,
-        SimpleRoomsManagerService,
-    ],
-    exports: [SimpleRoomsManagerService],
+  imports: [
+    MongooseModule.forFeature([
+      { name: SimpleRoom.name, schema: SimpleRoomSchema },
+    ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: GameResult.name, schema: GameResultSchema },
+    ]),
+  ],
+  providers: [
+    SimpleRoomsRepository,
+    UsersRepository,
+    GameResultRepository,
+    SimpleRoomsManagerService,
+  ],
+  exports: [SimpleRoomsManagerService],
 })
 export class SimpleRoomsManagerModule {
-    constructor (
-        private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
-    ) {
-    }
+  constructor(
+    private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
+  ) {}
 
-    static forRootAsync (options: SimpleRoomsManagerOptions): DynamicModule {
-        return {
-            module: SimpleRoomsManagerModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: SIMPLE_ROOMS_MANAGER_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: SimpleRoomsManagerOptions): DynamicModule {
+    return {
+      module: SimpleRoomsManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: SIMPLE_ROOMS_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit () {
-        await this.simpleRoomsManagerService.hydrateRoomsFromDB();
-    }
+  async onModuleInit() {
+    await this.simpleRoomsManagerService.hydrateRoomsFromDB();
+  }
 }
-

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

@@ -2,22 +2,22 @@ import { Inject, Injectable } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
 import {
-    BaseGameEvent,
-    GameMaster,
-    MinPlayersStartStrategy,
-    SimpleRoom,
-    GameRoomConfig,
-    RoomUpdateStateEvent,
-    UserWonTheGameAppEvent,
-    GameTableFinishedEvent,
-    GamePlayerEnteredTheTableEvent,
-    GamePlayerExitedTheTableEvent,
+  BaseGameEvent,
+  GameMaster,
+  MinPlayersStartStrategy,
+  SimpleRoom,
+  GameRoomConfig,
+  RoomUpdateStateEvent,
+  UserWonTheGameAppEvent,
+  GameTableFinishedEvent,
+  GamePlayerEnteredTheTableEvent,
+  GamePlayerExitedTheTableEvent,
 } from 'jp.ms.common.engine';
 import {
-    GameResultRepository,
-    SimpleRoomDocument,
-    SimpleRoomsRepository,
-    UsersRepository
+  GameResultRepository,
+  SimpleRoomDocument,
+  SimpleRoomsRepository,
+  UsersRepository,
 } from 'jp.db.schemas';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
@@ -30,150 +30,164 @@ import { SimpleRoomsFactoryOptions } from './simple-rooms-manager.interfaces';
 
 @Injectable()
 export class SimpleRoomsManagerService {
-    private readonly rooms: Map<string, SimpleRoom>;
-
-    constructor(
-        private readonly roomsRepository: SimpleRoomsRepository,
-        private readonly usersRepository: UsersRepository,
-        private readonly gameResultRepository: GameResultRepository,
-        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
-        @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
-        @InjectConnection() private readonly connection: Connection,
-        @Inject() private readonly logger: JpLoggerService,
-    ) {
-        this.rooms = new Map<string, SimpleRoom>();
-    }
-
-    get gameType () {
-        return this.options.configService.get<string>('GAME_TYPE') || '';
-    }
-
-    getRoomById (roomId: string): SimpleRoom | undefined {
-        return this.rooms.get(roomId);
-    }
-
-    getRoomByTableId (tableId: string): SimpleRoom | undefined {
-        const { roomId } = GameMaster.parseTableId(tableId);
-
-        return this.getRoomById(roomId);
+  private readonly rooms: Map<string, SimpleRoom>;
+
+  constructor(
+    private readonly roomsRepository: SimpleRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
+    @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS)
+    private readonly options: SimpleRoomsFactoryOptions,
+    @InjectConnection() private readonly connection: Connection,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.rooms = new Map<string, SimpleRoom>();
+  }
+
+  get gameType() {
+    return this.options.configService.get<string>('GAME_TYPE') || '';
+  }
+
+  getRoomById(roomId: string): SimpleRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId(tableId: string): SimpleRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  getRooms(): Array<SimpleRoom> {
+    return Array.from(this.rooms.values());
+  }
+
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
+  }
+
+  addRoom(room: SimpleRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async hydrateRoomsFromDB() {
+    const templates = await this.roomsRepository.findRooms(this.gameType);
+
+    templates.forEach((item) => {
+      const newRoom = this.options.createRoom(
+        this.simpleRoomDocumentToRoom(item),
+      );
+      this.addRoom(newRoom);
+    });
+  }
+
+  /*
+        1. Сначала ищем стол в котором один игрок
+        2. Далее ищем стол за которым есть игроки и свободные места
+        3. Отправляем на стол для быстрой игры если там есть места
+        4. Наконец создаем стол для быстрой игры и отправляем туда
+    */
+  getFreeFastGameRoom(): GameMaster | undefined {
+    if (this.getRooms().some((item) => item.isTechBreak())) {
+      return;
     }
 
-    getRooms (): Array<SimpleRoom> {
-        return Array.from(this.rooms.values());
-    }
+    const tables = this.getTables();
 
-    getTables (): Array<GameMaster> {
-        return this.getRooms().reduce(
-            (result, currentValue) => {
-                return [...result, ...currentValue.getMasters()];
-            }, [] as Array<GameMaster>
-        );
-    }
+    let freeTable = tables.find(
+      (master) =>
+        master.getTable().remainOnePlayer() &&
+        master.getTable().getPlayers()[0].hasOpenConnection(),
+    );
 
-    addRoom (room: SimpleRoom) {
-        this.rooms.set(room.getId(), room);
+    if (!freeTable) {
+      freeTable = tables.find(
+        (master) =>
+          master.getTable().hasMinPlayers() &&
+          !master.getTable().isFullWithQueue(),
+      );
     }
 
-    async hydrateRoomsFromDB () {
-        const templates = await this.roomsRepository.findRooms(this.gameType);
-
-        templates.forEach((item) => {
-            const newRoom = this.options.createRoom(
-                this.simpleRoomDocumentToRoom(item)
-            );
-            this.addRoom(newRoom);
-        });
+    if (!freeTable) {
+      freeTable = tables
+        .filter((item) => item.getRoom().getEnableForFastGame())
+        .find((master) => !master.getTable().isFullWithQueue());
     }
 
-    /*
-        1. Сначала ищем стол в котором один игрок
-        2. Далее ищем стол за которым есть игроки и свободные места
-        3. Отправляем на стол для быстрой игры если там есть места
-        4. Наконец создаем стол для быстрой игры и отправляем туда
-    */
-    getFreeFastGameRoom (): GameMaster | undefined {
-        if (this.getRooms().some((item) => item.isTechBreak())) {
-            return;
-        }
-
-        const tables = this.getTables();
-
-        let freeTable = tables.find(
-            (master) => master.getTable().remainOnePlayer() && master.getTable().getPlayers()[0].hasOpenConnection()
-        );
-
-        if (!freeTable) {
-            freeTable = tables.find(
-                (master) => master.getTable().hasMinPlayers() && !master.getTable().isFullWithQueue(),
-            );
-        }
-
-        if (!freeTable) {
-            freeTable = tables.filter((item) => item.getRoom().getEnableForFastGame()).find(
-                (master) => !master.getTable().isFullWithQueue(),
-            );
-        }
-
-        if (!freeTable) {
-            const fastGameRoom = this.getRooms().find((item) => item.getEnableForFastGame());
-            if (fastGameRoom) {
-                freeTable = fastGameRoom.addMaster();
-            }
-        }
-
-        return freeTable;
+    if (!freeTable) {
+      const fastGameRoom = this.getRooms().find((item) =>
+        item.getEnableForFastGame(),
+      );
+      if (fastGameRoom) {
+        freeTable = fastGameRoom.addMaster();
+      }
     }
 
-    private simpleRoomDocumentToRoom (room: SimpleRoomDocument): GameRoomConfig {
-        const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
-        const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-
-        return {
-            id: room.roomId,
-            gameType: room.gameType,
-            roomType: room.roomType,
-            rulesType: room.rulesType,
-            deckType: room.deckType,
-            tableSize: room.tableSize,
-            bet: room.bet,
-            ticketPrice: room.ticketPrice / 2,
-            title: room.title,
-            subtitle: room.subtitle,
-            description: room.description,
-            enableForFastGame: room.enableForFastGame,
-            turnTimeout: playersTurnTimeout,
-            restartTimeout: restartGameTimeout,
-            localeService: this.options.i18n,
-            startStrategy: new MinPlayersStartStrategy(),
-            onRoomEvent: this.handleRoomEvent,
-        } as GameRoomConfig;
+    return freeTable;
+  }
+
+  private simpleRoomDocumentToRoom(room: SimpleRoomDocument): GameRoomConfig {
+    const restartGameTimeout =
+      this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
+    const playersTurnTimeout =
+      this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
+
+    return {
+      id: room.roomId,
+      gameType: room.gameType,
+      roomType: room.roomType,
+      rulesType: room.rulesType,
+      deckType: room.deckType,
+      tableSize: room.tableSize,
+      bet: room.bet,
+      ticketPrice: room.ticketPrice / 2,
+      title: room.title,
+      subtitle: room.subtitle,
+      description: room.description,
+      enableForFastGame: room.enableForFastGame,
+      turnTimeout: playersTurnTimeout,
+      restartTimeout: restartGameTimeout,
+      localeService: this.options.i18n,
+      startStrategy: new MinPlayersStartStrategy(),
+      onRoomEvent: this.handleRoomEvent,
+    } as GameRoomConfig;
+  }
+
+  private handleRoomEvent = (event: BaseGameEvent) => {
+    this.logger.log(event.toLog());
+
+    if (event instanceof GameTableFinishedEvent) {
+      void this.handleRoomTableGameFinished(event.master);
+    } else if (
+      event instanceof GamePlayerEnteredTheTableEvent ||
+      event instanceof GamePlayerExitedTheTableEvent
+    ) {
+      this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
     }
-
-    private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
-
-        if (event instanceof GameTableFinishedEvent) {
-            this.handleRoomTableGameFinished(event.master!!);
-        } else if (event instanceof GamePlayerEnteredTheTableEvent || event instanceof GamePlayerExitedTheTableEvent) {
-            this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
-        }
-    };
-
-    private handleRoomTableGameFinished = async (master: GameMaster) => {
-        await saveGameTablesResult(
-            master,
-            this.connection,
-            this.gameResultRepository,
-            this.usersRepository,
-            true,
-        );
-
-        // TODO: записать разные события для достижений
-        this.eventsBusAppSubscribeService.pushNewEvent(new UserWonTheGameAppEvent(this.gameType, '123'));
-    };
-
-    private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-        this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    };
+  };
+
+  private handleRoomTableGameFinished = async (master: GameMaster) => {
+    await saveGameTablesResult(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      true,
+    );
+
+    // TODO: записать разные события для достижений
+    this.eventsBusAppSubscribeService.pushNewEvent(
+      new UserWonTheGameAppEvent(this.gameType, '123'),
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+  };
 }

package/src/modules/support/dump.service.ts

@@ -3,10 +3,9 @@ import v8 from 'v8';
 
 @Injectable()
 export class DumpService {
-    constructor () {
-    }
+  constructor() {}
 
-    async getDump (): Promise<NodeJS.ReadableStream> {
-        return v8.getHeapSnapshot();
-    }
+  getDump(): NodeJS.ReadableStream {
+    return v8.getHeapSnapshot();
+  }
 }