jp.ms.common.modules 1.0.41 → 1.0.43

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

@@ -1,16 +1,16 @@
-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 SupportFactoryOptions {
-  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 SupportFactoryOptions {
+  prometheusNameApp: string;
+}

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

@@ -1,35 +1,35 @@
-import { DynamicModule, Module, Provider } from '@nestjs/common';
-
-import { SupportController } from './support.controller';
-import { SupportService } from './support.service';
-import { SupportOptions } from './support.interfaces';
-import { SUPPORT_OPTIONS } from './support.constants';
-import { MetricService } from './metric.service';
-import { DumpService } from './dump.service';
-
-@Module({
-  controllers: [SupportController],
-  providers: [SupportService, MetricService, DumpService],
-})
-export class SupportModule {
-  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,
-      ],
-    };
-  }
-}
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+
+import { SupportController } from './support.controller';
+import { SupportService } from './support.service';
+import { SupportOptions } from './support.interfaces';
+import { SUPPORT_OPTIONS } from './support.constants';
+import { MetricService } from './metric.service';
+import { DumpService } from './dump.service';
+
+@Module({
+  controllers: [SupportController],
+  providers: [SupportService, MetricService, DumpService],
+})
+export class SupportModule {
+  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

@@ -1,27 +1,27 @@
-import { Injectable } from '@nestjs/common';
-
-import { PlayersManagerService } from '../players-manager/players-manager.service';
-import { PlayerConnectedDto } from '../../dto/common/player-connected.dto';
-import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
-
-@Injectable()
-export class SupportService {
-  constructor(
-    private readonly playersManager: PlayersManagerService,
-    private readonly simpleRoomsManager: SimpleRoomsManagerService,
-  ) {}
-
-  getUsers(): Array<PlayerConnectedDto> {
-    return this.playersManager
-      .getPlayers()
-      .map((item) => PlayerConnectedDto.fromEntities(item));
-  }
-
-  techBreakOn(): boolean {
-    this.simpleRoomsManager
-      .getRooms()
-      .forEach((item) => item.handleTechBreakOn());
-
-    return true;
-  }
-}
+import { Injectable } from '@nestjs/common';
+
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { PlayerConnectedDto } from '../../dto/common/player-connected.dto';
+import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
+
+@Injectable()
+export class SupportService {
+  constructor(
+    private readonly playersManager: PlayersManagerService,
+    private readonly simpleRoomsManager: SimpleRoomsManagerService,
+  ) {}
+
+  getUsers(): Array<PlayerConnectedDto> {
+    return this.playersManager
+      .getPlayers()
+      .map((item) => PlayerConnectedDto.fromEntities(item));
+  }
+
+  techBreakOn(): boolean {
+    this.simpleRoomsManager
+      .getRooms()
+      .forEach((item) => item.handleTechBreakOn());
+
+    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 getMinutes(timeStr: string) {
-  return parseInt(timeStr.substring(3, 5), 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);
+}

package/src/utils/game-table-result.ts

@@ -1,129 +1,190 @@
-import { Connection } from 'mongoose';
-import {
-  GameResultRepository,
-  OneTableTournamentRoomsRepository,
-  ManyTablesTournamentRoomsRepository,
-  UsersRepository,
-} from 'jp.db.schemas';
-import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
-
-export function getGameTableResults(master: GameMaster) {
-  return {
-    gameType: master.getRoom().getGameType(),
-    gameId: master.getGameRound()?.getId() ?? '',
-    roomId: master.getRoom().getId(),
-    date: new Date(),
-    pot: master.getGameRound()?.getPot() ?? 0,
-    players: master
-      .getTable()
-      .getPlayers()
-      .map((item) => ({
-        userId: item.id,
-        fullName: item.fullName,
-        profit: item.profit,
-        figures: [],
-      })),
-    winners: master
-      .getGameResultHelper()
-      .getWinners()
-      .map((item) => ({
-        userId: item.id,
-        fullName: item.fullName,
-        profit: item.profit,
-        figures: [],
-      })),
-    history:
-      master
-        .getGameRound()
-        ?.getHistory()
-        .map((item) => ({
-          userId: item.userId,
-          fullName: item.fullName,
-          date: item.date,
-          actionType: item.actionType,
-          state: item.state,
-          turnNumber: item.turnNumber,
-          moveAction: item.move?.action,
-          moveData: item.move ?? undefined,
-          figures:
-            item.figures?.map((item) => ({
-              figureId: item.id,
-              type: item.type,
-              name: item.getName(),
-            })) ?? [],
-        })) ?? [],
-  };
-}
-
-export async function saveGameTablesResult(
-  master: GameMaster,
-  connection: Connection,
-  gameResultRepository: GameResultRepository,
-  usersRepository: UsersRepository,
-  saveNewBalance: boolean,
-) {
-  const userGameResult = master
-    .getTable()
-    .getPlayers()
-    .map((player) => {
-      return {
-        userId: player.id,
-        balanceAdding: saveNewBalance ? player.profit : 0,
-        experienceAdding: master.levelHelper.getNewExperienceAmount(player),
-        levelAdding: master.levelHelper.getNewLevelAdding(
-          player.level,
-          player.experience,
-        ),
-      };
-    });
-
-  const session = await connection.startSession();
-  session.startTransaction();
-
-  try {
-    await gameResultRepository.createGameResult(getGameTableResults(master));
-    await usersRepository.saveGameResult(userGameResult);
-
-    await session.commitTransaction();
-  } catch (error) {
-    await session.abortTransaction();
-    throw error;
-  } finally {
-    await session.endSession();
-  }
-}
-
-export async function saveTournamentResult(
-  master: TournamentMaster,
-  connection: Connection,
-  tournamentRepository:
-    | OneTableTournamentRoomsRepository
-    | ManyTablesTournamentRoomsRepository,
-  usersRepository: UsersRepository,
-) {
-  const userTournamentResult = master.getTournamentResult().map((player) => {
-    return {
-      userId: player.playerId,
-      balanceAdding: player.profit,
-      experienceAdding: 0,
-      levelAdding: 0,
-    };
-  });
-
-  const session = await connection.startSession();
-  session.startTransaction();
-
-  try {
-    await usersRepository.saveGameResult(userTournamentResult);
-    await tournamentRepository.finishTournament(
-      master.getTournamentId(),
-      master.getTournamentResult(),
-    );
-    await session.commitTransaction();
-  } catch (error) {
-    await session.abortTransaction();
-    throw error;
-  } finally {
-    await session.endSession();
-  }
-}
+import { Connection } from 'mongoose';
+import {
+  GameResultRepository,
+  OneTableTournamentRoomsRepository,
+  ManyTablesTournamentRoomsRepository,
+  UsersRepository,
+  RatingRepository,
+} from 'jp.db.schemas';
+import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
+
+export function getGameTableResults(master: GameMaster) {
+  return {
+    gameType: master.getRoom().getGameType(),
+    gameId: master.getGameRound()?.getId() ?? '',
+    roomId: master.getRoom().getId(),
+    date: new Date(),
+    pot: master.getGameRound()?.getPot() ?? 0,
+    players: master
+      .getTable()
+      .getPlayers()
+      .map((item) => ({
+        userId: item.id,
+        fullName: item.fullName,
+        profit: item.profit,
+        figures: [],
+      })),
+    winners: master
+      .getGameResultHelper()
+      .getWinners()
+      .map((item) => ({
+        userId: item.id,
+        fullName: item.fullName,
+        profit: item.profit,
+        figures: [],
+      })),
+    history:
+      master
+        .getGameRound()
+        ?.getHistory()
+        .map((item) => ({
+          userId: item.userId,
+          fullName: item.fullName,
+          date: item.date,
+          actionType: item.actionType,
+          state: item.state,
+          turnNumber: item.turnNumber,
+          moveAction: item.move?.action,
+          moveData: item.move ?? undefined,
+          figures:
+            item.figures?.map((item) => ({
+              figureId: item.id,
+              type: item.type,
+              name: item.getName(),
+            })) ?? [],
+        })) ?? [],
+  };
+}
+
+export async function saveGameTablesResultForSimpleRoom(
+  master: GameMaster,
+  connection: Connection,
+  gameResultRepository: GameResultRepository,
+  usersRepository: UsersRepository,
+  ratingRepository: RatingRepository,
+) {
+  const userGameResult = master
+    .getTable()
+    .getPlayers()
+    .map((player) => {
+      return {
+        userId: player.id,
+        userName: player.fullName,
+        userAvatarUrl: player.avatarUrl,
+        balanceAdding: player.profit,
+        experienceAdding: master.levelHelper.getNewExperienceAmount(player),
+        levelAdding: master.levelHelper.getNewLevelAdding(
+          player.level,
+          player.experience,
+        ),
+      };
+    });
+
+  const ratings = userGameResult.map((item) => ({
+    userId: item.userId,
+    userName: item.userName,
+    userAvatarUrl: item.userAvatarUrl,
+    profit: item.balanceAdding,
+    game: master.getRoom().getGameType(),
+  }));
+
+  const session = await connection.startSession();
+  session.startTransaction();
+
+  try {
+    await gameResultRepository.createGameResult(getGameTableResults(master));
+    await usersRepository.saveGameResult(userGameResult);
+    await ratingRepository.addBulkPlayerRating(ratings);
+
+    await session.commitTransaction();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    await session.endSession();
+  }
+}
+
+export async function saveGameTablesResultForTournamentRoom(
+  master: GameMaster,
+  connection: Connection,
+  gameResultRepository: GameResultRepository,
+  usersRepository: UsersRepository,
+) {
+  const userGameResult = master
+    .getTable()
+    .getPlayers()
+    .map((player) => {
+      return {
+        userId: player.id,
+        userName: player.fullName,
+        userAvatarUrl: player.avatarUrl,
+        balanceAdding: 0,
+        experienceAdding: master.levelHelper.getNewExperienceAmount(player),
+        levelAdding: master.levelHelper.getNewLevelAdding(
+          player.level,
+          player.experience,
+        ),
+      };
+    });
+
+  const session = await connection.startSession();
+  session.startTransaction();
+
+  try {
+    await gameResultRepository.createGameResult(getGameTableResults(master));
+    await usersRepository.saveGameResult(userGameResult);
+    await session.commitTransaction();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    await session.endSession();
+  }
+}
+
+export async function saveTournamentResult(
+  master: TournamentMaster,
+  connection: Connection,
+  tournamentRepository:
+    OneTableTournamentRoomsRepository | ManyTablesTournamentRoomsRepository,
+  usersRepository: UsersRepository,
+  ratingRepository: RatingRepository,
+) {
+  const userTournamentResult = master.getTournamentResult().map((player) => {
+    return {
+      userId: player.playerId,
+      userName: player.playerName,
+      userAvatarUrl: player.playerAvatarUrl,
+      balanceAdding: player.profit,
+      experienceAdding: 0,
+      levelAdding: 0,
+    };
+  });
+
+  const ratings = userTournamentResult.map((item) => ({
+    userId: item.userId,
+    userName: item.userName,
+    userAvatarUrl: item.userAvatarUrl,
+    profit: item.balanceAdding,
+    game: master.getRoom().getGameType(),
+  }));
+
+  const session = await connection.startSession();
+  session.startTransaction();
+
+  try {
+    await usersRepository.saveGameResult(userTournamentResult);
+    await tournamentRepository.finishTournament(
+      master.getTournamentId(),
+      master.getTournamentResult(),
+    );
+    await ratingRepository.addBulkPlayerRating(ratings);
+    await session.commitTransaction();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    await session.endSession();
+  }
+}

package/src/views/index.ts

@@ -1,5 +1,5 @@
-export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';
-export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dialog.view';
-export { ManyTablesTournamentConfirmExitDialogView } from './many-tables-tournament-conifrm-exit-dialog.view';
-export { OneTableTournamentConfirmExitDialogView } from './one-table-tournament-conifrm-exit-dialog.view';
-export { TableSummaryView } from './table-summary.view';
+export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';
+export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dialog.view';
+export { ManyTablesTournamentConfirmExitDialogView } from './many-tables-tournament-conifrm-exit-dialog.view';
+export { OneTableTournamentConfirmExitDialogView } from './one-table-tournament-conifrm-exit-dialog.view';
+export { TableSummaryView } from './table-summary.view';

package/src/views/many-tables-tournament-conifrm-exit-dialog.view.ts

@@ -1,37 +1,37 @@
-import {
-  UniversalScreenDialogView,
-  AppScreenDialogIdEnum,
-  StandardDialogComponent,
-  FullButtonsButtonsComponent,
-  TextButtonComponent,
-} from 'jp.common.models';
-
-export class ManyTablesTournamentConfirmExitDialogView extends UniversalScreenDialogView {
-  build() {
-    return new StandardDialogComponent(
-      AppScreenDialogIdEnum.DIALOG_MANY_TABLES_TOURNAMENT_CONFIRM_EXIT,
-      this.localeService.t(
-        'common.many.tables.tournament.screen.dialog.confirm.exit.game.title',
-        { lang: this.lang },
-      ),
-      this.localeService.t(
-        'common.many.tables.tournament.screen.dialog.confirm.exit.game.message',
-        { lang: this.lang },
-      ),
-      new FullButtonsButtonsComponent(
-        new TextButtonComponent(
-          this.localeService.t(
-            'common.many.tables.tournament.screen.dialog.confirm.exit.game.ok',
-            { lang: this.lang },
-          ),
-        ),
-        new TextButtonComponent(
-          this.localeService.t(
-            'common.many.tables.tournament.screen.dialog.confirm.exit.game.cancel',
-            { lang: this.lang },
-          ),
-        ),
-      ),
-    );
-  }
-}
+import {
+  UniversalScreenDialogView,
+  AppScreenDialogIdEnum,
+  StandardDialogComponent,
+  FullButtonsButtonsComponent,
+  TextButtonComponent,
+} from 'jp.common.models';
+
+export class ManyTablesTournamentConfirmExitDialogView extends UniversalScreenDialogView {
+  build() {
+    return new StandardDialogComponent(
+      AppScreenDialogIdEnum.DIALOG_MANY_TABLES_TOURNAMENT_CONFIRM_EXIT,
+      this.localeService.t(
+        'common.many.tables.tournament.screen.dialog.confirm.exit.game.title',
+        { lang: this.lang },
+      ),
+      this.localeService.t(
+        'common.many.tables.tournament.screen.dialog.confirm.exit.game.message',
+        { lang: this.lang },
+      ),
+      new FullButtonsButtonsComponent(
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.many.tables.tournament.screen.dialog.confirm.exit.game.ok',
+            { lang: this.lang },
+          ),
+        ),
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.many.tables.tournament.screen.dialog.confirm.exit.game.cancel',
+            { lang: this.lang },
+          ),
+        ),
+      ),
+    );
+  }
+}

package/src/views/one-table-tournament-conifrm-exit-dialog.view.ts

@@ -1,37 +1,37 @@
-import {
-  UniversalScreenDialogView,
-  AppScreenDialogIdEnum,
-  StandardDialogComponent,
-  FullButtonsButtonsComponent,
-  TextButtonComponent,
-} from 'jp.common.models';
-
-export class OneTableTournamentConfirmExitDialogView extends UniversalScreenDialogView {
-  build() {
-    return new StandardDialogComponent(
-      AppScreenDialogIdEnum.DIALOG_ONE_TABLE_TOURNAMENT_CONFIRM_EXIT,
-      this.localeService.t(
-        'common.one.table.tournament.screen.dialog.confirm.exit.game.title',
-        { lang: this.lang },
-      ),
-      this.localeService.t(
-        'common.one.table.tournament.screen.dialog.confirm.exit.game.message',
-        { lang: this.lang },
-      ),
-      new FullButtonsButtonsComponent(
-        new TextButtonComponent(
-          this.localeService.t(
-            'common.one.table.tournament.screen.dialog.confirm.exit.game.ok',
-            { lang: this.lang },
-          ),
-        ),
-        new TextButtonComponent(
-          this.localeService.t(
-            'common.one.table.tournament.screen.dialog.confirm.exit.game.cancel',
-            { lang: this.lang },
-          ),
-        ),
-      ),
-    );
-  }
-}
+import {
+  UniversalScreenDialogView,
+  AppScreenDialogIdEnum,
+  StandardDialogComponent,
+  FullButtonsButtonsComponent,
+  TextButtonComponent,
+} from 'jp.common.models';
+
+export class OneTableTournamentConfirmExitDialogView extends UniversalScreenDialogView {
+  build() {
+    return new StandardDialogComponent(
+      AppScreenDialogIdEnum.DIALOG_ONE_TABLE_TOURNAMENT_CONFIRM_EXIT,
+      this.localeService.t(
+        'common.one.table.tournament.screen.dialog.confirm.exit.game.title',
+        { lang: this.lang },
+      ),
+      this.localeService.t(
+        'common.one.table.tournament.screen.dialog.confirm.exit.game.message',
+        { lang: this.lang },
+      ),
+      new FullButtonsButtonsComponent(
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.one.table.tournament.screen.dialog.confirm.exit.game.ok',
+            { lang: this.lang },
+          ),
+        ),
+        new TextButtonComponent(
+          this.localeService.t(
+            'common.one.table.tournament.screen.dialog.confirm.exit.game.cancel',
+            { lang: this.lang },
+          ),
+        ),
+      ),
+    );
+  }
+}