jp.ms.common.modules 1.0.20 → 1.0.22

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

@@ -0,0 +1,107 @@
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    router,
+    AppScreenSectionButtons,
+} from "jp.common.models";
+import {
+    SimpleRoom,
+    OneTableTournamentRoom,
+    ManyTablesTournamentRoom,
+} from "jp.ms.common.engine";
+import { replacePattern } from "jp.common.utils";
+
+import { TournamentBuyTicketDialogView } from "../../views";
+
+export class MainTablesListScreenView extends UniversalScreenView {
+    private readonly simpleRooms: Array<SimpleRoom>;
+    private readonly oneTableTournamentRooms: Array<OneTableTournamentRoom>;
+    private readonly manyTablesTournamentRooms: Array<ManyTablesTournamentRoom>;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        simpleRooms: Array<SimpleRoom>,
+        oneTableTournamentRooms: Array<OneTableTournamentRoom>,
+        manyTablesTournamentRooms: Array<ManyTablesTournamentRoom>,
+    ) {
+        super(localeService, lang);
+        this.simpleRooms = simpleRooms;
+        this.oneTableTournamentRooms = oneTableTournamentRooms;
+        this.manyTablesTournamentRooms = manyTablesTournamentRooms;
+    }
+
+    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(),
+                replacePattern(table.getTitle(this.lang), { NUMBER: table.getNumber().toString() }),
+                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)
+            .addAppBar(
+                AppScreenAppBar.CreateStandardAppBar(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection(
+                AppScreenSection.CreateCardListSection(
+                    'id1',
+                    [
+                        ...manyTablesTournamentsCardList,
+                        ...oneTableTournamentsCardList,
+                        ...simpleRoomsTableCardList
+                    ]
+                ),
+            )
+            .addDialog(
+                new TournamentBuyTicketDialogView(
+                    this.localeService,
+                    this.lang,
+                ).build(),
+            )
+    }
+}

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

@@ -7,23 +7,32 @@ import { MainService } from './main.service';
 
 @Controller('main')
 export class MainController {
-    constructor (
+    constructor(
         private readonly mainService: MainService,
-    ) {
-    }
+    ) { }
 
     @Get('player/check/state')
-    checkState (@Headers() headers: IAppHeaders): PlayerCheckStateDto {
-        return this.mainService.playerCheckState(headers.client_auth_token);
+    checkState(@Headers() headers: IAppHeaders): Promise<PlayerCheckStateDto> {
+        return this.mainService.playerCheckState(headers.client_auth_token, headers.client_game);
     }
 
     @Get('tables')
-    getScreen (@Headers() headers: IAppHeaders): Promise<IBaseAppScreen> {
+    getScreen(@Headers() headers: IAppHeaders): IBaseAppScreen {
         return this.mainService.getScreen(headers.client_language);
     }
 
+    @Get('tables/subscribe')
+    subscribeOnTablesScreen(@Headers() headers: IAppHeaders): Promise<void> {
+        return this.mainService.subscribeOnTablesScreen(headers.client_language);
+    }
+
+    @Get('tables/unsubscribe')
+    unsubscribeFromTablesScreen(@Headers() headers: IAppHeaders): Promise<void> {
+        return this.mainService.unsubscribeFromTablesScreen(headers.client_language);
+    }
+
     @Get('findFreeTable')
-    findFreeTable (@Headers() headers: IAppHeaders) {
+    findFreeTable(@Headers() headers: IAppHeaders) {
         return this.mainService.findFreeTable(headers.client_auth_token);
     }
 }

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

@@ -1,4 +1,9 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { GamePlayer, MainTablesUpdateListWsEvent } from 'jp.ms.common.engine';
+import { ActivityLog, ActivityLogRepository, ActivityLogSchema, User, UserSchema, UsersRepository } from 'jp.db.schemas';
+
+import { EventsBusMainTablesSubscribeService } from '../event-bus';
 
 import { MainController } from './main.controller';
 import { MainService } from './main.service';
@@ -6,15 +11,24 @@ import { MAIN_OPTIONS } from './main.constants';
 import { MainModuleOptions } from './main.interfaces';
 
 @Module({
+    imports: [
+        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+        MongooseModule.forFeature([{ name: ActivityLog.name, schema: ActivityLogSchema }]),
+    ],
     controllers: [MainController],
-    providers: [MainService],
+    providers: [
+        MainService,
+        UsersRepository,
+        ActivityLogRepository,
+    ]
 })
 export class MainModule {
-    constructor () {
-
-    }
+    constructor(
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly mainService: MainService,
+    ) { }
 
-    static forRootAsync (options: MainModuleOptions): DynamicModule {
+    static forRootAsync(options: MainModuleOptions): DynamicModule {
         return {
             module: MainModule,
             imports: options.imports ?? [],
@@ -27,5 +41,16 @@ export class MainModule {
             ],
         };
     }
+
+    async onModuleInit() {
+        this.eventsBusMainTablesSubscribeService.subscribe(this.onHandleStatusRoomChange);
+    }
+
+    private onHandleStatusRoomChange = () => {
+        this.eventsBusMainTablesSubscribeService.getTablesSubscribers().forEach((subscriber: GamePlayer) => {
+            const screen = this.mainService.getScreen(subscriber.language);
+            subscriber.sendMessage(new MainTablesUpdateListWsEvent(screen.screen));
+        });
+    }
 }
 

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

@@ -1,111 +1,95 @@
-import { Inject, Injectable } from '@nestjs/common';
-import {
-    AppScreen,
-    AppScreenAppBar,
-    AppScreenIdEnum,
-    AppScreenRoutesEnum,
-    AppScreenSection,
-    AppScreenSectionButton,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
-    BaseAppScreen,
-    router,
-    AppScreenIconEnum,
-    AppScreenSectionButtons,
-} from 'jp.common.models';
-import { replacePattern } from 'jp.common.utils';
+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 { ActivityLogRepository, UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto, PlayerCheckStateDto } from '../../dto';
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 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 { MainFactoryOptions } from './main.interfaces';
 import { MAIN_OPTIONS } from './main.constants';
+import { MainTablesListScreenView } from './main-tables-list-screen.view';
 
 @Injectable()
 export class MainService {
-    constructor (
+
+    constructor(
         private readonly simpleRoomsManager: SimpleRoomsManagerService,
         private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
         private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
         private readonly playersManager: PlayersManagerService,
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly userRepository: UsersRepository,
+        private readonly activityLogRepository: ActivityLogRepository,
         @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
     ) {
+        dayjs.extend(isToday);
     }
 
-    async getScreen (lang: string): Promise<BaseAppScreenDto> {
-        const oneTableTournamentsCardList = this.oneTableRoomsManagerService.getRooms().map((room) =>
-            AppScreenSectionListItem.CreateCardListItemMini(
-                room.getId(),
-                room.getTitle(lang),
-                room.getSubtitle(lang),
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                true,
-                router.getRoomPath(room.getFirstMaster()?.getId() ?? ''),
-        ));
-
-        const manyTablesTournamentsCardList = this.manyTablesRoomsManagerService.getRooms().map((room) =>
-            AppScreenSectionListItem.CreateCardListItemExtended(
-                room.getId(),
-                room.getTitle(lang),
-                room.getSubtitle(lang),
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                true,
-                true,
-                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
-                room.getDescription(lang),
-                AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
-            ));
-
-        const simpleRoomsTableCardList = this.simpleRoomsManager.getRooms().reduce<Array<AppScreenSectionListItem>>((result, room) => {
-            const list = room.getTables().map((table) => AppScreenSectionListItem.CreateCardListItemMini(
-                    table.getId(),
-                    replacePattern(table.getTitle(lang), { NUMBER: table.getNumber().toString() }),
-                    replacePattern(table.getSubtitle(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];
-        }, []);
-
-        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',
-                        [
-                            ...manyTablesTournamentsCardList,
-                            ...oneTableTournamentsCardList,
-                            ...simpleRoomsTableCardList
-                        ]
-                    ),
-                );
-
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    getScreen(lang: string): BaseAppScreenDto {
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new MainTablesListScreenView(
+                    this.options.i18n,
+                    lang,
+                    this.simpleRoomsManager.getRooms(),
+                    this.oneTableRoomsManagerService.getRooms(),
+                    this.manyTablesRoomsManagerService.getRooms(),
+                ).build(),
+            )
+        );
     }
 
-    playerCheckState (clientAuthToken: string): PlayerCheckStateDto {
+    subscribeOnTablesScreen(clientAuthToken: string): Promise<void> {
         const player = this.playersManager.getPlayerById(clientAuthToken);
-        if (player && player.isPlayer() && player.tableId) {
-            return PlayerCheckStateDto.fromEntities(router.getRoomPath(player.tableId), player.id);
+
+        if (player) {
+            this.eventsBusMainTablesSubscribeService.addTablesSubscriber(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+
+        if (player) {
+            this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async playerCheckState(clientAuthToken: string, game: string): Promise<PlayerCheckStateDto> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        let redirectUrl: string = AppScreenRoutesEnum.MENU;
+
+        const foundUser = await this.userRepository.findById(clientAuthToken);
+        const isNewbie = await this.activityLogRepository.userIsNewbie(clientAuthToken)
+        const last7logins = await this.activityLogRepository.findLast7DaysLogins(game, clientAuthToken);
+
+        if (!foundUser) {
+            throw new InternalServerErrorException();
+        }
+
+        if (player?.isPlayer() && player.tableId) {
+            redirectUrl = router.getRoomPath(player.tableId);
+        } else if (isNewbie) {
+            redirectUrl = AppScreenRoutesEnum.WELCOME;
+        } else if (dayjs(last7logins[0].date).isToday() && last7logins[0].count === 1) {
+            redirectUrl = AppScreenRoutesEnum.TODAY_BONUS;
+        } else if (dayjs(foundUser.premiumExpired).isToday()) {
+            redirectUrl = AppScreenRoutesEnum.PREMIUM;
         }
 
-        return PlayerCheckStateDto.fromEntities(AppScreenRoutesEnum.MENU);
+        return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
     }
 
-    findFreeTable (clientAuthToken: string) {
+    findFreeTable(clientAuthToken: string) {
     }
 }

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

@@ -1 +1 @@
-export { ManyTablesTournamentModule } from './many-tables-tournament.module';
+export { ManyTablesTournamentModule } from './many-tables-tournament.module';

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

@@ -0,0 +1,59 @@
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionButtons,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+} from "jp.common.models";
+import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
+
+export class ManyTablesTournamentStatusScreenView extends UniversalScreenView {
+    private readonly tournament: ManyTablesTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: ManyTablesTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return AppScreen.CreateStatusScreen(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 })),
+                ),
+            )
+            .addSection((
+                AppScreenSection.CreateStatusHeader(
+                    'status',
+                    'description',
+                    AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                    AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
+                )
+            ))
+            .addSection(
+                AppScreenSection.CreateCardListSection(
+                    'id1',
+                    this.tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
+                        item.playerId,
+                        item.playerName,
+                        '',
+                        AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
+                        true,
+                        '',
+                    ))
+                ),
+            );
+    }
+}

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

@@ -0,0 +1,53 @@
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    router,
+} from "jp.common.models";
+import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
+
+export class ManyTablesTournamentTablesListScreenView extends UniversalScreenView {
+    private readonly tournament: ManyTablesTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: ManyTablesTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+            .addAppBar(
+                AppScreenAppBar.CreateStandardAppBar(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection(
+                AppScreenSection.CreateCardListSection(
+                    'id1',
+                    this.tournament?.getTables().map((table) =>
+                        AppScreenSectionListItem.CreateCardListItemMini(
+                            table.getId(),
+                            table.getTitle(this.lang),
+                            table.getSubtitle(this.lang),
+                            AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                            true,
+                            router.getRoomPath(table.getId()),
+                        )
+                    ) ?? []
+                ),
+            );
+    }
+}

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

@@ -8,21 +8,37 @@ import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tour
 
 @Controller('tournament/many_tables')
 export class ManyTablesTournamentController {
-    constructor (
+    constructor(
         private readonly tournamentService: ManyTablesTournamentService,
     ) {
     }
 
     @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);
+    }
+
     @Get('tables/:tournamentId')
-    getTableListScreen (
+    getTableListScreen(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): Promise<IBaseAppScreen> {
@@ -31,7 +47,7 @@ export class ManyTablesTournamentController {
 
     @Post('table/watch/:tableId')
     @HttpCode(HttpStatus.OK)
-    watchTheTable (
+    watchTheTable(
         @Param('tableId') tableId: string,
         @Headers() headers: IAppHeaders,
     ): IBaseTableGameState {
@@ -40,7 +56,7 @@ export class ManyTablesTournamentController {
 
     @Post('table/move/:tableId')
     @HttpCode(HttpStatus.OK)
-    moveOnTheTable (
+    moveOnTheTable(
         @Param('tableId') tableId: string,
         @Body() baseMoveData: IBaseMoveData,
         @Headers() headers: IAppHeaders,
@@ -50,7 +66,7 @@ export class ManyTablesTournamentController {
 
     @Post('join/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    joinTournament (
+    joinTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): JoinTournamentDto {
@@ -59,16 +75,25 @@ export class ManyTablesTournamentController {
 
     @Post('leave/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    leaveTournament (
+    leaveTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): IBaseTableGameState {
         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 (
+    createTournament(
         @Headers() headers: IAppHeaders,
         @Body() createTournamentDto: ManyTablesTournamentCreateDto,
     ): Promise<void> {
@@ -77,7 +102,7 @@ export class ManyTablesTournamentController {
 
     @Patch('update/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    updateTournament (
+    updateTournament(
         @Param('tournamentId') tournamentId: string,
         @Body() updateTournamentDto: ManyTablesTournamentUpdateDto,
         @Headers() headers: IAppHeaders,
@@ -87,7 +112,7 @@ export class ManyTablesTournamentController {
 
     @Delete('remove/:tournamentId')
     @HttpCode(HttpStatus.OK)
-    removeTournament (
+    removeTournament(
         @Param('tournamentId') tournamentId: string,
         @Headers() headers: IAppHeaders,
     ): Promise<void> {

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

@@ -1,6 +1,10 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema, TournamentManyTablesRoomsRepository } from 'jp.db.schemas';
+import { GamePlayer, ManyTablesTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+
+import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
+import { EventsBusManyTablesTournamentSubscribeService } from '../event-bus';
 
 import { ManyTablesTournamentController } from './many-tables-tournament.controller';
 import { ManyTablesTournamentService } from './many-tables-tournament.service';
@@ -15,11 +19,13 @@ import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.inte
     providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
 })
 export class ManyTablesTournamentModule {
-    constructor () {
-
-    }
+    constructor(
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+        private readonly manyTablesTournamentService: ManyTablesTournamentService,
+    ) { }
 
-    static forRootAsync (options: ManyTablesTournamentModuleOptions): DynamicModule {
+    static forRootAsync(options: ManyTablesTournamentModuleOptions): DynamicModule {
         return {
             module: ManyTablesTournamentModule,
             imports: options.imports ?? [],
@@ -32,5 +38,16 @@ export class ManyTablesTournamentModule {
             ],
         };
     }
+
+    async onModuleInit() {
+        this.eventsBusManyTablesTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
+    }
+
+    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));
+        });
+    }
 }