jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -0,0 +1,331 @@
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import dayjs from 'dayjs';
+import schedule, { Job } from 'node-schedule';
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import {
+  BaseGameEvent,
+  GameMaster,
+  GamePlayer,
+  GameTableFinishedEvent,
+  GameTournamentCancelledEvent,
+  GameTournamentFinishedEvent,
+  GameTournamentPlayerJoinedTheTournamentEvent,
+  GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentStartedEvent,
+  GameTournamentWaitedEvent,
+  LocalService,
+  ManyTablesTournamentRoom,
+  ManyTablesTournamentRoomConfig,
+  NoStartStrategy,
+  RoomUpdateStateEvent,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
+import {
+  GameResultRepository,
+  PurchaseRepository,
+  ManyTablesTournamentRoomDocument,
+  ManyTablesTournamentRoomsRepository,
+  UsersRepository,
+} from 'jp.db.schemas';
+
+import {
+  saveGameTablesResult,
+  saveTournamentResult,
+} from '../../utils/game-table-result';
+import { JpLoggerService } from '../logger';
+import { getHours, getMinutes } from '../../utils/date';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+import {
+  EventsBusMainTablesSubscribeService,
+  EventsBusManyTablesTournamentSubscribeService,
+} from '../event-bus';
+
+import { MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './many-tables-tournament-rooms-manager.constants';
+import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournament-rooms-manager.interfaces';
+
+@Injectable()
+export class ManyTablesTournamentRoomsManagerService {
+  private readonly rooms: Map<string, ManyTablesTournamentRoom>;
+  private createDailyTournamentJob: Job | null;
+
+  constructor(
+    private readonly tournamentRepository: ManyTablesTournamentRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly purchaseRepository: PurchaseRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
+    private readonly options: ManyTablesTournamentRoomsFactoryOptions,
+    @InjectConnection() private readonly connection: Connection,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.rooms = new Map<string, ManyTablesTournamentRoom>();
+    this.createDailyTournamentJob = null;
+  }
+
+  get gameType() {
+    return this.options.gameType;
+  }
+
+  getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
+    return this.rooms.get(roomId);
+  }
+
+  getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
+    const { roomId } = GameMaster.parseTableId(tableId);
+
+    return this.getRoomById(roomId);
+  }
+
+  getRooms(): Array<ManyTablesTournamentRoom> {
+    return Array.from(this.rooms.values());
+  }
+
+  getTables(): Array<GameMaster> {
+    return this.getRooms().reduce((result, currentValue) => {
+      return [...result, ...currentValue.getMasters()];
+    }, [] as Array<GameMaster>);
+  }
+
+  addRoom(room: ManyTablesTournamentRoom) {
+    this.rooms.set(room.getId(), room);
+  }
+
+  async hydrateTournamentsFromDB() {
+    const templates = await this.tournamentRepository.findActualTournaments(
+      this.gameType,
+    );
+    templates.forEach((item) => {
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(item),
+        ),
+      );
+    });
+  }
+
+  async runDailyTournamentJob() {
+    if (
+      this.options.dailyTournamentScheduleTaskTime &&
+      this.options.dailyTournamentTime
+    ) {
+      await this.createDailyTournament(this.options.dailyTournamentTime);
+
+      this.createDailyTournamentJob = schedule.scheduleJob(
+        this.options.dailyTournamentScheduleTaskTime,
+        () => this.createDailyTournament(this.options.dailyTournamentTime),
+      );
+    }
+  }
+
+  async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    const newTournament =
+      await this.tournamentRepository.createTournament(createTournamentDto);
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+      ),
+    );
+  }
+
+  async updateTournament(
+    tournamentId: string,
+    updateTournamentDto: ManyTablesTournamentUpdateDto,
+  ) {
+    const updatedTournament = await this.tournamentRepository.updateTournament(
+      tournamentId,
+      updateTournamentDto,
+    );
+
+    this.getRoomById(tournamentId)
+      ?.getRoomMaster<TournamentMaster>()
+      .cancelTournament();
+
+    this.addRoom(
+      this.options.createTournamentRoom(
+        this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament),
+      ),
+    );
+  }
+
+  async removeTournament(tournamentId: string) {
+    await this.tournamentRepository.removeTournament(tournamentId);
+  }
+
+  async buyTicket(tournamentId: string, player: GamePlayer) {
+    const tournament = this.getRoomById(tournamentId);
+    const user = await this.usersRepository.findById(player.id);
+
+    if (!tournament || !user) {
+      throw new InternalServerErrorException();
+    }
+
+    const session = await this.connection.startSession();
+    session.startTransaction();
+
+    try {
+      player.decreaseBalance(tournament.getTicketPrice());
+      tournament.addParticipant(player);
+      void this.purchaseRepository.addManyTablesTournamentTicketPurchase(
+        player.id,
+        player.fullName,
+        tournamentId,
+        tournament.getTicketPrice(),
+        tournament.getGameType(),
+      );
+      void this.usersRepository.subtractFromBalance(
+        player.id,
+        tournament.getTicketPrice(),
+      );
+
+      await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+        playerId: player.id,
+        playerAvatarUrl: player.avatarUrl,
+        playerName: player.fullName,
+      });
+
+      await session.commitTransaction();
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  private manyTablesTournamentDocumentToTournamentRoom(
+    tournamentDocument: ManyTablesTournamentRoomDocument,
+  ): ManyTablesTournamentRoomConfig {
+    return {
+      id: tournamentDocument.tournamentId,
+      gameType: tournamentDocument.gameType,
+      roomType: tournamentDocument.roomType,
+      rulesType: tournamentDocument.rulesType,
+      deckType: tournamentDocument.deckType,
+      tableSize: tournamentDocument.tableSize,
+      bet: tournamentDocument.bet,
+      ticketPrice: tournamentDocument.ticketPrice,
+      title: tournamentDocument.title,
+      subtitle: tournamentDocument.subtitle,
+      description: tournamentDocument.description,
+      enableForFastGame: false,
+      scheduleDate: tournamentDocument.scheduleDate,
+      turnTimeout: this.options.playersTurnTimeout,
+      restartTimeout: this.options.restartGameTimeout,
+      instantFinishMode: this.options.instantFinishMode,
+      minPlayersForMergeTables: this.options.minPlayersForMergeTables,
+      localeService: this.options.i18n as LocalService,
+      startStrategy: new NoStartStrategy(),
+      onRoomEvent: this.handleRoomEvent,
+      tournamentPrizeTable: this.options.tournamentPrizeTable,
+      tournamentInitialStatus: tournamentDocument.status,
+      tournamentWinners: tournamentDocument.winners,
+      maxParticipants: tournamentDocument.maxParticipants,
+      participants: tournamentDocument.participants,
+    };
+  }
+
+  private handleRoomEvent = (event: BaseGameEvent) => {
+    this.logger.log(event.toLog());
+
+    if (event instanceof GameTableFinishedEvent) {
+      void this.handleRoomTableGameFinished(event.master);
+    } else if (event instanceof GameTournamentStartedEvent) {
+      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentCancelledEvent) {
+      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentFinishedEvent) {
+      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
+    } else if (
+      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
+      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
+      event instanceof GameTournamentCancelledEvent ||
+      event instanceof GameTournamentWaitedEvent ||
+      event instanceof GameTournamentStartedEvent ||
+      event instanceof GameTournamentFinishedEvent
+    ) {
+      void this.handleRoomStatusUpdated(
+        new RoomUpdateStateEvent(event.gameType, event.roomId),
+      );
+    }
+  };
+
+  private handleRoomTableGameFinished = async (master: GameMaster) => {
+    await saveGameTablesResult(
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      false,
+    );
+  };
+
+  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+    await this.tournamentRepository.startTournament(master.getTournamentId());
+  };
+
+  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+    await this.tournamentRepository.cancelTournament(master.getTournamentId());
+  };
+
+  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
+    await saveTournamentResult(
+      master,
+      this.connection,
+      this.tournamentRepository,
+      this.usersRepository,
+    );
+  };
+
+  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  };
+
+  private createDailyTournament = async (dailyTournamentTime: string) => {
+    const hour = getHours(dailyTournamentTime);
+    const minutes = getMinutes(dailyTournamentTime);
+    const jobEveningDate = dayjs()
+      .set('hour', hour)
+      .set('minute', minutes)
+      .set('second', 0);
+    const addingDay = dayjs().isBefore(jobEveningDate) ? 0 : 1;
+
+    const startDate = dayjs().add(addingDay, 'day').startOf('day');
+    const endDate = dayjs().add(addingDay, 'day').endOf('day');
+
+    const tournamentDate = dayjs()
+      .add(addingDay, 'day')
+      .set('hour', hour)
+      .set('minute', minutes);
+
+    const waitedTournament =
+      await this.tournamentRepository.findWaitingTournamentByDate(
+        this.gameType,
+        startDate.toDate(),
+        endDate.toDate(),
+      );
+
+    if (!waitedTournament) {
+      const newTournament =
+        await this.tournamentRepository.scheduleTournamentFromMasterTemplate(
+          this.gameType,
+          tournamentDate.toDate(),
+        );
+
+      this.addRoom(
+        this.options.createTournamentRoom(
+          this.manyTablesTournamentDocumentToTournamentRoom(newTournament),
+        ),
+      );
+    }
+  };
+}

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.getDbResource(item.title),
+                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;
 }

package/src/modules/menu/menu.module.ts

@@ -1,33 +1,39 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { Menu, MenuSchema, MenuRepository, Banner, BannerSchema, BannersRepository } from 'jp.db.schemas';
+import {
+  Menu,
+  MenuSchema,
+  MenuRepository,
+  Banner,
+  BannerSchema,
+  BannersRepository,
+} from 'jp.db.schemas';
 
 import { MenuController } from './menu.controller';
 import { MenuService } from './menu.service';
-import { MENU_OPTIONS } from './menu.constants'
+import { MENU_OPTIONS } from './menu.constants';
 import { MenuModuleOptions } from './menu.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: Menu.name, schema: MenuSchema }]),
-        MongooseModule.forFeature([{ name: Banner.name, schema: BannerSchema }]),
-    ],
-    controllers: [MenuController],
-    providers: [MenuRepository, MenuService, BannersRepository],
+  imports: [
+    MongooseModule.forFeature([{ name: Menu.name, schema: MenuSchema }]),
+    MongooseModule.forFeature([{ name: Banner.name, schema: BannerSchema }]),
+  ],
+  controllers: [MenuController],
+  providers: [MenuRepository, MenuService, BannersRepository],
 })
 export class MenuModule {
-    static forRootAsync(options: MenuModuleOptions): DynamicModule {
-        return {
-            module: MenuModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: MENU_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: MenuModuleOptions): DynamicModule {
+    return {
+      module: MenuModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: MENU_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 }
-

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

@@ -1,8 +1,6 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { BannersRepository, MenuRepository } from 'jp.db.schemas';
-import {
-    IAppHeaders,
-} from 'jp.common.models';
+import { IAppHeaders } from 'jp.common.models';
 
 import { BaseAppScreenDto } from '../../dto';
 
@@ -12,24 +10,26 @@ import { MenuScreenView } from './menu-screen.view';
 
 @Injectable()
 export class MenuService {
-    constructor(
-        private readonly menuRepository: MenuRepository,
-        private readonly bannersRepository: BannersRepository,
-        @Inject(MENU_OPTIONS) private readonly options: MenuFactoryOptions
-    ) {
-    }
+  constructor(
+    private readonly menuRepository: MenuRepository,
+    private readonly bannersRepository: BannersRepository,
+    @Inject(MENU_OPTIONS) private readonly options: MenuFactoryOptions,
+  ) {}
 
-    async getScreen (headers: IAppHeaders): Promise<BaseAppScreenDto> {
-        const menuItems = await this.menuRepository.findMenus('ALL', 'VK') ?? [];
-        const enabledBanner = await this.bannersRepository.findEnabledBanner(headers.client_game, headers.client_channel);
+  async getScreen(headers: IAppHeaders): Promise<BaseAppScreenDto> {
+    const menuItems = (await this.menuRepository.findMenus('ALL', 'VK')) ?? [];
+    const enabledBanner = await this.bannersRepository.findEnabledBanner(
+      headers.client_game,
+      headers.client_channel,
+    );
 
-        return new BaseAppScreenDto(
-            new MenuScreenView(
-                this.options.i18n,
-                headers.client_language,
-                menuItems,
-                enabledBanner,
-            ).buildBS()
-        );
-    }
+    return new BaseAppScreenDto(
+      new MenuScreenView(
+        this.options.i18n,
+        headers.client_language,
+        menuItems,
+        enabledBanner,
+      ).buildBS(),
+    );
+  }
 }