""" 账户实时数据API - 从币安API获取实时账户和订单数据 """ from fastapi import APIRouter, HTTPException import sys from pathlib import Path import logging project_root = Path(__file__).parent.parent.parent.parent sys.path.insert(0, str(project_root)) sys.path.insert(0, str(project_root / 'backend')) sys.path.insert(0, str(project_root / 'trading_system')) from database.models import TradingConfig logger = logging.getLogger(__name__) router = APIRouter() async def get_realtime_account_data(): """从币安API实时获取账户数据""" logger.info("=" * 60) logger.info("开始获取实时账户数据") logger.info("=" * 60) try: # 从数据库读取API密钥 logger.info("步骤1: 从数据库读取API配置...") api_key = TradingConfig.get_value('BINANCE_API_KEY') api_secret = TradingConfig.get_value('BINANCE_API_SECRET') use_testnet = TradingConfig.get_value('USE_TESTNET', False) logger.info(f" - API密钥存在: {bool(api_key)}") if api_key: logger.info(f" - API密钥长度: {len(api_key)} 字符") logger.info(f" - API密钥前缀: {api_key[:10]}...") else: logger.warning(" - API密钥为空!") logger.info(f" - API密钥存在: {bool(api_secret)}") if api_secret: logger.info(f" - API密钥长度: {len(api_secret)} 字符") logger.info(f" - API密钥前缀: {api_secret[:10]}...") else: logger.warning(" - API密钥为空!") logger.info(f" - 使用测试网: {use_testnet}") if not api_key or not api_secret: error_msg = "API密钥未配置，请在配置界面设置BINANCE_API_KEY和BINANCE_API_SECRET" logger.error(f" ✗ {error_msg}") raise HTTPException( status_code=400, detail=error_msg ) # 导入交易系统的BinanceClient logger.info("步骤2: 导入BinanceClient...") try: from binance_client import BinanceClient logger.info(" ✓ 从当前路径导入BinanceClient成功") except ImportError as e: logger.warning(f" - 从当前路径导入失败: {e}") # 如果直接导入失败，尝试从trading_system导入 trading_system_path = project_root / 'trading_system' sys.path.insert(0, str(trading_system_path)) logger.info(f" - 添加路径到sys.path: {trading_system_path}") try: from binance_client import BinanceClient logger.info(" ✓ 从trading_system路径导入BinanceClient成功") except ImportError as e2: logger.error(f" ✗ 导入BinanceClient失败: {e2}") raise # 创建客户端 logger.info("步骤3: 创建BinanceClient实例...") client = BinanceClient( api_key=api_key, api_secret=api_secret, testnet=use_testnet ) logger.info(f" ✓ 客户端创建成功 (testnet={use_testnet})") # 连接币安API logger.info("步骤4: 连接币安API...") try: await client.connect() logger.info(" ✓ 币安API连接成功") except Exception as e: logger.error(f" ✗ 币安API连接失败: {e}", exc_info=True) raise # 获取账户余额 logger.info("步骤5: 获取账户余额...") try: balance = await client.get_account_balance() logger.info(" ✓ 账户余额获取成功") logger.info(f" - 返回数据类型: {type(balance)}") logger.info(f" - 返回数据内容: {balance}") if balance: logger.info(f" - 总余额: {balance.get('total', 'N/A')} USDT") logger.info(f" - 可用余额: {balance.get('available', 'N/A')} USDT") logger.info(f" - 保证金: {balance.get('margin', 'N/A')} USDT") if balance.get('total', 0) == 0: logger.warning(" ⚠ 账户余额为0，可能是API权限问题或账户确实无余额") else: logger.warning(" ⚠ 返回的余额数据为空") except Exception as e: logger.error(f" ✗ 获取账户余额失败: {e}", exc_info=True) raise # 获取持仓 logger.info("步骤6: 获取持仓信息...") try: positions = await client.get_open_positions() logger.info(" ✓ 持仓信息获取成功") logger.info(f" - 返回数据类型: {type(positions)}") logger.info(f" - 持仓数量: {len(positions)}") if positions: logger.info(" - 持仓详情:") for i, pos in enumerate(positions[:5], 1): # 只显示前5个 logger.info(f" {i}. {pos.get('symbol', 'N/A')}: " f"数量={pos.get('positionAmt', 0)}, " f"入场价={pos.get('entryPrice', 0)}, " f"盈亏={pos.get('unRealizedProfit', 0)}") if len(positions) > 5: logger.info(f" ... 还有 {len(positions) - 5} 个持仓") else: logger.info(" - 当前无持仓") except Exception as e: logger.error(f" ✗ 获取持仓信息失败: {e}", exc_info=True) raise # 计算总仓位价值和总盈亏 logger.info("步骤7: 计算仓位统计...") # total_position_value：历史上这里代表“名义仓位价值(notional)”（按标记价） total_position_value = 0 # total_margin_value：更贴近风控配置语义（保证金占用） total_margin_value = 0 total_pnl = 0 open_positions_count = 0 for pos in positions: position_amt = float(pos.get('positionAmt', 0)) if position_amt == 0: continue entry_price = float(pos.get('entryPrice', 0)) mark_price = float(pos.get('markPrice', 0)) unrealized_pnl = float(pos.get('unRealizedProfit', 0)) if mark_price == 0: # 如果没有标记价格，使用入场价 mark_price = entry_price position_value = abs(position_amt * mark_price) total_position_value += position_value # 保证金占用（粗略口径）：名义/杠杆（币安页面的展示会更复杂，但这个口径与 MAX_TOTAL_POSITION_PERCENT 对齐） try: lv = float(pos.get('leverage', 0) or 0) if lv <= 0: lv = 1.0 except Exception: lv = 1.0 total_margin_value += (position_value / lv) total_pnl += unrealized_pnl open_positions_count += 1 logger.debug(f" - {pos.get('symbol')}: 价值={position_value:.2f}, 盈亏={unrealized_pnl:.2f}") logger.info(" ✓ 仓位统计计算完成") logger.info(f" - 总名义仓位: {total_position_value:.2f} USDT") logger.info(f" - 总保证金占用(估算): {total_margin_value:.2f} USDT") logger.info(f" - 总盈亏: {total_pnl:.2f} USDT") logger.info(f" - 持仓数量: {open_positions_count}") # 断开连接 logger.info("步骤8: 断开币安API连接...") try: await client.disconnect() logger.info(" ✓ 连接已断开") except Exception as e: logger.warning(f" ⚠ 断开连接时出错: {e}") # 构建返回结果 result = { "total_balance": balance.get('total', 0) if balance else 0, "available_balance": balance.get('available', 0) if balance else 0, # 名义仓位（按标记价汇总） "total_position_value": total_position_value, # 保证金占用（名义/杠杆汇总） "total_margin_value": total_margin_value, "total_pnl": total_pnl, "open_positions": open_positions_count } logger.info("=" * 60) logger.info("账户数据获取成功!") logger.info(f"最终结果: {result}") logger.info("=" * 60) return result except HTTPException as e: logger.error("=" * 60) logger.error(f"HTTP异常: {e.status_code} - {e.detail}") logger.error("=" * 60) raise except Exception as e: error_msg = f"获取账户数据失败: {str(e)}" logger.error("=" * 60) logger.error(f"异常类型: {type(e).__name__}") logger.error(f"错误信息: {error_msg}") logger.error("=" * 60, exc_info=True) raise HTTPException(status_code=500, detail=error_msg) @router.get("/realtime") async def get_realtime_account(): """获取实时账户数据""" return await get_realtime_account_data() @router.get("/positions") async def get_realtime_positions(): """获取实时持仓数据""" try: # 从数据库读取API密钥 api_key = TradingConfig.get_value('BINANCE_API_KEY') api_secret = TradingConfig.get_value('BINANCE_API_SECRET') use_testnet = TradingConfig.get_value('USE_TESTNET', False) logger.info(f"尝试获取实时持仓数据 (testnet={use_testnet})") if not api_key or not api_secret: error_msg = "API密钥未配置" logger.warning(error_msg) raise HTTPException( status_code=400, detail=error_msg ) # 导入BinanceClient try: from binance_client import BinanceClient except ImportError: trading_system_path = project_root / 'trading_system' sys.path.insert(0, str(trading_system_path)) from binance_client import BinanceClient client = BinanceClient( api_key=api_key, api_secret=api_secret, testnet=use_testnet ) logger.info("连接币安API获取持仓...") await client.connect() positions = await client.get_open_positions() await client.disconnect() logger.info(f"获取到 {len(positions)} 个持仓") # 格式化持仓数据 formatted_positions = [] for pos in positions: position_amt = float(pos.get('positionAmt', 0)) if position_amt == 0: continue entry_price = float(pos.get('entryPrice', 0)) mark_price = float(pos.get('markPrice', 0)) unrealized_pnl = float(pos.get('unRealizedProfit', 0)) if mark_price == 0: mark_price = entry_price # === 名义/保证金口径说明（与币安展示更接近）=== # - 币安的名义价值/仓位价值通常随标记价(markPrice)变动 # - DB 中的 notional_usdt/margin_usdt 通常是“开仓时”写入，用于复盘/统计 # - 若发生部分止盈/减仓：币安 positionAmt 会变小，但 DB 里的 notional/margin 可能仍是“原始开仓量” # → 会出现：数量=6.8，但名义/保证金像是 13.6 的两倍（与你反馈一致） # # 因此：实时持仓展示统一使用“当前数量×标记价”的实时名义/保证金， # 并额外返回 original_* 字段保留 DB 开仓口径，避免混用导致误解。 # 兼容旧字段：entry_value_usdt 仍保留（但它是按入场价计算的名义） entry_value_usdt = abs(position_amt) * entry_price leverage = float(pos.get('leverage', 1)) if leverage <= 0: leverage = 1.0 # 当前持仓名义价值（USDT）：按标记价 notional_usdt_live = abs(position_amt) * mark_price # 当前持仓保证金（USDT）：名义/杠杆 margin_usdt_live = notional_usdt_live / leverage pnl_percent = 0 if margin_usdt_live > 0: pnl_percent = (unrealized_pnl / margin_usdt_live) * 100 # 尝试从数据库获取开仓时间、止损止盈价格（以及交易规模字段） entry_time = None stop_loss_price = None take_profit_price = None take_profit_1 = None take_profit_2 = None atr_value = None db_margin_usdt = None db_notional_usdt = None try: from database.models import Trade db_trades = Trade.get_by_symbol(pos.get('symbol'), status='open') if db_trades: # 找到匹配的交易记录（通过symbol和entry_price匹配） for db_trade in db_trades: if abs(float(db_trade.get('entry_price', 0)) - entry_price) < 0.01: entry_time = db_trade.get('entry_time') # 尝试从数据库获取止损止盈价格（如果存储了） stop_loss_price = db_trade.get('stop_loss_price') take_profit_price = db_trade.get('take_profit_price') take_profit_1 = db_trade.get('take_profit_1') take_profit_2 = db_trade.get('take_profit_2') atr_value = db_trade.get('atr') db_margin_usdt = db_trade.get('margin_usdt') db_notional_usdt = db_trade.get('notional_usdt') break except Exception as e: logger.debug(f"获取数据库信息失败: {e}") # 如果没有从数据库获取到止损止盈价格，前端会自己计算 # 注意：数据库可能没有存储止损止盈价格，这是正常的 formatted_positions.append({ "symbol": pos.get('symbol'), "side": "BUY" if position_amt > 0 else "SELL", "quantity": abs(position_amt), "entry_price": entry_price, # 兼容旧字段：entry_value_usdt 仍保留（前端已有使用） "entry_value_usdt": entry_value_usdt, # 实时展示字段：与币安更一致（按当前数量×标记价） "notional_usdt": notional_usdt_live, "margin_usdt": margin_usdt_live, # 额外返回“开仓记录口径”（用于排查部分止盈/减仓导致的不一致） "original_notional_usdt": db_notional_usdt, "original_margin_usdt": db_margin_usdt, "mark_price": mark_price, "pnl": unrealized_pnl, "pnl_percent": pnl_percent, # 基于保证金的盈亏百分比 "leverage": int(pos.get('leverage', 1)), "entry_time": entry_time, # 开仓时间 "stop_loss_price": stop_loss_price, # 止损价格（如果可用） "take_profit_price": take_profit_price, # 止盈价格（如果可用） "take_profit_1": take_profit_1, "take_profit_2": take_profit_2, "atr": atr_value, }) logger.info(f"格式化后 {len(formatted_positions)} 个有效持仓") return formatted_positions except HTTPException: raise except Exception as e: error_msg = f"获取持仓数据失败: {str(e)}" logger.error(error_msg, exc_info=True) raise HTTPException(status_code=500, detail=error_msg) @router.post("/positions/{symbol}/close") async def close_position(symbol: str): """手动平仓指定交易对的持仓""" try: logger.info(f"=" * 60) logger.info(f"收到平仓请求: {symbol}") logger.info(f"=" * 60) # 从数据库读取API密钥 api_key = TradingConfig.get_value('BINANCE_API_KEY') api_secret = TradingConfig.get_value('BINANCE_API_SECRET') use_testnet = TradingConfig.get_value('USE_TESTNET', False) if not api_key or not api_secret: error_msg = "API密钥未配置" logger.warning(error_msg) raise HTTPException(status_code=400, detail=error_msg) # 导入必要的模块 try: from binance_client import BinanceClient logger.info("✓ 成功导入交易系统模块") except ImportError as import_error: logger.warning(f"首次导入失败: {import_error}，尝试从trading_system路径导入") trading_system_path = project_root / 'trading_system' sys.path.insert(0, str(trading_system_path)) from binance_client import BinanceClient logger.info("✓ 从trading_system路径导入成功") # 导入数据库模型 from database.models import Trade # 创建客户端 logger.info(f"创建BinanceClient (testnet={use_testnet})...") client = BinanceClient( api_key=api_key, api_secret=api_secret, testnet=use_testnet ) logger.info("连接币安API...") await client.connect() logger.info("✓ 币安API连接成功") try: # 检查币安是否有持仓（使用原始 position_information，确保能拿到 positionSide 以处理 -4061） logger.info(f"检查 {symbol} 在币安的持仓状态...") # 读取持仓模式：dualSidePosition=True => 对冲模式（必须传 positionSide=LONG/SHORT） dual_side = None try: mode_res = await client.client.futures_get_position_mode() if isinstance(mode_res, dict): dual_side = bool(mode_res.get("dualSidePosition")) except Exception as e: logger.warning(f"读取持仓模式失败（将按单向模式兜底）: {e}") dual_side = None raw_positions = await client.client.futures_position_information(symbol=symbol) nonzero_positions = [] for p in raw_positions or []: try: amt = float(p.get("positionAmt", 0)) except Exception: continue if abs(amt) > 0: nonzero_positions.append((amt, p)) # 兼容旧逻辑：如果原始接口异常，回退到封装方法 if not nonzero_positions: try: positions = await client.get_open_positions() position = next((p for p in positions if p['symbol'] == symbol and float(p['positionAmt']) != 0), None) if position: nonzero_positions = [(float(position["positionAmt"]), {"positionAmt": position["positionAmt"]})] except Exception: nonzero_positions = [] if not nonzero_positions: logger.warning(f"⚠ {symbol} 币安账户中没有持仓，可能已被平仓") # 检查数据库中是否有未平仓的记录，如果有则更新 open_trades = Trade.get_by_symbol(symbol, status='open') if open_trades: trade = open_trades[0] # 获取当前价格作为平仓价格 ticker = await client.get_ticker_24h(symbol) exit_price = float(ticker['price']) if ticker else float(trade['entry_price']) # 计算盈亏 entry_price = float(trade['entry_price']) quantity = float(trade['quantity']) if trade['side'] == 'BUY': pnl = (exit_price - entry_price) * quantity pnl_percent = ((exit_price - entry_price) / entry_price) * 100 else: pnl = (entry_price - exit_price) * quantity pnl_percent = ((entry_price - exit_price) / entry_price) * 100 # 更新数据库 Trade.update_exit( trade_id=trade['id'], exit_price=exit_price, exit_reason='manual', pnl=pnl, pnl_percent=pnl_percent, exit_order_id=None ) logger.info(f"✓ 已更新数据库记录（币安无持仓但数据库有记录）") return { "message": f"{symbol} 平仓操作完成（币安账户中没有持仓，可能已被平仓）", "symbol": symbol, "status": "closed" } # 获取交易对精度信息，调整数量精度（平仓不要向上补 minQty，避免超过持仓数量） symbol_info = None try: symbol_info = await client.get_symbol_info(symbol) except Exception: symbol_info = None def _adjust_close_qty(qty: float) -> float: if qty is None: return 0.0 q = float(qty) if not symbol_info: return q quantity_precision = symbol_info.get('quantityPrecision', 8) step_size = float(symbol_info.get('stepSize', 0) or 0) if step_size and step_size > 0: # 向下取整，避免超过持仓 q = float(int(q / step_size)) * step_size else: q = round(q, quantity_precision) q = round(q, quantity_precision) return q # 组装平仓订单（对冲模式可能同币种有 LONG/SHORT 两个仓位，这里一并平掉） orders = [] order_ids = [] # 如果 dual_side 无法读取，按 raw_positions 是否包含 positionSide 来推断 if dual_side is None: if any(isinstance(p, dict) and (p.get("positionSide") in ("LONG", "SHORT")) for _, p in nonzero_positions): dual_side = True else: dual_side = False logger.info(f"{symbol} 持仓模式: {'HEDGE(对冲)' if dual_side else 'ONE-WAY(单向)'}") # 构造待平仓列表：[(positionSide, amt)] to_close = [] if dual_side: for amt, p in nonzero_positions: ps = (p.get("positionSide") or "").upper() if ps not in ("LONG", "SHORT"): ps = "LONG" if amt > 0 else "SHORT" to_close.append((ps, amt)) else: # 单向模式只应存在一个净仓位；如果有多个，按合计处理 net_amt = sum([amt for amt, _ in nonzero_positions]) if abs(net_amt) > 0: to_close.append(("BOTH", net_amt)) logger.info(f"✓ 币安账户中 {symbol} 待平仓: {to_close}") for ps, amt in to_close: side = 'SELL' if float(amt) > 0 else 'BUY' quantity = abs(float(amt)) quantity = _adjust_close_qty(quantity) if quantity <= 0: logger.warning(f"{symbol} 平仓数量调整后为0，跳过该仓位: positionSide={ps}, amt={amt}") continue order_params = { "symbol": symbol, "side": side, "type": "MARKET", "quantity": quantity, } # 对冲模式必须传 positionSide=LONG/SHORT；并且某些账户会 -1106，因此这里不再传 reduceOnly if dual_side and ps in ("LONG", "SHORT"): order_params["positionSide"] = ps else: # 单向模式用 reduceOnly 防止反向开仓 order_params["reduceOnly"] = True logger.info( f"开始执行平仓下单: {symbol} side={side} qty={quantity} " f"positionSide={order_params.get('positionSide')} reduceOnly={order_params.get('reduceOnly')}" ) try: order = await client.client.futures_create_order(**order_params) if not order: raise RuntimeError("币安API返回 None") orders.append(order) oid = order.get("orderId") if oid: order_ids.append(oid) except Exception as order_error: error_msg = f"{symbol} 平仓失败：下单异常 - {str(order_error)}" logger.error(error_msg) logger.error(f" 错误类型: {type(order_error).__name__}") import traceback logger.error(f" 完整错误堆栈:\n{traceback.format_exc()}") raise HTTPException(status_code=500, detail=error_msg) if not orders: raise HTTPException(status_code=400, detail=f"{symbol} 无可平仓的有效仓位（数量调整后为0或无持仓）") logger.info(f"✓ {symbol} 平仓订单已提交: {order_ids}") # 等待订单成交，获取实际成交价格 import asyncio await asyncio.sleep(1) # 获取订单详情（可能多个订单，按订单号分别取价） exit_prices = {} for oid in order_ids: try: order_info = await client.client.futures_get_order(symbol=symbol, orderId=oid) if order_info: p = float(order_info.get('avgPrice', 0)) or float(order_info.get('price', 0)) if p <= 0 and order_info.get('fills'): total_qty = 0 total_value = 0 for fill in order_info.get('fills', []): qty = float(fill.get('qty', 0)) price = float(fill.get('price', 0)) total_qty += qty total_value += qty * price if total_qty > 0: p = total_value / total_qty if p > 0: exit_prices[oid] = p except Exception as e: logger.warning(f"获取订单详情失败 (orderId={oid}): {e}") # 兜底：如果无法获取订单价格，使用当前价格 fallback_exit_price = None try: ticker = await client.get_ticker_24h(symbol) fallback_exit_price = float(ticker['price']) if ticker else None except Exception: fallback_exit_price = None # 更新数据库记录 open_trades = Trade.get_by_symbol(symbol, status='open') if open_trades: # 对冲模式可能有多条 trade（BUY/LONG 和 SELL/SHORT），尽量按方向匹配订单更新 used_order_ids = set() for trade in open_trades: try: entry_price = float(trade['entry_price']) trade_quantity = float(trade['quantity']) except Exception: continue # 选择一个未使用的 orderId（如果只有一个，就复用） chosen_oid = None for oid in order_ids: if oid not in used_order_ids: chosen_oid = oid break if chosen_oid is None and order_ids: chosen_oid = order_ids[0] if chosen_oid: used_order_ids.add(chosen_oid) exit_price = exit_prices.get(chosen_oid) if chosen_oid else None if not exit_price: exit_price = fallback_exit_price or entry_price # 计算盈亏（数据库侧依旧按名义盈亏；收益率展示用保证金口径在前端/统计里另算） if trade['side'] == 'BUY': pnl = (exit_price - entry_price) * trade_quantity pnl_percent = ((exit_price - entry_price) / entry_price) * 100 else: pnl = (entry_price - exit_price) * trade_quantity pnl_percent = ((entry_price - exit_price) / entry_price) * 100 Trade.update_exit( trade_id=trade['id'], exit_price=exit_price, exit_reason='manual', pnl=pnl, pnl_percent=pnl_percent, exit_order_id=chosen_oid ) logger.info(f"✓ 已更新数据库记录 trade_id={trade['id']} order_id={chosen_oid} (盈亏: {pnl:.2f} USDT, {pnl_percent:.2f}%)") logger.info(f"✓ {symbol} 平仓成功") return { "message": f"{symbol} 平仓成功", "symbol": symbol, "status": "closed" } finally: logger.info("断开币安API连接...") await client.disconnect() logger.info("✓ 已断开连接") except HTTPException: raise except Exception as e: error_msg = f"平仓失败: {str(e)}" logger.error("=" * 60) logger.error(f"平仓操作异常: {error_msg}") logger.error(f"错误类型: {type(e).__name__}") logger.error("=" * 60, exc_info=True) raise HTTPException(status_code=500, detail=error_msg) @router.post("/positions/sync") async def sync_positions(): """同步币安实际持仓状态与数据库状态""" try: logger.info("=" * 60) logger.info("收到持仓状态同步请求") logger.info("=" * 60) # 从数据库读取API密钥 api_key = TradingConfig.get_value('BINANCE_API_KEY') api_secret = TradingConfig.get_value('BINANCE_API_SECRET') use_testnet = TradingConfig.get_value('USE_TESTNET', False) if not api_key or not api_secret: error_msg = "API密钥未配置" logger.warning(error_msg) raise HTTPException(status_code=400, detail=error_msg) # 导入必要的模块 try: from binance_client import BinanceClient except ImportError: trading_system_path = project_root / 'trading_system' sys.path.insert(0, str(trading_system_path)) from binance_client import BinanceClient # 导入数据库模型 from database.models import Trade # 创建客户端 client = BinanceClient( api_key=api_key, api_secret=api_secret, testnet=use_testnet ) logger.info("连接币安API...") await client.connect() try: # 1. 获取币安实际持仓 binance_positions = await client.get_open_positions() binance_symbols = {p['symbol'] for p in binance_positions if float(p.get('positionAmt', 0)) != 0} logger.info(f"币安实际持仓: {len(binance_symbols)} 个") if binance_symbols: logger.info(f" 持仓列表: {', '.join(binance_symbols)}") # 2. 获取数据库中状态为open的交易记录 db_open_trades = Trade.get_all(status='open') db_open_symbols = {t['symbol'] for t in db_open_trades} logger.info(f"数据库open状态: {len(db_open_symbols)} 个") if db_open_symbols: logger.info(f" 持仓列表: {', '.join(db_open_symbols)}") # 3. 找出在数据库中open但在币安已不存在的持仓（需要更新为closed） missing_in_binance = db_open_symbols - binance_symbols updated_count = 0 if missing_in_binance: logger.info(f"发现 {len(missing_in_binance)} 个持仓在数据库中是open但币安已不存在: {', '.join(missing_in_binance)}") for symbol in missing_in_binance: try: # 获取该交易对的所有open记录 open_trades = Trade.get_by_symbol(symbol, status='open') for trade in open_trades: trade_id = trade['id'] entry_price = float(trade['entry_price']) quantity = float(trade['quantity']) # 获取当前价格作为平仓价格 ticker = await client.get_ticker_24h(symbol) exit_price = float(ticker['price']) if ticker else entry_price # 计算盈亏 if trade['side'] == 'BUY': pnl = (exit_price - entry_price) * quantity else: pnl = (entry_price - exit_price) * quantity # 计算基于保证金的盈亏百分比 leverage = float(trade.get('leverage', 10)) entry_value = entry_price * quantity margin = entry_value / leverage if leverage > 0 else entry_value pnl_percent_margin = (pnl / margin * 100) if margin > 0 else 0 # 更新数据库记录 Trade.update_exit( trade_id=trade_id, exit_price=exit_price, exit_reason='sync', # 标记为同步平仓 pnl=pnl, pnl_percent=pnl_percent_margin, # 使用基于保证金的盈亏百分比 exit_order_id=None ) updated_count += 1 logger.info( f"✓ {symbol} 已更新为closed (ID: {trade_id}, " f"盈亏: {pnl:.2f} USDT, {pnl_percent_margin:.2f}% of margin)" ) except Exception as e: logger.error(f"❌ {symbol} 更新失败: {e}") import traceback logger.error(f" 错误详情:\n{traceback.format_exc()}") else: logger.info("✓ 数据库与币安状态一致，无需更新") # 4. 检查币安有但数据库没有记录的持仓 missing_in_db = binance_symbols - db_open_symbols if missing_in_db: logger.info(f"发现 {len(missing_in_db)} 个持仓在币安存在但数据库中没有记录: {', '.join(missing_in_db)}") logger.info(" 这些持仓可能是手动开仓的，建议手动处理") result = { "message": "持仓状态同步完成", "binance_positions": len(binance_symbols), "db_open_positions": len(db_open_symbols), "updated_to_closed": updated_count, "missing_in_binance": list(missing_in_binance), "missing_in_db": list(missing_in_db) } logger.info("=" * 60) logger.info("持仓状态同步完成!") logger.info(f"结果: {result}") logger.info("=" * 60) return result finally: await client.disconnect() logger.info("✓ 已断开币安API连接") except HTTPException: raise except Exception as e: error_msg = f"同步持仓状态失败: {str(e)}" logger.error(error_msg, exc_info=True) raise HTTPException(status_code=500, detail=error_msg)