feat：查询本地是否存在 使用协程

app/api/endpoints/mediaserver.py

@@ -9,7 +9,7 @@ from app.chain.mediaserver import MediaServerChain
 from app.core.context import MediaInfo
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.db import get_db
+from app.db import get_async_db
 from app.db.mediaserver_oper import MediaServerOper
 from app.db.models import MediaServerItem
 from app.db.systemconfig_oper import SystemConfigOper
@@ -43,13 +43,13 @@ def play_item(itemid: str, _: schemas.TokenPayload = Depends(verify_token)) -> s
 
 
 @router.get("/exists", summary="查询本地是否存在（数据库）", response_model=schemas.Response)
-def exists_local(title: Optional[str] = None,
+async def exists_local(title: Optional[str] = None,
-                 year: Optional[str] = None,
+                       year: Optional[str] = None,
-                 mtype: Optional[str] = None,
+                       mtype: Optional[str] = None,
-                 tmdbid: Optional[int] = None,
+                       tmdbid: Optional[int] = None,
-                 season: Optional[int] = None,
+                       season: Optional[int] = None,
-                 db: Session = Depends(get_db),
+                       db: Session = Depends(get_async_db),
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     判断本地是否存在
     """
@@ -59,7 +59,7 @@ def exists_local(title: Optional[str] = None,
     # 返回对象
     ret_info = {}
     # 本地数据库是否存在
-    exist: MediaServerItem = MediaServerOper(db).exists(
+    exist: MediaServerItem = await MediaServerOper(db).async_exists(
         title=meta.name, year=year, mtype=mtype, tmdbid=tmdbid, season=season
     )
     if exist:

app/db/mediaserver_oper.py

@@ -58,6 +58,32 @@ class MediaServerOper(DbOper):
                 return None
         return item
 
+    async def async_exists(self, **kwargs) -> Optional[MediaServerItem]:
+        """
+        异步判断媒体服务器数据是否存在
+        """
+        if kwargs.get("tmdbid"):
+            # 优先按TMDBID查
+            item = await MediaServerItem.async_exist_by_tmdbid(self._db, tmdbid=kwargs.get("tmdbid"),
+                                                               mtype=kwargs.get("mtype"))
+        elif kwargs.get("title"):
+            # 按标题、类型、年份查
+            item = await MediaServerItem.async_exists_by_title(self._db, title=kwargs.get("title"),
+                                                               mtype=kwargs.get("mtype"), year=kwargs.get("year"))
+        else:
+            return None
+        if not item:
+            return None
+
+        if kwargs.get("season"):
+            # 判断季是否存在
+            if not item.seasoninfo:
+                return None
+            seasoninfo = item.seasoninfo or {}
+            if kwargs.get("season") not in seasoninfo.keys():
+                return None
+        return item
+
     def get_item_id(self, **kwargs) -> Optional[str]:
         """
         获取媒体服务器数据ID
@@ -66,3 +92,12 @@ class MediaServerOper(DbOper):
         if not item:
             return None
         return str(item.item_id)
+
+    async def async_get_item_id(self, **kwargs) -> Optional[str]:
+        """
+        异步获取媒体服务器数据ID
+        """
+        item = await self.async_exists(**kwargs)
+        if not item:
+            return None
+        return str(item.item_id)

app/db/models/mediaserver.py

@@ -2,9 +2,11 @@ from datetime import datetime
 from typing import Optional
 
 from sqlalchemy import Column, Integer, String, Sequence, JSON
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base
+from app.db import db_query, db_update, async_db_query, Base
 
 
 class MediaServerItem(Base):
@@ -66,3 +68,24 @@ class MediaServerItem(Base):
         return db.query(cls).filter(cls.title == title,
                                     cls.item_type == mtype,
                                     cls.year == str(year)).first()
+
+    @classmethod
+    @async_db_query
+    async def async_get_by_itemid(cls, db: AsyncSession, item_id: str):
+        result = await db.execute(select(cls).filter(cls.item_id == item_id))
+        return result.scalars().first()
+
+    @classmethod
+    @async_db_query
+    async def async_exist_by_tmdbid(cls, db: AsyncSession, tmdbid: int, mtype: str):
+        result = await db.execute(select(cls).filter(cls.tmdbid == tmdbid,
+                                                     cls.item_type == mtype))
+        return result.scalars().first()
+
+    @classmethod
+    @async_db_query
+    async def async_exists_by_title(cls, db: AsyncSession, title: str, mtype: str, year: str):
+        result = await db.execute(select(cls).filter(cls.title == title,
+                                                     cls.item_type == mtype,
+                                                     cls.year == str(year)))
+        return result.scalars().first()