jp.ms.common.modules 1.0.40 → 1.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,10 +13,10 @@
     "@nestjs/mongoose": "11.0.4",
     "@nestjs/websockets": "11.1.9",
     "dayjs": "1.11.18",
-    "jp.common.models": "1.1.32",
-    "jp.common.utils": "1.0.5",
-    "jp.db.schemas": "2.2.12",
-    "jp.ms.common.engine": "3.0.21",
+    "jp.common.models": "1.1.45",
+    "jp.common.utils": "1.0.6",
+    "jp.db.schemas": "2.2.14",
+    "jp.ms.common.engine": "3.0.25",
     "mongoose": "9.1.5",
     "nestjs-i18n": "10.5.1",
     "node-schedule": "2.1.1",

package/src/dto/app-table/bids-panel-item.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+import { IsString } from 'class-validator';
+import { IAppTableBidsPanelItem } from 'jp.common.models';
+
+export class BidsPanelItemDto implements IAppTableBidsPanelItem {
+  @ApiProperty({
+    description: 'key',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  key: string;
+
+  @ApiProperty({
+    description: 'value',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  value: string;
+
+  @ApiProperty({
+    description: 'Title',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  title: string;
+}

package/src/dto/app-table/bids-panel.dto.ts

@@ -0,0 +1,32 @@
+import { Expose, Type } from 'class-transformer';
+import { IsArray, IsBoolean, IsString, ValidateNested } from 'class-validator';
+import { IAppTableBidsPanel } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { BidsPanelItemDto } from './bids-panel-item.dto';
+
+export class BidsPanelDto implements IAppTableBidsPanel {
+  @ApiProperty({
+    description: 'description',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  description: string;
+
+  @ApiProperty({
+    description: 'isOpen',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  isOpen: boolean;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => BidsPanelItemDto)
+  @Expose()
+  bids: Array<BidsPanelItemDto>;
+}

package/src/dto/app-table/index.ts

@@ -11,3 +11,5 @@ export { MovesPanelDto } from './moves-panel.dto';
 export { PlayerDto } from './player.dto';
 export { SummaryDto } from './summary.dto';
 export { SummaryItemDto } from './summary-item.dto';
+export { BidsPanelDto } from './bids-panel.dto';
+export { BidsPanelItemDto } from './bids-panel-item.dto';

package/src/dto/games/poker/poker-table.dto.ts

@@ -9,6 +9,7 @@ import {
   CardsSlotsDto,
   MovesPanelDto,
   SummaryDto,
+  BidsPanelDto,
 } from '../../app-table';
 
 import { PokerPlayerDto } from './poker-player.dto';
@@ -68,6 +69,10 @@ export class PokerTableDto implements IPokerTable {
   @Expose()
   movesPanel: MovesPanelDto;
 
+  @Type(() => BidsPanelDto)
+  @Expose()
+  bidsPanel: BidsPanelDto;
+
   constructor(entity: IPokerTable) {
     return plainToInstance(PokerTableDto, entity, {
       excludeExtraneousValues: true,

package/src/modules/anti-freeze-system/anti-freeze-system.module.ts

@@ -7,6 +7,8 @@ import {
 } from '@nestjs/common';
 import schedule, { Job } from 'node-schedule';
 
+import { JpLoggerService } from '../logger';
+
 import { AntiFreezeSystemService } from './anti-freeze-system.service';
 import { ANTI_FREEZE_SYSTEM_OPTIONS } from './anti-freeze-system.constants';
 import {
@@ -25,6 +27,7 @@ export class AntiFreezeSystemModule {
     private readonly antiFreezeSystemService: AntiFreezeSystemService,
     @Inject(ANTI_FREEZE_SYSTEM_OPTIONS)
     private readonly options: AntiFreezeSystemFactoryOptions,
+    @Inject() private readonly logger: JpLoggerService,
   ) {}
 
   static forRootAsync(options: AntiFreezeSystemOptions): DynamicModule {
@@ -43,12 +46,13 @@ export class AntiFreezeSystemModule {
 
   onModuleInit() {
     const antiFreezeSystemTime = this.options.antiFreezeSystemTime;
-    const antiFreezeSystemCheckCount = this.options.antiFreezeSystemCheckCount;
 
     if (antiFreezeSystemTime) {
+      this.logger.log(`${AntiFreezeSystemModule.name}: scheduleJob`);
+
       this.antiFreezeSystemJob = schedule.scheduleJob(
         antiFreezeSystemTime,
-        () => this.antiFreezeSystemService.process(antiFreezeSystemCheckCount),
+        () => this.antiFreezeSystemService.process(),
       );
     }
   }

package/src/modules/anti-freeze-system/anti-freeze-system.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import {
   GameRoom,
   ManyTablesTournamentRoom,
@@ -9,6 +9,10 @@ import {
 import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
 import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
 import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
+import { JpLoggerService } from '../logger';
+
+import { AntiFreezeSystemFactoryOptions } from './anti-freeze-system.interfaces';
+import { ANTI_FREEZE_SYSTEM_OPTIONS } from './anti-freeze-system.constants';
 
 export interface IRoomSetItem {
   tableId: string;
@@ -25,13 +29,16 @@ export class AntiFreezeSystemService {
     private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
     private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
     private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+    @Inject() private readonly logger: JpLoggerService,
+    @Inject(ANTI_FREEZE_SYSTEM_OPTIONS)
+    private readonly options: AntiFreezeSystemFactoryOptions,
   ) {
     this.prevSet = new Map<string, IRoomSetItem>();
   }
 
-  process(checkCount: number) {
+  process() {
     this.mergeSets();
-    this.clear(checkCount);
+    this.clear();
   }
 
   private mergeSets() {
@@ -48,6 +55,10 @@ export class AntiFreezeSystemService {
             ...currentSetItem,
             count: prevSetItem.count + 1,
           });
+
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: tableId: ${prevSetItem.tableId}, count: ${prevSetItem.count}`,
+          );
         } else {
           newSet.set(currentSetKey, currentSetItem);
         }
@@ -79,20 +90,40 @@ export class AntiFreezeSystemService {
     return newSet;
   }
 
-  private clear(checkCount: number) {
+  private clear() {
     this.prevSet.forEach((item) => {
-      if (item.count === checkCount) {
+      if (item.count === this.options.antiFreezeSystemCheckCount) {
         if (item.room instanceof OneTableTournamentRoom) {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: cancel tournamentId: ${item.room.getId()}`,
+          );
           const room = this.oneTableRoomsManagerService.getRoomByTableId(
             item.tableId,
           );
-          room?.getRoomMaster<TournamentMaster>().cancelTournament();
+          room?.getTables().forEach((table) => {
+            table.getPlayers().forEach((player) => {
+              room?.handleLeaveTournament(player);
+            });
+          });
+          room?.getRoomMaster<TournamentMaster>().onTournamentCancel();
         } else if (item.room instanceof ManyTablesTournamentRoom) {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: cancel tournamentId: ${item.room.getId()}`,
+          );
           const room = this.manyTablesRoomsManagerService.getRoomByTableId(
             item.tableId,
           );
-          room?.getRoomMaster<TournamentMaster>().cancelTournament();
+          room?.getTables().forEach((table) => {
+            table.getPlayers().forEach((player) => {
+              room?.handleLeaveTournament(player);
+            });
+          });
+          room?.getRoomMaster<TournamentMaster>().onTournamentCancel();
         } else {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: restart tableId: ${item.tableId}`,
+          );
+
           this.simpleRoomsManagerService
             .getRoomByTableId(item.tableId)
             ?.restartTable(item.tableId);

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

@@ -33,7 +33,7 @@ import {
   Won3ProfiAchievement,
   WonOneTableTournament3TimesAchievement,
 } from 'jp.ms.common.engine';
-import { AppScreenIconEnum } from 'jp.common.models';
+import { AppScreenIconEnum, LanguageTypeEnum } from 'jp.common.models';
 
 import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
 import { PlayersManagerService } from '../players-manager';
@@ -82,7 +82,7 @@ export abstract class BaseAchievementsModule {
       const player = this.playersManager.getPlayerById(userId);
       const foundUser = await this.usersRepository.findById(userId);
       const allAchievements: Array<Achievement> =
-        await this.achievementRepository.findAchievements();
+        await this.achievementRepository.findAchievements(event.game);
       const usersAchievements: Array<UsersAchievement> =
         await this.usersAchievementRepository.findAchivementsByUserId(userId);
 
@@ -95,6 +95,7 @@ export abstract class BaseAchievementsModule {
         player.sendMessage(
           new SnackbarSendToPlayerWsEvent(
             event.game,
+            player.id,
             AppScreenIconEnum.ARROW_UPWARD,
             'level up',
             'buttonText',
@@ -303,7 +304,7 @@ export abstract class BaseAchievementsModule {
         user.userId,
         user.fullName,
         foundAchievement.achievementId,
-        foundAchievement.title,
+        foundAchievement.title[LanguageTypeEnum.RU],
         foundAchievement.code,
         foundAchievement.prize,
         '',
@@ -312,9 +313,10 @@ export abstract class BaseAchievementsModule {
       player.sendMessage(
         new SnackbarSendToPlayerWsEvent(
           game,
+          player.id,
           AppScreenIconEnum.EMOJI_EVENTS,
-          foundAchievement.title,
-          foundAchievement.description,
+          foundAchievement.title[player.language],
+          foundAchievement.description[player.language],
         ),
       );
     }

package/src/modules/confirmation-message-manager/confirmation-message-manager.constants.ts

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

package/src/modules/confirmation-message-manager/confirmation-message-manager.interfaces.ts

@@ -0,0 +1,20 @@
+import { ModuleMetadata } from '@nestjs/common';
+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';
+
+export interface ConfirmationMessageManagerOptions extends Pick<
+  ModuleMetadata,
+  'imports'
+> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => ConfirmationMessageManagerFactoryOptions;
+}
+
+export interface ConfirmationMessageManagerFactoryOptions {
+  confirmationMessageManagerTime: string;
+  confirmationMessageManagerAttemptCount: number;
+}

package/src/modules/confirmation-message-manager/confirmation-message-manager.module.ts

@@ -0,0 +1,77 @@
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
+import schedule, { Job } from 'node-schedule';
+import { BaseWsEvent } from 'jp.ms.common.engine';
+
+import { JpLoggerService } from '../logger';
+import { EventsBusPlayerWsMessageSubscribeService } from '../event-bus';
+
+import { ConfirmationMessageManagerService } from './confirmation-message-manager.service';
+import {
+  ConfirmationMessageManagerFactoryOptions,
+  ConfirmationMessageManagerOptions,
+} from './confirmation-message-manager.interfaces';
+import { CONFIRMATION_MESSAGE_MANAGER_OPTIONS } from './confirmation-message-manager.constants';
+
+@Global()
+@Module({
+  providers: [ConfirmationMessageManagerService],
+  exports: [ConfirmationMessageManagerService],
+})
+export class ConfirmationMessageManagerModule {
+  private confirmationMessageManagerJob: Job;
+
+  constructor(
+    private readonly confirmationMessageManagerService: ConfirmationMessageManagerService,
+    private readonly eventsBusPlayerWsMessageSubscribeService: EventsBusPlayerWsMessageSubscribeService,
+    @Inject(CONFIRMATION_MESSAGE_MANAGER_OPTIONS)
+    private readonly options: ConfirmationMessageManagerFactoryOptions,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {}
+
+  static forRootAsync(
+    options: ConfirmationMessageManagerOptions,
+  ): DynamicModule {
+    return {
+      module: ConfirmationMessageManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: CONFIRMATION_MESSAGE_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+
+  onModuleInit() {
+    this.eventsBusPlayerWsMessageSubscribeService.subscribeOnSendMessage(
+      (wsEvent: BaseWsEvent) => {
+        this.confirmationMessageManagerService.addToQueue(wsEvent);
+      },
+    );
+
+    this.eventsBusPlayerWsMessageSubscribeService.subscribeOnGotMessageFromClient(
+      (wsEvent: BaseWsEvent) => {
+        this.confirmationMessageManagerService.removeFromQueue(wsEvent.key);
+      },
+    );
+
+    const confirmationMessageManagerTime =
+      this.options.confirmationMessageManagerTime;
+
+    if (confirmationMessageManagerTime) {
+      this.logger.log(`${ConfirmationMessageManagerModule.name}: scheduleJob`);
+      this.confirmationMessageManagerJob = schedule.scheduleJob(
+        confirmationMessageManagerTime,
+        () => this.confirmationMessageManagerService.process(),
+      );
+    }
+  }
+}

package/src/modules/confirmation-message-manager/confirmation-message-manager.service.ts

@@ -0,0 +1,91 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { BaseWsEvent } from 'jp.ms.common.engine';
+
+import { PlayersManagerService } from '../players-manager';
+import { JpLoggerService } from '../logger';
+
+import { CONFIRMATION_MESSAGE_MANAGER_OPTIONS } from './confirmation-message-manager.constants';
+import { ConfirmationMessageManagerFactoryOptions } from './confirmation-message-manager.interfaces';
+
+interface IGameMessageConfirmationManagerMessage {
+  event: BaseWsEvent;
+  repeatCount: number;
+}
+
+@Injectable()
+export class ConfirmationMessageManagerService {
+  private queue: Map<string, IGameMessageConfirmationManagerMessage>;
+  private jobId: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly playersManagerService: PlayersManagerService,
+    @Inject(CONFIRMATION_MESSAGE_MANAGER_OPTIONS)
+    private readonly options: ConfirmationMessageManagerFactoryOptions,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.queue = new Map<string, IGameMessageConfirmationManagerMessage>();
+  }
+
+  getByKey(key: string) {
+    this.queue.get(key);
+  }
+
+  addToQueue(message: BaseWsEvent): void {
+    this.logger.log(
+      `${ConfirmationMessageManagerService.name}: add to queue ws message key: ${message.key}, type: ${message.type}`,
+    );
+
+    const foundMessage = this.queue.get(message.key);
+
+    if (foundMessage) {
+      foundMessage.repeatCount += 1;
+    } else {
+      this.queue.set(message.key, {
+        event: message,
+        repeatCount: 0,
+      });
+    }
+  }
+
+  removeFromQueue(key: string): void {
+    this.logger.log(
+      `${ConfirmationMessageManagerService.name}: remove from queue ws message key: ${key}`,
+    );
+
+    this.queue.delete(key);
+  }
+
+  process() {
+    this.clearQueue();
+    this.repeatSendingMessages();
+  }
+
+  private isExpired(message: IGameMessageConfirmationManagerMessage): boolean {
+    return (
+      message.repeatCount >= this.options.confirmationMessageManagerAttemptCount
+    );
+  }
+
+  private clearQueue(): void {
+    for (const [key, message] of this.queue) {
+      if (this.isExpired(message)) {
+        this.logger.log(
+          `${ConfirmationMessageManagerService.name}: clear expired ws message key: ${message.event.key}, type: ${message.event.type}`,
+        );
+        this.queue.delete(key);
+      }
+    }
+  }
+
+  private repeatSendingMessages(): void {
+    for (const [, message] of this.queue) {
+      const foundPlayer = this.playersManagerService.getPlayerById(
+        message.event.playerId,
+      );
+      this.logger.log(
+        `${ConfirmationMessageManagerService.name}: repeat ws message key: ${message.event.key}, type: ${message.event.type}, repeatCount: ${message.repeatCount}`,
+      );
+      foundPlayer?.sendMessage(message.event);
+    }
+  }
+}

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

@@ -4,6 +4,7 @@ import { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.su
 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';
+import { EventsBusPlayerWsMessageSubscribeService } from './events-bus.player-ws-message.subscribe.service';
 
 @Global()
 @Module({
@@ -12,12 +13,14 @@ import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service
     EventsBusOneTableTournamentSubscribeService,
     EventsBusManyTablesTournamentSubscribeService,
     EventsBusAppSubscribeService,
+    EventsBusPlayerWsMessageSubscribeService,
   ],
   exports: [
     EventsBusMainTablesSubscribeService,
     EventsBusOneTableTournamentSubscribeService,
     EventsBusManyTablesTournamentSubscribeService,
     EventsBusAppSubscribeService,
+    EventsBusPlayerWsMessageSubscribeService,
   ],
 })
 export class EventsBusModule {}

package/src/modules/event-bus/events-bus.player-ws-message.subscribe.service.ts

@@ -0,0 +1,30 @@
+import { BaseWsEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+export class EventsBusPlayerWsMessageSubscribeService {
+  private readonly subjectSendMessage: Subject<BaseWsEvent>;
+  private readonly subjectGotMessage: Subject<BaseWsEvent>;
+
+  constructor() {
+    this.subjectSendMessage = new Subject<BaseWsEvent>();
+    this.subjectGotMessage = new Subject<BaseWsEvent>();
+  }
+
+  pushSendMessage(event: BaseWsEvent) {
+    this.subjectSendMessage.next(event);
+  }
+
+  pushGotMessage(event: BaseWsEvent) {
+    this.subjectGotMessage.next(event);
+  }
+
+  subscribeOnSendMessage(onHandleWsEvent: (event: BaseWsEvent) => void) {
+    this.subjectSendMessage.subscribe(onHandleWsEvent);
+  }
+
+  subscribeOnGotMessageFromClient(
+    onHandleWsEvent: (event: BaseWsEvent) => void,
+  ) {
+    this.subjectGotMessage.subscribe(onHandleWsEvent);
+  }
+}

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

@@ -3,3 +3,4 @@ export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.su
 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';
+export { EventsBusPlayerWsMessageSubscribeService } from './events-bus.player-ws-message.subscribe.service';

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

@@ -7,8 +7,10 @@ import {
 import { Server, Socket } from 'socket.io';
 import { UsersRepository } from 'jp.db.schemas';
 import { Inject } from '@nestjs/common';
+import { BaseWsEvent } from 'jp.ms.common.engine';
 
 import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { EventsBusPlayerWsMessageSubscribeService } from '../event-bus';
 
 import { EVENTS_OPTIONS } from './events.constants';
 import { EventsFactoryOptions } from './events.interfaces';
@@ -23,6 +25,7 @@ export class EventsGateway
   constructor(
     private readonly playersManager: PlayersManagerService,
     private readonly usersRepository: UsersRepository,
+    private readonly eventsBusPlayerWsMessageSubscribeService: EventsBusPlayerWsMessageSubscribeService,
     @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
   ) {}
 
@@ -43,6 +46,8 @@ export class EventsGateway
           experience: user.experience,
           level: user.level,
           language: user.normalizedLang,
+          onSendWsMessage: this.handleSendWsMessage,
+          onGotWsMessageClientResponse: this.handleGotWsMessageClientResponse,
         });
         this.playersManager.addPlayer(player);
         player.connections.addConnection(client);
@@ -56,7 +61,6 @@ export class EventsGateway
 
     if (connectedPlayer) {
       connectedPlayer.disconnect();
-
       if (
         !connectedPlayer.isPlayer() &&
         !connectedPlayer.isTableQueuer() &&
@@ -67,4 +71,12 @@ export class EventsGateway
       }
     }
   }
+
+  handleSendWsMessage = (wsEvent: BaseWsEvent) => {
+    this.eventsBusPlayerWsMessageSubscribeService.pushSendMessage(wsEvent);
+  };
+
+  handleGotWsMessageClientResponse = (wsEvent: BaseWsEvent) => {
+    this.eventsBusPlayerWsMessageSubscribeService.pushGotMessage(wsEvent);
+  };
 }

package/src/modules/index.ts

@@ -25,3 +25,4 @@ export {
   EventsBusMainTablesSubscribeService,
 } from './event-bus';
 export { BaseAchievementsModule } from './base-achievements/base-achievements.module';
+export { ConfirmationMessageManagerModule } from './confirmation-message-manager/confirmation-message-manager.module';

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

@@ -66,7 +66,7 @@ export class MainModule {
           subscriber.id,
         );
         subscriber.sendMessage(
-          new MainTablesUpdateListWsEvent(event.game, screen),
+          new MainTablesUpdateListWsEvent(event.game, subscriber.id, screen),
         );
       });
   };

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

@@ -126,7 +126,7 @@ export class MainService {
       dayjs(last7logins[0].date).isToday() &&
       last7logins[0].count === 1
     ) {
-      redirectUrl = AppScreenRoutesEnum.TODAY_BONUS;
+      redirectUrl = AppScreenRoutesEnum.DAILY_BONUS;
     } else if (dayjs(foundUser.premiumExpired).isToday()) {
       redirectUrl = AppScreenRoutesEnum.PREMIUM;
     }

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

@@ -72,6 +72,7 @@ export class ManyTablesTournamentModule {
         subscriber.sendMessage(
           new ManyTablesTournamentUpdateStatusWsEvent(
             event.game,
+            subscriber.id,
             screen.screen,
           ),
         );

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

@@ -55,7 +55,7 @@ export class MenuScreenView extends UniversalScreenView {
         'banner',
         new BannerSectionListItemComponent(
           this.banner.bannerId,
-          this.banner.titleRu,
+          this.getDbResource(this.banner.title),
           this.localeService.t('common.menu.header.title', { lang: this.lang }),
           new UrlImageComponent(this.banner.image),
           this.banner.link,

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

@@ -17,7 +17,11 @@ export class MenuService {
   ) {}
 
   async getScreen(headers: IAppHeaders): Promise<BaseAppScreenDto> {
-    const menuItems = (await this.menuRepository.findMenus('ALL', 'VK')) ?? [];
+    const menuItems =
+      (await this.menuRepository.findMenus(
+        headers.client_game,
+        headers.client_channel,
+      )) ?? [];
     const enabledBanner = await this.bannersRepository.findEnabledBanner(
       headers.client_game,
       headers.client_channel,

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

@@ -69,7 +69,11 @@ export class OneTableTournamentModule {
           subscriber.id,
         );
         subscriber.sendMessage(
-          new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen),
+          new OneTableTournamentUpdateStatusWsEvent(
+            event.game,
+            subscriber.id,
+            screen.screen,
+          ),
         );
       });
   };