Lightstar/backend/api/chat_history.py

"""
聊天历史API路由
"""
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import List, Optional
from datetime import datetime

from backend.core.database import get_db
from backend.core.models import User, ChatHistory, ChatMessage
from backend.core.auth import get_current_user

router = APIRouter(tags=["chat"], prefix="/chat-history")

class MessageCreate(BaseModel):
    role: str
    content: str
    
class MessageResponse(BaseModel):
    id: int
    role: str
    content: str
    timestamp: datetime
    
    class Config:
        orm_mode = True

class ChatHistoryCreate(BaseModel):
    title: str
    messages: List[MessageCreate]
    
class ChatHistoryResponse(BaseModel):
    id: int
    title: str
    created_at: datetime
    updated_at: datetime
    messages: List[MessageResponse]
    
    class Config:
        orm_mode = True
        
class ChatHistorySummary(BaseModel):
    id: int
    title: str
    created_at: datetime
    updated_at: datetime
    
    class Config:
        orm_mode = True

@router.post("/", response_model=ChatHistoryResponse)
async def create_chat_history(
    chat_data: ChatHistoryCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """创建新的聊天历史"""
    # 创建聊天历史
    chat = ChatHistory(
        user_id=current_user.id,
        title=chat_data.title
    )
    db.add(chat)
    db.commit()
    db.refresh(chat)
    
    # 添加消息
    for msg_data in chat_data.messages:
        message = ChatMessage(
            chat_id=chat.id,
            role=msg_data.role,
            content=msg_data.content
        )
        db.add(message)
    
    db.commit()
    db.refresh(chat)
    
    return chat

@router.get("/", response_model=List[ChatHistorySummary])
async def get_chat_histories(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """获取用户的所有聊天历史摘要"""
    chats = db.query(ChatHistory)\
        .filter(ChatHistory.user_id == current_user.id)\
        .order_by(ChatHistory.updated_at.desc())\
        .all()
    
    return chats

@router.get("/{chat_id}", response_model=ChatHistoryResponse)
async def get_chat_history(
    chat_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """获取特定聊天历史的详情"""
    chat = db.query(ChatHistory)\
        .filter(ChatHistory.id == chat_id, ChatHistory.user_id == current_user.id)\
        .first()
    
    if not chat:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="聊天历史不存在或无权访问"
        )
    
    return chat

@router.post("/{chat_id}/messages", response_model=MessageResponse)
async def add_message(
    chat_id: int,
    message: MessageCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """向现有聊天添加新消息"""
    # 检查聊天是否存在且属于当前用户
    chat = db.query(ChatHistory)\
        .filter(ChatHistory.id == chat_id, ChatHistory.user_id == current_user.id)\
        .first()
    
    if not chat:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="聊天历史不存在或无权访问"
        )
    
    # 创建新消息
    db_message = ChatMessage(
        chat_id=chat_id,
        role=message.role,
        content=message.content
    )
    
    # 更新聊天的更新时间
    chat.updated_at = datetime.utcnow()
    
    db.add(db_message)
    db.commit()
    db.refresh(db_message)
    
    return db_message

@router.delete("/{chat_id}")
async def delete_chat_history(
    chat_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """删除聊天历史"""
    chat = db.query(ChatHistory)\
        .filter(ChatHistory.id == chat_id, ChatHistory.user_id == current_user.id)\
        .first()
    
    if not chat:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="聊天历史不存在或无权访问"
        )
    
    # 删除聊天相关的所有消息
    db.query(ChatMessage).filter(ChatMessage.chat_id == chat_id).delete()
    
    # 删除聊天
    db.delete(chat)
    db.commit()
    
    return {"message": "聊天历史已删除"}