refactor(db): 修正SQLAlchemy异步操作调用方式

移除session.add()方法的不必要await调用，修正异步数据库操作模式。主要变更包括：

- 将 `await session.add()` 统一改为 `session.add()`
- 修正部分函数调用为异步版本（如消息查询函数）
- 重构SQLAlchemyTransaction为完全异步实现
- 重写napcat_adapter_plugin数据库层以符合异步规范
- 添加aiomysql和aiosqlite依赖支持

src/plugins/built_in/maizone_refactored/services/scheduler_service.py

@@ -186,7 +186,7 @@ class SchedulerService:
                         story_content=content,
                         send_success=success,
                     )
-                    await session.add(new_record)
+                    session.add(new_record)
                 await session.commit()
                 logger.info(f"已更新日程处理状态: {hour_str} - {activity} - 成功: {success}")
         except Exception as e:

src/plugins/built_in/napcat_adapter_plugin/src/database.py

@@ -1,162 +1,156 @@
-import os
-from typing import Optional, List
-from dataclasses import dataclass
-from sqlmodel import Field, Session, SQLModel, create_engine, select
+"""Napcat Adapter 插件数据库层 (基于主程序异步SQLAlchemy API)
 
+本模块替换原先的 sqlmodel + 同步Session 实现:
+1. 复用主项目的异步数据库连接与迁移体系
+2. 提供与旧接口名兼容的方法(update_ban_record/create_ban_record/delete_ban_record)
+3. 新增首选异步方法: update_ban_records / create_or_update / delete_record / get_ban_records
+
+数据语义:
+    user_id == 0 表示群全体禁言
+
+注意: 所有方法均为异步, 需要在 async 上下文中调用。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, List, Sequence
+
+from sqlalchemy import Column, Integer, BigInteger, UniqueConstraint, select, Index
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.common.database.sqlalchemy_models import Base, get_db_session
 from src.common.logger import get_logger
 
 logger = get_logger("napcat_adapter")
 
-"""
-表记录的方式：
-| group_id | user_id | lift_time |
-|----------|---------|-----------|
 
-其中使用 user_id == 0 表示群全体禁言
-"""
+class NapcatBanRecord(Base):
+    __tablename__ = "napcat_ban_records"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    group_id = Column(BigInteger, nullable=False, index=True)
+    user_id = Column(BigInteger, nullable=False, index=True)  # 0 == 全体禁言
+    lift_time = Column(BigInteger, nullable=True)  # -1 / None 表示未知/永久
+
+    __table_args__ = (
+        UniqueConstraint("group_id", "user_id", name="uq_napcat_group_user"),
+        Index("idx_napcat_ban_group", "group_id"),
+        Index("idx_napcat_ban_user", "user_id"),
+    )
 
 
 @dataclass
 class BanUser:
-    """
-    程序处理使用的实例
-    """
-
     user_id: int
     group_id: int
-    lift_time: Optional[int] = Field(default=-1)
+    lift_time: Optional[int] = -1
+
+    def identity(self) -> tuple[int, int]:
+        return self.group_id, self.user_id
 
 
-class DB_BanUser(SQLModel, table=True):
-    """
-    表示数据库中的用户禁言记录。
-    使用双重主键
-    """
+class NapcatDatabase:
+    async def _fetch_all(self, session: AsyncSession) -> Sequence[NapcatBanRecord]:
+        result = await session.execute(select(NapcatBanRecord))
+        return result.scalars().all()
 
-    user_id: int = Field(index=True, primary_key=True)  # 被禁言用户的用户 ID
-    group_id: int = Field(index=True, primary_key=True)  # 用户被禁言的群组 ID
-    lift_time: Optional[int]  # 禁言解除的时间（时间戳）
+    async def get_ban_records(self) -> List[BanUser]:
+        async with get_db_session() as session:
+            rows = await self._fetch_all(session)
+            return [BanUser(group_id=r.group_id, user_id=r.user_id, lift_time=r.lift_time) for r in rows]
 
+    async def update_ban_records(self, ban_list: List[BanUser]) -> None:
+        target_map = {b.identity(): b for b in ban_list}
+        async with get_db_session() as session:
+            rows = await self._fetch_all(session)
+            existing_map = {(r.group_id, r.user_id): r for r in rows}
 
-def is_identical(obj1: BanUser, obj2: BanUser) -> bool:
-    """
-    检查两个 BanUser 对象是否相同。
-    """
-    return obj1.user_id == obj2.user_id and obj1.group_id == obj2.group_id
-
-
-class DatabaseManager:
-    """
-    数据库管理类，负责与数据库交互。
-    """
-
-    def __init__(self):
-        os.makedirs(os.path.join(os.path.dirname(__file__), "..", "data"), exist_ok=True)  # 确保数据目录存在
-        DATABASE_FILE = os.path.join(os.path.dirname(__file__), "..", "data", "NapcatAdapter.db")
-        self.sqlite_url = f"sqlite:///{DATABASE_FILE}"  # SQLite 数据库 URL
-        self.engine = create_engine(self.sqlite_url, echo=False)  # 创建数据库引擎
-        self._ensure_database()  # 确保数据库和表已创建
-
-    def _ensure_database(self) -> None:
-        """
-        确保数据库和表已创建。
-        """
-        logger.info("确保数据库文件和表已创建...")
-        SQLModel.metadata.create_all(self.engine)
-        logger.info("数据库和表已创建或已存在")
-
-    def update_ban_record(self, ban_list: List[BanUser]) -> None:
-        # sourcery skip: class-extract-method
-        """
-        更新禁言列表到数据库。
-        支持在不存在时创建新记录，对于多余的项目自动删除。
-        """
-        with Session(self.engine) as session:
-            all_records = session.exec(select(DB_BanUser)).all()
-            for ban_user in ban_list:
-                statement = select(DB_BanUser).where(
-                    DB_BanUser.user_id == ban_user.user_id, DB_BanUser.group_id == ban_user.group_id
-                )
-                if existing_record := session.exec(statement).first():
-                    if existing_record.lift_time == ban_user.lift_time:
-                        logger.debug(f"禁言记录未变更: {existing_record}")
-                        continue
-                    # 更新现有记录的 lift_time
-                    existing_record.lift_time = ban_user.lift_time
-                    await session.add(existing_record)
-                    logger.debug(f"更新禁言记录: {existing_record}")
+            changed = 0
+            for ident, ban in target_map.items():
+                if ident in existing_map:
+                    row = existing_map[ident]
+                    if row.lift_time != ban.lift_time:
+                        row.lift_time = ban.lift_time
+                        changed += 1
                 else:
-                    # 创建新记录
-                    db_record = DB_BanUser(
-                        user_id=ban_user.user_id, group_id=ban_user.group_id, lift_time=ban_user.lift_time
+                    session.add(
+                        NapcatBanRecord(group_id=ban.group_id, user_id=ban.user_id, lift_time=ban.lift_time)
                     )
-                    await session.add(db_record)
-                    logger.debug(f"创建新禁言记录: {ban_user}")
-            # 删除不在 ban_list 中的记录
-            for db_record in all_records:
-                record = BanUser(user_id=db_record.user_id, group_id=db_record.group_id, lift_time=db_record.lift_time)
-                if not any(is_identical(record, ban_user) for ban_user in ban_list):
-                    statement = select(DB_BanUser).where(
-                        DB_BanUser.user_id == record.user_id, DB_BanUser.group_id == record.group_id
-                    )
-                    if ban_record := session.exec(statement).first():
-                        session.delete(ban_record)
+                    changed += 1
 
-                        logger.debug(f"删除禁言记录: {ban_record}")
-                    else:
-                        logger.info(f"未找到禁言记录: {ban_record}")
+            removed = 0
+            for ident, row in existing_map.items():
+                if ident not in target_map:
+                    await session.delete(row)
+                    removed += 1
 
-            logger.info("禁言记录已更新")
-
-    def get_ban_records(self) -> List[BanUser]:
-        """
-        读取所有禁言记录。
-        """
-        with Session(self.engine) as session:
-            statement = select(DB_BanUser)
-            records = session.exec(statement).all()
-            return [BanUser(user_id=item.user_id, group_id=item.group_id, lift_time=item.lift_time) for item in records]
-
-    def create_ban_record(self, ban_record: BanUser) -> None:
-        """
-        为特定群组中的用户创建禁言记录。
-        一个简化版本的添加方式，防止 update_ban_record 方法的复杂性。
-        其同时还是简化版的更新方式。
-        """
-        with Session(self.engine) as session:
-            # 检查记录是否已存在
-            statement = select(DB_BanUser).where(
-                DB_BanUser.user_id == ban_record.user_id, DB_BanUser.group_id == ban_record.group_id
+            logger.debug(
+                f"Napcat ban list sync => total_incoming={len(ban_list)} created_or_updated={changed} removed={removed}"
             )
-            existing_record = session.exec(statement).first()
-            if existing_record:
-                # 如果记录已存在，更新 lift_time
-                existing_record.lift_time = ban_record.lift_time
-                await session.add(existing_record)
-                logger.debug(f"更新禁言记录: {ban_record}")
+
+    async def create_or_update(self, ban_record: BanUser) -> None:
+        async with get_db_session() as session:
+            stmt = select(NapcatBanRecord).where(
+                NapcatBanRecord.group_id == ban_record.group_id,
+                NapcatBanRecord.user_id == ban_record.user_id,
+            )
+            result = await session.execute(stmt)
+            row = result.scalars().first()
+            if row:
+                if row.lift_time != ban_record.lift_time:
+                    row.lift_time = ban_record.lift_time
+                    logger.debug(
+                        f"更新禁言记录 group={ban_record.group_id} user={ban_record.user_id} lift={ban_record.lift_time}"
+                    )
             else:
-                # 如果记录不存在，创建新记录
-                db_record = DB_BanUser(
-                    user_id=ban_record.user_id, group_id=ban_record.group_id, lift_time=ban_record.lift_time
+                session.add(
+                    NapcatBanRecord(
+                        group_id=ban_record.group_id, user_id=ban_record.user_id, lift_time=ban_record.lift_time
+                    )
+                )
+                logger.debug(
+                    f"创建禁言记录 group={ban_record.group_id} user={ban_record.user_id} lift={ban_record.lift_time}"
                 )
-                await session.add(db_record)
-                logger.debug(f"创建新禁言记录: {ban_record}")
 
-    def delete_ban_record(self, ban_record: BanUser):
-        """
-        删除特定用户在特定群组中的禁言记录。
-        一个简化版本的删除方式，防止 update_ban_record 方法的复杂性。
-        """
-        user_id = ban_record.user_id
-        group_id = ban_record.group_id
-        with Session(self.engine) as session:
-            statement = select(DB_BanUser).where(DB_BanUser.user_id == user_id, DB_BanUser.group_id == group_id)
-            if ban_record := session.exec(statement).first():
-                session.delete(ban_record)
-
-                logger.debug(f"删除禁言记录: {ban_record}")
+    async def delete_record(self, ban_record: BanUser) -> None:
+        async with get_db_session() as session:
+            stmt = select(NapcatBanRecord).where(
+                NapcatBanRecord.group_id == ban_record.group_id,
+                NapcatBanRecord.user_id == ban_record.user_id,
+            )
+            result = await session.execute(stmt)
+            row = result.scalars().first()
+            if row:
+                await session.delete(row)
+                logger.debug(
+                    f"删除禁言记录 group={ban_record.group_id} user={ban_record.user_id} lift={row.lift_time}"
+                )
             else:
-                logger.info(f"未找到禁言记录: user_id: {user_id}, group_id: {group_id}")
+                logger.info(
+                    f"未找到禁言记录 group={ban_record.group_id} user={ban_record.user_id}"
+                )
+
+    # 兼容旧命名
+    async def update_ban_record(self, ban_list: List[BanUser]) -> None:  # old name
+        await self.update_ban_records(ban_list)
+
+    async def create_ban_record(self, ban_record: BanUser) -> None:  # old name
+        await self.create_or_update(ban_record)
+
+    async def delete_ban_record(self, ban_record: BanUser) -> None:  # old name
+        await self.delete_record(ban_record)
 
 
-db_manager = DatabaseManager()
+napcat_db = NapcatDatabase()
+
+
+def is_identical(a: BanUser, b: BanUser) -> bool:
+    return a.group_id == b.group_id and a.user_id == b.user_id
+
+
+__all__ = [
+    "BanUser",
+    "NapcatBanRecord",
+    "napcat_db",
+    "is_identical",
+]

src/plugins/built_in/napcat_adapter_plugin/src/recv_handler/notice_handler.py

@@ -9,7 +9,7 @@ from src.common.logger import get_logger
 logger = get_logger("napcat_adapter")
 
 from src.plugin_system.apis import config_api
-from ..database import BanUser, db_manager, is_identical
+from ..database import BanUser, napcat_db, is_identical
 from . import NoticeType, ACCEPT_FORMAT
 from .message_sending import message_send_instance
 from .message_handler import message_handler
@@ -62,7 +62,7 @@ class NoticeHandler:
             return self.server_connection
         return websocket_manager.get_connection()
 
-    def _ban_operation(self, group_id: int, user_id: Optional[int] = None, lift_time: Optional[int] = None) -> None:
+    async def _ban_operation(self, group_id: int, user_id: Optional[int] = None, lift_time: Optional[int] = None) -> None:
         """
         将用户禁言记录添加到self.banned_list中
         如果是全体禁言，则user_id为0
@@ -71,16 +71,16 @@ class NoticeHandler:
             user_id = 0  # 使用0表示全体禁言
             lift_time = -1
         ban_record = BanUser(user_id=user_id, group_id=group_id, lift_time=lift_time)
-        for record in self.banned_list:
+        for record in list(self.banned_list):
             if is_identical(record, ban_record):
                 self.banned_list.remove(record)
                 self.banned_list.append(ban_record)
-                db_manager.create_ban_record(ban_record)  # 作为更新
+                await napcat_db.create_ban_record(ban_record)  # 更新
                 return
         self.banned_list.append(ban_record)
-        db_manager.create_ban_record(ban_record)  # 添加到数据库
+        await napcat_db.create_ban_record(ban_record)  # 新建
 
-    def _lift_operation(self, group_id: int, user_id: Optional[int] = None) -> None:
+    async def _lift_operation(self, group_id: int, user_id: Optional[int] = None) -> None:
         """
         从self.lifted_group_list中移除已经解除全体禁言的群
         """
@@ -88,7 +88,12 @@ class NoticeHandler:
             user_id = 0  # 使用0表示全体禁言
         ban_record = BanUser(user_id=user_id, group_id=group_id, lift_time=-1)
         self.lifted_list.append(ban_record)
-        db_manager.delete_ban_record(ban_record)  # 删除数据库中的记录
+        # 从被禁言列表里移除对应记录
+        for record in list(self.banned_list):
+            if is_identical(record, ban_record):
+                self.banned_list.remove(record)
+                break
+        await napcat_db.delete_ban_record(ban_record)
 
     async def handle_notice(self, raw_message: dict) -> None:
         notice_type = raw_message.get("notice_type")
@@ -376,7 +381,7 @@ class NoticeHandler:
 
         if user_id == 0:  # 为全体禁言
             sub_type: str = "whole_ban"
-            self._ban_operation(group_id)
+            await self._ban_operation(group_id)
         else:  # 为单人禁言
             # 获取被禁言人的信息
             sub_type: str = "ban"
@@ -390,7 +395,7 @@ class NoticeHandler:
                 user_nickname=user_nickname,
                 user_cardname=user_cardname,
             )
-            self._ban_operation(group_id, user_id, int(time.time() + duration))
+            await self._ban_operation(group_id, user_id, int(time.time() + duration))
 
         seg_data: Seg = Seg(
             type="notify",
@@ -439,7 +444,7 @@ class NoticeHandler:
         user_id = raw_message.get("user_id")
         if user_id == 0:  # 全体禁言解除
             sub_type = "whole_lift_ban"
-            self._lift_operation(group_id)
+            await self._lift_operation(group_id)
         else:  # 单人禁言解除
             sub_type = "lift_ban"
             # 获取被解除禁言人的信息
@@ -455,7 +460,7 @@ class NoticeHandler:
                 user_nickname=user_nickname,
                 user_cardname=user_cardname,
             )
-            self._lift_operation(group_id, user_id)
+            await self._lift_operation(group_id, user_id)
 
         seg_data: Seg = Seg(
             type="notify",
@@ -483,7 +488,7 @@ class NoticeHandler:
                 group_id = lift_record.group_id
                 user_id = lift_record.user_id
 
-                db_manager.delete_ban_record(lift_record)  # 从数据库中删除禁言记录
+                asyncio.create_task(napcat_db.delete_ban_record(lift_record))  # 从数据库中删除禁言记录
 
                 seg_message: Seg = await self.natural_lift(group_id, user_id)
 

src/plugins/built_in/napcat_adapter_plugin/src/utils.py

@@ -6,7 +6,7 @@ import urllib3
 import ssl
 import io
 
-from .database import BanUser, db_manager
+from .database import BanUser, napcat_db
 from src.common.logger import get_logger
 
 logger = get_logger("napcat_adapter")
@@ -270,10 +270,11 @@ async def read_ban_list(
         ]
     """
     try:
-        ban_list = db_manager.get_ban_records()
+        ban_list = await napcat_db.get_ban_records()
         lifted_list: List[BanUser] = []
         logger.info("已经读取禁言列表")
-        for ban_record in ban_list:
+        # 复制列表以避免迭代中修改原列表问题
+        for ban_record in list(ban_list):
             if ban_record.user_id == 0:
                 fetched_group_info = await get_group_info(websocket, ban_record.group_id)
                 if fetched_group_info is None:
@@ -301,12 +302,12 @@ async def read_ban_list(
                     ban_list.remove(ban_record)
                 else:
                     ban_record.lift_time = lift_ban_time
-        db_manager.update_ban_record(ban_list)
+        await napcat_db.update_ban_record(ban_list)
         return ban_list, lifted_list
     except Exception as e:
         logger.error(f"读取禁言列表失败: {e}")
         return [], []
 
 
-def save_ban_record(list: List[BanUser]):
-    return db_manager.update_ban_record(list)
+async def save_ban_record(list: List[BanUser]):
+    return await napcat_db.update_ban_record(list)