jp.ms.common.modules 1.0.42 → 1.0.44

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

@@ -40,12 +40,14 @@ export class EventsGateway
       if (user) {
         const player = this.options.createPlayer({
           id: user.userId,
-          fullName: user.fullName,
-          avatarUrl: user.avatarUrl,
+          fullName: user.publicFullName,
+          avatarUrl: user.publicAvatarUrl,
+          avatarFrame: user.avatarFrame,
           balance: user.balance,
           experience: user.experience,
           level: user.level,
           language: user.normalizedLang,
+          cardsSkin: user.cardSkin,
           onSendWsMessage: this.handleSendWsMessage,
           onGotWsMessageClientResponse: this.handleGotWsMessageClientResponse,
         });

package/src/modules/index.ts

@@ -24,5 +24,10 @@ export {
   EventsBusModule,
   EventsBusMainTablesSubscribeService,
 } from './event-bus';
-export { BaseAchievementsModule } from './base-achievements/base-achievements.module';
+export {
+  BaseAchievementsModule,
+  BaseAchievementsFactoryOptions,
+  BASE_ACHIEVEMENTS_OPTIONS,
+  BaseAchievementsOptions,
+} from './base-achievements/';
 export { ConfirmationMessageManagerModule } from './confirmation-message-manager/confirmation-message-manager.module';

package/src/modules/main/main.controller.ts

@@ -1,12 +1,4 @@
-import {
-  Controller,
-  Get,
-  Headers,
-  HttpCode,
-  HttpStatus,
-  Param,
-  Post,
-} from '@nestjs/common';
+import { Controller, Get, Headers } from '@nestjs/common';
 import { IAppHeaders } from 'jp.common.models';
 
 import {
@@ -56,17 +48,4 @@ export class MainController {
       headers.client_language,
     );
   }
-
-  @Post('many_tables_tournament/buy_ticket/:tournamentId')
-  @HttpCode(HttpStatus.OK)
-  buyTicket(
-    @Param('tournamentId') tournamentId: string,
-    @Headers() headers: IAppHeaders,
-  ): Promise<BaseAppScreenDto> {
-    return this.mainService.manyTablesTournamentbBuyTicket(
-      headers.client_auth_token,
-      headers.client_language,
-      tournamentId,
-    );
-  }
 }

package/src/modules/main/main.service.ts

@@ -29,7 +29,6 @@ import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tourname
 import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
 import {
   ErrorCodeEnum,
-  NotEnoughMoneyForPurchaseException,
   NotFoundFreeRoomForFastGameException,
 } from '../../exception';
 
@@ -107,18 +106,20 @@ export class MainService {
     if (
       player &&
       (player.isPlayer() || player.isTableQueuer()) &&
-      player.tableId
+      player.tableId &&
+      player.room
     ) {
-      if (player.room instanceof SimpleRoom) {
-        redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
-      } else if (player.room instanceof OneTableTournamentRoom) {
+      const roomName = player.room.constructor.name;
+      if (roomName.includes(OneTableTournamentRoom.name)) {
         redirectUrl = AppScreenRouter.getOneTableTournamentTablePath(
           player.tableId,
         );
-      } else if (player.room instanceof ManyTablesTournamentRoom) {
+      } else if (roomName.includes(ManyTablesTournamentRoom.name)) {
         redirectUrl = AppScreenRouter.getManyTablesTournamentTablePath(
           player.tableId,
         );
+      } else if (roomName.includes(SimpleRoom.name)) {
+        redirectUrl = AppScreenRouter.getSimpleRoomTablePath(player.tableId);
       }
     } else if (isNewbie) {
       redirectUrl = AppScreenRoutesEnum.WELCOME;
@@ -152,32 +153,4 @@ export class MainService {
       player.id,
     );
   }
-
-  async manyTablesTournamentbBuyTicket(
-    clientAuthToken: string,
-    lang: string,
-    tournamentId: string,
-  ): Promise<BaseAppScreenDto> {
-    const player = this.playersManager.getPlayerById(clientAuthToken);
-    const tournament =
-      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
-    const user = await this.usersRepository.findById(player?.id ?? '');
-
-    if (!player || !tournament || !user) {
-      throw new InternalServerErrorException();
-    }
-
-    if (user.balance < tournament.getTicketPrice()) {
-      throw new NotEnoughMoneyForPurchaseException(
-        new ErrorSnackbarComponent(
-          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
-          this.options.i18n.t('common.server.message.code.4004', { lang }),
-        ),
-      );
-    }
-
-    await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
-
-    return this.getScreen(lang, clientAuthToken);
-  }
 }

package/src/modules/many-tables-tournament/many-tables-tournament.controller.ts

@@ -148,4 +148,17 @@ export class ManyTablesTournamentController {
   removeTournament(@Param('tournamentId') tournamentId: string): Promise<void> {
     return this.tournamentService.removeTournament(tournamentId);
   }
+
+  @Post('buy_ticket/:tournamentId')
+  @HttpCode(HttpStatus.OK)
+  buyTicket(
+    @Param('tournamentId') tournamentId: string,
+    @Headers() headers: IAppHeaders,
+  ): Promise<void> {
+    return this.tournamentService.manyTablesTournamentbBuyTicket(
+      headers.client_auth_token,
+      headers.client_language,
+      tournamentId,
+    );
+  }
 }

package/src/modules/many-tables-tournament/many-tables-tournament.module.ts

@@ -4,6 +4,9 @@ import {
   ManyTablesTournamentRoom,
   ManyTablesTournamentRoomSchema,
   ManyTablesTournamentRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
 } from 'jp.db.schemas';
 import {
   GamePlayer,
@@ -27,9 +30,14 @@ import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.inte
         schema: ManyTablesTournamentRoomSchema,
       },
     ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
   ],
   controllers: [ManyTablesTournamentController],
-  providers: [ManyTablesTournamentService, ManyTablesTournamentRoomsRepository],
+  providers: [
+    ManyTablesTournamentService,
+    ManyTablesTournamentRoomsRepository,
+    UsersRepository,
+  ],
 })
 export class ManyTablesTournamentModule {
   constructor(

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

@@ -7,11 +7,13 @@ import {
   IBaseMoveData,
   IAppTableState,
   AppScreenRouter,
+  ErrorSnackbarComponent,
 } from 'jp.common.models';
 import {
   ManyTablesTournamentMaster,
   TournamentMaster,
 } from 'jp.ms.common.engine';
+import { UsersRepository } from 'jp.db.schemas';
 
 import { BaseAppScreenDto } from '../../dto';
 import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
@@ -19,6 +21,10 @@ import { PlayersManagerService } from '../players-manager/players-manager.servic
 import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
 import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
 import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+import {
+  NotEnoughMoneyForPurchaseException,
+  ErrorCodeEnum,
+} from '../../exception';
 
 import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
 import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
@@ -32,6 +38,7 @@ export class ManyTablesTournamentService {
     private readonly playersManager: PlayersManagerService,
     @Inject(MANY_TABLES_TOURNAMENT_OPTIONS)
     private readonly options: ManyTablesTournamentFactoryOptions,
+    private readonly usersRepository: UsersRepository,
   ) {}
 
   getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
@@ -205,4 +212,30 @@ export class ManyTablesTournamentService {
   async removeTournament(tournamentId: string) {
     return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
   }
+
+  async manyTablesTournamentbBuyTicket(
+    clientAuthToken: string,
+    lang: string,
+    tournamentId: string,
+  ): Promise<void> {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const tournament =
+      this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+    const user = await this.usersRepository.findById(player?.id ?? '');
+
+    if (!player || !tournament || !user) {
+      throw new InternalServerErrorException();
+    }
+
+    if (user.balance < tournament.getTicketPrice()) {
+      throw new NotEnoughMoneyForPurchaseException(
+        new ErrorSnackbarComponent(
+          ErrorCodeEnum.NOT_ENOUGH_MONEY_FOR_PURCHASE,
+          this.options.i18n.t('common.server.message.code.4004', { lang }),
+        ),
+      );
+    }
+
+    await this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+  }
 }

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

@@ -34,4 +34,5 @@ export interface ManyTablesTournamentRoomsFactoryOptions {
   dailyTournamentScheduleTaskTime: string;
   dailyTournamentTime: string;
   minPlayersForMergeTables: number;
+  levelUpBonus: number;
 }

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

@@ -19,6 +19,12 @@ import {
   Purchase,
   PurchaseSchema,
   PurchaseRepository,
+  Rating,
+  RatingSchema,
+  RatingRepository,
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
 } from 'jp.db.schemas';
 
 import { ManyTablesTournamentRoomsManagerService } from './many-tables-tournament-rooms-manager.service';
@@ -42,6 +48,10 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
     MongooseModule.forFeature([
       { name: GameResult.name, schema: GameResultSchema },
     ]),
+    MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     ManyTablesTournamentRoomsRepository,
@@ -49,6 +59,8 @@ import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournamen
     ManyTablesTournamentRoomsManagerService,
     GameResultRepository,
     PurchaseRepository,
+    RatingRepository,
+    ActivityLogRepository,
   ],
   exports: [ManyTablesTournamentRoomsManagerService],
 })

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

@@ -11,6 +11,7 @@ import {
   BaseGameEvent,
   GameMaster,
   GamePlayer,
+  GamePlayerMovedOnTheTableEvent,
   GameTableFinishedEvent,
   GameTournamentCancelledEvent,
   GameTournamentFinishedEvent,
@@ -31,26 +32,26 @@ import {
   ManyTablesTournamentRoomDocument,
   ManyTablesTournamentRoomsRepository,
   UsersRepository,
+  RatingRepository,
+  ActivityLogRepository,
 } from 'jp.db.schemas';
+import { getHours, getMinutes } from 'jp.common.utils';
 
-import {
-  saveGameTablesResult,
-  saveTournamentResult,
-} from '../../utils/game-table-result';
 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 {
+  EventsBusAppSubscribeService,
   EventsBusMainTablesSubscribeService,
   EventsBusManyTablesTournamentSubscribeService,
 } from '../event-bus';
+import { TournamentRoomsManagerService } from '../../common/tournament-rooms-manager.service';
 
 import { MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './many-tables-tournament-rooms-manager.constants';
 import { ManyTablesTournamentRoomsFactoryOptions } from './many-tables-tournament-rooms-manager.interfaces';
 
 @Injectable()
-export class ManyTablesTournamentRoomsManagerService {
+export class ManyTablesTournamentRoomsManagerService extends TournamentRoomsManagerService {
   private readonly rooms: Map<string, ManyTablesTournamentRoom>;
   private createDailyTournamentJob: Job | null;
 
@@ -59,13 +60,17 @@ export class ManyTablesTournamentRoomsManagerService {
     private readonly usersRepository: UsersRepository,
     private readonly gameResultRepository: GameResultRepository,
     private readonly purchaseRepository: PurchaseRepository,
+    private readonly ratingRepository: RatingRepository,
+    private readonly activityLogRepository: ActivityLogRepository,
     private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
     private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+    private readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     @Inject(MANY_TABLES_TOURNAMENT_ROOMS_MANAGER_OPTIONS)
     private readonly options: ManyTablesTournamentRoomsFactoryOptions,
     @InjectConnection() private readonly connection: Connection,
     @Inject() private readonly logger: JpLoggerService,
   ) {
+    super();
     this.rooms = new Map<string, ManyTablesTournamentRoom>();
     this.createDailyTournamentJob = null;
   }
@@ -211,6 +216,7 @@ export class ManyTablesTournamentRoomsManagerService {
       rulesType: tournamentDocument.rulesType,
       deckType: tournamentDocument.deckType,
       tableSize: tournamentDocument.tableSize,
+      tableType: tournamentDocument.tableType,
       bet: tournamentDocument.bet,
       ticketPrice: tournamentDocument.ticketPrice,
       title: tournamentDocument.title,
@@ -236,58 +242,102 @@ export class ManyTablesTournamentRoomsManagerService {
   private handleRoomEvent = (event: BaseGameEvent) => {
     this.logger.log(event.toLog());
 
-    if (event instanceof GameTableFinishedEvent) {
-      void this.handleRoomTableGameFinished(event.master);
-    } else if (event instanceof GameTournamentStartedEvent) {
-      void this.handleTournamentRoomStarted(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentCancelledEvent) {
-      void this.handleTournamentRoomCancelled(event.room.getRoomMaster());
-    } else if (event instanceof GameTournamentFinishedEvent) {
-      void this.handleTournamentRoomFinished(event.room.getRoomMaster());
-    } else if (
-      event instanceof GameTournamentPlayerJoinedTheTournamentEvent ||
-      event instanceof GameTournamentPlayerLeavedTheTournamentEvent ||
-      event instanceof GameTournamentCancelledEvent ||
-      event instanceof GameTournamentWaitedEvent ||
-      event instanceof GameTournamentStartedEvent ||
-      event instanceof GameTournamentFinishedEvent
-    ) {
-      void this.handleRoomStatusUpdated(
-        new RoomUpdateStateEvent(event.gameType, event.roomId),
-      );
+    switch (event.constructor.name) {
+      case GameTableFinishedEvent.name: {
+        void this.handleRoomTableGameFinished(
+          event as GameTableFinishedEvent,
+          this.connection,
+          this.gameResultRepository,
+          this.usersRepository,
+          this.activityLogRepository,
+          this.eventsBusAppSubscribeService,
+          this.options.levelUpBonus,
+        );
+        break;
+      }
+      case GamePlayerMovedOnTheTableEvent.name: {
+        this.handleRoomTableGamePlayerMoved(
+          event as GamePlayerMovedOnTheTableEvent,
+          this.eventsBusAppSubscribeService,
+        );
+        break;
+      }
+      case GameTournamentStartedEvent.name: {
+        void this.handleTournamentRoomStarted(
+          event as GameTournamentStartedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentStartedEvent);
+        break;
+      }
+      case GameTournamentCancelledEvent.name: {
+        void this.handleTournamentRoomCancelled(
+          event as GameTournamentCancelledEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentCancelledEvent);
+        break;
+      }
+      case GameTournamentFinishedEvent.name: {
+        void this.handleTournamentRoomFinished(
+          event as GameTournamentFinishedEvent,
+        );
+        this.handleRoomStatusUpdated(event as GameTournamentFinishedEvent);
+        break;
+      }
+      case GameTournamentPlayerJoinedTheTournamentEvent.name:
+      case GameTournamentPlayerLeavedTheTournamentEvent.name:
+      case GameTournamentWaitedEvent.name: {
+        this.handleRoomStatusUpdated(
+          event as
+          | GameTournamentPlayerJoinedTheTournamentEvent
+          | GameTournamentPlayerLeavedTheTournamentEvent
+          | GameTournamentCancelledEvent,
+        );
+        break;
+      }
     }
   };
 
-  private handleRoomTableGameFinished = async (master: GameMaster) => {
-    await saveGameTablesResult(
-      master,
-      this.connection,
-      this.gameResultRepository,
-      this.usersRepository,
-      false,
-    );
-  };
-
-  private handleTournamentRoomStarted = async (master: TournamentMaster) => {
+  private handleTournamentRoomStarted = async (
+    event: GameTournamentStartedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.startTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomCancelled = async (master: TournamentMaster) => {
+  private handleTournamentRoomCancelled = async (
+    event: GameTournamentStartedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
     await this.tournamentRepository.cancelTournament(master.getTournamentId());
   };
 
-  private handleTournamentRoomFinished = async (master: TournamentMaster) => {
-    await saveTournamentResult(
+  private handleTournamentRoomFinished = async (
+    event: GameTournamentFinishedEvent,
+  ) => {
+    const master = event.room.getRoomMaster<TournamentMaster>();
+    await this.saveTournamentResult(
       master,
       this.connection,
       this.tournamentRepository,
       this.usersRepository,
+      this.ratingRepository,
     );
   };
 
-  private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {
-    this.eventsBusMainTablesSubscribeService.pushNewRoomState(event);
-    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(event);
+  private handleRoomStatusUpdated = (
+    event:
+      | GameTournamentPlayerJoinedTheTournamentEvent
+      | GameTournamentPlayerLeavedTheTournamentEvent
+      | GameTournamentCancelledEvent
+      | GameTournamentWaitedEvent
+      | GameTournamentStartedEvent
+      | GameTournamentFinishedEvent,
+  ) => {
+    const updateEvent = new RoomUpdateStateEvent(event.gameType, event.roomId);
+    this.eventsBusMainTablesSubscribeService.pushNewRoomState(updateEvent);
+    this.eventsBusManyTablesTournamentSubscribeService.pushNewRoomState(
+      updateEvent,
+    );
   };
 
   private createDailyTournament = async (dailyTournamentTime: string) => {

package/src/modules/menu/menu-screen.view.ts

@@ -18,16 +18,19 @@ import { Banner, Menu } from 'jp.db.schemas';
 export class MenuScreenView extends UniversalScreenView {
   private readonly menuItems: Array<Menu>;
   private readonly banner: Banner | null;
+  private gameType: string;
 
   constructor(
     localeService: ILocaleService,
     lang: string,
+    gameType: string,
     menuItems: Array<Menu>,
     banner: Banner | null,
   ) {
     super(localeService, lang);
     this.menuItems = menuItems;
     this.banner = banner;
+    this.gameType = gameType;
   }
 
   build(): IAppScreen {
@@ -56,7 +59,9 @@ export class MenuScreenView extends UniversalScreenView {
         new BannerSectionListItemComponent(
           this.banner.bannerId,
           this.getDbResource(this.banner.title),
-          this.localeService.t('common.menu.header.title', { lang: this.lang }),
+          this.localeService.t(`${this.gameType}.menu.header.title`, {
+            lang: this.lang,
+          }),
           new UrlImageComponent(this.banner.image),
           this.banner.link,
         ),
@@ -65,7 +70,9 @@ export class MenuScreenView extends UniversalScreenView {
 
     return new MenuHeaderSectionComponent(
       'header',
-      this.localeService.t('common.menu.header.title', { lang: this.lang }),
+      this.localeService.t(`${this.gameType}.menu.header.title`, {
+        lang: this.lang,
+      }),
     );
   }
 }

package/src/modules/menu/menu.interfaces.ts

@@ -14,4 +14,5 @@ export interface MenuModuleOptions extends Pick<ModuleMetadata, 'imports'> {
 
 export interface MenuFactoryOptions {
   i18n: I18nService;
+  gameType: string;
 }

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

@@ -31,6 +31,7 @@ export class MenuService {
       new MenuScreenView(
         this.options.i18n,
         headers.client_language,
+        this.options.gameType,
         menuItems,
         enabledBanner,
       ).buildBS(),

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

@@ -28,4 +28,5 @@ export interface OneTableTournamentRoomsFactoryOptions {
   playersTurnTimeout: number;
   instantFinishMode: boolean;
   tournamentPrizeTable: IPrizeTableData;
+  levelUpBonus: number;
 }

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

@@ -10,6 +10,12 @@ import {
   GameResult,
   GameResultSchema,
   GameResultRepository,
+  Rating,
+  RatingSchema,
+  RatingRepository,
+  ActivityLog,
+  ActivityLogRepository,
+  ActivityLogSchema,
 } from 'jp.db.schemas';
 
 import { OneTableTournamentRoomsManagerService } from './one-table-tournament-rooms-manager.service';
@@ -29,12 +35,18 @@ import { ONE_TABLE_TOURNAMENT_ROOMS_MANAGER_OPTIONS } from './one-table-tourname
     MongooseModule.forFeature([
       { name: GameResult.name, schema: GameResultSchema },
     ]),
+    MongooseModule.forFeature([{ name: Rating.name, schema: RatingSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
   ],
   providers: [
     OneTableTournamentRoomsRepository,
     UsersRepository,
     OneTableTournamentRoomsManagerService,
     GameResultRepository,
+    RatingRepository,
+    ActivityLogRepository,
   ],
   exports: [OneTableTournamentRoomsManagerService],
 })