Merge remote-tracking branch 'origin/main' into feature/reset-achievements

src/main/events/auth/get-session-hash.ts

@@ -9,6 +9,8 @@ const getSessionHash = async (_event: Electron.IpcMainInvokeEvent) => {
   if (!auth) return null;
   const payload = jwt.decode(auth.accessToken) as jwt.JwtPayload;
 
+  if (!payload) return null;
+
   return payload.sessionId;
 };
 

src/main/events/auth/sign-out.ts

@@ -1,12 +1,8 @@
 import { registerEvent } from "../register-event";
-import {
-  DownloadManager,
-  HydraApi,
-  PythonInstance,
-  gamesPlaytime,
-} from "@main/services";
+import { DownloadManager, HydraApi, gamesPlaytime } from "@main/services";
 import { dataSource } from "@main/data-source";
 import { DownloadQueue, Game, UserAuth, UserSubscription } from "@main/entity";
+import { PythonRPC } from "@main/services/python-rpc";
 
 const signOut = async (_event: Electron.IpcMainInvokeEvent) => {
   const databaseOperations = dataSource
@@ -32,7 +28,7 @@ const signOut = async (_event: Electron.IpcMainInvokeEvent) => {
   DownloadManager.cancelDownload();
 
   /* Disconnects libtorrent */
-  PythonInstance.killTorrent();
+  PythonRPC.kill();
 
   HydraApi.handleSignOut();
 

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

@@ -1,9 +1,6 @@
-import type { GameShop } from "@types";
-
 import { registerEvent } from "../register-event";
 import { HydraApi } from "@main/services";
-import { CatalogueCategory, steamUrlBuilder } from "@shared";
-import { steamGamesWorker } from "@main/workers";
+import { CatalogueCategory } from "@shared";
 
 const getCatalogue = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -14,26 +11,11 @@ const getCatalogue = async (
     skip: "0",
   });
 
-  const response = await HydraApi.get<{ objectId: string; shop: GameShop }[]>(
+  return HydraApi.get(
     `/catalogue/${category}?${params.toString()}`,
     {},
     { needsAuth: false }
   );
-
-  return Promise.all(
-    response.map(async (game) => {
-      const steamGame = await steamGamesWorker.run(Number(game.objectId), {
-        name: "getById",
-      });
-
-      return {
-        title: steamGame.name,
-        shop: game.shop,
-        cover: steamUrlBuilder.library(game.objectId),
-        objectId: game.objectId,
-      };
-    })
-  );
 };
 
 registerEvent("getCatalogue", getCatalogue);

src/main/events/catalogue/get-developers.ts

@@ -0,0 +1,10 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const getDevelopers = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>(`/catalogue/developers`, null, {
+    needsAuth: false,
+  });
+};
+
+registerEvent("getDevelopers", getDevelopers);

src/main/events/catalogue/get-games.ts

@@ -1,29 +0,0 @@
-import type { CatalogueEntry } from "@types";
-
-import { registerEvent } from "../register-event";
-import { HydraApi } from "@main/services";
-import { steamUrlBuilder } from "@shared";
-
-const getGames = async (
-  _event: Electron.IpcMainInvokeEvent,
-  take = 12,
-  skip = 0
-): Promise<CatalogueEntry[]> => {
-  const searchParams = new URLSearchParams({
-    take: take.toString(),
-    skip: skip.toString(),
-  });
-
-  const games = await HydraApi.get<CatalogueEntry[]>(
-    `/games/catalogue?${searchParams.toString()}`,
-    undefined,
-    { needsAuth: false }
-  );
-
-  return games.map((game) => ({
-    ...game,
-    cover: steamUrlBuilder.library(game.objectId),
-  }));
-};
-
-registerEvent("getGames", getGames);

src/main/events/catalogue/get-publishers.ts

@@ -0,0 +1,10 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const getPublishers = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>(`/catalogue/publishers`, null, {
+    needsAuth: false,
+  });
+};
+
+registerEvent("getPublishers", getPublishers);

src/main/events/catalogue/search-games.ts

@@ -1,23 +1,18 @@
+import type { CatalogueSearchPayload } from "@types";
 import { registerEvent } from "../register-event";
-import { convertSteamGameToCatalogueEntry } from "../helpers/search-games";
-import type { CatalogueEntry } from "@types";
 import { HydraApi } from "@main/services";
 
-const searchGamesEvent = async (
+const searchGames = async (
   _event: Electron.IpcMainInvokeEvent,
-  query: string
-): Promise<CatalogueEntry[]> => {
-  const games = await HydraApi.get<
-    { objectId: string; title: string; shop: string }[]
-  >("/games/search", { title: query, take: 12, skip: 0 }, { needsAuth: false });
-
-  return games.map((game) => {
-    return convertSteamGameToCatalogueEntry({
-      id: Number(game.objectId),
-      name: game.title,
-      clientIcon: null,
-    });
-  });
+  payload: CatalogueSearchPayload,
+  take: number,
+  skip: number
+) => {
+  return HydraApi.post(
+    "/catalogue/search",
+    { ...payload, take, skip },
+    { needsAuth: false }
+  );
 };
 
-registerEvent("searchGames", searchGamesEvent);
+registerEvent("searchGames", searchGames);

src/main/events/cloud-save/get-game-artifacts.ts

@@ -1,6 +1,7 @@
 import { HydraApi } from "@main/services";
 import { registerEvent } from "../register-event";
 import type { GameArtifact, GameShop } from "@types";
+import { SubscriptionRequiredError, UserNotLoggedInError } from "@shared";
 
 const getGameArtifacts = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -13,8 +14,20 @@ const getGameArtifacts = async (
   });
 
   return HydraApi.get<GameArtifact[]>(
-    `/profile/games/artifacts?${params.toString()}`
-  );
+    `/profile/games/artifacts?${params.toString()}`,
+    {},
+    { needsSubscription: true }
+  ).catch((err) => {
+    if (err instanceof SubscriptionRequiredError) {
+      return [];
+    }
+
+    if (err instanceof UserNotLoggedInError) {
+      return [];
+    }
+
+    throw err;
+  });
 };
 
 registerEvent("getGameArtifacts", getGameArtifacts);

src/main/events/cloud-save/upload-save-game.ts

@@ -89,7 +89,7 @@ const uploadSaveGame = async (
           "Content-Type": "application/tar",
         },
         onUploadProgress: (progressEvent) => {
-          console.log(progressEvent);
+          logger.log(progressEvent);
         },
       });
 

src/main/events/download-sources/delete-download-source.ts

@@ -1,9 +0,0 @@
-import { registerEvent } from "../register-event";
-import { knexClient } from "@main/knex-client";
-
-const deleteDownloadSource = async (
-  _event: Electron.IpcMainInvokeEvent,
-  id: number
-) => knexClient("download_source").where({ id }).delete();
-
-registerEvent("deleteDownloadSource", deleteDownloadSource);

src/main/events/download-sources/get-download-sources.ts

@@ -1,7 +0,0 @@
-import { registerEvent } from "../register-event";
-import { knexClient } from "@main/knex-client";
-
-const getDownloadSources = async (_event: Electron.IpcMainInvokeEvent) =>
-  knexClient.select("*").from("download_source");
-
-registerEvent("getDownloadSources", getDownloadSources);

src/main/events/download-sources/put-download-source.ts

@@ -0,0 +1,17 @@
+import { HydraApi } from "@main/services";
+import { registerEvent } from "../register-event";
+
+const putDownloadSource = async (
+  _event: Electron.IpcMainInvokeEvent,
+  objectIds: string[]
+) => {
+  return HydraApi.put<{ fingerprint: string }>(
+    "/download-sources",
+    {
+      objectIds,
+    },
+    { needsAuth: false }
+  );
+};
+
+registerEvent("putDownloadSource", putDownloadSource);

src/main/events/hardware/check-folder-write-permission.ts

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+
+import { registerEvent } from "../register-event";
+
+const checkFolderWritePermission = async (
+  _event: Electron.IpcMainInvokeEvent,
+  path: string
+) =>
+  new Promise((resolve) => {
+    fs.access(path, fs.constants.W_OK, (err) => {
+      resolve(!err);
+    });
+  });
+
+registerEvent("checkFolderWritePermission", checkFolderWritePermission);

src/main/events/hardware/get-disk-free-space.ts

@@ -1,10 +1,10 @@
-import checkDiskSpace from "check-disk-space";
+import disk from "diskusage";
 
 import { registerEvent } from "../register-event";
 
 const getDiskFreeSpace = async (
   _event: Electron.IpcMainInvokeEvent,
   path: string
-) => checkDiskSpace(path);
+) => disk.check(path);
 
 registerEvent("getDiskFreeSpace", getDiskFreeSpace);

src/main/events/helpers/search-games.ts

@@ -1,31 +0,0 @@
-import type { GameShop, CatalogueEntry, SteamGame } from "@types";
-
-import { steamGamesWorker } from "@main/workers";
-import { steamUrlBuilder } from "@shared";
-
-export interface SearchGamesArgs {
-  query?: string;
-  take?: number;
-  skip?: number;
-}
-
-export const convertSteamGameToCatalogueEntry = (
-  game: SteamGame
-): CatalogueEntry => ({
-  objectId: String(game.id),
-  title: game.name,
-  shop: "steam" as GameShop,
-  cover: steamUrlBuilder.library(String(game.id)),
-});
-
-export const getSteamGameById = async (
-  objectId: string
-): Promise<CatalogueEntry | null> => {
-  const steamGame = await steamGamesWorker.run(Number(objectId), {
-    name: "getById",
-  });
-
-  if (!steamGame) return null;
-
-  return convertSteamGameToCatalogueEntry(steamGame);
-};

src/main/events/index.ts

@@ -3,13 +3,15 @@ import { ipcMain } from "electron";
 
 import "./catalogue/get-catalogue";
 import "./catalogue/get-game-shop-details";
-import "./catalogue/get-games";
 import "./catalogue/get-how-long-to-beat";
 import "./catalogue/get-random-game";
 import "./catalogue/search-games";
 import "./catalogue/get-game-stats";
 import "./catalogue/get-trending-games";
+import "./catalogue/get-publishers";
+import "./catalogue/get-developers";
 import "./hardware/get-disk-free-space";
+import "./hardware/check-folder-write-permission";
 import "./library/add-game-to-library";
 import "./library/create-game-shortcut";
 import "./library/close-game";
@@ -21,6 +23,7 @@ import "./library/open-game-executable-path";
 import "./library/open-game-installer";
 import "./library/open-game-installer-path";
 import "./library/update-executable-path";
+import "./library/update-launch-options";
 import "./library/verify-executable-path";
 import "./library/remove-game";
 import "./library/remove-game-from-library";
@@ -29,18 +32,21 @@ import "./library/reset-game-achievements";
 import "./misc/open-checkout";
 import "./misc/open-external";
 import "./misc/show-open-dialog";
+import "./misc/get-features";
+import "./misc/show-item-in-folder";
 import "./torrenting/cancel-game-download";
 import "./torrenting/pause-game-download";
 import "./torrenting/resume-game-download";
 import "./torrenting/start-game-download";
+import "./torrenting/pause-game-seed";
+import "./torrenting/resume-game-seed";
 import "./user-preferences/get-user-preferences";
 import "./user-preferences/update-user-preferences";
 import "./user-preferences/auto-launch";
 import "./autoupdater/check-for-updates";
 import "./autoupdater/restart-and-install-update";
 import "./user-preferences/authenticate-real-debrid";
-import "./download-sources/delete-download-source";
-import "./download-sources/get-download-sources";
+import "./download-sources/put-download-source";
 import "./auth/sign-out";
 import "./auth/open-auth-window";
 import "./auth/get-session-hash";
@@ -69,7 +75,6 @@ import "./cloud-save/delete-game-artifact";
 import "./cloud-save/select-game-backup-path";
 import "./notifications/publish-new-repacks-notification";
 import { isPortableVersion } from "@main/helpers";
-import "./misc/show-item-in-folder";
 
 ipcMain.handle("ping", () => "pong");
 ipcMain.handle("getVersion", () => appVersion);

src/main/events/library/close-game.ts

@@ -1,8 +1,10 @@
 import { gameRepository } from "@main/repository";
 import { registerEvent } from "../register-event";
-import { PythonInstance, logger } from "@main/services";
+import { logger } from "@main/services";
 import sudo from "sudo-prompt";
 import { app } from "electron";
+import { PythonRPC } from "@main/services/python-rpc";
+import { ProcessPayload } from "@main/services/download/types";
 
 const getKillCommand = (pid: number) => {
   if (process.platform == "win32") {
@@ -16,7 +18,10 @@ const closeGame = async (
   _event: Electron.IpcMainInvokeEvent,
   gameId: number
 ) => {
-  const processes = await PythonInstance.getProcessList();
+  const processes =
+    (await PythonRPC.rpc.get<ProcessPayload[] | null>("/process-list")).data ||
+    [];
+
   const game = await gameRepository.findOne({
     where: { id: gameId, isDeleted: false },
   });

src/main/events/library/open-game.ts

@@ -7,11 +7,16 @@ import { parseExecutablePath } from "../helpers/parse-executable-path";
 const openGame = async (
   _event: Electron.IpcMainInvokeEvent,
   gameId: number,
-  executablePath: string
+  executablePath: string,
+  launchOptions: string | null
 ) => {
+  // TODO: revisit this for launchOptions
   const parsedPath = parseExecutablePath(executablePath);
 
-  await gameRepository.update({ id: gameId }, { executablePath: parsedPath });
+  await gameRepository.update(
+    { id: gameId },
+    { executablePath: parsedPath, launchOptions }
+  );
 
   shell.openPath(parsedPath);
 };

src/main/events/library/update-launch-options.ts

@@ -0,0 +1,19 @@
+import { gameRepository } from "@main/repository";
+import { registerEvent } from "../register-event";
+
+const updateLaunchOptions = async (
+  _event: Electron.IpcMainInvokeEvent,
+  id: number,
+  launchOptions: string | null
+) => {
+  return gameRepository.update(
+    {
+      id,
+    },
+    {
+      launchOptions: launchOptions?.trim() != "" ? launchOptions : null,
+    }
+  );
+};
+
+registerEvent("updateLaunchOptions", updateLaunchOptions);

src/main/events/misc/get-features.ts

@@ -0,0 +1,8 @@
+import { registerEvent } from "../register-event";
+import { HydraApi } from "@main/services";
+
+const getFeatures = async (_event: Electron.IpcMainInvokeEvent) => {
+  return HydraApi.get<string[]>("/features", null, { needsAuth: false });
+};
+
+registerEvent("getFeatures", getFeatures);

src/main/events/misc/open-checkout.ts

@@ -1,16 +1,10 @@
 import { shell } from "electron";
 import { registerEvent } from "../register-event";
-import {
-  userAuthRepository,
-  userPreferencesRepository,
-} from "@main/repository";
+import { userAuthRepository } from "@main/repository";
 import { HydraApi } from "@main/services";
 
 const openCheckout = async (_event: Electron.IpcMainInvokeEvent) => {
-  const [userAuth, userPreferences] = await Promise.all([
-    userAuthRepository.findOne({ where: { id: 1 } }),
-    userPreferencesRepository.findOne({ where: { id: 1 } }),
-  ]);
+  const userAuth = await userAuthRepository.findOne({ where: { id: 1 } });
 
   if (!userAuth) {
     return;
@@ -22,7 +16,6 @@ const openCheckout = async (_event: Electron.IpcMainInvokeEvent) => {
 
   const params = new URLSearchParams({
     token: paymentToken,
-    lng: userPreferences?.language || "en",
   });
 
   shell.openExternal(

src/main/events/profile/process-profile-image.ts

@@ -1,11 +1,16 @@
 import { registerEvent } from "../register-event";
-import { PythonInstance } from "@main/services";
+import { PythonRPC } from "@main/services/python-rpc";
 
 const processProfileImage = async (
   _event: Electron.IpcMainInvokeEvent,
   path: string
 ) => {
-  return PythonInstance.processProfileImage(path);
+  return PythonRPC.rpc
+    .post<{
+      imagePath: string;
+      mimeType: string;
+    }>("/profile-image", { image_path: path })
+    .then((response) => response.data);
 };
 
 registerEvent("processProfileImage", processProfileImage);

src/main/events/torrenting/pause-game-seed.ts

@@ -0,0 +1,17 @@
+import { registerEvent } from "../register-event";
+import { DownloadManager } from "@main/services";
+import { gameRepository } from "@main/repository";
+
+const pauseGameSeed = async (
+  _event: Electron.IpcMainInvokeEvent,
+  gameId: number
+) => {
+  await gameRepository.update(gameId, {
+    status: "complete",
+    shouldSeed: false,
+  });
+
+  await DownloadManager.pauseSeeding(gameId);
+};
+
+registerEvent("pauseGameSeed", pauseGameSeed);

src/main/events/torrenting/resume-game-seed.ts

@@ -0,0 +1,29 @@
+import { registerEvent } from "../register-event";
+import { gameRepository } from "../../repository";
+import { DownloadManager } from "@main/services";
+import { Downloader } from "@shared";
+
+const resumeGameSeed = async (
+  _event: Electron.IpcMainInvokeEvent,
+  gameId: number
+) => {
+  const game = await gameRepository.findOne({
+    where: {
+      id: gameId,
+      isDeleted: false,
+      downloader: Downloader.Torrent,
+      progress: 1,
+    },
+  });
+
+  if (!game) return;
+
+  await gameRepository.update(gameId, {
+    status: "seeding",
+    shouldSeed: true,
+  });
+
+  await DownloadManager.resumeSeeding(game);
+};
+
+registerEvent("resumeGameSeed", resumeGameSeed);

src/main/events/torrenting/start-game-download.ts

@@ -1,6 +1,6 @@
 import { registerEvent } from "../register-event";
 import type { StartGameDownloadPayload } from "@types";
-import { DownloadManager, HydraApi, logger } from "@main/services";
+import { DownloadManager, HydraApi } from "@main/services";
 
 import { Not } from "typeorm";
 import { steamGamesWorker } from "@main/workers";
@@ -76,24 +76,23 @@ const startGameDownload = async (
       },
     });
 
-    createGame(updatedGame!).catch(() => {});
-
-    HydraApi.post(
-      "/games/download",
-      {
-        objectId: updatedGame!.objectID,
-        shop: updatedGame!.shop,
-      },
-      { needsAuth: false }
-    ).catch((err) => {
-      logger.error("Failed to create game download", err);
-    });
-
     await DownloadManager.cancelDownload(updatedGame!.id);
     await DownloadManager.startDownload(updatedGame!);
 
     await downloadQueueRepository.delete({ game: { id: updatedGame!.id } });
     await downloadQueueRepository.insert({ game: { id: updatedGame!.id } });
+
+    await Promise.all([
+      createGame(updatedGame!).catch(() => {}),
+      HydraApi.post(
+        "/games/download",
+        {
+          objectId: updatedGame!.objectID,
+          shop: updatedGame!.shop,
+        },
+        { needsAuth: false }
+      ).catch(() => {}),
+    ]);
   });
 };
 

src/main/events/user-preferences/authenticate-real-debrid.ts

@@ -1,4 +1,4 @@
-import { RealDebridClient } from "@main/services/real-debrid";
+import { RealDebridClient } from "@main/services/download/real-debrid";
 import { registerEvent } from "../register-event";
 
 const authenticateRealDebrid = async (

src/main/events/user/get-compared-unlocked-achievements.ts

@@ -13,6 +13,9 @@ const getComparedUnlockedAchievements = async (
     where: { id: 1 },
   });
 
+  const showHiddenAchievementsDescription =
+    userPreferences?.showHiddenAchievementsDescription || false;
+
   return HydraApi.get<ComparedAchievements>(
     `/users/${userId}/games/achievements/compare`,
     {
@@ -21,15 +24,35 @@ const getComparedUnlockedAchievements = async (
       language: userPreferences?.language || "en",
     }
   ).then((achievements) => {
-    const sortedAchievements = achievements.achievements.sort((a, b) => {
-      if (a.targetStat.unlocked && !b.targetStat.unlocked) return -1;
-      if (!a.targetStat.unlocked && b.targetStat.unlocked) return 1;
-      if (a.targetStat.unlocked && b.targetStat.unlocked) {
-        return b.targetStat.unlockTime! - a.targetStat.unlockTime!;
-      }
+    const sortedAchievements = achievements.achievements
+      .sort((a, b) => {
+        if (a.targetStat.unlocked && !b.targetStat.unlocked) return -1;
+        if (!a.targetStat.unlocked && b.targetStat.unlocked) return 1;
+        if (a.targetStat.unlocked && b.targetStat.unlocked) {
+          return b.targetStat.unlockTime! - a.targetStat.unlockTime!;
+        }
 
-      return Number(a.hidden) - Number(b.hidden);
-    });
+        return Number(a.hidden) - Number(b.hidden);
+      })
+      .map((achievement) => {
+        if (!achievement.hidden) return achievement;
+
+        if (!achievement.ownerStat) {
+          return {
+            ...achievement,
+            description: "",
+          };
+        }
+
+        if (!showHiddenAchievementsDescription && achievement.hidden) {
+          return {
+            ...achievement,
+            description: "",
+          };
+        }
+
+        return achievement;
+      });
 
     return {
       ...achievements,

src/main/events/user/get-unlocked-achievements.ts

@@ -1,6 +1,9 @@
 import type { GameShop, UnlockedAchievement, UserAchievement } from "@types";
 import { registerEvent } from "../register-event";
-import { gameAchievementRepository } from "@main/repository";
+import {
+  gameAchievementRepository,
+  userPreferencesRepository,
+} from "@main/repository";
 import { getGameAchievementData } from "@main/services/achievements/get-game-achievement-data";
 
 export const getUnlockedAchievements = async (
@@ -12,10 +15,17 @@ export const getUnlockedAchievements = async (
     where: { objectId, shop },
   });
 
+  const userPreferences = await userPreferencesRepository.findOne({
+    where: { id: 1 },
+  });
+
+  const showHiddenAchievementsDescription =
+    userPreferences?.showHiddenAchievementsDescription || false;
+
   const achievementsData = await getGameAchievementData(
     objectId,
     shop,
-    useCachedData
+    useCachedData ? cachedAchievements : null
   );
 
   const unlockedAchievements = JSON.parse(
@@ -50,6 +60,10 @@ export const getUnlockedAchievements = async (
         unlocked: false,
         unlockTime: null,
         icongray: icongray,
+        description:
+          !achievementData.hidden || showHiddenAchievementsDescription
+            ? achievementData.description
+            : undefined,
       } as UserAchievement;
     })
     .sort((a, b) => {

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

@@ -11,7 +11,7 @@ const getSteamGame = async (objectId: string) => {
     });
 
     return {
-      title: steamGame.name,
+      title: steamGame.name as string,
       iconUrl: steamUrlBuilder.icon(objectId, steamGame.clientIcon),
     };
   } catch (err) {
@@ -67,8 +67,25 @@ const getUser = async (
       }
     }
 
+    const friends = await Promise.all(
+      profile.friends.map(async (friend) => {
+        if (!friend.currentGame) return friend;
+
+        const currentGame = await getSteamGame(friend.currentGame.objectId);
+
+        return {
+          ...friend,
+          currentGame: {
+            ...friend.currentGame,
+            ...currentGame,
+          },
+        };
+      })
+    );
+
     return {
       ...profile,
+      friends,
       libraryGames,
       recentGames,
     };