jp.ms.common.modules 1.0.0

package/src/dto/base/player-check-state.dto.ts

@@ -0,0 +1,30 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+import { IsString } from 'class-validator';
+
+export class PlayerCheckStateDto {
+    @ApiProperty({
+        description: 'Идентификатор пользователя',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    playerId?: string;
+
+    @ApiProperty({
+        description: 'redirect link',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    redirectUrl: string;
+
+    static fromEntities(redirectUrl: string, playerId?: string): PlayerCheckStateDto {
+        const dto = new PlayerCheckStateDto();
+        dto.redirectUrl = redirectUrl;
+        dto.playerId = playerId
+        return dto;
+    }
+}

package/src/dto/index.ts

@@ -0,0 +1,2 @@
+export * from './base'
+export * from './app-screen'

package/src/index.ts

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

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

@@ -0,0 +1,62 @@
+import {
+  WebSocketServer,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+} from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { UsersRepository } from 'jp.db.schemas';
+import { GamePlayer } from 'jp.ms.common.engine';
+
+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);
+      }
+    }
+  }
+
+  handleDisconnect (client: Socket): void {
+    const c = client;
+  }
+}

package/src/modules/index.ts

@@ -0,0 +1,15 @@
+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';
+
+export {
+    PlayersManagerModule,
+    PlayersManagerService,
+    BaseEventsGateway,
+    MenuModule,
+    MenuService,
+    MenuController,
+}

package/src/modules/menu/menu.constants.ts

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

package/src/modules/menu/menu.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Get, Headers } from '@nestjs/common';
+import { IAppHeaders } from 'jp.common.models';
+
+import { BaseAppScreenDto } from '../../dto';
+
+import { MenuService } from './menu.service';
+
+@Controller()
+export class MenuController {
+    constructor (private readonly menuService: MenuService) {
+    }
+
+    @Get('menu')
+    getScreen(@Headers() headers: IAppHeaders): Promise<BaseAppScreenDto> {
+        return this.menuService.getScreen(headers);
+    }
+}

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

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

@@ -0,0 +1,32 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Menu, MenuSchema, MenuRepository } from 'jp.db.schemas';
+
+import { MenuController } from './menu.controller';
+import { MenuService } from './menu.service';
+import { MENU_OPTIONS } from './menu.constants'
+import { MenuModuleOptions } from './menu.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: Menu.name, schema: MenuSchema }]),
+    ],
+    controllers: [MenuController],
+    providers: [MenuRepository, MenuService],
+})
+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,
+            ],
+        };
+    }
+}
+

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

@@ -0,0 +1,53 @@
+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 { MENU_OPTIONS } from './menu.constants';
+import { MenuFactoryOptions } from './menu.interfaces';
+
+import { BaseAppScreenDto } from '../../dto';
+
+@Injectable()
+export class MenuService {
+    constructor (
+        private readonly menuRepository: MenuRepository,
+        @Inject(MENU_OPTIONS) private readonly options: MenuFactoryOptions
+    ) {
+    }
+
+    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));
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PlayersManagerService } from './players-manager.service';
+
+
+@Module({
+  providers: [PlayersManagerService],
+  exports: [PlayersManagerService]
+})
+export class PlayersManagerModule {}

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

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { GamePlayer } from 'jp.ms.common.engine';
+
+@Injectable()
+export class PlayersManagerService {
+  private readonly players: Map<string, GamePlayer>;
+
+  constructor () {
+    this.players = new Map<string, GamePlayer>();
+  }
+
+  getPlayerById (playerId: string): GamePlayer | undefined {
+    return this.players.get(playerId);
+  }
+
+  getPlayers (): Array<GamePlayer> {
+    return Array.from(this.players.values());
+  }
+
+  addPlayer (player: GamePlayer): void {
+    this.players.set(player.id, player);
+  }
+
+  removePlayer (playerId: string): void {
+    this.players.delete(playerId);
+  }
+}