jp.ms.common.modules 1.0.43 → 1.0.45

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

@@ -1,4 +1,4 @@
-import { Global, InternalServerErrorException, Module } from '@nestjs/common';
+import { Inject, Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
   ActivityLog,
@@ -15,30 +15,27 @@ import {
   UsersAchievementsRepository,
 } from 'jp.db.schemas';
 import {
-  BaseAppEvent,
-  BaseUserAppEvent,
-  EarnOneMillionAchievement,
-  GotLevel10Achievement,
-  GotLevel3Achievement,
-  Playd10GamesAchievement,
   SnackbarSendToPlayerWsEvent,
-  Take1PlaceOnManyTablesTournamentAchievement,
-  Take2Or3PlaceOnManyTablesTournamentAchievement,
   UserGotNewLevelAppEvent,
-  UserPlayedTheGameAppEvent,
-  UserWonManyTablesTournamentAppEvent,
-  UserWonOneTableTournamentAppEvent,
-  UserWonTheGameAppEvent,
-  Won3GamesAchievement,
-  Won3ProfiAchievement,
-  WonOneTableTournament3TimesAchievement,
+  BaseAchievement,
+  BaseUserAppEvent,
+  AchievementsCodesEnum,
+  GamePlayerRoundFinishedAppEvent,
+  GamePlayerMovedAppEvent,
+  GamePlayerManyTablesTournamentFinishedAppEvent,
+  GamePlayerOneTableTournamentFinishedAppEvent,
+  LocalService,
+  TournamentMaster,
 } from 'jp.ms.common.engine';
-import { AppScreenIconEnum, LanguageTypeEnum } from 'jp.common.models';
+import { LanguageTypeEnum } from 'jp.common.models';
 
 import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
 import { PlayersManagerService } from '../players-manager';
+import { AchievementSnackbarView } from '../../views';
+
+import { BASE_ACHIEVEMENTS_OPTIONS } from './base-achievements.constants';
+import { BaseAchievementsFactoryOptions } from './base-achievements.interfaces';
 
-@Global()
 @Module({
   imports: [
     MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
@@ -57,10 +54,13 @@ import { PlayersManagerService } from '../players-manager';
     ActivityLogRepository,
     AchievementRepository,
     UsersAchievementsRepository,
-    EventsBusAppSubscribeService,
   ],
 })
 export abstract class BaseAchievementsModule {
+  protected allAchievements: Array<Achievement> = [];
+  protected achievemnts: Map<string, BaseAchievement> = new Map();
+  protected usersAchievements: Map<string, UsersAchievement[]> = new Map();
+
   constructor(
     protected readonly eventsBusAppSubscribeService: EventsBusAppSubscribeService,
     protected readonly playersManager: PlayersManagerService,
@@ -68,257 +68,370 @@ export abstract class BaseAchievementsModule {
     protected readonly activityLogRepository: ActivityLogRepository,
     protected readonly achievementRepository: AchievementRepository,
     protected readonly usersAchievementRepository: UsersAchievementsRepository,
+    @Inject(BASE_ACHIEVEMENTS_OPTIONS)
+    private readonly options: BaseAchievementsFactoryOptions,
   ) {}
 
-  onModuleInit() {
+  abstract createAchievemnt(code: string, gameType: string): BaseAchievement;
+
+  async onModuleInit() {
     this.eventsBusAppSubscribeService.subscribe((event) => {
       void this.onHandleAppEvent(event);
     });
+
+    this.allAchievements = await this.achievementRepository.findAchievements(
+      this.options.gameType,
+    );
+
+    for (const achievement of this.allAchievements) {
+      const objAchievemnt = this.createAchievemnt(
+        achievement.code,
+        this.options.gameType,
+      );
+
+      this.achievemnts.set(objAchievemnt.getCode(), objAchievemnt);
+    }
   }
 
-  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(event.game);
-      const usersAchievements: Array<UsersAchievement> =
-        await this.usersAchievementRepository.findAchivementsByUserId(userId);
-
-      if (!player || !foundUser) {
-        throw new InternalServerErrorException();
-      }
+  protected async onHandleAppEvent(event: BaseUserAppEvent) {
+    const usersAchievemnets =
+      await this.usersAchievementRepository.findAchivementsByUserId(
+        event.userId,
+      );
+    this.usersAchievements.set(event.userId, usersAchievemnets);
 
-      if (event instanceof UserGotNewLevelAppEvent) {
-        // TODO подумать куда перенести LEVEL UP
-        player.sendMessage(
-          new SnackbarSendToPlayerWsEvent(
-            event.game,
-            player.id,
-            AppScreenIconEnum.ARROW_UPWARD,
-            'level up',
-            'buttonText',
-          ),
+    switch (event.constructor.name) {
+      case UserGotNewLevelAppEvent.name: {
+        this.handleUserGotLevelUp(event as UserGotNewLevelAppEvent);
+        break;
+      }
+      case GamePlayerRoundFinishedAppEvent.name: {
+        await this.handleGamePlayerRoundFinishedAppEvent(
+          event as GamePlayerRoundFinishedAppEvent,
+        );
+        break;
+      }
+      case GamePlayerMovedAppEvent.name: {
+        this.handleGamePlayerMovedAppEvent(event as GamePlayerMovedAppEvent);
+        break;
+      }
+      case GamePlayerManyTablesTournamentFinishedAppEvent.name: {
+        this.handleGamePlayerManyTablesTournamentFinishedAppEvent(
+          event as GamePlayerManyTablesTournamentFinishedAppEvent,
+        );
+        break;
+      }
+      case GamePlayerOneTableTournamentFinishedAppEvent.name: {
+        await this.handleGamePlayerOneTableTournamentFinishedAppEvent(
+          event as GamePlayerOneTableTournamentFinishedAppEvent,
         );
+        break;
+      }
+    }
+
+    this.usersAchievements.delete(event.userId);
+  }
 
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            GotLevel3Achievement.code,
-          )
-        ) {
-          if (new GotLevel3Achievement(event.newLevel).userGotAchievement()) {
-            void this.giveAchievement(
-              allAchievements,
-              GotLevel3Achievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            GotLevel10Achievement.code,
-          )
-        ) {
-          if (new GotLevel10Achievement(event.newLevel).userGotAchievement()) {
-            void this.giveAchievement(
-              allAchievements,
-              GotLevel10Achievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-      } else if (event instanceof UserPlayedTheGameAppEvent) {
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            Playd10GamesAchievement.code,
-          )
-        ) {
-          const playdGamesCount =
-            await this.activityLogRepository.getUserPlayedGamesCount(userId);
-
-          if (
-            new Playd10GamesAchievement(playdGamesCount).userGotAchievement()
-          ) {
-            void this.giveAchievement(
-              allAchievements,
-              Playd10GamesAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-      } else if (event instanceof UserWonTheGameAppEvent) {
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            Won3GamesAchievement.code,
-          )
-        ) {
-          const wonGamesCount =
-            await this.activityLogRepository.getUserWonGamesCount(userId);
-
-          if (new Won3GamesAchievement(wonGamesCount).userGotAchievement()) {
-            void this.giveAchievement(
-              allAchievements,
-              Won3GamesAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            Won3ProfiAchievement.code,
-          )
-        ) {
-          const wonProfiCount =
-            await this.activityLogRepository.getUserWonProfiCount(userId);
-          if (new Won3ProfiAchievement(wonProfiCount).userGotAchievement()) {
-            void this.giveAchievement(
-              allAchievements,
-              Won3ProfiAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            EarnOneMillionAchievement.code,
-          )
-        ) {
-          if (
-            new EarnOneMillionAchievement(
-              foundUser.balance,
-            ).userGotAchievement()
-          ) {
-            void this.giveAchievement(
-              allAchievements,
-              EarnOneMillionAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-      } else if (event instanceof UserWonOneTableTournamentAppEvent) {
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            WonOneTableTournament3TimesAchievement.code,
-          )
-        ) {
-          const wonFastTournamentCount =
-            await this.activityLogRepository.getUserWonOneTableTournamentCount(
-              userId,
-            );
-          if (
-            new WonOneTableTournament3TimesAchievement(
-              wonFastTournamentCount,
-            ).userGotAchievement()
-          ) {
-            void this.giveAchievement(
-              allAchievements,
-              WonOneTableTournament3TimesAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-      } else if (event instanceof UserWonManyTablesTournamentAppEvent) {
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            Take1PlaceOnManyTablesTournamentAchievement.code,
-          )
-        ) {
-          if (
-            new Take1PlaceOnManyTablesTournamentAchievement(
-              event.rank,
-            ).userGotAchievement()
-          ) {
-            void this.giveAchievement(
-              allAchievements,
-              Take1PlaceOnManyTablesTournamentAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
-
-        if (
-          this.userHasNoAchievement(
-            usersAchievements,
-            Take2Or3PlaceOnManyTablesTournamentAchievement.code,
-          )
-        ) {
-          if (
-            new Take2Or3PlaceOnManyTablesTournamentAchievement(
-              event.rank,
-            ).userGotAchievement()
-          ) {
-            void this.giveAchievement(
-              allAchievements,
-              Take2Or3PlaceOnManyTablesTournamentAchievement.code,
-              foundUser,
-              event.game,
-            );
-          }
-        }
+  protected async handleGamePlayerRoundFinishedAppEvent(
+    event: GamePlayerRoundFinishedAppEvent,
+  ) {
+    this.processEarnOneMillion(event);
+    await this.processFailNTimes(event);
+    await this.processPlayNTimes(event);
+    await this.processPlayNTimesADay(event);
+    await this.processWinNTimes(event);
+    this.processWinNTimesARow(event);
+    await this.processWinNProfi(event);
+  }
+
+  protected abstract handleGamePlayerMovedAppEvent(
+    event: GamePlayerMovedAppEvent,
+  );
+
+  protected handleGamePlayerManyTablesTournamentFinishedAppEvent(
+    event: GamePlayerManyTablesTournamentFinishedAppEvent,
+  ) {
+    this.processTakeNPlaceOnManyTablesTournament(event);
+  }
+
+  protected async handleGamePlayerOneTableTournamentFinishedAppEvent(
+    event: GamePlayerOneTableTournamentFinishedAppEvent,
+  ) {
+    await this.processWinNTimesOneTableTournament(event);
+  }
+
+  protected handleUserGotLevelUp(event: UserGotNewLevelAppEvent) {
+    const levelsAchievements = [
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_3,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_10,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_50,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_100,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_200,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_300,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_500,
+      AchievementsCodesEnum.GLOBAL_GET_LEVEL_1000,
+    ] as Array<string>;
+
+    for (const achievementCode of levelsAchievements) {
+      if (
+        this.achievemnts
+          .get(achievementCode)
+          ?.userGotAchievement(event.newLevel)
+      ) {
+        void this.giveAchievement(
+          achievementCode,
+          event.userId,
+          event.fullName,
+          event.game,
+        );
       }
     }
   }
 
-  protected userHasNoAchievement(
-    usersAchievements: Array<UsersAchievement>,
-    achievementCode: string,
+  private processEarnOneMillion(event: GamePlayerRoundFinishedAppEvent) {
+    if (
+      this.achievemnts
+        .get(AchievementsCodesEnum.GLOBAL_EARN_ONE_MILLION)
+        ?.userGotAchievement(event.getPlayer().balance)
+    ) {
+      void this.giveAchievement(
+        AchievementsCodesEnum.GLOBAL_EARN_ONE_MILLION,
+        event.userId,
+        event.fullName,
+        event.game,
+      );
+    }
+  }
+
+  private async processFailNTimes(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_FAIL_10_TIMES,
+      AchievementsCodesEnum.GB_FAIL_100_TIMES,
+    ] as Array<string>;
+
+    const failGamesCount =
+      await this.activityLogRepository.getUserFailedGamesCount(
+        event.userId,
+        event.game,
+      );
+
+    this.processManyGBAchievements(
+      achievements,
+      failGamesCount,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private async processPlayNTimes(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_PLAY_1000_TIMES,
+    ] as Array<string>;
+
+    const playdGamesCount =
+      await this.activityLogRepository.getUserPlayedGamesCount(
+        event.userId,
+        event.game,
+      );
+
+    this.processManyGBAchievements(
+      achievements,
+      playdGamesCount,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private async processPlayNTimesADay(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_PLAY_50_TIMES_A_DAY,
+      AchievementsCodesEnum.GB_PLAY_100_TIMES_A_DAY,
+    ] as Array<string>;
+
+    const playdGamesADayCount =
+      await this.activityLogRepository.getUserPlayedGamesADayCount(
+        event.userId,
+        event.game,
+      );
+
+    this.processManyGBAchievements(
+      achievements,
+      playdGamesADayCount,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private async processWinNTimes(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_WIN_1_TIMES,
+      AchievementsCodesEnum.GB_WIN_10_TIMES,
+      AchievementsCodesEnum.GB_WIN_100_TIMES,
+    ] as Array<string>;
+
+    const wonGamesCount = await this.activityLogRepository.getUserWonGamesCount(
+      event.userId,
+      event.game,
+    );
+
+    this.processManyGBAchievements(
+      achievements,
+      wonGamesCount,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private processWinNTimesARow(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_WIN_3_TIMES_A_ROW,
+      AchievementsCodesEnum.GB_WIN_10_TIMES_A_ROW,
+    ] as Array<string>;
+
+    this.processManyGBAchievements(
+      achievements,
+      event.getPlayer().getWinTimesARow(),
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private async processWinNProfi(event: GamePlayerRoundFinishedAppEvent) {
+    const achievements = [
+      AchievementsCodesEnum.GB_WIN_3_PROFI,
+    ] as Array<string>;
+
+    const wonProfiCount = await this.activityLogRepository.getUserWonProfiCount(
+      event.userId,
+      event.game,
+    );
+
+    this.processManyGBAchievements(
+      achievements,
+      wonProfiCount,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private processTakeNPlaceOnManyTablesTournament(
+    event: GamePlayerManyTablesTournamentFinishedAppEvent,
+  ) {
+    const achievements = [
+      AchievementsCodesEnum.GB_TAKE_1_PLACE_ON_MANY_TABLES_TOURNAMENT,
+      AchievementsCodesEnum.GB_TAKE_2_OR_3_PLACE_AT_MANY_TABLES_TOURNAMENT,
+    ] as Array<string>;
+
+    const foundPlayer = event
+      .getRoomMaster<TournamentMaster>()
+      .getTournamentResult()
+      .find((player) => player.playerId == event.getPlayer().id);
+
+    this.processManyGBAchievements(
+      achievements,
+      foundPlayer?.rank ?? 0,
+      event.userId,
+      event.fullName,
+      event.game,
+    );
+  }
+
+  private async processWinNTimesOneTableTournament(
+    event: GamePlayerOneTableTournamentFinishedAppEvent,
   ) {
-    return !usersAchievements.find(
-      (item) => item.achievementCode === achievementCode,
+    const achievements = [
+      AchievementsCodesEnum.GB_WIN_ONE_TABLE_TOURNAMENT_3_TIMES,
+    ] as Array<string>;
+
+    const winCount =
+      await this.activityLogRepository.getUserWonOneTableTournamentCount(
+        event.userId,
+        event.game,
+      );
+
+    this.processManyGBAchievements(
+      achievements,
+      winCount,
+      event.userId,
+      event.fullName,
+      event.game,
     );
   }
 
   protected async giveAchievement(
-    allAchievements: Array<Achievement>,
     achievementCode: string,
-    user: User,
+    userId: string,
+    fullName: string,
     game: string,
   ) {
-    const foundAchievement = allAchievements.find(
+    const foundAchievement = this.allAchievements.find(
       (item) => item.code === achievementCode,
     );
-    const player = this.playersManager.getPlayerById(user.userId);
+    const player = this.playersManager.getPlayerById(userId);
+    const hasAchievemnt = this.usersAchievements
+      .get(userId)
+      ?.find((item) => item.achievementCode !== achievementCode);
 
-    if (foundAchievement && player) {
+    if (foundAchievement && player && !hasAchievemnt) {
       await this.usersAchievementRepository.addUsersAchievement(
-        user.userId,
-        user.fullName,
+        userId,
+        fullName,
         foundAchievement.achievementId,
         foundAchievement.title[LanguageTypeEnum.RU],
-        foundAchievement.code,
+        achievementCode,
         foundAchievement.prize,
-        '',
+        game,
       );
 
       player.sendMessage(
         new SnackbarSendToPlayerWsEvent(
-          game,
+          this.options.gameType,
           player.id,
-          AppScreenIconEnum.EMOJI_EVENTS,
-          foundAchievement.title[player.language],
-          foundAchievement.description[player.language],
+          new AchievementSnackbarView(
+            this.options.i18n as LocalService,
+            player.language,
+            foundAchievement,
+            this.options.achievementBonus,
+          ).build(),
         ),
       );
     }
   }
+
+  protected gameTypedCode(achievementCode: string): string {
+    return `${this.options.gameType}_${achievementCode}`;
+  }
+
+  protected processManyGBAchievements(
+    achievements: Array<string>,
+    count: number,
+    userId: string,
+    fullName: string,
+    game: string,
+  ) {
+    for (const achievementCode of achievements) {
+      const gbCode = this.gameTypedCode(achievementCode);
+      if (this.achievemnts.get(gbCode)?.userGotAchievement(count)) {
+        void this.giveAchievement(gbCode, userId, fullName, game);
+      }
+    }
+  }
+
+  protected processOneUniqAchievement(
+    achievementCode: string,
+    count: number,
+    userId: string,
+    fullName: string,
+    game: string,
+  ) {
+    if (this.achievemnts.get(achievementCode)?.userGotAchievement(count)) {
+      void this.giveAchievement(achievementCode, userId, fullName, game);
+    }
+  }
 }

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

@@ -1 +1,6 @@
 export { BaseAchievementsModule } from './base-achievements.module';
+export { BASE_ACHIEVEMENTS_OPTIONS } from './base-achievements.constants';
+export {
+  BaseAchievementsOptions,
+  BaseAchievementsFactoryOptions,
+} from './base-achievements.interfaces';

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

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

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';