Yuzhiran Dev
262 lines
11 KiB
Python
262 lines
11 KiB
Python
import logging
|
|
from fastapi import APIRouter, HTTPException, Depends, Body
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import func
|
|
from datetime import datetime, date
|
|
from typing import Dict, Any, List, Optional
|
|
from pathlib import Path
|
|
import os
|
|
import json
|
|
from ..database import get_db
|
|
from ..models import Topic, Article
|
|
from ..core.generator import run_creator
|
|
from ..core.optimizer import run_optimizer
|
|
from ..core.collector import run_collector
|
|
from ..core.sync import sync_all_topics
|
|
from ..core.scheduler import scheduler
|
|
from .auth import get_current_user, org_filter
|
|
|
|
PROJECT_ROOT = Path(__file__).resolve().parents[4]
|
|
if os.getenv('PROJECT_ROOT'):
|
|
PROJECT_ROOT = Path(os.getenv('PROJECT_ROOT'))
|
|
LOGS_DIR = PROJECT_ROOT / "automation" / "logs"
|
|
|
|
logger = logging.getLogger(__name__)
|
|
router = APIRouter(prefix="/api/system", tags=["system"])
|
|
|
|
def _aggregate_status_counts(q):
|
|
"""聚合状态计数，兼容中英文状态值"""
|
|
raw = q.with_entities(Topic.status, func.count()).group_by(Topic.status).all()
|
|
mapping = {
|
|
'pending': ['pending', '待处理'],
|
|
'review': ['review', '待审查'],
|
|
'ready': ['ready', '待发布'],
|
|
'published': ['published', '已发布']
|
|
}
|
|
counts = {'pending': 0, 'review': 0, 'ready': 0, 'published': 0}
|
|
for status_val, cnt in raw:
|
|
for key, aliases in mapping.items():
|
|
if status_val in aliases:
|
|
counts[key] += cnt
|
|
break
|
|
return counts
|
|
|
|
@router.get("/status")
|
|
def get_status(db: Session = Depends(get_db)):
|
|
total = db.query(Topic).count()
|
|
counts = _aggregate_status_counts(db.query(Topic))
|
|
today = date.today()
|
|
today_count = db.query(Topic).filter(func.date(Topic.created_at) == today).count()
|
|
return {
|
|
"stats": {
|
|
"total": total,
|
|
"pending": counts['pending'],
|
|
"review": counts['review'],
|
|
"ready": counts['ready'],
|
|
"published": counts['published'],
|
|
"today": today_count
|
|
}
|
|
}
|
|
|
|
@router.post("/generate/run", dependencies=[Depends(get_current_user)])
|
|
def trigger_generation(topic_id: str = Body(None, embed=True), db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
logger.info(f"Received topic_id={topic_id}")
|
|
try:
|
|
result = run_creator(topic_id)
|
|
if not result["ok"]:
|
|
raise HTTPException(status_code=500, detail=result["error"])
|
|
sync_all_topics()
|
|
return {"message": "Generation triggered", "result": result}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post("/collect/run", dependencies=[Depends(get_current_user)])
|
|
def trigger_collection(db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
logger.info(f"Manual collection triggered by {current_user.username}")
|
|
try:
|
|
result = run_collector()
|
|
return {"message": "内容采集已完成", "result": result}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post("/review/run", dependencies=[Depends(get_current_user)])
|
|
def trigger_review(topic_ids: List[str] = Body(None, embed=True), db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
try:
|
|
result = run_optimizer(topic_ids)
|
|
if not result["ok"]:
|
|
raise HTTPException(status_code=500, detail=result["error"])
|
|
report = result.get("report")
|
|
if report and report["summary"]["total_articles"] > 0:
|
|
s = report["summary"]
|
|
total = s["total_articles"]
|
|
avg = s["average_score"]
|
|
msg = f"审查完成: {total} 篇全部通过 ({avg:.0f}分)"
|
|
return {"message": msg, "summary": s}
|
|
else:
|
|
if topic_ids:
|
|
updated = 0
|
|
for tid in topic_ids:
|
|
q = db.query(Topic).filter(Topic.id == tid)
|
|
of = org_filter(current_user, Topic)
|
|
if of is not True:
|
|
q = q.filter(of)
|
|
topic = q.first()
|
|
if topic and topic.status in ('review', '待审查'):
|
|
topic.status = 'ready'
|
|
if not topic.generated_at:
|
|
topic.generated_at = datetime.utcnow()
|
|
updated += 1
|
|
db.commit()
|
|
if updated:
|
|
logger.info(f"Review: {updated} topics advanced to 'ready' (no release files)")
|
|
return {"message": "审查完成（未找到 release 文件，仅推进状态）", "stdout": result.get("stdout", "")}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get("/logs/{log_date}", dependencies=[Depends(get_current_user)])
|
|
def get_logs(log_date: str, log_type: str = "creator"):
|
|
log_file = LOGS_DIR / f"{log_type}_{log_date}.log"
|
|
if not log_file.exists():
|
|
raise HTTPException(status_code=404, detail=f"Log file not found: {log_file}")
|
|
content = log_file.read_text(encoding='utf-8')
|
|
lines = content.splitlines()[-100:] if log_type != "collector" else content.splitlines()[-200:]
|
|
return {"log_date": log_date, "log_type": log_type, "content": lines}
|
|
|
|
@router.get("/pipeline/status", dependencies=[Depends(get_current_user)])
|
|
def get_pipeline_status(db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
topic_base = db.query(Topic)
|
|
of = org_filter(current_user, Topic)
|
|
if of is not True:
|
|
topic_base = topic_base.filter(of)
|
|
total = topic_base.count()
|
|
counts = _aggregate_status_counts(topic_base)
|
|
log_files = {
|
|
"collector": LOGS_DIR / f"collector_{date.today().isoformat()}.log",
|
|
"creator": LOGS_DIR / f"creator_{date.today().isoformat()}.log",
|
|
"optimizer": LOGS_DIR / f"optimizer_{date.today().isoformat()}.log",
|
|
}
|
|
pipeline_status = {}
|
|
for name, log_file in log_files.items():
|
|
if log_file.exists():
|
|
mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
|
|
pipeline_status[name] = {"last_run": mtime.isoformat(), "exists": True}
|
|
else:
|
|
pipeline_status[name] = {"exists": False, "last_run": None}
|
|
return {"topics_count": total, "status_distribution": counts, "pipeline_modules": pipeline_status}
|
|
|
|
@router.post("/sync/run")
|
|
def run_sync():
|
|
try:
|
|
sync_all_topics()
|
|
return {"message": "Sync completed (DB → JSON backup)"}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post("/optimize-sources/run")
|
|
def trigger_optimize_sources():
|
|
try:
|
|
from ..core.scheduler import scheduler
|
|
scheduler._run_optimize_sources()
|
|
log_file = LOGS_DIR / f"optimizer_sources_{date.today().isoformat()}.log"
|
|
log_file.parent.mkdir(parents=True, exist_ok=True)
|
|
log_file.write_text(f"{datetime.now().isoformat()} - 信息源优化完成\n")
|
|
return {"message": "信息源优化已完成"}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post("/metrics-sync/run")
|
|
def trigger_metrics_sync():
|
|
try:
|
|
from ..core.scheduler import scheduler
|
|
scheduler._run_metrics_sync()
|
|
log_file = LOGS_DIR / f"metrics_sync_{date.today().isoformat()}.log"
|
|
log_file.parent.mkdir(parents=True, exist_ok=True)
|
|
log_file.write_text(f"{datetime.now().isoformat()} - 指标同步完成\n")
|
|
return {"message": "指标同步已完成"}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get("/automation/topics")
|
|
def list_automation_topics(db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
try:
|
|
topic_base = db.query(Topic)
|
|
of = org_filter(current_user, Topic)
|
|
if of is not True:
|
|
topic_base = topic_base.filter(of)
|
|
topics = topic_base.order_by(Topic.created_at.desc()).limit(100).all()
|
|
result = []
|
|
for t in topics:
|
|
result.append({
|
|
"id": t.id,
|
|
"title": t.title,
|
|
"field": t.field,
|
|
"status": t.status,
|
|
"priority": t.priority,
|
|
"priority_score": t.priority_score,
|
|
"total_score": t.total_score,
|
|
"created_at": t.created_at.isoformat() if t.created_at else None,
|
|
"updated_at": t.updated_at.isoformat() if t.updated_at else None,
|
|
"ready_at": t.ready_at.isoformat() if t.ready_at else None,
|
|
"compliance_score": t.compliance_score
|
|
})
|
|
return {"count": len(result), "topics": result[:50]}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post("/refresh")
|
|
def refresh_all():
|
|
try:
|
|
sync_all_topics()
|
|
return {"message": "Refresh completed"}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get("/scheduler/status", dependencies=[Depends(get_current_user)])
|
|
def get_scheduler_status():
|
|
return {"running": scheduler._started, "jobs": scheduler.get_jobs()}
|
|
|
|
|
|
@router.get("/modules/status", dependencies=[Depends(get_current_user)])
|
|
def get_modules_status():
|
|
today_str = date.today().isoformat()
|
|
log_based: dict = {
|
|
"scheduled_collect": {"name": "📡 内容采集", "log": LOGS_DIR / f"collector_{today_str}.log"},
|
|
"scheduled_generate": {"name": "🤖 内容创作", "log": LOGS_DIR / f"creator_{today_str}.log"},
|
|
"scheduled_optimize": {"name": "🔍 合规审查", "log": LOGS_DIR / f"optimizer_{today_str}.log"},
|
|
"scheduled_optimize_sources": {"name": "📡 信息源优化", "log": LOGS_DIR / f"optimizer_sources_{today_str}.log"},
|
|
"scheduled_metrics_sync": {"name": "📊 指标同步", "log": LOGS_DIR / f"metrics_sync_{today_str}.log"},
|
|
}
|
|
jobs = {j['id']: j for j in scheduler.get_jobs()}
|
|
modules = []
|
|
for mod_id, cfg in log_based.items():
|
|
log_file = cfg["log"]
|
|
last_run = None
|
|
task_count = 0
|
|
success_rate = None
|
|
if log_file.exists():
|
|
mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
|
|
last_run = mtime.strftime("%Y-%m-%d %H:%M")
|
|
content = log_file.read_text(encoding="utf-8", errors="ignore")
|
|
task_count = content.count("完成") + content.count("success") + content.count("SUCCESS")
|
|
total = task_count + content.count("失败") + content.count("failed") + content.count("ERROR")
|
|
success_rate = round(task_count / total * 100) if total > 0 else None
|
|
status = "running" if mod_id in jobs else "stopped"
|
|
job = jobs.get(mod_id)
|
|
next_run = None
|
|
if job and job.get("next_run_time"):
|
|
try:
|
|
next_dt = datetime.fromisoformat(job["next_run_time"])
|
|
next_run = next_dt.strftime("%Y-%m-%d %H:%M")
|
|
except Exception:
|
|
next_run = job["next_run_time"]
|
|
modules.append({
|
|
"id": mod_id,
|
|
"title": cfg["name"],
|
|
"status": status,
|
|
"last_run": last_run or "从未运行",
|
|
"next_run": next_run or "待计划",
|
|
"task_count": task_count,
|
|
"success_rate": success_rate if success_rate is not None else 0,
|
|
})
|
|
return {"modules": modules, "scheduler": {"running": scheduler._started, "jobs": scheduler.get_jobs()}}
|