jp.ms.common.modules 1.0.1 → 1.0.2

package/src/dto/table-game/cards/card-player.dto.ts

@@ -0,0 +1,15 @@
+import { Expose, Type } from 'class-transformer';
+import { IsArray, IsBoolean, IsNumber, IsString, ValidateNested } from 'class-validator';
+import { ICardPlayerState } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { CardDto } from './card.dto';
+import { GamePlayerDto } from '../base/game-player.dto';
+
+export class CardPlayerDto extends GamePlayerDto implements ICardPlayerState {
+    @IsArray()
+    @ValidateNested({ each: true })
+    @Type(() => CardDto)
+    @Expose()
+    cards: Array<CardDto>;
+}

package/src/dto/table-game/cards/card-table-game-state.dto.ts

@@ -0,0 +1,50 @@
+import { Expose, plainToInstance, Type } from 'class-transformer';
+import { IsArray, ValidateNested } from 'class-validator';
+import { ICardTableGameState } from 'jp.common.models';
+
+import { CardTableGameStateAdapter } from '../../../adapter';
+
+import { CardPlayerDto } from './card-player.dto';
+import { CardPairSlotDto } from './card-pair-slot.dto';
+import { CardDto } from './card.dto';
+import { CardsPanelDto } from './cards-panel.dto';
+import { BaseTableGameStateDto } from '../base/base-table-game-state.dto';
+
+export class CardTableGameStateDto extends BaseTableGameStateDto implements ICardTableGameState {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CardPlayerDto)
+  @Expose()
+  players: Array<CardPlayerDto>;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CardDto)
+  @Expose()
+  gameCards: Array<CardDto>;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CardPairSlotDto)
+  @Expose()
+  gameCardsPair: Array<CardPairSlotDto>;
+
+  @ValidateNested()
+  @Type(() => CardDto)
+  @Expose()
+  baseCard?: CardDto;
+
+  @ValidateNested()
+  @Type(() => CardsPanelDto)
+  @Expose()
+  cardsPanel: CardsPanelDto;
+
+  constructor(entity: ICardTableGameState) {
+    super();
+    return plainToInstance(CardTableGameStateDto, entity, { excludeExtraneousValues: true })
+  }
+
+  static fromAdapter (adapter: CardTableGameStateAdapter) {
+    return new CardTableGameStateDto(adapter.getState());
+  }
+}

package/src/dto/{base → table-game/cards}/card.dto.ts

@@ -1,10 +1,9 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { Expose } from 'class-transformer';
-import { IsString, IsNumber, IsBoolean } from 'class-validator';
+import { Expose, Type } from 'class-transformer';
+import { IsString, IsNumber, IsBoolean, IsArray, ValidateNested } from 'class-validator';
+import { ICardState } from 'jp.common.models';
 
-import { IBaseTableGameStateCard } from 'jp.common.models';
-
-export class CardDto implements IBaseTableGameStateCard {
+export class CardDto implements ICardState {
   @ApiProperty({
     description: 'card ID',
     required: true,
@@ -40,4 +39,10 @@ export class CardDto implements IBaseTableGameStateCard {
   @Expose()
   @IsBoolean()
   isDisable: boolean;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Number)
+  @Expose()
+  targets: Array<number>;
 }

package/src/dto/table-game/cards/cards-panel.dto.ts

@@ -0,0 +1,40 @@
+import { Expose, Type } from 'class-transformer';
+import { IsArray, IsBoolean, ValidateNested } from 'class-validator';
+import { ICardsPanelState } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { BaseTableYoursActionDto } from '../base/base-table-yours-action.dto';
+
+import { CardDto } from './card.dto';
+
+export class CardsPanelDto implements ICardsPanelState {
+  @ApiProperty({
+    description: 'isOpen',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  isOpen: boolean;
+
+  @ApiProperty({
+    description: 'backdropVisible',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  backdropVisible: boolean;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => BaseTableYoursActionDto)
+  @Expose()
+  moves: Array<BaseTableYoursActionDto>;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CardDto)
+  @Expose()
+  cards: Array<CardDto>;
+}

package/src/dto/table-game/index.ts

@@ -0,0 +1,2 @@
+export { CardTableGameStateDto } from './cards/card-table-game-state.dto';
+

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './dto';
 export * from './modules';
 export * from './config';
+export * from './adapter';

package/src/modules/events/events.constants.ts

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

package/src/modules/events/events.gateway.ts

@@ -1,62 +1,68 @@
 import {
-  WebSocketServer,
-  OnGatewayConnection,
-  OnGatewayDisconnect,
+    WebSocketServer,
+    OnGatewayConnection,
+    OnGatewayDisconnect,
+    WebSocketGateway,
 } from '@nestjs/websockets';
 import { Server, Socket } from 'socket.io';
 import { UsersRepository } from 'jp.db.schemas';
-import { GamePlayer } from 'jp.ms.common.engine';
+import { Inject, Injectable } from '@nestjs/common';
 
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 
-export abstract class BaseEventsGateway implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket> {
-  @WebSocketServer()
-  server: Server;
-
-  private playersManager: PlayersManagerService;
-  private readonly usersRepository: UsersRepository;
-
-  protected constructor (
-    playersManager: PlayersManagerService,
-    usersRepository: UsersRepository,
-  ) {
-    this.playersManager = playersManager;
-    this.usersRepository = usersRepository;
-  }
-
-  abstract createPlayer (
-    userId: string,
-    fullName: string,
-    avatarUrl: string,
-    balance: number,
-    experience: number,
-    level: number,
-  ): GamePlayer;
-
-  async handleConnection (client: Socket) {
-    const playerId = client.handshake.auth.token as string | undefined;
-
-    const player = this.playersManager.getPlayerById(playerId ?? '');
-    if (player) {
-      player.connections.addConnection(client);
-    } else {
-      const user = await this.usersRepository.findById(playerId ?? '');
-      if (user) {
-        const player = this.createPlayer(
-          user.userId,
-          user.fullName,
-          user.avatarUrl,
-          user.balance,
-          user.experience,
-          user.level,
-        );
-        this.playersManager.addPlayer(player);
-        player.connections.addConnection(client);
-      }
+import { EVENTS_OPTIONS } from './events.constants';
+import { EventsFactoryOptions, EventsModuleOptions } from './events.interfaces';
+
+@WebSocketGateway({ cors: { origin: '*' } })
+export class EventsGateway implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket> {
+    @WebSocketServer()
+    server: Server;
+
+    constructor (
+        private readonly playersManager: PlayersManagerService,
+        private readonly usersRepository: UsersRepository,
+        @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
+    ) {
+    }
+
+    async handleConnection (client: Socket) {
+        const playerId = client.handshake.auth.token as string | undefined;
+
+        const player = this.playersManager.getPlayerById(playerId ?? '');
+        if (player) {
+            player.connections.addConnection(client);
+        } else {
+            const user = await this.usersRepository.findById(playerId ?? '');
+            if (user) {
+                const player = this.options.createPlayer({
+                    id: user.userId,
+                    fullName: user.fullName,
+                    avatarUrl: user.avatarUrl,
+                    balance: user.balance,
+                    experience: user.experience,
+                    level: user.level,
+                    language: user.language,
+                });
+                this.playersManager.addPlayer(player);
+                player.connections.addConnection(client);
+            }
+        }
     }
-  }
 
-  handleDisconnect (client: Socket): void {
-    const c = client;
-  }
+    handleDisconnect (client: Socket): void {
+        const playerId = client.handshake.auth.token as string | undefined;
+        const connectedPlayer = this.playersManager.getPlayerById(playerId ?? '');
+
+        if (connectedPlayer) {
+            connectedPlayer.disconnect();
+
+            if (!connectedPlayer.isPlayer() &&
+                !connectedPlayer.isTableQueuer() &&
+                !connectedPlayer.isRoomQueuer() &&
+                !connectedPlayer.hasOpenConnection()
+            ) {
+                this.playersManager.removePlayer(playerId ?? '');
+            }
+        }
+    }
 }

package/src/modules/events/events.interfaces.ts

@@ -0,0 +1,16 @@
+import { GamePlayer, IGamePlayerConfig } from 'jp.ms.common.engine';
+import { ModuleMetadata } from '@nestjs/common';
+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 EventsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface EventsFactoryOptions {
+    createPlayer: (config: IGamePlayerConfig) => GamePlayer;
+}

package/src/modules/events/events.module.ts

@@ -0,0 +1,33 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { User, UserSchema, UsersRepository } from 'jp.db.schemas';
+
+import { PlayersManagerModule } from '../players-manager/players-manager.module';
+
+import { EventsGateway } from './events.gateway';
+import { EventsModuleOptions } from './events.interfaces';
+import { EVENTS_OPTIONS } from './events.constants';
+
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+        PlayersManagerModule,
+    ],
+    providers: [UsersRepository, EventsGateway],
+})
+export class EventsModule {
+    static forRootAsync(options: EventsModuleOptions): DynamicModule {
+        return {
+            module: EventsModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: EVENTS_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}

package/src/modules/index.ts

@@ -1,15 +1,23 @@
 import { PlayersManagerModule } from './players-manager/players-manager.module';
 import { PlayersManagerService } from './players-manager/players-manager.service';
-import { BaseEventsGateway } from './events/events.gateway';
 import { MenuModule } from './menu/menu.module';
 import { MenuService } from './menu/menu.service';
 import { MenuController } from './menu/menu.controller';
+import { EventsModule } from './events/events.module';
+import { SimpleRoomsManagerModule } from './simple-rooms-manager/simple-rooms-manager.module';
+import { SimpleRoomsManagerService } from './simple-rooms-manager/simple-rooms-manager.service';
+import { RoomsModule } from './rooms/rooms.module';
+import { SupportModule } from './support/support.module';
 
 export {
     PlayersManagerModule,
     PlayersManagerService,
-    BaseEventsGateway,
     MenuModule,
     MenuService,
     MenuController,
+    EventsModule,
+    SimpleRoomsManagerModule,
+    SimpleRoomsManagerService,
+    RoomsModule,
+    SupportModule,
 }

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

@@ -1,7 +1,8 @@
-import { Module } from '@nestjs/common';
+import { Global, Module } from '@nestjs/common';
 import { PlayersManagerService } from './players-manager.service';
 
 
+@Global()
 @Module({
   providers: [PlayersManagerService],
   exports: [PlayersManagerService]

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

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

package/src/modules/rooms/rooms.controller.ts

@@ -0,0 +1,73 @@
+import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+
+import { PlayerCheckStateDto } from '../../dto';
+
+import { RoomsService } from './rooms.service';
+
+@Controller('rooms')
+export class RoomsController {
+    constructor (
+        private readonly roomsService: RoomsService,
+    ) {
+    }
+
+    @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 (
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
+    }
+
+    @Post('table/enter/:tableId')
+    @HttpCode(HttpStatus.OK)
+    enterTheTable (
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
+    }
+
+    @Post('table/exit/:tableId')
+    @HttpCode(HttpStatus.OK)
+    exitTheTable (
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.roomsService.exitTheTable(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.roomsService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
+    }
+
+    @Post('table/restart/:tableId')
+    @HttpCode(HttpStatus.OK)
+    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/rooms/rooms.interfaces.ts

@@ -0,0 +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';
+import { IBaseTableGameState } from 'jp.common.models';
+
+export interface RoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface RoomsFactoryOptions {
+    i18n: I18nService
+    createTableDto: (data: object) => IBaseTableGameState
+}

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

@@ -0,0 +1,36 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Room, RoomSchema, RoomsRepository } from 'jp.db.schemas';
+
+import { RoomsController } from './rooms.controller';
+import { RoomsService } from './rooms.service';
+import { ROOMS_OPTIONS } from './rooms.constants';
+import { RoomsModuleOptions } from './rooms.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: Room.name, schema: RoomSchema }]),
+    ],
+    controllers: [RoomsController],
+    providers: [RoomsService, RoomsRepository],
+})
+export class RoomsModule {
+    constructor () {
+
+    }
+
+    static forRootAsync (options: RoomsModuleOptions): DynamicModule {
+        return {
+            module: RoomsModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: ROOMS_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+}
+

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

@@ -0,0 +1,150 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIdEnum,
+    AppScreenRoutesEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    BaseAppScreen, IBaseMoveData,
+    IBaseTableGameState,
+    router,
+} from 'jp.common.models';
+import { replacePattern } from 'jp.common.utils';
+
+import { BaseAppScreenDto, PlayerCheckStateDto } from '../../dto';
+import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+
+import { RoomsFactoryOptions } from './rooms.interfaces';
+import { ROOMS_OPTIONS } from './rooms.constants';
+
+@Injectable()
+export class RoomsService {
+    constructor (
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(ROOMS_OPTIONS) private readonly options: RoomsFactoryOptions,
+    ) {
+    }
+
+    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);
+    }
+
+    async getScreen (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.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];
+                        }, []),
+                    ),
+                );
+
+        return new BaseAppScreenDto(new BaseAppScreen(screen));
+    }
+
+    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();
+    }
+
+    techBreakOn (): boolean {
+        this.simpleRoomsManager.getRooms().forEach((item) => item.handleTechBreakOn());
+
+        return true;
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+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 { GameRoomConfig, SimpleRoom } from 'jp.ms.common.engine';
+import { ConfigService } from '@nestjs/config';
+
+export interface SimpleRoomsManagerOptions 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;
+    configService: ConfigService;
+    createRoom (room: GameRoomConfig): SimpleRoom;
+}