jp.ms.common.modules 1.0.34 → 1.0.36

package/src/modules/one-table-tournament/one-table-tournament-status-screen.view.ts

@@ -1,157 +1,166 @@
 import {
-    AppScreenIconEnum,
-    AppScreenIdEnum,
-    IAppScreen,
-    UniversalScreenView,
-    ILocaleService,
-    StandardScreenComponent,
-    StatusAppBarComponent,
-    StatusHeaderSectionComponent,
-    CardListSectionComponent,
-    ArrowBackButtonComponent,
-    IconImageComponent,
-    PrimaryButtonButtonsComponent,
-    TextButtonComponent,
-    MiniCardSectionListItemComponent,
-    UrlImageComponent,
-} from "jp.common.models";
-import { formatChips } from "jp.common.utils";
-import { OneTableTournamentRoom, TournamentMaster } from "jp.ms.common.engine";
+  AppScreenIconEnum,
+  AppScreenIdEnum,
+  IAppScreen,
+  UniversalScreenView,
+  ILocaleService,
+  StandardScreenComponent,
+  StatusAppBarComponent,
+  StatusHeaderSectionComponent,
+  CardListSectionComponent,
+  ArrowBackButtonComponent,
+  IconImageComponent,
+  PrimaryButtonButtonsComponent,
+  TextButtonComponent,
+  MiniCardSectionListItemComponent,
+  UrlImageComponent,
+} from 'jp.common.models';
+import { formatChips } from 'jp.common.utils';
+import { OneTableTournamentRoom, TournamentMaster } from 'jp.ms.common.engine';
 
 export class OneTableTournamentStatusScreenView extends UniversalScreenView {
-    private readonly tournament: OneTableTournamentRoom;
-    private readonly playerId: string;
+  private readonly tournament: OneTableTournamentRoom;
+  private readonly playerId: string;
 
-    constructor(
-        localeService: ILocaleService,
-        lang: string,
-        tournament: OneTableTournamentRoom,
-        playerId: string,
-    ) {
-        super(localeService, lang);
-        this.tournament = tournament;
-        this.playerId = playerId;
-    }
-
-    build (): IAppScreen {
-        return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
-            .addAppBar(
-                new StatusAppBarComponent(
-                    this.tournament.getTitle(this.lang),
-                    new ArrowBackButtonComponent(
-                        this.localeService.t('common.button.back', { lang: this.lang })
-                    ),
-                ),
-            )
-            .addSection(
-                this.getStatusHeader()
-            )
-            .addSection(
-                new CardListSectionComponent(
-                    'id1',
-                    this.getPlayersList()
-                )
-            );
-    }
+  constructor(
+    localeService: ILocaleService,
+    lang: string,
+    tournament: OneTableTournamentRoom,
+    playerId: string,
+  ) {
+    super(localeService, lang);
+    this.tournament = tournament;
+    this.playerId = playerId;
+  }
 
-    private getPlayersList (): Array<MiniCardSectionListItemComponent> {
-        if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
-            return this.tournament.getWinners().map((item) => (
-                new MiniCardSectionListItemComponent(
-                    item.playerId,
-                    item.playerName,
-                    this.localeService.t('common.tournaments.status.screen.finish.description', {
-                        lang: this.lang,
-                        args: {
-                            RANK: item.rank.toString(),
-                            PRIZE: formatChips(item.profit, this.lang, true),
-                        }
-                    }),
-                    new UrlImageComponent(item.playerAvatarUrl),
-                    true,
-                    true,
-                    '',
-                )
-            ));
-        }
+  build(): IAppScreen {
+    return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
+      .addAppBar(
+        new StatusAppBarComponent(
+          this.tournament.getTitle(this.lang),
+          new ArrowBackButtonComponent(
+            this.localeService.t('common.button.back', { lang: this.lang }),
+          ),
+        ),
+      )
+      .addSection(this.getStatusHeader())
+      .addSection(new CardListSectionComponent('id1', this.getPlayersList()));
+  }
 
-        return this.tournament.getParticipants().map((item) => (
-            new MiniCardSectionListItemComponent(
-                item.playerId,
-                item.playerName,
-                '',
-                new UrlImageComponent(item.playerAvatarUrl),
-                true,
-                true,
-                '',
-            )
-        ));
+  private getPlayersList(): Array<MiniCardSectionListItemComponent> {
+    if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+      return this.tournament.getWinners().map(
+        (item) =>
+          new MiniCardSectionListItemComponent(
+            item.playerId,
+            item.playerName,
+            this.localeService.t(
+              'common.tournaments.status.screen.finish.description',
+              {
+                lang: this.lang,
+                args: {
+                  RANK: item.rank.toString(),
+                  PRIZE: formatChips(item.profit, this.lang, true),
+                },
+              },
+            ),
+            new UrlImageComponent(item.playerAvatarUrl),
+            true,
+            true,
+            '',
+          ),
+      );
     }
 
-    private getStatusHeader (): StatusHeaderSectionComponent {
-        const foundPlayer = this.tournament.getParticipant(this.playerId)
+    return this.tournament
+      .getParticipants()
+      .map(
+        (item) =>
+          new MiniCardSectionListItemComponent(
+            item.playerId,
+            item.playerName,
+            '',
+            new UrlImageComponent(item.playerAvatarUrl),
+            true,
+            true,
+            '',
+          ),
+      );
+  }
 
-        return new StatusHeaderSectionComponent(
-            'status',
-            this.getStatusDescription(),
-            new IconImageComponent(this.getStatusIcon()),
-            !foundPlayer && this.tournament.getRoomMaster<TournamentMaster>().isWaiting() ?
-                new PrimaryButtonButtonsComponent(
-                    new TextButtonComponent(
-                        this.localeService.t('common.tournaments.screen.button.join.tournament', { lang: this.lang })
-                    )
-                ) : undefined,
-        )
-    }
+  private getStatusHeader(): StatusHeaderSectionComponent {
+    const foundPlayer = this.tournament.getParticipant(this.playerId);
 
-    private getStatusIcon (): string {
-        if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
-            return AppScreenIconEnum.INFO;
-        } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
-            return AppScreenIconEnum.EMOJI_EVENTS;
-        } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
-            return AppScreenIconEnum.HOURGLASS_EMPTY;
-        }
+    return new StatusHeaderSectionComponent(
+      'status',
+      this.getStatusDescription(),
+      new IconImageComponent(this.getStatusIcon()),
+      !foundPlayer &&
+      this.tournament.getRoomMaster<TournamentMaster>().isWaiting()
+        ? new PrimaryButtonButtonsComponent(
+            new TextButtonComponent(
+              this.localeService.t(
+                'common.tournaments.screen.button.join.tournament',
+                { lang: this.lang },
+              ),
+            ),
+          )
+        : undefined,
+    );
+  }
 
-        return '';
+  private getStatusIcon(): string {
+    if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+      return AppScreenIconEnum.INFO;
+    } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+      return AppScreenIconEnum.EMOJI_EVENTS;
+    } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+      return AppScreenIconEnum.HOURGLASS_EMPTY;
     }
 
-    private getStatusDescription (): string {
-        if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
-            return this.localeService.t('common.tournaments.status.4', { lang: this.lang });
-        } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
-            return this.localeService.t('common.tournaments.status.3', { lang: this.lang });
-        } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
-            return this.getStatusDescriptionWaiting();
-        }
+    return '';
+  }
 
-        return '';
+  private getStatusDescription(): string {
+    if (this.tournament.getRoomMaster<TournamentMaster>().isCancelled()) {
+      return this.localeService.t('common.tournaments.status.4', {
+        lang: this.lang,
+      });
+    } else if (this.tournament.getRoomMaster<TournamentMaster>().isFinish()) {
+      return this.localeService.t('common.tournaments.status.3', {
+        lang: this.lang,
+      });
+    } else if (this.tournament.getRoomMaster<TournamentMaster>().isWaiting()) {
+      return this.getStatusDescriptionWaiting();
     }
 
-    private getStatusDescriptionWaiting (): string {
-        const players = this.tournament.getParticipants().length;
-        const maxPlayers = this.tournament.getTableSize();
+    return '';
+  }
 
-        if (players === 0) {
-            return this.localeService.t(
-                'common.room.screen.seat.and.go.waiting.for.the.players',
-                {
-                    lang: this.lang,
-                    args: {
-                        MAX_PLAYERS: this.tournament.getTableSize().toString(),
-                    }
-                },
-            );
-        }
+  private getStatusDescriptionWaiting(): string {
+    const players = this.tournament.getParticipants().length;
+    const maxPlayers = this.tournament.getTableSize();
 
-        return this.localeService.t(
-            'common.room.screen.seat.and.go.more.waiting.for.the.players',
-            {
-                lang: this.lang,
-                args: {
-                    PLAYERS: (maxPlayers - players).toString(),
-                }
-            },
-        );
+    if (players === 0) {
+      return this.localeService.t(
+        'common.room.screen.seat.and.go.waiting.for.the.players',
+        {
+          lang: this.lang,
+          args: {
+            MAX_PLAYERS: this.tournament.getTableSize().toString(),
+          },
+        },
+      );
     }
-}
+
+    return this.localeService.t(
+      'common.room.screen.seat.and.go.more.waiting.for.the.players',
+      {
+        lang: this.lang,
+        args: {
+          PLAYERS: (maxPlayers - players).toString(),
+        },
+      },
+    );
+  }
+}

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

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

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

@@ -1,73 +1,104 @@
-import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
-import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IAppTableState } from 'jp.common.models';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  Headers,
+  HttpStatus,
+  HttpCode,
+} from '@nestjs/common';
+import {
+  IAppHeaders,
+  IBaseAppScreen,
+  IBaseMoveData,
+  IAppTableState,
+} from 'jp.common.models';
 
 import { OneTableTournamentService } from './one-table-tournament.service';
 
 @Controller('tournament/one_table')
 export class OneTableTournamentController {
-    constructor(
-        private readonly tournamentService: OneTableTournamentService,
-    ) {
-    }
+  constructor(private readonly tournamentService: OneTableTournamentService) {}
 
-    @Get('status/:tournamentId')
-    getStatusScreen(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): IBaseAppScreen {
-        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language, headers.client_auth_token);
-    }
+  @Get('status/:tournamentId')
+  getStatusScreen(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): IBaseAppScreen {
+    return this.tournamentService.getStatusScreen(
+      tournamentId,
+      headers.client_language,
+      headers.client_auth_token,
+    );
+  }
 
-    @Get('status/subscribe/:tournamentId')
-    subscribeOnStatusScreen(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): void {
-        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_auth_token);
-    }
+  @Get('status/subscribe/:tournamentId')
+  subscribeOnStatusScreen(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): void {
+    return this.tournamentService.subscribeOnStatusScreen(
+      tournamentId,
+      headers.client_auth_token,
+    );
+  }
 
-    @Get('status/unsubscribe/:tournamentId')
-    unsubscribeFromStatusScreen(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): void {
-        return this.tournamentService.unsubscribeFromStatusScreen(tournamentId, headers.client_auth_token);
-    }
+  @Get('status/unsubscribe/:tournamentId')
+  unsubscribeFromStatusScreen(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): void {
+    return this.tournamentService.unsubscribeFromStatusScreen(
+      tournamentId,
+      headers.client_auth_token,
+    );
+  }
 
-    @Post('table/watch/:tableId')
-    @HttpCode(HttpStatus.OK)
-    watchTheTable(
-        @Param('tableId') tableId: string,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.tournamentService.watchTheTable(tableId, headers.client_auth_token);
-    }
+  @Post('table/watch/:tableId')
+  @HttpCode(HttpStatus.OK)
+  watchTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.tournamentService.watchTheTable(
+      tableId,
+      headers.client_auth_token,
+    );
+  }
 
-    @Post('table/move/:tableId')
-    @HttpCode(HttpStatus.OK)
-    moveOnTheTable(
-        @Param('tableId') tableId: string,
-        @Body() baseMoveData: IBaseMoveData,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.tournamentService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
-    }
+  @Post('table/move/:tableId')
+  @HttpCode(HttpStatus.OK)
+  moveOnTheTable(
+    @Param('tableId') tableId: string,
+    @Body() baseMoveData: IBaseMoveData,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.tournamentService.moveOnTheTable(
+      tableId,
+      headers.client_auth_token,
+      baseMoveData,
+    );
+  }
 
-    @Post('join/:tournamentId')
-    @HttpCode(HttpStatus.OK)
-    joinTournament(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): IBaseAppScreen {
-        return this.tournamentService.joinTournament(tournamentId, headers);
-    }
+  @Post('join/:tournamentId')
+  @HttpCode(HttpStatus.OK)
+  joinTournament(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): IBaseAppScreen {
+    return this.tournamentService.joinTournament(tournamentId, headers);
+  }
 
-    @Post('leave/:tournamentId')
-    @HttpCode(HttpStatus.OK)
-    leaveTournament(
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): void {
-        return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
-    }
+  @Post('leave/:tournamentId')
+  @HttpCode(HttpStatus.OK)
+  leaveTournament(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): void {
+    return this.tournamentService.leaveTournament(
+      tournamentId,
+      headers.client_auth_token,
+    );
+  }
 }

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

@@ -4,12 +4,15 @@ 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 OneTableTournamentModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface OneTableTournamentModuleOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface OneTableTournamentFactoryOptions {
-    i18n: I18nService
+  i18n: I18nService;
 }

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

@@ -1,9 +1,17 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { TournamentOneTableRoom, TournamentOneTableRoomSchema, TournamentOneTableRoomsRepository } from 'jp.db.schemas';
-import { GamePlayer, OneTableTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import {
+  OneTableTournamentRoom,
+  OneTableTournamentRoomSchema,
+  OneTableTournamentRoomsRepository,
+} from 'jp.db.schemas';
+import {
+  GamePlayer,
+  OneTableTournamentUpdateStatusWsEvent,
+  RoomUpdateStateEvent,
+} from 'jp.ms.common.engine';
 
-import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
 import { EventsBusOneTableTournamentSubscribeService } from '../event-bus';
 
 import { OneTableTournamentController } from './one-table-tournament.controller';
@@ -12,42 +20,57 @@ import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
 import { OneTableTournamentModuleOptions } from './one-table-tournament.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: TournamentOneTableRoom.name, schema: TournamentOneTableRoomSchema }]),
-    ],
-    controllers: [OneTableTournamentController],
-    providers: [OneTableTournamentService, TournamentOneTableRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: OneTableTournamentRoom.name,
+        schema: OneTableTournamentRoomSchema,
+      },
+    ]),
+  ],
+  controllers: [OneTableTournamentController],
+  providers: [OneTableTournamentService, OneTableTournamentRoomsRepository],
 })
 export class OneTableTournamentModule {
-    constructor(
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
-        private readonly oneTableTournamentService: OneTableTournamentService,
-    ) { }
+  constructor(
+    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
+    private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    private readonly oneTableTournamentService: OneTableTournamentService,
+  ) {}
 
-    static forRootAsync(options: OneTableTournamentModuleOptions): DynamicModule {
-        return {
-            module: OneTableTournamentModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: ONE_TABLE_TOURNAMENT_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: OneTableTournamentModuleOptions): DynamicModule {
+    return {
+      module: OneTableTournamentModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: ONE_TABLE_TOURNAMENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit() {
-        this.eventsBusOneTableTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
-    }
+  onModuleInit() {
+    this.eventsBusOneTableTournamentSubscribeService.subscribe(
+      this.onHandleStatusRoomChange,
+    );
+  }
 
-    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
-        this.oneTableRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
-            const screen = this.oneTableTournamentService.getStatusScreen(event.roomId, subscriber.language, subscriber.id);
-            subscriber.sendMessage(new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen));
-        });
-    }
+  private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+    this.oneTableRoomsManagerService
+      .getRoomById(event.roomId)
+      ?.getStatusScreenWatchers()
+      .forEach((subscriber: GamePlayer) => {
+        const screen = this.oneTableTournamentService.getStatusScreen(
+          event.roomId,
+          subscriber.language,
+          subscriber.id,
+        );
+        subscriber.sendMessage(
+          new OneTableTournamentUpdateStatusWsEvent(event.game, screen.screen),
+        );
+      });
+  };
 }
-