better db model

src/server/services/data_migration_service.py

@@ -22,7 +22,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from src.core.entities.series import Serie
-from src.server.database.service import AnimeSeriesService
+from src.server.database.service import AnimeSeriesService, EpisodeService
 
 logger = logging.getLogger(__name__)
 
@@ -206,7 +206,7 @@ class DataMigrationService:
         
         Reads the data file, checks if the series already exists in the
         database, and creates a new record if it doesn't exist. If the
-        series exists, optionally updates the episode_dict if changed.
+        series exists, optionally updates the episodes if changed.
         
         Args:
             data_path: Path to the data file
@@ -229,41 +229,44 @@ class DataMigrationService:
         existing = await AnimeSeriesService.get_by_key(db, serie.key)
         
         if existing is not None:
-            # Check if episode_dict has changed
-            existing_dict = existing.episode_dict or {}
+            # Build episode dict from existing episodes for comparison
+            existing_dict: dict[int, list[int]] = {}
+            episodes = await EpisodeService.get_by_series(db, existing.id)
+            for ep in episodes:
+                if ep.season not in existing_dict:
+                    existing_dict[ep.season] = []
+                existing_dict[ep.season].append(ep.episode_number)
+            for season in existing_dict:
+                existing_dict[season].sort()
+            
             new_dict = serie.episodeDict or {}
             
-            # Convert keys to strings for comparison (JSON stores keys as strings)
-            new_dict_str_keys = {
-                str(k): v for k, v in new_dict.items()
-            }
-            
-            if existing_dict == new_dict_str_keys:
+            if existing_dict == new_dict:
                 logger.debug(
                     "Series '%s' already exists with same data, skipping",
                     serie.key
                 )
                 return False
             
-            # Update episode_dict if different
-            await AnimeSeriesService.update(
-                db,
-                existing.id,
-                episode_dict=new_dict_str_keys
-            )
+            # Update episodes if different - add new episodes
+            for season, episode_numbers in new_dict.items():
+                existing_eps = set(existing_dict.get(season, []))
+                for ep_num in episode_numbers:
+                    if ep_num not in existing_eps:
+                        await EpisodeService.create(
+                            db=db,
+                            series_id=existing.id,
+                            season=season,
+                            episode_number=ep_num,
+                        )
             logger.info(
-                "Updated episode_dict for existing series '%s'",
+                "Updated episodes for existing series '%s'",
                 serie.key
             )
             return True
         
         # Create new series in database
         try:
-            # Convert episode_dict keys to strings for JSON storage
-            episode_dict_for_db = {
-                str(k): v for k, v in (serie.episodeDict or {}).items()
-            }
-            
             # Use folder as fallback name if name is empty
             series_name = serie.name
             if not series_name or not series_name.strip():
@@ -274,14 +277,25 @@ class DataMigrationService:
                     serie.key
                 )
             
-            await AnimeSeriesService.create(
+            anime_series = await AnimeSeriesService.create(
                 db,
                 key=serie.key,
                 name=series_name,
                 site=serie.site,
                 folder=serie.folder,
-                episode_dict=episode_dict_for_db,
             )
+            
+            # Create Episode records for each episode in episodeDict
+            if serie.episodeDict:
+                for season, episode_numbers in serie.episodeDict.items():
+                    for episode_number in episode_numbers:
+                        await EpisodeService.create(
+                            db=db,
+                            series_id=anime_series.id,
+                            season=season,
+                            episode_number=episode_number,
+                        )
+            
             logger.info(
                 "Migrated series '%s' to database",
                 serie.key