MongoDB ile TV dizileri için CRUD işlemleri eklendi

server/modules/tvDataStore.js

@@ -0,0 +1,74 @@
+import { connectMongo } from "./db.js";
+
+const COLLECTION = "tv_data";
+
+async function getCollection() {
+  const { db } = await connectMongo();
+  const col = db.collection(COLLECTION);
+  await col.createIndex({ rootFolder: 1 });
+  await col.createIndex({ tvdbId: 1 });
+  await col.createIndex({ updatedAt: -1 });
+  return col;
+}
+
+function buildDocument(key, rootFolder, seriesData) {
+  const tvdbId = seriesData?.id ?? seriesData?.tvdbId ?? null;
+  return {
+    _id: key,
+    key,
+    rootFolder,
+    tvdbId,
+    name: seriesData?.name || null,
+    data: seriesData || {},
+    updatedAt: Date.now()
+  };
+}
+
+export async function upsertTvSeries(key, rootFolder, seriesData) {
+  const col = await getCollection();
+  const doc = buildDocument(key, rootFolder, seriesData);
+  await col.updateOne({ _id: key }, { $set: doc }, { upsert: true });
+  return doc.data;
+}
+
+export async function getTvSeriesByKey(key) {
+  const col = await getCollection();
+  const doc = await col.findOne({ _id: key });
+  return doc?.data || null;
+}
+
+export async function getTvSeriesByRoot(rootFolder) {
+  const col = await getCollection();
+  const docs = await col.find({ rootFolder }).toArray();
+  return docs.map((doc) => ({
+    key: doc.key,
+    rootFolder: doc.rootFolder,
+    data: doc.data
+  }));
+}
+
+export async function listAllTvSeries() {
+  const col = await getCollection();
+  const docs = await col.find({}).toArray();
+  return docs.map((doc) => ({
+    key: doc.key,
+    rootFolder: doc.rootFolder,
+    data: doc.data
+  }));
+}
+
+export async function listTvSeriesKeysForRoot(rootFolder) {
+  const col = await getCollection();
+  const docs = await col.find({ rootFolder }).project({ key: 1 }).toArray();
+  return docs.map((d) => d.key).filter(Boolean);
+}
+
+export async function removeTvSeriesByKey(key) {
+  const col = await getCollection();
+  await col.deleteOne({ _id: key });
+}
+
+export async function removeTvSeriesByRoot(rootFolder) {
+  const col = await getCollection();
+  await col.deleteMany({ rootFolder });
+}

server/server.js

@@ -14,6 +14,13 @@ import { buildHealthReport, healthRouter } from "./modules/health.js";
 import { restoreTorrentsFromDisk } from "./modules/state.js";
 import { createWebsocketServer, broadcastJson } from "./modules/websocket.js";
 import { connectMongo, getDb } from "./modules/db.js";
+import {
+  getTvSeriesByKey as loadTvSeriesByKey,
+  listAllTvSeries as listAllTvSeriesFromDb,
+  removeTvSeriesByKey,
+  removeTvSeriesByRoot,
+  upsertTvSeries
+} from "./modules/tvDataStore.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -2739,41 +2746,49 @@ async function ensureSeriesData(
   const normalizedRoot = sanitizeRelative(rootFolder);
   const normalizedFile = normalizeTrashPath(relativeFilePath);
 
-  const candidateKeys = listTvSeriesKeysForRoot(normalizedRoot);
+  const candidateKeys = await listTvSeriesKeysForRoot(normalizedRoot);
   let seriesData = null;
   let existingPaths = null;
 
   for (const key of candidateKeys) {
     const candidatePaths = tvSeriesPathsByKey(key);
-    if (!fs.existsSync(candidatePaths.metadata)) continue;
+    let data = null;
     try {
-      const data = JSON.parse(fs.readFileSync(candidatePaths.metadata, "utf-8")) || {};
+      data = await loadTvSeriesByKey(key);
-      const seasons = data?.seasons || {};
-      const matchesEpisode = Object.values(seasons).some((season) =>
-        season?.episodes &&
-        Object.values(season.episodes).some((episode) => episode?.file === normalizedFile)
-      );
-      if (matchesEpisode) {
-        seriesData = data;
-        existingPaths = candidatePaths;
-        break;
-      }
     } catch (err) {
-      console.warn(
+      console.warn(`⚠️ TV metadata okunamadı (db - ${key}): ${err.message}`);
-        `⚠️ series.json okunamadı (${candidatePaths.metadata}): ${err.message}`
-      );
     }
-  }
 
-  const legacyPaths = tvSeriesPaths(normalizedRoot);
+    // Fallback: eski dosya varsa bir kere oku ve Mongo'ya yaz
-  if (!seriesData && fs.existsSync(legacyPaths.metadata)) {
+    if (!data && fs.existsSync(candidatePaths.metadata)) {
-    try {
+      try {
-      seriesData = JSON.parse(fs.readFileSync(legacyPaths.metadata, "utf-8")) || {};
+        data = JSON.parse(fs.readFileSync(candidatePaths.metadata, "utf-8")) || {};
-      existingPaths = legacyPaths;
+        await upsertTvSeries(key, candidatePaths.rootFolder, data);
-    } catch (err) {
+        try {
-      console.warn(
+          fs.rmSync(candidatePaths.metadata, { force: true });
-        `⚠️ series.json okunamadı (${legacyPaths.metadata}): ${err.message}`
+        } catch {
-      );
+          /* no-op */
+        }
+      } catch (err) {
+        console.warn(
+          `⚠️ series.json okunamadı (${candidatePaths.metadata}): ${err.message}`
+        );
+      }
+    }
+
+    if (!data) continue;
+    const seasons = data?.seasons || {};
+    const matchesEpisode = Object.values(seasons).some(
+      (season) =>
+        season?.episodes &&
+        Object.values(season.episodes).some(
+          (episode) => episode?.file === normalizedFile
+        )
+    );
+    if (matchesEpisode) {
+      seriesData = data;
+      existingPaths = candidatePaths;
+      break;
     }
   }
 
@@ -3167,7 +3182,13 @@ async function ensureSeriesData(
   seasonContainer.updatedAt = Date.now();
 
   ensureDirForFile(seriesMetaPath);
-  fs.writeFileSync(seriesMetaPath, JSON.stringify(seriesData, null, 2), "utf-8");
+  try {
+    await upsertTvSeries(targetPaths.key, normalizedRoot, seriesData);
+  } catch (err) {
+    console.warn(
+      `⚠️ TV metadata kaydedilemedi (db - ${targetPaths.key}): ${err.message}`
+    );
+  }
 
   if (
     existingPaths &&
@@ -3326,6 +3347,9 @@ function removeSeriesData(rootFolder, seriesId = null) {
     ? [tvSeriesKey(rootFolder, seriesId)].filter(Boolean)
     : listTvSeriesKeysForRoot(rootFolder);
   for (const key of keys) {
+    removeTvSeriesByKey(key).catch((err) =>
+      console.warn(`⚠️ TV metadata silinemedi (db - ${key}): ${err.message}`)
+    );
     const dir = tvSeriesDir(key);
     if (dir && fs.existsSync(dir)) {
       try {
@@ -3344,74 +3368,110 @@ function removeSeriesEpisode(rootFolder, relativeFilePath) {
   const keys = listTvSeriesKeysForRoot(rootFolder);
   if (!keys.length) return;
 
-  for (const key of keys) {
+  (async () => {
-    const paths = tvSeriesPathsByKey(key);
+    for (const key of keys) {
-    if (!fs.existsSync(paths.metadata)) continue;
+      const paths = tvSeriesPathsByKey(key);
 
-    let seriesData;
+      let seriesData;
-    try {
+      try {
-      seriesData = JSON.parse(fs.readFileSync(paths.metadata, "utf-8"));
+        seriesData = await loadTvSeriesByKey(key);
-    } catch (err) {
+      } catch (err) {
-      console.warn(
+        console.warn(`⚠️ TV metadata okunamadı (db - ${key}): ${err.message}`);
-        `⚠️ series.json okunamadı (${paths.metadata}): ${err.message}`
+        continue;
-      );
+      }
-      continue;
+      if (!seriesData) continue;
-    }
 
-    const seasons = seriesData?.seasons || {};
+      const seasons = seriesData?.seasons || {};
-    let removed = false;
+      let removed = false;
 
-    for (const [seasonKey, season] of Object.entries(seasons)) {
+      for (const [seasonKey, season] of Object.entries(seasons)) {
-      if (!season?.episodes) continue;
+        if (!season?.episodes) continue;
 
-      let seasonChanged = false;
+        let seasonChanged = false;
-      for (const episodeKey of Object.keys(season.episodes)) {
+        for (const episodeKey of Object.keys(season.episodes)) {
-        const episode = season.episodes[episodeKey];
+          const episode = season.episodes[episodeKey];
-        if (episode?.file === relativeFilePath) {
+          if (episode?.file === relativeFilePath) {
-          delete season.episodes[episodeKey];
+            delete season.episodes[episodeKey];
-          seasonChanged = true;
+            seasonChanged = true;
-          removed = true;
+            removed = true;
+          }
+        }
+
+        if (
+          seasonChanged &&
+          (!season.episodes || Object.keys(season.episodes).length === 0)
+        ) {
+          delete seasons[seasonKey];
         }
       }
 
-      if (
+      if (!removed) continue;
-        seasonChanged &&
+
-        (!season.episodes || Object.keys(season.episodes).length === 0)
+      if (!Object.keys(seasons).length) {
-      ) {
+        removeSeriesData(seriesData._dupe?.folder || rootFolder, seriesData.id);
-        delete seasons[seasonKey];
+        continue;
+      }
+
+      seriesData.seasons = seasons;
+      seriesData.updatedAt = Date.now();
+
+      try {
+        await upsertTvSeries(key, paths.rootFolder, seriesData);
+      } catch (err) {
+        console.warn(
+          `⚠️ TV metadata güncellenemedi (db - ${key}): ${err.message}`
+        );
+      }
+
+      try {
+        const seasonDirs = [paths.episodesDir, paths.seasonsDir];
+        for (const dir of seasonDirs) {
+          if (!dir || !fs.existsSync(dir)) continue;
+          cleanupEmptyDirs(dir);
+        }
+      } catch (err) {
+        console.warn(
+          `⚠️ TV metadata klasörü temizlenemedi (${paths.dir}): ${err.message}`
+        );
       }
     }
+  })().catch((err) =>
+    console.warn(
+      `⚠️ TV bölümü silme işlemi tamamlanamadı (${rootFolder}/${relativeFilePath}): ${err.message}`
+    )
+  );
+}
 
-    if (!removed) continue;
+async function importLegacySeriesMetadata() {
+  if (!fs.existsSync(TV_DATA_ROOT)) return 0;
+  let imported = 0;
+  const dirEntries = fs
+    .readdirSync(TV_DATA_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory());
 
-    if (!Object.keys(seasons).length) {
+  for (const dirent of dirEntries) {
-      removeSeriesData(seriesData._dupe?.folder || rootFolder, seriesData.id);
+    const key = sanitizeRelative(dirent.name);
-      continue;
+    if (!key) continue;
-    }
+    const paths = tvSeriesPathsByKey(key);
-
+    if (!fs.existsSync(paths.metadata)) continue;
-    seriesData.seasons = seasons;
-    seriesData.updatedAt = Date.now();
 
     try {
-      fs.writeFileSync(paths.metadata, JSON.stringify(seriesData, null, 2), "utf-8");
+      const data = JSON.parse(fs.readFileSync(paths.metadata, "utf-8")) || {};
-    } catch (err) {
+      await upsertTvSeries(key, paths.rootFolder, data);
-      console.warn(
+      imported += 1;
-        `⚠️ series.json güncellenemedi (${paths.metadata}): ${err.message}`
+      try {
-      );
+        fs.rmSync(paths.metadata, { force: true });
-    }
+      } catch {
-
+        /* no-op */
-    try {
-      const seasonDirs = [paths.episodesDir, paths.seasonsDir];
-      for (const dir of seasonDirs) {
-        if (!dir || !fs.existsSync(dir)) continue;
-        cleanupEmptyDirs(dir);
       }
     } catch (err) {
       console.warn(
-        `⚠️ TV metadata klasörü temizlenemedi (${paths.dir}): ${err.message}`
+        `⚠️ Legacy series.json içeri aktarılamadı (${paths.metadata}): ${err.message}`
       );
     }
   }
+
+  return imported;
 }
 
 function purgeRootFolder(rootFolder) {
@@ -3755,66 +3815,73 @@ function renameSeriesDataPaths(rootFolder, oldRel, newRel) {
   if (!oldPrefix || oldPrefix === newPrefix) return;
 
   const keys = listTvSeriesKeysForRoot(rootFolder);
-  for (const key of keys) {
+  if (!keys.length) return;
-    const metadataPath = tvSeriesPathsByKey(key).metadata;
-    if (!fs.existsSync(metadataPath)) continue;
 
-    let seriesData;
+  (async () => {
-    try {
+    for (const key of keys) {
-      seriesData = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
+      const paths = tvSeriesPathsByKey(key);
-    } catch (err) {
+      let seriesData;
-      console.warn(`⚠️ series.json okunamadı (${metadataPath}): ${err.message}`);
-      continue;
-    }
-
-    const transform = (value) => {
-      const normalized = normalizeTrashPath(value);
-      if (
-        normalized === oldPrefix ||
-        normalized.startsWith(`${oldPrefix}/`)
-      ) {
-      const suffix = normalized.slice(oldPrefix.length).replace(/^\/+/, "");
-      return newPrefix
-        ? `${newPrefix}${suffix ? `/${suffix}` : ""}`
-        : suffix;
-    }
-    return value;
-  };
-
-    let changed = false;
-
-    const seasons = seriesData?.seasons || {};
-    for (const season of Object.values(seasons)) {
-      if (!season?.episodes) continue;
-      for (const episode of Object.values(season.episodes)) {
-        if (!episode || typeof episode !== "object") continue;
-        if (episode.file) {
-          const nextFile = transform(episode.file);
-          if (nextFile !== episode.file) {
-            episode.file = nextFile;
-            changed = true;
-          }
-        }
-        if (episode.videoPath) {
-          const nextVideo = transform(episode.videoPath);
-          if (nextVideo !== episode.videoPath) {
-            episode.videoPath = nextVideo;
-            changed = true;
-          }
-        }
-      }
-    }
-
-    if (changed) {
       try {
-        fs.writeFileSync(metadataPath, JSON.stringify(seriesData, null, 2), "utf-8");
+        seriesData = await loadTvSeriesByKey(key);
       } catch (err) {
-        console.warn(
+        console.warn(`⚠️ TV metadata okunamadı (db - ${key}): ${err.message}`);
-          `⚠️ series.json güncellenemedi (${metadataPath}): ${err.message}`
+        continue;
-        );
+      }
+      if (!seriesData) continue;
+
+      const transform = (value) => {
+        const normalized = normalizeTrashPath(value);
+        if (
+          normalized === oldPrefix ||
+          normalized.startsWith(`${oldPrefix}/`)
+        ) {
+          const suffix = normalized.slice(oldPrefix.length).replace(/^\/+/, "");
+          return newPrefix
+            ? `${newPrefix}${suffix ? `/${suffix}` : ""}`
+            : suffix;
+        }
+        return value;
+      };
+
+      let changed = false;
+
+      const seasons = seriesData?.seasons || {};
+      for (const season of Object.values(seasons)) {
+        if (!season?.episodes) continue;
+        for (const episode of Object.values(season.episodes)) {
+          if (!episode || typeof episode !== "object") continue;
+          if (episode.file) {
+            const nextFile = transform(episode.file);
+            if (nextFile !== episode.file) {
+              episode.file = nextFile;
+              changed = true;
+            }
+          }
+          if (episode.videoPath) {
+            const nextVideo = transform(episode.videoPath);
+            if (nextVideo !== episode.videoPath) {
+              episode.videoPath = nextVideo;
+              changed = true;
+            }
+          }
+        }
+      }
+
+      if (changed) {
+        try {
+          await upsertTvSeries(key, paths.rootFolder, seriesData);
+        } catch (err) {
+          console.warn(
+            `⚠️ TV metadata güncellenemedi (db - ${key}): ${err.message}`
+          );
+        }
       }
     }
-  }
+  })().catch((err) =>
+    console.warn(
+      `⚠️ TV metadata yeniden adlandırma tamamlanamadı (${rootFolder}): ${err.message}`
+    )
+  );
 }
 
 function removeThumbnailsForDirectory(rootFolder, relativeDir) {
@@ -5818,16 +5885,19 @@ app.post("/api/youtube/download", requireAuth, async (req, res) => {
 });
 
 // --- 📺 TV dizileri listesi ---
-app.get("/api/tvshows", requireAuth, (req, res) => {
+app.get("/api/tvshows", requireAuth, async (req, res) => {
   try {
-    if (!fs.existsSync(TV_DATA_ROOT)) {
+    let seriesDocs = await listAllTvSeriesFromDb();
+    if (!seriesDocs || !seriesDocs.length) {
+      const migrated = await importLegacySeriesMetadata();
+      if (migrated > 0) {
+        seriesDocs = await listAllTvSeriesFromDb();
+      }
+    }
+    if (!seriesDocs || !seriesDocs.length) {
       return res.json([]);
     }
 
-    const dirEntries = fs
-      .readdirSync(TV_DATA_ROOT, { withFileTypes: true })
-      .filter((d) => d.isDirectory());
-
     const aggregated = new Map();
 
     const mergeEpisode = (existing, incoming) => {
@@ -5847,12 +5917,12 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
       return merged;
     };
 
-    for (const dirent of dirEntries) {
+    for (const doc of seriesDocs) {
-      const key = sanitizeRelative(dirent.name);
+      const key = sanitizeRelative(doc.key);
       if (!key) continue;
       const paths = tvSeriesPathsByKey(key);
-      if (!paths || !fs.existsSync(paths.metadata)) continue;
+      const parsed = parseTvSeriesKey(key);
-      const { rootFolder } = parseTvSeriesKey(key);
+      const rootFolder = parsed.rootFolder || doc.rootFolder;
       if (!rootFolder) continue;
 
       const infoForFolder = readInfoForRoot(rootFolder) || {};
@@ -5885,13 +5955,9 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
         });
       }
 
-      let seriesData;
+      let seriesData = doc.data;
-      try {
+      if (!seriesData) {
-        seriesData = JSON.parse(fs.readFileSync(paths.metadata, "utf-8"));
+        await removeTvSeriesByKey(key);
-      } catch (err) {
-        console.warn(
-          `⚠️ series.json okunamadı (${paths.metadata}): ${err.message}`
-        );
         continue;
       }
 
@@ -5972,7 +6038,7 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
         );
         if (!Number.isFinite(seasonNumber)) continue;
 
-      const seasonPaths = seasonAssetPaths(paths, seasonNumber);
+        const seasonPaths = seasonAssetPaths(paths, seasonNumber);
 
         const rawEpisodes = rawSeason.episodes || {};
         for (const [episodeKey, rawEpisode] of Object.entries(rawEpisodes)) {
@@ -6053,7 +6119,7 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
           const infoEpisode = infoEpisodeIndex.get(`${seasonNumber}-${episodeNumber}`);
           if (infoEpisode?.relPath) {
             const normalizedRel = infoEpisode.relPath.replace(/^\/+/, "");
-          const withRoot = `${rootFolder}/${normalizedRel}`.replace(/^\/+/, "");
+            const withRoot = `${rootFolder}/${normalizedRel}`.replace(/^\/+/, "");
             normalizedEpisode.file = normalizedRel;
             normalizedEpisode.videoPath = withRoot;
             const fileMeta = infoFiles[normalizedRel];
@@ -6070,13 +6136,13 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
           let videoPath = rawVideoPath.replace(/\\/g, "/").replace(/^\.\//, "");
           if (videoPath) {
             const isExternal = /^https?:\/\//i.test(videoPath);
-          const needsFolderPrefix =
+            const needsFolderPrefix =
-            !isExternal &&
+              !isExternal &&
-            !videoPath.startsWith(`${rootFolder}/`) &&
+              !videoPath.startsWith(`${rootFolder}/`) &&
-            !videoPath.startsWith(`/${rootFolder}/`);
+              !videoPath.startsWith(`/${rootFolder}/`);
-          if (needsFolderPrefix) {
+            if (needsFolderPrefix) {
-            videoPath = `${rootFolder}/${videoPath}`.replace(/\\/g, "/");
+              videoPath = `${rootFolder}/${videoPath}`.replace(/\\/g, "/");
-          }
+            }
             const finalPath = videoPath.replace(/^\/+/, "");
             if (finalPath !== rawVideoPath) {
               dataChanged = true;
@@ -6130,14 +6196,10 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
         try {
           seriesData.seasons = seasonsObj;
           seriesData.updatedAt = Date.now();
-          fs.writeFileSync(
+          await upsertTvSeries(key, rootFolder, seriesData);
-            paths.metadata,
-            JSON.stringify(seriesData, null, 2),
-            "utf-8"
-          );
         } catch (err) {
           console.warn(
-            `⚠️ series.json güncellenemedi (${paths.metadata}): ${err.message}`
+            `⚠️ TV metadata güncellenemedi (db - ${key}): ${err.message}`
           );
         }
       }
@@ -6313,6 +6375,14 @@ async function rebuildTvMetadata({ clearCache = false } = {}) {
     const rootDir = path.join(DOWNLOAD_DIR, folder);
     if (!fs.existsSync(rootDir)) continue;
 
+    if (clearCache) {
+      try {
+        await removeTvSeriesByRoot(folder);
+      } catch (err) {
+        console.warn(`⚠️ TV metadata temizlenemedi (db - ${folder}): ${err.message}`);
+      }
+    }
+
     try {
       const info = readInfoForRoot(folder) || {};
       const infoFiles = info.files || {};