jp.ms.common.modules 1.0.20 → 1.0.22

package/dist/views/index.d.ts

@@ -0,0 +1 @@
+export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';

package/dist/views/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentBuyTicketDialogView = void 0;
+var tournament_buy_ticket_dialog_view_1 = require("./tournament-buy-ticket-dialog.view");
+Object.defineProperty(exports, "TournamentBuyTicketDialogView", { enumerable: true, get: function () { return tournament_buy_ticket_dialog_view_1.TournamentBuyTicketDialogView; } });
+//# sourceMappingURL=index.js.map

package/dist/views/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/views/index.ts"],"names":[],"mappings":";;;AAAA,yFAAoF;AAA3E,kJAAA,6BAA6B,OAAA"}

package/dist/views/tournament-buy-ticket-dialog.view.d.ts

@@ -0,0 +1,4 @@
+import { UniversalScreenDialogView, AppScreenDialog } from "jp.common.models";
+export declare class TournamentBuyTicketDialogView extends UniversalScreenDialogView {
+    build(): AppScreenDialog;
+}

package/dist/views/tournament-buy-ticket-dialog.view.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentBuyTicketDialogView = void 0;
+const jp_common_models_1 = require("jp.common.models");
+class TournamentBuyTicketDialogView extends jp_common_models_1.UniversalScreenDialogView {
+    build() {
+        return jp_common_models_1.AppScreenDialog.CreateStandardDialog(jp_common_models_1.AppScreenDialogIdEnum.DIALOG_TOURNAMENT_BUY_TICKET, this.localeService.t('common.rooms.screen.buyTicket.title', { lang: this.lang }), this.localeService.t('common.rooms.screen.buyTicket.description', { lang: this.lang }), jp_common_models_1.AppScreenSectionButtons.CreateFullButtonSection(jp_common_models_1.AppScreenSectionButton.CreateTextButton('Ok'), jp_common_models_1.AppScreenSectionButton.CreateTextButton('Cancel')));
+    }
+}
+exports.TournamentBuyTicketDialogView = TournamentBuyTicketDialogView;
+//# sourceMappingURL=tournament-buy-ticket-dialog.view.js.map

package/dist/views/tournament-buy-ticket-dialog.view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament-buy-ticket-dialog.view.js","sourceRoot":"","sources":["../../src/views/tournament-buy-ticket-dialog.view.ts"],"names":[],"mappings":";;;AAAA,uDAM2B;AAE3B,MAAa,6BAA8B,SAAQ,4CAAyB;IACxE,KAAK;QACD,OAAO,kCAAe,CAAC,oBAAoB,CACvC,wCAAqB,CAAC,4BAA4B,EAClD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,qCAAqC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,EAChF,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,2CAA2C,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,EACtF,0CAAuB,CAAC,uBAAuB,CAC3C,yCAAsB,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAC7C,yCAAsB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CACpD,CACJ,CAAC;IACN,CAAC;CACJ;AAZD,sEAYC"}

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "dayjs": "1.11.18",
     "@nestjs/common": "11.1.0",
     "@nestjs/config": "4.0.2",
     "@nestjs/core": "11.1.0",
     "@nestjs/mongoose": "11.0.4",
     "@nestjs/websockets": "11.1.9",
-    "jp.common.models": "1.0.10",
+    "dayjs": "1.11.18",
+    "jp.common.models": "1.1.1",
     "jp.common.utils": "1.0.2",
-    "jp.db.schemas": "2.0.9",
-    "jp.ms.common.engine": "3.0.4",
+    "jp.db.schemas": "2.1.10",
+    "jp.ms.common.engine": "3.0.8",
     "mongoose": "9.1.5",
-    "node-schedule": "2.1.1",
     "nestjs-i18n": "10.5.1",
+    "node-schedule": "2.1.1",
     "prom-client": "^15.1.0",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
@@ -43,4 +43,4 @@
     "src",
     "dist"
   ]
-}
+}

package/src/dto/app-screen/app-screen-dialog.dto.ts

@@ -0,0 +1,64 @@
+import { Expose, Type } from 'class-transformer';
+import { IAppScreenDialog } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+
+import { AppScreenSectionButtonsDto } from './app-screen-section-buttons.dto';
+import { AppScreenFieldDto } from './app-screen-field.dto';
+
+export class AppScreenDialogDto implements IAppScreenDialog {
+  @ApiProperty({
+    description: 'id',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  id: string;
+
+  @ApiProperty({
+    description: 'type',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  type: string;
+
+  @ApiProperty({
+    description: 'isOpen',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsString()
+  isOpen: boolean;
+
+  @ApiProperty({
+    description: 'title',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  title: string;
+
+  @ApiProperty({
+    description: 'description',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  description?: string;
+
+  @Type(() => AppScreenSectionButtonsDto)
+  @Expose()
+  buttons: AppScreenSectionButtonsDto;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => AppScreenFieldDto)
+  @Expose()
+  fields?: Array<AppScreenFieldDto>;
+}

package/src/dto/app-screen/app-screen-field-list-item.dto.ts

@@ -0,0 +1,42 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose, Type } from 'class-transformer';
+import { IsBoolean, IsString } from 'class-validator';
+import { IAppScreenFieldListItem } from 'jp.common.models';
+
+export class AppScreenFieldListItemDto implements IAppScreenFieldListItem {
+    @ApiProperty({
+        description: 'id',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    id: string;
+
+    @ApiProperty({
+        description: 'title',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    title: string;
+
+    @ApiProperty({
+        description: 'imageUrl',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    imageUrl: string;
+
+    @ApiProperty({
+        description: 'disabled',
+        required: true,
+        type: Boolean,
+    })
+    @Expose()
+    @IsBoolean()
+    disabled: boolean;
+}

package/src/dto/app-screen/app-screen-field.dto.ts

@@ -0,0 +1,59 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose, Type } from 'class-transformer';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+import { IAppScreenField } from 'jp.common.models';
+
+import { AppScreenFieldListItemDto } from './app-screen-field-list-item.dto';
+
+export class AppScreenFieldDto implements IAppScreenField {
+    @ApiProperty({
+        description: 'id',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    id: string;
+
+    @ApiProperty({
+        description: 'type',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    type: string;
+
+    @ApiProperty({
+        description: 'label',
+        required: false,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    label?: string;
+
+    @ApiProperty({
+        description: 'placeholder',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    placeholder?: string;
+
+    @ApiProperty({
+        description: 'value',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    value: string;
+
+    @IsArray()
+    @ValidateNested({ each: true })
+    @Type(() => AppScreenFieldListItemDto)
+    @Expose()
+    list?: Array<AppScreenFieldListItemDto>;
+}

package/src/dto/app-screen/app-screen.dto.ts

@@ -1,10 +1,11 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { Expose, Type } from 'class-transformer';
+import { Expose, plainToInstance, Type } from 'class-transformer';
 import { IsArray, IsString, ValidateNested } from 'class-validator';
 import { IAppScreen } from 'jp.common.models';
 
 import { AppScreenSectionDto } from './app-screen-section.dto';
 import { AppScreenAppBarDto } from './app-screen-app-bar.dto';
+import { AppScreenDialogDto } from './app-screen-dialog.dto';
 
 export class AppScreenDto implements IAppScreen {
   @ApiProperty({
@@ -31,7 +32,17 @@ export class AppScreenDto implements IAppScreen {
   @Expose()
   sections: Array<AppScreenSectionDto>;
 
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => AppScreenDialogDto)
+  @Expose()
+  dialogs?: Array<AppScreenDialogDto>;
+
   @Type(() => AppScreenAppBarDto)
   @Expose()
   appBar?: AppScreenAppBarDto;
+
+  constructor(screen: IAppScreen) {
+    return plainToInstance(AppScreenDto, screen, { excludeExtraneousValues: true });
+  }
 }

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

@@ -10,7 +10,7 @@ export class PlayerCheckStateDto {
     })
     @Expose()
     @IsString()
-    playerId?: string;
+    playerId: string;
 
     @ApiProperty({
         description: 'redirect link',
@@ -21,7 +21,7 @@ export class PlayerCheckStateDto {
     @IsString()
     redirectUrl: string;
 
-    static fromEntities(redirectUrl: string, playerId?: string): PlayerCheckStateDto {
+    static fromEntities(redirectUrl: string, playerId: string): PlayerCheckStateDto {
         const dto = new PlayerCheckStateDto();
         dto.redirectUrl = redirectUrl;
         dto.playerId = playerId

package/src/modules/base-achievements/base-achievements.module.ts

@@ -0,0 +1,163 @@
+import { Global, InternalServerErrorException, Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import {
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
+  User,
+  UserSchema,
+  UsersRepository,
+  AchievementRepository,
+  Achievement,
+  AchievementSchema
+} from 'jp.db.schemas';
+import {
+  BaseAppEvent,
+  BaseUserAppEvent,
+  EarnOneMillionAchievement,
+  GotLevel10Achievement,
+  GotLevel3Achievement,
+  Playd10GamesAchievement,
+  SnackbarSendToPlayerWsEvent,
+  Take1PlaceOnManyTablesTournamentAchievement,
+  Take2Or3PlaceOnManyTablesTournamentAchievement,
+  UserGotNewLevelAppEvent,
+  UserPlayedTheGameAppEvent,
+  UserWonManyTablesTournamentAppEvent,
+  UserWonOneTableTournamentAppEvent,
+  UserWonTheGameAppEvent,
+  Won3GamesAchievement, Won3ProfiAchievement,
+  WonOneTableTournament3TimesAchievement
+} from 'jp.ms.common.engine';
+import { AppScreenIconEnum } from 'jp.common.models';
+
+import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
+import { PlayersManagerService } from '../players-manager';
+
+
+@Global()
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([{ name: ActivityLog.name, schema: ActivityLogSchema }]),
+    MongooseModule.forFeature([{ name: Achievement.name, schema: AchievementSchema }]),
+  ],
+  providers: [
+    UsersRepository,
+    ActivityLogRepository,
+    AchievementRepository,
+    EventsBusAppSubscribeService,
+  ],
+})
+export abstract class BaseAchievementsModule {
+  constructor(
+    protected readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
+    protected readonly playersManager: PlayersManagerService,
+    protected readonly usersRepository: UsersRepository,
+    protected readonly activityLogRepository: ActivityLogRepository,
+    protected readonly achievementRepository: AchievementRepository,
+  ) {
+  }
+
+  async onModuleInit() {
+    this.eventsBusAppSubscribeService.subscribe(this.onHandleAppEvent);
+  }
+
+  protected async onHandleAppEvent(event: BaseAppEvent) {
+    if (event instanceof BaseUserAppEvent) {
+      const userId = event.userId;
+      const player = this.playersManager.getPlayerById(userId);
+      const foundUser = await this.usersRepository.findById(userId);
+      const allAchievements: Array<Achievement> = await this.achievementRepository.findAchievements();
+
+      if (!player || !foundUser) {
+        throw new InternalServerErrorException();
+      }
+
+      if (event instanceof UserGotNewLevelAppEvent) {
+        // TODO подумать куда перенести LEVEL UP 
+        player.sendMessage(new SnackbarSendToPlayerWsEvent(
+          AppScreenIconEnum.ARROW_UPWARD,
+          'level up',
+          'buttonText'
+        ));
+
+        if (foundUser.hasNoAchievement(GotLevel3Achievement.code)) {
+          if (new GotLevel3Achievement(event.newLevel).userGotAchievement()) {
+            this.giveAchievement(allAchievements, GotLevel3Achievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(GotLevel10Achievement.code)) {
+          if (new GotLevel10Achievement(event.newLevel).userGotAchievement()) {
+            this.giveAchievement(allAchievements, GotLevel10Achievement.code, userId);
+          }
+        }
+
+      } else if (event instanceof UserPlayedTheGameAppEvent) {
+        if (foundUser.hasNoAchievement(Playd10GamesAchievement.code)) {
+          const playdGamesCount = await this.activityLogRepository.getUserPlayedGamesCount(userId);
+
+          if (new Playd10GamesAchievement(playdGamesCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Playd10GamesAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonTheGameAppEvent) {
+        if (foundUser.hasNoAchievement(Won3GamesAchievement.code)) {
+          const wonGamesCount = await this.activityLogRepository.getUserWonGamesCount(userId);
+
+          if (new Won3GamesAchievement(wonGamesCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Won3GamesAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(Won3ProfiAchievement.code)) {
+          const wonProfiCount = await this.activityLogRepository.getUserWonProfiCount(userId);
+          if (new Won3ProfiAchievement(wonProfiCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, Won3ProfiAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(EarnOneMillionAchievement.code)) {
+          if (new EarnOneMillionAchievement(foundUser.balance).userGotAchievement()) {
+            this.giveAchievement(allAchievements, EarnOneMillionAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonOneTableTournamentAppEvent) {
+        if (foundUser.hasNoAchievement(WonOneTableTournament3TimesAchievement.code)) {
+          const wonFastTournamentCount = await this.activityLogRepository.getUserWonOneTableTournamentCount(userId);
+          if (new WonOneTableTournament3TimesAchievement(wonFastTournamentCount).userGotAchievement()) {
+            this.giveAchievement(allAchievements, WonOneTableTournament3TimesAchievement.code, userId);
+          }
+        }
+      } else if (event instanceof UserWonManyTablesTournamentAppEvent) {
+        if (foundUser.hasNoAchievement(Take1PlaceOnManyTablesTournamentAchievement.code)) {
+          if (new Take1PlaceOnManyTablesTournamentAchievement(event.rank)) {
+            this.giveAchievement(allAchievements, Take1PlaceOnManyTablesTournamentAchievement.code, userId);
+          }
+        }
+
+        if (foundUser.hasNoAchievement(Take2Or3PlaceOnManyTablesTournamentAchievement.code)) {
+          if (new Take2Or3PlaceOnManyTablesTournamentAchievement(event.rank)) {
+            this.giveAchievement(allAchievements, Take2Or3PlaceOnManyTablesTournamentAchievement.code, userId);
+          }
+        }
+      }
+    }
+  }
+
+  protected async giveAchievement(allAchievements: Array<Achievement>, achievementCode: string, userId: string) {
+    const foundAchievement = allAchievements.find((item) => item.code === achievementCode);
+    const player = this.playersManager.getPlayerById(userId);
+
+    if (foundAchievement && player) {
+      await this.usersRepository.addAchievement(userId, achievementCode);
+
+      player.sendMessage(new SnackbarSendToPlayerWsEvent(
+        AppScreenIconEnum.EMOJI_EVENTS,
+        foundAchievement.title,
+        foundAchievement.description
+      ));
+    }
+  }
+}

package/src/modules/base-achievements/index.ts

@@ -0,0 +1 @@
+export { BaseAchievementsModule } from './base-achievements.module';

package/src/modules/event-bus/events-bus.app.subscribe.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { BaseAppEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+
+@Injectable()
+export class EventsBusAppSubscribeService {
+    private readonly appEventSubject: Subject<BaseAppEvent>;
+
+    constructor() {
+        this.appEventSubject = new Subject<BaseAppEvent>();
+    }
+
+    pushNewEvent(event: BaseAppEvent) {
+        this.appEventSubject.next(event);
+    }
+
+    subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
+        this.appEventSubject.subscribe(onHandleAppEvent);
+    }
+}

package/src/modules/event-bus/events-bus.main-tables.subscribe.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from "@nestjs/common";
+import { GamePlayer, RoomUpdateStateEvent } from "jp.ms.common.engine";
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class EventsBusMainTablesSubscribeService {
+    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+    private readonly tablesSubscribers: Map<string, GamePlayer>;
+
+    constructor() {
+        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+        this.tablesSubscribers = new Map();
+    }
+
+    getTablesSubscribers() {
+        return Array.from(this.tablesSubscribers.values());
+    }
+
+    addTablesSubscriber(player: GamePlayer) {
+        this.tablesSubscribers.set(player.id, player);
+    }
+
+    removeTablesSubbcriber(player: GamePlayer) {
+        this.tablesSubscribers.delete(player.id);
+    }
+
+    pushNewRoomState(event: RoomUpdateStateEvent) {
+        this.roomStatesSubject.next(event);
+    }
+
+    subscribe(onHandleStatusRoomChange: () => void) {
+        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+    }
+}

package/src/modules/event-bus/events-bus.many-tables-tournament.subscribe.service.ts

@@ -0,0 +1,6 @@
+import { Injectable } from "@nestjs/common";
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.module.ts

@@ -0,0 +1,23 @@
+import { Global, Module } from '@nestjs/common';
+
+import { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+import { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+import { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+
+@Global()
+@Module({
+  providers: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+  ],
+  exports: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+  ]
+})
+export class EventsBusModule { }

package/src/modules/event-bus/events-bus.one-table-tournament.subscribe.service.ts

@@ -0,0 +1,6 @@
+import { Injectable } from "@nestjs/common";
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.tournament.subscribe.service.ts

@@ -0,0 +1,19 @@
+import { RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+
+export abstract class EventsBusTournamentSubscribeService {
+    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+
+    constructor() {
+        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+    }
+
+    pushNewRoomState(event: RoomUpdateStateEvent) {
+        this.roomStatesSubject.next(event);
+    }
+
+    subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+    }
+}

package/src/modules/event-bus/index.ts

@@ -0,0 +1,5 @@
+export { EventsBusModule } from './events-bus.module';
+export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+export { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+export { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';

package/src/modules/index.ts

@@ -17,4 +17,5 @@ export {
     TournamentOneTableRoomsManagerService,
     TournamentOneTableRoomsManagerModule,
 } from './tournament-one-table-rooms-manager';
-
+export { EventsBusModule, EventsBusMainTablesSubscribeService } from './event-bus'
+export { BaseAchievementsModule } from './base-achievements/base-achievements.module'