jp.ms.common.modules 1.0.24 → 1.0.25

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

@@ -1,10 +1,10 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import { AppScreenRoutesEnum, BaseAppScreen, router } from 'jp.common.models';
-import * as dayjs from 'dayjs';
-import * as isToday from 'dayjs/plugin/isToday';
+import dayjs from 'dayjs';
+import isToday from 'dayjs/plugin/isToday';
 import { ActivityLogRepository, UsersRepository } from 'jp.db.schemas';
 
-import { BaseAppScreenDto, PlayerCheckStateDto } from '../../dto';
+import { BaseAppScreenDto, PlayerCheckStateDto, FindFreeTableDto } from '../../dto';
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 import { PlayersManagerService } from '../players-manager';
 import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager';
@@ -17,7 +17,6 @@ import { MainTablesListScreenView } from './main-tables-list-screen.view';
 
 @Injectable()
 export class MainService {
-
     constructor(
         private readonly simpleRoomsManager: SimpleRoomsManagerService,
         private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
@@ -31,7 +30,7 @@ export class MainService {
         dayjs.extend(isToday);
     }
 
-    getScreen(lang: string): BaseAppScreenDto {
+    getScreen (lang: string): BaseAppScreenDto {
         return new BaseAppScreenDto(
             new BaseAppScreen(
                 new MainTablesListScreenView(
@@ -45,7 +44,7 @@ export class MainService {
         );
     }
 
-    subscribeOnTablesScreen(clientAuthToken: string): Promise<void> {
+    subscribeOnTablesScreen (clientAuthToken: string): Promise<void> {
         const player = this.playersManager.getPlayerById(clientAuthToken);
 
         if (player) {
@@ -55,7 +54,7 @@ export class MainService {
         throw new InternalServerErrorException();
     }
 
-    unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
+    unsubscribeFromTablesScreen (clientAuthToken: string): Promise<void> {
         const player = this.playersManager.getPlayerById(clientAuthToken);
 
         if (player) {
@@ -65,7 +64,7 @@ export class MainService {
         throw new InternalServerErrorException();
     }
 
-    async playerCheckState(clientAuthToken: string, game: string): Promise<PlayerCheckStateDto> {
+    async playerCheckState (clientAuthToken: string, game: string): Promise<PlayerCheckStateDto> {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         let redirectUrl: string = AppScreenRoutesEnum.MENU;
 
@@ -87,9 +86,20 @@ export class MainService {
             redirectUrl = AppScreenRoutesEnum.PREMIUM;
         }
 
-        return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
+        return PlayerCheckStateDto.fromEntities(
+            redirectUrl,
+            player?.id ?? '',
+        );
     }
 
-    findFreeTable(clientAuthToken: string) {
+    findFreeTable (clientAuthToken: string): FindFreeTableDto {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId() ?? '';
+
+
+        return FindFreeTableDto.fromEntities(
+            tableId ? router.getRoomPath(tableId) : '',
+            player?.id ?? '',
+        );
     }
 }

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

@@ -46,7 +46,7 @@ export class ManyTablesTournamentModule {
     private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
         this.manyTablesRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
             const screen = this.manyTablesTournamentService.getStatusScreen(event.roomId, subscriber.language);
-            subscriber.sendMessage(new ManyTablesTournamentUpdateStatusWsEvent(screen.screen));
+            subscriber.sendMessage(new ManyTablesTournamentUpdateStatusWsEvent(event.game, screen.screen));
         });
     }
 }

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

@@ -17,6 +17,7 @@ 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 {
@@ -121,7 +122,7 @@ export class ManyTablesTournamentService {
         if (player && tournament && master) {
             tournament.handleJoinTournament(player);
 
-            if (tournament.getTournamentMaster().isInProgress()) {
+            if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
                 if (player.isPlayer() || player.isTableQueuer()) {
                     return JoinTournamentDto.fromEntities(
                         router.getManyTablesTournamentTablePath(player.tableId ?? ''),

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

@@ -8,29 +8,31 @@ import {
     MenuHeaderSectionComponent,
     MenuListSectionComponent,
     MenuSectionListItemComponent,
+    OneBannerSectionComponent,
+    BannerSectionListItemComponent,
+    UrlImageComponent,
+    BaseSectionComponent,
 } from "jp.common.models";
-import { Menu } from "jp.db.schemas";
+import { Banner, Menu } from "jp.db.schemas";
 
 export class MenuScreenView extends UniversalScreenView {
     private readonly menuItems: Array<Menu>;
+    private readonly banner: Banner | null
 
     constructor(
         localeService: ILocaleService,
         lang: string,
         menuItems: Array<Menu>,
+        banner: Banner | null
     ) {
         super(localeService, lang);
         this.menuItems = menuItems;
+        this.banner = banner;
     }
 
-    build(): IAppScreen {
+    build (): IAppScreen {
         return new StandardScreenComponent(AppScreenIdEnum.MENU)
-            .addSection(
-                new MenuHeaderSectionComponent(
-                    'header',
-                    this.localeService.t('common.menu.header.title', { lang: this.lang }),
-                ),
-            )
+            .addSection(this.getHeaderSection())
             .addSection(
                 new MenuListSectionComponent(
                     'id1',
@@ -41,8 +43,28 @@ export class MenuScreenView extends UniversalScreenView {
                             new IconImageComponent(item.icon),
                             item.url,
                         )
-                    )
-                ),
-            ));
+                    )),
+                )
+            );
+    }
+
+    getHeaderSection (): BaseSectionComponent {
+        if (this.banner) {
+            return new OneBannerSectionComponent(
+                'banner',
+                new BannerSectionListItemComponent(
+                    this.banner.bannerId,
+                    this.banner.titleRu,
+                    this.localeService.t('common.menu.header.title', { lang: this.lang }),
+                    new UrlImageComponent(this.banner.image),
+                    this.banner.link,
+                )
+            );
+        }
+
+        return new MenuHeaderSectionComponent(
+            'header',
+            this.localeService.t('common.menu.header.title', { lang: this.lang }),
+        );
     }
 }

package/src/modules/menu/menu.module.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { Menu, MenuSchema, MenuRepository } from 'jp.db.schemas';
+import { Menu, MenuSchema, MenuRepository, Banner, BannerSchema, BannersRepository } from 'jp.db.schemas';
 
 import { MenuController } from './menu.controller';
 import { MenuService } from './menu.service';
@@ -10,9 +10,10 @@ import { MenuModuleOptions } from './menu.interfaces';
 @Module({
     imports: [
         MongooseModule.forFeature([{ name: Menu.name, schema: MenuSchema }]),
+        MongooseModule.forFeature([{ name: Banner.name, schema: BannerSchema }]),
     ],
     controllers: [MenuController],
-    providers: [MenuRepository, MenuService],
+    providers: [MenuRepository, MenuService, BannersRepository],
 })
 export class MenuModule {
     static forRootAsync(options: MenuModuleOptions): DynamicModule {

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

@@ -1,5 +1,5 @@
 import { Inject, Injectable } from '@nestjs/common';
-import { MenuRepository } from 'jp.db.schemas';
+import { BannersRepository, MenuRepository } from 'jp.db.schemas';
 import {
     BaseAppScreen,
     IAppHeaders,
@@ -15,12 +15,14 @@ import { MenuScreenView } from './menu-screen.view';
 export class MenuService {
     constructor(
         private readonly menuRepository: MenuRepository,
+        private readonly bannersRepository: BannersRepository,
         @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 enabledBanner = await this.bannersRepository.findEnabledBanner(headers.client_game, headers.client_channel);
 
         return new BaseAppScreenDto(
             new BaseAppScreen(
@@ -28,6 +30,7 @@ export class MenuService {
                     this.options.i18n,
                     headers.client_language,
                     menuItems,
+                    enabledBanner,
                 ).build()
             )
         );

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

@@ -15,35 +15,35 @@ import {
     MiniCardSectionListItemComponent,
     UrlImageComponent,
 } from "jp.common.models";
-import { OneTableTournamentRoom } from "jp.ms.common.engine";
+import { OneTableTournamentRoom, TournamentMaster } from "jp.ms.common.engine";
 
 export class OneTableTournamentStatusScreenView extends UniversalScreenView {
     private readonly tournament: OneTableTournamentRoom;
+    private readonly playerId: string;
 
     constructor(
         localeService: ILocaleService,
         lang: string,
         tournament: OneTableTournamentRoom,
+        playerId: string,
     ) {
         super(localeService, lang);
         this.tournament = tournament;
+        this.playerId = playerId;
     }
 
-    build(): IAppScreen {
+    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 })),
+                    this.tournament.getTitle(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')),
-                )
+                this.getStatusHeader()
             )
             .addSection(
                 new CardListSectionComponent(
@@ -62,4 +62,70 @@ export class OneTableTournamentStatusScreenView extends UniversalScreenView {
                 ),
             );
     }
+
+    private getStatusHeader (): StatusHeaderSectionComponent {
+        // TODO разобраться с участниками для туринар
+        const foundPlayer = this.tournament.getParticipants().find((item) => item.playerId === this.playerId);
+
+        return new StatusHeaderSectionComponent(
+            'status',
+            this.getStatusDescription(),
+            new IconImageComponent(this.getStatusIcon()),
+            !foundPlayer ?
+                new PrimaryButtonButtonsComponent(
+                    new TextButtonComponent('Join tournament')
+                ) : undefined,
+        )
+    }
+
+    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.2', { 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>().isWaiting()) {
+            return this.getStatusDescriptionWaiting();
+        }
+
+        return '';
+    }
+
+    private getStatusDescriptionWaiting (): string {
+        const players = this.tournament.getParticipants().length;
+        const maxPlayers = this.tournament.getTableSize();
+
+        if (players === 0) {
+            return this.localeService.t(
+                'common.room.screen.seat.and.go.waiting.for.the.players',
+                {
+                    lang: this.lang,
+                    args: {
+                        MAX_PLAYERS: this.tournament.getTableSize().toString(),
+                    }
+                },
+            );
+        }
+
+        return this.localeService.t(
+            'common.room.screen.seat.and.go.more.waiting.for.the.players',
+            {
+                lang: this.lang,
+                args: {
+                    PLAYERS: (maxPlayers - players).toString(),
+                }
+            },
+        );
+    }
 }

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

@@ -16,23 +16,23 @@ export class OneTableTournamentController {
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): IBaseAppScreen {
-        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
+        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language, headers.client_auth_token);
     }
 
     @Get('status/subscribe/:tournamentId')
     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);
     }
 
     @Post('table/watch/:tableId')
@@ -59,8 +59,8 @@ export class OneTableTournamentController {
     joinTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): JoinTournamentDto {
-        return this.tournamentService.joinTournament(tournamentId, headers.client_auth_token);
+    ): IBaseAppScreen {
+        return this.tournamentService.joinTournament(tournamentId, headers);
     }
 
     @Post('leave/:tournamentId')
@@ -68,7 +68,7 @@ export class OneTableTournamentController {
     leaveTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
-    ): IBaseTableGameState {
+    ): void {
         return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
     }
 }

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

@@ -45,8 +45,8 @@ export class OneTableTournamentModule {
 
     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));
+            const screen = this.oneTableTournamentService.getStatusScreen(event.roomId, subscriber.language, subscriber.id);
+            subscriber.sendMessage(new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen));
         });
     }
 }

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

@@ -1,15 +1,15 @@
 import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
     BaseAppScreen,
+    IAppHeaders,
+    IBaseAppScreen,
     IBaseMoveData,
     IBaseTableGameState,
-    router,
 } from 'jp.common.models';
 
-import { AppScreenDto, BaseAppScreenDto } from '../../dto';
+import { 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';
@@ -24,7 +24,7 @@ export class OneTableTournamentService {
     ) {
     }
 
-    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    getStatusScreen (tournamentId: string, lang: string, playerId: string): BaseAppScreenDto {
         const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
         if (!tournament) {
@@ -37,34 +37,39 @@ export class OneTableTournamentService {
                     this.options.i18n,
                     lang,
                     tournament,
+                    playerId,
                 ).build()
             )
         );
     }
 
-    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
         if (player && tournament) {
             tournament.addToStatusScreenWatchers(player);
+
+            return;
         }
 
         throw new InternalServerErrorException();
     }
 
-    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
 
         if (player && tournament) {
             tournament.removeFromStatusScreenWatchers(player);
+
+            return;
         }
 
         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);
@@ -78,7 +83,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);
@@ -92,40 +97,27 @@ export class OneTableTournamentService {
         throw new InternalServerErrorException();
     }
 
-    joinTournament(tournamentId: string, clientAuthToken: string): JoinTournamentDto {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
+    joinTournament (tournamentId: string, headers: IAppHeaders): IBaseAppScreen {
+        const player = this.playersManager.getPlayerById(headers.client_auth_token);
         const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
-        const master = tournament?.getMasterById(tournamentId);
 
-        if (player && tournament && master) {
+        if (player && tournament) {
             tournament.handleJoinTournament(player);
 
-            if (tournament.getTournamentMaster().isInProgress()) {
-                const onlyTableId = tournament.getFirstMaster()?.getTable()?.getId() ?? '';
-                return JoinTournamentDto.fromEntities(
-                    router.getOneTableTournamentTablePath(onlyTableId),
-                    player.id,
-                );
-            } else {
-                return JoinTournamentDto.fromEntities(
-                    router.getOneTableTournamentStatusPath(tournament.getId()),
-                    player.id,
-                );
-            }
+            return this.getStatusScreen(tournamentId, headers.client_language, headers.client_auth_token);
         }
 
         throw new InternalServerErrorException();
     }
 
-    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+    leaveTournament (tournamentId: string, clientAuthToken: string): void {
         const player = this.playersManager.getPlayerById(clientAuthToken);
         const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
-        const master = tournament?.getMasterById(tournamentId);
 
-        if (player && tournament && master) {
+        if (player && tournament) {
             tournament.handleLeaveTournament(player);
 
-            return master.createGameStateDto(player);
+            return;
         }
 
         throw new InternalServerErrorException();