feat: refactor

src/main/events/catalogue/get-game-achievements.ts

@@ -1,23 +1,81 @@
 import type {
   AchievementData,
-  GameAchievement,
   GameShop,
+  RemoteUnlockedAchievement,
   UnlockedAchievement,
+  UserAchievement,
 } from "@types";
 import { registerEvent } from "../register-event";
 import {
   gameAchievementRepository,
-  userAuthRepository,
+  userPreferencesRepository,
 } from "@main/repository";
 import { getGameAchievementData } from "@main/services/achievements/get-game-achievement-data";
-import { HydraApi } from "@main/services";
+import { HydraApi, logger } from "@main/services";
 
-const getAchievements = async (
+const getAchievementLocalUser = async (shop: string, objectId: string) => {
+  const cachedAchievements = await gameAchievementRepository.findOne({
+    where: { objectId, shop },
+  });
+
+  const achievementsData: AchievementData[] = cachedAchievements?.achievements
+    ? JSON.parse(cachedAchievements.achievements)
+    : await getGameAchievementData(objectId, shop);
+
+  const unlockedAchievements = JSON.parse(
+    cachedAchievements?.unlockedAchievements || "[]"
+  ) as UnlockedAchievement[];
+
+  return achievementsData
+    .map((achievementData) => {
+      logger.info("unclockedAchievements", unlockedAchievements);
+
+      const unlockedAchiementData = unlockedAchievements.find(
+        (localAchievement) => {
+          return (
+            localAchievement.name.toUpperCase() ==
+            achievementData.name.toUpperCase()
+          );
+        }
+      );
+
+      const icongray = achievementData.icongray.endsWith("/")
+        ? achievementData.icon
+        : achievementData.icongray;
+
+      if (unlockedAchiementData) {
+        return {
+          ...achievementData,
+          unlocked: true,
+          unlockTime: unlockedAchiementData.unlockTime,
+        };
+      }
+
+      return {
+        ...achievementData,
+        unlocked: false,
+        unlockTime: null,
+        icon: icongray,
+      } as UserAchievement;
+    })
+    .sort((a, b) => {
+      if (a.unlocked && !b.unlocked) return -1;
+      if (!a.unlocked && b.unlocked) return 1;
+      if (a.unlocked && b.unlocked) {
+        return b.unlockTime! - a.unlockTime!;
+      }
+      return Number(a.hidden) - Number(b.hidden);
+    });
+};
+
+const getAchievementsRemoteUser = async (
   shop: string,
   objectId: string,
-  userId?: string
+  userId: string
 ) => {
-  const userAuth = await userAuthRepository.findOne({ where: { userId } });
+  const userPreferences = await userPreferencesRepository.findOne({
+    where: { id: 1 },
+  });
 
   const cachedAchievements = await gameAchievementRepository.findOne({
     where: { objectId, shop },
@@ -27,31 +85,9 @@ const getAchievements = async (
     ? JSON.parse(cachedAchievements.achievements)
     : await getGameAchievementData(objectId, shop);
 
-  if (!userId || userAuth) {
-    const unlockedAchievements = JSON.parse(
-      cachedAchievements?.unlockedAchievements || "[]"
-    ) as UnlockedAchievement[];
-
-    return { achievementsData, unlockedAchievements };
-  }
-
-  const unlockedAchievements = await HydraApi.get<UnlockedAchievement[]>(
+  const unlockedAchievements = await HydraApi.get<RemoteUnlockedAchievement[]>(
     `/users/${userId}/games/achievements`,
-    { shop, objectId, language: "en" }
-  );
-
-  return { achievementsData, unlockedAchievements };
-};
-
-export const getGameAchievements = async (
-  objectId: string,
-  shop: GameShop,
-  userId?: string
-): Promise<GameAchievement[]> => {
-  const { achievementsData, unlockedAchievements } = await getAchievements(
-    shop,
-    objectId,
-    userId
+    { shop, objectId, language: userPreferences?.language || "en" }
   );
 
   return achievementsData
@@ -74,7 +110,6 @@ export const getGameAchievements = async (
           ...achievementData,
           unlocked: true,
           unlockTime: unlockedAchiementData.unlockTime,
-          icongray,
         };
       }
 
@@ -82,8 +117,8 @@ export const getGameAchievements = async (
         ...achievementData,
         unlocked: false,
         unlockTime: null,
-        icongray,
-      } as GameAchievement;
+        icon: icongray,
+      } as UserAchievement;
     })
     .sort((a, b) => {
       if (a.unlocked && !b.unlocked) return -1;
@@ -95,12 +130,24 @@ export const getGameAchievements = async (
     });
 };
 
+export const getGameAchievements = async (
+  objectId: string,
+  shop: GameShop,
+  userId?: string
+): Promise<UserAchievement[]> => {
+  if (!userId) {
+    return getAchievementLocalUser(shop, objectId);
+  }
+
+  return getAchievementsRemoteUser(shop, objectId, userId);
+};
+
 const getGameAchievementsEvent = async (
   _event: Electron.IpcMainInvokeEvent,
   objectId: string,
   shop: GameShop,
   userId?: string
-): Promise<GameAchievement[]> => {
+): Promise<UserAchievement[]> => {
   return getGameAchievements(objectId, shop, userId);
 };