jp.ms.common.modules 1.0.18 → 1.0.21

package/src/modules/base-achievements/base-achievements.module.ts

@@ -0,0 +1,163 @@
+import { Global, InternalServerErrorException, Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
+  User,
+  UserSchema,
+  UsersRepository,
+  AchievementRepository,
+  Achievement,
+  AchievementSchema
+} from 'jp.db.schemas';
+import {
+  BaseAppEvent,
+  BaseUserAppEvent,
+  EarnOneMillionAchievement,
+  GotLevel10Achievement,
+  GotLevel3Achievement,
+  Playd10GamesAchievement,
+  SnackbarSendToPlayerWsEvent,
+  Take1PlaceOnManyTablesTournamentAchievement,
+  Take2Or3PlaceOnManyTablesTournamentAchievement,
+  UserGotNewLevelAppEvent,
+  UserPlayedTheGameAppEvent,
+  UserWonManyTablesTournamentAppEvent,
+  UserWonOneTableTournamentAppEvent,
+  UserWonTheGameAppEvent,
+  Won3GamesAchievement, Won3ProfiAchievement,
+  WonOneTableTournament3TimesAchievement
+} from 'jp.ms.common.engine';
+import { AppScreenIconEnum } from 'jp.common.models';
+
+import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
+import { PlayersManagerService } from '../players-manager';
+
+
+@Global()
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([{ name: ActivityLog.name, schema: ActivityLogSchema }]),
+    MongooseModule.forFeature([{ name: Achievement.name, schema: AchievementSchema }]),
+  ],
+  providers: [
+    UsersRepository,
+    ActivityLogRepository,
+    AchievementRepository,
+    EventsBusAppSubscribeService,
+  ],
+})
+export abstract class BaseAchievementsModule {
+  constructor(
+    protected readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
+    protected readonly playersManager: PlayersManagerService,
+    protected readonly usersRepository: UsersRepository,
+    protected readonly activityLogRepository: ActivityLogRepository,
+    protected readonly achievementRepository: AchievementRepository,
+  ) {
+  }
+
+  async onModuleInit() {
+    this.eventsBusAppSubscribeService.subscribe(this.onHandleAppEvent);
+  }
+
+  protected async onHandleAppEvent(event: BaseAppEvent) {
+    if (event instanceof BaseUserAppEvent) {
+      const userId = event.userId;
+      const player = this.playersManager.getPlayerById(userId);
+      const foundUser = await this.usersRepository.findById(userId);
+      const allAchievements: Array<Achievement> = await this.achievementRepository.findAchievements();
+
+      if (!player || !foundUser) {
+        throw new InternalServerErrorException();
+      }
+
+      if (event instanceof UserGotNewLevelAppEvent) {
+        // TODO подумать куда перенести LEVEL UP 
+        player.sendMessage(new SnackbarSendToPlayerWsEvent(
+          AppScreenIconEnum.ARROW_UPWARD,
+          'level up',
+          'buttonText'
+        ));
+
+        if (foundUser.hasNoAchievement(GotLevel3Achievement.code)) {
+          if (new GotLevel3Achievement(event.newLevel).userGotAchievement()) {
+            this.giveAchievement(allAchievements, GotLevel3Achievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(GotLevel10Achievement.code)) {
+          if (new GotLevel10Achievement(event.newLevel).userGotAchievement()) {
+            this.giveAchievement(allAchievements, GotLevel10Achievement.code, userId);
+          }
+        }
+
+      } else if (event instanceof UserPlayedTheGameAppEvent) {
+        if (foundUser.hasNoAchievement(Playd10GamesAchievement.code)) {
+          const playdGamesCount = await this.activityLogRepository.getUserPlayedGamesCount(userId);
+
+          if (new Playd10GamesAchievement(playdGamesCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Playd10GamesAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonTheGameAppEvent) {
+        if (foundUser.hasNoAchievement(Won3GamesAchievement.code)) {
+          const wonGamesCount = await this.activityLogRepository.getUserWonGamesCount(userId);
+
+          if (new Won3GamesAchievement(wonGamesCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Won3GamesAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(Won3ProfiAchievement.code)) {
+          const wonProfiCount = await this.activityLogRepository.getUserWonProfiCount(userId);
+          if (new Won3ProfiAchievement(wonProfiCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Won3ProfiAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(EarnOneMillionAchievement.code)) {
+          if (new EarnOneMillionAchievement(foundUser.balance).userGotAchievement()) {
+            this.giveAchievement(allAchievements, EarnOneMillionAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonOneTableTournamentAppEvent) {
+        if (foundUser.hasNoAchievement(WonOneTableTournament3TimesAchievement.code)) {
+          const wonFastTournamentCount = await this.activityLogRepository.getUserWonOneTableTournamentCount(userId);
+          if (new WonOneTableTournament3TimesAchievement(wonFastTournamentCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, WonOneTableTournament3TimesAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonManyTablesTournamentAppEvent) {
+        if (foundUser.hasNoAchievement(Take1PlaceOnManyTablesTournamentAchievement.code)) {
+          if (new Take1PlaceOnManyTablesTournamentAchievement(event.rank)) {
+            this.giveAchievement(allAchievements, Take1PlaceOnManyTablesTournamentAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(Take2Or3PlaceOnManyTablesTournamentAchievement.code)) {
+          if (new Take2Or3PlaceOnManyTablesTournamentAchievement(event.rank)) {
+            this.giveAchievement(allAchievements, Take2Or3PlaceOnManyTablesTournamentAchievement.code, userId);
+          }
+        }
+      }
+    }
+  }
+
+  protected async giveAchievement(allAchievements: Array<Achievement>, achievementCode: string, userId: string) {
+    const foundAchievement = allAchievements.find((item) => item.code === achievementCode);
+    const player = this.playersManager.getPlayerById(userId);
+
+    if (foundAchievement && player) {
+      await this.usersRepository.addAchievement(userId, achievementCode);
+
+      player.sendMessage(new SnackbarSendToPlayerWsEvent(
+        AppScreenIconEnum.EMOJI_EVENTS,
+        foundAchievement.title,
+        foundAchievement.description
+      ));
+    }
+  }
+}

package/src/modules/base-achievements/index.ts

@@ -0,0 +1 @@
+export { BaseAchievementsModule } from './base-achievements.module';

package/src/modules/event-bus/events-bus.app.subscribe.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { BaseAppEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+
+@Injectable()
+export class EventsBusAppSubscribeService {
+    private readonly appEventSubject: Subject<BaseAppEvent>;
+
+    constructor() {
+        this.appEventSubject = new Subject<BaseAppEvent>();
+    }
+
+    pushNewEvent(event: BaseAppEvent) {
+        this.appEventSubject.next(event);
+    }
+
+    subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
+        this.appEventSubject.subscribe(onHandleAppEvent);
+    }
+}

package/src/modules/event-bus/events-bus.main-tables.subscribe.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from "@nestjs/common";
+import { GamePlayer, RoomUpdateStateEvent } from "jp.ms.common.engine";
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class EventsBusMainTablesSubscribeService {
+    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+    private readonly tablesSubscribers: Map<string, GamePlayer>;
+
+    constructor() {
+        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+        this.tablesSubscribers = new Map();
+    }
+
+    getTablesSubscribers() {
+        return Array.from(this.tablesSubscribers.values());
+    }
+
+    addTablesSubscriber(player: GamePlayer) {
+        this.tablesSubscribers.set(player.id, player);
+    }
+
+    removeTablesSubbcriber(player: GamePlayer) {
+        this.tablesSubscribers.delete(player.id);
+    }
+
+    pushNewRoomState(event: RoomUpdateStateEvent) {
+        this.roomStatesSubject.next(event);
+    }
+
+    subscribe(onHandleStatusRoomChange: () => void) {
+        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+    }
+}

package/src/modules/event-bus/events-bus.many-tables-tournament.subscribe.service.ts

@@ -0,0 +1,6 @@
+import { Injectable } from "@nestjs/common";
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.module.ts

@@ -0,0 +1,23 @@
+import { Global, Module } from '@nestjs/common';
+
+import { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+import { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+import { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+
+@Global()
+@Module({
+  providers: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+  ],
+  exports: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+  ]
+})
+export class EventsBusModule { }

package/src/modules/event-bus/events-bus.one-table-tournament.subscribe.service.ts

@@ -0,0 +1,6 @@
+import { Injectable } from "@nestjs/common";
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.tournament.subscribe.service.ts

@@ -0,0 +1,19 @@
+import { RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+
+export abstract class EventsBusTournamentSubscribeService {
+    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+
+    constructor() {
+        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+    }
+
+    pushNewRoomState(event: RoomUpdateStateEvent) {
+        this.roomStatesSubject.next(event);
+    }
+
+    subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+    }
+}

package/src/modules/event-bus/index.ts

@@ -0,0 +1,5 @@
+export { EventsBusModule } from './events-bus.module';
+export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+export { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+export { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';

package/src/modules/events/events.module.ts

@@ -2,7 +2,7 @@ import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { User, UserSchema, UsersRepository } from 'jp.db.schemas';
 
-import { PlayersManagerModule } from '../players-manager/players-manager.module';
+import { PlayersManagerModule } from '../players-manager';
 
 import { EventsGateway } from './events.gateway';
 import { EventsModuleOptions } from './events.interfaces';

package/src/modules/events/index.ts

@@ -0,0 +1 @@
+export { EventsModule } from './events.module';

package/src/modules/index.ts

@@ -1,27 +1,21 @@
-import { PlayersManagerModule } from './players-manager/players-manager.module';
-import { PlayersManagerService } from './players-manager/players-manager.service';
-import { MenuModule } from './menu/menu.module';
-import { MenuService } from './menu/menu.service';
-import { MenuController } from './menu/menu.controller';
-import { EventsModule } from './events/events.module';
-import { SimpleRoomsManagerModule } from './simple-rooms-manager/simple-rooms-manager.module';
-import { SimpleRoomsManagerService } from './simple-rooms-manager/simple-rooms-manager.service';
-import { RoomsModule } from './rooms/rooms.module';
-import { SupportModule } from './support/support.module';
-import { JpLoggerModule } from './logger/jp-logger.module';
-import { JpLoggerService } from './logger/jp-logger.service';
-
+export { AntiFreezeSystemModule } from './anti-freeze-system';
+export { EventsModule } from './events';
+export { JpLoggerService, JpLoggerModule } from './logger';
+export { MainModule } from './main';
+export { ManyTablesTournamentModule } from './many-tables-tournament';
+export { MenuModule } from './menu';
+export { OneTableTournamentModule } from './one-table-tournament';
+export { PlayersManagerService, PlayersManagerModule } from './players-manager';
+export { SimpleRoomsModule } from './simple-rooms';
+export { SimpleRoomsManagerService, SimpleRoomsManagerModule } from './simple-rooms-manager';
+export { SupportModule } from './support';
 export {
-    PlayersManagerModule,
-    PlayersManagerService,
-    MenuModule,
-    MenuService,
-    MenuController,
-    EventsModule,
-    SimpleRoomsManagerModule,
-    SimpleRoomsManagerService,
-    RoomsModule,
-    SupportModule,
-    JpLoggerModule,
-    JpLoggerService,
-}
+    TournamentManyTablesRoomsManagerService,
+    TournamentManyTablesRoomsManagerModule,
+} from './tournament-many-tables-rooms-manager';
+export {
+    TournamentOneTableRoomsManagerService,
+    TournamentOneTableRoomsManagerModule,
+} from './tournament-one-table-rooms-manager';
+export { EventsBusModule, EventsBusMainTablesSubscribeService } from './event-bus'
+export { BaseAchievementsModule } from './base-achievements/base-achievements.module'

package/src/modules/logger/index.ts

@@ -0,0 +1,2 @@
+export { JpLoggerModule } from './jp-logger.module';
+export { JpLoggerService } from './jp-logger.service';

package/src/modules/main/index.ts

@@ -0,0 +1 @@
+export { MainModule } from './main.module';

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.constants.ts

@@ -0,0 +1 @@
+export const MAIN_OPTIONS = Symbol('MAIN_OPTIONS');

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

@@ -0,0 +1,38 @@
+import { Controller, Get, Headers } from '@nestjs/common';
+import { IAppHeaders, IBaseAppScreen } from 'jp.common.models';
+
+import { PlayerCheckStateDto } from '../../dto';
+
+import { MainService } from './main.service';
+
+@Controller('main')
+export class MainController {
+    constructor(
+        private readonly mainService: MainService,
+    ) { }
+
+    @Get('player/check/state')
+    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);
+    }
+
+    @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) {
+        return this.mainService.findFreeTable(headers.client_auth_token);
+    }
+}

package/src/modules/{rooms/rooms.interfaces.ts → main/main.interfaces.ts}

@@ -3,15 +3,13 @@ import { I18nService } from 'nestjs-i18n';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
 import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
-import { IBaseTableGameState } from 'jp.common.models';
 
-export interface RoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+export interface MainModuleOptions extends Pick<ModuleMetadata, 'imports'> {
     imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
     inject?: any[];
     useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
-export interface RoomsFactoryOptions {
+export interface MainFactoryOptions {
     i18n: I18nService
-    createTableDto: (data: object) => IBaseTableGameState
 }

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

@@ -0,0 +1,56 @@
+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';
+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,
+        UsersRepository,
+        ActivityLogRepository,
+    ]
+})
+export class MainModule {
+    constructor(
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly mainService: MainService,
+    ) { }
+
+    static forRootAsync(options: MainModuleOptions): DynamicModule {
+        return {
+            module: MainModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: MAIN_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+
+    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));
+        });
+    }
+}
+