jp.ms.common.modules 1.0.42 → 1.0.44

package/src/modules/one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service.ts

@@ -2,6 +2,7 @@ import { Inject, Injectable } from '@nestjs/common';
 import {
   BaseGameEvent,
   GameMaster,
+  GamePlayerMovedOnTheTableEvent,
   GameTableFinishedEvent,
   GameTournamentCancelledEvent,
   GameTournamentFinishedEvent,
@@ -17,9 +18,11 @@ import {
   TournamentRoomConfig,
 } from 'jp.ms.common.engine';
 import {
+  ActivityLogRepository,
   GameResultRepository,
   OneTableTournamentRoomDocument,
   OneTableTournamentRoomsRepository,
+  RatingRepository,
   UsersRepository,
 } from 'jp.db.schemas';
 import { InjectConnection } from '@nestjs/mongoose';
@@ -27,32 +30,34 @@ import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
 import {
-  saveGameTablesResult,
-  saveTournamentResult,
-} from '../../utils/game-table-result';
-import {
+  EventsBusAppSubscribeService,
   EventsBusMainTablesSubscribeService,
   EventsBusOneTableTournamentSubscribeService,
 } from '../event-bus';
+import { TournamentRoomsManagerService } from '../../common/tournament-rooms-manager.service';
 
 import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tournament-rooms-manager.constants';
 import { OneTableTournamentRoomsFactoryOptions } from './one-table-tournament-rooms-manager.interfaces';
 
 @Injectable()
-export class OneTableTournamentRoomsManagerService {
+export class OneTableTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, OneTableTournamentRoom>;
 
   constructor(
     private readonly tournamentRepository: OneTableTournamentRoomsRepository,
     private readonly usersRepository: UsersRepository,
     private readonly gameResultRepository: GameResultRepository,
+    private readonly ratingRepository: RatingRepository,
+    private readonly activityLogRepository: ActivityLogRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     @Inject(ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
     private readonly options: OneTableTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
+    super();
     this.rooms = new Map<string, OneTableTournamentRoom>();
   }
 
@@ -117,6 +122,7 @@ export class OneTableTournamentRoomsManagerService {
       rulesType: tournamentDocument.rulesType,
       deckType: tournamentDocument.deckType,
       tableSize: tournamentDocument.tableSize,
+      tableType: tournamentDocument.tableType,
       bet: tournamentDocument.bet,
       ticketPrice: tournamentDocument.ticketPrice,
       title: tournamentDocument.title,
@@ -140,41 +146,67 @@ export class OneTableTournamentRoomsManagerService {
   private handleRoomEvent = (event: BaseGameEvent) => {
     this.logger.log(event.toLog());
 
-    if (event instanceof GameTableFinishedEvent) {
-      void this.handleRoomTableGameFinished(event.master);
-    } else if (event instanceof GameTournamentStartedEvent) {
-      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentCancelledEvent) {
-      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentFinishedEvent) {
-      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
-    } else if (
-      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
-      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
-      event instanceof GameTournamentCancelledEvent ||
-      event instanceof GameTournamentWaitedEvent ||
-      event instanceof GameTournamentStartedEvent ||
-      event instanceof GameTournamentFinishedEvent
-    ) {
-      void this.handleRoomStatusUpdated(
-        new RoomUpdateStateEvent(event.gameType, event.roomId),
-      );
+    switch (event.constructor.name) {
+      case GameTableFinishedEvent.name: {
+        void this.handleRoomTableGameFinished(
+          event as GameTableFinishedEvent,
+          this.connection,
+          this.gameResultRepository,
+          this.usersRepository,
+          this.activityLogRepository,
+          this.eventsBusAppSubscribeService,
+          this.options.levelUpBonus,
+        );
+        break;
+      }
+      case GamePlayerMovedOnTheTableEvent.name: {
+        this.handleRoomTableGamePlayerMoved(
+          event as GamePlayerMovedOnTheTableEvent,
+          this.eventsBusAppSubscribeService,
+        );
+        break;
+      }
+      case GameTournamentStartedEvent.name: {
+        void this.handleTournamentRoomStarted(
+          event as GameTournamentStartedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentStartedEvent);
+        break;
+      }
+      case GameTournamentCancelledEvent.name: {
+        void this.handleTournamentRoomCancelled(
+          event as GameTournamentCancelledEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentCancelledEvent);
+        break;
+      }
+      case GameTournamentFinishedEvent.name: {
+        void this.handleTournamentRoomFinished(
+          event as GameTournamentFinishedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
+        break;
+      }
+      case GameTournamentPlayerJoinedTheTournamentEvent.name:
+      case GameTournamentPlayerLeavedTheTournamentEvent.name:
+      case GameTournamentWaitedEvent.name: {
+        this.handleRoomStatusUpdated(
+          event as
+            | GameTournamentPlayerJoinedTheTournamentEvent
+            | GameTournamentPlayerLeavedTheTournamentEvent
+            | GameTournamentCancelledEvent,
+        );
+        break;
+      }
     }
   };
 
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResult(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-      false,
-    );
-  };
-
-  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+  private handleTournamentRoomStarted = async (
+    event: GameTournamentStartedEvent,
+  ) => {
     const session = await this.connection.startSession();
     session.startTransaction();
+    const master = event.room.getRoomMaster<TournamentMaster>();
 
     try {
       await this.tournamentRepository.startTournament(
@@ -200,21 +232,40 @@ export class OneTableTournamentRoomsManagerService {
     }
   };
 
-  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+  private handleTournamentRoomCancelled = async (
+    event: GameTournamentCancelledEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-    await saveTournamentResult(
+  private handleTournamentRoomFinished = async (
+    event: GameTournamentFinishedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
+
+    await this.saveTournamentResult(
       master,
       this.connection,
       this.tournamentRepository,
       this.usersRepository,
+      this.ratingRepository,
     );
   };
 
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
+  private handleRoomStatusUpdated = (
+    event:
+      | GameTournamentPlayerJoinedTheTournamentEvent
+      | GameTournamentPlayerLeavedTheTournamentEvent
+      | GameTournamentCancelledEvent
+      | GameTournamentWaitedEvent
+      | GameTournamentStartedEvent
+      | GameTournamentFinishedEvent,
+  ) => {
+    const updateEvent = new RoomUpdateStateEvent(event.gameType, event.roomId);
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(updateEvent);
+    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(
+      updateEvent,
+    );
   };
 }

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

@@ -23,4 +23,5 @@ export interface SimpleRoomsFactoryOptions {
   restartGameTimeout: number;
   playersTurnTimeout: number;
   instantFinishMode: boolean;
+  levelUpBonus: number;
 }

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

@@ -10,6 +10,12 @@ import {
   GameResult,
   GameResultSchema,
   GameResultRepository,
+  Rating,
+  RatingSchema,
+  RatingRepository,
+  ActivityLog,
+  ActivityLogSchema,
+  ActivityLogRepository,
 } from 'jp.db.schemas';
 
 import { SimpleRoomsManagerService } from './simple-rooms-manager.service';
@@ -26,11 +32,17 @@ import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
     MongooseModule.forFeature([
       { name: GameResult.name, schema: GameResultSchema },
     ]),
+    MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     SimpleRoomsRepository,
     UsersRepository,
     GameResultRepository,
+    RatingRepository,
+    ActivityLogRepository,
     SimpleRoomsManagerService,
   ],
   exports: [SimpleRoomsManagerService],

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

@@ -8,35 +8,41 @@ import {
   SimpleRoom,
   GameRoomConfig,
   RoomUpdateStateEvent,
-  UserWonTheGameAppEvent,
   GameTableFinishedEvent,
   GamePlayerEnteredTheTableEvent,
   GamePlayerExitedTheTableEvent,
   LocalService,
+  GamePlayerMovedOnTheTableEvent,
 } from 'jp.ms.common.engine';
 import {
+  ActivityLogRepository,
   GameResultRepository,
+  RatingRepository,
   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 {
+  EventsBusMainTablesSubscribeService,
+  EventsBusAppSubscribeService,
+} from '../event-bus';
+import { RoomsManagerService } from '../../common/rooms-manager.service';
 
 import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 import { SimpleRoomsFactoryOptions } from './simple-rooms-manager.interfaces';
 
 @Injectable()
-export class SimpleRoomsManagerService {
+export class SimpleRoomsManagerService extends RoomsManagerService {
   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 activityLogRepository: ActivityLogRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS)
@@ -44,6 +50,7 @@ export class SimpleRoomsManagerService {
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
+    super();
     this.rooms = new Map<string, SimpleRoom>();
   }
 
@@ -87,11 +94,11 @@ export class SimpleRoomsManagerService {
   }
 
   /*
-        1. Сначала ищем стол в котором один игрок
-        2. Далее ищем стол за которым есть игроки и свободные места
-        3. Отправляем на стол для быстрой игры если там есть места
-        4. Наконец создаем стол для быстрой игры и отправляем туда
-    */
+    1. Сначала ищем стол в котором один игрок
+    2. Далее ищем стол за которым есть игроки и свободные места
+    3. Отправляем на стол для быстрой игры если там есть места
+    4. Наконец создаем стол для быстрой игры и отправляем туда
+  */
   getFreeFastGameRoom(): GameMaster | undefined {
     if (this.getRooms().some((item) => item.isTechBreak())) {
       return;
@@ -139,6 +146,7 @@ export class SimpleRoomsManagerService {
       rulesType: room.rulesType,
       deckType: room.deckType,
       tableSize: room.tableSize,
+      tableType: room.tableType,
       bet: room.bet,
       ticketPrice: room.ticketPrice / 2,
       title: room.title,
@@ -157,34 +165,74 @@ export class SimpleRoomsManagerService {
   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),
-      );
+    switch (event.constructor.name) {
+      case GameTableFinishedEvent.name: {
+        void this.handleRoomTableGameFinished(event as GameTableFinishedEvent);
+        break;
+      }
+      case GamePlayerMovedOnTheTableEvent.name: {
+        this.handleRoomTableGamePlayerMoved(
+          event as GamePlayerMovedOnTheTableEvent,
+          this.eventsBusAppSubscribeService,
+        );
+        break;
+      }
+      case GamePlayerEnteredTheTableEvent.name:
+      case GamePlayerExitedTheTableEvent.name: {
+        this.handleRoomStatusUpdated(
+          event as
+          GamePlayerExitedTheTableEvent | GamePlayerEnteredTheTableEvent,
+        );
+        break;
+      }
     }
   };
 
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResult(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-      true,
-    );
+  private handleRoomTableGameFinished = async (
+    event: GameTableFinishedEvent,
+  ) => {
+    await this.saveGameTableReuslts(event);
+    this.processGameFinishEvent(event, this.eventsBusAppSubscribeService);
+  };
 
-    // TODO: записать разные события для достижений
-    this.eventsBusAppSubscribeService.pushNewEvent(
-      new UserWonTheGameAppEvent(this.gameType, '123'),
+  private handleRoomStatusUpdated = (
+    event: GamePlayerEnteredTheTableEvent | GamePlayerExitedTheTableEvent,
+  ) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(
+      new RoomUpdateStateEvent(event.gameType, event.roomId),
     );
   };
 
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-  };
+  private async saveGameTableReuslts(event: GameTableFinishedEvent) {
+    const session = await this.connection.startSession();
+    session.startTransaction();
+    const master = event.master;
+
+    try {
+      await this.gameResultRepository.createGameResult(
+        this.getGameTableResults(master),
+      );
+      const userGameResults = this.getUserGameResults(master, false);
+      await this.usersRepository.saveGameResult(userGameResults);
+      await this.ratingRepository.addBulkPlayerRating(
+        this.getUserRatings(master),
+      );
+      await this.activityLogRepository.addGameTableResult(
+        this.getGameTableActivityLogResult(master),
+      );
+      this.commitExperience(
+        master,
+        userGameResults,
+        event,
+        this.eventsBusAppSubscribeService,
+        this.options.levelUpBonus,
+      );
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
 }

package/src/views/achievement-snackbar.view.ts

@@ -0,0 +1,38 @@
+import { randomUUID } from 'crypto';
+import {
+  AppScreenSnackbarIdEnum,
+  ILocaleService,
+  AchievementSnackbarComponent,
+  UniversalScreenSnackbarView,
+} from 'jp.common.models';
+import { formatChips } from 'jp.common.utils';
+import { Achievement } from 'jp.db.schemas';
+
+export class AchievementSnackbarView extends UniversalScreenSnackbarView {
+  private achievement: Achievement;
+  private bonus: number;
+
+  constructor(
+    localeService: ILocaleService,
+    lang: string,
+    achievement: Achievement,
+    bonus: number,
+  ) {
+    super(localeService, lang);
+    this.achievement = achievement;
+    this.bonus = bonus;
+  }
+
+  build() {
+    return new AchievementSnackbarComponent(
+      `${AppScreenSnackbarIdEnum.SNACKBAR_ACHIEVEMENT}_${randomUUID()}`,
+      this.localeService.t('common.server.message.code.4011', {
+        lang: this.lang,
+        args: {
+          TITLE: this.getDbResource(this.achievement.title),
+          PRIZE: formatChips(this.bonus, this.lang, true),
+        },
+      }),
+    );
+  }
+}

package/src/views/base-table.view.ts

@@ -0,0 +1,57 @@
+import {
+  IAppScreenDialog,
+  ILocaleService,
+  UniversalView,
+} from 'jp.common.models';
+import { GameMaster, GamePlayer } from 'jp.ms.common.engine';
+
+export abstract class BaseTableView extends UniversalView {
+  abstract getConfirmExitDialog(): IAppScreenDialog | undefined;
+
+  protected ROUND_TABLE_TARGET_SEAT_MAPPING: Record<number, number> = {
+    2: 1,
+    3: 2,
+    4: 2,
+    5: 2,
+    6: 3,
+  };
+
+  protected readonly gameMaster: GameMaster;
+  protected readonly gamePlayer: GamePlayer;
+
+  constructor(
+    localeService: ILocaleService,
+    lang: string,
+    gameMaster: GameMaster,
+    gamePlayer: GamePlayer,
+  ) {
+    super(localeService, lang);
+    this.gameMaster = gameMaster;
+    this.gamePlayer = gamePlayer;
+  }
+
+  protected getGameMaster<T extends GameMaster>(): T {
+    return this.gameMaster as T;
+  }
+
+  protected getGamePlayer<T extends GamePlayer>(): T {
+    return this.gamePlayer as T;
+  }
+
+  protected getSeatShift(): number {
+    return (
+      this.gameMaster.table.seats.getShift(
+        this.gamePlayer.seatNumber,
+        this.getTargetSeat(),
+      ) ?? 0
+    );
+  }
+
+  protected getTargetSeat(): number {
+    return (
+      this.ROUND_TABLE_TARGET_SEAT_MAPPING[
+        this.gameMaster.room.getTableSize()
+      ] ?? 0
+    );
+  }
+}

package/src/views/index.ts

@@ -3,3 +3,6 @@ export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dial
 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 { AchievementSnackbarView } from './achievement-snackbar.view';
+export { LevelUpSnackbarView } from './level-up-snackbar.view';
+export { BaseTableView } from './base-table.view';

package/src/views/level-up-snackbar.view.ts

@@ -0,0 +1,38 @@
+import { randomUUID } from 'crypto';
+import {
+  AppScreenSnackbarIdEnum,
+  IAppScreenSnackbar,
+  ILocaleService,
+  LevelUpSnackbarComponent,
+  UniversalScreenSnackbarView,
+} from 'jp.common.models';
+import { formatChips } from 'jp.common.utils';
+
+export class LevelUpSnackbarView extends UniversalScreenSnackbarView {
+  private newLevel: number;
+  private bonus: number;
+
+  constructor(
+    localeService: ILocaleService,
+    lang: string,
+    newLevel: number,
+    bonus: number,
+  ) {
+    super(localeService, lang);
+    this.newLevel = newLevel;
+    this.bonus = bonus;
+  }
+
+  build(): IAppScreenSnackbar {
+    return new LevelUpSnackbarComponent(
+      `${AppScreenSnackbarIdEnum.SNACKBAR_LEVEL_UP}_${randomUUID()}`,
+      this.localeService.t('common.server.message.code.4010', {
+        lang: this.lang,
+        args: {
+          NEW_LEVEL: this.newLevel.toString(),
+          BONUS: formatChips(this.bonus, this.lang, true),
+        },
+      }),
+    );
+  }
+}

package/dist/utils/date.d.ts

@@ -1,2 +0,0 @@
-export declare function getHours(timeStr: string): number;
-export declare function getMinutes(timeStr: string): number;

package/dist/utils/date.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHours = getHours;
-exports.getMinutes = getMinutes;
-function getHours(timeStr) {
-    return parseInt(timeStr.substring(0, 2), 10);
-}
-function getMinutes(timeStr) {
-    return parseInt(timeStr.substring(3, 5), 10);
-}
-//# sourceMappingURL=date.js.map

package/dist/utils/date.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.js","sourceRoot":"","sources":["../../src/utils/date.ts"],"names":[],"mappings":";;AAAA,4BAEC;AAED,gCAEC;AAND,SAAgB,QAAQ,CAAC,OAAe;IACtC,OAAO,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/C,CAAC;AAED,SAAgB,UAAU,CAAC,OAAe;IACxC,OAAO,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/C,CAAC"}

package/dist/utils/game-table-result.d.ts

@@ -1,39 +0,0 @@
-import { Connection } from 'mongoose';
-import { GameResultRepository, OneTableTournamentRoomsRepository, ManyTablesTournamentRoomsRepository, UsersRepository } from 'jp.db.schemas';
-import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
-export declare function getGameTableResults(master: GameMaster): {
-    gameType: string;
-    gameId: string;
-    roomId: string;
-    date: Date;
-    pot: number;
-    players: {
-        userId: string;
-        fullName: string;
-        profit: number;
-        figures: never[];
-    }[];
-    winners: {
-        userId: string;
-        fullName: string;
-        profit: number;
-        figures: never[];
-    }[];
-    history: {
-        userId: string;
-        fullName: string;
-        date: Date;
-        actionType: string;
-        state: string;
-        turnNumber: number;
-        moveAction: string | undefined;
-        moveData: import("jp.ms.common.engine").BaseMoveData | undefined;
-        figures: {
-            figureId: number;
-            type: string;
-            name: string;
-        }[];
-    }[];
-};
-export declare function saveGameTablesResult(master: GameMaster, connection: Connection, gameResultRepository: GameResultRepository, usersRepository: UsersRepository, saveNewBalance: boolean): Promise<void>;
-export declare function saveTournamentResult(master: TournamentMaster, connection: Connection, tournamentRepository: OneTableTournamentRoomsRepository | ManyTablesTournamentRoomsRepository, usersRepository: UsersRepository): Promise<void>;