jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -2,22 +2,23 @@ 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,
+  LocalService,
 } 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 +31,160 @@ 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.gameType;
+  }
+
+  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 {
+    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: this.options.playersTurnTimeout,
+      restartTimeout: this.options.restartGameTimeout,
+      instantFinishMode: this.options.instantFinishMode,
+      localeService: this.options.i18n as LocalService,
+      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();
+  }
 }

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

@@ -5,37 +5,37 @@ import { Gauge, register, Registry } from 'prom-client';
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 
 import { SUPPORT_OPTIONS } from './support.constants';
-import { SupportOptions } from './support.interfaces';
+import { SupportFactoryOptions } from './support.interfaces';
 
 @Injectable()
 export class MetricService {
-    private readonly register: Registry;
-    private readonly activeUsersGauge: Gauge;
-    private readonly playingTablesGauge: Gauge;
-
-    constructor (
-        @Inject(SUPPORT_OPTIONS) private options: SupportOptions,
-        private readonly playersManager: PlayersManagerService,
-    ) {
-        this.register = new client.Registry();
-        register.setDefaultLabels({ app: this.options.prometheusNameApp });
-        client.collectDefaultMetrics({ register });
-
-        this.activeUsersGauge = new client.Gauge({
-            name: 'jptserveractiveusers',
-            help: 'Amount of active users',
-        });
-
-        this.playingTablesGauge = new client.Gauge({
-            name: 'jptserverplayingtables',
-            help: 'Amount of playing tables',
-        });
-    }
-
-    async getMetrics (): Promise<Registry> {
-        this.activeUsersGauge.set(this.playersManager.getPlayers().length)
-        // this.playingTablesGauge.set(this.playersManager.getPlayingTables(''))
-
-        return register;
-    }
+  private readonly register: Registry;
+  private readonly activeUsersGauge: Gauge;
+  private readonly playingTablesGauge: Gauge;
+
+  constructor(
+    @Inject(SUPPORT_OPTIONS) private options: SupportFactoryOptions,
+    private readonly playersManager: PlayersManagerService,
+  ) {
+    this.register = new client.Registry();
+    register.setDefaultLabels({ app: this.options.prometheusNameApp });
+    client.collectDefaultMetrics({ register });
+
+    this.activeUsersGauge = new client.Gauge({
+      name: 'jptserveractiveusers',
+      help: 'Amount of active users',
+    });
+
+    this.playingTablesGauge = new client.Gauge({
+      name: 'jptserverplayingtables',
+      help: 'Amount of playing tables',
+    });
+  }
+
+  getMetrics(): Registry {
+    this.activeUsersGauge.set(this.playersManager.getPlayers().length);
+    // this.playingTablesGauge.set(this.playersManager.getPlayingTables(''))
+
+    return register;
+  }
 }

package/src/modules/support/support.controller.ts

@@ -1,4 +1,14 @@
-import { Body, Controller, Get, Headers, HttpCode, HttpStatus, Inject, Post, Res } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Headers,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Res,
+} from '@nestjs/common';
 import type { Response } from 'express';
 import { IAppHeaders } from 'jp.common.models';
 
@@ -12,59 +22,58 @@ import { DumpService } from './dump.service';
 
 @Controller('support')
 export class SupportController {
-    constructor (
-        private readonly supportService: SupportService,
-        private readonly metricService: MetricService,
-        private readonly dumpService: DumpService,
-        @Inject() private readonly logger: JpLoggerService,
-    ) {
-    }
+  constructor(
+    private readonly supportService: SupportService,
+    private readonly metricService: MetricService,
+    private readonly dumpService: DumpService,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {}
 
-    @Get('users')
-    getUsers (): Promise<Array<PlayerConnectedDto>> {
-        return this.supportService.getUsers();
-    }
+  @Get('users')
+  getUsers(): Array<PlayerConnectedDto> {
+    return this.supportService.getUsers();
+  }
 
-    @Get('dump')
-    async getDump (@Res() response: Response): Promise<void> {
-        const dump = await this.dumpService.getDump()
+  @Get('dump')
+  getDump(@Res() response: Response): void {
+    const dump = this.dumpService.getDump();
 
-        response.set({
-            "Content-Type": "application/octet-stream",
-            "Content-Disposition": "attachment; filename=${Date.now()}.heapsnapshot"
-        });
+    response.set({
+      'Content-Type': 'application/octet-stream',
+      'Content-Disposition': 'attachment; filename=${Date.now()}.heapsnapshot',
+    });
 
-        dump.pipe(response);
-    }
+    dump.pipe(response);
+  }
 
-    @Get('metrics')
-    async getMetrics (@Res() response: Response) {
-        const register = await this.metricService.getMetrics();
-        response.set({ 'Content-Type': register.contentType });
+  @Get('metrics')
+  async getMetrics(@Res() response: Response) {
+    const register = this.metricService.getMetrics();
+    response.set({ 'Content-Type': register.contentType });
 
-        response.send(await register.metrics());
-    }
+    response.send(await register.metrics());
+  }
 
-    @Post('log')
-    @HttpCode(HttpStatus.OK)
-    addLog (@Headers() headers: IAppHeaders, @Body() body: LogsDto) {
-        body.logs.forEach((item) => {
-            this.logger.log({
-                client_auth_token: headers.client_auth_token,
-                client_game: headers.client_game,
-                client_channel: headers.client_channel,
-                client_language: headers.client_language,
-                client_version: headers.client_version,
-                description: item.message,
-                stackTrace: item.stackTrace,
-                level: item.level,
-            });
-        })
-    }
+  @Post('log')
+  @HttpCode(HttpStatus.OK)
+  addLog(@Headers() headers: IAppHeaders, @Body() body: LogsDto) {
+    body.logs.forEach((item) => {
+      this.logger.log({
+        client_auth_token: headers.client_auth_token,
+        client_game: headers.client_game,
+        client_channel: headers.client_channel,
+        client_language: headers.client_language,
+        client_version: headers.client_version,
+        description: item.message,
+        stackTrace: item.stackTrace,
+        level: item.level,
+      });
+    });
+  }
 
-    @Post('techBreakOn')
-    @HttpCode(HttpStatus.OK)
-    techBreakOn (): boolean {
-        return this.supportService.techBreakOn();
-    }
+  @Post('techBreakOn')
+  @HttpCode(HttpStatus.OK)
+  techBreakOn(): boolean {
+    return this.supportService.techBreakOn();
+  }
 }

package/src/modules/support/support.interfaces.ts

@@ -1,7 +1,16 @@
-export type SupportOptions = {
-  prometheusNameApp: string;
-};
+import { ModuleMetadata } from '@nestjs/common';
+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 SupportOptions extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => SupportFactoryOptions;
+}
 
-export interface SupportOptionsFactory {
-  createSupportOptions(): Promise<SupportOptions> | SupportOptions;
+export interface SupportFactoryOptions {
+  prometheusNameApp: string;
 }

package/src/modules/support/support.module.ts

@@ -1,4 +1,4 @@
-import { DynamicModule, Module } from '@nestjs/common';
+import { DynamicModule, Module, Provider } from '@nestjs/common';
 
 import { SupportController } from './support.controller';
 import { SupportService } from './support.service';
@@ -8,15 +8,28 @@ import { MetricService } from './metric.service';
 import { DumpService } from './dump.service';
 
 @Module({
-    controllers: [SupportController],
-    providers: [SupportService, MetricService, DumpService],
+  controllers: [SupportController],
+  providers: [SupportService, MetricService, DumpService],
 })
 export class SupportModule {
-    public static forRoot(options: SupportOptions): DynamicModule {
-        return {
-            module: SupportModule,
-            providers: [{ provide: SUPPORT_OPTIONS, useValue: options }],
-        };
-    }
-}
+  public static forRoot(options: SupportOptions): DynamicModule {
+    return {
+      module: SupportModule,
+      providers: [{ provide: SUPPORT_OPTIONS, useValue: options }],
+    };
+  }
 
+  static forRootAsync(options: SupportOptions): DynamicModule {
+    return {
+      module: SupportModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: SUPPORT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+}

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

@@ -6,19 +6,22 @@ import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-
 
 @Injectable()
 export class SupportService {
-    constructor (
-        private readonly playersManager: PlayersManagerService,
-        private readonly simpleRoomsManager: SimpleRoomsManagerService,
-    ) {
-    }
+  constructor(
+    private readonly playersManager: PlayersManagerService,
+    private readonly simpleRoomsManager: SimpleRoomsManagerService,
+  ) {}
 
-    async getUsers (): Promise<Array<PlayerConnectedDto>> {
-        return this.playersManager.getPlayers().map((item) => PlayerConnectedDto.fromEntities(item));
-    }
+  getUsers(): Array<PlayerConnectedDto> {
+    return this.playersManager
+      .getPlayers()
+      .map((item) => PlayerConnectedDto.fromEntities(item));
+  }
 
-    techBreakOn (): boolean {
-        this.simpleRoomsManager.getRooms().forEach((item) => item.handleTechBreakOn());
+  techBreakOn(): boolean {
+    this.simpleRoomsManager
+      .getRooms()
+      .forEach((item) => item.handleTechBreakOn());
 
-        return true;
-    }
+    return true;
+  }
 }

package/src/utils/date.ts

@@ -1,7 +1,7 @@
-export function getHours (timeStr: string) {
-    return parseInt(timeStr.substring(0, 2), 10);
+export function getHours(timeStr: string) {
+  return parseInt(timeStr.substring(0, 2), 10);
 }
 
-export function getMinutes (timeStr: string) {
-    return parseInt(timeStr.substring(3, 5), 10);
+export function getMinutes(timeStr: string) {
+  return parseInt(timeStr.substring(3, 5), 10);
 }