feat: saving achievements on open launcher

src/main/entity/game-achievements.entity.ts

@@ -16,6 +16,9 @@ export class GameAchievement {
   @JoinColumn()
   game: Game;
 
+  @Column("text", { nullable: true })
+  unlockedAchievements: string;
+
   @Column("text", { nullable: true })
   achievements: string;
 }

src/main/events/achievements/services/get-game-achievements-to-watch.ts

@@ -22,7 +22,9 @@ export const getGameAchievementsToWatch = async (
   const steamId = Number(game.objectID);
 
   const achievements = await steamGetAchivement(game);
+
   console.log(achievements);
+
   if (!achievements || !achievements.length) return;
 
   const achievementFiles = steamFindGameAchievementFiles(game.objectID)[
@@ -50,7 +52,7 @@ export const getGameAchievementsToWatch = async (
         game: { id: gameId },
       },
       {
-        achievements: JSON.stringify(checkedAchievements.all),
+        unlockedAchievements: JSON.stringify(checkedAchievements.all),
       }
     );
   }

src/main/events/achievements/services/save-all-local-steam-achivements.ts

@@ -1,11 +1,7 @@
 import { gameAchievementRepository, gameRepository } from "@main/repository";
 import { steamFindGameAchievementFiles } from "../steam/steam-find-game-achivement-files";
-import { steamGlobalAchievementPercentages } from "../steam/steam-global-achievement-percentages";
-import { steamAchievementInfo } from "../steam/steam-achievement-info";
-import { steamAchievementMerge } from "../steam/steam-achievement-merge";
 import { parseAchievementFile } from "../util/parseAchievementFile";
-import { checkUnlockedAchievements } from "../util/check-unlocked-achievements";
+import { HydraApi } from "@main/services";
-import { CheckedAchievements } from "../types";
 
 export const saveAllLocalSteamAchivements = async () => {
   const gameAchievementFiles = steamFindGameAchievementFiles();
@@ -19,56 +15,56 @@ export const saveAllLocalSteamAchivements = async () => {
 
     if (!game) continue;
 
-    const hasOnDb = await gameAchievementRepository.existsBy({
+    const savedGameAchievements = await gameAchievementRepository.findOneBy({
       game: game,
     });
 
-    if (hasOnDb) continue;
+    if (!savedGameAchievements || !savedGameAchievements.achievements) {
-
+      HydraApi.get(
-    const achievementPercentage =
+        "/games/achievements",
-      await steamGlobalAchievementPercentages(objectId);
+        {
-
+          shop: "steam",
-    if (!achievementPercentage) {
+          objectId,
-      await gameAchievementRepository.save({
+        },
-        game,
+        { needsAuth: false }
-        achievements: "[]",
+      )
-      });
+        .then((achievements) => {
-      continue;
+          return gameAchievementRepository.upsert(
+            {
+              game: { id: game.id },
+              achievements: JSON.stringify(achievements),
+            },
+            ["game"]
+          );
+        })
+        .catch(console.log);
     }
 
-    const achievementInfo = await steamAchievementInfo(objectId);
+    const unlockedAchievements: { name: string; unlockTime: number }[] = [];
-
-    if (!achievementInfo) continue;
-
-    const achievements = steamAchievementMerge(
-      achievementPercentage,
-      achievementInfo
-    );
-
-    if (!achievements) continue;
-
-    const checkedAchievements: CheckedAchievements = {
-      all: achievements,
-      new: [],
-    };
 
     for (const achievementFile of gameAchievementFiles[key]) {
       const localAchievementFile = await parseAchievementFile(
         achievementFile.filePath
       );
 
-      checkedAchievements.new.push(
+      console.log(achievementFile.filePath);
-        ...checkUnlockedAchievements(
+      console.log(localAchievementFile);
-          achievementFile.type,
-          localAchievementFile,
-          achievements
-        ).new
-      );
-    }
 
-    await gameAchievementRepository.save({
+      for (const a of Object.keys(localAchievementFile)) {
-      game,
+        // TODO: use checkUnlockedAchievements after refactoring it to be generic
-      achievements: JSON.stringify(checkedAchievements.all),
+        unlockedAchievements.push({
+          name: a,
+          unlockTime: localAchievementFile[a].UnlockTime,
         });
       }
+    }
+
+    await gameAchievementRepository.upsert(
+      {
+        game: { id: game.id },
+        unlockedAchievements: JSON.stringify(unlockedAchievements),
+      },
+      ["game"]
+    );
+  }
 };

src/main/events/achievements/steam/steam-find-game-achivement-files.ts

@@ -1,21 +1,21 @@
 import path from "node:path";
-import { existsSync, readdirSync } from "node:fs";
+import fs from "node:fs";
 import { Cracker, GameAchievementFiles } from "../types";
 import { app } from "electron";
 
 const addGame = (
   achievementFiles: GameAchievementFiles,
-  gamePath: string,
+  achievementPath: string,
   objectId: string,
   fileLocation: string[],
   type: Cracker
 ) => {
-  const filePath = path.join(gamePath, objectId, ...fileLocation);
+  const filePath = path.join(achievementPath, objectId, ...fileLocation);
 
-  if (existsSync(filePath)) {
+  if (fs.existsSync(filePath)) {
     const achivementFile = {
       type,
-      filePath: filePath,
+      filePath,
     };
 
     achievementFiles[objectId]
@@ -33,7 +33,7 @@ export const steamFindGameAchievementFiles = (
 
   const gameAchievementFiles: GameAchievementFiles = {};
 
-  const crackers: Cracker[] = [
+  const crackers = [
     Cracker.codex,
     Cracker.goldberg,
     Cracker.rune,
@@ -55,9 +55,9 @@ export const steamFindGameAchievementFiles = (
       fileLocation = ["achievements.ini"];
     }
 
-    if (!existsSync(achievementPath)) continue;
+    if (!fs.existsSync(achievementPath)) continue;
 
-    const objectIds = readdirSync(achievementPath);
+    const objectIds = fs.readdirSync(achievementPath);
 
     if (objectId) {
       if (objectIds.includes(objectId)) {

src/main/events/achievements/util/parseAchievementFile.ts

@@ -25,7 +25,7 @@ const iniParse = async (filePath: string) => {
     });
 
     let objectName = "";
-    const object: any = {};
+    const object: Record<string, Record<string, string | number>> = {};
 
     for await (const line of lines) {
       if (line.startsWith("###") || !line.length) continue;

src/main/main.ts

@@ -16,6 +16,7 @@ import { publishNewRepacksNotifications } from "./services/notifications";
 import { MoreThan } from "typeorm";
 import { HydraApi } from "./services/hydra-api";
 import { uploadGamesBatch } from "./services/library-sync";
+import { saveAllLocalSteamAchivements } from "./events/achievements/services/save-all-local-steam-achivements";
 
 const loadState = async (userPreferences: UserPreferences | null) => {
   RepacksManager.updateRepacks();
@@ -58,6 +59,8 @@ const loadState = async (userPreferences: UserPreferences | null) => {
 
     if (newRepacksCount > 0) publishNewRepacksNotifications(newRepacksCount);
   });
+
+  saveAllLocalSteamAchivements();
 };
 
 userPreferencesRepository

src/main/migrations/20240919030940_create_game_achievement.ts

@@ -3,16 +3,17 @@ import type { Knex } from "knex";
 
 export const CreateGameAchievement: HydraMigration = {
   name: "CreateGameAchievement",
-  up: async (knex: Knex) => {
+  up: (knex: Knex) => {
-    await knex.schema.createTable("game_achievement", (table) => {
+    return knex.schema.createTable("game_achievement", (table) => {
       table.increments("id").primary();
-      table.integer("gameId").notNullable();
+      table.integer("gameId").notNullable().unique();
       table.text("achievements");
+      table.text("unlockedAchievements");
       table.foreign("gameId").references("game.id").onDelete("CASCADE");
     });
   },
 
-  down: async (knex: Knex) => {
+  down: (knex: Knex) => {
-    await knex.schema.dropTable("game_achievement");
+    return knex.schema.dropTable("game_achievement");
   },
 };