jp.ms.common.modules 1.0.34 → 1.0.36

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

@@ -1,295 +0,0 @@
-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,
-    ManyTablesTournamentRoom,
-    ManyTablesTournamentRoomConfig,
-    NoStartStrategy,
-    RoomUpdateStateEvent,
-    TournamentMaster
-} from 'jp.ms.common.engine';
-import {
-    GameResultRepository,
-    PurchaseRepository,
-    TournamentManyTablesRoomDocument,
-    TournamentManyTablesRoomsRepository,
-    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 { TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS } from './tournament-many-tables-rooms-manager.constants';
-import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-tables-rooms-manager.interfaces';
-
-
-@Injectable()
-export class TournamentManyTablesRoomsManagerService {
-    private readonly rooms: Map<string, ManyTablesTournamentRoom>;
-    private createDailyTournamentJob: Job | null;
-
-    constructor(
-        private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
-        private readonly usersRepository: UsersRepository,
-        private readonly gameResultRepository: GameResultRepository,
-        private readonly purchaseRepository: PurchaseRepository,
-        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
-        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
-        @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
-        @InjectConnection() private readonly connection: Connection,
-        @Inject() private readonly logger: JpLoggerService,
-    ) {
-        this.rooms = new Map<string, ManyTablesTournamentRoom>();
-        this.createDailyTournamentJob = null;
-    }
-
-    get gameType () {
-        return this.options.configService.get<string>('GAME_TYPE') || '';
-    }
-
-    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 () {
-        const dailyTournamentScheduleTaskTime = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_TASK_TIME');
-        const dailyTournamentTime = this.options.configService.get<string>('DAILY_TOURNAMENT_TIME');
-
-        if (dailyTournamentScheduleTaskTime && dailyTournamentTime) {
-            await this.createDailyTournament(dailyTournamentTime);
-
-            this.createDailyTournamentJob = schedule.scheduleJob(
-                dailyTournamentScheduleTaskTime,
-                () => this.createDailyTournament(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);
-            this.purchaseRepository.addManyTablesTournamentTicketPurchase(
-                player.id,
-                player.fullName,
-                tournamentId,
-                tournament.getTicketPrice(),
-                tournament.getGameType(),
-            )
-            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: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
-        const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
-        const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
-        const minPlayersForMergeTables = this.options.configService.get<string>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES');
-
-        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: playersTurnTimeout,
-            restartTimeout: restartGameTimeout,
-            minPlayersForMergeTables: parseInt(minPlayersForMergeTables ?? '0', 10),
-            localeService: this.options.i18n,
-            startStrategy: new NoStartStrategy(),
-            onRoomEvent: this.handleRoomEvent,
-            tournamentPrizeTable: this.options.tournamentPrizeTable,
-            tournamentInitialStatus: tournamentDocument.status,
-            tournamentWinners: tournamentDocument.winners,
-            maxParticipants: tournamentDocument.maxParticipants,
-            participants: tournamentDocument.participants,
-        } as ManyTablesTournamentRoomConfig;
-    }
-
-    private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
-
-        if (event instanceof GameTableFinishedEvent) {
-            this.handleRoomTableGameFinished(event.master!!);
-        } else if (event instanceof GameTournamentStartedEvent) {
-            this.handleTournamentRoomStarted(event.room.getRoomMaster());
-        } else if (event instanceof GameTournamentCancelledEvent) {
-            this.handleTournamentRoomCancelled(event.room.getRoomMaster());
-        } else if (event instanceof GameTournamentFinishedEvent) {
-            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
-        ) {
-            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 = async (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/tournament-one-table-rooms-manager/index.ts

@@ -1,2 +0,0 @@
-export { TournamentOneTableRoomsManagerModule } from './tournament-one-table-rooms-manager.module';
-export { TournamentOneTableRoomsManagerService } from './tournament-one-table-rooms-manager.service';

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

@@ -1 +0,0 @@
-export const TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS = Symbol('TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS');

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

@@ -1,20 +0,0 @@
-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';
-import { TournamentRoomConfig, OneTableTournamentRoom, IPrizeTableData } from 'jp.ms.common.engine';
-import { ConfigService } from '@nestjs/config';
-
-export interface TournamentOneTableRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
-}
-
-export interface TournamentOneTableRoomsFactoryOptions {
-    i18n: I18nService;
-    configService: ConfigService;
-    tournamentPrizeTable: IPrizeTableData;
-    createTournamentRoom (room: TournamentRoomConfig): OneTableTournamentRoom;
-}

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

@@ -1,59 +0,0 @@
-import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
-import {
-    TournamentOneTableRoom,
-    TournamentOneTableRoomSchema,
-    TournamentOneTableRoomsRepository,
-    User,
-    UserSchema,
-    UsersRepository,
-    GameResult,
-    GameResultSchema,
-    GameResultRepository,
-} from 'jp.db.schemas';
-
-import { TournamentOneTableRoomsManagerService } from './tournament-one-table-rooms-manager.service';
-import { TournamentOneTableRoomsManagerOptions } from './tournament-one-table-rooms-manager.interfaces';
-import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
-
-@Global()
-@Module({
-    imports: [
-        MongooseModule.forFeature([{name: TournamentOneTableRoom.name, schema: TournamentOneTableRoomSchema}]),
-        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
-        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
-    ],
-    providers: [
-        TournamentOneTableRoomsRepository,
-        UsersRepository,
-        TournamentOneTableRoomsManagerService,
-        GameResultRepository,
-    ],
-    exports: [TournamentOneTableRoomsManagerService],
-})
-export class TournamentOneTableRoomsManagerModule {
-    constructor (
-        private readonly managerService: TournamentOneTableRoomsManagerService,
-    ) {
-    }
-
-    static forRootAsync (options: TournamentOneTableRoomsManagerOptions): DynamicModule {
-        return {
-            module: TournamentOneTableRoomsManagerModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
-
-    async onModuleInit () {
-        await this.managerService.createMasterTournament();
-        await this.managerService.hydrateTournamentsFromDB();
-    }
-}
-