feat: fixing download error for gofile

src/main/events/index.ts

@@ -45,7 +45,7 @@ import "./auth/sign-out";
 import "./auth/open-auth-window";
 import "./auth/get-session-hash";
 import "./user/get-user";
-import "./user/get-user-blocks";
+import "./user/get-blocked-users";
 import "./user/block-user";
 import "./user/unblock-user";
 import "./user/get-user-friends";

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

@@ -1,9 +1,3 @@
-import {
-  downloadQueueRepository,
-  gameRepository,
-  repackRepository,
-} from "@main/repository";
-
 import { registerEvent } from "../register-event";
 
 import type { StartGameDownloadPayload } from "@types";
@@ -14,6 +8,8 @@ import { Not } from "typeorm";
 import { steamGamesWorker } from "@main/workers";
 import { createGame } from "@main/services/library-sync";
 import { steamUrlBuilder } from "@shared";
+import { dataSource } from "@main/data-source";
+import { DownloadQueue, Game, Repack } from "@main/entity";
 
 const startGameDownload = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -22,88 +18,95 @@ const startGameDownload = async (
   const { repackId, objectID, title, shop, downloadPath, downloader, uri } =
     payload;
 
-  const [game, repack] = await Promise.all([
-    gameRepository.findOne({
+  return dataSource.transaction(async (transactionalEntityManager) => {
+    const gameRepository = transactionalEntityManager.getRepository(Game);
+    const repackRepository = transactionalEntityManager.getRepository(Repack);
+    const downloadQueueRepository =
+      transactionalEntityManager.getRepository(DownloadQueue);
+
+    const [game, repack] = await Promise.all([
+      gameRepository.findOne({
+        where: {
+          objectID,
+          shop,
+        },
+      }),
+      repackRepository.findOne({
+        where: {
+          id: repackId,
+        },
+      }),
+    ]);
+
+    if (!repack) return;
+
+    await DownloadManager.pauseDownload();
+
+    await gameRepository.update(
+      { status: "active", progress: Not(1) },
+      { status: "paused" }
+    );
+
+    if (game) {
+      await gameRepository.update(
+        {
+          id: game.id,
+        },
+        {
+          status: "active",
+          progress: 0,
+          bytesDownloaded: 0,
+          downloadPath,
+          downloader,
+          uri,
+          isDeleted: false,
+        }
+      );
+    } else {
+      const steamGame = await steamGamesWorker.run(Number(objectID), {
+        name: "getById",
+      });
+
+      const iconUrl = steamGame?.clientIcon
+        ? steamUrlBuilder.icon(objectID, steamGame.clientIcon)
+        : null;
+
+      await gameRepository
+        .insert({
+          title,
+          iconUrl,
+          objectID,
+          downloader,
+          shop,
+          status: "active",
+          downloadPath,
+          uri,
+        })
+        .then((result) => {
+          if (iconUrl) {
+            getFileBase64(iconUrl).then((base64) =>
+              gameRepository.update({ objectID }, { iconUrl: base64 })
+            );
+          }
+
+          return result;
+        });
+    }
+
+    const updatedGame = await gameRepository.findOne({
       where: {
         objectID,
-        shop,
       },
-    }),
-    repackRepository.findOne({
-      where: {
-        id: repackId,
-      },
-    }),
-  ]);
-
-  if (!repack) return;
-
-  await DownloadManager.pauseDownload();
-
-  await gameRepository.update(
-    { status: "active", progress: Not(1) },
-    { status: "paused" }
-  );
-
-  if (game) {
-    await gameRepository.update(
-      {
-        id: game.id,
-      },
-      {
-        status: "active",
-        progress: 0,
-        bytesDownloaded: 0,
-        downloadPath,
-        downloader,
-        uri,
-        isDeleted: false,
-      }
-    );
-  } else {
-    const steamGame = await steamGamesWorker.run(Number(objectID), {
-      name: "getById",
     });
 
-    const iconUrl = steamGame?.clientIcon
-      ? steamUrlBuilder.icon(objectID, steamGame.clientIcon)
-      : null;
+    createGame(updatedGame!).catch(() => {});
 
-    await gameRepository
-      .insert({
-        title,
-        iconUrl,
-        objectID,
-        downloader,
-        shop,
-        status: "active",
-        downloadPath,
-        uri,
-      })
-      .then((result) => {
-        if (iconUrl) {
-          getFileBase64(iconUrl).then((base64) =>
-            gameRepository.update({ objectID }, { iconUrl: base64 })
-          );
-        }
+    await DownloadManager.cancelDownload(updatedGame!.id);
+    await DownloadManager.startDownload(updatedGame!);
 
-        return result;
-      });
-  }
-
-  const updatedGame = await gameRepository.findOne({
-    where: {
-      objectID,
-    },
+    await downloadQueueRepository.delete({ game: { id: updatedGame!.id } });
+    await downloadQueueRepository.insert({ game: { id: updatedGame!.id } });
   });
-
-  createGame(updatedGame!).catch(() => {});
-
-  await downloadQueueRepository.delete({ game: { id: updatedGame!.id } });
-  await downloadQueueRepository.insert({ game: { id: updatedGame!.id } });
-
-  await DownloadManager.cancelDownload(updatedGame!.id);
-  await DownloadManager.startDownload(updatedGame!);
 };
 
 registerEvent("startGameDownload", startGameDownload);

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

@@ -2,7 +2,7 @@ import { registerEvent } from "../register-event";
 import { HydraApi } from "@main/services";
 import { UserBlocks } from "@types";
 
-export const getUserBlocks = async (
+export const getBlockedUsers = async (
   _event: Electron.IpcMainInvokeEvent,
   take: number,
   skip: number
@@ -10,4 +10,4 @@ export const getUserBlocks = async (
   return HydraApi.get(`/profile/blocks`, { take, skip });
 };
 
-registerEvent("getUserBlocks", getUserBlocks);
+registerEvent("getBlockedUsers", getBlockedUsers);