knowledge/router/knowledge_saas.py

from fastapi import APIRouter, Depends, HTTPException
from typing import Optional
from pydantic import BaseModel
from model.response import StandardResponse
from db.session import get_db
from sqlalchemy.orm import Session
from service.trunks_service import TrunksService
import logging

router = APIRouter(prefix="/saas", tags=["SaaS Knowledge Base"])

logger = logging.getLogger(__name__)

class PaginatedSearchRequest(BaseModel):
    keyword: Optional[str] = None
    pageNo: int = 1
    limit: int = 10
    knowledge_ids: Optional[List[str]] = None

class NodeCreateRequest(BaseModel):
    name: str
    category: str
    layout: Optional[str] = None
    version: Optional[str] = None
    embedding: Optional[List[float]] = None

class NodeUpdateRequest(BaseModel):
    layout: Optional[str] = None
    version: Optional[str] = None
    status: Optional[int] = None
    embedding: Optional[List[float]] = None

@router.post("/paginated_search", response_model=StandardResponse)
async def paginated_search(
    payload: PaginatedSearchRequest,
    db: Session = Depends(get_db)
):
    try:
        service = KGNodeService()
        search_params = {
            'keyword': payload.keyword,
            'pageNo': payload.pageNo,
            'limit': payload.limit,
            'knowledge_ids': payload.knowledge_ids
        }
        return service.paginated_search(search_params)
    except Exception as e:
        logger.error(f"分页查询失败: {str(e)}")
        raise HTTPException(
            status_code=500,
            detail=StandardResponse(
                success=False,
                error_code=500,
                error_msg=str(e)
            )
        )
    try:
        trunks_service = TrunksService()
        search_params = {
            'keyword': payload.keyword,
            'pageNo': payload.pageNo,
            'limit': payload.limit,
            'knowledge_ids': payload.knowledge_ids
        }
        result = trunks_service.paginated_search(search_params)
        return StandardResponse(
            success=True,
            data={
                'records': result['data'],
                'pagination': result['pagination']
            }
        )
    except Exception as e:
        logger.error(f"分页查询失败: {str(e)}")
        raise HTTPException(
            status_code=500,
            detail=StandardResponse(
                success=False,
                error_code=500,
                error_msg=str(e)
            )
        )

@router.post("/nodes", response_model=StandardResponse)
async def create_node(
    payload: NodeCreateRequest,
    db: Session = Depends(get_db)
):
    try:
        service = TrunksService()
        return service.create_node(payload.dict())
    except Exception as e:
        logger.error(f"创建节点失败: {str(e)}")
        raise HTTPException(500, detail=StandardResponse.error(str(e)))

@router.get("/nodes/{node_id}", response_model=StandardResponse)
async def get_node(
    node_id: int,
    db: Session = Depends(get_db)
):
    try:
        service = TrunksService()
        return service.get_node(node_id)
    except Exception as e:
        logger.error(f"获取节点失败: {str(e)}")
        raise HTTPException(500, detail=StandardResponse.error(str(e)))

@router.put("/nodes/{node_id}", response_model=StandardResponse)
async def update_node(
    node_id: int,
    payload: NodeUpdateRequest,
    db: Session = Depends(get_db)
):
    try:
        service = TrunksService()
        return service.update_node(node_id, payload.dict(exclude_unset=True))
    except Exception as e:
        logger.error(f"更新节点失败: {str(e)}")
        raise HTTPException(500, detail=StandardResponse.error(str(e)))

@router.delete("/nodes/{node_id}", response_model=StandardResponse)
async def delete_node(
    node_id: int,
    db: Session = Depends(get_db)
):
    try:
        service = TrunksService()
        return service.delete_node(node_id)
    except Exception as e:
        logger.error(f"删除节点失败: {str(e)}")
        raise HTTPException(500, detail=StandardResponse.error(str(e)))

saas_kb_router = router