Feature/eventsub achievements cheers and raid

server/src/defaults/achievements/achievements.ts

@@ -113,6 +113,26 @@ export const getDefaultAchievementsData = (stagesId: string, tagId: string): Ach
       tag: tagId,
       showProgress: true
     },
+    {
+      name: ACHIEVEMENTS.SENT_CHEERS,
+      description: "Achievements for sending cheers cumulative to channel",
+      stages: stagesId,
+      tag: tagId,
+      showProgress: true
+    },
+    {
+      name: ACHIEVEMENTS.SENT_CHEERS_AS_PACK,
+      description: "Achievements for sending cheers choosen amounts at once to channel",
+      stages: stagesId,
+      tag: tagId
+    },
+    {
+      name: ACHIEVEMENTS.RAID_FROM,
+      description: "Achievements for raid a channel with choosen amount of viewers",
+      stages: stagesId,
+      tag: tagId,
+      showProgress: true
+    },
     {
       name: ACHIEVEMENTS.COMMANDS_COUNT,
       description: "Achievements for use of command",

server/src/defaults/achievements/types.ts

@@ -13,6 +13,9 @@ export enum ACHIEVEMENTS {
   SENT_SUBSCRIBTIONS_GIFTS_AS_PACK_TIER_1 = "SUB GIFTER PACK TIER 1",
   SENT_SUBSCRIBTIONS_GIFTS_AS_PACK_TIER_2 = "SUB GIFTER PACK TIER 2",
   SENT_SUBSCRIBTIONS_GIFTS_AS_PACK_TIER_3 = "SUB GIFTER PACK TIER 3",
+  SENT_CHEERS = "SENT CHEERS",
+  SENT_CHEERS_AS_PACK = "SENT CHEERS PACK",
+  RAID_FROM = "RAIDER",
   RECEIVED_SUBSCRIBTIONS_GIFTS = "SUB GIFTS RECEIVED",
   BOUGHT_SUBSCRIBTIONS = "BOUGHT SUBS",
   COMMANDS_COUNT = "COMMANDS",

server/src/stream/AchievementsHandler.ts

@@ -94,6 +94,15 @@ interface AddAnonymousAchievementProgressData {
   gainedProgress: AddAchievementProgressDataToQueueData["gainedProgress"];
 }
 
+interface CheckRaidFromForAchievementsParams extends CommonAchievementCheckType {
+  viewersAmount: number;
+}
+interface CheckUserCheersForAchievementsParams extends Partial<CommonAchievementCheckType> {
+  isAnonymous: boolean;
+  bits: number;
+  message: string;
+}
+
 class AchievementsHandler extends QueueHandler<
   ObtainAchievementDataWithCollectedAchievement | ObtainAchievementDataWithProgressOnly
 > {
@@ -302,6 +311,44 @@ class AchievementsHandler extends QueueHandler<
     });
   }
 
+  public async checkRaidFromForAchievements({ viewersAmount, ...rest }: CheckRaidFromForAchievementsParams) {
+    await this.updateAchievementUserProgressAndAddToQueue({
+      achievementName: ACHIEVEMENTS.RAID_FROM,
+      progress: { value: viewersAmount },
+      ...rest
+    });
+  }
+
+  public async checkUserCheersForAchievements({
+    bits,
+    isAnonymous,
+    message,
+    username,
+    userId
+  }: CheckUserCheersForAchievementsParams) {
+    //TODO: add usage of message
+    const cheerAchievements = [
+      { achievement: ACHIEVEMENTS.SENT_CHEERS, pack: false },
+      { achievement: ACHIEVEMENTS.SENT_CHEERS_AS_PACK, pack: true }
+    ];
+    for (const achievementData of cheerAchievements) {
+      if (!isAnonymous && username && userId) {
+        await this.updateAchievementUserProgressAndAddToQueue({
+          achievementName: achievementData.achievement,
+          progress: { value: bits },
+          userId,
+          username
+        });
+      } else {
+        await this.addAnonymousAchievementProgress({
+          achievementName: achievementData.achievement,
+          username: "Anonymous user",
+          gainedProgress: { progress: bits, timestamp: Date.now() }
+        });
+      }
+    }
+  }
+
   public async checkUserSubscribeForAchievements({ tier, isGift, ...rest }: CheckUserSubscribeForAchievementsParams) {
     const tierAchievements = new Map<SubscriptionTiers, ACHIEVEMENTS[]>([
       [

server/src/stream/EventSubHandler.ts

@@ -165,6 +165,85 @@ class EventSubHandler extends HeadHandler {
       }
     });
   }
+  private async subscribeToChannelRaidFrom() {
+    this.listener.onChannelRaidFrom(this.authorizedUser.id, async (e) => {
+      const { viewers, raidingBroadcasterDisplayName, raidingBroadcasterId, raidingBroadcasterName } = e;
+
+      eventsubLogger.info(
+        `Someone raided a channel: ${JSON.stringify({
+          viewers,
+          raidingBroadcasterDisplayName,
+          raidingBroadcasterId,
+          raidingBroadcasterName
+        })}`
+      );
+
+      const userData = {
+        username: raidingBroadcasterDisplayName,
+        twitchId: raidingBroadcasterId,
+        twitchName: raidingBroadcasterName,
+        privileges: 0
+      };
+
+      try {
+        const userDB = await createUserIfNotExist({ twitchId: raidingBroadcasterId }, userData);
+        if (!userDB) {
+          return eventsubLogger.error(`subscribeToChannelRaidFrom - error when trying to manipulate user data`);
+        }
+        await this.achievementsHandler.checkRaidFromForAchievements({
+          viewersAmount: viewers,
+          userId: userDB._id,
+          username: userDB.username
+        });
+      } catch (err) {
+        eventsubLogger.error(`Error occured in subscribeToChannelRaidFrom: ${err}`);
+      }
+    });
+  }
+
+  private async subscribeToChannelCheer() {
+    this.listener.onChannelCheer(this.authorizedUser.id, async (e) => {
+      const { bits, userDisplayName, userId, userName, message, isAnonymous } = e;
+      eventsubLogger.info(
+        `Someone cheered to channel: ${JSON.stringify({
+          bits,
+          userDisplayName,
+          userId,
+          userName,
+          message,
+          isAnonymous
+        })}`
+      );
+
+      try {
+        const userDB = isAnonymous
+          ? null
+          : await createUserIfNotExist(
+              { twitchId: userId },
+              {
+                //NOTE:below 3: null assertion - because I know if !isAnonymous its not null
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                username: userDisplayName!,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                twitchId: userId!,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                twitchName: userName!,
+                privileges: 0
+              }
+            );
+
+        await this.achievementsHandler.checkUserCheersForAchievements({
+          isAnonymous,
+          bits,
+          message,
+          userId: userDB?._id,
+          username: userDB?.username
+        });
+      } catch (err) {
+        eventsubLogger.error(`Error occured in subscribeToChannelCheer: ${err}`);
+      }
+    });
+  }
 
   private async createStreamSessionHelper(startDate: Date, title: string, category: string) {
     const timestampUpdateStream = startDate.getTime().toString();
@@ -294,6 +373,8 @@ class EventSubHandler extends HeadHandler {
     await this.subscribeToChannelFollow();
     await this.subscribeToChannelSubscription();
     await this.subscribeToChannelSubscriptionGift();
+    await this.subscribeToChannelCheer();
+    await this.subscribeToChannelRaidFrom();
   }
 }