jp.ms.common.modules 1.0.28 → 1.0.30

package/src/modules/main/main.service.ts

@@ -1,8 +1,9 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
-import { AppScreenRoutesEnum, BaseAppScreen, router } from 'jp.common.models';
 import dayjs from 'dayjs';
 import isToday from 'dayjs/plugin/isToday';
 import { ActivityLogRepository, UsersRepository } from 'jp.db.schemas';
+import { SimpleRoom, OneTableTournamentRoom, ManyTablesTournamentRoom } from 'jp.ms.common.engine';
+import { AppScreenRoutesEnum, ErrorSnackbarComponent, AppScreenRouter } from 'jp.common.models';
 
 import { BaseAppScreenDto, PlayerCheckStateDto, FindFreeTableDto } from '../../dto';
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
@@ -10,6 +11,7 @@ import { PlayersManagerService } from '../players-manager';
 import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager';
 import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
 import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
+import { ErrorCodeEnum, NotEnoughMoneyForPurchaseException, NotFoundFreeRoomForFastGameException } from '../../exception';
 
 import { MainFactoryOptions } from './main.interfaces';
 import { MAIN_OPTIONS } from './main.constants';
@@ -23,24 +25,23 @@ export class MainService {
         private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
         private readonly playersManager: PlayersManagerService,
         private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly userRepository: UsersRepository,
+        private readonly usersRepository: UsersRepository,
         private readonly activityLogRepository: ActivityLogRepository,
         @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
     ) {
         dayjs.extend(isToday);
     }
 
-    getScreen (lang: string): BaseAppScreenDto {
+    getScreen (lang: string, clientAuthToken: string): BaseAppScreenDto {
         return new BaseAppScreenDto(
-            new BaseAppScreen(
-                new MainTablesListScreenView(
-                    this.options.i18n,
-                    lang,
-                    this.simpleRoomsManager.getRooms(),
-                    this.oneTableRoomsManagerService.getRooms(),
-                    this.manyTablesRoomsManagerService.getRooms(),
-                ).build(),
-            )
+            new MainTablesListScreenView(
+                this.options.i18n,
+                lang,
+                this.simpleRoomsManager.getRooms(),
+                this.oneTableRoomsManagerService.getRooms(),
+                this.manyTablesRoomsManagerService.getRooms(),
+                clientAuthToken,
+            ).buildBS(),
         );
     }
 
@@ -68,7 +69,7 @@ export class MainService {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         let redirectUrl: string = AppScreenRoutesEnum.MENU;
 
-        const foundUser = await this.userRepository.findById(clientAuthToken);
+        const foundUser = await this.usersRepository.findById(clientAuthToken);
         const isNewbie = await this.activityLogRepository.userIsNewbie(clientAuthToken)
         const last7logins = await this.activityLogRepository.findLast7DaysLogins(game, clientAuthToken);
 
@@ -76,8 +77,14 @@ export class MainService {
             throw new InternalServerErrorException();
         }
 
-        if (player?.isPlayer() && player.tableId) {
-            redirectUrl = router.getRoomPath(player.tableId);
+        if (player && (player.isPlayer() || player.isTableQueuer()) && player.tableId) {
+            if (player.room instanceof SimpleRoom) {
+                redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
+            } else if (player.room instanceof OneTableTournamentRoom) {
+                redirectUrl = AppScreenRouter.getOneTableTournamentTablePath(player.tableId);
+            } else if (player.room instanceof ManyTablesTournamentRoom) {
+                redirectUrl = AppScreenRouter.getManyTablesTournamentTablePath(player.tableId);
+            }
         } else if (isNewbie) {
             redirectUrl = AppScreenRoutesEnum.WELCOME;
         } else if (dayjs(last7logins[0].date).isToday() && last7logins[0].count === 1) {
@@ -92,14 +99,41 @@ export class MainService {
         );
     }
 
-    findFreeTable (clientAuthToken: string): FindFreeTableDto {
+    findFreeTable (clientAuthToken: string, lang: string): FindFreeTableDto {
         const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId() ?? '';
+        const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
 
+        if (!player || !tableId) {
+            throw new NotFoundFreeRoomForFastGameException(new ErrorSnackbarComponent(
+                ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
+                this.options.i18n.t('common.server.message.code.4003', { lang })
+            ));
+        }
 
         return FindFreeTableDto.fromEntities(
-            tableId ? router.getRoomPath(tableId) : '',
-            player?.id ?? '',
+            AppScreenRouter.getSimpleRoomTablePath(tableId),
+            player.id,
         );
     }
+
+    async manyTablesTournamentbBuyTicket (clientAuthToken: string, lang: string, tournamentId: string): Promise<BaseAppScreenDto> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const user = await this.usersRepository.findById(player?.id ?? '');
+
+        if (!player || !tournament || !user) {
+            throw new InternalServerErrorException();
+        }
+
+        if (user.balance < tournament.getTicketPrice()) {
+            throw new NotEnoughMoneyForPurchaseException(new ErrorSnackbarComponent(
+                ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+                this.options.i18n.t('common.server.message.code.4004', { lang })
+            ));
+        }
+
+        await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+
+        return this.getScreen(lang, clientAuthToken);
+    }
 }

package/src/modules/many-tables-tournament/many-tables-tournament-status-screen.view.ts

@@ -1,18 +1,21 @@
+import dayjs from "dayjs";
 import {
-    AppScreen,
-    AppScreenAppBar,
     AppScreenIconEnum,
     AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionButtons,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     IAppScreen,
     UniversalScreenView,
     ILocaleService,
+    StandardScreenComponent,
+    StatusAppBarComponent,
+    StatusHeaderSectionComponent,
+    CardListSectionComponent,
+    ArrowBackButtonComponent,
+    IconImageComponent,
+    MiniCardSectionListItemComponent,
+    UrlImageComponent,
 } from "jp.common.models";
-import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
+import { formatChips, formatDate, formatTime, replacePattern } from "jp.common.utils";
+import { ManyTablesTournamentRoom, TournamentMaster } from "jp.ms.common.engine";
 
 export class ManyTablesTournamentStatusScreenView extends UniversalScreenView {
     private readonly tournament: ManyTablesTournamentRoom;
@@ -26,34 +29,97 @@ export class ManyTablesTournamentStatusScreenView extends UniversalScreenView {
         this.tournament = tournament;
     }
 
-    build(): IAppScreen {
-        return AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
+    build (): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
             .addAppBar(
-                AppScreenAppBar.CreateStatusAppBar(
-                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
-                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                new StatusAppBarComponent(
+                    this.tournament.getTitle(this.lang),
+                    new ArrowBackButtonComponent(
+                        this.localeService.t('common.button.back', { lang: this.lang })
+                    ),
                 ),
             )
-            .addSection((
-                AppScreenSection.CreateStatusHeader(
-                    'status',
-                    'description',
-                    AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                    AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
-                )
-            ))
             .addSection(
-                AppScreenSection.CreateCardListSection(
+                this.getStatusHeader()
+            )
+            .addSection(
+                new CardListSectionComponent(
                     'id1',
-                    this.tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
-                        item.playerId,
-                        item.playerName,
-                        '',
-                        AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
-                        true,
-                        '',
-                    ))
-                ),
+                    this.getPlayersList()
+                )
             );
     }
+
+    private getPlayersList (): Array<MiniCardSectionListItemComponent> {
+        if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return this.tournament.getWinners().map((item) => (
+                new MiniCardSectionListItemComponent(
+                    item.playerId,
+                    item.playerName,
+                    this.localeService.t('common.tournaments.status.screen.finish.description', {
+                        lang: this.lang,
+                        args: {
+                            RANK: item.rank.toString(),
+                            PRIZE: formatChips(item.profit, this.lang, true),
+                        }
+                    }),
+                    new UrlImageComponent(item.playerAvatarUrl),
+                    true,
+                    true,
+                    '',
+                )
+            ));
+        }
+
+        return this.tournament.getParticipants().map((item) => (
+            new MiniCardSectionListItemComponent(
+                item.playerId,
+                item.playerName,
+                '',
+                new UrlImageComponent(item.playerAvatarUrl),
+                true,
+                true,
+                '',
+            )
+        ));
+    }
+
+    private getStatusHeader (): StatusHeaderSectionComponent {
+        return new StatusHeaderSectionComponent(
+            'status',
+            this.getStatusDescription(),
+            new IconImageComponent(this.getStatusIcon())
+        );
+    }
+
+    private getStatusIcon (): string {
+        if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return AppScreenIconEnum.INFO;
+        } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return AppScreenIconEnum.EMOJI_EVENTS;
+        } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+            return AppScreenIconEnum.HOURGLASS_EMPTY;
+        }
+
+        return '';
+    }
+
+    private getStatusDescription (): string {
+        if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return this.localeService.t('common.tournaments.status.4', { lang: this.lang });
+        } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return this.localeService.t('common.tournaments.status.3', { lang: this.lang });
+        } else if (this.tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return this.localeService.t('common.tournaments.status.2', { lang: this.lang });
+        } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+            return replacePattern(this.tournament.getSubtitle(this.lang), {
+                DATE: dayjs(this.tournament.getScheduleDate()).isToday() ?
+                    this.localeService.t('common.tournaments.status.today', { lang: this.lang }) :
+                    formatDate(this.tournament.getScheduleDate() ?? ''),
+                SCHEDULE_DATE: formatTime(this.tournament.getScheduleDate() ?? ''),
+            });
+        }
+
+        return '';
+    }
 }

package/src/modules/many-tables-tournament/many-tables-tournament-tables-list-screen.view.ts

@@ -1,16 +1,15 @@
 import {
-    AppScreen,
-    AppScreenAppBar,
-    AppScreenIconEnum,
     AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     IAppScreen,
     UniversalScreenView,
     ILocaleService,
-    router,
+    StandardScreenComponent,
+    AppScreenRouter,
+    StandardAppBarComponent,
+    ArrowBackButtonComponent,
+    CardListSectionComponent,
+    MiniCardSectionListItemComponent,
+    UrlImageComponent,
 } from "jp.common.models";
 import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
 
@@ -26,25 +25,34 @@ export class ManyTablesTournamentTablesListScreenView extends UniversalScreenVie
         this.tournament = tournament;
     }
 
-    build(): IAppScreen {
-        return AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+    build (): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
             .addAppBar(
-                AppScreenAppBar.CreateStandardAppBar(
+                new StandardAppBarComponent(
                     this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
-                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                    new ArrowBackButtonComponent(
+                        this.localeService.t(
+                            'common.button.back',
+                            { lang: this.lang },
+                        )
+                    ),
                 ),
             )
             .addSection(
-                AppScreenSection.CreateCardListSection(
+                new CardListSectionComponent(
                     'id1',
                     this.tournament?.getTables().map((table) =>
-                        AppScreenSectionListItem.CreateCardListItemMini(
+                        new MiniCardSectionListItemComponent(
                             table.getId(),
                             table.getTitle(this.lang),
-                            table.getSubtitle(this.lang),
-                            AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                            this.localeService.t(
+                                'common.tournaments.screen.table.title',
+                                { lang: this.lang, args: { NUMBER: table.getNumber().toString() } }
+                            ),
+                            new UrlImageComponent(`${table.getPlayers().length}/${table.getTableSize()}`),
+                            true,
                             true,
-                            router.getRoomPath(table.getId()),
+                            AppScreenRouter.getManyTablesTournamentTablePath(table.getId()),
                         )
                     ) ?? []
                 ),

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

@@ -25,16 +25,16 @@ export class ManyTablesTournamentController {
     subscribeOnStatusScreen(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): Promise<void> {
-        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_language);
+    ): void {
+        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_auth_token);
     }
 
     @Get('status/unsubscribe/:tournamentId')
     unsubscribeFromStatusScreen(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): Promise<void> {
-        return this.tournamentService.unsubscribeFromStatusScreen(tournamentId, headers.client_language);
+    ): void {
+        return this.tournamentService.unsubscribeFromStatusScreen(tournamentId, headers.client_auth_token);
     }
 
     @Get('tables/:tournamentId')
@@ -78,19 +78,10 @@ export class ManyTablesTournamentController {
     leaveTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): void {
         return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
     }
 
-    @Post('buy_ticket/:tournamentId')
-    @HttpCode(HttpStatus.OK)
-    buyTicket(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): Promise<void> {
-        return this.tournamentService.buyTicket(tournamentId, headers.client_auth_token);
-    }
-
     @Post('create')
     @HttpCode(HttpStatus.OK)
     createTournament(

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

@@ -1,10 +1,10 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    BaseAppScreen,
     IBaseMoveData,
     IBaseTableGameState,
-    router,
+    AppScreenRouter,
 } from 'jp.common.models';
+import { ManyTablesTournamentMaster, TournamentMaster } from 'jp.ms.common.engine';
 
 import { BaseAppScreenDto } from '../../dto';
 import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
@@ -17,7 +17,6 @@ import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.int
 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';
-import { TournamentMaster } from 'jp.ms.common.engine';
 
 @Injectable()
 export class ManyTablesTournamentService {
@@ -28,7 +27,7 @@ export class ManyTablesTournamentService {
     ) {
     }
 
-    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    getStatusScreen (tournamentId: string, lang: string): BaseAppScreenDto {
         const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
         if (!tournament) {
@@ -36,39 +35,38 @@ export class ManyTablesTournamentService {
         }
 
         return new BaseAppScreenDto(
-            new BaseAppScreen(
-                new ManyTablesTournamentStatusScreenView(
-                    this.options.i18n,
-                    lang,
-                    tournament,
-                ).build()
-            )
+            new ManyTablesTournamentStatusScreenView(
+                this.options.i18n,
+                lang,
+                tournament,
+            ).buildBS()
         );
     }
 
-    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
-        if (player && tournament) {
-            tournament.addToStatusScreenWatchers(player);
+        if (!player || !tournament) {
+            throw new InternalServerErrorException();
         }
 
-        throw new InternalServerErrorException();
+        tournament.addToStatusScreenWatchers(player);
+
     }
 
-    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
-        if (player && tournament) {
-            tournament.removeFromStatusScreenWatchers(player);
+        if (!player || !tournament) {
+            throw new InternalServerErrorException();
         }
 
-        throw new InternalServerErrorException();
+        tournament.removeFromStatusScreenWatchers(player);
     }
 
-    async getTableListScreen(tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+    async getTableListScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
         const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
         if (!tournament) {
@@ -76,17 +74,15 @@ export class ManyTablesTournamentService {
         }
 
         return new BaseAppScreenDto(
-            new BaseAppScreen(
-                new ManyTablesTournamentTablesListScreenView(
-                    this.options.i18n,
-                    lang,
-                    tournament,
-                ).build()
-            )
+            new ManyTablesTournamentTablesListScreenView(
+                this.options.i18n,
+                lang,
+                tournament,
+            ).buildBS()
         );
     }
 
-    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);
@@ -100,7 +96,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);
@@ -114,29 +110,36 @@ 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);
 
-        if (player && tournament && master) {
+        if (player && tournament) {
             tournament.handleJoinTournament(player);
 
             if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
                 if (player.isPlayer() || player.isTableQueuer()) {
                     return JoinTournamentDto.fromEntities(
-                        router.getManyTablesTournamentTablePath(player.tableId ?? ''),
+                        AppScreenRouter.getManyTablesTournamentTablePath(player.tableId ?? ''),
+                        player.id,
+                    );
+                } else if (tournament.isParticipant(player.id)) {
+                    tournament.getRoomMaster<ManyTablesTournamentMaster>()
+                        .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
+
+                    return JoinTournamentDto.fromEntities(
+                        AppScreenRouter.getManyTablesTournamentTablePath(player.tableId ?? ''),
                         player.id,
                     );
                 } else {
                     return JoinTournamentDto.fromEntities(
-                        router.getManyTablesTournamentTableListPath(),
+                        AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
                         player.id,
                     );
                 }
             } else {
                 return JoinTournamentDto.fromEntities(
-                    router.getManyTablesTournamentStatusPath(tournament.getId()),
+                    AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
                     player.id,
                 );
             }
@@ -145,41 +148,26 @@ export class ManyTablesTournamentService {
         throw new InternalServerErrorException();
     }
 
-    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+    leaveTournament (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-        const master = tournament?.getMasterById(tournamentId);
 
-        if (player && tournament && master) {
-            tournament.handleLeaveTournament(player);
-
-            return master.createGameStateDto(player);
-        }
-
-        throw new InternalServerErrorException();
-    }
-
-    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);
+        if (!player || !tournament) {
+            throw new InternalServerErrorException();
         }
 
-        throw new InternalServerErrorException();
+        tournament.handleLeaveTournament(player);
     }
 
-    async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    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.service.ts

@@ -1,7 +1,6 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { BannersRepository, MenuRepository } from 'jp.db.schemas';
 import {
-    BaseAppScreen,
     IAppHeaders,
 } from 'jp.common.models';
 
@@ -25,14 +24,12 @@ export class MenuService {
         const enabledBanner = await this.bannersRepository.findEnabledBanner(headers.client_game, headers.client_channel);
 
         return new BaseAppScreenDto(
-            new BaseAppScreen(
-                new MenuScreenView(
-                    this.options.i18n,
-                    headers.client_language,
-                    menuItems,
-                    enabledBanner,
-                ).build()
-            )
+            new MenuScreenView(
+                this.options.i18n,
+                headers.client_language,
+                menuItems,
+                enabledBanner,
+            ).buildBS()
         );
     }
 }