jp.ms.common.modules 1.0.34 → 1.0.35

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

@@ -1,7 +1,15 @@
 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 {
+  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';
@@ -12,42 +20,61 @@ import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constan
 import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
-    ],
-    controllers: [ManyTablesTournamentController],
-    providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: TournamentManyTablesRoom.name,
+        schema: TournamentManyTablesRoomSchema,
+      },
+    ]),
+  ],
+  controllers: [ManyTablesTournamentController],
+  providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
 })
 export class ManyTablesTournamentModule {
-    constructor(
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
-        private readonly manyTablesTournamentService: ManyTablesTournamentService,
-    ) { }
+  constructor(
+    private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    private readonly manyTablesTournamentService: ManyTablesTournamentService,
+  ) {}
 
-    static forRootAsync(options: ManyTablesTournamentModuleOptions): DynamicModule {
-        return {
-            module: ManyTablesTournamentModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: MANY_TABLES_TOURNAMENT_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(
+    options: ManyTablesTournamentModuleOptions,
+  ): DynamicModule {
+    return {
+      module: ManyTablesTournamentModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: MANY_TABLES_TOURNAMENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit() {
-        this.eventsBusManyTablesTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
-    }
+  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(event.game, screen.screen));
-        });
-    }
+  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(
+            event.game,
+            screen.screen,
+          ),
+        );
+      });
+  };
 }
-

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

@@ -1,10 +1,17 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IBaseMoveData,
-    IAppTableState,
-    AppScreenRouter,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  IBaseMoveData,
+  IAppTableState,
+  AppScreenRouter,
 } from 'jp.common.models';
-import { ManyTablesTournamentMaster, TournamentMaster } from 'jp.ms.common.engine';
+import {
+  ManyTablesTournamentMaster,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
 
 import { BaseAppScreenDto } from '../../dto';
 import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
@@ -20,154 +27,182 @@ import { ManyTablesTournamentTablesListScreenView } from './many-tables-tourname
 
 @Injectable()
 export class ManyTablesTournamentService {
-    constructor(
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(MANY_TABLES_TOURNAMENT_OPTIONS) private readonly options: ManyTablesTournamentFactoryOptions,
-    ) {
+  constructor(
+    private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
+    private readonly options: ManyTablesTournamentFactoryOptions,
+  ) {}
+
+  getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!tournament) {
+      throw new InternalServerErrorException();
     }
 
-    getStatusScreen (tournamentId: string, lang: string): BaseAppScreenDto {
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-        if (!tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        return new BaseAppScreenDto(
-            new ManyTablesTournamentStatusScreenView(
-                this.options.i18n,
-                lang,
-                tournament,
-            ).buildBS()
-        );
+    return new BaseAppScreenDto(
+      new ManyTablesTournamentStatusScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+      ).buildBS(),
+    );
+  }
+
+  subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
     }
 
-    subscribeOnStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+    tournament.addToStatusScreenWatchers(player);
+  }
 
-        if (!player || !tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        tournament.addToStatusScreenWatchers(player);
+  unsubscribeFromStatusScreen(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
     }
 
-    unsubscribeFromStatusScreen (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+    tournament.removeFromStatusScreenWatchers(player);
+  }
 
-        if (!player || !tournament) {
-            throw new InternalServerErrorException();
-        }
+  getTableListScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomById(tournamentId);
 
-        tournament.removeFromStatusScreenWatchers(player);
+    if (!tournament) {
+      throw new InternalServerErrorException();
     }
 
-    async getTableListScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
-        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
-
-        if (!tournament) {
-            throw new InternalServerErrorException();
-        }
+    return new BaseAppScreenDto(
+      new ManyTablesTournamentTablesListScreenView(
+        this.options.i18n,
+        lang,
+        tournament,
+      ).buildBS(),
+    );
+  }
 
-        return new BaseAppScreenDto(
-            new ManyTablesTournamentTablesListScreenView(
-                this.options.i18n,
-                lang,
-                tournament,
-            ).buildBS()
-        );
-    }
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
-
-            return master.createGameStateDto(player);
-        }
-
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  moveOnTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    moveDto: IBaseMoveData,
+  ): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleMoveOnTheTable(player, tableId, moveDto);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    joinTournament (tournamentId: string, clientAuthToken: string): JoinTournamentDto {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-
-        if (player && tournament) {
-            tournament.handleJoinTournament(player);
-
-            if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
-                if (player.isPlayer() || player.isTableQueuer()) {
-                    return JoinTournamentDto.fromEntities(
-                        AppScreenRouter.getManyTablesTournamentTablePath(player.tableId ?? ''),
-                        player.id,
-                    );
-                } else if (tournament.isParticipant(player.id)) {
-                    tournament.getRoomMaster<ManyTablesTournamentMaster>()
-                        .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
-
-                    return JoinTournamentDto.fromEntities(
-                        AppScreenRouter.getManyTablesTournamentTablePath(player.tableId ?? ''),
-                        player.id,
-                    );
-                } else {
-                    return JoinTournamentDto.fromEntities(
-                        AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
-                        player.id,
-                    );
-                }
-            } else {
-                return JoinTournamentDto.fromEntities(
-                    AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
-                    player.id,
-                );
-            }
+    throw new InternalServerErrorException();
+  }
+
+  joinTournament(
+    tournamentId: string,
+    clientAuthToken: string,
+  ): JoinTournamentDto {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+
+    if (player && tournament) {
+      tournament.handleJoinTournament(player);
+
+      if (tournament.getRoomMaster<TournamentMaster>().isInProgress()) {
+        if (player.isPlayer() || player.isTableQueuer()) {
+          return JoinTournamentDto.fromEntities(
+            AppScreenRouter.getManyTablesTournamentTablePath(
+              player.tableId ?? '',
+            ),
+            player.id,
+          );
+        } else if (tournament.isParticipant(player.id)) {
+          tournament
+            .getRoomMaster<ManyTablesTournamentMaster>()
+            .onTournamentProcessAlonePlayer(tournament.getRoomMaster(), player);
+
+          return JoinTournamentDto.fromEntities(
+            AppScreenRouter.getManyTablesTournamentTablePath(
+              player.tableId ?? '',
+            ),
+            player.id,
+          );
+        } else {
+          return JoinTournamentDto.fromEntities(
+            AppScreenRouter.getManyTablesTournamentTableListPath(tournamentId),
+            player.id,
+          );
         }
-
-        throw new InternalServerErrorException();
+      } else {
+        return JoinTournamentDto.fromEntities(
+          AppScreenRouter.getManyTablesTournamentStatusPath(tournament.getId()),
+          player.id,
+        );
+      }
     }
 
-    leaveTournament (tournamentId: string, clientAuthToken: string): void {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    throw new InternalServerErrorException();
+  }
 
-        if (!player || !tournament) {
-            throw new InternalServerErrorException();
-        }
-
-        tournament.handleLeaveTournament(player);
-    }
+  leaveTournament(tournamentId: string, clientAuthToken: string): void {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
 
-    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
-        return this.manyTablesRoomsManagerService.createTournament(createTournamentDto);
+    if (!player || !tournament) {
+      throw new InternalServerErrorException();
     }
 
-    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
-        return this.manyTablesRoomsManagerService.updateTournament(tournamentId, updateTournamentDto);
-    }
-
-    async removeTournament (tournamentId: string) {
-        return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
-    }
+    tournament.handleLeaveTournament(player);
+  }
+
+  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    return this.manyTablesRoomsManagerService.createTournament(
+      createTournamentDto,
+    );
+  }
+
+  async updateTournament(
+    tournamentId: string,
+    updateTournamentDto: ManyTablesTournamentUpdateDto,
+  ) {
+    return this.manyTablesRoomsManagerService.updateTournament(
+      tournamentId,
+      updateTournamentDto,
+    );
+  }
+
+  async removeTournament(tournamentId: string) {
+    return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
+  }
 }

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

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

package/src/modules/menu/menu.controller.ts

@@ -7,11 +7,10 @@ import { MenuService } from './menu.service';
 
 @Controller()
 export class MenuController {
-    constructor (private readonly menuService: MenuService) {
-    }
+  constructor(private readonly menuService: MenuService) {}
 
-    @Get('menu')
-    getScreen(@Headers() headers: IAppHeaders): Promise<BaseAppScreenDto> {
-        return this.menuService.getScreen(headers);
-    }
+  @Get('menu')
+  getScreen(@Headers() headers: IAppHeaders): Promise<BaseAppScreenDto> {
+    return this.menuService.getScreen(headers);
+  }
 }

package/src/modules/menu/menu.interfaces.ts

@@ -5,11 +5,13 @@ import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.
 import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
 
 export interface MenuModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface MenuFactoryOptions {
-    i18n: I18nService
+  i18n: I18nService;
 }