jp.ms.common.modules 1.0.34 → 1.0.36

package/src/dto/games/fool/fool-table.dto.ts

@@ -1,79 +1,81 @@
-import { ApiProperty } from "@nestjs/swagger";
-import { Expose, plainToInstance, Type } from "class-transformer";
-import { IsArray, IsNumber, ValidateNested } from "class-validator";
-import { IFoolTable } from "jp.common.models";
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose, plainToInstance, Type } from 'class-transformer';
+import { IsArray, IsNumber, ValidateNested } from 'class-validator';
+import { IFoolTable } from 'jp.common.models';
 
-import { AppScreenAppBarDto, AppScreenDialogDto } from "../../app-screen";
+import { AppScreenAppBarDto, AppScreenDialogDto } from '../../app-screen';
 import {
-    CardsPairSlotsDto,
-    CardsDeckDto,
-    CardsPanelDto,
-    MovesPanelDto,
-    SummaryDto,
-} from "../../app-table";
+  CardsPairSlotsDto,
+  CardsDeckDto,
+  CardsPanelDto,
+  MovesPanelDto,
+  SummaryDto,
+} from '../../app-table';
 
-import { FoolPlayerDto } from "./fool-player.dto";
+import { FoolPlayerDto } from './fool-player.dto';
 
 export class FoolTableDto implements IFoolTable {
-    @Type(() => AppScreenAppBarDto)
-    @Expose()
-    appBar: AppScreenAppBarDto;
+  @Type(() => AppScreenAppBarDto)
+  @Expose()
+  appBar: AppScreenAppBarDto;
 
-    @Type(() => AppScreenDialogDto)
-    @Expose()
-    confirmExitDialog: AppScreenDialogDto | undefined;
+  @Type(() => AppScreenDialogDto)
+  @Expose()
+  confirmExitDialog: AppScreenDialogDto | undefined;
 
-    @ApiProperty({
-        description: 'Player Turn Timer Remain',
-        type: Number,
-    })
-    @IsNumber()
-    @Expose()
-    playersTurnTimer: number | undefined;
+  @ApiProperty({
+    description: 'Player Turn Timer Remain',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  playersTurnTimer: number | undefined;
 
-    @ApiProperty({
-        description: 'Restart Timer Remain',
-        type: Number,
-    })
-    @IsNumber()
-    @Expose()
-    restartTimer: number | undefined;
+  @ApiProperty({
+    description: 'Restart Timer Remain',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  restartTimer: number | undefined;
 
-    @ApiProperty({
-        description: 'Table size',
-        type: Number,
-    })
-    @IsNumber()
-    @Expose()
-    tableSize: number;
+  @ApiProperty({
+    description: 'Table size',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  tableSize: number;
 
-    @IsArray()
-    @ValidateNested({ each: true })
-    @Type(() => FoolPlayerDto)
-    @Expose()
-    players: FoolPlayerDto[];
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => FoolPlayerDto)
+  @Expose()
+  players: FoolPlayerDto[];
 
-    @Type(() => CardsPairSlotsDto)
-    @Expose()
-    cardsSlots: CardsPairSlotsDto;
+  @Type(() => CardsPairSlotsDto)
+  @Expose()
+  cardsSlots: CardsPairSlotsDto;
 
-    @Type(() => CardsDeckDto)
-    @Expose()
-    cardsDeck: CardsDeckDto;
+  @Type(() => CardsDeckDto)
+  @Expose()
+  cardsDeck: CardsDeckDto;
 
-    @Type(() => SummaryDto)
-    @Expose()
-    summary: SummaryDto;
+  @Type(() => SummaryDto)
+  @Expose()
+  summary: SummaryDto;
 
-    @Type(() => CardsPanelDto)
-    @Expose()
-    cardsPanel: CardsPanelDto;
+  @Type(() => CardsPanelDto)
+  @Expose()
+  cardsPanel: CardsPanelDto;
 
-    @Type(() => MovesPanelDto)
-    @Expose()
-    movesPanel: MovesPanelDto;
+  @Type(() => MovesPanelDto)
+  @Expose()
+  movesPanel: MovesPanelDto;
 
-    constructor(entity: IFoolTable) {
-        return plainToInstance(FoolTableDto, entity, { excludeExtraneousValues: true })
-    }
-}
+  constructor(entity: IFoolTable) {
+    return plainToInstance(FoolTableDto, entity, {
+      excludeExtraneousValues: true,
+    });
+  }
+}

package/src/dto/games/index.ts

@@ -1 +1 @@
-export * from './fool/fool-table.dto';
+export * from './fool/fool-table.dto';

package/src/dto/index.ts

@@ -1,4 +1,4 @@
-export * from './app-table'
-export * from './app-screen'
-export * from './common'
+export * from './app-table';
+export * from './app-screen';
+export * from './common';
 export * from './games';

package/src/exception/error-code.enum.ts

@@ -1,4 +1,4 @@
 export enum ErrorCodeEnum {
-    NOT_ENOUGH_MONEY_FOR_PURCHASE = '1001',
-    NOT_FOUND_FREE_ROOM_FOR_FAST_GAME = '1002',
-}
+  NOT_ENOUGH_MONEY_FOR_PURCHASE = '1001',
+  NOT_FOUND_FREE_ROOM_FOR_FAST_GAME = '1002',
+}

package/src/exception/global-exception-filter.ts

@@ -1,15 +1,24 @@
-import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpCode, HttpStatus } from '@nestjs/common';
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
 import { Response } from 'express';
 
 import { JpLoggerService } from '../modules';
 
-import { ErrorResponseWithSnackbar, HttpExceptionWithSnackbar } from './http-exception-wth-snackbar';
+import {
+  ErrorResponseWithSnackbar,
+  HttpExceptionWithSnackbar,
+} from './http-exception-wth-snackbar';
 
 @Catch(Error)
 export class GlobalExceptionFilter implements ExceptionFilter {
   private readonly logger = new JpLoggerService();
 
-  catch (exception: Error, host: ArgumentsHost) {
+  catch(exception: Error, host: ArgumentsHost) {
     this.logger.error(exception);
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
@@ -18,33 +27,27 @@ export class GlobalExceptionFilter implements ExceptionFilter {
       const data = exception.getResponse() as ErrorResponseWithSnackbar;
       const status = exception.getStatus();
 
-      response
-        .status(status)
-        .json({
-          statusCode: status,
-          message: exception.message,
-          snackbar: data.snackbar,
-        });
+      response.status(status).json({
+        statusCode: status,
+        message: exception.message,
+        snackbar: data.snackbar,
+      });
 
       return;
     } else if (exception instanceof HttpException) {
       const status = exception.getStatus();
 
-      response
-        .status(status)
-        .json({
-          statusCode: status,
-          message: exception.message,
-        });
+      response.status(status).json({
+        statusCode: status,
+        message: exception.message,
+      });
 
       return;
     }
 
-    response
-      .status(HttpStatus.INTERNAL_SERVER_ERROR)
-      .json({
-        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-        message: exception.message,
-      });
+    response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+      message: exception.message,
+    });
   }
-}
+}

package/src/exception/http-exception-wth-snackbar.ts

@@ -4,20 +4,24 @@ import { IAppScreenSnackbar } from 'jp.common.models';
 import { ErrorCodeEnum } from './error-code.enum';
 
 export interface ErrorResponseWithSnackbar {
-    statusCode: number;
-    message: string;
-    errorCode: string;
-    snackbar: IAppScreenSnackbar;
+  statusCode: number;
+  message: string;
+  errorCode: string;
+  snackbar: IAppScreenSnackbar;
 }
 
 export class HttpExceptionWithSnackbar extends HttpException {
-    constructor(message: string, errorCode: ErrorCodeEnum, snackbar: IAppScreenSnackbar) {
-        const response: ErrorResponseWithSnackbar = {
-            statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-            message,
-            errorCode,
-            snackbar,
-        };
-        super(response, HttpStatus.INTERNAL_SERVER_ERROR);
-    }
-}
+  constructor(
+    message: string,
+    errorCode: ErrorCodeEnum,
+    snackbar: IAppScreenSnackbar,
+  ) {
+    const response: ErrorResponseWithSnackbar = {
+      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+      message,
+      errorCode,
+      snackbar,
+    };
+    super(response, HttpStatus.INTERNAL_SERVER_ERROR);
+  }
+}

package/src/exception/index.ts

@@ -1,4 +1,4 @@
-export { GlobalExceptionFilter  } from './global-exception-filter';
+export { GlobalExceptionFilter } from './global-exception-filter';
 export { NotEnoughMoneyForPurchaseException } from './not-enough-money-for-purchase.exception';
 export { NotFoundFreeRoomForFastGameException } from './not-found-free-room-for-fast-game.exception';
-export { ErrorCodeEnum } from './error-code.enum';
+export { ErrorCodeEnum } from './error-code.enum';

package/src/exception/not-enough-money-for-purchase.exception.ts

@@ -3,13 +3,12 @@ import { IAppScreenSnackbar } from 'jp.common.models';
 import { ErrorCodeEnum } from './error-code.enum';
 import { HttpExceptionWithSnackbar } from './http-exception-wth-snackbar';
 
-
 export class NotEnoughMoneyForPurchaseException extends HttpExceptionWithSnackbar {
-    constructor(snackbar: IAppScreenSnackbar) {
-        super(
-            'Not enough money for purchase',
-            ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
-            snackbar,
-        );
-    }
-}
+  constructor(snackbar: IAppScreenSnackbar) {
+    super(
+      'Not enough money for purchase',
+      ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+      snackbar,
+    );
+  }
+}

package/src/exception/not-found-free-room-for-fast-game.exception.ts

@@ -3,13 +3,12 @@ import { IAppScreenSnackbar } from 'jp.common.models';
 import { ErrorCodeEnum } from './error-code.enum';
 import { HttpExceptionWithSnackbar } from './http-exception-wth-snackbar';
 
-
 export class NotFoundFreeRoomForFastGameException extends HttpExceptionWithSnackbar {
-    constructor(snackbar: IAppScreenSnackbar) {
-        super(
-            'Not found free room for fast game',
-            ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
-            snackbar,
-        );
-    }
-}
+  constructor(snackbar: IAppScreenSnackbar) {
+    super(
+      'Not found free room for fast game',
+      ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
+      snackbar,
+    );
+  }
+}

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './dto';
 export * from './modules';
-export * from './config';
 export * from './exception';
-export * from './views';
+export * from './views';

package/src/modules/anti-freeze-system/anti-freeze-system.interfaces.ts

@@ -2,14 +2,17 @@ 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';
-import { ConfigService } from '@nestjs/config';
 
-export interface AntiFreezeSystemOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface AntiFreezeSystemOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => AntiFreezeSystemFactoryOptions;
 }
 
 export interface AntiFreezeSystemFactoryOptions {
-    configService: ConfigService;
+  antiFreezeSystemTime: string;
+  antiFreezeSystemCheckCount: number;
 }

package/src/modules/anti-freeze-system/anti-freeze-system.module.ts

@@ -1,55 +1,55 @@
-import { DynamicModule, Global, Inject, Module, Provider } from '@nestjs/common';
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
 import schedule, { Job } from 'node-schedule';
 
-import { JpLoggerService } from '../logger';
-
-import {
-    AntiFreezeSystemFactoryOptions,
-    AntiFreezeSystemOptions,
-} from './anti-freeze-system.interfaces';
 import { AntiFreezeSystemService } from './anti-freeze-system.service';
 import { ANTI_FREEZE_SYSTEM_OPTIONS } from './anti-freeze-system.constants';
+import {
+  AntiFreezeSystemFactoryOptions,
+  AntiFreezeSystemOptions,
+} from './anti-freeze-system.interfaces';
 
 @Global()
 @Module({
-    providers: [
-        AntiFreezeSystemService,
-    ],
+  providers: [AntiFreezeSystemService],
 })
 export class AntiFreezeSystemModule {
-    private antiFreezeSystemJob: Job;
-
-    constructor (
-        private readonly antiFreezeSystemService: AntiFreezeSystemService,
-        @Inject(ANTI_FREEZE_SYSTEM_OPTIONS) private readonly options: AntiFreezeSystemFactoryOptions,
-        @Inject() private readonly logger: JpLoggerService,
-    ) {
-    }
-
-    static forRootAsync (options: AntiFreezeSystemOptions): DynamicModule {
-        return {
-            module: AntiFreezeSystemModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: ANTI_FREEZE_SYSTEM_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
-
-    async onModuleInit () {
-        const antiFreezeSystemTime = this.options.configService.get<string>('ANTI_FREEZE_SYSTEM_TIME');
-        const antiFreezeSystemCheckCount = this.options.configService.get<number>('ANTI_FREEZE_SYSTEM_CHECK_COUNT') || 0;
-
-        if (antiFreezeSystemTime) {
-            this.antiFreezeSystemJob = schedule.scheduleJob(
-                antiFreezeSystemTime,
-                () => this.antiFreezeSystemService.process(antiFreezeSystemCheckCount),
-            );
-        }
+  private antiFreezeSystemJob: Job;
+
+  constructor(
+    private readonly antiFreezeSystemService: AntiFreezeSystemService,
+    @Inject(ANTI_FREEZE_SYSTEM_OPTIONS)
+    private readonly options: AntiFreezeSystemFactoryOptions,
+  ) {}
+
+  static forRootAsync(options: AntiFreezeSystemOptions): DynamicModule {
+    return {
+      module: AntiFreezeSystemModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: ANTI_FREEZE_SYSTEM_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+
+  onModuleInit() {
+    const antiFreezeSystemTime = this.options.antiFreezeSystemTime;
+    const antiFreezeSystemCheckCount = this.options.antiFreezeSystemCheckCount;
+
+    if (antiFreezeSystemTime) {
+      this.antiFreezeSystemJob = schedule.scheduleJob(
+        antiFreezeSystemTime,
+        () => this.antiFreezeSystemService.process(antiFreezeSystemCheckCount),
+      );
     }
+  }
 }
-

package/src/modules/anti-freeze-system/anti-freeze-system.service.ts

@@ -1,94 +1,105 @@
 import { Injectable } from '@nestjs/common';
-import { GameRoom, ManyTablesTournamentRoom, OneTableTournamentRoom, TournamentMaster } from 'jp.ms.common.engine';
+import {
+  GameRoom,
+  ManyTablesTournamentRoom,
+  OneTableTournamentRoom,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
 
 import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
-import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
-import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
+import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
+import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
 
 export interface IRoomSetItem {
-    tableId: string;
-    hash: string;
-    count: number;
-    room: GameRoom;
+  tableId: string;
+  hash: string;
+  count: number;
+  room: GameRoom;
 }
 
 @Injectable()
 export class AntiFreezeSystemService {
-    private prevSet: Map<string, IRoomSetItem>;
+  private prevSet: Map<string, IRoomSetItem>;
 
-    constructor (
-        private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-    ) {
-        this.prevSet = new Map<string, IRoomSetItem>();
-    }
+  constructor(
+    private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
+    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
+    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+  ) {
+    this.prevSet = new Map<string, IRoomSetItem>();
+  }
 
-    process (checkCount: number) {
-        this.mergeSets();
-        this.clear(checkCount);
-    }
+  process(checkCount: number) {
+    this.mergeSets();
+    this.clear(checkCount);
+  }
 
-    private mergeSets () {
-        if (this.prevSet.size === 0) {
-            this.prevSet = this.getCurrentSet();
-        } else {
-            const newSet = new Map();
-            const currentSet = this.getCurrentSet();
+  private mergeSets() {
+    if (this.prevSet.size === 0) {
+      this.prevSet = this.getCurrentSet();
+    } else {
+      const newSet = new Map<string, IRoomSetItem>();
+      const currentSet = this.getCurrentSet();
 
-            currentSet.forEach((currentSetItem, currentSetKey) => {
-                const prevSetItem = this.prevSet.get(currentSetKey);
-                if (prevSetItem && prevSetItem.hash === currentSetItem.hash) {
-                    newSet.set(currentSetKey, {
-                        ...currentSetItem,
-                        count: prevSetItem.count + 1,
-                    });
-                } else {
-                    newSet.set(currentSetKey, currentSetItem);
-                }
-            });
-
-            this.prevSet = newSet;
+      currentSet.forEach((currentSetItem, currentSetKey) => {
+        const prevSetItem = this.prevSet.get(currentSetKey);
+        if (prevSetItem && prevSetItem.hash === currentSetItem.hash) {
+          newSet.set(currentSetKey, {
+            ...currentSetItem,
+            count: prevSetItem.count + 1,
+          });
+        } else {
+          newSet.set(currentSetKey, currentSetItem);
         }
+      });
+
+      this.prevSet = newSet;
     }
+  }
 
-    private getCurrentSet () {
-        const newSet = new Map<string, IRoomSetItem>();
-        const allTables = [
-            ...this.simpleRoomsManagerService.getTables(),
-            ...this.oneTableRoomsManagerService.getTables(),
-            ...this.manyTablesRoomsManagerService.getTables(),
-        ];
+  private getCurrentSet() {
+    const newSet = new Map<string, IRoomSetItem>();
+    const allTables = [
+      ...this.simpleRoomsManagerService.getTables(),
+      ...this.oneTableRoomsManagerService.getTables(),
+      ...this.manyTablesRoomsManagerService.getTables(),
+    ];
 
-        const list: Array<IRoomSetItem> = allTables
-            .filter((item) => item.isInProgress())
-            .map((item) => ({
-                tableId: item.getId(),
-                hash: item.getHash(),
-                count: 0,
-                room: item.getRoom(),
-            }));
+    const list: Array<IRoomSetItem> = allTables
+      .filter((item) => item.isInProgress())
+      .map((item) => ({
+        tableId: item.getId(),
+        hash: item.getHash(),
+        count: 0,
+        room: item.getRoom(),
+      }));
 
-        list.forEach(obj => newSet.set(obj.tableId, obj));
+    list.forEach((obj) => newSet.set(obj.tableId, obj));
 
-        return newSet;
-    }
+    return newSet;
+  }
 
-    private clear (checkCount: number) {
-        this.prevSet.forEach((item) => {
-            if (item.count === checkCount) {
-                if (item.room instanceof OneTableTournamentRoom) {
-                    const room = this.oneTableRoomsManagerService.getRoomByTableId(item.tableId);
-                    room?.getRoomMaster<TournamentMaster>().cancelTournament();
-                } else if (item.room instanceof ManyTablesTournamentRoom) {
-                    const room = this.manyTablesRoomsManagerService.getRoomByTableId(item.tableId)
-                    room?.getRoomMaster<TournamentMaster>().cancelTournament();
-                } else {
-                    this.simpleRoomsManagerService.getRoomByTableId(item.tableId)?.restartTable(item.tableId);
-                }
+  private clear(checkCount: number) {
+    this.prevSet.forEach((item) => {
+      if (item.count === checkCount) {
+        if (item.room instanceof OneTableTournamentRoom) {
+          const room = this.oneTableRoomsManagerService.getRoomByTableId(
+            item.tableId,
+          );
+          room?.getRoomMaster<TournamentMaster>().cancelTournament();
+        } else if (item.room instanceof ManyTablesTournamentRoom) {
+          const room = this.manyTablesRoomsManagerService.getRoomByTableId(
+            item.tableId,
+          );
+          room?.getRoomMaster<TournamentMaster>().cancelTournament();
+        } else {
+          this.simpleRoomsManagerService
+            .getRoomByTableId(item.tableId)
+            ?.restartTable(item.tableId);
+        }
 
-                this.prevSet.delete(item.tableId);
-            }
-        });
-    }
+        this.prevSet.delete(item.tableId);
+      }
+    });
+  }
 }