jp.ms.common.modules 1.0.20 → 1.0.21

package/src/modules/many-tables-tournament/many-tables-tournament.service.ts

@@ -1,17 +1,8 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    AppScreen,
-    AppScreenAppBar,
-    AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     BaseAppScreen,
     IBaseMoveData,
     IBaseTableGameState,
-    AppScreenIconEnum,
-    AppScreenSectionButtons,
     router,
 } from 'jp.common.models';
 
@@ -24,85 +15,77 @@ import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tour
 
 import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
 import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+import { ManyTablesTournamentStatusScreenView } from './many-tables-tournament-status-screen.view';
+import { ManyTablesTournamentTablesListScreenView } from './many-tables-tournament-tables-list-screen.view';
 
 @Injectable()
 export class ManyTablesTournamentService {
-    constructor (
+    constructor(
         private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
         private readonly playersManager: PlayersManagerService,
         @Inject(MANY_TABLES_TOURNAMENT_OPTIONS) private readonly options: ManyTablesTournamentFactoryOptions,
     ) {
     }
 
-    async getStatusScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
         const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
         if (!tournament) {
             throw new InternalServerErrorException();
         }
 
-        const screen =
-            AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
-                .addAppBar(
-                    AppScreenAppBar.CreateStatusAppBar(
-                        this.options.i18n.t('common.rooms.screen.title', { lang }),
-                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
-                    ),
-                )
-                .addSection((
-                    AppScreenSection.CreateStatusHeader(
-                        'status',
-                        'description',
-                        AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                        AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
-                    )
-                ))
-                .addSection(
-                    AppScreenSection.CreateCardListSection(
-                        'id1',
-                        tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
-                            item.playerId,
-                            item.playerName,
-                            '',
-                            AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
-                            true,
-                            '',
-                        ))
-                    ),
-                );
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new ManyTablesTournamentStatusScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
+    }
+
+    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.addToStatusScreenWatchers(player);
+        }
 
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+        throw new InternalServerErrorException();
     }
 
-    async getTableListScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
-        const screen =
-            AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
-                .addAppBar(
-                    AppScreenAppBar.CreateStandardAppBar(
-                        this.options.i18n.t('common.rooms.screen.title', { lang }),
-                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
-                    ),
-                )
-                .addSection(
-                    AppScreenSection.CreateCardListSection(
-                        'id1',
-                        this.manyTablesRoomsManagerService.getRoomById(tournamentId)?.getTables().map((table) =>
-                            AppScreenSectionListItem.CreateCardListItemMini(
-                                table.getId(),
-                                table.getTitle(lang),
-                                table.getSubtitle(lang),
-                                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                                true,
-                                router.getRoomPath(table.getId()),
-                            )
-                        ) ?? []
-                    ),
-                );
+    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.removeFromStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
 
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    async getTableListScreen(tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new ManyTablesTournamentTablesListScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    watchTheTable(tableId: string, clientAuthToken: string): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -116,7 +99,7 @@ export class ManyTablesTournamentService {
         throw new InternalServerErrorException();
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+    moveOnTheTable(tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -130,7 +113,7 @@ export class ManyTablesTournamentService {
         throw new InternalServerErrorException();
     }
 
-    joinTournament (tournamentId: string, clientAuthToken: string): JoinTournamentDto {
+    joinTournament(tournamentId: string, clientAuthToken: string): JoinTournamentDto {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
         const master = tournament?.getMasterById(tournamentId);
@@ -161,7 +144,7 @@ export class ManyTablesTournamentService {
         throw new InternalServerErrorException();
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
         const master = tournament?.getMasterById(tournamentId);
@@ -175,15 +158,27 @@ export class ManyTablesTournamentService {
         throw new InternalServerErrorException();
     }
 
-    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
+    async buyTicket(tournamentId: string, clientAuthToken: string) {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            return this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
         return this.manyTablesRoomsManagerService.createTournament(createTournamentDto);
     }
 
-    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
+    async updateTournament(tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
         return this.manyTablesRoomsManagerService.updateTournament(tournamentId, updateTournamentDto);
     }
 
-    async removeTournament (tournamentId: string) {
+    async removeTournament(tournamentId: string) {
         return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
     }
 }

package/src/modules/menu/menu-screen.view.ts

@@ -0,0 +1,48 @@
+import {
+    AppScreenIdEnum,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    StandardScreenComponent,
+    IconImageComponent,
+    MenuHeaderSectionComponent,
+    MenuListSectionComponent,
+    MenuSectionListItemComponent,
+} from "jp.common.models";
+import { Menu } from "jp.db.schemas";
+
+export class MenuScreenView extends UniversalScreenView {
+    private readonly menuItems: Array<Menu>;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        menuItems: Array<Menu>,
+    ) {
+        super(localeService, lang);
+        this.menuItems = menuItems;
+    }
+
+    build(): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.MENU)
+            .addSection(
+                new MenuHeaderSectionComponent(
+                    'header',
+                    this.localeService.t('common.menu.header.title', { lang: this.lang }),
+                ),
+            )
+            .addSection(
+                new MenuListSectionComponent(
+                    'id1',
+                    this.menuItems.map((item) => (
+                        new MenuSectionListItemComponent(
+                            item.code,
+                            this.lang === 'ru' ? item.title : item.titleEn,
+                            new IconImageComponent(item.icon),
+                            item.url,
+                        )
+                    )
+                ),
+            ));
+    }
+}

package/src/modules/menu/menu.service.ts

@@ -1,53 +1,35 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { MenuRepository } from 'jp.db.schemas';
 import {
-    AppScreen,
-    AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     BaseAppScreen,
     IAppHeaders,
 } from 'jp.common.models';
 
+import { BaseAppScreenDto } from '../../dto';
+
 import { MENU_OPTIONS } from './menu.constants';
 import { MenuFactoryOptions } from './menu.interfaces';
-
-import { BaseAppScreenDto } from '../../dto';
+import { MenuScreenView } from './menu-screen.view';
 
 @Injectable()
 export class MenuService {
-    constructor (
+    constructor(
         private readonly menuRepository: MenuRepository,
         @Inject(MENU_OPTIONS) private readonly options: MenuFactoryOptions
     ) {
     }
 
-    async getScreen (headers: IAppHeaders): Promise<BaseAppScreenDto> {
+    async getScreen(headers: IAppHeaders): Promise<BaseAppScreenDto> {
         const menuItems = await this.menuRepository.findMenus('ALL', 'VK') ?? [];
 
-        const screen =
-            AppScreen.CreateStandardScreen(AppScreenIdEnum.MENU)
-                .addSection(
-                    AppScreenSection.CreateMenuHeaderSection(
-                        'header',
-                        this.options.i18n.t('common.menu.header.title', { lang: headers.client_language }),
-                    ),
-                )
-                .addSection(
-                    AppScreenSection.CreateMenuListSection(
-                        'id1',
-                        menuItems.map((item) =>
-                            AppScreenSectionListItem.CreateMenuListItem(
-                                item.code,
-                                headers.client_language === 'ru' ? item.title : item.titleEn,
-                                AppScreenSectionImage.CreateIconImage(item.icon),
-                                item.url,
-                            ),
-                        ),
-                    ),
-                );
-
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new MenuScreenView(
+                    this.options.i18n,
+                    headers.client_language,
+                    menuItems,
+                ).build()
+            )
+        );
     }
 }

package/src/modules/one-table-tournament/one-table-tournament-status-screen.view.ts

@@ -0,0 +1,64 @@
+import {
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    StandardScreenComponent,
+    StatusAppBarComponent,
+    StatusHeaderSectionComponent,
+    CardListSectionComponent,
+    ArrowBackButtonComponent,
+    IconImageComponent,
+    PrimaryButtonButtonsComponent,
+    TextButtonComponent,
+    MiniCardSectionListItemComponent,
+    UrlImageComponent,
+} from "jp.common.models";
+import { OneTableTournamentRoom } from "jp.ms.common.engine";
+
+export class OneTableTournamentStatusScreenView extends UniversalScreenView {
+    private readonly tournament: OneTableTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: OneTableTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
+            .addAppBar(
+                new StatusAppBarComponent(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    new ArrowBackButtonComponent(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection(
+                new StatusHeaderSectionComponent(
+                    'status',
+                    'description',
+                    new IconImageComponent(AppScreenIconEnum.EMOJI_EVENTS),
+                    new PrimaryButtonButtonsComponent(new TextButtonComponent('button')),
+                )
+            )
+            .addSection(
+                new CardListSectionComponent(
+                    'id1',
+                    this.tournament.getParticipants().map((item) => (
+                        new MiniCardSectionListItemComponent(
+                            item.playerId,
+                            item.playerName,
+                            '',
+                            new UrlImageComponent(item.playerAvatarUrl),
+                            true,
+                            '',
+                        )
+                    ))
+                ),
+            );
+    }
+}

package/src/modules/one-table-tournament/one-table-tournament.controller.ts

@@ -6,22 +6,38 @@ import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
 
 @Controller('tournament/one_table')
 export class OneTableTournamentController {
-    constructor (
+    constructor(
         private readonly tournamentService: OneTableTournamentService,
     ) {
     }
 
     @Get('status/:tournamentId')
-    getStatusScreen (
+    getStatusScreen(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): Promise<IBaseAppScreen> {
+    ): IBaseAppScreen {
         return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
     }
 
+    @Get('status/subscribe/:tournamentId')
+    subscribeOnStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('status/unsubscribe/:tournamentId')
+    unsubscribeFromStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.unsubscribeFromStatusScreen(tournamentId, headers.client_language);
+    }
+
     @Post('table/watch/:tableId')
     @HttpCode(HttpStatus.OK)
-    watchTheTable (
+    watchTheTable(
         @Param('tableId') tableId: string,
         @Headers() headers: IAppHeaders,
     ): IBaseTableGameState {
@@ -30,7 +46,7 @@ export class OneTableTournamentController {
 
     @Post('table/move/:tableId')
     @HttpCode(HttpStatus.OK)
-    moveOnTheTable (
+    moveOnTheTable(
         @Param('tableId') tableId: string,
         @Body() baseMoveData: IBaseMoveData,
         @Headers() headers: IAppHeaders,
@@ -40,7 +56,7 @@ export class OneTableTournamentController {
 
     @Post('join/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    joinTournament (
+    joinTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): JoinTournamentDto {
@@ -49,7 +65,7 @@ export class OneTableTournamentController {
 
     @Post('leave/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    leaveTournament (
+    leaveTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): IBaseTableGameState {

package/src/modules/one-table-tournament/one-table-tournament.module.ts

@@ -1,6 +1,10 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { TournamentOneTableRoom, TournamentOneTableRoomSchema, TournamentOneTableRoomsRepository } from 'jp.db.schemas';
+import { GamePlayer, OneTableTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+
+import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { EventsBusOneTableTournamentSubscribeService } from '../event-bus';
 
 import { OneTableTournamentController } from './one-table-tournament.controller';
 import { OneTableTournamentService } from './one-table-tournament.service';
@@ -15,11 +19,13 @@ import { OneTableTournamentModuleOptions } from './one-table-tournament.interfac
     providers: [OneTableTournamentService, TournamentOneTableRoomsRepository],
 })
 export class OneTableTournamentModule {
-    constructor () {
-
-    }
+    constructor(
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+        private readonly oneTableTournamentService: OneTableTournamentService,
+    ) { }
 
-    static forRootAsync (options: OneTableTournamentModuleOptions): DynamicModule {
+    static forRootAsync(options: OneTableTournamentModuleOptions): DynamicModule {
         return {
             module: OneTableTournamentModule,
             imports: options.imports ?? [],
@@ -32,5 +38,16 @@ export class OneTableTournamentModule {
             ],
         };
     }
+
+    async onModuleInit() {
+        this.eventsBusOneTableTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
+    }
+
+    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+        this.oneTableRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
+            const screen = this.oneTableTournamentService.getStatusScreen(event.roomId, subscriber.language);
+            subscriber.sendMessage(new OneTableTournamentUpdateStatusWsEvent(screen.screen));
+        });
+    }
 }
 

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

@@ -1,77 +1,70 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    AppScreen,
-    AppScreenAppBar,
-    AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     BaseAppScreen,
     IBaseMoveData,
     IBaseTableGameState,
-    AppScreenIconEnum,
-    AppScreenSectionButtons, router,
+    router,
 } from 'jp.common.models';
 
-import { BaseAppScreenDto } from '../../dto';
+import { AppScreenDto, BaseAppScreenDto } from '../../dto';
 import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
 
 import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
 import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
+import { OneTableTournamentStatusScreenView } from './one-table-tournament-status-screen.view';
 
 @Injectable()
 export class OneTableTournamentService {
-    constructor (
+    constructor(
         private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
         private readonly playersManager: PlayersManagerService,
         @Inject(ONE_TABLE_TOURNAMENT_OPTIONS) private readonly options: OneTableTournamentFactoryOptions,
     ) {
     }
 
-    async getStatusScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
         const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
         if (!tournament) {
             throw new InternalServerErrorException();
         }
 
-        const screen =
-            AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
-                .addAppBar(
-                    AppScreenAppBar.CreateStatusAppBar(
-                        this.options.i18n.t('common.rooms.screen.title', { lang }),
-                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
-                    ),
-                )
-                .addSection((
-                    AppScreenSection.CreateStatusHeader(
-                        'status',
-                        'description',
-                        AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                        AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
-                    )
-                ))
-                .addSection(
-                    AppScreenSection.CreateCardListSection(
-                        'id1',
-                        tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
-                            item.playerId,
-                            item.playerName,
-                            '',
-                            AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
-                            true,
-                            '',
-                        ))
-                    ),
-                );
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new OneTableTournamentStatusScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
+    }
+
+    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.addToStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.removeFromStatusScreenWatchers(player);
+        }
 
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+        throw new InternalServerErrorException();
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+    watchTheTable(tableId: string, clientAuthToken: string): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -85,7 +78,7 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+    moveOnTheTable(tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const room = this.oneTableRoomsManagerService.getRoomByTableId(tableId);
         const master = room?.getMasterById(tableId);
@@ -99,7 +92,7 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    joinTournament (tournamentId: string, clientAuthToken: string): JoinTournamentDto {
+    joinTournament(tournamentId: string, clientAuthToken: string): JoinTournamentDto {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
         const master = tournament?.getMasterById(tournamentId);
@@ -124,7 +117,7 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
         const master = tournament?.getMasterById(tournamentId);