jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -1,51 +1,72 @@
-import { Controller, Get, Headers, HttpCode, HttpStatus, NotImplementedException, Param, Post } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Headers,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Post,
+} from '@nestjs/common';
 import { IAppHeaders } from 'jp.common.models';
 
-import { PlayerCheckStateDto, FindFreeTableDto, BaseAppScreenDto } from '../../dto';
+import {
+  PlayerCheckStateDto,
+  FindFreeTableDto,
+  BaseAppScreenDto,
+} from '../../dto';
 
 import { MainService } from './main.service';
 
 @Controller('main')
 export class MainController {
-    constructor(
-        private readonly mainService: MainService,
-    ) { }
-
-    @Get('player_check_state')
-    checkState (@Headers() headers: IAppHeaders): Promise<PlayerCheckStateDto> {
-        return this.mainService.playerCheckState(headers.client_auth_token, headers.client_game);
-    }
-
-    @Get('tables')
-    getScreen (@Headers() headers: IAppHeaders): BaseAppScreenDto {
-        return this.mainService.getScreen(headers.client_language, headers.client_auth_token);
-    }
-
-    @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('find_free_table')
-    findFreeTable (@Headers() headers: IAppHeaders): FindFreeTableDto {
-        return this.mainService.findFreeTable(headers.client_auth_token, headers.client_language);
-    }
-
-    @Post('many_tables_tournament/buy_ticket/:tournamentId')
-    @HttpCode(HttpStatus.OK)
-    buyTicket (
-        @Param('tournamentId') tournamentId: string,
-        @Headers() headers: IAppHeaders,
-    ): Promise<BaseAppScreenDto> {
-        return this.mainService.manyTablesTournamentbBuyTicket(
-            headers.client_auth_token,
-            headers.client_language,
-            tournamentId,
-        );
-    }
+  constructor(private readonly mainService: MainService) {}
+
+  @Get('player_check_state')
+  checkState(@Headers() headers: IAppHeaders): Promise<PlayerCheckStateDto> {
+    return this.mainService.playerCheckState(
+      headers.client_auth_token,
+      headers.client_game,
+    );
+  }
+
+  @Get('tables')
+  getScreen(@Headers() headers: IAppHeaders): BaseAppScreenDto {
+    return this.mainService.getScreen(
+      headers.client_language,
+      headers.client_auth_token,
+    );
+  }
+
+  @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('find_free_table')
+  findFreeTable(@Headers() headers: IAppHeaders): FindFreeTableDto {
+    return this.mainService.findFreeTable(
+      headers.client_auth_token,
+      headers.client_language,
+    );
+  }
+
+  @Post('many_tables_tournament/buy_ticket/:tournamentId')
+  @HttpCode(HttpStatus.OK)
+  buyTicket(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): Promise<BaseAppScreenDto> {
+    return this.mainService.manyTablesTournamentbBuyTicket(
+      headers.client_auth_token,
+      headers.client_language,
+      tournamentId,
+    );
+  }
 }

package/src/modules/main/main.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 MainModuleOptions 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 MainFactoryOptions {
-    i18n: I18nService
+  i18n: I18nService;
 }

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

@@ -1,7 +1,18 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { GamePlayer, MainTablesUpdateListWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
-import { ActivityLog, ActivityLogRepository, ActivityLogSchema, User, UserSchema, UsersRepository } from 'jp.db.schemas';
+import {
+  GamePlayer,
+  MainTablesUpdateListWsEvent,
+  RoomUpdateStateEvent,
+} from 'jp.ms.common.engine';
+import {
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
+  User,
+  UserSchema,
+  UsersRepository,
+} from 'jp.db.schemas';
 
 import { EventsBusMainTablesSubscribeService } from '../event-bus';
 
@@ -11,46 +22,52 @@ import { MAIN_OPTIONS } from './main.constants';
 import { MainModuleOptions } from './main.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-        MongooseModule.forFeature([{ name: ActivityLog.name, schema: ActivityLogSchema }]),
-    ],
-    controllers: [MainController],
-    providers: [
-        MainService,
-        UsersRepository,
-        ActivityLogRepository,
-    ],
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
+  ],
+  controllers: [MainController],
+  providers: [MainService, UsersRepository, ActivityLogRepository],
 })
 export class MainModule {
-    constructor(
-        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly mainService: MainService,
-    ) { }
+  constructor(
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly mainService: MainService,
+  ) {}
 
-    static forRootAsync (options: MainModuleOptions): DynamicModule {
-        return {
-            module: MainModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: MAIN_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: MainModuleOptions): DynamicModule {
+    return {
+      module: MainModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: MAIN_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit () {
-        this.eventsBusMainTablesSubscribeService.subscribe(this.onHandleStatusRoomChange);
-    }
+  onModuleInit() {
+    this.eventsBusMainTablesSubscribeService.subscribe(
+      this.onHandleStatusRoomChange,
+    );
+  }
 
-    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
-        this.eventsBusMainTablesSubscribeService.getTablesSubscribers().forEach((subscriber: GamePlayer) => {
-            const screen = this.mainService.getScreen(subscriber.language, subscriber.id);
-            subscriber.sendMessage(new MainTablesUpdateListWsEvent(event.game, screen));
-        });
-    }
+  private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService
+      .getTablesSubscribers()
+      .forEach((subscriber: GamePlayer) => {
+        const screen = this.mainService.getScreen(
+          subscriber.language,
+          subscriber.id,
+        );
+        subscriber.sendMessage(
+          new MainTablesUpdateListWsEvent(event.game, screen),
+        );
+      });
+  };
 }
-

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

@@ -1,17 +1,37 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
 import dayjs from 'dayjs';
 import isToday from 'dayjs/plugin/isToday';
 import { ActivityLogRepository, UsersRepository } from 'jp.db.schemas';
-import { SimpleRoom, OneTableTournamentRoom, ManyTablesTournamentRoom } from 'jp.ms.common.engine';
-import { AppScreenRoutesEnum, ErrorSnackbarComponent, AppScreenRouter } from 'jp.common.models';
-
-import { BaseAppScreenDto, PlayerCheckStateDto, FindFreeTableDto } from '../../dto';
+import {
+  SimpleRoom,
+  OneTableTournamentRoom,
+  ManyTablesTournamentRoom,
+} from 'jp.ms.common.engine';
+import {
+  AppScreenRoutesEnum,
+  ErrorSnackbarComponent,
+  AppScreenRouter,
+} from 'jp.common.models';
+
+import {
+  BaseAppScreenDto,
+  PlayerCheckStateDto,
+  FindFreeTableDto,
+} from '../../dto';
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 import { PlayersManagerService } from '../players-manager';
-import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager';
-import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
+import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager';
+import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager';
 import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
-import { ErrorCodeEnum, NotEnoughMoneyForPurchaseException, NotFoundFreeRoomForFastGameException } from '../../exception';
+import {
+  ErrorCodeEnum,
+  NotEnoughMoneyForPurchaseException,
+  NotFoundFreeRoomForFastGameException,
+} from '../../exception';
 
 import { MainFactoryOptions } from './main.interfaces';
 import { MAIN_OPTIONS } from './main.constants';
@@ -19,121 +39,145 @@ import { MainTablesListScreenView } from './main-tables-list-screen.view';
 
 @Injectable()
 export class MainService {
-    constructor(
-        private readonly simpleRoomsManager: SimpleRoomsManagerService,
-        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
-        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly usersRepository: UsersRepository,
-        private readonly activityLogRepository: ActivityLogRepository,
-        @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
-    ) {
-        dayjs.extend(isToday);
-    }
-
-    getScreen (lang: string, clientAuthToken: string): BaseAppScreenDto {
-        return new BaseAppScreenDto(
-            new MainTablesListScreenView(
-                this.options.i18n,
-                lang,
-                this.simpleRoomsManager.getRooms(),
-                this.oneTableRoomsManagerService.getRooms(),
-                this.manyTablesRoomsManagerService.getRooms(),
-                clientAuthToken,
-            ).buildBS(),
-        );
+  constructor(
+    private readonly simpleRoomsManager: SimpleRoomsManagerService,
+    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
+    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly usersRepository: UsersRepository,
+    private readonly activityLogRepository: ActivityLogRepository,
+    @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
+  ) {
+    dayjs.extend(isToday);
+  }
+
+  getScreen(lang: string, clientAuthToken: string): BaseAppScreenDto {
+    return new BaseAppScreenDto(
+      new MainTablesListScreenView(
+        this.options.i18n,
+        lang,
+        this.simpleRoomsManager.getRooms(),
+        this.oneTableRoomsManagerService.getRooms(),
+        this.manyTablesRoomsManagerService.getRooms(),
+        clientAuthToken,
+      ).buildBS(),
+    );
+  }
+
+  subscribeOnTablesScreen(clientAuthToken: string): Promise<void> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+
+    if (player) {
+      this.eventsBusMainTablesSubscribeService.addTablesSubscriber(player);
     }
 
-    subscribeOnTablesScreen (clientAuthToken: string): Promise<void> {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
+    throw new InternalServerErrorException();
+  }
 
-        if (player) {
-            this.eventsBusMainTablesSubscribeService.addTablesSubscriber(player);
-        }
+  unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
 
-        throw new InternalServerErrorException();
+    if (player) {
+      this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
     }
 
-    unsubscribeFromTablesScreen (clientAuthToken: string): Promise<void> {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-
-        if (player) {
-            this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
-        }
-
-        throw new InternalServerErrorException();
+    throw new InternalServerErrorException();
+  }
+
+  async playerCheckState(
+    clientAuthToken: string,
+    game: string,
+  ): Promise<PlayerCheckStateDto> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    let redirectUrl: string = AppScreenRoutesEnum.MENU;
+
+    const foundUser = await this.usersRepository.findById(clientAuthToken);
+    const isNewbie =
+      await this.activityLogRepository.userIsNewbie(clientAuthToken);
+    const last7logins = await this.activityLogRepository.findLast7DaysLogins(
+      game,
+      clientAuthToken,
+    );
+
+    if (!foundUser) {
+      throw new InternalServerErrorException();
     }
 
-    async playerCheckState (clientAuthToken: string, game: string): Promise<PlayerCheckStateDto> {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        let redirectUrl: string = AppScreenRoutesEnum.MENU;
-
-        const foundUser = await this.usersRepository.findById(clientAuthToken);
-        const isNewbie = await this.activityLogRepository.userIsNewbie(clientAuthToken)
-        const last7logins = await this.activityLogRepository.findLast7DaysLogins(game, clientAuthToken);
-
-        if (!foundUser) {
-            throw new InternalServerErrorException();
-        }
-
-        if (player && (player.isPlayer() || player.isTableQueuer()) && player.tableId) {
-            if (player.room instanceof SimpleRoom) {
-                redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
-            } else if (player.room instanceof OneTableTournamentRoom) {
-                redirectUrl = AppScreenRouter.getOneTableTournamentTablePath(player.tableId);
-            } else if (player.room instanceof ManyTablesTournamentRoom) {
-                redirectUrl = AppScreenRouter.getManyTablesTournamentTablePath(player.tableId);
-            }
-        } else if (isNewbie) {
-            redirectUrl = AppScreenRoutesEnum.WELCOME;
-        } else if (dayjs(last7logins[0].date).isToday() && last7logins[0].count === 1) {
-            redirectUrl = AppScreenRoutesEnum.TODAY_BONUS;
-        } else if (dayjs(foundUser.premiumExpired).isToday()) {
-            redirectUrl = AppScreenRoutesEnum.PREMIUM;
-        }
-
-        return PlayerCheckStateDto.fromEntities(
-            redirectUrl,
-            player?.id ?? '',
+    if (
+      player &&
+      (player.isPlayer() || player.isTableQueuer()) &&
+      player.tableId
+    ) {
+      if (player.room instanceof SimpleRoom) {
+        redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
+      } else if (player.room instanceof OneTableTournamentRoom) {
+        redirectUrl = AppScreenRouter.getOneTableTournamentTablePath(
+          player.tableId,
         );
+      } else if (player.room instanceof ManyTablesTournamentRoom) {
+        redirectUrl = AppScreenRouter.getManyTablesTournamentTablePath(
+          player.tableId,
+        );
+      }
+    } else if (isNewbie) {
+      redirectUrl = AppScreenRoutesEnum.WELCOME;
+    } else if (
+      dayjs(last7logins[0].date).isToday() &&
+      last7logins[0].count === 1
+    ) {
+      redirectUrl = AppScreenRoutesEnum.TODAY_BONUS;
+    } else if (dayjs(foundUser.premiumExpired).isToday()) {
+      redirectUrl = AppScreenRoutesEnum.PREMIUM;
     }
 
-    findFreeTable (clientAuthToken: string, lang: string): FindFreeTableDto {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
+    return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
+  }
 
-        if (!player || !tableId) {
-            throw new NotFoundFreeRoomForFastGameException(new ErrorSnackbarComponent(
-                ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
-                this.options.i18n.t('common.server.message.code.4003', { lang })
-            ));
-        }
+  findFreeTable(clientAuthToken: string, lang: string): FindFreeTableDto {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
 
-        return FindFreeTableDto.fromEntities(
-            AppScreenRouter.getSimpleRoomTablePath(tableId),
-            player.id,
-        );
+    if (!player || !tableId) {
+      throw new NotFoundFreeRoomForFastGameException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_FOUND_FREE_ROOM_FOR_FAST_GAME,
+          this.options.i18n.t('common.server.message.code.4003', { lang }),
+        ),
+      );
     }
 
-    async manyTablesTournamentbBuyTicket (clientAuthToken: string, lang: string, tournamentId: string): Promise<BaseAppScreenDto> {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-        const user = await this.usersRepository.findById(player?.id ?? '');
-
-        if (!player || !tournament || !user) {
-            throw new InternalServerErrorException();
-        }
+    return FindFreeTableDto.fromEntities(
+      AppScreenRouter.getSimpleRoomTablePath(tableId),
+      player.id,
+    );
+  }
+
+  async manyTablesTournamentbBuyTicket(
+    clientAuthToken: string,
+    lang: string,
+    tournamentId: string,
+  ): Promise<BaseAppScreenDto> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
+
+    if (!player || !tournament || !user) {
+      throw new InternalServerErrorException();
+    }
 
-        if (user.balance < tournament.getTicketPrice()) {
-            throw new NotEnoughMoneyForPurchaseException(new ErrorSnackbarComponent(
-                ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
-                this.options.i18n.t('common.server.message.code.4004', { lang })
-            ));
-        }
+    if (user.balance < tournament.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', { lang }),
+        ),
+      );
+    }
 
-        await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+    await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
 
-        return this.getScreen(lang, clientAuthToken);
-    }
+    return this.getScreen(lang, clientAuthToken);
+  }
 }

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

@@ -1 +1 @@
-export { ManyTablesTournamentModule } from './many-tables-tournament.module';
+export { ManyTablesTournamentModule } from './many-tables-tournament.module';