Merge pull request #166 from marceljungle/copilot/fix-165

marceljungle · web-flow · commit bc40ff7d2d5d · 2025-08-18T21:06:39.000+02:00
Add show-missing command to compare local collections with site collages
diff --git a/red_plex/infrastructure/cli/commands/collages.py b/red_plex/infrastructure/cli/commands/collages.py
@@ -10,6 +10,7 @@
 from red_plex.infrastructure.plex.plex_manager import PlexManager
 from red_plex.infrastructure.rest.gazelle.gazelle_api import GazelleAPI
 from red_plex.infrastructure.service.collection_processor import CollectionProcessingService
+from red_plex.use_case.show_missing.show_missing_use_case import ShowMissingUseCase
 
 
 @click.group('collages')
@@ -171,3 +172,67 @@ def convert_collages(ctx, collage_ids, site, fetch_mode):
     )
 
     click.echo("Processing finished.")
+
+
+@collages.command('show-missing')
+@click.pass_context
+@click.argument('collage_id')
+def show_missing(ctx, collage_id):
+    """
+    Show missing torrent groups from the local collection compared to the site collage.
+    
+    COLLAGE_ID is the external ID of the collage to check.
+    """
+    local_database = ctx.obj.get('db')
+    if not local_database:
+        click.echo("Error: Database not initialized.", err=True)
+        return
+
+    # Get the local collection to determine which site to use
+    local_collection = local_database.get_collage_collection_by_external_id(collage_id)
+    if not local_collection:
+        click.echo(
+            f"Error: No local collection found for collage ID {collage_id}. "
+            f"You may need to convert it first using "
+            f"'red-plex collages convert {collage_id} --site <site>'", err=True)
+        return
+
+    site = local_collection.site
+
+    # Initialize Gazelle API
+    try:
+        gazelle_api = GazelleAPI(site)
+    except Exception as e: # pylint: disable=W0718
+        logger.error("Failed to initialize Gazelle API: %s", e, exc_info=True)
+        click.echo(f"Error: Failed to initialize API for {site.upper()} - {e}", err=True)
+        return
+
+    # Use the show missing use case
+    use_case = ShowMissingUseCase(local_database, gazelle_api)
+    result = use_case.execute(collage_id)
+
+    if not result.success:
+        click.echo(f"Error: {result.error_message}", err=True)
+        return
+
+    click.echo(f"Checking collage '{result.collage_name}' "
+               f"(ID: {collage_id}) on {result.site.upper()}...")
+
+    if not result.has_missing_groups:
+        click.echo("✓ No missing groups found! "
+                   "Your local collection is up to date.")
+        return
+
+    click.echo(f"\nFound {len(result.missing_groups)} missing group(s) "
+               "in your local collection:")
+    click.echo("=" * 80)
+
+    # Display missing groups
+    for i, missing_group in enumerate(result.missing_groups, 1):
+        artists_str = ", ".join(missing_group.artist_names)
+        click.echo(f"{i:3d}. {artists_str} - {missing_group.album_name}")
+        click.echo(f"     Link: {missing_group.torrent_url}")
+        if i < len(result.missing_groups):  # Don't add extra line after last item
+            click.echo()
+
+    click.echo("=" * 80)
diff --git a/red_plex/infrastructure/db/collection.py b/red_plex/infrastructure/db/collection.py
@@ -143,6 +143,35 @@ def get_collage_collection(self, rating_key: str) -> Optional[Collection]:
             site=site
         )
 
+    def get_collage_collection_by_external_id(self, external_id: str) -> Optional[Collection]:
+        """
+        Retrieve a single collage-based collection (and associated group_ids) by external_id.
+        Returns a Collection or None if not found.
+        """
+        cur = self.conn.cursor()
+        # Get collage collection fields
+        cur.execute(
+            """
+            SELECT rating_key, name, site, external_id
+            FROM collage_collections
+            WHERE external_id = ?
+            """,
+            (external_id,)
+        )
+        row = cur.fetchone()
+        if not row:
+            return None
+        rating_key_val, name, site, external_id_val = row
+        # Get associated group_ids
+        group_ids = self._get_torrent_group_ids_for(rating_key_val)
+        return Collection(
+            id=rating_key_val,
+            external_id=external_id_val,
+            name=name,
+            torrent_groups=[TorrentGroup(id=gid) for gid in group_ids],
+            site=site
+        )
+
     def get_all_collage_collections(self) -> List[Collection]:
         """
         Retrieve all collage-based collections from the DB,
diff --git a/red_plex/infrastructure/db/local_database.py b/red_plex/infrastructure/db/local_database.py
@@ -78,6 +78,10 @@ def get_collage_collection(self, rating_key: str) -> Optional[Collection]:
         """Retrieve a single collage-based collection by rating_key."""
         return self._collection_manager.get_collage_collection(rating_key)
 
+    def get_collage_collection_by_external_id(self, external_id: str) -> Optional[Collection]:
+        """Retrieve a single collage-based collection by external_id."""
+        return self._collection_manager.get_collage_collection_by_external_id(external_id)
+
     def get_all_collage_collections(self) -> List[Collection]:
         """Retrieve all collage-based collections from the DB."""
         return self._collection_manager.get_all_collage_collections()
diff --git a/red_plex/infrastructure/rest/gazelle/gazelle_api.py b/red_plex/infrastructure/rest/gazelle/gazelle_api.py
@@ -29,12 +29,12 @@ def __init__(self, site: str):
         site_config = config_data.site_configurations.get(site.upper())
 
         api_key = site_config.api_key
-        base_url = site_config.base_url
+        self.base_url = site_config.base_url
         rate_limit_config = site_config.rate_limit
         rate_limit = Rate(
             rate_limit_config.calls, Duration.SECOND * rate_limit_config.seconds)
 
-        self.base_url = base_url.rstrip('/') + '/ajax.php?action='
+        self.base_url_with_action = self.base_url.rstrip('/') + '/ajax.php?action='
         self.headers = {'Authorization': api_key}
 
         # Initialize the rate limiter: default to 10 calls per 10 seconds if not specified
@@ -68,7 +68,7 @@ def get_call(self, action: str, params: Dict[str, str]) -> Dict[str, Any]:
         Rate limit is handled in a loop, while network/HTTP errors trigger a retry.
         """
         formatted_params = '&' + '&'.join(f'{k}={v}' for k, v in params.items()) if params else ''
-        formatted_url = f'{self.base_url}{action}{formatted_params}'
+        formatted_url = f'{self.base_url_with_action}{action}{formatted_params}'
         logger.debug('Calling GET API: %s', formatted_url)
 
         self._wait_for_rate_limit()
@@ -89,7 +89,7 @@ def post_call(self, action: str,
         Makes a rate-limited POST API call to the Gazelle-based service with retries.
         Rate limit is handled in a loop, while network/HTTP errors trigger a retry.
         """
-        url = f'{self.base_url}{action}'
+        url = f'{self.base_url_with_action}{action}'
         logger.debug('Calling POST API: %s', url)
 
         self._wait_for_rate_limit()
@@ -378,6 +378,10 @@ def add_to_collage(self, collage_id: str,
             logger.error('Error adding groups %s to collage %s: %s', group_ids_str, collage_id, e)
             return None
 
+    def get_torrent_group_url(self, group_id: str) -> str:
+        """ Constructs the URL for a torrent group based on its ID."""
+        return f"{self.base_url}/torrents.php?id={group_id}"
+
     @staticmethod
     def _normalize_string(text: str) -> str:
         """
diff --git a/red_plex/use_case/show_missing/show_missing_response.py b/red_plex/use_case/show_missing/show_missing_response.py
@@ -0,0 +1,28 @@
+"""Response model for show missing use case."""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class MissingGroupInfo:
+    """Information about a missing torrent group."""
+    group_id: int
+    artist_names: List[str]
+    album_name: str
+    torrent_url: str
+
+
+@dataclass
+class ShowMissingResponse:
+    """Response from the show missing use case."""
+    success: bool
+    collage_name: str
+    site: str
+    missing_groups: List[MissingGroupInfo]
+    error_message: Optional[str] = None
+
+    @property
+    def has_missing_groups(self) -> bool:
+        """Check if there are any missing groups."""
+        return len(self.missing_groups) > 0
diff --git a/red_plex/use_case/show_missing/show_missing_use_case.py b/red_plex/use_case/show_missing/show_missing_use_case.py
@@ -0,0 +1,123 @@
+"""Use case for showing missing torrent groups in local collections."""
+
+from red_plex.infrastructure.db.local_database import LocalDatabase
+from red_plex.infrastructure.logger.logger import logger
+from red_plex.infrastructure.rest.gazelle.gazelle_api import GazelleAPI
+from red_plex.use_case.show_missing.show_missing_response import (
+    ShowMissingResponse, MissingGroupInfo
+)
+
+
+# pylint: disable=R0903
+class ShowMissingUseCase:
+    """Use case for finding missing torrent groups in local collections."""
+
+    def __init__(self, db: LocalDatabase, gazelle_api: GazelleAPI):
+        """Initialize the use case with required dependencies."""
+        self.db = db
+        self.gazelle_api = gazelle_api
+
+    # pylint: disable=R0914
+    def execute(self, collage_id: str) -> ShowMissingResponse:
+        """
+        Execute the show missing use case.
+
+        Args:
+            collage_id: The external ID of the collage to check
+
+        Returns:
+            ShowMissingResponse with the results
+        """
+        # Get the local collection by external_id
+        local_collection = self.db.get_collage_collection_by_external_id(collage_id)
+        if not local_collection:
+            return ShowMissingResponse(
+                success=False,
+                collage_name="",
+                site="",
+                missing_groups=[],
+                error_message=(
+                    f"No local collection found for collage ID {collage_id}. "
+                    f"You may need to convert it first using "
+                    f"'red-plex collages convert {collage_id} --site <site>'"
+                )
+            )
+
+        site = local_collection.site
+
+        # Get the current collage from the site
+        try:
+            site_collection = self.gazelle_api.get_collage(collage_id)
+        except Exception as e:  # pylint: disable=W0718
+            logger.error("Failed to fetch collage from site: %s", e, exc_info=True)
+            return ShowMissingResponse(
+                success=False,
+                collage_name=local_collection.name,
+                site=site,
+                missing_groups=[],
+                error_message=f"Failed to fetch collage {collage_id} from {site.upper()} - {e}"
+            )
+
+        if not site_collection:
+            return ShowMissingResponse(
+                success=False,
+                collage_name=local_collection.name,
+                site=site,
+                missing_groups=[],
+                error_message=f"Collage {collage_id} not found on {site.upper()}"
+            )
+
+        # Compare group IDs
+        local_group_ids = {int(tg.id) for tg in local_collection.torrent_groups}
+        site_group_ids = {int(tg.id) for tg in site_collection.torrent_groups}
+        missing_group_ids = site_group_ids - local_group_ids
+
+        # If no missing groups, return success with empty list
+        if not missing_group_ids:
+            return ShowMissingResponse(
+                success=True,
+                collage_name=local_collection.name,
+                site=site,
+                missing_groups=[]
+            )
+
+        # Fetch details for each missing group
+        missing_groups = []
+        for group_id in sorted(missing_group_ids):
+            try:
+                torrent_group = self.gazelle_api.get_torrent_group(str(group_id))
+                if torrent_group:
+                    artists = torrent_group.artists if torrent_group.artists else ["Unknown Artist"]
+                    album_name = torrent_group.album_name or "Unknown Album"
+                    torrent_url = self.gazelle_api.get_torrent_group_url(str(group_id))
+
+                    missing_groups.append(MissingGroupInfo(
+                        group_id=group_id,
+                        artist_names=artists,
+                        album_name=album_name,
+                        torrent_url=torrent_url
+                    ))
+                else:
+                    # Group details not available, but still add basic info
+                    missing_groups.append(MissingGroupInfo(
+                        group_id=group_id,
+                        artist_names=["Unknown Artist"],
+                        album_name="Details not available",
+                        torrent_url=self.gazelle_api.get_torrent_group_url(str(group_id))
+                    ))
+            except Exception as e:  # pylint: disable=W0718
+                logger.warning("Failed to fetch details for group %s: %s", group_id, e)
+                # Add basic info even if details fetch failed
+                missing_groups.append(MissingGroupInfo(
+                    group_id=group_id,
+                    artist_names=["Unknown Artist"],
+                    album_name="Error fetching details",
+                    torrent_url=self.gazelle_api.get_torrent_group_url(str(group_id))
+                ))
+
+        return ShowMissingResponse(
+            success=True,
+            collage_name=local_collection.name,
+            site=site,
+            missing_groups=missing_groups
+        )
