Merge branch 'feature/game-achievements' into chore/test-preview

# Conflicts:
#	src/main/services/window-manager.ts
#	src/renderer/src/context/game-details/game-details.context.tsx
#	src/renderer/src/declaration.d.ts
#	src/types/index.ts
#	yarn.lock

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

@@ -0,0 +1,94 @@
+import type { GameAchievement, GameShop } from "@types";
+import { registerEvent } from "../register-event";
+import { HydraApi } from "@main/services";
+import {
+  gameAchievementRepository,
+  gameRepository,
+  userPreferencesRepository,
+} from "@main/repository";
+import { UserNotLoggedInError } from "@shared";
+import { Game } from "@main/entity";
+
+const getAchievementsDataFromApi = async (
+  objectId: string,
+  shop: string,
+  game: Game | null
+) => {
+  const userPreferences = await userPreferencesRepository.findOne({
+    where: { id: 1 },
+  });
+
+  return HydraApi.get("/games/achievements", {
+    objectId,
+    shop,
+    language: userPreferences?.language || "en",
+  })
+    .then((achievements) => {
+      if (game) {
+        gameAchievementRepository.upsert(
+          {
+            objectId,
+            shop,
+            achievements: JSON.stringify(achievements),
+          },
+          ["objectId", "shop"]
+        );
+      }
+
+      return achievements;
+    })
+    .catch((err) => {
+      if (err instanceof UserNotLoggedInError) throw err;
+      return [];
+    });
+};
+
+const getGameAchievements = async (
+  _event: Electron.IpcMainInvokeEvent,
+  objectId: string,
+  shop: GameShop
+): Promise<GameAchievement[]> => {
+  const [game, cachedAchievements] = await Promise.all([
+    gameRepository.findOne({
+      where: { objectID: objectId, shop },
+    }),
+    gameAchievementRepository.findOne({ where: { objectId, shop } }),
+  ]);
+
+  const gameAchievements = cachedAchievements?.achievements
+    ? JSON.parse(cachedAchievements.achievements)
+    : await getAchievementsDataFromApi(objectId, shop, game);
+
+  const unlockedAchievements = JSON.parse(
+    cachedAchievements?.unlockedAchievements || "[]"
+  ) as { name: string; unlockTime: number }[];
+
+  return gameAchievements
+    .map((achievement) => {
+      const unlockedAchiement = unlockedAchievements.find(
+        (localAchievement) => {
+          return (
+            localAchievement.name.toUpperCase() ==
+            achievement.name.toUpperCase()
+          );
+        }
+      );
+
+      if (unlockedAchiement) {
+        return {
+          ...achievement,
+          unlocked: true,
+          unlockTime: unlockedAchiement.unlockTime,
+        };
+      }
+
+      return { ...achievement, unlocked: false, unlockTime: null };
+    })
+    .sort((a, b) => {
+      if (a.unlocked && !b.unlocked) return -1;
+      if (!a.unlocked && b.unlocked) return 1;
+      return b.unlockTime - a.unlockTime;
+    });
+};
+
+registerEvent("getGameAchievements", getGameAchievements);

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

@@ -9,13 +9,10 @@ const getGameStats = async (
   objectId: string,
   shop: GameShop
 ) => {
-  const params = new URLSearchParams({
-    objectId,
-    shop,
-  });
-
   const response = await HydraApi.get<GameStats>(
-    `/games/stats?${params.toString()}`
+    `/games/stats`,
+    { objectId, shop },
+    { needsAuth: false }
   );
   return response;
 };

src/main/events/index.ts

@@ -9,6 +9,7 @@ import "./catalogue/get-random-game";
 import "./catalogue/search-games";
 import "./catalogue/get-game-stats";
 import "./catalogue/get-trending-games";
+import "./catalogue/get-game-achievements";
 import "./hardware/get-disk-free-space";
 import "./library/add-game-to-library";
 import "./library/create-game-shortcut";

src/main/events/library/add-game-to-library.ts

@@ -7,6 +7,7 @@ import type { GameShop } from "@types";
 import { steamGamesWorker } from "@main/workers";
 import { createGame } from "@main/services/library-sync";
 import { steamUrlBuilder } from "@shared";
+import { updateLocalUnlockedAchivements } from "@main/services/achievements/update-local-unlocked-achivements";
 
 const addGameToLibrary = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -43,6 +44,8 @@ const addGameToLibrary = async (
         });
       }
 
+      updateLocalUnlockedAchivements(true, objectID);
+
       const game = await gameRepository.findOne({ where: { objectID } });
 
       createGame(game!).catch(() => {});

src/main/events/profile/sync-friend-requests.ts

@@ -1,9 +1,17 @@
 import { registerEvent } from "../register-event";
 import { HydraApi } from "@main/services";
+import { UserNotLoggedInError } from "@shared";
 import { FriendRequestSync } from "@types";
 
 const syncFriendRequests = async (_event: Electron.IpcMainInvokeEvent) => {
-  return HydraApi.get<FriendRequestSync>(`/profile/friend-requests/sync`);
+  return HydraApi.get<FriendRequestSync>(`/profile/friend-requests/sync`).catch(
+    (err) => {
+      if (err instanceof UserNotLoggedInError) {
+        return { friendRequests: [] };
+      }
+      throw err;
+    }
+  );
 };
 
 registerEvent("syncFriendRequests", syncFriendRequests);

src/main/events/user/get-blocked-users.ts

@@ -1,5 +1,6 @@
 import { registerEvent } from "../register-event";
 import { HydraApi } from "@main/services";
+import { UserNotLoggedInError } from "@shared";
 import { UserBlocks } from "@types";
 
 export const getBlockedUsers = async (
@@ -7,7 +8,12 @@ export const getBlockedUsers = async (
   take: number,
   skip: number
 ): Promise<UserBlocks> => {
-  return HydraApi.get(`/profile/blocks`, { take, skip });
+  return HydraApi.get(`/profile/blocks`, { take, skip }).catch((err) => {
+    if (err instanceof UserNotLoggedInError) {
+      return { blocks: [] };
+    }
+    throw err;
+  });
 };
 
 registerEvent("getBlockedUsers", getBlockedUsers);