Feature/server achievements handlers

server/src/models/types/index.ts

@@ -287,7 +287,7 @@ export interface BadgeModel extends BaseModel {
 
 export type BadgeDocument = BadgeModel & Document;
 
-interface StageData {
+export interface StageData {
   name: string;
   stage: number;
   goal: number;

server/src/services/achievements/achievementsService.ts

@@ -58,7 +58,14 @@ export const getOneAchievement = async (
 ) => {
   const { select = { __v: 0 } } = achievementFindOptions;
   try {
-    const foundAchievement = await Achievement.findOne(filter).select(select).populate("stages");
+    const foundAchievement = await Achievement.findOne(filter)
+      .select(select)
+      .populate({
+        path: "stages",
+        populate: {
+          path: "stageData.badge"
+        }
+      });
 
     return foundAchievement;
   } catch (err) {

server/src/services/achievements/achivementUserProgresses.ts

@@ -2,12 +2,18 @@ import {
   AchievementUserProgressDocument,
   AchievementUserProgress,
   AchievementModel,
-  AchievementUserProgressModel
+  AchievementUserProgressModel,
+  StageData
 } from "@models";
 import { logger, handleAppError, checkExistResource } from "@utils";
 import { FilterQuery, UpdateQuery } from "mongoose";
-import { getUserById } from "@services";
-import { AchievementUserProgressCreate, AchievementUserProgressUpdate } from "./types";
+import { getOneAchievement, getUserById } from "@services";
+import {
+  AchievementUserProgressCreate,
+  AchievementUserProgressUpdate,
+  GetDataForObtainAchievementEmitReturnData,
+  UpdateAchievementUserProgressProgressesReturnData
+} from "./types";
 
 export const getOneAchievementUserProgress = async (filter: FilterQuery<AchievementUserProgressDocument> = {}) => {
   try {
@@ -83,21 +89,52 @@ export const updateFinishedStagesDependsOnProgress = async (
   achievement: AchievementModel,
   achievementProgress: AchievementUserProgressModel,
   progress: number
-) => {
-  const modifiedStages: AchievementUserProgressModel["progresses"] = achievementProgress.progresses;
-
+): Promise<[number, number][]> => {
+  const newfinishedStages: AchievementUserProgressModel["progresses"] = [];
   for (let idx = 0; idx < achievement.stages.stageData.length; idx++) {
     const currentAchievementStage = achievement.stages.stageData[idx];
     const currentProgressStage = achievementProgress.progresses.at(idx);
     if (!currentProgressStage && currentAchievementStage.goal <= progress) {
-      modifiedStages.push([currentAchievementStage.stage, Date.now()]);
+      newfinishedStages.push([currentAchievementStage.stage, Date.now()]);
     }
   }
 
-  const updatedAchievementUpdate = await updateOneAchievementUserProgress(
+  await updateOneAchievementUserProgress(
     { _id: achievementProgress._id },
-    { progresses: modifiedStages, value: progress }
+    { progresses: [...achievementProgress.progresses, ...newfinishedStages], value: progress }
   );
 
-  return updatedAchievementUpdate;
+  return newfinishedStages;
+};
+
+export const updateAchievementUserProgressProgresses = async (
+  achievementName: string,
+  userId: string,
+  progressValue: number
+): Promise<UpdateAchievementUserProgressProgressesReturnData | undefined> => {
+  const foundAchievement = await getOneAchievement({ name: achievementName }, {});
+
+  if (!foundAchievement) return; //TODO: add handling
+  const userProgress = await createAchievementUserProgress({
+    userId: userId,
+    achievement: foundAchievement._id
+  });
+
+  if (!userProgress) return; //TODO: add handling
+
+  const nowFinishedStages = await updateFinishedStagesDependsOnProgress(foundAchievement, userProgress, progressValue);
+
+  return { foundAchievement, nowFinishedStages };
+};
+
+export const getDataForObtainAchievementEmit = (
+  data: UpdateAchievementUserProgressProgressesReturnData
+): GetDataForObtainAchievementEmitReturnData => {
+  const newStages: StageData[] = [];
+
+  data.nowFinishedStages.forEach((stage) => {
+    const stageData = data.foundAchievement.stages.stageData.find((innerStage) => innerStage.stage === stage[0]);
+    if (stageData) newStages.push(stageData);
+  });
+  return { achievementName: data.foundAchievement.name, stages: newStages };
 };

server/src/services/achievements/index.ts

@@ -1,4 +1,4 @@
 export * from "./achievementsService";
 export * from "./achivementUserProgresses";
 export * from "./achievementStages";
-export * from "./";
+export * from "./types";

server/src/services/achievements/types/index.ts

@@ -1,5 +1,5 @@
 import { SortQuery, SelectQuery } from "@services";
-import { AchievementModel, AchievementStageModel, AchievementUserProgressModel } from "@models";
+import { AchievementModel, AchievementStageModel, AchievementUserProgressModel, StageData } from "@models";
 
 export interface AchievementsFindOptions<T = AchievementModel> {
   select?: SelectQuery<T>;
@@ -24,3 +24,13 @@ export interface AchievementUserProgressCreate
 
 export type AchievementStageCreateData = Pick<AchievementStageModel, "name" | "stageData">;
 export type AchievementStageUpdateData = Partial<AchievementStageCreateData>;
+
+export type UpdateAchievementUserProgressProgressesReturnData = {
+  foundAchievement: AchievementModel;
+  nowFinishedStages: AchievementUserProgressModel["progresses"];
+};
+
+export interface GetDataForObtainAchievementEmitReturnData {
+  achievementName: string;
+  stages: StageData[];
+}

server/src/socketIO/types/dataTypes.ts

@@ -1,4 +1,4 @@
-import { UserModel } from "@models";
+import { StageData, UserModel } from "@models";
 
 export interface AudioDataRequester {
   id: string;
@@ -80,3 +80,9 @@ export interface RewardData {
   rewardCost: number;
   rewardImage: string;
 }
+
+export interface ObtainAchievementData {
+  achievementName: string;
+  stage: StageData;
+  username: string;
+}

server/src/socketIO/types/serverToClient.ts

@@ -5,7 +5,8 @@ import {
   AudioStreamData,
   AudioStreamDataInfo,
   AudioYTData,
-  AudioYTDataInfo
+  AudioYTDataInfo,
+  ObtainAchievementData
 } from "./dataTypes";
 
 export interface ServerToClientEvents extends ServerToClientYoutubeEvents, ServerToClientMusicLocalEvents {
@@ -18,6 +19,8 @@ export interface ServerToClientEvents extends ServerToClientYoutubeEvents, Serve
   forceReconnect: () => void;
   getCustomRewards: (data: CustomRewardData[]) => void;
   sendLoggedUserInfo: (username: string) => void;
+
+  obtainAchievement: (data: ObtainAchievementData) => void;
 }
 
 export interface ServerToClientMusicLocalEvents {

server/src/stream/AchievementsHandler.ts

@@ -0,0 +1,81 @@
+import {
+  ClientToServerEvents,
+  ServerToClientEvents,
+  InterServerEvents,
+  SocketData,
+  ObtainAchievementData
+} from "@socket";
+import { Server } from "socket.io";
+import QueueHandler from "./QueueHandler";
+import {
+  getDataForObtainAchievementEmit,
+  updateAchievementUserProgressProgresses,
+  UpdateAchievementUserProgressProgressesReturnData,
+  GetDataForObtainAchievementEmitReturnData
+} from "@services";
+import { ACHIEVEMENTS } from "@defaults";
+import { achievementsLogger } from "@utils";
+
+interface UpdateAchievementUserProgressOpts {
+  achievement: ACHIEVEMENTS;
+  progressValue: number;
+  userId: string;
+  username: string;
+}
+
+class AchievementsHandler extends QueueHandler<ObtainAchievementData> {
+  private socketIO: Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+  constructor(socketIO: Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>) {
+    super();
+    this.socketIO = socketIO;
+  }
+
+  protected override startInterval(): void {
+    super.startInterval((item) => {
+      this.emitObtainAchievement(item);
+    });
+  }
+
+  public override enqueue(item: ObtainAchievementData) {
+    super.enqueue(item);
+
+    this.startInterval();
+  }
+
+  private convertUpdateDataToObtainAchievementData(data: UpdateAchievementUserProgressProgressesReturnData) {
+    const nowFinishedStagesInfo = getDataForObtainAchievementEmit({
+      foundAchievement: data.foundAchievement,
+      nowFinishedStages: data.nowFinishedStages
+    });
+
+    return nowFinishedStagesInfo;
+  }
+
+  public async updateAchievementUserProgressAndAddToQueue({
+    achievement,
+    userId,
+    progressValue,
+    username
+  }: UpdateAchievementUserProgressOpts) {
+    const updateData = await updateAchievementUserProgressProgresses(achievement, userId, progressValue);
+
+    if (!updateData) {
+      achievementsLogger.error("Not found update data in updateAchievementUserProgressAndAddToQueue");
+      return;
+    }
+
+    const modifiedUpdateData = this.convertUpdateDataToObtainAchievementData(updateData);
+
+    this.addObtainedAchievementDataToQueue(modifiedUpdateData, username);
+  }
+
+  private addObtainedAchievementDataToQueue(data: GetDataForObtainAchievementEmitReturnData, username: string) {
+    data.stages.forEach((stage) => this.enqueue({ achievementName: data.achievementName, stage, username }));
+  }
+
+  private emitObtainAchievement({ achievementName, stage, username }: ObtainAchievementData) {
+    this.socketIO.emit("obtainAchievement", { achievementName: achievementName, stage, username });
+  }
+}
+
+export default AchievementsHandler;

server/src/stream/LoyaltyHandler.ts

@@ -1,13 +1,4 @@
-import {
-  updateCurrentStreamSession,
-  createUserIfNotExist,
-  isUserInDB,
-  updateUser,
-  getOneUser,
-  createAchievementUserProgress,
-  getOneAchievement,
-  updateFinishedStagesDependsOnProgress
-} from "@services";
+import { updateCurrentStreamSession, createUserIfNotExist, isUserInDB, updateUser, getOneUser } from "@services";
 import { ApiClient, HelixChatChatter } from "@twurple/api";
 import { getBaseLog, removeDifferenceFromSet, retryWithCatch, watcherLogger } from "@utils";
 import type { ClientToServerEvents, InterServerEvents, ServerToClientEvents, SocketData } from "@socket";
@@ -16,6 +7,7 @@ import HeadHandler from "./HeadHandler";
 import { LoyaltyConfigs, PointsConfigs, StreamSessionModel } from "@models";
 import { AuthorizedUserData } from "./types";
 import { ACHIEVEMENTS } from "@defaults";
+import AchievementsHandler from "./AchievementsHandler";
 
 interface LoyaltyConfigsHandler extends LoyaltyConfigs, PointsConfigs {}
 
@@ -24,14 +16,17 @@ class LoyaltyHandler extends HeadHandler {
   private usersBefore = new Set<string>();
   private currentSession: StreamSessionModel | null | undefined;
   private checkChattersTimeout: NodeJS.Timeout | undefined;
+  private achievementsHandler: AchievementsHandler;
   constructor(
     twitchApi: ApiClient,
     socketIO: Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>,
     authorizedUser: AuthorizedUserData,
-    configs: LoyaltyConfigsHandler
+    configs: LoyaltyConfigsHandler,
+    achievementsHandler: AchievementsHandler
   ) {
     super(socketIO, twitchApi, authorizedUser);
     this.configs = configs;
+    this.achievementsHandler = achievementsHandler;
     this.init();
   }
 
@@ -193,24 +188,20 @@ class LoyaltyHandler extends HeadHandler {
       const foundUser = await getOneUser({ twitchId: userId }, {});
       if (!foundUser) return watcherLogger.error("updateLoyaltyAchievements - user  not found");
 
-      await this.updateAchievementUserProgress(ACHIEVEMENTS.CHAT_MESSAGES, foundUser._id, foundUser.messageCount || 0);
-      await this.updateAchievementUserProgress(ACHIEVEMENTS.WATCH_TIME, foundUser._id, foundUser.watchTime || 0);
+      await this.achievementsHandler.updateAchievementUserProgressAndAddToQueue({
+        achievement: ACHIEVEMENTS.CHAT_MESSAGES,
+        userId: foundUser._id,
+        progressValue: foundUser.messageCount || 0,
+        username: foundUser.username
+      });
+      await this.achievementsHandler.updateAchievementUserProgressAndAddToQueue({
+        achievement: ACHIEVEMENTS.WATCH_TIME,
+        userId: foundUser._id,
+        progressValue: foundUser.watchTime || 0,
+        username: foundUser.username
+      });
     }
   }
-
-  private async updateAchievementUserProgress(achievementName: string, userId: string, progressValue: number) {
-    const foundAchievement = await getOneAchievement({ name: achievementName }, {});
-
-    if (!foundAchievement) return watcherLogger.error("updateAchievementUserProgress - achievement  not found");
-    const userProgress = await createAchievementUserProgress({
-      userId: userId,
-      achievement: foundAchievement._id
-    });
-
-    if (!userProgress) return;
-
-    updateFinishedStagesDependsOnProgress(foundAchievement, userProgress, progressValue);
-  }
 }
 
 export default LoyaltyHandler;

server/src/stream/MessagesHandler.ts

@@ -1,9 +1,13 @@
 import { createMessage, MessageCreateData, updateUser } from "@services";
-import { PointsConfigs } from "@models";
+import { PointsConfigs, UserModel } from "@models";
+import AchievementsHandler from "./AchievementsHandler";
+import { ACHIEVEMENTS } from "@defaults";
 
 class MessagesHandler {
   private configs: PointsConfigs;
-  constructor(configs: PointsConfigs) {
+  private achievementsHandler: AchievementsHandler;
+  constructor(achievementsHandler: AchievementsHandler, configs: PointsConfigs) {
+    this.achievementsHandler = achievementsHandler;
     this.configs = configs;
   }
 
@@ -19,8 +23,23 @@ class MessagesHandler {
       message: message
     });
 
-    await this.updateUserStatistics(userId);
+    const updatedUser = await this.updateUserStatistics(userId);
+
+    if (!updatedUser) return;
+    this.checkAchievementsIfUserFirstMessage(updatedUser);
+  }
+
+  private async checkAchievementsIfUserFirstMessage(user: UserModel) {
+    if (user.messageCount !== 1) return;
+
+    await this.achievementsHandler.updateAchievementUserProgressAndAddToQueue({
+      achievement: ACHIEVEMENTS.CHAT_MESSAGES,
+      userId: user._id,
+      progressValue: user.messageCount || 0,
+      username: user.username
+    });
   }
+
   private async saveMessageToDatabase(messageCreateData: MessageCreateData) {
     try {
       const newMessage = await createMessage(messageCreateData);
@@ -38,7 +57,7 @@ class MessagesHandler {
       // set last seen to new Date()
     };
 
-    await updateUser({ _id: userId }, updateData);
+    return await updateUser({ _id: userId }, updateData);
   }
 }