refactoring

src/core/entities/SerieList.py

@@ -0,0 +1,56 @@
+import os
+import json
+import logging
+from .series import Serie
+class SerieList:
+    def __init__(self, basePath: str):
+        self.directory = basePath
+        self.folderDict: dict[str, Serie] = {}  # Proper initialization
+        self.load_series()
+
+    def add(self, serie: Serie):
+        if (not self.contains(serie.key)):
+            dataPath = os.path.join(self.directory, serie.folder, "data")
+            animePath = os.path.join(self.directory, serie.folder)
+            os.makedirs(animePath, exist_ok=True)
+            if not os.path.isfile(dataPath):
+                serie.save_to_file(dataPath)
+                self.folderDict[serie.folder] = serie;
+
+    def contains(self, key: str) -> bool:
+        for k, value in self.folderDict.items():
+            if value.key == key:
+                return True
+        return False
+
+    def load_series(self):
+        """ Scan folders and load data files """
+        logging.info(f"Scanning anime folders in: {self.directory}")
+        for anime_folder in os.listdir(self.directory):
+            anime_path = os.path.join(self.directory, anime_folder, "data")
+            if os.path.isfile(anime_path):
+                logging.debug(f"Found data folder: {anime_path}")
+                self.load_data(anime_folder, anime_path)
+            else:
+                logging.warning(f"Skipping {anime_folder} - No data folder found")
+
+    def load_data(self, anime_folder, data_path):
+        """ Load pickle files from the data folder """
+        try:
+            self.folderDict[anime_folder] = Serie.load_from_file(data_path)
+            logging.debug(f"Successfully loaded {data_path} for {anime_folder}")
+        except Exception as e:
+            logging.error(f"Failed to load {data_path} in {anime_folder}: {e}")
+
+    def GetMissingEpisode(self):
+        """Find all series with a non-empty episodeDict"""
+        return [serie for serie in self.folderDict.values() if len(serie.episodeDict) > 0]
+    
+    def GetList(self):
+        """Get all series in the list"""
+        return list(self.folderDict.values())
+
+
+#k = AnimeList("\\\\sshfs.r\\ubuntu@192.168.178.43\\media\\serien\\Serien")
+#bbabab = k.GetMissingEpisode()
+#print(bbabab)

src/core/entities/series.py

@@ -0,0 +1,82 @@
+import json
+
+class Serie:
+    def __init__(self, key: str, name: str, site: str, folder: str, episodeDict: dict[int, list[int]]):
+        self._key = key
+        self._name = name
+        self._site = site
+        self._folder = folder
+        self._episodeDict = episodeDict
+    def __str__(self):
+        """String representation of Serie object"""
+        return f"Serie(key='{self.key}', name='{self.name}', site='{self.site}', folder='{self.folder}', episodeDict={self.episodeDict})"
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @key.setter
+    def key(self, value: str):
+        self._key = value
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str):
+        self._name = value
+
+    @property
+    def site(self) -> str:
+        return self._site
+
+    @site.setter
+    def site(self, value: str):
+        self._site = value
+
+    @property
+    def folder(self) -> str:
+        return self._folder
+
+    @folder.setter
+    def folder(self, value: str):
+        self._folder = value
+
+    @property
+    def episodeDict(self) -> dict[int, list[int]]:
+        return self._episodeDict
+
+    @episodeDict.setter
+    def episodeDict(self, value: dict[int, list[int]]):
+        self._episodeDict = value
+
+    def to_dict(self):
+        """Convert Serie object to dictionary for JSON serialization."""
+        return {
+            "key": self.key,
+            "name": self.name,
+            "site": self.site,
+            "folder": self.folder,
+            "episodeDict": {str(k): list(v) for k, v in self.episodeDict.items()}
+        }
+
+    @staticmethod
+    def from_dict(data: dict):
+        """Create a Serie object from dictionary."""
+        episode_dict = {int(k): v for k, v in data["episodeDict"].items()}  # Convert keys to int
+        return Serie(data["key"], data["name"], data["site"], data["folder"], episode_dict)
+
+
+    def save_to_file(self, filename: str):
+        """Save Serie object to JSON file."""
+        with open(filename, "w") as file:
+            json.dump(self.to_dict(), file, indent=4)
+
+
+    @classmethod
+    def load_from_file(cls, filename: str) -> "Serie":
+        """Load Serie object from JSON file."""
+        with open(filename, "r") as file:
+            data = json.load(file)
+        return cls.from_dict(data)