jp.ms.common.modules 1.0.41 → 1.0.43

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

@@ -1,190 +1,192 @@
-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,
-  LocalService,
-} from 'jp.ms.common.engine';
-import {
-  GameResultRepository,
-  SimpleRoomDocument,
-  SimpleRoomsRepository,
-  UsersRepository,
-} from 'jp.db.schemas';
-
-import { JpLoggerService } from '../logger/jp-logger.service';
-import { saveGameTablesResult } from '../../utils/game-table-result';
-import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
-import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
-
-import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
-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.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;
-    }
-
-    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;
-  }
-
-  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 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);
-  };
-}
+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,
+  LocalService,
+} from 'jp.ms.common.engine';
+import {
+  GameResultRepository,
+  RatingRepository,
+  SimpleRoomDocument,
+  SimpleRoomsRepository,
+  UsersRepository,
+} from 'jp.db.schemas';
+
+import { JpLoggerService } from '../logger/jp-logger.service';
+import { saveGameTablesResultForSimpleRoom } from '../../utils/game-table-result';
+import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
+import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
+
+import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
+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 ratingRepository: RatingRepository,
+    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;
+    }
+
+    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;
+  }
+
+  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 handleRoomTableGameFinished = async (master: GameMaster) => {
+    await saveGameTablesResultForSimpleRoom(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      this.ratingRepository,
+    );
+
+    // TODO: записать разные события для достижений
+    this.eventsBusAppSubscribeService.pushNewEvent(
+      new UserWonTheGameAppEvent(this.gameType, '123'),
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+  };
+}

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

@@ -1,11 +1,11 @@
-import { Injectable } from '@nestjs/common';
-import v8 from 'v8';
-
-@Injectable()
-export class DumpService {
-  constructor() {}
-
-  getDump(): NodeJS.ReadableStream {
-    return v8.getHeapSnapshot();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import v8 from 'v8';
+
+@Injectable()
+export class DumpService {
+  constructor() {}
+
+  getDump(): NodeJS.ReadableStream {
+    return v8.getHeapSnapshot();
+  }
+}

package/src/modules/support/index.ts

@@ -1 +1 @@
-export { SupportModule } from './support.module';
+export { SupportModule } from './support.module';

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

@@ -1,41 +1,41 @@
-import { Inject, Injectable } from '@nestjs/common';
-import * as client from 'prom-client';
-import { Gauge, register, Registry } from 'prom-client';
-
-import { PlayersManagerService } from '../players-manager/players-manager.service';
-
-import { SUPPORT_OPTIONS } from './support.constants';
-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: 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;
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import * as client from 'prom-client';
+import { Gauge, register, Registry } from 'prom-client';
+
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+
+import { SUPPORT_OPTIONS } from './support.constants';
+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: 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.constants.ts

@@ -1 +1 @@
-export const SUPPORT_OPTIONS = Symbol('SUPPORT_OPTIONS');
+export const SUPPORT_OPTIONS = Symbol('SUPPORT_OPTIONS');

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

@@ -1,79 +1,79 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Headers,
-  HttpCode,
-  HttpStatus,
-  Inject,
-  Post,
-  Res,
-} from '@nestjs/common';
-import type { Response } from 'express';
-import { IAppHeaders } from 'jp.common.models';
-
-import { PlayerConnectedDto } from '../../dto/common/player-connected.dto';
-import { JpLoggerService } from '../logger/jp-logger.service';
-import { LogsDto } from '../../dto/common/log.dto';
-
-import { SupportService } from './support.service';
-import { MetricService } from './metric.service';
-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,
-  ) {}
-
-  @Get('users')
-  getUsers(): Array<PlayerConnectedDto> {
-    return this.supportService.getUsers();
-  }
-
-  @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',
-    });
-
-    dump.pipe(response);
-  }
-
-  @Get('metrics')
-  async getMetrics(@Res() response: Response) {
-    const register = this.metricService.getMetrics();
-    response.set({ 'Content-Type': register.contentType });
-
-    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('techBreakOn')
-  @HttpCode(HttpStatus.OK)
-  techBreakOn(): boolean {
-    return this.supportService.techBreakOn();
-  }
-}
+import {
+  Body,
+  Controller,
+  Get,
+  Headers,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Res,
+} from '@nestjs/common';
+import type { Response } from 'express';
+import { IAppHeaders } from 'jp.common.models';
+
+import { PlayerConnectedDto } from '../../dto/common/player-connected.dto';
+import { JpLoggerService } from '../logger/jp-logger.service';
+import { LogsDto } from '../../dto/common/log.dto';
+
+import { SupportService } from './support.service';
+import { MetricService } from './metric.service';
+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,
+  ) {}
+
+  @Get('users')
+  getUsers(): Array<PlayerConnectedDto> {
+    return this.supportService.getUsers();
+  }
+
+  @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',
+    });
+
+    dump.pipe(response);
+  }
+
+  @Get('metrics')
+  async getMetrics(@Res() response: Response) {
+    const register = this.metricService.getMetrics();
+    response.set({ 'Content-Type': register.contentType });
+
+    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('techBreakOn')
+  @HttpCode(HttpStatus.OK)
+  techBreakOn(): boolean {
+    return this.supportService.techBreakOn();
+  }
+}