jp.ms.common.modules 1.0.20 → 1.0.21

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

@@ -1,21 +1,26 @@
 import { Inject, Injectable } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
 import {
     BaseGameEvent,
     GameMaster,
     MinPlayersStartStrategy,
     SimpleRoom,
     GameRoomConfig,
+    RoomUpdateStateEvent,
+    UserWonTheGameAppEvent,
 } from 'jp.ms.common.engine';
 import {
-    GameResultRepository, SimpleRoomDocument,
+    GameResultRepository,
+    SimpleRoomDocument,
     SimpleRoomsRepository,
     UsersRepository
 } from 'jp.db.schemas';
-import { InjectConnection } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
 import { saveGameTablesResult } from '../../utils/game-table-result';
+import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
+import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
 
 import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 import { SimpleRoomsFactoryOptions } from './simple-rooms-manager.interfaces';
@@ -24,10 +29,12 @@ import { SimpleRoomsFactoryOptions } from './simple-rooms-manager.interfaces';
 export class SimpleRoomsManagerService {
     private readonly rooms: Map<string, SimpleRoom>;
 
-    constructor (
+    constructor(
         private readonly roomsRepository: SimpleRoomsRepository,
         private readonly usersRepository: UsersRepository,
         private readonly gameResultRepository: GameResultRepository,
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
         @Inject(SIMPLE_ROOMS_MANAGER_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
         @InjectConnection() private readonly connection: Connection,
         @Inject() private readonly logger: JpLoggerService,
@@ -35,49 +42,47 @@ export class SimpleRoomsManagerService {
         this.rooms = new Map<string, SimpleRoom>();
     }
 
-    get gameType () {
+    get gameType() {
         return this.options.configService.get<string>('GAME_TYPE') || '';
     }
 
-    getRoomById (roomId: string): SimpleRoom | undefined {
+    getRoomById(roomId: string): SimpleRoom | undefined {
         return this.rooms.get(roomId);
     }
 
-    getRoomByTableId (tableId: string): SimpleRoom | undefined {
-        const {roomId} = GameMaster.parseTableId(tableId);
+    getRoomByTableId(tableId: string): SimpleRoom | undefined {
+        const { roomId } = GameMaster.parseTableId(tableId);
 
         return this.getRoomById(roomId);
     }
 
-    getRooms (): Array<SimpleRoom> {
+    getRooms(): Array<SimpleRoom> {
         return Array.from(this.rooms.values());
     }
 
-    getTables (): Array<GameMaster> {
+    getTables(): Array<GameMaster> {
         return this.getRooms().reduce(
             (result, currentValue) => {
                 return [...result, ...currentValue.getMasters()];
-            }, []);
+            }, [] as Array<GameMaster>);
     }
 
-    addRoom (room: SimpleRoom) {
+    addRoom(room: SimpleRoom) {
         this.rooms.set(room.getId(), room);
     }
 
-    async hydrateRoomsFromDB () {
+    async hydrateRoomsFromDB() {
         const templates = await this.roomsRepository.findRooms(this.gameType);
 
         templates.forEach((item) => {
             const newRoom = this.options.createRoom(
                 this.simpleRoomDocumentToTournamentRoom(item)
             );
-
-            newRoom.addMaster();
             this.addRoom(newRoom);
         });
     }
 
-    private simpleRoomDocumentToTournamentRoom (room: SimpleRoomDocument): GameRoomConfig {
+    private simpleRoomDocumentToTournamentRoom(room: SimpleRoomDocument): GameRoomConfig {
         const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
         const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
 
@@ -99,11 +104,12 @@ export class SimpleRoomsManagerService {
             startStrategy: new MinPlayersStartStrategy(),
             onRoomEvent: this.handleRoomEvent,
             onRoomTableGameFinished: this.handleRoomTableGameFinished,
+            onRoomStatusUpdated: this.handleRoomStatusUpdated,
         } as GameRoomConfig;
     }
 
     private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
+        this.logger.log(event.toLog());        
     };
 
     private handleRoomTableGameFinished = async (master: GameMaster) => {
@@ -114,5 +120,12 @@ export class SimpleRoomsManagerService {
             this.usersRepository,
             true,
         );
+
+        // TODO: записать разные события для достижений
+        this.eventsBusAppSubscribeService.pushNewEvent(new UserWonTheGameAppEvent('123'));
+    };
+
+    private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
+        this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
     };
 }

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

@@ -2,9 +2,12 @@ import { Inject, Injectable } from '@nestjs/common';
 import {
     BaseGameEvent,
     GameMaster,
+    GamePlayer,
     ManyTablesTournamentRoom,
     ManyTablesTournamentRoomConfig,
-    NoStartStrategy, TournamentMaster
+    NoStartStrategy,
+    RoomUpdateStateEvent,
+    TournamentMaster
 } from 'jp.ms.common.engine';
 import {
     GameResultRepository,
@@ -23,6 +26,7 @@ import { JpLoggerService } from '../logger';
 import { getHours, getMinutes } from '../../utils/date';
 import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
 import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+import { EventsBusMainTablesSubscribeService, EventsBusManyTablesTournamentSubscribeService } from '../event-bus';
 
 import { TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS } from './tournament-many-tables-rooms-manager.constants';
 import { TournamentManyTablesRoomsFactoryOptions } from './tournament-many-tables-rooms-manager.interfaces';
@@ -33,10 +37,12 @@ export class TournamentManyTablesRoomsManagerService {
     private readonly rooms: Map<string, ManyTablesTournamentRoom>;
     private createDailyTournamentJob: Job;
 
-    constructor (
+    constructor(
         private readonly tournamentRepository: TournamentManyTablesRoomsRepository,
         private readonly usersRepository: UsersRepository,
         private readonly gameResultRepository: GameResultRepository,
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
         @Inject(TOURNAMENT_MANY_TABLES_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentManyTablesRoomsFactoryOptions,
         @InjectConnection() private readonly connection: Connection,
         @Inject() private readonly logger: JpLoggerService,
@@ -44,36 +50,38 @@ export class TournamentManyTablesRoomsManagerService {
         this.rooms = new Map<string, ManyTablesTournamentRoom>();
     }
 
-    get gameType () {
+    get gameType() {
         return this.options.configService.get<string>('GAME_TYPE') || '';
     }
 
-    getRoomById (roomId: string): ManyTablesTournamentRoom | undefined {
+    getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
         return this.rooms.get(roomId);
     }
 
-    getRoomByTableId (tableId: string): ManyTablesTournamentRoom | undefined {
-        const {roomId} = GameMaster.parseTableId(tableId);
+    getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
+        const { roomId } = GameMaster.parseTableId(tableId);
 
         return this.getRoomById(roomId);
     }
 
-    getRooms (): Array<ManyTablesTournamentRoom> {
+    getRooms(): Array<ManyTablesTournamentRoom> {
         return Array.from(this.rooms.values());
     }
 
-    getTables (): Array<GameMaster> {
+    getTables(): Array<GameMaster> {
         return this.getRooms().reduce(
             (result, currentValue) => {
                 return [...result, ...currentValue.getMasters()];
-            }, []);
+            },
+            [] as Array<GameMaster>
+        );
     }
 
-    addRoom (room: ManyTablesTournamentRoom) {
+    addRoom(room: ManyTablesTournamentRoom) {
         this.rooms.set(room.getId(), room);
     }
 
-    async hydrateTournamentsFromDB () {
+    async hydrateTournamentsFromDB() {
         const templates = await this.tournamentRepository.findTournaments(this.gameType);
         templates.forEach((item) => {
             this.addRoom(this.options.createTournamentRoom(
@@ -82,7 +90,7 @@ export class TournamentManyTablesRoomsManagerService {
         });
     }
 
-    async runDailyTournamentJob () {
+    async runDailyTournamentJob() {
         const dailyTournamentScheduleTaskTime = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_TASK_TIME');
         const dailyTournamentTime = this.options.configService.get<string>('DAILY_TOURNAMENT_TIME');
 
@@ -96,7 +104,7 @@ export class TournamentManyTablesRoomsManagerService {
         }
     }
 
-    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
+    async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
         const newTournament = await this.tournamentRepository.createTournament(createTournamentDto);
 
         this.addRoom(this.options.createTournamentRoom(
@@ -104,7 +112,7 @@ export class TournamentManyTablesRoomsManagerService {
         ));
     }
 
-    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
+    async updateTournament(tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
         const updatedTournament = await this.tournamentRepository.updateTournament(tournamentId, updateTournamentDto);
 
         this.getRoomById(tournamentId)?.getTournamentMaster().cancelTournament();
@@ -114,11 +122,20 @@ export class TournamentManyTablesRoomsManagerService {
         ));
     }
 
-    async removeTournament (tournamentId: string) {
+    async removeTournament(tournamentId: string) {
         await this.tournamentRepository.removeTournament(tournamentId);
     }
 
-    private manyTablesTournamentDocumentToTournamentRoom (tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
+    async buyTicket(tournamentId: string, player: GamePlayer) {
+        // TODO списать деньги у игрока
+        await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
+            playerId: player.id,
+            playerAvatarUrl: player.avatarUrl,
+            playerName: player.avatarUrl,
+        });
+    }
+
+    private manyTablesTournamentDocumentToTournamentRoom(tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
         const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
         const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
         const minPlayersForMergeTables = this.options.configService.get<number>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES') || 0;
@@ -146,6 +163,7 @@ export class TournamentManyTablesRoomsManagerService {
             onTournamentRoomStarted: this.handleTournamentRoomStarted,
             onTournamentRoomFinished: this.handleTournamentRoomFinished,
             onTournamentRoomCancelled: this.handleTournamentRoomCancelled,
+            onRoomStatusUpdated: this.handleRoomStatusUpdated,
             tournamentPrizeTable: this.options.tournamentPrizeTable,
             tournamentInitialStatus: tournamentDocument.status,
         } as ManyTablesTournamentRoomConfig;
@@ -182,6 +200,11 @@ export class TournamentManyTablesRoomsManagerService {
         );
     }
 
+    private handleRoomStatusUpdated = async (event: RoomUpdateStateEvent) => {
+        this.eventsBusMainTablesSubscribeService.pushNewRoomState(event)
+        this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+    }
+
     private createDailyTournament = async (dailyTournamentTime: string) => {
         const hour = getHours(dailyTournamentTime);
         const minutes = getMinutes(dailyTournamentTime);

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

@@ -3,8 +3,10 @@ import {
   BaseGameEvent,
   GameMaster,
   NoStartStrategy,
-  OneTableTournamentRoom, TournamentMaster,
-  TournamentRoomConfig
+  OneTableTournamentRoom,
+  RoomUpdateStateEvent,
+  TournamentMaster,
+  TournamentRoomConfig,
 } from 'jp.ms.common.engine';
 import {
   GameResultRepository,
@@ -17,6 +19,7 @@ import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
 import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
+import { EventsBusMainTablesSubscribeService, EventsBusOneTableTournamentSubscribeService } from '../event-bus';
 
 import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
 import { TournamentOneTableRoomsFactoryOptions } from './tournament-one-table-rooms-manager.interfaces';
@@ -25,63 +28,67 @@ import { TournamentOneTableRoomsFactoryOptions } from './tournament-one-table-ro
 export class TournamentOneTableRoomsManagerService {
   private readonly rooms: Map<string, OneTableTournamentRoom>;
 
-  constructor (
-      private readonly tournamentRepository: TournamentOneTableRoomsRepository,
-      private readonly usersRepository: UsersRepository,
-      private readonly gameResultRepository: GameResultRepository,
-      @Inject(TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentOneTableRoomsFactoryOptions,
-      @InjectConnection() private readonly connection: Connection,
-      @Inject() private readonly logger: JpLoggerService,
+  constructor(
+    private readonly tournamentRepository: TournamentOneTableRoomsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly gameResultRepository: GameResultRepository,
+    private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+    private readonly eventsBusOneTableTournamentSubscribeService: EventsBusOneTableTournamentSubscribeService,
+    @Inject(TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS) private readonly options: TournamentOneTableRoomsFactoryOptions,
+    @InjectConnection() private readonly connection: Connection,
+    @Inject() private readonly logger: JpLoggerService,
   ) {
     this.rooms = new Map<string, OneTableTournamentRoom>();
   }
 
-  get gameType () {
+  get gameType() {
     return this.options.configService.get<string>('GAME_TYPE') || '';
   }
 
-  getRoomById (roomId: string): OneTableTournamentRoom | undefined {
+  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
     return this.rooms.get(roomId);
   }
 
-  getRoomByTableId (tableId: string): OneTableTournamentRoom | undefined {
+  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
     return this.getRoomById(roomId);
   }
 
-  getRooms (): Array<OneTableTournamentRoom> {
+  getRooms(): Array<OneTableTournamentRoom> {
     return Array.from(this.rooms.values());
   }
 
-  getTables (): Array<GameMaster> {
+  getTables(): Array<GameMaster> {
     return this.getRooms().reduce(
-        (result, currentValue) => {
-          return [...result, ...currentValue.getMasters()];
-        }, []);
+      (result, currentValue) => {
+        return [...result, ...currentValue.getMasters()];
+      },
+      [] as Array<GameMaster>
+    );
   }
 
-  addRoom (room: OneTableTournamentRoom) {
+  addRoom(room: OneTableTournamentRoom) {
     this.rooms.set(room.getId(), room);
   }
 
-  async createMasterTournament () {
+  async createMasterTournament() {
     const waitingTournament = await this.tournamentRepository.findWaitingTournament(this.gameType);
     if (!waitingTournament) {
       await this.tournamentRepository.createTournamentFromMasterTemplate(this.gameType);
     }
   }
 
-  async hydrateTournamentsFromDB () {
+  async hydrateTournamentsFromDB() {
     const templates = await this.tournamentRepository.findTournaments(this.gameType);
     templates.forEach((item) => {
       this.addRoom(this.options.createTournamentRoom(
-          this.oneTableTournamentDocumentToTournamentRoom(item)
+        this.oneTableTournamentDocumentToTournamentRoom(item)
       ));
     });
   }
 
-  private oneTableTournamentDocumentToTournamentRoom (tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
+  private oneTableTournamentDocumentToTournamentRoom(tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
     const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
     const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
 
@@ -106,6 +113,7 @@ export class TournamentOneTableRoomsManagerService {
       onTournamentRoomStarted: this.handleTournamentRoomStarted,
       onTournamentRoomFinished: this.handleTournamentRoomFinished,
       onTournamentRoomCancelled: this.handleTournamentRoomCancelled,
+      onRoomStatusUpdated: this.handleRoomStatusUpdated,
       tournamentPrizeTable: this.options.tournamentPrizeTable,
       tournamentInitialStatus: tournamentDocument.status,
     } as TournamentRoomConfig;
@@ -117,11 +125,11 @@ export class TournamentOneTableRoomsManagerService {
 
   private handleRoomTableGameFinished = async (master: GameMaster) => {
     await saveGameTablesResult(
-        master,
-        this.connection,
-        this.gameResultRepository,
-        this.usersRepository,
-        false,
+      master,
+      this.connection,
+      this.gameResultRepository,
+      this.usersRepository,
+      false,
     );
   };
 
@@ -131,14 +139,14 @@ export class TournamentOneTableRoomsManagerService {
 
     try {
       await this.tournamentRepository.startTournament(
-          master.getTournamentId(),
-          master.getRoom().getParticipants(),
+        master.getTournamentId(),
+        master.getRoom().getParticipants(),
       );
       const newTournament = await this.tournamentRepository.createTournamentFromMasterTemplate(
-          master.getRoom().getGameType()
+        master.getRoom().getGameType()
       );
       this.addRoom(this.options.createTournamentRoom(
-          this.oneTableTournamentDocumentToTournamentRoom(newTournament)
+        this.oneTableTournamentDocumentToTournamentRoom(newTournament)
       ));
 
       await session.commitTransaction();
@@ -156,10 +164,15 @@ export class TournamentOneTableRoomsManagerService {
 
   private handleTournamentRoomFinished = async (master: TournamentMaster) => {
     await saveTournamentResult(
-        master,
-        this.connection,
-        this.tournamentRepository,
-        this.usersRepository,
+      master,
+      this.connection,
+      this.tournamentRepository,
+      this.usersRepository,
     );
   }
+
+  private handleRoomStatusUpdated = async (event: RoomUpdateStateEvent) => {
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
+    this.eventsBusOneTableTournamentSubscribeService.pushNewRoomState(event);
+  }
 }

package/src/views/index.ts

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

package/src/views/tournament-buy-ticket-dialog.view.ts

@@ -0,0 +1,21 @@
+import {
+    AppScreenSectionButton,
+    AppScreenSectionButtons,
+    UniversalScreenDialogView,
+    AppScreenDialog,
+    AppScreenDialogIdEnum,
+ } from "jp.common.models";
+
+export class TournamentBuyTicketDialogView extends UniversalScreenDialogView {
+    build() {
+        return AppScreenDialog.CreateStandardDialog(
+            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 }),
+            AppScreenSectionButtons.CreateFullButtonSection(
+                AppScreenSectionButton.CreateTextButton('Ok'),
+                AppScreenSectionButton.CreateTextButton('Cancel'),
+            )
+        );
+    }
+}