jp.ms.common.modules 1.0.18 → 1.0.21

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

@@ -1,53 +1,35 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { MenuRepository } from 'jp.db.schemas';
 import {
-    AppScreen,
-    AppScreenIdEnum,
-    AppScreenSection,
-    AppScreenSectionImage,
-    AppScreenSectionListItem,
     BaseAppScreen,
     IAppHeaders,
 } from 'jp.common.models';
 
+import { BaseAppScreenDto } from '../../dto';
+
 import { MENU_OPTIONS } from './menu.constants';
 import { MenuFactoryOptions } from './menu.interfaces';
-
-import { BaseAppScreenDto } from '../../dto';
+import { MenuScreenView } from './menu-screen.view';
 
 @Injectable()
 export class MenuService {
-    constructor (
+    constructor(
         private readonly menuRepository: MenuRepository,
         @Inject(MENU_OPTIONS) private readonly options: MenuFactoryOptions
     ) {
     }
 
-    async getScreen (headers: IAppHeaders): Promise<BaseAppScreenDto> {
+    async getScreen(headers: IAppHeaders): Promise<BaseAppScreenDto> {
         const menuItems = await this.menuRepository.findMenus('ALL', 'VK') ?? [];
 
-        const screen =
-            AppScreen.CreateStandardScreen(AppScreenIdEnum.MENU)
-                .addSection(
-                    AppScreenSection.CreateMenuHeaderSection(
-                        'header',
-                        this.options.i18n.t('common.menu.header.title', { lang: headers.client_language }),
-                    ),
-                )
-                .addSection(
-                    AppScreenSection.CreateMenuListSection(
-                        'id1',
-                        menuItems.map((item) =>
-                            AppScreenSectionListItem.CreateMenuListItem(
-                                item.code,
-                                headers.client_language === 'ru' ? item.title : item.titleEn,
-                                AppScreenSectionImage.CreateIconImage(item.icon),
-                                item.url,
-                            ),
-                        ),
-                    ),
-                );
-
-        return new BaseAppScreenDto(new BaseAppScreen(screen));
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new MenuScreenView(
+                    this.options.i18n,
+                    headers.client_language,
+                    menuItems,
+                ).build()
+            )
+        );
     }
 }

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-status-screen.view.ts

@@ -0,0 +1,64 @@
+import {
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    StandardScreenComponent,
+    StatusAppBarComponent,
+    StatusHeaderSectionComponent,
+    CardListSectionComponent,
+    ArrowBackButtonComponent,
+    IconImageComponent,
+    PrimaryButtonButtonsComponent,
+    TextButtonComponent,
+    MiniCardSectionListItemComponent,
+    UrlImageComponent,
+} from "jp.common.models";
+import { OneTableTournamentRoom } from "jp.ms.common.engine";
+
+export class OneTableTournamentStatusScreenView extends UniversalScreenView {
+    private readonly tournament: OneTableTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: OneTableTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.ROOMS)
+            .addAppBar(
+                new StatusAppBarComponent(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    new ArrowBackButtonComponent(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection(
+                new StatusHeaderSectionComponent(
+                    'status',
+                    'description',
+                    new IconImageComponent(AppScreenIconEnum.EMOJI_EVENTS),
+                    new PrimaryButtonButtonsComponent(new TextButtonComponent('button')),
+                )
+            )
+            .addSection(
+                new CardListSectionComponent(
+                    'id1',
+                    this.tournament.getParticipants().map((item) => (
+                        new MiniCardSectionListItemComponent(
+                            item.playerId,
+                            item.playerName,
+                            '',
+                            new UrlImageComponent(item.playerAvatarUrl),
+                            true,
+                            '',
+                        )
+                    ))
+                ),
+            );
+    }
+}

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,74 @@
+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,
+    ): IBaseAppScreen {
+        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('status/subscribe/:tournamentId')
+    subscribeOnStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('status/unsubscribe/:tournamentId')
+    unsubscribeFromStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.unsubscribeFromStatusScreen(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,53 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TournamentOneTableRoom, TournamentOneTableRoomSchema, TournamentOneTableRoomsRepository } from 'jp.db.schemas';
+import { GamePlayer, OneTableTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+
+import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { EventsBusOneTableTournamentSubscribeService } from '../event-bus';
+
+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(
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+        private readonly oneTableTournamentService: OneTableTournamentService,
+    ) { }
+
+    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,
+            ],
+        };
+    }
+
+    async onModuleInit() {
+        this.eventsBusOneTableTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
+    }
+
+    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+        this.oneTableRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
+            const screen = this.oneTableTournamentService.getStatusScreen(event.roomId, subscriber.language);
+            subscriber.sendMessage(new OneTableTournamentUpdateStatusWsEvent(screen.screen));
+        });
+    }
+}
+

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

@@ -0,0 +1,133 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    BaseAppScreen,
+    IBaseMoveData,
+    IBaseTableGameState,
+    router,
+} from 'jp.common.models';
+
+import { AppScreenDto, BaseAppScreenDto } from '../../dto';
+import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+
+import { OneTableTournamentFactoryOptions } from './one-table-tournament.interfaces';
+import { ONE_TABLE_TOURNAMENT_OPTIONS } from './one-table-tournament.constants';
+import { OneTableTournamentStatusScreenView } from './one-table-tournament-status-screen.view';
+
+@Injectable()
+export class OneTableTournamentService {
+    constructor(
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(ONE_TABLE_TOURNAMENT_OPTIONS) private readonly options: OneTableTournamentFactoryOptions,
+    ) {
+    }
+
+    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new OneTableTournamentStatusScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
+    }
+
+    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.addToStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.removeFromStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    watchTheTable(tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.oneTableRoomsManagerService.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.oneTableRoomsManagerService.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.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleJoinTournament(player);
+
+            if (tournament.getTournamentMaster().isInProgress()) {
+                const onlyTableId = tournament.getFirstMaster()?.getTable()?.getId() ?? '';
+                return JoinTournamentDto.fromEntities(
+                    router.getOneTableTournamentTablePath(onlyTableId),
+                    player.id,
+                );
+            } else {
+                return JoinTournamentDto.fromEntities(
+                    router.getOneTableTournamentStatusPath(tournament.getId()),
+                    player.id,
+                );
+            }
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.oneTableRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleLeaveTournament(player);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+}

package/src/modules/players-manager/index.ts

@@ -0,0 +1,2 @@
+export { PlayersManagerModule } from './players-manager.module';
+export { PlayersManagerService } from './players-manager.service';

package/src/modules/simple-rooms/index.ts

@@ -0,0 +1 @@
+export { SimpleRoomsModule } from './simple-rooms.module';

package/src/modules/simple-rooms/simple-rooms.constants.ts

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

package/src/modules/{rooms/rooms.controller.ts → simple-rooms/simple-rooms.controller.ts}

@@ -1,27 +1,14 @@
-import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
-import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+import { Body, Controller, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+import { IAppHeaders, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
 
-import { PlayerCheckStateDto } from '../../dto';
+import { SimpleRoomsService } from './simple-rooms.service';
 
-import { RoomsService } from './rooms.service';
-
-@Controller('rooms')
-export class RoomsController {
+@Controller('simple-rooms')
+export class SimpleRoomsController {
     constructor (
-        private readonly roomsService: RoomsService,
+        private readonly roomsService: SimpleRoomsService,
     ) {
     }
-
-    @Get('player/check/state')
-    checkState (@Headers() headers: IAppHeaders): PlayerCheckStateDto {
-        return this.roomsService.playerCheckState(headers.client_auth_token);
-    }
-
-    @Get('tables')
-    getScreen (@Headers() headers: IAppHeaders): Promise<IBaseAppScreen> {
-        return this.roomsService.getScreen(headers.client_language);
-    }
-
     @Post('table/watch/:tableId')
     @HttpCode(HttpStatus.OK)
     watchTheTable (
@@ -64,10 +51,4 @@ export class RoomsController {
     restartTable (@Param('tableId') tableId: string): boolean {
         return this.roomsService.restartTable(tableId);
     }
-
-    @Post('techBreakOn')
-    @HttpCode(HttpStatus.OK)
-    techBreakOn (): boolean {
-        return this.roomsService.techBreakOn();
-    }
 }

package/src/modules/simple-rooms/simple-rooms.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 SimpleRoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface SimpleRoomsFactoryOptions {
+    i18n: I18nService
+}

package/src/modules/simple-rooms/simple-rooms.module.ts

@@ -0,0 +1,36 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { SimpleRoom, SimpleRoomSchema, SimpleRoomsRepository } from 'jp.db.schemas';
+
+import { SimpleRoomsController } from './simple-rooms.controller';
+import { SimpleRoomsService } from './simple-rooms.service';
+import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
+import { SimpleRoomsModuleOptions } from './simple-rooms.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: SimpleRoom.name, schema: SimpleRoomSchema }]),
+    ],
+    controllers: [SimpleRoomsController],
+    providers: [SimpleRoomsService, SimpleRoomsRepository],
+})
+export class SimpleRoomsModule {
+    constructor () {
+
+    }
+
+    static forRootAsync (options: SimpleRoomsModuleOptions): DynamicModule {
+        return {
+            module: SimpleRoomsModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: SIMPLE_ROOMS_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}
+

package/src/modules/simple-rooms/simple-rooms.service.ts

@@ -0,0 +1,90 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    IBaseMoveData,
+    IBaseTableGameState,
+} from 'jp.common.models';
+
+import { SimpleRoomsManagerService } from '../simple-rooms-manager';
+import { PlayersManagerService } from '../players-manager';
+
+import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
+import { SimpleRoomsFactoryOptions } from './simple-rooms.interfaces';
+
+@Injectable()
+export class SimpleRoomsService {
+    constructor (
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(SIMPLE_ROOMS_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
+    ) {
+    }
+
+    watchTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleWatchTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    enterTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleEnterTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    exitTheTable (tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleExitTheTable(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.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleMoveOnTheTable(player, tableId, moveDto);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    restartTable (tableId: string): boolean {
+        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (room && master) {
+            room.handleRestartTable(tableId);
+
+            return true;
+        }
+
+        throw new InternalServerErrorException();
+    }
+}

package/src/modules/simple-rooms-manager/index.ts

@@ -0,0 +1,2 @@
+export { SimpleRoomsManagerModule } from './simple-rooms-manager.module';
+export { SimpleRoomsManagerService } from './simple-rooms-manager.service';