jp.ms.common.modules 1.0.29 → 1.0.31

package/src/exception/index.ts

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

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

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

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

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

package/src/index.ts

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

package/src/modules/events/events.gateway.ts

@@ -41,7 +41,7 @@ export class EventsGateway implements OnGatewayConnection<Socket>, OnGatewayDisc
                     balance: user.balance,
                     experience: user.experience,
                     level: user.level,
-                    language: user.language,
+                    language: user.normalizedLang,
                 });
                 this.playersManager.addPlayer(player);
                 player.connections.addConnection(client);

package/src/modules/main/main-tables-list-screen.view.ts

@@ -1,24 +1,33 @@
+import dayjs from "dayjs";
 import {
-    AppScreen,
-    AppScreenAppBar,
     AppScreenIconEnum,
     AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     IAppScreen,
     UniversalScreenView,
     ILocaleService,
-    router,
-    AppScreenSectionButtons,
+    AppScreeButtonIdEnum,
+    StandardScreenComponent,
+    AppScreenRouter,
+    IAppScreenSectionListItem,
+    StandardAppBarComponent,
+    ArrowBackButtonComponent,
+    CardListSectionComponent,
+    MiniCardSectionListItemComponent,
+    UrlImageComponent,
+    IconImageComponent,
+    ExtendedCardSectionListItemComponent,
+    TextButtonComponent,
+    FullButtonsButtonsComponent,
+    PrimaryButtonButtonsComponent,
 } from "jp.common.models";
 import {
     SimpleRoom,
     OneTableTournamentRoom,
     ManyTablesTournamentRoom,
+    TournamentMaster,
+    TournamentRoom,
 } from "jp.ms.common.engine";
-import { replacePattern } from "jp.common.utils";
+import { formatDate, formatTime, replacePattern } from "jp.common.utils";
 
 import { TournamentBuyTicketDialogView } from "../../views";
 
@@ -26,6 +35,7 @@ export class MainTablesListScreenView extends UniversalScreenView {
     private readonly simpleRooms: Array<SimpleRoom>;
     private readonly oneTableTournamentRooms: Array<OneTableTournamentRoom>;
     private readonly manyTablesTournamentRooms: Array<ManyTablesTournamentRoom>;
+    private readonly playerId: string;
 
     constructor(
         localeService: ILocaleService,
@@ -33,67 +43,32 @@ export class MainTablesListScreenView extends UniversalScreenView {
         simpleRooms: Array<SimpleRoom>,
         oneTableTournamentRooms: Array<OneTableTournamentRoom>,
         manyTablesTournamentRooms: Array<ManyTablesTournamentRoom>,
+        playerId: string,
     ) {
         super(localeService, lang);
         this.simpleRooms = simpleRooms;
         this.oneTableTournamentRooms = oneTableTournamentRooms;
         this.manyTablesTournamentRooms = manyTablesTournamentRooms;
+        this.playerId = playerId;
     }
 
     build (): IAppScreen {
-        const oneTableTournamentsCardList = this.oneTableTournamentRooms.map((room) =>
-            AppScreenSectionListItem.CreateCardListItemMini(
-                room.getId(),
-                room.getTitle(this.lang),
-                room.getSubtitle(this.lang),
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                true,
-                router.getOneTableTournamentStatusPath(room.getId()),
-            ));
-
-        const manyTablesTournamentsCardList = this.manyTablesTournamentRooms.map((room) =>
-            AppScreenSectionListItem.CreateCardListItemExtended(
-                room.getId(),
-                room.getTitle(this.lang),
-                room.getSubtitle(this.lang),
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                true,
-                true,
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                room.getDescription(this.lang),
-                AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
-            ));
-
-        const simpleRoomsTableCardList = this.simpleRooms.reduce<Array<AppScreenSectionListItem>>((result, room) => {
-            const list = room.getTables().map((table) => AppScreenSectionListItem.CreateCardListItemMini(
-                table.getId(),
-                table.getTitleWithNumber(this.lang),
-                replacePattern(table.getSubtitle(this.lang), {
-                    HALF_BET: table.getHalfBet().toString(),
-                    BET: table.getBet().toString()
-                }),
-                AppScreenSectionImage.CreateUrlImage(`${table.getPlayers().length}/${table.getTableSize()}`),
-                true,
-                router.getRoomPath(table.getId()),
-            ));
-
-            return [...result, ...list];
-        }, []);
-
-        return AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+        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',
                     [
-                        ...manyTablesTournamentsCardList,
-                        ...oneTableTournamentsCardList,
-                        ...simpleRoomsTableCardList
+                        ...this.getManyTablesTournamentsCardList(),
+                        ...this.getOneTableTournamentsCardList(),
+                        ...this.getSimpleRoomsTableCardList(),
                     ]
                 ),
             )
@@ -104,4 +79,151 @@ export class MainTablesListScreenView extends UniversalScreenView {
                 ).build(),
             )
     }
+
+    private getSimpleRoomsTableCardList (): Array<IAppScreenSectionListItem> {
+        return this.simpleRooms.reduce<Array<IAppScreenSectionListItem>>((result, room) => {
+            const list = room.getTables().map((table) => new MiniCardSectionListItemComponent(
+                table.getId(),
+                table.getTitleWithNumber(this.lang),
+                replacePattern(table.getSubtitle(this.lang), {
+                    HALF_BET: table.getHalfBet().toString(),
+                    BET: table.getBet().toString()
+                }),
+                new UrlImageComponent(`${table.getPlayers().length}/${table.getTableSize()}`),
+                true,
+                true,
+                AppScreenRouter.getSimpleRoomTablePath(table.getId()),
+            ));
+
+            return [...result, ...list];
+        }, []);
+    }
+
+    private getOneTableTournamentsCardList (): Array<IAppScreenSectionListItem> {
+        return this.oneTableTournamentRooms.map((room) =>
+            new MiniCardSectionListItemComponent(
+                room.getId(),
+                room.getTitle(this.lang),
+                this.getOneTableTournamentSubtitle(room),
+                this.getOneTableTournamentIcon(room),
+                true,
+                true,
+                AppScreenRouter.getOneTableTournamentStatusPath(room.getId()),
+            )
+        );
+    }
+
+    private getOneTableTournamentSubtitle (tournament: TournamentRoom): string {
+        if (tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return this.localeService.t('common.tournaments.status.4', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return this.localeService.t('common.tournaments.status.3', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return this.localeService.t('common.tournaments.status.2', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+            return tournament.getSubtitle(this.lang);
+        }
+
+        return '';
+    }
+
+    private getOneTableTournamentIcon (tournament: TournamentRoom) {
+        if (tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return new IconImageComponent(AppScreenIconEnum.EMOJI_EVENTS);
+        }
+
+        if (tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return new IconImageComponent(AppScreenIconEnum.INFO);
+        }
+
+        if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return new IconImageComponent(AppScreenIconEnum.BOLT);
+        }
+
+        return new UrlImageComponent(`${tournament.getParticipants().length}/${tournament.getTableSize()}`);
+    }
+
+    private getManyTablesTournamentsCardList (): Array<IAppScreenSectionListItem> {
+        return this.manyTablesTournamentRooms.map((room) =>
+            this.getManyTablesTournamentsCardListItem(room));
+    }
+
+    private getManyTablesTournamentsCardListItem (tournament: ManyTablesTournamentRoom): IAppScreenSectionListItem {
+        if (tournament.getRoomMaster<TournamentMaster>().isWaiting() || tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return new ExtendedCardSectionListItemComponent(
+                tournament.getId(),
+                tournament.getTitle(this.lang),
+                this.getManyTablesTournamentSubtitle(tournament),
+                this.getManyTablesTournamentIcon(tournament),
+                true,
+                true,
+                this.getManyTablesTournamentIcon(tournament),
+                replacePattern(tournament.getDescription(this.lang), {
+                    PARTICIPANTS: tournament.getParticipants().length.toString(),
+                    TOTAL_PARTICIPANTS: tournament.getMaxParticipants().toString(),
+                }),
+                this.getManyTablesTournamenButtons(tournament),
+            );
+        }
+
+        return new MiniCardSectionListItemComponent(
+            tournament.getId(),
+            tournament.getTitle(this.lang),
+            this.getManyTablesTournamentSubtitle(tournament),
+            this.getManyTablesTournamentIcon(tournament),
+            true,
+            true,
+            AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+        );
+    }
+
+    private getManyTablesTournamentIcon (tournament: TournamentRoom) {
+        if (tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return new IconImageComponent(AppScreenIconEnum.INFO);
+        }
+
+        if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return new IconImageComponent(AppScreenIconEnum.BOLT);
+        }
+
+        return new IconImageComponent(AppScreenIconEnum.EMOJI_EVENTS);
+    }
+
+    private getManyTablesTournamentSubtitle (tournament: ManyTablesTournamentRoom): string {
+        if (tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+            return this.localeService.t('common.tournaments.status.4', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+            return this.localeService.t('common.tournaments.status.3', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+            return this.localeService.t('common.tournaments.status.2', { lang: this.lang });
+        } else if (tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+            return replacePattern(tournament.getSubtitle(this.lang), {
+                DATE: dayjs(tournament.getScheduleDate()).isToday() ?
+                    this.localeService.t('common.tournaments.status.today', { lang: this.lang }) :
+                    formatDate(tournament.getScheduleDate() ?? ''),
+                SCHEDULE_DATE: formatTime(tournament.getScheduleDate() ?? ''),
+            });
+        }
+
+        return '';
+    }
+
+    private getManyTablesTournamenButtons (tournament: ManyTablesTournamentRoom) {
+        if (tournament.isParticipant(this.playerId)) {
+            return new PrimaryButtonButtonsComponent(
+                new TextButtonComponent(
+                    this.localeService.t('common.tournaments.screen.button.join.tournament', { lang: this.lang })
+                ).setId(AppScreeButtonIdEnum.BUTTON_MAIN_TABLES_MANY_TABLES_TOURNAMENT_JOIN)
+            );
+        }
+
+        return new FullButtonsButtonsComponent(
+            new TextButtonComponent(
+                this.localeService.t('common.tournaments.screen.button.buy.ticket', { lang: this.lang })
+            ).setId(AppScreeButtonIdEnum.BUTTON_MAIN_TABLES_MANY_TABLES_TOURNAMENT_BUY_TICKET),
+            new TextButtonComponent(
+                this.localeService.t('common.tournaments.screen.button.join.tournament', { lang: this.lang })
+            ).setId(AppScreeButtonIdEnum.BUTTON_MAIN_TABLES_MANY_TABLES_TOURNAMENT_JOIN)
+        );
+    }
 }

package/src/modules/main/main.controller.ts

@@ -1,7 +1,7 @@
-import { Controller, Get, Headers } from '@nestjs/common';
-import { IAppHeaders, IBaseAppScreen } from 'jp.common.models';
+import { Controller, Get, Headers, HttpCode, HttpStatus, NotImplementedException, Param, Post } from '@nestjs/common';
+import { IAppHeaders } from 'jp.common.models';
 
-import { PlayerCheckStateDto, FindFreeTableDto } from '../../dto';
+import { PlayerCheckStateDto, FindFreeTableDto, BaseAppScreenDto } from '../../dto';
 
 import { MainService } from './main.service';
 
@@ -12,27 +12,40 @@ export class MainController {
     ) { }
 
     @Get('player_check_state')
-    checkState(@Headers() headers: IAppHeaders): Promise<PlayerCheckStateDto> {
+    checkState (@Headers() headers: IAppHeaders): Promise<PlayerCheckStateDto> {
         return this.mainService.playerCheckState(headers.client_auth_token, headers.client_game);
     }
 
     @Get('tables')
-    getScreen(@Headers() headers: IAppHeaders): IBaseAppScreen {
-        return this.mainService.getScreen(headers.client_language);
+    getScreen (@Headers() headers: IAppHeaders): BaseAppScreenDto {
+        return this.mainService.getScreen(headers.client_language, headers.client_auth_token);
     }
 
     @Get('tables/subscribe')
-    subscribeOnTablesScreen(@Headers() headers: IAppHeaders): Promise<void> {
+    subscribeOnTablesScreen (@Headers() headers: IAppHeaders): Promise<void> {
         return this.mainService.subscribeOnTablesScreen(headers.client_language);
     }
 
     @Get('tables/unsubscribe')
-    unsubscribeFromTablesScreen(@Headers() headers: IAppHeaders): Promise<void> {
+    unsubscribeFromTablesScreen (@Headers() headers: IAppHeaders): Promise<void> {
         return this.mainService.unsubscribeFromTablesScreen(headers.client_language);
     }
 
     @Get('find_free_table')
-    findFreeTable(@Headers() headers: IAppHeaders): FindFreeTableDto {
-        return this.mainService.findFreeTable(headers.client_auth_token);
+    findFreeTable (@Headers() headers: IAppHeaders): FindFreeTableDto {
+        return this.mainService.findFreeTable(headers.client_auth_token, headers.client_language);
+    }
+
+    @Post('many_tables_tournament/buy_ticket/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    buyTicket (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<BaseAppScreenDto> {
+        return this.mainService.manyTablesTournamentbBuyTicket(
+            headers.client_auth_token,
+            headers.client_language,
+            tournamentId,
+        );
     }
 }

package/src/modules/main/main.module.ts

@@ -20,7 +20,7 @@ import { MainModuleOptions } from './main.interfaces';
         MainService,
         UsersRepository,
         ActivityLogRepository,
-    ]
+    ],
 })
 export class MainModule {
     constructor(
@@ -48,7 +48,7 @@ export class MainModule {
 
     private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
         this.eventsBusMainTablesSubscribeService.getTablesSubscribers().forEach((subscriber: GamePlayer) => {
-            const screen = this.mainService.getScreen(subscriber.language);
+            const screen = this.mainService.getScreen(subscriber.language, subscriber.id);
             subscriber.sendMessage(new MainTablesUpdateListWsEvent(event.game, screen));
         });
     }

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);
+    }
 }