fix(notifications): fix two onSuccessfulDownload notifications being sent out when downloading a source

Author: markbeep

app/internal/prowlarr/prowlarr.py

@@ -2,13 +2,14 @@
 import json
 import posixpath
 import time
+import uuid
 from datetime import datetime
 from typing import Literal
 from urllib.parse import urlencode
 
 from aiohttp import ClientResponse, ClientSession
 from pydantic import BaseModel, TypeAdapter
-from sqlmodel import Session
+from sqlmodel import Session, select
 from torf import BdecodeError, MetainfoError, ReadError, Torrent
 
 from app.internal.indexers.abstract import SessionContainer
@@ -21,7 +22,10 @@
     TorrentSource,
     UsenetSource,
 )
-from app.internal.notifications import send_all_notifications
+from app.internal.notifications import (
+    send_all_manual_notifications,
+    send_all_notifications,
+)
 from app.internal.prowlarr.source_metadata import edit_source_metadata
 from app.internal.prowlarr.util import (
     prowlarr_config,
@@ -55,12 +59,13 @@ async def _get_torrent_info_hash(
 
 
 async def start_download(
+    *,
     session: Session,
     client_session: ClientSession,
     guid: str,
     indexer_id: int,
-    book_asin: str,
     prowlarr_source: ProwlarrSource | None = None,
+    asin_or_uuid: str | None = None,
 ) -> ClientResponse:
     prowlarr_config.raise_if_invalid(session)
     base_url = prowlarr_config.get_base_url(session)
@@ -71,6 +76,13 @@ async def start_download(
     logger.debug("Starting download", guid=guid)
     headers = {"X-Api-Key": api_key, "User-Agent": USER_AGENT}
 
+    manual_book_request: ManualBookRequest | None = None
+    try:
+        uuid_obj = uuid.UUID(asin_or_uuid)
+        manual_book_request = session.get(ManualBookRequest, uuid_obj)
+    except ValueError:
+        pass
+
     async with client_session.post(
         url,
         json={"guid": guid, "indexerId": indexer_id},
@@ -83,18 +95,31 @@ async def start_download(
                 response=response,
                 text=await response.text(),
             )
-            await send_all_notifications(
-                EventEnum.on_failed_download,
-                book_asin,
-                {
-                    "errorStatus": str(response.status),
-                    "errorReason": response.reason or "<unknown>",
-                },
-            )
+
+            if manual_book_request:
+                await send_all_manual_notifications(
+                    EventEnum.on_failed_download,
+                    manual_book_request,
+                    {
+                        "errorStatus": str(response.status),
+                        "errorReason": response.reason or "<unknown>",
+                    },
+                )
+            else:
+                await send_all_notifications(
+                    EventEnum.on_failed_download,
+                    asin_or_uuid,
+                    {
+                        "errorStatus": str(response.status),
+                        "errorReason": response.reason or "<unknown>",
+                    },
+                )
             return response
 
         # Find additional metadata/replacements to pass along notifications
-        additional_replacements: dict[str, str] = {"bookASIN": book_asin}
+        additional_replacements: dict[str, str] = (
+            {"bookASIN": asin_or_uuid} if asin_or_uuid else {}
+        )
         if prowlarr_source:
             if prowlarr_source.download_url and prowlarr_source.protocol == "torrent":
                 if info_hash := await _get_torrent_info_hash(
@@ -113,11 +138,28 @@ async def start_download(
             additional_replacements["sourceProtocol"] = prowlarr_source.protocol
 
         logger.debug("Download successfully started", guid=guid)
-        await send_all_notifications(
-            EventEnum.on_successful_download,
-            book_asin,
-            additional_replacements,
-        )
+        if manual_book_request:
+            manual_book_request.downloaded = True
+            session.add(manual_book_request)
+            session.commit()
+            await send_all_manual_notifications(
+                EventEnum.on_successful_download,
+                manual_book_request,
+                additional_replacements,
+            )
+        else:
+            same_books = session.exec(
+                select(Audiobook).where(Audiobook.asin == asin_or_uuid)
+            ).all()
+            for b in same_books:
+                b.downloaded = True
+                session.add(b)
+
+            await send_all_notifications(
+                EventEnum.on_successful_download,
+                asin_or_uuid,
+                additional_replacements,
+            )
 
         return response
 

app/internal/query.py

@@ -15,6 +15,7 @@
 from app.internal.prowlarr.util import prowlarr_config
 from app.internal.ranking.download_ranking import rank_sources
 from app.util.db import get_session
+from app.util.log import logger
 
 querying: set[str] = set()
 
@@ -95,23 +96,16 @@ async def query_sources(
                 client_session=client_session,
                 guid=ranked[0].guid,
                 indexer_id=ranked[0].indexer_id,
-                book_asin=asin_or_uuid,
+                asin_or_uuid=asin_or_uuid,
                 prowlarr_source=ranked[0],
             )
             if resp.ok:
-                same_books = session.exec(
-                    select(Audiobook).where(Audiobook.asin == asin_or_uuid)
-                ).all()
-                for b in same_books:
-                    b.downloaded = True
-                    session.add(b)
-                session.commit()
                 # Try to trigger an ABS scan to pick up new media
                 try:
                     if abs_config.is_valid(session):
                         await abs_trigger_scan(session, client_session)
                 except Exception:
-                    pass
+                    logger.error("Failed to trigger ABS scan after starting download")
             else:
                 raise HTTPException(status_code=500, detail="Failed to start download")
 

app/routers/api/requests.py

@@ -354,43 +354,13 @@ async def download_book(
             client_session=client_session,
             guid=body.guid,
             indexer_id=body.indexer_id,
-            book_asin=asin_or_uuid,
+            asin_or_uuid=asin_or_uuid,
         )
     except ProwlarrMisconfigured as e:
         raise HTTPException(status_code=500, detail=str(e))
     if not resp.ok:
         raise HTTPException(status_code=500, detail="Failed to start download")
 
-    # Check if this was a manual request (UUID)
-    try:
-        uuid_obj = uuid.UUID(asin_or_uuid)
-        book_req = session.get(ManualBookRequest, uuid_obj)
-        if book_req:
-            book_req.downloaded = True
-            session.add(book_req)
-            session.commit()
-
-            background_task.add_task(
-                send_all_manual_notifications,
-                event_type=EventEnum.on_successful_download,
-                book_request=ManualBookRequest.model_validate(book_req),
-            )
-
-    except ValueError:
-        book = session.exec(
-            select(Audiobook).where(Audiobook.asin == asin_or_uuid)
-        ).first()
-        if book:
-            book.downloaded = True
-            session.add(book)
-            session.commit()
-
-            background_task.add_task(
-                send_all_notifications,
-                event_type=EventEnum.on_successful_download,
-                book_asin=asin_or_uuid,
-            )
-
     if abs_config.is_valid(session):
         background_task.add_task(background_abs_trigger_scan)
 

app/routers/pages/search/__init__.py

@@ -68,7 +68,7 @@ async def read_search(
 
     except Exception as e:
         session.rollback()
-        logger.exception("Error during search", error=e)
+        logger.error("Error during search", error=e)
         raise ToastException(
             "An error occurred while searching for books. Please try again later."
         ) from e