840 lines
26 KiB
Python
840 lines
26 KiB
Python
"""
|
||
故事相关API路由
|
||
"""
|
||
import random
|
||
from fastapi import APIRouter, Depends, Query, HTTPException
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from sqlalchemy import select, update, func, distinct
|
||
from typing import Optional, List
|
||
from pydantic import BaseModel
|
||
|
||
from app.database import get_db
|
||
from app.models.story import Story, StoryNode, StoryChoice, StoryCharacter
|
||
|
||
router = APIRouter()
|
||
|
||
|
||
# ========== 请求/响应模型 ==========
|
||
class LikeRequest(BaseModel):
|
||
like: bool
|
||
|
||
|
||
class RewriteRequest(BaseModel):
|
||
ending_name: str
|
||
ending_content: str
|
||
prompt: str
|
||
|
||
|
||
class PathHistoryItem(BaseModel):
|
||
nodeKey: str
|
||
content: str = ""
|
||
choice: str = ""
|
||
|
||
|
||
class RewriteBranchRequest(BaseModel):
|
||
userId: int
|
||
currentNodeKey: str
|
||
pathHistory: List[PathHistoryItem]
|
||
currentContent: str
|
||
prompt: str
|
||
|
||
|
||
class NodeImageUpdate(BaseModel):
|
||
nodeKey: str
|
||
backgroundImage: str = ""
|
||
characterImage: str = ""
|
||
|
||
|
||
class CharacterImageUpdate(BaseModel):
|
||
characterId: int
|
||
avatarUrl: str = ""
|
||
|
||
|
||
class ImageConfigRequest(BaseModel):
|
||
coverUrl: str = ""
|
||
nodes: List[NodeImageUpdate] = []
|
||
characters: List[CharacterImageUpdate] = []
|
||
|
||
|
||
class GenerateImageRequest(BaseModel):
|
||
prompt: str
|
||
style: str = "anime" # anime/realistic/illustration
|
||
category: str = "character" # character/background/cover
|
||
storyId: Optional[int] = None
|
||
targetField: Optional[str] = None # coverUrl/backgroundImage/characterImage/avatarUrl
|
||
targetKey: Optional[str] = None # nodeKey 或 characterId
|
||
|
||
|
||
# ========== API接口 ==========
|
||
|
||
@router.get("")
|
||
async def get_stories(
|
||
category: Optional[str] = Query(None),
|
||
featured: bool = Query(False),
|
||
limit: int = Query(20, ge=1, le=100),
|
||
offset: int = Query(0, ge=0),
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""获取故事列表"""
|
||
query = select(Story).where(Story.status == 1)
|
||
|
||
if category:
|
||
query = query.where(Story.category == category)
|
||
if featured:
|
||
query = query.where(Story.is_featured == True)
|
||
|
||
query = query.order_by(Story.is_featured.desc(), Story.play_count.desc())
|
||
query = query.limit(limit).offset(offset)
|
||
|
||
result = await db.execute(query)
|
||
stories = result.scalars().all()
|
||
|
||
data = [{
|
||
"id": s.id,
|
||
"title": s.title,
|
||
"cover_url": s.cover_url,
|
||
"description": s.description,
|
||
"category": s.category,
|
||
"play_count": s.play_count,
|
||
"like_count": s.like_count,
|
||
"is_featured": s.is_featured
|
||
} for s in stories]
|
||
|
||
return {"code": 0, "data": data}
|
||
|
||
|
||
@router.get("/hot")
|
||
async def get_hot_stories(
|
||
limit: int = Query(10, ge=1, le=50),
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""获取热门故事"""
|
||
query = select(Story).where(Story.status == 1).order_by(Story.play_count.desc()).limit(limit)
|
||
result = await db.execute(query)
|
||
stories = result.scalars().all()
|
||
|
||
data = [{
|
||
"id": s.id,
|
||
"title": s.title,
|
||
"cover_url": s.cover_url,
|
||
"description": s.description,
|
||
"category": s.category,
|
||
"play_count": s.play_count,
|
||
"like_count": s.like_count
|
||
} for s in stories]
|
||
|
||
return {"code": 0, "data": data}
|
||
|
||
|
||
@router.get("/categories")
|
||
async def get_categories(db: AsyncSession = Depends(get_db)):
|
||
"""获取分类列表"""
|
||
query = select(distinct(Story.category)).where(Story.status == 1)
|
||
result = await db.execute(query)
|
||
categories = [row[0] for row in result.all()]
|
||
|
||
return {"code": 0, "data": categories}
|
||
|
||
|
||
@router.get("/test-image-gen")
|
||
async def test_image_generation():
|
||
"""测试图片生成服务是否正常"""
|
||
from app.config import get_settings
|
||
from app.services.image_gen import get_image_gen_service
|
||
import httpx
|
||
|
||
settings = get_settings()
|
||
results = {
|
||
"api_key_configured": bool(settings.gemini_api_key),
|
||
"api_key_preview": settings.gemini_api_key[:8] + "..." if settings.gemini_api_key else "未配置",
|
||
"base_url": "https://work.poloapi.com/v1beta",
|
||
"network_test": None,
|
||
"generate_test": None
|
||
}
|
||
|
||
# 测试网络连接
|
||
try:
|
||
async with httpx.AsyncClient(timeout=10.0) as client:
|
||
response = await client.get("https://work.poloapi.com")
|
||
results["network_test"] = {
|
||
"success": response.status_code < 500,
|
||
"status_code": response.status_code,
|
||
"message": "网络连接正常" if response.status_code < 500 else "服务端错误"
|
||
}
|
||
except Exception as e:
|
||
results["network_test"] = {
|
||
"success": False,
|
||
"error": str(e),
|
||
"message": "网络连接失败"
|
||
}
|
||
|
||
# 测试实际生图（简单测试）
|
||
if settings.gemini_api_key:
|
||
try:
|
||
service = get_image_gen_service()
|
||
gen_result = await service.generate_image(
|
||
prompt="a simple red circle on white background",
|
||
image_type="avatar",
|
||
style="illustration"
|
||
)
|
||
results["generate_test"] = {
|
||
"success": gen_result.get("success", False),
|
||
"error": gen_result.get("error") if not gen_result.get("success") else None,
|
||
"has_image_data": bool(gen_result.get("image_data"))
|
||
}
|
||
except Exception as e:
|
||
results["generate_test"] = {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
else:
|
||
results["generate_test"] = {
|
||
"success": False,
|
||
"error": "API Key 未配置"
|
||
}
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": "测试完成",
|
||
"data": results
|
||
}
|
||
|
||
|
||
@router.get("/test-deepseek")
|
||
async def test_deepseek():
|
||
"""测试 DeepSeek AI 服务是否正常"""
|
||
from app.config import get_settings
|
||
import httpx
|
||
|
||
settings = get_settings()
|
||
results = {
|
||
"ai_service_enabled": settings.ai_service_enabled,
|
||
"provider": settings.ai_provider,
|
||
"api_key_configured": bool(settings.deepseek_api_key),
|
||
"api_key_preview": settings.deepseek_api_key[:8] + "..." + settings.deepseek_api_key[-4:] if settings.deepseek_api_key and len(settings.deepseek_api_key) > 12 else "未配置或太短",
|
||
"base_url": settings.deepseek_base_url,
|
||
"model": settings.deepseek_model,
|
||
"network_test": None,
|
||
"api_test": None
|
||
}
|
||
|
||
# 测试网络连接
|
||
try:
|
||
async with httpx.AsyncClient(timeout=10.0) as client:
|
||
response = await client.get("https://api.deepseek.com")
|
||
results["network_test"] = {
|
||
"success": response.status_code < 500,
|
||
"status_code": response.status_code,
|
||
"message": "网络连接正常"
|
||
}
|
||
except Exception as e:
|
||
results["network_test"] = {
|
||
"success": False,
|
||
"error": str(e),
|
||
"message": "网络连接失败"
|
||
}
|
||
|
||
# 测试 API 调用
|
||
if settings.deepseek_api_key:
|
||
try:
|
||
async with httpx.AsyncClient(timeout=30.0) as client:
|
||
response = await client.post(
|
||
f"{settings.deepseek_base_url}/chat/completions",
|
||
headers={
|
||
"Content-Type": "application/json",
|
||
"Authorization": f"Bearer {settings.deepseek_api_key}"
|
||
},
|
||
json={
|
||
"model": settings.deepseek_model,
|
||
"messages": [{"role": "user", "content": "说'测试成功'两个字"}],
|
||
"max_tokens": 10
|
||
}
|
||
)
|
||
|
||
if response.status_code == 200:
|
||
data = response.json()
|
||
content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
|
||
results["api_test"] = {
|
||
"success": True,
|
||
"status_code": 200,
|
||
"response": content[:50]
|
||
}
|
||
else:
|
||
results["api_test"] = {
|
||
"success": False,
|
||
"status_code": response.status_code,
|
||
"error": response.text[:200]
|
||
}
|
||
except Exception as e:
|
||
results["api_test"] = {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
else:
|
||
results["api_test"] = {
|
||
"success": False,
|
||
"error": "API Key 未配置"
|
||
}
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": "测试完成",
|
||
"data": results
|
||
}
|
||
|
||
|
||
@router.get("/test-cloud-upload")
|
||
async def test_cloud_upload():
|
||
"""测试云存储上传是否正常"""
|
||
import os
|
||
import httpx
|
||
|
||
tcb_env = os.environ.get("TCB_ENV") or os.environ.get("CBR_ENV_ID")
|
||
|
||
results = {
|
||
"env_id": tcb_env,
|
||
"is_cloud": bool(tcb_env)
|
||
}
|
||
|
||
if not tcb_env:
|
||
return {
|
||
"code": 1,
|
||
"message": "非云托管环境，无法测试云存储上传",
|
||
"data": results
|
||
}
|
||
|
||
try:
|
||
# 测试获取上传链接
|
||
async with httpx.AsyncClient(timeout=30.0) as client:
|
||
resp = await client.post(
|
||
"http://api.weixin.qq.com/tcb/uploadfile",
|
||
json={
|
||
"env": tcb_env,
|
||
"path": "test/cloud_upload_test.txt"
|
||
},
|
||
headers={"Content-Type": "application/json"}
|
||
)
|
||
|
||
results["status_code"] = resp.status_code
|
||
results["response"] = resp.text[:500] if resp.text else ""
|
||
|
||
if resp.status_code == 200:
|
||
data = resp.json()
|
||
if data.get("errcode", 0) == 0:
|
||
results["upload_url"] = data.get("url", "")[:100]
|
||
results["file_id"] = data.get("file_id", "")
|
||
return {
|
||
"code": 0,
|
||
"message": "云存储上传链接获取成功",
|
||
"data": results
|
||
}
|
||
else:
|
||
results["errcode"] = data.get("errcode")
|
||
results["errmsg"] = data.get("errmsg")
|
||
return {
|
||
"code": 1,
|
||
"message": f"获取上传链接失败: {data.get('errmsg')}",
|
||
"data": results
|
||
}
|
||
else:
|
||
return {
|
||
"code": 1,
|
||
"message": f"请求失败: HTTP {resp.status_code}",
|
||
"data": results
|
||
}
|
||
|
||
except Exception as e:
|
||
results["error"] = str(e)
|
||
return {
|
||
"code": 1,
|
||
"message": f"测试异常: {str(e)}",
|
||
"data": results
|
||
}
|
||
|
||
|
||
@router.get("/{story_id}")
|
||
async def get_story_detail(story_id: int, db: AsyncSession = Depends(get_db)):
|
||
"""获取故事详情（含节点和选项）"""
|
||
# 获取故事
|
||
result = await db.execute(select(Story).where(Story.id == story_id, Story.status == 1))
|
||
story = result.scalar_one_or_none()
|
||
|
||
if not story:
|
||
raise HTTPException(status_code=404, detail="故事不存在")
|
||
|
||
# 获取节点
|
||
nodes_result = await db.execute(
|
||
select(StoryNode).where(StoryNode.story_id == story_id).order_by(StoryNode.sort_order)
|
||
)
|
||
nodes = nodes_result.scalars().all()
|
||
|
||
# 获取选项
|
||
choices_result = await db.execute(
|
||
select(StoryChoice).where(StoryChoice.story_id == story_id).order_by(StoryChoice.sort_order)
|
||
)
|
||
choices = choices_result.scalars().all()
|
||
|
||
# 组装节点和选项
|
||
nodes_map = {}
|
||
for node in nodes:
|
||
nodes_map[node.node_key] = {
|
||
"id": node.id,
|
||
"node_key": node.node_key,
|
||
"content": node.content,
|
||
"speaker": node.speaker,
|
||
"background_image": node.background_image,
|
||
"character_image": node.character_image,
|
||
"bgm": node.bgm,
|
||
"is_ending": node.is_ending,
|
||
"ending_name": node.ending_name,
|
||
"ending_score": node.ending_score,
|
||
"ending_type": node.ending_type,
|
||
"choices": []
|
||
}
|
||
|
||
for choice in choices:
|
||
# 找到对应的节点
|
||
for node in nodes:
|
||
if node.id == choice.node_id and node.node_key in nodes_map:
|
||
nodes_map[node.node_key]["choices"].append({
|
||
"text": choice.text,
|
||
"nextNodeKey": choice.next_node_key,
|
||
"isLocked": choice.is_locked
|
||
})
|
||
break
|
||
|
||
data = {
|
||
"id": story.id,
|
||
"title": story.title,
|
||
"cover_url": story.cover_url,
|
||
"description": story.description,
|
||
"category": story.category,
|
||
"author_id": story.author_id,
|
||
"play_count": story.play_count,
|
||
"like_count": story.like_count,
|
||
"is_featured": story.is_featured,
|
||
"nodes": nodes_map
|
||
}
|
||
|
||
return {"code": 0, "data": data}
|
||
|
||
|
||
@router.post("/{story_id}/play")
|
||
async def record_play(story_id: int, db: AsyncSession = Depends(get_db)):
|
||
"""记录游玩"""
|
||
await db.execute(
|
||
update(Story).where(Story.id == story_id).values(play_count=Story.play_count + 1)
|
||
)
|
||
await db.commit()
|
||
return {"code": 0, "message": "记录成功"}
|
||
|
||
|
||
@router.post("/{story_id}/like")
|
||
async def toggle_like(story_id: int, request: LikeRequest, db: AsyncSession = Depends(get_db)):
|
||
"""点赞/取消点赞"""
|
||
delta = 1 if request.like else -1
|
||
await db.execute(
|
||
update(Story).where(Story.id == story_id).values(like_count=Story.like_count + delta)
|
||
)
|
||
await db.commit()
|
||
return {"code": 0, "message": "点赞成功" if request.like else "取消点赞成功"}
|
||
|
||
|
||
@router.post("/{story_id}/rewrite")
|
||
async def ai_rewrite_ending(story_id: int, request: RewriteRequest, db: AsyncSession = Depends(get_db)):
|
||
"""AI改写结局"""
|
||
import json
|
||
import re
|
||
|
||
if not request.prompt:
|
||
raise HTTPException(status_code=400, detail="请输入改写指令")
|
||
|
||
# 获取故事信息
|
||
result = await db.execute(select(Story).where(Story.id == story_id))
|
||
story = result.scalar_one_or_none()
|
||
|
||
if not story:
|
||
raise HTTPException(status_code=404, detail="故事不存在")
|
||
|
||
# 获取故事角色
|
||
char_result = await db.execute(
|
||
select(StoryCharacter).where(StoryCharacter.story_id == story_id)
|
||
)
|
||
characters = [
|
||
{
|
||
"name": c.name,
|
||
"role_type": c.role_type,
|
||
"gender": c.gender,
|
||
"age_range": c.age_range,
|
||
"appearance": c.appearance,
|
||
"personality": c.personality
|
||
}
|
||
for c in char_result.scalars().all()
|
||
]
|
||
|
||
# 调用 AI 服务
|
||
from app.services.ai import ai_service
|
||
|
||
ai_result = await ai_service.rewrite_ending(
|
||
story_title=story.title,
|
||
story_category=story.category or "未知",
|
||
ending_name=request.ending_name or "未知结局",
|
||
ending_content=request.ending_content or "",
|
||
user_prompt=request.prompt,
|
||
characters=characters
|
||
)
|
||
|
||
if ai_result and ai_result.get("content"):
|
||
content = ai_result["content"]
|
||
ending_name = f"{request.ending_name}（AI改写）"
|
||
|
||
# 尝试解析 JSON 格式的返回
|
||
try:
|
||
# 提取 JSON 部分
|
||
json_match = re.search(r'\{[^{}]*"ending_name"[^{}]*"content"[^{}]*\}', content, re.DOTALL)
|
||
if json_match:
|
||
parsed = json.loads(json_match.group())
|
||
ending_name = parsed.get("ending_name", ending_name)
|
||
content = parsed.get("content", content)
|
||
else:
|
||
# 尝试直接解析整个内容
|
||
parsed = json.loads(content)
|
||
ending_name = parsed.get("ending_name", ending_name)
|
||
content = parsed.get("content", content)
|
||
except (json.JSONDecodeError, AttributeError):
|
||
# 解析失败，使用原始内容
|
||
pass
|
||
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"content": content,
|
||
"speaker": "旁白",
|
||
"is_ending": True,
|
||
"ending_name": ending_name,
|
||
"ending_type": "rewrite",
|
||
"tokens_used": ai_result.get("tokens_used", 0)
|
||
}
|
||
}
|
||
|
||
# AI 服务不可用时的降级处理
|
||
templates = [
|
||
f"根据你的愿望「{request.prompt}」，故事有了新的发展...\n\n",
|
||
f"命运的齿轮开始转动，{request.prompt}...\n\n",
|
||
f"在另一个平行世界里，{request.prompt}成为了现实...\n\n"
|
||
]
|
||
|
||
template = random.choice(templates)
|
||
new_content = (
|
||
template +
|
||
"原本的结局被改写，新的故事在这里展开。\n\n" +
|
||
f"【提示】AI服务暂时不可用，这是模板内容。"
|
||
)
|
||
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"content": new_content,
|
||
"speaker": "旁白",
|
||
"is_ending": True,
|
||
"ending_name": f"{request.ending_name}（改写版）",
|
||
"ending_type": "rewrite"
|
||
}
|
||
}
|
||
|
||
|
||
@router.post("/{story_id}/rewrite-branch")
|
||
async def ai_rewrite_branch(
|
||
story_id: int,
|
||
request: RewriteBranchRequest,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""AI改写中间章节，生成新的剧情分支"""
|
||
if not request.prompt:
|
||
raise HTTPException(status_code=400, detail="请输入改写指令")
|
||
|
||
# 获取故事信息
|
||
result = await db.execute(select(Story).where(Story.id == story_id))
|
||
story = result.scalar_one_or_none()
|
||
|
||
if not story:
|
||
raise HTTPException(status_code=404, detail="故事不存在")
|
||
|
||
# 获取故事角色
|
||
char_result = await db.execute(
|
||
select(StoryCharacter).where(StoryCharacter.story_id == story_id)
|
||
)
|
||
characters = [
|
||
{
|
||
"name": c.name,
|
||
"role_type": c.role_type,
|
||
"gender": c.gender,
|
||
"age_range": c.age_range,
|
||
"appearance": c.appearance,
|
||
"personality": c.personality
|
||
}
|
||
for c in char_result.scalars().all()
|
||
]
|
||
|
||
# 将 Pydantic 模型转换为字典列表
|
||
path_history = [
|
||
{"nodeKey": item.nodeKey, "content": item.content, "choice": item.choice}
|
||
for item in request.pathHistory
|
||
]
|
||
|
||
# 调用 AI 服务
|
||
from app.services.ai import ai_service
|
||
|
||
ai_result = await ai_service.rewrite_branch(
|
||
story_title=story.title,
|
||
story_category=story.category or "未知",
|
||
path_history=path_history,
|
||
current_content=request.currentContent,
|
||
user_prompt=request.prompt,
|
||
characters=characters
|
||
)
|
||
|
||
if ai_result and ai_result.get("nodes"):
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"nodes": ai_result["nodes"],
|
||
"entryNodeKey": ai_result.get("entryNodeKey", "branch_1"),
|
||
"tokensUsed": ai_result.get("tokens_used", 0)
|
||
}
|
||
}
|
||
|
||
# AI 服务不可用时，返回空结果（不使用兜底模板）
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"nodes": None,
|
||
"entryNodeKey": None,
|
||
"tokensUsed": 0,
|
||
"error": "AI服务暂时不可用"
|
||
}
|
||
}
|
||
|
||
|
||
@router.get("/{story_id}/images")
|
||
async def get_story_images(story_id: int, db: AsyncSession = Depends(get_db)):
|
||
"""获取故事的所有图片配置"""
|
||
# 获取故事封面
|
||
result = await db.execute(select(Story).where(Story.id == story_id))
|
||
story = result.scalar_one_or_none()
|
||
if not story:
|
||
raise HTTPException(status_code=404, detail="故事不存在")
|
||
|
||
# 获取所有节点的图片
|
||
nodes_result = await db.execute(
|
||
select(StoryNode).where(StoryNode.story_id == story_id).order_by(StoryNode.sort_order)
|
||
)
|
||
nodes = nodes_result.scalars().all()
|
||
|
||
# 获取所有角色的头像
|
||
chars_result = await db.execute(
|
||
select(StoryCharacter).where(StoryCharacter.story_id == story_id)
|
||
)
|
||
characters = chars_result.scalars().all()
|
||
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"storyId": story_id,
|
||
"title": story.title,
|
||
"coverUrl": story.cover_url or "",
|
||
"nodes": [
|
||
{
|
||
"nodeKey": n.node_key,
|
||
"content": n.content[:50] + "..." if len(n.content) > 50 else n.content,
|
||
"backgroundImage": n.background_image or "",
|
||
"characterImage": n.character_image or "",
|
||
"isEnding": n.is_ending,
|
||
"endingName": n.ending_name or ""
|
||
}
|
||
for n in nodes
|
||
],
|
||
"characters": [
|
||
{
|
||
"characterId": c.id,
|
||
"name": c.name,
|
||
"roleType": c.role_type,
|
||
"avatarUrl": c.avatar_url or "",
|
||
"avatarPrompt": c.avatar_prompt or ""
|
||
}
|
||
for c in characters
|
||
]
|
||
}
|
||
}
|
||
|
||
|
||
@router.put("/{story_id}/images")
|
||
async def update_story_images(
|
||
story_id: int,
|
||
request: ImageConfigRequest,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""批量更新故事的图片配置"""
|
||
# 验证故事存在
|
||
result = await db.execute(select(Story).where(Story.id == story_id))
|
||
story = result.scalar_one_or_none()
|
||
if not story:
|
||
raise HTTPException(status_code=404, detail="故事不存在")
|
||
|
||
updated = {"cover": False, "nodes": 0, "characters": 0}
|
||
|
||
# 更新封面
|
||
if request.coverUrl:
|
||
await db.execute(
|
||
update(Story).where(Story.id == story_id).values(cover_url=request.coverUrl)
|
||
)
|
||
updated["cover"] = True
|
||
|
||
# 更新节点图片
|
||
for node_img in request.nodes:
|
||
values = {}
|
||
if node_img.backgroundImage:
|
||
values["background_image"] = node_img.backgroundImage
|
||
if node_img.characterImage:
|
||
values["character_image"] = node_img.characterImage
|
||
if values:
|
||
await db.execute(
|
||
update(StoryNode)
|
||
.where(StoryNode.story_id == story_id, StoryNode.node_key == node_img.nodeKey)
|
||
.values(**values)
|
||
)
|
||
updated["nodes"] += 1
|
||
|
||
# 更新角色头像
|
||
for char_img in request.characters:
|
||
if char_img.avatarUrl:
|
||
await db.execute(
|
||
update(StoryCharacter)
|
||
.where(StoryCharacter.id == char_img.characterId, StoryCharacter.story_id == story_id)
|
||
.values(avatar_url=char_img.avatarUrl)
|
||
)
|
||
updated["characters"] += 1
|
||
|
||
await db.commit()
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": "更新成功",
|
||
"data": updated
|
||
}
|
||
|
||
|
||
@router.post("/generate-image")
|
||
async def generate_story_image(
|
||
request: GenerateImageRequest,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""使用AI生成图片并可选保存到故事"""
|
||
from app.services.image_gen import get_image_gen_service
|
||
|
||
# 生成图片
|
||
result = await get_image_gen_service().generate_and_save(
|
||
prompt=request.prompt,
|
||
category=request.category,
|
||
style=request.style
|
||
)
|
||
|
||
if not result.get("success"):
|
||
return {
|
||
"code": 1,
|
||
"message": result.get("error", "生成失败"),
|
||
"data": None
|
||
}
|
||
|
||
image_url = result["url"]
|
||
|
||
# 如果指定了故事和目标字段，自动更新
|
||
if request.storyId and request.targetField:
|
||
if request.targetField == "coverUrl":
|
||
await db.execute(
|
||
update(Story).where(Story.id == request.storyId).values(cover_url=image_url)
|
||
)
|
||
elif request.targetField == "backgroundImage" and request.targetKey:
|
||
await db.execute(
|
||
update(StoryNode)
|
||
.where(StoryNode.story_id == request.storyId, StoryNode.node_key == request.targetKey)
|
||
.values(background_image=image_url)
|
||
)
|
||
elif request.targetField == "characterImage" and request.targetKey:
|
||
await db.execute(
|
||
update(StoryNode)
|
||
.where(StoryNode.story_id == request.storyId, StoryNode.node_key == request.targetKey)
|
||
.values(character_image=image_url)
|
||
)
|
||
elif request.targetField == "avatarUrl" and request.targetKey:
|
||
await db.execute(
|
||
update(StoryCharacter)
|
||
.where(StoryCharacter.story_id == request.storyId, StoryCharacter.id == int(request.targetKey))
|
||
.values(avatar_url=image_url)
|
||
)
|
||
await db.commit()
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": "生成成功",
|
||
"data": {
|
||
"url": image_url,
|
||
"filename": result.get("filename"),
|
||
"saved": bool(request.storyId and request.targetField)
|
||
}
|
||
}
|
||
|
||
|
||
@router.post("/{story_id}/generate-all-images")
|
||
async def generate_all_story_images(
|
||
story_id: int,
|
||
style: str = "anime",
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""为故事批量生成所有角色头像"""
|
||
from app.services.image_gen import get_image_gen_service
|
||
image_service = get_image_gen_service()
|
||
|
||
# 获取所有角色
|
||
result = await db.execute(
|
||
select(StoryCharacter).where(StoryCharacter.story_id == story_id)
|
||
)
|
||
characters = result.scalars().all()
|
||
|
||
if not characters:
|
||
return {"code": 1, "message": "故事没有角色数据", "data": None}
|
||
|
||
generated = []
|
||
failed = []
|
||
|
||
for char in characters:
|
||
# 使用avatar_prompt或自动构建
|
||
prompt = char.avatar_prompt or f"{char.name}, {char.gender}, {char.appearance or ''}"
|
||
|
||
gen_result = await image_service.generate_and_save(
|
||
prompt=prompt,
|
||
category="character",
|
||
style=style
|
||
)
|
||
|
||
if gen_result.get("success"):
|
||
# 更新数据库
|
||
await db.execute(
|
||
update(StoryCharacter)
|
||
.where(StoryCharacter.id == char.id)
|
||
.values(avatar_url=gen_result["url"])
|
||
)
|
||
generated.append({"id": char.id, "name": char.name, "url": gen_result["url"]})
|
||
else:
|
||
failed.append({"id": char.id, "name": char.name, "error": gen_result.get("error")})
|
||
|
||
await db.commit()
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": f"生成完成: {len(generated)}成功, {len(failed)}失败",
|
||
"data": {
|
||
"generated": generated,
|
||
"failed": failed
|
||
}
|
||
} |