refactor: 添加订阅协程处理

app/api/endpoints/subscribe.py

@@ -17,7 +17,7 @@ from app.db.models.subscribe import Subscribe
 from app.db.models.subscribehistory import SubscribeHistory
 from app.db.models.user import User
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_user
+from app.db.user_oper import get_current_active_user_async
 from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
 from app.schemas.types import MediaType, EventType, SystemConfigKey
@@ -53,10 +53,10 @@ async def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
 
 
 @router.post("/", summary="新增订阅", response_model=schemas.Response)
-def create_subscribe(
+async def create_subscribe(
         *,
         subscribe_in: schemas.Subscribe,
-        current_user: User = Depends(get_current_active_user),
+        current_user: User = Depends(get_current_active_user_async),
 ) -> schemas.Response:
     """
     新增订阅
@@ -78,10 +78,10 @@ def create_subscribe(
         title = None
     # 订阅用户
     subscribe_in.username = current_user.name
-    sid, message = SubscribeChain().add(mtype=mtype,
-                                        title=title,
-                                        exist_ok=True,
-                                        **subscribe_in.dict())
+    sid, message = await SubscribeChain().async_add(mtype=mtype,
+                                                   title=title,
+                                                   exist_ok=True,
+                                                   **subscribe_in.dict())
     return schemas.Response(
         success=bool(sid), message=message, data={"id": sid}
     )
@@ -495,9 +495,9 @@ async def subscribe_share_delete(
 
 
 @router.post("/fork", summary="复用订阅", response_model=schemas.Response)
-def subscribe_fork(
+async def subscribe_fork(
         sub: schemas.SubscribeShare,
-        current_user: User = Depends(get_current_active_user)) -> Any:
+        current_user: User = Depends(get_current_active_user_async)) -> Any:
     """
     复用订阅
     """
@@ -506,10 +506,10 @@ def subscribe_fork(
     for key in list(sub_dict.keys()):
         if not hasattr(schemas.Subscribe(), key):
             sub_dict.pop(key)
-    result = create_subscribe(subscribe_in=schemas.Subscribe(**sub_dict),
-                              current_user=current_user)
+    result = await create_subscribe(subscribe_in=schemas.Subscribe(**sub_dict),
+                                    current_user=current_user)
     if result.success:
-        SubscribeHelper().sub_fork(share_id=sub.id)
+        await SubscribeHelper().async_sub_fork(share_id=sub.id)
     return result
 
 

app/api/servarr.py

@@ -6,8 +6,8 @@ from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.media import MediaChain
-from app.chain.tvdb import TvdbChain
 from app.chain.subscribe import SubscribeChain
+from app.chain.tvdb import TvdbChain
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_apikey
 from app.db import get_db, get_async_db
@@ -307,7 +307,8 @@ def arr_movie_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: S
 
 
 @arr_router.get("/movie/{mid}", summary="电影订阅详情", response_model=schemas.RadarrMovie)
-async def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+async def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],
+                    db: AsyncSession = Depends(get_async_db)) -> Any:
     """
     查询Rardar电影订阅
     """
@@ -333,25 +334,25 @@ async def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: Asy
 
 
 @arr_router.post("/movie", summary="新增电影订阅")
-def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
-                  movie: RadarrMovie,
-                  db: Session = Depends(get_db)
-                  ) -> Any:
+async def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
+                        movie: RadarrMovie,
+                        db: AsyncSession = Depends(get_async_db)
+                        ) -> Any:
     """
     新增Rardar电影订阅
     """
     # 检查订阅是否已存在
-    subscribe = Subscribe.get_by_tmdbid(db, movie.tmdbId)
+    subscribe = await Subscribe.async_get_by_tmdbid(db, movie.tmdbId)
     if subscribe:
         return {
             "id": subscribe.id
         }
     # 添加订阅
-    sid, message = SubscribeChain().add(title=movie.title,
-                                        year=movie.year,
-                                        mtype=MediaType.MOVIE,
-                                        tmdbid=movie.tmdbId,
-                                        username="Seerr")
+    sid, message = await SubscribeChain().async_add(title=movie.title,
+                                                    year=movie.year,
+                                                    mtype=MediaType.MOVIE,
+                                                    tmdbid=movie.tmdbId,
+                                                    username="Seerr")
     if sid:
         return {
             "id": sid
@@ -364,7 +365,8 @@ def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
 
 
 @arr_router.delete("/movie/{mid}", summary="删除电影订阅", response_model=schemas.Response)
-async def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+async def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],
+                           db: AsyncSession = Depends(get_async_db)) -> Any:
     """
     删除Rardar电影订阅
     """
@@ -606,7 +608,8 @@ def arr_series_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db:
 
 
 @arr_router.get("/series/{tid}", summary="剧集详情")
-async def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+async def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)],
+                    db: AsyncSession = Depends(get_async_db)) -> Any:
     """
     查询Sonarr剧集
     """
@@ -640,17 +643,17 @@ async def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)], db: Asy
 
 
 @arr_router.post("/series", summary="新增剧集订阅")
-def arr_add_series(tv: schemas.SonarrSeries,
-                   _: Annotated[str, Depends(verify_apikey)],
-                   db: Session = Depends(get_db)) -> Any:
+async def arr_add_series(tv: schemas.SonarrSeries,
+                         _: Annotated[str, Depends(verify_apikey)],
+                         db: AsyncSession = Depends(get_async_db)) -> Any:
     """
     新增Sonarr剧集订阅
     """
     # 检查订阅是否存在
     left_seasons = []
     for season in tv.seasons:
-        subscribe = Subscribe.get_by_tmdbid(db, tmdbid=tv.tmdbId,
-                                            season=season.get("seasonNumber"))
+        subscribe = await Subscribe.async_get_by_tmdbid(db, tmdbid=tv.tmdbId,
+                                                        season=season.get("seasonNumber"))
         if subscribe:
             continue
         left_seasons.append(season)
@@ -665,12 +668,12 @@ def arr_add_series(tv: schemas.SonarrSeries,
     for season in left_seasons:
         if not season.get("monitored"):
             continue
-        sid, message = SubscribeChain().add(title=tv.title,
-                                            year=tv.year,
-                                            season=season.get("seasonNumber"),
-                                            tmdbid=tv.tmdbId,
-                                            mtype=MediaType.TV,
-                                            username="Seerr")
+        sid, message = await SubscribeChain().async_add(title=tv.title,
+                                                        year=tv.year,
+                                                        season=season.get("seasonNumber"),
+                                                        tmdbid=tv.tmdbId,
+                                                        mtype=MediaType.TV,
+                                                        username="Seerr")
 
     if sid:
         return {
@@ -684,15 +687,16 @@ def arr_add_series(tv: schemas.SonarrSeries,
 
 
 @arr_router.put("/series", summary="更新剧集订阅")
-def arr_update_series(tv: schemas.SonarrSeries) -> Any:
+async def arr_update_series(tv: schemas.SonarrSeries, _: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     更新Sonarr剧集订阅
     """
-    return arr_add_series(tv)
+    return await arr_add_series(tv)
 
 
 @arr_router.delete("/series/{tid}", summary="删除剧集订阅")
-async def arr_remove_series(tid: int, _: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+async def arr_remove_series(tid: int, _: Annotated[str, Depends(verify_apikey)],
+                            db: AsyncSession = Depends(get_async_db)) -> Any:
     """
     删除Sonarr剧集订阅
     """