feat: 完成布局优化 - 操作列固定、批量按钮自适应、分类标签带数量

优化内容: 1. 表格布局: - 使用 calc(100vw - 160px) 确保表格不超出视口 - 操作列 fixed='right' 固定在右侧，宽度 300px - 按钮 3 个后自动换行 (max-width: 200px) - 恢复合理列宽，不再过度压缩 2. 批量操作区域: - 容器改为 inline-block，宽度自适应按钮内容 - 背景宽度与按钮总宽度匹配 3. 分类标签: - 显示数量 (如 '待处理 (20)') - 点击切换筛选，去掉误导的 'X' 图标 4. 删除功能: - 操作列增加删除按钮 - 删除前弹出确认对话框 5. 系统日志: - 修复后端日志路径 (parents[4]) - 404 时显示友好提示 6. 其他: - 左侧菜单宽度 160px - 所有功能保留 (登录、用户管理、批量操作等)
2026-04-27 11:32:17 +08:00
parent 59d2a76df4
commit 277b13eaae
137 changed files with 8615 additions and 1213 deletions
@@ -1,156 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
-from sqlalchemy.orm import Session
-from typing import List, Optional
-from pathlib import Path
-import subprocess
-import json
-from datetime import datetime
-
-from ..database import get_db
-from ..models import Topic
-
-router = APIRouter(prefix="/api/publisher", tags=["publisher"])
-
-# 项目根目录（从 api/publisher.py 上升到 yu-zhi-ran 根目录）
-import os
-PROJECT_ROOT = Path(__file__).resolve().parents[4]
-if os.getenv('PROJECT_ROOT'):
-    PROJECT_ROOT = Path(os.getenv('PROJECT_ROOT'))
-SCRIPTS_DIR = PROJECT_ROOT / "scripts"
-
-@router.get("/ready")
-def get_ready_topics(
-    platform: Optional[str] = None,
-    db: Session = Depends(get_db)
-):
-    """获取待发布的选题（状态为 ready）"""
-    query = db.query(Topic).filter(Topic.status == "ready")
-    if platform:
-        # 筛选未在该平台发布的选题
-        # platform_urls 是 JSON 字段，需要特殊处理
-        pass  # 简化：暂不筛选
-    topics = query.order_by(Topic.ready_at.desc()).all()
-    return topics
-
-@router.post("/generate/{topic_id}")
-def generate_publish_package(
-    topic_id: str,
-    background_tasks: BackgroundTasks,
-    db: Session = Depends(get_db)
-):
-    """为指定选题生成发布包（所有平台HTML）"""
-    topic = db.query(Topic).filter(Topic.id == topic_id).first()
-    if not topic:
-        raise HTTPException(status_code=404, detail="Topic not found")
-    
-    # 调用 publisher.py 脚本
-    script_path = SCRIPTS_DIR / "publisher.py"
-    if not script_path.exists():
-        raise HTTPException(status_code=500, detail="Publisher script not found")
-    
-    try:
-        result = subprocess.run(
-            ["python3", str(script_path), "--topic-id", topic_id],
-            capture_output=True,
-            text=True,
-            timeout=300,
-            cwd=str(PROJECT_ROOT)
-        )
-        if result.returncode != 0:
-            raise HTTPException(status_code=500, detail=f"Publisher failed: {result.stderr}")
-        
-        return {
-            "message": "Publish package generated",
-            "topic_id": topic_id,
-            "output": result.stdout
-        }
-    except subprocess.TimeoutExpired:
-        raise HTTPException(status_code=504, detail="Publisher timeout")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/packages/{topic_id}")
-def list_platform_packages(topic_id: str):
-    """列出某个选题的所有平台发布包"""
-    release_dir = PROJECT_ROOT / "automation" / "data" / "releases"
-    today = datetime.now().strftime("%Y-%m-%d")
-    
-    packages = []
-    for platform in ["zhihu", "wechat", "xiaohongshu", "bilibili", "toutiao"]:
-        html_file = release_dir / today / platform / f"{platform}_{topic_id}_{platform}.html"
-        if html_file.exists():
-            packages.append({
-                "platform": platform,
-                "file": str(html_file.relative_to(PROJECT_ROOT)),
-                "size": html_file.stat().st_size
-            })
-    
-    published_dir = PROJECT_ROOT / "content" / "published" / topic_id / "手动发布"
-    if published_dir.exists():
-        for platform_dir in published_dir.iterdir():
-            if platform_dir.is_dir():
-                html_file = platform_dir / "文章.html"
-                if html_file.exists():
-                    packages.append({
-                        "platform": platform_dir.name,
-                        "file": str(html_file.relative_to(PROJECT_ROOT)),
-                        "size": html_file.stat().st_size,
-                        "manual": True
-                    })
-    
-    return {"topic_id": topic_id, "packages": packages}
-
-@router.get("/package/{topic_id}/{platform}")
-def get_package_html(topic_id: str, platform: str):
-    """获取指定平台发布包的HTML内容"""
-    # 优先查找 published 目录（手动发布包）
-    published_html = PROJECT_ROOT / "content" / "published" / topic_id / "手动发布" / platform / "文章.html"
-    if published_html.exists():
-        return {"html": published_html.read_text(encoding='utf-8')}
-    
-    # 其次查找 releases 目录（自动生成）
-    today = datetime.now().strftime("%Y-%m-%d")
-    release_html = PROJECT_ROOT / "automation" / "data" / "releases" / today / platform / f"{platform}_{topic_id}_{platform}.html"
-    if release_html.exists():
-        return {"html": release_html.read_text(encoding='utf-8')}
-    
-    raise HTTPException(status_code=404, detail="Package not found")
-
-@router.post("/mark/{topic_id}/published")
-def mark_as_published(
-    topic_id: str,
-    platform_urls: dict,
-    db: Session = Depends(get_db)
-):
-    """手动标记选题为已发布，记录平台链接"""
-    topic = db.query(Topic).filter(Topic.id == topic_id).first()
-    if not topic:
-        raise HTTPException(status_code=404, detail="Topic not found")
-    
-    topic.status = "published"
-    topic.published_at = datetime.now().date()
-    topic.platform_urls = platform_urls
-    db.commit()
-    
-    return {"message": "Topic marked as published", "topic_id": topic_id}
-
-@router.get("/status")
-def get_publisher_status():
-    """获取发布统计"""
-    # 统计今日已发布数量等
-    today = datetime.now().strftime("%Y-%m-%d")
-    release_dir = PROJECT_ROOT / "automation" / "data" / "releases" / today
-    
-    stats = {
-        "today_releases": 0,
-        "platforms": {}
-    }
-    
-    if release_dir.exists():
-        for platform_dir in release_dir.iterdir():
-            if platform_dir.is_dir():
-                count = len(list(platform_dir.glob("*.html")))
-                stats["platforms"][platform_dir.name] = count
-                stats["today_releases"] += count
-    
-    return stats
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""发布管理 API"""
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Optional
+
+from app.database import get_db
+from app.models import Topic, PublishRecord, User
+from sqlalchemy.orm import Session
+from .auth import verify_token
+from ..core.audit_logger import audit_log
+
+router = APIRouter()
+
+class PublishRequest(BaseModel):
+    topic_id: str
+
+class PublishResponse(BaseModel):
+    ok: bool
+    topic_id: str
+    message: str
+
+def get_current_user(request: Request, db: Session = Depends(get_db)) -> User:
+    """获取当前登录用户（可选，未登录也允许，但记录为 anonymous）"""
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        return None
+    token = auth_header.split(" ")[1]
+    try:
+        from .auth import verify_token
+        return verify_token(token, db)
+    except Exception:
+        return None
+
+@router.post("/api/publishing/create", response_model=PublishResponse)
+async def create_publish_record(
+    req: PublishRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """标记选题为已发布，并创建发布记录"""
+    try:
+        # 查找选题
+        topic = db.query(Topic).filter(Topic.id == req.topic_id).first()
+        if not topic:
+            raise HTTPException(status_code=404, detail=f"选题 {req.topic_id} 不存在")
+
+        if topic.status != '待发布':
+            raise HTTPException(status_code=400, detail=f"选题 {req.topic_id} 状态不是待发布")
+
+        # 更新选题状态
+        topic.status = '已发布'
+        topic.updated_at = datetime.now()
+        topic.published_at = datetime.now().date()  # 设置发布时间为今天
+
+        # 创建发布记录
+        operator = current_user.username if current_user else 'anonymous'
+        record = PublishRecord(
+            topic_id=req.topic_id,
+            platform='all',
+            action='publish',
+            status='success',
+            operator=operator,
+            description=f"选题 {req.topic_id} 已发布"
+        )
+        db.add(record)
+        db.commit()
+        # 强制刷新会话缓存，确保后续读取最新数据
+        db.expire_all()
+        db.refresh(topic)
+
+        # 审计日志
+        audit_log(
+            action="publish",
+            user=current_user,
+            resource_type="topic",
+            resource_id=req.topic_id,
+            details={"operator": operator, "status": "success"},
+            ip_address=request.client.host if request.client else None,
+            user_agent=request.headers.get("user-agent", ""),
+            db=db
+        )
+
+        return PublishResponse(
+            ok=True,
+            topic_id=req.topic_id,
+            message=f"选题 {req.topic_id} 已成功发布"
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
@@ -185,3 +185,14 @@ def generate_packages(topic_id: str):
    """
    # TODO: 实际调用 publisher.py 逻辑，这里先返回模拟响应
    return {"message": "Package generation triggered", "topic_id": topic_id, "status": "pending"}
+
+@router.delete("/{topic_id}")
+def delete_topic(topic_id: str, db: Session = Depends(get_db)):
+    """删除选题"""
+    topic = db.query(Topic).filter(Topic.id == topic_id).first()
+    if not topic:
+        raise HTTPException(status_code=404, detail="选题不存在")
+    
+    db.delete(topic)
+    db.commit()
+    return {"message": "删除成功", "topic_id": topic_id}
@@ -0,0 +1,65 @@
+"""
+审计日志记录模块
+
+用法：
+  from .audit_logger import audit_log
+  audit_log(action="create_user", user=current_user, details={...}, request=request, db=db)
+"""
+
+from sqlalchemy.orm import Session
+from ..models import AuditLog
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+
+def audit_log(
+    action: str,
+    *,
+    user=None,  # User 对象或 None
+    username: Optional[str] = None,
+    resource_type: Optional[str] = None,
+    resource_id: Optional[str] = None,
+    details: Optional[Dict[str, Any]] = None,
+    ip_address: Optional[str] = None,
+    user_agent: Optional[str] = None,
+    db: Session = None
+) -> None:
+    """
+    记录审计日志
+
+    参数：
+      action: 操作类型（必填），如 "login", "create_user", "delete_user", "publish"
+      user: 操作用户的 User 对象（可选，如果提供则自动填充 user_id 和 username）
+      username: 直接指定用户名（如果 user 为 None 则必须提供）
+      resource_type: 资源类型，如 "user", "topic", "publish_record"
+      resource_id: 资源ID
+      details: 操作详情字典（如变更前后的值）
+      ip_address: IP 地址
+      user_agent: User-Agent
+      db: 数据库会话（必填）
+    """
+    if db is None:
+        raise ValueError("db session is required")
+
+    # 确定 user_id 和 username
+    user_id = None
+    if user is not None:
+        user_id = getattr(user, 'id', None)
+        username = getattr(user, 'username', username)
+    if not username:
+        username = "anonymous"
+
+    log = AuditLog(
+        user_id=user_id,
+        username=username,
+        action=action,
+        resource_type=resource_type,
+        resource_id=resource_id,
+        details=details or {},
+        ip_address=ip_address,
+        user_agent=user_agent,
+        created_at=datetime.utcnow()
+    )
+    db.add(log)
+    db.commit()
+    # 不抛出异常，避免影响主流程
@@ -6,7 +6,7 @@ import os
 logger = logging.getLogger(__name__)

 # 计算项目根目录（从本文件位置上升4层）
-PROJECT_ROOT = Path(__file__).resolve().parents[4]
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
 # 允许环境变量覆盖（适合容器部署）
 if os.getenv('PROJECT_ROOT'):
    PROJECT_ROOT = Path(os.getenv('PROJECT_ROOT'))
@@ -26,7 +26,7 @@ def run_creator(topic_id: str = None):
        cwd=str(PROJECT_ROOT),
        capture_output=True,
        text=True,
-        timeout=300  # 5分钟超时
+        timeout=1800  # 30分钟超时，避免AI撰写超时
    )
    if result.returncode != 0:
        logger.error(f"Creator failed: {result.stderr}")
@@ -0,0 +1,118 @@
+""" ModelScope 专用 LLM 客户端 """
+import requests
+import json
+from typing import Optional
+
+class LLMError(Exception):
+    pass
+
+# 临时使用 NVIDIA 端点（ModelScope Key 已失效）
+CONFIG = {
+    "base_url": "https://integrate.api.nvidia.com/v1",
+    "api_key": "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",
+    "model": "stepfun-ai/step-3.5-flash",
+}
+
+def call_llm(
+    prompt: str,
+    system_prompt: str = "你是一个专业的内容创作助手。",
+    temperature: float = 0.7,
+    max_tokens: int = 2000,
+    stream: bool = False,
+) -> str:
+    """调用 ModelScope LLM 生成文本"""
+    endpoint = f"{CONFIG['base_url'].rstrip('/')}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {CONFIG['api_key']}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "model": CONFIG["model"],
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "stream": stream,
+    }
+    
+    try:
+        resp = requests.post(endpoint, json=payload, headers=headers, timeout=120, stream=stream)
+        if resp.status_code != 200:
+            raise LLMError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        
+        if stream:
+            full = []
+            for line in resp.iter_lines():
+                if not line:
+                    continue
+                if line.startswith(b'data: '):
+                    data = line[6:]
+                    if data == b'[DONE]':
+                        break
+                    try:
+                        chunk = json.loads(data)
+                        delta = chunk['choices'][0]['delta']
+                        if 'reasoning_content' in delta and delta['reasoning_content']:
+                            full.append(delta['reasoning_content'])
+                        if 'content' in delta and delta['content']:
+                            full.append(delta['content'])
+                    except Exception:
+                        continue
+            return "".join(full)
+        else:
+            data = resp.json()
+            msg = data["choices"][0]["message"]
+            content = msg.get('content') or msg.get('reasoning') or msg.get('reasoning_content')
+            return content.strip() if content else ''
+    except requests.RequestException as e:
+        raise LLMError(f"Request failed: {e}")
+
+def expand_content_with_llm(
+    topic: dict,
+    section_title: str,
+    section_content: str,
+    context: str = ""
+) -> str:
+    """扩写大纲章节，返回包含 ## 标题的完整 Markdown"""
+    prompt = f"""你是一个专业的内容创作者。请将以下大纲扩展为完整的文章章节。
+
+# 选题信息
+- 标题：{topic.get('title')}
+- 领域：{topic.get('field')}
+- 核心观点：{topic.get('core_concept', '')}
+- 受众痛点：{topic.get('audience_pain', '')}
+- 独特视角：{topic.get('unique_angle', '')}
+
+# 当前章节
+## {section_title}
+{section_content}
+
+# 要求
+- 以 `## {section_title}` 作为章节标题开头
+- 字数：300-500 字
+- 风格：客观、专业、易懂
+- 使用 Markdown 格式
+- 包含具体数据或案例（如果有）
+- 保持与整体文章调性一致
+
+直接输出完整的 Markdown 章节（包括 ## 标题和正文段落）。"""
+    
+    if context:
+        prompt = f"# 参考资料\n{context}\n\n{prompt}"
+    
+    try:
+        result = call_llm(prompt, temperature=0.8, max_tokens=2000)
+        return result.strip()
+    except Exception as e:
+        return f"## {section_title}\n\n（LLM 调用失败：{e}，请手动补充）"
+
+# 测试
+if __name__ == "__main__":
+    try:
+        print(f"[modelscope_client] 使用模型：{CONFIG['model']}")
+        resp = call_llm("你好，请用一句话介绍你自己。", max_tokens=50)
+        print(f"[modelscope_client] 响应：{resp}")
+    except Exception as e:
+        print(f"[modelscope_client] 错误：{e}")
@@ -9,7 +9,7 @@ from typing import List
 logger = logging.getLogger(__name__)

 # 计算项目根目录（从本文件位置上升4层）
-PROJECT_ROOT = Path(__file__).resolve().parents[4]
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if os.getenv('PROJECT_ROOT'):
    PROJECT_ROOT = Path(os.getenv('PROJECT_ROOT'))

@@ -3,53 +3,85 @@ import os
 from datetime import datetime
 from pathlib import Path
 from .database import SessionLocal, init_db
-from .models import Topic
+from .models import Topic, User
+import bcrypt

 # 计算项目根目录（backend/app/initial_data.py -> 上升3层到 yu-zhi-ran）
-PROJECT_ROOT = Path(__file__).resolve().parents[3]
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if os.getenv('PROJECT_ROOT'):
    PROJECT_ROOT = Path(os.getenv('PROJECT_ROOT'))
 TOPICS_FILE = PROJECT_ROOT / "automation" / "data" / "sustainability_topics.json"

-def import_topics_from_json():
+# 从环境变量读取管理员配置
+DEFAULT_ADMIN_USERNAME = os.getenv('DEFAULT_ADMIN_USERNAME', 'admin')
+DEFAULT_ADMIN_PASSWORD = os.getenv('DEFAULT_ADMIN_PASSWORD', 'admin123')
+
+def import_initial_data():
    db = SessionLocal()
    try:
-        if db.query(Topic).count() > 0:
-            print("数据库已有数据，跳过导入")
-            return
-        if not __import__('os').path.exists(TOPICS_FILE):
-            print(f"选题文件不存在: {TOPICS_FILE}")
-            return
-        topics = json.loads(open(TOPICS_FILE, encoding='utf-8').read())
-        for t in topics:
-            topic = Topic(
-                id=t['id'],
-                title=t['title'],
-                field=t['field'],
-                format=t.get('format'),
-                core_concept=t.get('core_concept'),
-                audience_pain=t.get('audience_pain'),
-                unique_angle=t.get('unique_angle'),
-                priority=t.get('priority'),
-                priority_score=t.get('priority_score', 0),
-                total_score=t.get('total_score'),
-                status=t.get('status', 'pending'),
-                cases=t.get('cases', []),
-                source_file=t.get('source_file'),
-                ready_at=datetime.strptime(t['ready_at'], '%Y-%m-%d').date() if t.get('ready_at') else None,
-                published_at=datetime.strptime(t['published_at'], '%Y-%m-%d').date() if t.get('published_at') else None,
-                compliance_score=t.get('compliance_score'),
-                platform_urls=t.get('platform_urls', {})
+        # 1. 导入选题数据
+        if db.query(Topic).count() == 0:
+            if __import__('os').path.exists(TOPICS_FILE):
+                topics = json.loads(open(TOPICS_FILE, encoding='utf-8').read())
+                # 去重：保留每个 ID 最后出现的记录
+                seen = {}
+                for t in topics:
+                    seen[t['id']] = t
+                unique_topics = list(seen.values())
+                for t in unique_topics:
+                    topic = Topic(
+                        id=t['id'],
+                        title=t['title'],
+                        field=t['field'],
+                        format=t.get('format'),
+                        core_concept=t.get('core_concept'),
+                        audience_pain=t.get('audience_pain'),
+                        unique_angle=t.get('unique_angle'),
+                        priority=t.get('priority'),
+                        priority_score=t.get('priority_score', 0),
+                        total_score=t.get('total_score'),
+                        status=t.get('status', 'pending'),
+                        cases=t.get('cases', []),
+                        source_file=t.get('source_file'),
+                        ready_at=datetime.strptime(t['ready_at'], '%Y-%m-%d').date() if t.get('ready_at') else None,
+                        published_at=datetime.strptime(t['published_at'], '%Y-%m-%d').date() if t.get('published_at') else None,
+                        compliance_score=t.get('compliance_score'),
+                        platform_urls=t.get('platform_urls', {})
+                    )
+                    db.add(topic)
+                db.commit()
+                print(f"✅ 导入 {len(unique_topics)} 个选题到数据库（去重后）")
+            else:
+                print(f"⚠️ 选题文件不存在: {TOPICS_FILE}")
+        else:
+            print("数据库已有选题数据，跳过导入")
+
+        # 2. 创建默认管理员用户（bcrypt 哈希）
+        admin_exists = db.query(User).filter(User.username == DEFAULT_ADMIN_USERNAME).first()
+        if not admin_exists:
+            hashed = bcrypt.hashpw(DEFAULT_ADMIN_PASSWORD.encode('utf-8'), bcrypt.gensalt())
+            admin = User(
+                username=DEFAULT_ADMIN_USERNAME,
+                password_hash=hashed.decode('utf-8'),
+                role="admin"
            )
-            db.add(topic)
-        db.commit()
-        print(f"✅ 导入 {len(topics)} 个选题到数据库")
+            db.add(admin)
+            db.commit()
+            print(f"✅ 创建默认管理员: {DEFAULT_ADMIN_USERNAME}")
+        else:
+            # 如果管理员已存在但密码为空，更新为默认密码的哈希
+            if not admin_exists.password_hash:
+                hashed = bcrypt.hashpw(DEFAULT_ADMIN_PASSWORD.encode('utf-8'), bcrypt.gensalt())
+                admin_exists.password_hash = hashed.decode('utf-8')
+                db.commit()
+                print(f"✅ 更新管理员密码")
+            print(f"管理员已存在: {DEFAULT_ADMIN_USERNAME}")
    except Exception as e:
-        print(f"导入失败: {e}")
+        print(f"初始化失败: {e}")
        db.rollback()
    finally:
        db.close()

 if __name__ == "__main__":
    init_db()
-    import_topics_from_json()
+    import_initial_data()