重构订阅和用户相关API，支持异步操作

2026-09-05 23:47:41 +08:00 · 2025-07-30 15:23:25 +08:00
parent 21541bc468
commit 42d955b175
8 changed files with 483 additions and 136 deletions
@@ -1,10 +1,11 @@
 import time
 from typing import Optional

-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON
+from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, 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, Base, async_db_query, async_db_update


 class Subscribe(Base):
@@ -99,6 +100,27 @@ class Subscribe(Base):
            return db.query(Subscribe).filter(Subscribe.doubanid == doubanid).first()
        return None

+    @classmethod
+    @async_db_query
+    async def async_exists(cls, db: AsyncSession, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                           season: Optional[int] = None):
+        if tmdbid:
+            if season:
+                result = await db.execute(
+                    select(cls).filter(cls.tmdbid == tmdbid, cls.season == season)
+                )
+            else:
+                result = await db.execute(
+                    select(cls).filter(cls.tmdbid == tmdbid)
+                )
+        elif doubanid:
+            result = await db.execute(
+                select(cls).filter(cls.doubanid == doubanid)
+            )
+        else:
+            return None
+        return result.scalars().first()
+
    @staticmethod
    @db_query
    def get_by_state(db: Session, state: str):
@@ -109,6 +131,19 @@ class Subscribe(Base):
            # 如果传入的状态不为空，拆分成多个状态
            return db.query(Subscribe).filter(Subscribe.state.in_(state.split(','))).all()

+    @classmethod
+    @async_db_query
+    async def async_get_by_state(cls, db: AsyncSession, state: str):
+        # 如果 state 为空或 None，返回所有订阅
+        if not state:
+            result = await db.execute(select(cls))
+        else:
+            # 如果传入的状态不为空，拆分成多个状态
+            result = await db.execute(
+                select(cls).filter(cls.state.in_(state.split(',')))
+            )
+        return result.scalars().all()
+
    @staticmethod
    @db_query
    def get_by_title(db: Session, title: str, season: Optional[int] = None):
@@ -117,6 +152,19 @@ class Subscribe(Base):
                                              Subscribe.season == season).first()
        return db.query(Subscribe).filter(Subscribe.name == title).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_title(cls, db: AsyncSession, title: str, season: Optional[int] = None):
+        if season:
+            result = await db.execute(
+                select(cls).filter(cls.name == title, cls.season == season)
+            )
+        else:
+            result = await db.execute(
+                select(cls).filter(cls.name == title)
+            )
+        return result.scalars().first()
+
    @staticmethod
    @db_query
    def get_by_tmdbid(db: Session, tmdbid: int, season: Optional[int] = None):
@@ -126,21 +174,58 @@ class Subscribe(Base):
        else:
            return db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid).all()

+    @classmethod
+    @async_db_query
+    async def async_get_by_tmdbid(cls, db: AsyncSession, tmdbid: int, season: Optional[int] = None):
+        if season:
+            result = await db.execute(
+                select(cls).filter(cls.tmdbid == tmdbid, cls.season == season)
+            )
+        else:
+            result = await db.execute(
+                select(cls).filter(cls.tmdbid == tmdbid)
+            )
+        return result.scalars().all()
+
    @staticmethod
    @db_query
    def get_by_doubanid(db: Session, doubanid: str):
        return db.query(Subscribe).filter(Subscribe.doubanid == doubanid).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_doubanid(cls, db: AsyncSession, doubanid: str):
+        result = await db.execute(
+            select(cls).filter(cls.doubanid == doubanid)
+        )
+        return result.scalars().first()
+
    @staticmethod
    @db_query
    def get_by_bangumiid(db: Session, bangumiid: int):
        return db.query(Subscribe).filter(Subscribe.bangumiid == bangumiid).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_bangumiid(cls, db: AsyncSession, bangumiid: int):
+        result = await db.execute(
+            select(cls).filter(cls.bangumiid == bangumiid)
+        )
+        return result.scalars().first()
+
    @staticmethod
    @db_query
    def get_by_mediaid(db: Session, mediaid: str):
        return db.query(Subscribe).filter(Subscribe.mediaid == mediaid).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_mediaid(cls, db: AsyncSession, mediaid: str):
+        result = await db.execute(
+            select(cls).filter(cls.mediaid == mediaid)
+        )
+        return result.scalars().first()
+
    @db_update
    def delete_by_tmdbid(self, db: Session, tmdbid: int, season: int):
        subscrbies = self.get_by_tmdbid(db, tmdbid, season)
@@ -148,6 +233,13 @@ class Subscribe(Base):
            subscrbie.delete(db, subscrbie.id)
        return True

+    @async_db_update
+    async def async_delete_by_tmdbid(self, db: AsyncSession, tmdbid: int, season: int):
+        subscrbies = await self.async_get_by_tmdbid(db, tmdbid, season)
+        for subscrbie in subscrbies:
+            await subscrbie.async_delete(db, subscrbie.id)
+        return True
+
    @db_update
    def delete_by_doubanid(self, db: Session, doubanid: str):
        subscribe = self.get_by_doubanid(db, doubanid)
@@ -155,6 +247,13 @@ class Subscribe(Base):
            subscribe.delete(db, subscribe.id)
        return True

+    @async_db_update
+    async def async_delete_by_doubanid(self, db: AsyncSession, doubanid: str):
+        subscribe = await self.async_get_by_doubanid(db, doubanid)
+        if subscribe:
+            await subscribe.async_delete(db, subscribe.id)
+        return True
+
    @db_update
    def delete_by_mediaid(self, db: Session, mediaid: str):
        subscribe = self.get_by_mediaid(db, mediaid)
@@ -162,6 +261,13 @@ class Subscribe(Base):
            subscribe.delete(db, subscribe.id)
        return True

+    @async_db_update
+    async def async_delete_by_mediaid(self, db: AsyncSession, mediaid: str):
+        subscribe = await self.async_get_by_mediaid(db, mediaid)
+        if subscribe:
+            await subscribe.async_delete(db, subscribe.id)
+        return True
+
    @staticmethod
    @db_query
    def list_by_username(db: Session, username: str, state: Optional[str] = None, mtype: Optional[str] = None):
@@ -180,6 +286,30 @@ class Subscribe(Base):
            else:
                return db.query(Subscribe).filter(Subscribe.username == username).all()

+    @classmethod
+    @async_db_query
+    async def async_list_by_username(cls, db: AsyncSession, username: str, state: Optional[str] = None,
+                                     mtype: Optional[str] = None):
+        if mtype:
+            if state:
+                result = await db.execute(
+                    select(cls).filter(cls.state == state, cls.username == username, cls.type == mtype)
+                )
+            else:
+                result = await db.execute(
+                    select(cls).filter(cls.username == username, cls.type == mtype)
+                )
+        else:
+            if state:
+                result = await db.execute(
+                    select(cls).filter(cls.state == state, cls.username == username)
+                )
+            else:
+                result = await db.execute(
+                    select(cls).filter(cls.username == username)
+                )
+        return result.scalars().all()
+
    @staticmethod
    @db_query
    def list_by_type(db: Session, mtype: str, days: int):
@@ -188,3 +318,15 @@ class Subscribe(Base):
                    Subscribe.date >= time.strftime("%Y-%m-%d %H:%M:%S",
                                                    time.localtime(time.time() - 86400 * int(days)))
                    ).all()
+
+    @classmethod
+    @async_db_query
+    async def async_list_by_type(cls, db: AsyncSession, mtype: str, days: int):
+        result = await db.execute(
+            select(cls).filter(
+                cls.type == mtype,
+                cls.date >= time.strftime("%Y-%m-%d %H:%M:%S",
+                                          time.localtime(time.time() - 86400 * int(days)))
+            )
+        )
+        return result.scalars().all()
@@ -1,9 +1,10 @@
 from typing import Optional

-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON
+from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

-from app.db import db_query, Base
+from app.db import db_query, Base, async_db_query


 class SubscribeHistory(Base):
@@ -81,6 +82,18 @@ class SubscribeHistory(Base):
            SubscribeHistory.date.desc()
        ).offset((page - 1) * count).limit(count).all()

+    @classmethod
+    @async_db_query
+    async def async_list_by_type(cls, db: AsyncSession, mtype: str, page: Optional[int] = 1, count: Optional[int] = 30):
+        result = await db.execute(
+            select(cls).filter(
+                cls.type == mtype
+            ).order_by(
+                cls.date.desc()
+            ).offset((page - 1) * count).limit(count)
+        )
+        return result.scalars().all()
+
    @staticmethod
    @db_query
    def exists(db: Session, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None):
@@ -92,3 +105,24 @@ class SubscribeHistory(Base):
        elif doubanid:
            return db.query(SubscribeHistory).filter(SubscribeHistory.doubanid == doubanid).first()
        return None
+
+    @classmethod
+    @async_db_query
+    async def async_exists(cls, db: AsyncSession, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                           season: Optional[int] = None):
+        if tmdbid:
+            if season:
+                result = await db.execute(
+                    select(cls).filter(cls.tmdbid == tmdbid, cls.season == season)
+                )
+            else:
+                result = await db.execute(
+                    select(cls).filter(cls.tmdbid == tmdbid)
+                )
+        elif doubanid:
+            result = await db.execute(
+                select(cls).filter(cls.doubanid == doubanid)
+            )
+        else:
+            return None
+        return result.scalars().first()
@@ -1,7 +1,8 @@
-from sqlalchemy import Boolean, Column, Integer, JSON, Sequence, String
+from sqlalchemy import Boolean, Column, Integer, JSON, Sequence, String, select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

-from app.db import Base, db_query, db_update
+from app.db import Base, db_query, db_update, async_db_query, async_db_update


 class User(Base):
@@ -36,11 +37,27 @@ class User(Base):
    def get_by_name(db: Session, name: str):
        return db.query(User).filter(User.name == name).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_name(cls, db: AsyncSession, name: str):
+        result = await db.execute(
+            select(cls).filter(cls.name == name)
+        )
+        return result.scalars().first()
+
    @staticmethod
    @db_query
    def get_by_id(db: Session, user_id: int):
        return db.query(User).filter(User.id == user_id).first()

+    @classmethod
+    @async_db_query
+    async def async_get_by_id(cls, db: AsyncSession, user_id: int):
+        result = await db.execute(
+            select(cls).filter(cls.id == user_id)
+        )
+        return result.scalars().first()
+
    @db_update
    def delete_by_name(self, db: Session, name: str):
        user = self.get_by_name(db, name)
@@ -48,6 +65,13 @@ class User(Base):
            user.delete(db, user.id)
        return True

+    @async_db_update
+    async def async_delete_by_name(self, db: AsyncSession, name: str):
+        user = await self.async_get_by_name(db, name)
+        if user:
+            await user.async_delete(db, user.id)
+        return True
+
    @db_update
    def delete_by_id(self, db: Session, user_id: int):
        user = self.get_by_id(db, user_id)
@@ -55,6 +79,13 @@ class User(Base):
            user.delete(db, user.id)
        return True

+    @async_db_update
+    async def async_delete_by_id(self, db: AsyncSession, user_id: int):
+        user = await self.async_get_by_id(db, user_id)
+        if user:
+            await user.async_delete(db, user.id)
+        return True
+
    @db_update
    def update_otp_by_name(self, db: Session, name: str, otp: bool, secret: str):
        user = self.get_by_name(db, name)
@@ -65,3 +96,14 @@ class User(Base):
            })
            return True
        return False
+
+    @async_db_update
+    async def async_update_otp_by_name(self, db: AsyncSession, name: str, otp: bool, secret: str):
+        user = await self.async_get_by_name(db, name)
+        if user:
+            await user.async_update(db, {
+                'is_otp': otp,
+                'otp_secret': secret
+            })
+            return True
+        return False