jp.ms.common.modules 1.0.41 → 1.0.43

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

@@ -1,72 +1,51 @@
-import {
-  Controller,
-  Get,
-  Headers,
-  HttpCode,
-  HttpStatus,
-  Param,
-  Post,
-} from '@nestjs/common';
-import { IAppHeaders } from 'jp.common.models';
-
-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,
-    );
-  }
-}
+import { Controller, Get, Headers } from '@nestjs/common';
+import { IAppHeaders } from 'jp.common.models';
+
+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,
+    );
+  }
+}

package/src/modules/main/main.interfaces.ts

@@ -1,17 +1,17 @@
-import { ModuleMetadata } from '@nestjs/common';
-import { I18nService } from 'nestjs-i18n';
-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 MainModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-  imports?: Array<
-    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
-  >;
-  inject?: any[];
-  useFactory?: (...args: any[]) => Promise<any> | any;
-}
-
-export interface MainFactoryOptions {
-  i18n: I18nService;
-}
+import { ModuleMetadata } from '@nestjs/common';
+import { I18nService } from 'nestjs-i18n';
+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 MainModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface MainFactoryOptions {
+  i18n: I18nService;
+}

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

@@ -1,73 +1,73 @@
-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 { EventsBusMainTablesSubscribeService } from '../event-bus';
-
-import { MainController } from './main.controller';
-import { MainService } from './main.service';
-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],
-})
-export class MainModule {
-  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,
-      ],
-    };
-  }
-
-  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),
-        );
-      });
-  };
-}
+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 { EventsBusMainTablesSubscribeService } from '../event-bus';
+
+import { MainController } from './main.controller';
+import { MainService } from './main.service';
+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],
+})
+export class MainModule {
+  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,
+      ],
+    };
+  }
+
+  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, subscriber.id, screen),
+        );
+      });
+  };
+}

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

@@ -1,183 +1,154 @@
-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 { SimpleRoomsManagerService } from '../simple-rooms-manager';
-import { PlayersManagerService } from '../players-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 { MainFactoryOptions } from './main.interfaces';
-import { MAIN_OPTIONS } from './main.constants';
-import { MainTablesListScreenView } from './main-tables-list-screen.view';
-
-@Injectable()
-export class MainService {
-  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);
-    }
-
-    throw new InternalServerErrorException();
-  }
-
-  unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-
-    if (player) {
-      this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
-    }
-
-    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.DAILY_BONUS;
-    } else if (dayjs(foundUser.premiumExpired).isToday()) {
-      redirectUrl = AppScreenRoutesEnum.PREMIUM;
-    }
-
-    return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
-  }
-
-  findFreeTable(clientAuthToken: string, lang: string): FindFreeTableDto {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
-
-    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 }),
-        ),
-      );
-    }
-
-    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 }),
-        ),
-      );
-    }
-
-    await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
-
-    return this.getScreen(lang, clientAuthToken);
-  }
-}
+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 { SimpleRoomsManagerService } from '../simple-rooms-manager';
+import { PlayersManagerService } from '../players-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,
+  NotFoundFreeRoomForFastGameException,
+} from '../../exception';
+
+import { MainFactoryOptions } from './main.interfaces';
+import { MAIN_OPTIONS } from './main.constants';
+import { MainTablesListScreenView } from './main-tables-list-screen.view';
+
+@Injectable()
+export class MainService {
+  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);
+    }
+
+    throw new InternalServerErrorException();
+  }
+
+  unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+
+    if (player) {
+      this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
+    }
+
+    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.DAILY_BONUS;
+    } else if (dayjs(foundUser.premiumExpired).isToday()) {
+      redirectUrl = AppScreenRoutesEnum.PREMIUM;
+    }
+
+    return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
+  }
+
+  findFreeTable(clientAuthToken: string, lang: string): FindFreeTableDto {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tableId = this.simpleRoomsManager.getFreeFastGameRoom()?.getId();
+
+    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 }),
+        ),
+      );
+    }
+
+    return FindFreeTableDto.fromEntities(
+      AppScreenRouter.getSimpleRoomTablePath(tableId),
+      player.id,
+    );
+  }
+}

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

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