jp.ms.common.modules 1.0.18 → 1.0.20

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

@@ -0,0 +1,31 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+
+import { MainController } from './main.controller';
+import { MainService } from './main.service';
+import { MAIN_OPTIONS } from './main.constants';
+import { MainModuleOptions } from './main.interfaces';
+
+@Module({
+    controllers: [MainController],
+    providers: [MainService],
+})
+export class MainModule {
+    constructor () {
+
+    }
+
+    static forRootAsync (options: MainModuleOptions): DynamicModule {
+        return {
+            module: MainModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: MAIN_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}
+

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

@@ -0,0 +1,111 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIdEnum,
+    AppScreenRoutesEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    BaseAppScreen,
+    router,
+    AppScreenIconEnum,
+    AppScreenSectionButtons,
+} from 'jp.common.models';
+import { replacePattern } from 'jp.common.utils';
+
+import { BaseAppScreenDto, PlayerCheckStateDto } 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 { MainFactoryOptions } from './main.interfaces';
+import { MAIN_OPTIONS } from './main.constants';
+
+@Injectable()
+export class MainService {
+    constructor (
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
+    ) {
+    }
+
+    async getScreen (lang: string): Promise<BaseAppScreenDto> {
+        const oneTableTournamentsCardList = this.oneTableRoomsManagerService.getRooms().map((room) =>
+            AppScreenSectionListItem.CreateCardListItemMini(
+                room.getId(),
+                room.getTitle(lang),
+                room.getSubtitle(lang),
+                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                true,
+                router.getRoomPath(room.getFirstMaster()?.getId() ?? ''),
+        ));
+
+        const manyTablesTournamentsCardList = this.manyTablesRoomsManagerService.getRooms().map((room) =>
+            AppScreenSectionListItem.CreateCardListItemExtended(
+                room.getId(),
+                room.getTitle(lang),
+                room.getSubtitle(lang),
+                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                true,
+                true,
+                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                room.getDescription(lang),
+                AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
+            ));
+
+        const simpleRoomsTableCardList = this.simpleRoomsManager.getRooms().reduce<Array<AppScreenSectionListItem>>((result, room) => {
+            const list = room.getTables().map((table) => AppScreenSectionListItem.CreateCardListItemMini(
+                    table.getId(),
+                    replacePattern(table.getTitle(lang), { NUMBER: table.getNumber().toString() }),
+                    replacePattern(table.getSubtitle(lang), {
+                        HALF_BET: table.getHalfBet().toString(),
+                        BET: table.getBet().toString()
+                    }),
+                    AppScreenSectionImage.CreateUrlImage(`${table.getPlayers().length}/${table.getTableSize()}`),
+                    true,
+                    router.getRoomPath(table.getId()),
+                ));
+
+            return [...result, ...list];
+        }, []);
+
+        const screen =
+            AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+                .addAppBar(
+                    AppScreenAppBar.CreateStandardAppBar(
+                        this.options.i18n.t('common.rooms.screen.title', { lang }),
+                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
+                    ),
+                )
+                .addSection(
+                    AppScreenSection.CreateCardListSection(
+                        'id1',
+                        [
+                            ...manyTablesTournamentsCardList,
+                            ...oneTableTournamentsCardList,
+                            ...simpleRoomsTableCardList
+                        ]
+                    ),
+                );
+
+        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    }
+
+    playerCheckState (clientAuthToken: string): PlayerCheckStateDto {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        if (player && player.isPlayer() && player.tableId) {
+            return PlayerCheckStateDto.fromEntities(router.getRoomPath(player.tableId), player.id);
+        }
+
+        return PlayerCheckStateDto.fromEntities(AppScreenRoutesEnum.MENU);
+    }
+
+    findFreeTable (clientAuthToken: string) {
+    }
+}

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

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

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

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

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

@@ -0,0 +1,96 @@
+import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode, Patch, Delete } from '@nestjs/common';
+import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+
+import { ManyTablesTournamentService } from './many-tables-tournament.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+
+@Controller('tournament/many_tables')
+export class ManyTablesTournamentController {
+    constructor (
+        private readonly tournamentService: ManyTablesTournamentService,
+    ) {
+    }
+
+    @Get('status/:tournamentId')
+    getStatusScreen (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<IBaseAppScreen> {
+        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('tables/:tournamentId')
+    getTableListScreen (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<IBaseAppScreen> {
+        return this.tournamentService.getTableListScreen(tournamentId, headers.client_language);
+    }
+
+    @Post('table/watch/:tableId')
+    @HttpCode(HttpStatus.OK)
+    watchTheTable (
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        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,
+    ): IBaseTableGameState {
+        return this.tournamentService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
+    }
+
+    @Post('join/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    joinTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): JoinTournamentDto {
+        return this.tournamentService.joinTournament(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('leave/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    leaveTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('create')
+    @HttpCode(HttpStatus.OK)
+    createTournament (
+        @Headers() headers: IAppHeaders,
+        @Body() createTournamentDto: ManyTablesTournamentCreateDto,
+    ): Promise<void> {
+        return this.tournamentService.createTournament(createTournamentDto);
+    }
+
+    @Patch('update/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    updateTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Body() updateTournamentDto: ManyTablesTournamentUpdateDto,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.updateTournament(tournamentId, updateTournamentDto);
+    }
+
+    @Delete('remove/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    removeTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.removeTournament(tournamentId);
+    }
+}

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

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

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

@@ -0,0 +1,36 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema, TournamentManyTablesRoomsRepository } from 'jp.db.schemas';
+
+import { ManyTablesTournamentController } from './many-tables-tournament.controller';
+import { ManyTablesTournamentService } from './many-tables-tournament.service';
+import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
+    ],
+    controllers: [ManyTablesTournamentController],
+    providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
+})
+export class ManyTablesTournamentModule {
+    constructor () {
+
+    }
+
+    static forRootAsync (options: ManyTablesTournamentModuleOptions): DynamicModule {
+        return {
+            module: ManyTablesTournamentModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: MANY_TABLES_TOURNAMENT_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}
+

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

@@ -0,0 +1,189 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    BaseAppScreen,
+    IBaseMoveData,
+    IBaseTableGameState,
+    AppScreenIconEnum,
+    AppScreenSectionButtons,
+    router,
+} from 'jp.common.models';
+
+import { BaseAppScreenDto } from '../../dto';
+import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+
+import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
+import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+
+@Injectable()
+export class ManyTablesTournamentService {
+    constructor (
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(MANY_TABLES_TOURNAMENT_OPTIONS) private readonly options: ManyTablesTournamentFactoryOptions,
+    ) {
+    }
+
+    async getStatusScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        const screen =
+            AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
+                .addAppBar(
+                    AppScreenAppBar.CreateStatusAppBar(
+                        this.options.i18n.t('common.rooms.screen.title', { lang }),
+                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
+                    ),
+                )
+                .addSection((
+                    AppScreenSection.CreateStatusHeader(
+                        'status',
+                        'description',
+                        AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                        AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
+                    )
+                ))
+                .addSection(
+                    AppScreenSection.CreateCardListSection(
+                        'id1',
+                        tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
+                            item.playerId,
+                            item.playerName,
+                            '',
+                            AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
+                            true,
+                            '',
+                        ))
+                    ),
+                );
+
+        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    }
+
+    async getTableListScreen (tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+        const screen =
+            AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+                .addAppBar(
+                    AppScreenAppBar.CreateStandardAppBar(
+                        this.options.i18n.t('common.rooms.screen.title', { lang }),
+                        AppScreenSectionButton.CreateArrowBackButton(this.options.i18n.t('common.button.back', { lang })),
+                    ),
+                )
+                .addSection(
+                    AppScreenSection.CreateCardListSection(
+                        'id1',
+                        this.manyTablesRoomsManagerService.getRoomById(tournamentId)?.getTables().map((table) =>
+                            AppScreenSectionListItem.CreateCardListItemMini(
+                                table.getId(),
+                                table.getTitle(lang),
+                                table.getSubtitle(lang),
+                                AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                                true,
+                                router.getRoomPath(table.getId()),
+                            )
+                        ) ?? []
+                    ),
+                );
+
+        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    }
+
+    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleWatchTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleMoveOnTheTable(player, tableId, moveDto);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    joinTournament (tournamentId: string, clientAuthToken: string): JoinTournamentDto {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleJoinTournament(player);
+
+            if (tournament.getTournamentMaster().isInProgress()) {
+                if (player.isPlayer() || player.isTableQueuer()) {
+                    return JoinTournamentDto.fromEntities(
+                        router.getManyTablesTournamentTablePath(player.tableId ?? ''),
+                        player.id,
+                    );
+                } else {
+                    return JoinTournamentDto.fromEntities(
+                        router.getManyTablesTournamentTableListPath(),
+                        player.id,
+                    );
+                }
+            } else {
+                return JoinTournamentDto.fromEntities(
+                    router.getManyTablesTournamentStatusPath(tournament.getId()),
+                    player.id,
+                );
+            }
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    leaveTournament (tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleLeaveTournament(player);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
+        return this.manyTablesRoomsManagerService.createTournament(createTournamentDto);
+    }
+
+    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
+        return this.manyTablesRoomsManagerService.updateTournament(tournamentId, updateTournamentDto);
+    }
+
+    async removeTournament (tournamentId: string) {
+        return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
+    }
+}

package/src/modules/menu/index.ts

@@ -0,0 +1 @@
+export { MenuModule } from './menu.module';

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

@@ -0,0 +1 @@
+export { OneTableTournamentModule } from './one-table-tournament.module';

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

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

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

@@ -0,0 +1,58 @@
+import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+
+import { OneTableTournamentService } from './one-table-tournament.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+
+@Controller('tournament/one_table')
+export class OneTableTournamentController {
+    constructor (
+        private readonly tournamentService: OneTableTournamentService,
+    ) {
+    }
+
+    @Get('status/:tournamentId')
+    getStatusScreen (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<IBaseAppScreen> {
+        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Post('table/watch/:tableId')
+    @HttpCode(HttpStatus.OK)
+    watchTheTable (
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        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,
+    ): IBaseTableGameState {
+        return this.tournamentService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
+    }
+
+    @Post('join/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    joinTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): JoinTournamentDto {
+        return this.tournamentService.joinTournament(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('leave/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    leaveTournament (
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
+    }
+}

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

@@ -0,0 +1,15 @@
+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 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
+}

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

@@ -0,0 +1,36 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TournamentOneTableRoom, TournamentOneTableRoomSchema, TournamentOneTableRoomsRepository } from 'jp.db.schemas';
+
+import { OneTableTournamentController } from './one-table-tournament.controller';
+import { OneTableTournamentService } from './one-table-tournament.service';
+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],
+})
+export class OneTableTournamentModule {
+    constructor () {
+
+    }
+
+    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,
+            ],
+        };
+    }
+}
+