"""复盘计划 API 路由 - V1 复盘日期/排名/计划 + V2 评分/交易计划/板块热度""" import logging from datetime import datetime from fastapi import APIRouter, Depends, HTTPException from pydantic import BaseModel from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from app.database import get_db from app.models.analysis import ( ReviewDate, ReviewPlanV2, SectorHeat, SymbolRanking, SymbolScoreV2, TradingPlan, TradingPlanV2, ) from app.services.plan_generator import PlanGenerator, load_symbols_config logger = logging.getLogger(__name__) router = APIRouter(prefix="/review", tags=["复盘计划"]) class GeneratePlanRequest(BaseModel): """生成V2交易计划请求体。""" review_date: str # ==================== V1 复盘日期管理 ==================== @router.get("/dates") async def get_review_dates( limit: int = 10, db: AsyncSession = Depends(get_db), ): """获取复盘日期列表。""" stmt = select(ReviewDate).order_by(ReviewDate.review_date.desc()).limit(limit) result = await db.execute(stmt) dates = result.scalars().all() return { "success": True, "data": [{ "id": d.id, "review_date": d.review_date, "week_day": d.week_day, } for d in dates], } @router.post("/dates") async def create_review_date( review_date: str, week_day: str | None = None, db: AsyncSession = Depends(get_db), ): """创建复盘日期。""" stmt = select(ReviewDate).where(ReviewDate.review_date == review_date) result = await db.execute(stmt) existing = result.scalar_one_or_none() if existing: return {"success": False, "message": f"日期 {review_date} 已存在"} if not week_day: try: dt = datetime.strptime(review_date, "%Y-%m-%d") week_days = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"] week_day = week_days[dt.weekday()] except ValueError: week_day = "" new_date = ReviewDate(review_date=review_date, week_day=week_day) db.add(new_date) await db.flush() await db.refresh(new_date) return { "success": True, "data": { "id": new_date.id, "review_date": new_date.review_date, "week_day": new_date.week_day, }, } # ==================== V1 品种排名 ==================== @router.get("/rankings/{review_date_id}") async def get_rankings( review_date_id: int, db: AsyncSession = Depends(get_db), ): """获取指定日期的品种排名。""" stmt_date = select(ReviewDate).where(ReviewDate.id == review_date_id) result_date = await db.execute(stmt_date) review_date = result_date.scalar_one_or_none() if not review_date: raise HTTPException(status_code=404, detail="复盘日期不存在") stmt = ( select(SymbolRanking) .where(SymbolRanking.review_date_id == review_date_id) .order_by(SymbolRanking.rank_type, SymbolRanking.rank) ) result = await db.execute(stmt) rankings = result.scalars().all() rank_types = ["volume", "amplitude", "change", "open_interest"] rank_type_names = { "volume": "成交量排名", "amplitude": "振幅排名", "change": "涨跌幅排名", "open_interest": "持仓量排名", } result_data: dict = {rt: {"title": rank_type_names.get(rt, rt), "items": []} for rt in rank_types} for r in rankings: if r.rank_type in result_data: result_data[r.rank_type]["items"].append({ "id": r.id, "symbol": r.symbol, "name": r.name or r.symbol, "rank": r.rank, "value": r.value, "price": r.price, "change_pct": r.change_pct, }) return { "success": True, "data": { "review_date": review_date.review_date, "week_day": review_date.week_day, "rankings": result_data, }, } @router.post("/rankings") async def create_or_update_rankings( review_date_id: int, rankings: list[dict], db: AsyncSession = Depends(get_db), ): """创建或更新品种排名。""" stmt_date = select(ReviewDate).where(ReviewDate.id == review_date_id) result_date = await db.execute(stmt_date) review_date = result_date.scalar_one_or_none() if not review_date: raise HTTPException(status_code=404, detail="复盘日期不存在") from sqlalchemy import delete as sa_delete await db.execute( sa_delete(SymbolRanking).where(SymbolRanking.review_date_id == review_date_id) ) created: list[dict] = [] for r in rankings: new_ranking = SymbolRanking( review_date_id=review_date_id, symbol=r.get("symbol"), name=r.get("name"), rank_type=r.get("rank_type"), rank=r.get("rank", 1), value=r.get("value"), price=r.get("price"), change_pct=r.get("change_pct"), ) db.add(new_ranking) await db.flush() created.append({ "id": new_ranking.id, "symbol": new_ranking.symbol, "rank_type": new_ranking.rank_type, "rank": new_ranking.rank, }) return {"success": True, "data": created} # ==================== V1 交易计划 ==================== @router.get("/plans/{review_date_id}") async def get_trading_plans( review_date_id: int, db: AsyncSession = Depends(get_db), ): """获取指定日期的交易计划。""" stmt_date = select(ReviewDate).where(ReviewDate.id == review_date_id) result_date = await db.execute(stmt_date) review_date = result_date.scalar_one_or_none() if not review_date: raise HTTPException(status_code=404, detail="复盘日期不存在") stmt = ( select(TradingPlan) .where(TradingPlan.review_date_id == review_date_id) .order_by(TradingPlan.score.desc()) ) result = await db.execute(stmt) plans = result.scalars().all() return { "success": True, "data": { "review_date": review_date.review_date, "week_day": review_date.week_day, "plans": [{ "id": p.id, "symbol": p.symbol, "name": p.name or p.symbol, "plan_type": p.plan_type, "score": p.score, "logic": p.logic, "reason": p.reason, "entry_price": p.entry_price, "stop_loss": p.stop_loss, "take_profit": p.take_profit, "confidence": p.confidence, "position_suggestion": p.position_suggestion, "created_at": p.created_at.isoformat() if p.created_at else None, } for p in plans], }, } @router.post("/plans") async def create_or_update_plans( review_date_id: int, plans: list[dict], db: AsyncSession = Depends(get_db), ): """创建或更新交易计划。""" stmt_date = select(ReviewDate).where(ReviewDate.id == review_date_id) result_date = await db.execute(stmt_date) review_date = result_date.scalar_one_or_none() if not review_date: raise HTTPException(status_code=404, detail="复盘日期不存在") from sqlalchemy import delete as sa_delete await db.execute( sa_delete(TradingPlan).where(TradingPlan.review_date_id == review_date_id) ) created: list[dict] = [] for p in plans: new_plan = TradingPlan( review_date_id=review_date_id, symbol=p.get("symbol"), name=p.get("name"), plan_type=p.get("plan_type"), score=p.get("score", 0), logic=p.get("logic"), reason=p.get("reason"), entry_price=p.get("entry_price"), stop_loss=p.get("stop_loss"), take_profit=p.get("take_profit"), confidence=p.get("confidence"), position_suggestion=p.get("position_suggestion"), ) db.add(new_plan) await db.flush() created.append({ "id": new_plan.id, "symbol": new_plan.symbol, "plan_type": new_plan.plan_type, "score": new_plan.score, }) return {"success": True, "data": created} @router.post("/plans/batch") async def batch_create_review_data( review_data: dict, db: AsyncSession = Depends(get_db), ): """批量创建复盘数据（日期+排名+计划）。""" review_date_str = review_data.get("review_date") week_day = review_data.get("week_day") stmt = select(ReviewDate).where(ReviewDate.review_date == review_date_str) result = await db.execute(stmt) existing = result.scalar_one_or_none() if existing: review_date_id = existing.id else: if not week_day: try: dt = datetime.strptime(review_date_str, "%Y-%m-%d") week_days = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"] week_day = week_days[dt.weekday()] except ValueError: week_day = "" new_date = ReviewDate(review_date=review_date_str, week_day=week_day) db.add(new_date) await db.flush() await db.refresh(new_date) review_date_id = new_date.id rankings = review_data.get("rankings", []) if rankings: from sqlalchemy import delete as sa_delete await db.execute( sa_delete(SymbolRanking).where(SymbolRanking.review_date_id == review_date_id) ) for r in rankings: db.add(SymbolRanking( review_date_id=review_date_id, symbol=r.get("symbol"), name=r.get("name"), rank_type=r.get("rank_type"), rank=r.get("rank", 1), value=r.get("value"), price=r.get("price"), change_pct=r.get("change_pct"), )) plans = review_data.get("plans", []) if plans: from sqlalchemy import delete as sa_delete await db.execute( sa_delete(TradingPlan).where(TradingPlan.review_date_id == review_date_id) ) for p in plans: db.add(TradingPlan( review_date_id=review_date_id, symbol=p.get("symbol"), name=p.get("name"), plan_type=p.get("plan_type"), score=p.get("score", 0), logic=p.get("logic"), reason=p.get("reason"), entry_price=p.get("entry_price"), stop_loss=p.get("stop_loss"), take_profit=p.get("take_profit"), confidence=p.get("confidence"), position_suggestion=p.get("position_suggestion"), )) await db.flush() return { "success": True, "data": { "review_date_id": review_date_id, "review_date": review_date_str, "rankings_count": len(rankings), "plans_count": len(plans), }, } @router.get("/summary/{review_date_id}") async def get_review_summary( review_date_id: int, db: AsyncSession = Depends(get_db), ): """获取复盘摘要（包含排名和计划的完整数据）。""" stmt_date = select(ReviewDate).where(ReviewDate.id == review_date_id) result_date = await db.execute(stmt_date) review_date = result_date.scalar_one_or_none() if not review_date: raise HTTPException(status_code=404, detail="复盘日期不存在") stmt_rankings = ( select(SymbolRanking) .where(SymbolRanking.review_date_id == review_date_id) .order_by(SymbolRanking.rank_type, SymbolRanking.rank) ) result_rankings = await db.execute(stmt_rankings) rankings = result_rankings.scalars().all() stmt_plans = ( select(TradingPlan) .where(TradingPlan.review_date_id == review_date_id) .order_by(TradingPlan.score.desc()) ) result_plans = await db.execute(stmt_plans) plans = result_plans.scalars().all() rank_types = ["volume", "amplitude", "change", "open_interest"] rank_type_names = { "volume": "成交量排名 Top 5", "amplitude": "振幅排名 Top 5", "change": "涨跌幅排名 Top 5", "open_interest": "持仓量排名 Top 5", } rankings_result: dict = {rt: {"title": rank_type_names.get(rt, rt), "items": []} for rt in rank_types} for r in rankings: if r.rank_type in rankings_result: rankings_result[r.rank_type]["items"].append({ "symbol": r.symbol, "name": r.name or r.symbol, "rank": r.rank, "value": r.value, "price": r.price, "change_pct": r.change_pct, }) plans_result = [{ "id": p.id, "symbol": p.symbol, "name": p.name or p.symbol, "plan_type": p.plan_type, "score": p.score, "logic": p.logic, "reason": p.reason, "entry_price": p.entry_price, "stop_loss": p.stop_loss, "take_profit": p.take_profit, "confidence": p.confidence, "position_suggestion": p.position_suggestion, "created_at": p.created_at.isoformat() if p.created_at else None, } for p in plans] return { "success": True, "data": { "review_date": review_date.review_date, "week_day": review_date.week_day, "rankings": rankings_result, "plans": plans_result, }, } @router.delete("/clear") async def clear_review_data( db: AsyncSession = Depends(get_db), ): """清除所有V1复盘与交易计划数据。""" try: from sqlalchemy import delete as sa_delete await db.execute(sa_delete(TradingPlan)) await db.execute(sa_delete(SymbolRanking)) await db.execute(sa_delete(ReviewDate)) await db.flush() return {"success": True, "message": "复盘数据已清除"} except Exception as e: return {"success": False, "message": f"清除失败: {e!s}"} # ==================== V2 生成交易计划 ==================== @router.post("/generate") async def generate_review_plan( req: GeneratePlanRequest, db: AsyncSession = Depends(get_db), ): """生成V2交易计划。""" try: review_date_str = req.review_date dt = datetime.strptime(review_date_str, "%Y-%m-%d") week_days = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"] week_day = week_days[dt.weekday()] symbols_config = load_symbols_config() generator = PlanGenerator() plan_data = await generator.generate(db, symbols_config) # 保存计划到数据库 summary = plan_data.get("summary", {}) plan_v2 = ReviewPlanV2( review_date=review_date_str, week_day=week_day, data_basis=summary.get("data_basis"), core_conclusion=summary.get("core_conclusion"), bull_count=summary.get("bull_count"), bear_count=summary.get("bear_count"), neutral_count=summary.get("neutral_count"), opportunity_count=summary.get("opportunity_count"), risk_warnings=summary.get("risk_warnings"), actual_data_date=summary.get("actual_data_date"), ) db.add(plan_v2) await db.flush() # 保存品种评分 for s in plan_data.get("scores", []): score_v2 = SymbolScoreV2( review_date_id=plan_v2.id, symbol=s.get("symbol"), name=s.get("name"), close_price=s.get("close_price"), prev_close=s.get("prev_close"), high_price=s.get("high_price"), low_price=s.get("low_price"), volume=s.get("volume"), avg_volume_5=s.get("avg_volume_5"), amplitude_score=s.get("amplitude_score"), volume_score=s.get("volume_score"), change_score=s.get("change_score"), trend_score=s.get("trend_score"), activity_score=s.get("activity_score"), composite_score=s.get("composite_score"), amplitude_pct=s.get("amplitude_pct"), change_pct=s.get("change_pct"), volume_ratio=s.get("volume_ratio"), trend_60m=s.get("trend_60m"), trend_15m=s.get("trend_15m"), trend_5m=s.get("trend_5m"), direction=s.get("direction"), direction_tag=s.get("direction_tag"), category=s.get("category"), pivot=s.get("pivots", {}).get("pivot"), r1=s.get("pivots", {}).get("r1"), r2=s.get("pivots", {}).get("r2"), s1=s.get("pivots", {}).get("s1"), s2=s.get("pivots", {}).get("s2"), rank=s.get("rank"), data_date=s.get("data_date"), ) db.add(score_v2) # 保存交易计划 for p in plan_data.get("plans", []): plan_v2_item = TradingPlanV2( review_date_id=plan_v2.id, symbol=p.get("symbol"), name=p.get("name"), direction=p.get("direction"), composite_score=p.get("composite_score"), entry_low=p.get("entry_low"), entry_high=p.get("entry_high"), stop_loss=p.get("stop_loss"), target1=p.get("target1"), target2=p.get("target2"), trigger=p.get("trigger"), amplitude_score=p.get("amplitude_score"), volume_score=p.get("volume_score"), trend_score=p.get("trend_score"), activity_score=p.get("activity_score"), category=p.get("category"), ) db.add(plan_v2_item) # 保存板块热度 for sec in plan_data.get("sectors", []): sector_heat = SectorHeat( review_date_id=plan_v2.id, sector_name=sec.get("sector_name"), avg_score=sec.get("avg_score"), avg_trend=sec.get("avg_trend"), direction=sec.get("direction"), heat_level=sec.get("heat_level"), leader_symbol=sec.get("leader_symbol"), leader_score=sec.get("leader_score"), members=sec.get("members"), ) db.add(sector_heat) await db.flush() return { "success": True, "data": { "plan_id": plan_v2.id, "summary": { "review_date": review_date_str, "week_day": week_day, "core_conclusion": summary.get("core_conclusion"), "bull_count": summary.get("bull_count"), "bear_count": summary.get("bear_count"), "neutral_count": summary.get("neutral_count"), "opportunity_count": summary.get("opportunity_count"), "symbol_count": plan_data.get("symbol_count"), }, }, } except Exception as e: logger.exception("生成交易计划失败") return {"success": False, "message": f"生成失败: {e!s}"} # ==================== V2 查询接口 ==================== @router.get("/v2/plans") async def list_v2_plans( limit: int = 20, db: AsyncSession = Depends(get_db), ): """获取V2复盘计划列表。""" try: stmt = select(ReviewPlanV2).order_by(ReviewPlanV2.review_date.desc()).limit(limit) result = await db.execute(stmt) plans = result.scalars().all() return { "success": True, "data": [{ "id": p.id, "review_date": p.review_date, "week_day": p.week_day, "core_conclusion": p.core_conclusion, "opportunity_count": p.opportunity_count, "created_at": p.created_at.isoformat() if p.created_at else None, } for p in plans], } except Exception as e: logger.exception("获取V2计划列表失败") return {"success": False, "message": f"查询失败: {e!s}"} @router.get("/v2/plan/{plan_id}") async def get_v2_plan( plan_id: int, db: AsyncSession = Depends(get_db), ): """根据ID获取完整V2计划数据。""" try: stmt_plan = select(ReviewPlanV2).where(ReviewPlanV2.id == plan_id) result_plan = await db.execute(stmt_plan) plan_meta = result_plan.scalar_one_or_none() if not plan_meta: return {"success": False, "message": f"计划 {plan_id} 不存在"} stmt_scores = ( select(SymbolScoreV2) .where(SymbolScoreV2.review_date_id == plan_id) .order_by(SymbolScoreV2.composite_score.desc()) ) result_scores = await db.execute(stmt_scores) scores = result_scores.scalars().all() stmt_plans = ( select(TradingPlanV2) .where(TradingPlanV2.review_date_id == plan_id) .order_by(TradingPlanV2.composite_score.desc()) ) result_plans = await db.execute(stmt_plans) trading_plans = result_plans.scalars().all() stmt_sectors = ( select(SectorHeat) .where(SectorHeat.review_date_id == plan_id) .order_by(SectorHeat.avg_score.desc()) ) result_sectors = await db.execute(stmt_sectors) sectors = result_sectors.scalars().all() return { "success": True, "data": { "summary": { "id": plan_meta.id, "review_date": plan_meta.review_date, "week_day": plan_meta.week_day, "data_basis": plan_meta.data_basis, "core_conclusion": plan_meta.core_conclusion, "bull_count": plan_meta.bull_count, "bear_count": plan_meta.bear_count, "neutral_count": plan_meta.neutral_count, "opportunity_count": plan_meta.opportunity_count, "risk_warnings": plan_meta.risk_warnings, "actual_data_date": plan_meta.actual_data_date, "created_at": plan_meta.created_at.isoformat() if plan_meta.created_at else None, }, "scores": [{ "symbol": s.symbol, "name": s.name, "close_price": s.close_price, "composite_score": s.composite_score, "direction": s.direction, "direction_tag": s.direction_tag, "category": s.category, "rank": s.rank, } for s in scores], "plans": [{ "symbol": p.symbol, "name": p.name, "direction": p.direction, "composite_score": p.composite_score, "entry_low": p.entry_low, "entry_high": p.entry_high, "stop_loss": p.stop_loss, "target1": p.target1, "target2": p.target2, "trigger": p.trigger, "category": p.category, } for p in trading_plans], "sectors": [{ "sector_name": s.sector_name, "avg_score": s.avg_score, "direction": s.direction, "heat_level": s.heat_level, "leader_symbol": s.leader_symbol, "leader_score": s.leader_score, } for s in sectors], }, } except Exception as e: logger.exception("获取V2计划 %d 失败", plan_id) return {"success": False, "message": f"查询失败: {e!s}"} @router.get("/v2/plan/by-date/{date}") async def get_v2_plan_by_date( date: str, db: AsyncSession = Depends(get_db), ): """根据日期获取V2计划数据。""" try: stmt_meta = select(ReviewPlanV2).where(ReviewPlanV2.review_date == date) result_meta = await db.execute(stmt_meta) plan_meta = result_meta.scalar_one_or_none() if not plan_meta: return {"success": False, "message": f"日期 {date} 的计划不存在"} # 复用 get_v2_plan 的逻辑 stmt_scores = ( select(SymbolScoreV2) .where(SymbolScoreV2.review_date_id == plan_meta.id) .order_by(SymbolScoreV2.composite_score.desc()) ) result_scores = await db.execute(stmt_scores) scores = result_scores.scalars().all() stmt_plans = ( select(TradingPlanV2) .where(TradingPlanV2.review_date_id == plan_meta.id) .order_by(TradingPlanV2.composite_score.desc()) ) result_plans = await db.execute(stmt_plans) trading_plans = result_plans.scalars().all() stmt_sectors = ( select(SectorHeat) .where(SectorHeat.review_date_id == plan_meta.id) .order_by(SectorHeat.avg_score.desc()) ) result_sectors = await db.execute(stmt_sectors) sectors = result_sectors.scalars().all() return { "success": True, "data": { "summary": { "id": plan_meta.id, "review_date": plan_meta.review_date, "week_day": plan_meta.week_day, "data_basis": plan_meta.data_basis, "core_conclusion": plan_meta.core_conclusion, "bull_count": plan_meta.bull_count, "bear_count": plan_meta.bear_count, "neutral_count": plan_meta.neutral_count, "opportunity_count": plan_meta.opportunity_count, "risk_warnings": plan_meta.risk_warnings, "actual_data_date": plan_meta.actual_data_date, "created_at": plan_meta.created_at.isoformat() if plan_meta.created_at else None, }, "scores": [{ "symbol": s.symbol, "name": s.name, "close_price": s.close_price, "composite_score": s.composite_score, "direction": s.direction, "direction_tag": s.direction_tag, "category": s.category, "rank": s.rank, } for s in scores], "plans": [{ "symbol": p.symbol, "name": p.name, "direction": p.direction, "composite_score": p.composite_score, "entry_low": p.entry_low, "entry_high": p.entry_high, "stop_loss": p.stop_loss, "target1": p.target1, "target2": p.target2, "trigger": p.trigger, "category": p.category, } for p in trading_plans], "sectors": [{ "sector_name": s.sector_name, "avg_score": s.avg_score, "direction": s.direction, "heat_level": s.heat_level, "leader_symbol": s.leader_symbol, "leader_score": s.leader_score, } for s in sectors], }, } except Exception as e: logger.exception("获取V2计划 by-date %s 失败", date) return {"success": False, "message": f"查询失败: {e!s}"} @router.delete("/v2/clear") async def clear_v2_data( db: AsyncSession = Depends(get_db), ): """清除所有V2数据。""" try: from sqlalchemy import delete as sa_delete await db.execute(sa_delete(SectorHeat)) await db.execute(sa_delete(TradingPlanV2)) await db.execute(sa_delete(SymbolScoreV2)) await db.execute(sa_delete(ReviewPlanV2)) await db.flush() return {"success": True, "message": "V2复盘数据已清除"} except Exception as e: return {"success": False, "message": f"清除失败: {e!s}"}