jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -9,33 +9,33 @@ import { SupportOptions } 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: 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',
+    });
+  }
+
+  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.module.ts

@@ -8,15 +8,14 @@ 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 }],
+    };
+  }
 }
-

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/modules/tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.constants.ts

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

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

@@ -3,18 +3,27 @@ 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';
+import {
+  ManyTablesTournamentRoomConfig,
+  ManyTablesTournamentRoom,
+  IPrizeTableData,
+} from 'jp.ms.common.engine';
 import { ConfigService } from '@nestjs/config';
 
-export interface TournamentManyTablesRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface TournamentManyTablesRoomsManagerOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface TournamentManyTablesRoomsFactoryOptions {
-    i18n: I18nService;
-    configService: ConfigService;
-    tournamentPrizeTable: IPrizeTableData;
-    createTournamentRoom (room: ManyTablesTournamentRoomConfig): ManyTablesTournamentRoom;
+  i18n: I18nService;
+  configService: ConfigService;
+  tournamentPrizeTable: IPrizeTableData;
+  createTournamentRoom(
+    room: ManyTablesTournamentRoomConfig,
+  ): ManyTablesTournamentRoom;
 }

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

@@ -1,18 +1,24 @@
-import { DynamicModule, Global, Inject, Module, Provider } from '@nestjs/common';
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
-    TournamentManyTablesRoom,
-    TournamentManyTablesRoomSchema,
-    TournamentManyTablesRoomsRepository,
-    User,
-    UserSchema,
-    UsersRepository,
-    GameResult,
-    GameResultSchema,
-    GameResultRepository,
-    Purchase,
-    PurchaseSchema,
-    PurchaseRepository,
+  TournamentManyTablesRoom,
+  TournamentManyTablesRoomSchema,
+  TournamentManyTablesRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
+  Purchase,
+  PurchaseSchema,
+  PurchaseRepository,
 } from 'jp.db.schemas';
 
 import { TournamentManyTablesRoomsManagerService } from './tournament-many-tables-rooms-manager.service';
@@ -22,48 +28,61 @@ import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-table
 
 @Global()
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
-        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-        MongooseModule.forFeature([{ name: Purchase.name, schema: PurchaseSchema }]),
-        MongooseModule.forFeature([{ name: GameResult.name, schema: GameResultSchema }]),
-    ],
-    providers: [
-        TournamentManyTablesRoomsRepository,
-        UsersRepository,
-        TournamentManyTablesRoomsManagerService,
-        GameResultRepository,
-        PurchaseRepository,
-    ],
-    exports: [TournamentManyTablesRoomsManagerService],
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: TournamentManyTablesRoom.name,
+        schema: TournamentManyTablesRoomSchema,
+      },
+    ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: Purchase.name, schema: PurchaseSchema },
+    ]),
+    MongooseModule.forFeature([
+      { name: GameResult.name, schema: GameResultSchema },
+    ]),
+  ],
+  providers: [
+    TournamentManyTablesRoomsRepository,
+    UsersRepository,
+    TournamentManyTablesRoomsManagerService,
+    GameResultRepository,
+    PurchaseRepository,
+  ],
+  exports: [TournamentManyTablesRoomsManagerService],
 })
 export class TournamentManyTablesRoomsManagerModule {
-    constructor(
-        private readonly managerService: TournamentManyTablesRoomsManagerService,
-        @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
-    ) {
-    }
+  constructor(
+    private readonly managerService: TournamentManyTablesRoomsManagerService,
+    @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS)
+    private readonly options: TournamentManyTablesRoomsFactoryOptions,
+  ) {}
 
-    static forRootAsync (options: TournamentManyTablesRoomsManagerOptions): DynamicModule {
-        return {
-            module: TournamentManyTablesRoomsManagerModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(
+    options: TournamentManyTablesRoomsManagerOptions,
+  ): DynamicModule {
+    return {
+      module: TournamentManyTablesRoomsManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit () {
-        const dailyTournamentScheduleJobEnabled = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_JOB_ENABLED');
-        if (dailyTournamentScheduleJobEnabled === 'true') {
-            await this.managerService.runDailyTournamentJob();
-        }
-        await this.managerService.hydrateTournamentsFromDB();
+  async onModuleInit() {
+    const dailyTournamentScheduleJobEnabled =
+      this.options.configService.get<string>(
+        'DAILY_TOURNAMENT_SCHEDULE_JOB_ENABLED',
+      );
+    if (dailyTournamentScheduleJobEnabled === 'true') {
+      await this.managerService.runDailyTournamentJob();
     }
+    await this.managerService.hydrateTournamentsFromDB();
+  }
 }
-