功能更新

backend/app/api.py

@@ -2,6 +2,7 @@
 
   GET  /api/health               健康检查
   GET  /api/candles/{sym}        取 K 线（支持 1d/1w/1M/1y 周期，日线为基底聚合）
+  GET  /api/stocks               全市场股票列表（基本信息 + 最新行情 + 缓存条数）
   POST /api/backtest             跑回测，返回 K线+指标+买卖点+净值+绩效
   POST /api/screener/run         智能选股：自然语言 -> 条件 -> 全市场筛选
   POST /api/screener/sync        启动全市场数据同步（后台任务）
@@ -9,45 +10,66 @@
 """
 from __future__ import annotations
 
+import bisect
 import json
 
 import pandas as pd
 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy import select
+from sqlalchemy import select, text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from .backtest.engine import BacktestConfig, run_backtest
 from .auth import require_user
+from .backtest.events import EventEngineError, run_event_backtest
 from .backtest.strategies import build_strategy
 from .config import settings
 from .data import fetcher, repository
 from .data.aggregation import bars_per_year, resample_bars
 from .data.symbols import plain_code
-from .data.synthetic import seed_if_empty
 from .db import get_session
 from .domain import Bar
 from . import indicators as ind
-from .models import BacktestRun, DailySnapshot, MarketDaily, StockBasic
+from .models import (
+    AdjFactor,
+    BacktestRun,
+    DailySnapshot,
+    MarketDaily,
+    ScreenerQuery,
+    StockBasic,
+    UserPreference,
+    WatchlistItem,
+)
 from .schemas import (
     BacktestRequest,
     BacktestResponse,
     CandleOut,
     EquityPoint,
+    EventBacktestRequest,
+    EventBacktestResponse,
     IndicatorOut,
     MetricsOut,
+    PreferencesOut,
+    PreferencesUpdate,
     PreviewInfoOut,
     PreviewResponse,
+    ScreenerQueryListResponse,
+    ScreenerQueryOut,
     ScreenerRunRequest,
     ScreenerRunResponse,
     ScreenerSyncRequest,
     ScreenerSyncStatus,
     SignalOut,
+    StockListItemOut,
+    StockListResponse,
+    StockFacetsResponse,
+    FacetItemOut,
     SyncRequest,
     SyncResponse,
+    WatchlistOp,
 )
 from .screener import engine, market_sync
 from .screener.engine import DataNotReadyError
-from .screener.llm import ScreenerError, parse_conditions
+from .screener.llm import ScreenerError, parse_conditions, parse_event_spec
 
 router = APIRouter(prefix="/api", dependencies=[Depends(require_user)])
 
@@ -67,6 +89,41 @@ def _rows_to_bars(rows) -> list[Bar]:
     return [Bar(ts=r.ts, open=r.open, high=r.high, low=r.low, close=r.close, volume=r.volume) for r in rows]
 
 
+_ADJUST_MODES = ("bfq", "qfq", "hfq")
+
+
+def _adjust_bars(bars: list[Bar], factors, from_mode: str, to_mode: str) -> list[Bar]:
+    """按复权因子把 K 线从 from_mode 换算到 to_mode（bfq/qfq/hfq）。
+
+    相对不复权的乘数：bfq=1，qfq=f(t)/f(latest)，hfq=f(t)。
+    因子缺失的日期向前沿用最近因子（因子是阶梯函数，除权日之间不变）。
+    """
+    fd = sorted((f.trade_date.date(), float(f.adj_factor)) for f in factors)
+    fdates = [d for d, _ in fd]
+    f_latest = fd[-1][1]
+
+    def _f_at(d) -> float:
+        i = bisect.bisect_right(fdates, d) - 1
+        return fd[i][1] if i >= 0 else fd[0][1]
+
+    def _mult(mode: str, f: float) -> float:
+        if mode == "bfq":
+            return 1.0
+        return f / f_latest if mode == "qfq" else f
+
+    out: list[Bar] = []
+    for b in bars:
+        f = _f_at(b.ts.date())
+        m = _mult(to_mode, f) / _mult(from_mode, f)
+        out.append(Bar(
+            ts=b.ts,
+            open=round(b.open * m, 3), high=round(b.high * m, 3),
+            low=round(b.low * m, 3), close=round(b.close * m, 3),
+            volume=b.volume,
+        ))
+    return out
+
+
 @router.get("/candles/{symbol}", response_model=list[CandleOut])
 async def get_candles(
     symbol: str,
@@ -74,7 +131,6 @@ async def get_candles(
     limit: int = 5000,
     session: AsyncSession = Depends(get_session),
 ) -> list[CandleOut]:
-    await seed_if_empty(session, symbol="DEMO")
     # 始终以日线为基底，再聚合到目标周期
     rows = await repository.get_candles(session, symbol, "1d", limit=limit)
     bars = resample_bars(_rows_to_bars(rows), timeframe)
@@ -93,15 +149,114 @@ async def sync_data(req: SyncRequest, session: AsyncSession = Depends(get_sessio
         raise HTTPException(status_code=502, detail=str(e))
 
 
+# ---------- 股票列表（全市场浏览） ----------
+_STOCKS_SQL = text("""
+    SELECT sb.ts_code, sb.symbol, sb.name, sb.industry, sb.market,
+           c.close AS close, p.close AS prev_close, c.ts AS last_ts, cnt.n AS bar_count,
+           CASE WHEN c.close IS NOT NULL AND p.close IS NOT NULL AND p.close <> 0
+                THEN round(((c.close / p.close - 1) * 100)::numeric, 2) END AS pct_chg,
+           (w.id IS NOT NULL) AS watched
+    FROM stock_basic sb
+    LEFT JOIN LATERAL (
+        SELECT close, ts FROM candles
+        WHERE symbol = sb.symbol AND timeframe = '1d'
+        ORDER BY ts DESC LIMIT 1
+    ) c ON true
+    LEFT JOIN LATERAL (
+        SELECT close FROM candles
+        WHERE symbol = sb.symbol AND timeframe = '1d' AND ts < c.ts
+        ORDER BY ts DESC LIMIT 1
+    ) p ON c.ts IS NOT NULL
+    LEFT JOIN LATERAL (
+        SELECT count(*) AS n FROM candles
+        WHERE symbol = sb.symbol AND timeframe = '1d'
+    ) cnt ON true
+    LEFT JOIN watchlist_items w ON w.ts_code = sb.ts_code AND w.user_id = :uid
+    WHERE sb.list_status = 'L'
+      AND (:search = '' OR sb.symbol LIKE :psearch OR sb.name LIKE :psearch)
+      AND (:market = '' OR sb.market = :market)
+      AND (:industry = '' OR sb.industry = :industry)
+      AND (:area = '' OR sb.area = :area)
+      AND (:watched_only = false OR w.id IS NOT NULL)
+    ORDER BY w.id DESC NULLS LAST, sb.symbol
+    LIMIT :limit OFFSET :offset
+""")
+
+_STOCKS_COUNT_SQL = text("""
+    SELECT count(*) FROM stock_basic sb
+    LEFT JOIN watchlist_items w ON w.ts_code = sb.ts_code AND w.user_id = :uid
+    WHERE sb.list_status = 'L'
+      AND (:search = '' OR sb.symbol LIKE :psearch OR sb.name LIKE :psearch)
+      AND (:market = '' OR sb.market = :market)
+      AND (:industry = '' OR sb.industry = :industry)
+      AND (:area = '' OR sb.area = :area)
+      AND (:watched_only = false OR w.id IS NOT NULL)
+""")
+
+
+@router.get("/stocks", response_model=StockListResponse)
+async def list_stocks(
+    search: str = "",
+    market: str = "",
+    industry: str = "",
+    area: str = "",
+    watched_only: bool = False,
+    limit: int = 100,
+    offset: int = 0,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> StockListResponse:
+    """全市场股票列表：stock_basic 基本信息 + candles 最新行情（本地缓存，无缓存则行情列为空）。
+    自选股（watchlist_items）排最前；watched_only=true 只看自选。"""
+    search = search.strip()
+    limit = max(1, min(limit, 500))
+    offset = max(0, offset)
+    params = {
+        "search": search,
+        "psearch": f"%{search}%",
+        "market": market,
+        "industry": industry,
+        "area": area,
+        "watched_only": watched_only,
+        "uid": user.id,
+        "limit": limit,
+        "offset": offset,
+    }
+    total = (await session.execute(_STOCKS_COUNT_SQL, params)).scalar_one()
+    rows = (await session.execute(_STOCKS_SQL, params)).mappings().all()
+    return StockListResponse(total=total, items=[StockListItemOut(**r) for r in rows])
+
+
+@router.get("/stocks/facets", response_model=StockFacetsResponse)
+async def stock_facets(session: AsyncSession = Depends(get_session)) -> StockFacetsResponse:
+    """看股页筛选项：行业 / 地域（含数量，按数量降序）。"""
+    industries = (
+        await session.execute(text("""
+            SELECT industry AS name, count(*) AS n FROM stock_basic
+            WHERE list_status = 'L' AND industry IS NOT NULL AND industry <> ''
+            GROUP BY industry ORDER BY n DESC
+        """))
+    ).mappings().all()
+    areas = (
+        await session.execute(text("""
+            SELECT area AS name, count(*) AS n FROM stock_basic
+            WHERE list_status = 'L' AND area IS NOT NULL AND area <> ''
+            GROUP BY area ORDER BY n DESC
+        """))
+    ).mappings().all()
+    return StockFacetsResponse(
+        industries=[FacetItemOut(name=r["name"], count=r["n"]) for r in industries],
+        areas=[FacetItemOut(name=r["name"], count=r["n"]) for r in areas],
+    )
+
+
 @router.post("/backtest", response_model=BacktestResponse)
 async def backtest(
     req: BacktestRequest,
     session: AsyncSession = Depends(get_session),
 ) -> BacktestResponse:
-    await seed_if_empty(session, symbol="DEMO")
-
-    # 非演示标的：首次自动拉取真实数据并缓存
-    if req.symbol != "DEMO" and not await fetcher.is_cached(session, req.symbol):
+    # 真实数据：本地无缓存则先拉取
+    if not await fetcher.is_cached(session, req.symbol):
         try:
             await fetcher.sync_symbol(session, req.symbol, source="auto")
         except Exception as e:  # noqa: BLE001
@@ -179,17 +334,71 @@ async def backtest(
     )
 
 
+@router.post("/backtest/event", response_model=EventBacktestResponse)
+async def backtest_event(
+    req: EventBacktestRequest,
+    session: AsyncSession = Depends(get_session),
+) -> EventBacktestResponse:
+    """自然语言事件回测：入场条件命中 -> 次日买入 -> 持有 N 日，单股或全市场汇总统计。
+    直传 spec 则跳过 LLM（前端调参重跑）。"""
+    try:
+        spec = req.spec or await parse_event_spec(req.text)
+        result = await run_event_backtest(
+            session, spec,
+            ts_code=req.ts_code,
+            start=req.start.date() if req.start else None,
+            end=req.end.date() if req.end else None,
+        )
+    except ScreenerError as e:
+        raise HTTPException(status_code=502, detail=str(e))
+    except EventEngineError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:  # noqa: BLE001
+        raise HTTPException(status_code=500, detail=f"事件回测失败: {e}")
+    return EventBacktestResponse(
+        text=req.text,
+        spec=result["spec"],
+        universe=result["universe"],
+        start=result["start"],
+        end=result["end"],
+        stats=result["stats"],
+        trades=result["trades"],
+        total=result["total"],
+    )
+
+
 # ---------- 智能选股 ----------
 @router.post("/screener/run", response_model=ScreenerRunResponse)
 async def screener_run(
-    req: ScreenerRunRequest, session: AsyncSession = Depends(get_session)
+    req: ScreenerRunRequest,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
 ) -> ScreenerRunResponse:
-    """自然语言 -> LLM 解析条件 -> 全市场筛选。也可直传 conditions 跳过 LLM（微调再跑）。"""
+    """自然语言 -> LLM 解析条件 -> 全市场筛选。也可直传 conditions 跳过 LLM（微调再跑）。
+    成功的提问（含解析出的条件与命中数）记录到 screener_queries，供历史一键重跑。"""
     try:
         conds = req.conditions or await parse_conditions(req.text)
         if not conds.indicator and not conds.snapshot:
             raise HTTPException(status_code=400, detail="AI 未从描述中解析出任何筛选条件，请换种说法")
         result = await engine.run_screen(session, conds, settings.screener_default_limit)
+        # 相同文本 + 相同条件的上一条不重复记录（一键重跑场景）
+        exists = (
+            await session.execute(
+                select(ScreenerQuery.id).where(
+                    ScreenerQuery.user_id == user.id,
+                    ScreenerQuery.text == req.text.strip(),
+                    ScreenerQuery.conditions_json == json.dumps(conds.model_dump(), ensure_ascii=False),
+                )
+            )
+        ).scalar_one_or_none()
+        if exists is None:
+            session.add(ScreenerQuery(
+                user_id=user.id,
+                text=req.text.strip(),
+                conditions_json=json.dumps(conds.model_dump(), ensure_ascii=False),
+                hit_count=result.get("total", 0),
+            ))
+            await session.commit()
         return ScreenerRunResponse(**result)
     except HTTPException:
         raise
@@ -202,6 +411,148 @@ async def screener_run(
         raise HTTPException(status_code=code, detail=str(e))
 
 
+@router.get("/screener/queries", response_model=ScreenerQueryListResponse)
+async def screener_queries(
+    limit: int = 20,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> ScreenerQueryListResponse:
+    """当前用户的提问历史（最新在前，含解析出的条件与命中数，可一键重跑）。"""
+    limit = max(1, min(limit, 100))
+    rows = (
+        await session.execute(
+            select(ScreenerQuery)
+            .where(ScreenerQuery.user_id == user.id)
+            .order_by(ScreenerQuery.created_at.desc())
+            .limit(limit)
+        )
+    ).scalars().all()
+    items = []
+    for r in rows:
+        conds = None
+        if r.conditions_json:
+            try:
+                from .schemas import ScreenConditions
+                conds = ScreenConditions.model_validate_json(r.conditions_json)
+            except Exception:  # noqa: BLE001 —— 旧格式/解析失败则只展示文本
+                conds = None
+        items.append(ScreenerQueryOut(
+            id=r.id, text=r.text, conditions=conds, hit_count=r.hit_count, created_at=r.created_at
+        ))
+    return ScreenerQueryListResponse(items=items)
+
+
+@router.delete("/screener/queries/{query_id}", status_code=204)
+async def screener_query_delete(
+    query_id: int,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> None:
+    await session.execute(
+        text("DELETE FROM screener_queries WHERE id = :i AND user_id = :u"),
+        {"i": query_id, "u": user.id},
+    )
+    await session.commit()
+
+
+# ---------- 用户偏好 ----------
+@router.get("/preferences", response_model=PreferencesOut)
+async def get_preferences(
+    session: AsyncSession = Depends(get_session), user=Depends(require_user)
+) -> PreferencesOut:
+    prefs: dict[str, object] = {}
+    rows = (
+        await session.execute(select(UserPreference).where(UserPreference.user_id == user.id))
+    ).scalars().all()
+    for r in rows:
+        try:
+            prefs[r.key] = json.loads(r.value_json)
+        except Exception:  # noqa: BLE001
+            prefs[r.key] = None
+    return PreferencesOut(prefs=prefs)
+
+
+@router.put("/preferences", response_model=PreferencesOut)
+async def put_preferences(
+    req: PreferencesUpdate,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> PreferencesOut:
+    """部分更新：只覆盖出现的 key；值为 null 表示删除该 key。返回更新后的全量。"""
+    for key, value in req.prefs.items():
+        if not key or len(key) > 64:
+            continue
+        if value is None:
+            await session.execute(
+                text("DELETE FROM user_preferences WHERE user_id = :u AND key = :k"),
+                {"u": user.id, "k": key},
+            )
+            continue
+        existing = (
+            await session.execute(
+                select(UserPreference).where(
+                    UserPreference.user_id == user.id, UserPreference.key == key
+                )
+            )
+        ).scalars().first()
+        vj = json.dumps(value, ensure_ascii=False)
+        if existing:
+            existing.value_json = vj
+        else:
+            session.add(UserPreference(user_id=user.id, key=key, value_json=vj))
+    await session.commit()
+    return await get_preferences(session=session, user=user)
+
+
+# ---------- 自选股 ----------
+@router.get("/watchlist", response_model=list[str])
+async def get_watchlist(
+    session: AsyncSession = Depends(get_session), user=Depends(require_user)
+) -> list[str]:
+    """当前用户自选股 ts_code 列表（加入时间倒序）。"""
+    rows = (
+        await session.execute(
+            select(WatchlistItem.ts_code)
+            .where(WatchlistItem.user_id == user.id)
+            .order_by(WatchlistItem.created_at.desc(), WatchlistItem.id.desc())
+        )
+    ).scalars().all()
+    return list(rows)
+
+
+@router.post("/watchlist", response_model=list[str])
+async def add_watchlist(
+    req: WatchlistOp,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> list[str]:
+    exists = (
+        await session.execute(
+            select(WatchlistItem.id).where(
+                WatchlistItem.user_id == user.id, WatchlistItem.ts_code == req.ts_code
+            )
+        )
+    ).scalar_one_or_none()
+    if exists is None:
+        session.add(WatchlistItem(user_id=user.id, ts_code=req.ts_code))
+        await session.commit()
+    return await get_watchlist(session=session, user=user)
+
+
+@router.delete("/watchlist/{ts_code}", response_model=list[str])
+async def remove_watchlist(
+    ts_code: str,
+    session: AsyncSession = Depends(get_session),
+    user=Depends(require_user),
+) -> list[str]:
+    await session.execute(
+        text("DELETE FROM watchlist_items WHERE user_id = :u AND ts_code = :c"),
+        {"u": user.id, "c": ts_code},
+    )
+    await session.commit()
+    return await get_watchlist(session=session, user=user)
+
+
 @router.post("/screener/sync", response_model=ScreenerSyncStatus)
 async def screener_sync_start(
     req: ScreenerSyncRequest, session: AsyncSession = Depends(get_session)
@@ -224,10 +575,22 @@ async def screener_sync_status(session: AsyncSession = Depends(get_session)) ->
 
 @router.get("/screener/preview/{ts_code}", response_model=PreviewResponse)
 async def screener_preview(
-    ts_code: str, limit: int = 260, session: AsyncSession = Depends(get_session)
+    ts_code: str, limit: int = 500, adjust: str = "qfq", timeframe: str = "1d", mas: str = "5,10,20,60",
+    session: AsyncSession = Depends(get_session),
 ) -> PreviewResponse:
-    """个股详情预览：日线（qfq 全量缓存，未缓存/过期自动拉取，失败退 market_daily 近段）
-    + 全套指标（indicators.py 单一事实源）+ 最新截面信息卡。"""
+    """个股详情预览：日线（candles 不复权底座 + adj_factor 本地换算 bfq/qfq/hfq，
+    未缓存自动拉取，失败退 market_daily 近段）+ 全套指标 + 最新截面信息卡。
+    timeframe 聚合到周/月/年（先复权再聚合）；mas 指定主图 MA 周期（逗号分隔）。"""
+    if adjust not in _ADJUST_MODES:
+        raise HTTPException(status_code=400, detail=f"adjust 仅支持 {'/'.join(_ADJUST_MODES)}")
+    if timeframe not in ("1d", "1w", "1M", "1y"):
+        raise HTTPException(status_code=400, detail="timeframe 仅支持 1d/1w/1M/1y")
+    try:
+        ma_periods = sorted({int(p) for p in mas.split(",") if p.strip().isdigit() and 1 <= int(p) <= 500})
+    except ValueError:
+        raise HTTPException(status_code=400, detail="mas 格式应为逗号分隔的数字，如 5,10,20,60")
+    if not ma_periods:
+        ma_periods = [5, 10, 20, 60]
     symbol = plain_code(ts_code)
 
     # 先取 market_daily 最新行：既做缓存过期判断，也做信息卡数据源
@@ -237,16 +600,20 @@ async def screener_preview(
         )
     ).scalars().first()
 
-    # --- 日线：candles(qfq 全量) 优先；未缓存拉取，缓存落后于全市场最新交易日则强制刷新（每日至多一次） ---
+    # --- 日线：candles(不复权底座) 优先；未缓存拉取，缓存落后于全市场最新交易日则强制刷新（每日至多一次） ---
+    # fetcher 增量拉取写入的是 qfq（settings.data_adjust），此时底座模式记为 qfq。
     rows = await repository.get_candles(session, symbol, "1d", limit=100000)
-    source = "qfq"
+    source = "bfq"
+    mode = "bfq"
     try:
         if not rows:
             await fetcher.sync_symbol(session, symbol, source="auto")
             rows = await repository.get_candles(session, symbol, "1d", limit=100000)
+            mode = settings.data_adjust if settings.data_adjust in _ADJUST_MODES else "qfq"
         elif md is not None and rows and rows[-1].ts.date() < md.trade_date.date():
             await fetcher.sync_symbol(session, symbol, source="auto", force=True)
             rows = await repository.get_candles(session, symbol, "1d", limit=100000)
+            mode = settings.data_adjust if settings.data_adjust in _ADJUST_MODES else "qfq"
     except Exception:  # noqa: BLE001 —— tushare/写库失败时回滚会话（否则毒化后兜底查询 500）
         await session.rollback()
         if not rows:
@@ -265,6 +632,22 @@ async def screener_preview(
     if not bars:
         raise HTTPException(status_code=404, detail=f"无数据: {ts_code}（可先点「同步市场数据」）")
 
+    # --- 复权换算：请求模式与底座模式不同时按 adj_factor 本地换算（无因子则维持原样） ---
+    if adjust != mode:
+        factors = (
+            await session.execute(
+                select(AdjFactor).where(AdjFactor.ts_code == ts_code).order_by(AdjFactor.trade_date)
+            )
+        ).scalars().all()
+        if factors:
+            bars = _adjust_bars(bars, factors, mode, adjust)
+            mode = adjust
+            if source != "market":
+                source = adjust
+
+    # --- 周期聚合：复权之后按日历聚合到周/月/年，指标在聚合后的序列上计算 ---
+    bars = resample_bars(bars, timeframe)
+
     # --- 指标（在全量历史上计算后截尾，保证预热正确） ---
     df = pd.DataFrame({"close": [b.close for b in bars], "high": [b.high for b in bars], "low": [b.low for b in bars]})
     closes, highs, lows = df["close"], df["high"], df["low"]
@@ -272,7 +655,7 @@ async def screener_preview(
     kdj = ind.kdj(highs, lows, closes)
     boll = ind.bollinger(closes)
     indicators: dict[str, dict[str, list[float | None]]] = {
-        "ma": {f"ma{p}": _series_to_jsonable(ind.ma(closes, p)) for p in (5, 10, 20, 60)},
+        "ma": {f"ma{p}": _series_to_jsonable(ind.ma(closes, p)) for p in ma_periods},
         "macd": {
             "dif": _series_to_jsonable(macd["macd"]),
             "dea": _series_to_jsonable(macd["signal"]),