重构工作流相关API，支持异步操作并引入异步数据库管理

app/api/endpoints/workflow.py

@@ -3,18 +3,19 @@ from datetime import datetime
 from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.workflow import WorkflowChain
 from app.core.config import global_vars
 from app.core.plugin import PluginManager
+from app.core.security import verify_token
 from app.core.workflow import WorkFlowManager
-from app.db import get_db
+from app.db import get_async_db, get_db
 from app.db.models import Workflow
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_user
-from app.db.workflow_oper import WorkflowOper
+from app.db.workflow_oper import AsyncWorkflowOper, WorkflowOper
 from app.helper.workflow import WorkflowHelper
 from app.scheduler import Scheduler
 from app.schemas.types import EventType, EVENT_TYPE_NAMES
@@ -23,23 +24,22 @@ router = APIRouter()
 
 
 @router.get("/", summary="所有工作流", response_model=List[schemas.Workflow])
-def list_workflows(db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def list_workflows(db: AsyncSession = Depends(get_async_db),
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取工作流列表
     """
-    from app.db.workflow_oper import WorkflowOper
-    return WorkflowOper(db).list()
+    return await AsyncWorkflowOper(db).list()
 
 
 @router.post("/", summary="创建工作流", response_model=schemas.Response)
-def create_workflow(workflow: schemas.Workflow,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def create_workflow(workflow: schemas.Workflow,
+                          db: AsyncSession = Depends(get_async_db),
+                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     创建工作流
     """
-    if workflow.name and WorkflowOper(db).get_by_name(workflow.name):
+    if workflow.name and await AsyncWorkflowOper(db).get_by_name(workflow.name):
         return schemas.Response(success=False, message="已存在相同名称的工作流")
     if not workflow.add_time:
         workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
@@ -47,12 +47,13 @@ def create_workflow(workflow: schemas.Workflow,
         workflow.state = "P"
     if not workflow.trigger_type:
         workflow.trigger_type = "timer"
-    Workflow(**workflow.dict()).create(db)
+    workflow_obj = Workflow(**workflow.dict())
+    await workflow_obj.async_create(db)
     return schemas.Response(success=True, message="创建工作流成功")
 
 
 @router.get("/plugin/actions", summary="查询插件动作", response_model=List[dict])
-def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取所有动作
     """
@@ -60,7 +61,7 @@ def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends
 
 
 @router.get("/actions", summary="所有动作", response_model=List[dict])
-def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def list_actions(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取所有动作
     """
@@ -68,7 +69,7 @@ def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) ->
 
 
 @router.get("/event_types", summary="获取所有事件类型", response_model=List[dict])
-def get_event_types(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def get_event_types(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取所有事件类型
     """
@@ -79,38 +80,38 @@ def get_event_types(_: schemas.TokenPayload = Depends(get_current_active_user))
 
 
 @router.post("/share", summary="分享工作流", response_model=schemas.Response)
-def workflow_share(
+async def workflow_share(
         workflow: schemas.WorkflowShare,
-        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     分享工作流
     """
     if not workflow.id or not workflow.share_title or not workflow.share_user:
         return schemas.Response(success=False, message="请填写工作流ID、分享标题和分享人")
 
-    state, errmsg = WorkflowHelper().workflow_share(workflow_id=workflow.id,
-                                                    share_title=workflow.share_title or "",
-                                                    share_comment=workflow.share_comment or "",
-                                                    share_user=workflow.share_user or "")
+    state, errmsg = await WorkflowHelper().async_workflow_share(workflow_id=workflow.id,
+                                                                share_title=workflow.share_title or "",
+                                                                share_comment=workflow.share_comment or "",
+                                                                share_user=workflow.share_user or "")
     return schemas.Response(success=state, message=errmsg)
 
 
 @router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
-def workflow_share_delete(
+async def workflow_share_delete(
         share_id: int,
-        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除分享
     """
-    state, errmsg = WorkflowHelper().share_delete(share_id=share_id)
+    state, errmsg = await WorkflowHelper().async_share_delete(share_id=share_id)
     return schemas.Response(success=state, message=errmsg)
 
 
 @router.post("/fork", summary="复用工作流", response_model=schemas.Response)
-def workflow_fork(
+async def workflow_fork(
         workflow: schemas.WorkflowShare,
-        db: Session = Depends(get_db),
-        _: schemas.User = Depends(get_current_active_user)) -> Any:
+        db: AsyncSession = Depends(get_async_db),
+        _: schemas.User = Depends(verify_token)) -> Any:
     """
     复用工作流
     """
@@ -148,36 +149,40 @@ def workflow_fork(
     }
 
     # 检查名称是否重复
-    if Workflow.get_by_name(db, workflow_dict["name"]):
+    workflow_oper = AsyncWorkflowOper(db)
+    if await workflow_oper.get_by_name(workflow_dict["name"]):
         return schemas.Response(success=False, message="已存在相同名称的工作流")
 
     # 创建新工作流
-    workflow = Workflow(**workflow_dict)
-    workflow.create(db)
+    workflow_obj = Workflow(**workflow_dict)
+    await workflow_obj.async_create(db)
+
+    # 获取工作流ID（在数据库会话有效时）
+    workflow = await workflow_oper.get_by_name(workflow_dict["name"])
 
     # 更新复用次数
-    if workflow.id:
-        WorkflowHelper().workflow_fork(share_id=workflow.id)
+    if workflow:
+        await WorkflowHelper().async_workflow_fork(share_id=workflow.id)
 
     return schemas.Response(success=True, message="复用成功")
 
 
 @router.get("/shares", summary="查询分享的工作流", response_model=List[schemas.WorkflowShare])
-def workflow_shares(
+async def workflow_shares(
         name: Optional[str] = None,
         page: Optional[int] = 1,
         count: Optional[int] = 30,
-        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询分享的工作流
     """
-    return WorkflowHelper().get_shares(name=name, page=page, count=count)
+    return await WorkflowHelper().async_get_shares(name=name, page=page, count=count)
 
 
 @router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
 def run_workflow(workflow_id: int,
                  from_begin: Optional[bool] = True,
-                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     执行工作流
     """
@@ -190,11 +195,10 @@ def run_workflow(workflow_id: int,
 @router.post("/{workflow_id}/start", summary="启用工作流", response_model=schemas.Response)
 def start_workflow(workflow_id: int,
                    db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     启用工作流
     """
-    from app.db.workflow_oper import WorkflowOper
     workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
@@ -212,7 +216,7 @@ def start_workflow(workflow_id: int,
 @router.post("/{workflow_id}/pause", summary="停用工作流", response_model=schemas.Response)
 def pause_workflow(workflow_id: int,
                    db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     停用工作流
     """
@@ -234,53 +238,52 @@ def pause_workflow(workflow_id: int,
 
 
 @router.post("/{workflow_id}/reset", summary="重置工作流", response_model=schemas.Response)
-def reset_workflow(workflow_id: int,
-                   db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def reset_workflow(workflow_id: int,
+                         db: AsyncSession = Depends(get_async_db),
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     重置工作流
     """
-    from app.db.workflow_oper import WorkflowOper
-    workflow = WorkflowOper(db).get(workflow_id)
+    workflow = await AsyncWorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
     # 停止工作流
     global_vars.stop_workflow(workflow_id)
     # 重置工作流
-    workflow.reset(db, workflow_id, reset_count=True)
+    await Workflow.async_reset(db, workflow_id, reset_count=True)
     # 删除缓存
     SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
     return schemas.Response(success=True)
 
 
 @router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
-def get_workflow(workflow_id: int,
-                 db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+async def get_workflow(workflow_id: int,
+                       db: AsyncSession = Depends(get_async_db),
+                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取工作流详情
     """
-    from app.db.workflow_oper import WorkflowOper
-    return WorkflowOper(db).get(workflow_id)
+    return await AsyncWorkflowOper(db).get(workflow_id)
 
 
 @router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
 def update_workflow(workflow: schemas.Workflow,
                     db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     更新工作流
     """
     if not workflow.id:
         return schemas.Response(success=False, message="工作流ID不能为空")
-    wf = WorkflowOper(db).get(workflow.id)
+    workflow_oper = WorkflowOper(db)
+    wf = workflow_oper.get(workflow.id)
     if not wf:
         return schemas.Response(success=False, message="工作流不存在")
     if not wf.trigger_type:
         workflow.trigger_type = "timer"
     wf.update(db, workflow.dict())
     # 更新后的工作流对象
-    updated_workflow = wf.get(workflow.id)
+    updated_workflow = workflow_oper.get(workflow.id)
     # 更新定时任务
     Scheduler().update_workflow_job(updated_workflow)
     # 更新事件注册
@@ -291,7 +294,7 @@ def update_workflow(workflow: schemas.Workflow,
 @router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
 def delete_workflow(workflow_id: int,
                     db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除工作流
     """