jp.ms.common.modules 1.0.20 → 1.0.21

package/dist/views/index.d.ts

@@ -0,0 +1 @@
+export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';

package/dist/views/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentBuyTicketDialogView = void 0;
+var tournament_buy_ticket_dialog_view_1 = require("./tournament-buy-ticket-dialog.view");
+Object.defineProperty(exports, "TournamentBuyTicketDialogView", { enumerable: true, get: function () { return tournament_buy_ticket_dialog_view_1.TournamentBuyTicketDialogView; } });
+//# sourceMappingURL=index.js.map

package/dist/views/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/views/index.ts"],"names":[],"mappings":";;;AAAA,yFAAoF;AAA3E,kJAAA,6BAA6B,OAAA"}

package/dist/views/tournament-buy-ticket-dialog.view.d.ts

@@ -0,0 +1,4 @@
+import { UniversalScreenDialogView, AppScreenDialog } from "jp.common.models";
+export declare class TournamentBuyTicketDialogView extends UniversalScreenDialogView {
+    build(): AppScreenDialog;
+}

package/dist/views/tournament-buy-ticket-dialog.view.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentBuyTicketDialogView = void 0;
+const jp_common_models_1 = require("jp.common.models");
+class TournamentBuyTicketDialogView extends jp_common_models_1.UniversalScreenDialogView {
+    build() {
+        return jp_common_models_1.AppScreenDialog.CreateStandardDialog(jp_common_models_1.AppScreenDialogIdEnum.DIALOG_TOURNAMENT_BUY_TICKET, this.localeService.t('common.rooms.screen.buyTicket.title', { lang: this.lang }), this.localeService.t('common.rooms.screen.buyTicket.description', { lang: this.lang }), jp_common_models_1.AppScreenSectionButtons.CreateFullButtonSection(jp_common_models_1.AppScreenSectionButton.CreateTextButton('Ok'), jp_common_models_1.AppScreenSectionButton.CreateTextButton('Cancel')));
+    }
+}
+exports.TournamentBuyTicketDialogView = TournamentBuyTicketDialogView;
+//# sourceMappingURL=tournament-buy-ticket-dialog.view.js.map

package/dist/views/tournament-buy-ticket-dialog.view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament-buy-ticket-dialog.view.js","sourceRoot":"","sources":["../../src/views/tournament-buy-ticket-dialog.view.ts"],"names":[],"mappings":";;;AAAA,uDAM2B;AAE3B,MAAa,6BAA8B,SAAQ,4CAAyB;IACxE,KAAK;QACD,OAAO,kCAAe,CAAC,oBAAoB,CACvC,wCAAqB,CAAC,4BAA4B,EAClD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,qCAAqC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,EAChF,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,2CAA2C,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,EACtF,0CAAuB,CAAC,uBAAuB,CAC3C,yCAAsB,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAC7C,yCAAsB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CACpD,CACJ,CAAC;IACN,CAAC;CACJ;AAZD,sEAYC"}

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "dayjs": "1.11.18",
     "@nestjs/common": "11.1.0",
     "@nestjs/config": "4.0.2",
     "@nestjs/core": "11.1.0",
     "@nestjs/mongoose": "11.0.4",
     "@nestjs/websockets": "11.1.9",
-    "jp.common.models": "1.0.10",
+    "dayjs": "1.11.18",
+    "jp.common.models": "1.1.1",
     "jp.common.utils": "1.0.2",
-    "jp.db.schemas": "2.0.9",
-    "jp.ms.common.engine": "3.0.4",
+    "jp.db.schemas": "2.1.10",
+    "jp.ms.common.engine": "3.0.8",
     "mongoose": "9.1.5",
-    "node-schedule": "2.1.1",
     "nestjs-i18n": "10.5.1",
+    "node-schedule": "2.1.1",
     "prom-client": "^15.1.0",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
@@ -43,4 +43,4 @@
     "src",
     "dist"
   ]
-}
+}

package/src/dto/app-screen/app-screen-dialog.dto.ts

@@ -0,0 +1,57 @@
+import { Expose, Type } from 'class-transformer';
+import { IAppScreenDialog } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+
+import { AppScreenSectionButtonsDto } from './app-screen-section-buttons.dto';
+
+export class AppScreenDialogDto implements IAppScreenDialog {
+  @ApiProperty({
+    description: 'id',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  id: string;
+
+  @ApiProperty({
+    description: 'type',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  type: string;
+
+  @ApiProperty({
+    description: 'isOpen',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsString()
+  isOpen: boolean;
+
+  @ApiProperty({
+    description: 'title',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  title: string;
+
+  @ApiProperty({
+    description: 'description',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  description?: string;
+
+  @Type(() => AppScreenSectionButtonsDto)
+  @Expose()
+  buttons: AppScreenSectionButtonsDto;
+}

package/src/dto/app-screen/app-screen.dto.ts

@@ -1,10 +1,11 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { Expose, Type } from 'class-transformer';
+import { Expose, plainToInstance, Type } from 'class-transformer';
 import { IsArray, IsString, ValidateNested } from 'class-validator';
 import { IAppScreen } from 'jp.common.models';
 
 import { AppScreenSectionDto } from './app-screen-section.dto';
 import { AppScreenAppBarDto } from './app-screen-app-bar.dto';
+import { AppScreenDialogDto } from './app-screen-dialog.dto';
 
 export class AppScreenDto implements IAppScreen {
   @ApiProperty({
@@ -31,7 +32,17 @@ export class AppScreenDto implements IAppScreen {
   @Expose()
   sections: Array<AppScreenSectionDto>;
 
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => AppScreenDialogDto)
+  @Expose()
+  dialogs?: Array<AppScreenDialogDto>;
+
   @Type(() => AppScreenAppBarDto)
   @Expose()
   appBar?: AppScreenAppBarDto;
+
+  constructor(screen: IAppScreen) {
+    return plainToInstance(AppScreenDto, screen, { excludeExtraneousValues: true });
+  }
 }

package/src/dto/common/player-check-state.dto.ts

@@ -10,7 +10,7 @@ export class PlayerCheckStateDto {
     })
     @Expose()
     @IsString()
-    playerId?: string;
+    playerId: string;
 
     @ApiProperty({
         description: 'redirect link',
@@ -21,7 +21,7 @@ export class PlayerCheckStateDto {
     @IsString()
     redirectUrl: string;
 
-    static fromEntities(redirectUrl: string, playerId?: string): PlayerCheckStateDto {
+    static fromEntities(redirectUrl: string, playerId: string): PlayerCheckStateDto {
         const dto = new PlayerCheckStateDto();
         dto.redirectUrl = redirectUrl;
         dto.playerId = playerId

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/index.ts

@@ -17,4 +17,5 @@ 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/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);
     }
 }