liuyu/nofx
1
0
Fork 0
mirror of https://github.com/NoFxAiOS/nofx.git synced 2026-07-16 17:12:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: standardize code comments

Browse Source
This commit is contained in:
tinkle-community
2025-12-08 01:40:48 +08:00
parent 0636ced476
commit a12c0ae8c9
103 changed files with 5466 additions and 5468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
trader/order_sync.go
View File

@@ -8,19 +8,19 @@ import (
"time"
)
// OrderSyncManager 订单状态同步管理器
// 负责定期扫描所有 NEW 状态的订单，并更新其状态
// OrderSyncManager Order status synchronization manager
// Responsible for periodically scanning all NEW status orders and updating their status
type OrderSyncManager struct {
store *store.Store
interval time.Duration
stopCh chan struct{}
wg sync.WaitGroup
traderCache map[string]Trader // trader_id -> Trader 实例缓存
configCache map[string]*store.TraderFullConfig // trader_id -> 配置缓存
traderCache map[string]Trader // trader_id -> Trader instance cache
configCache map[string]*store.TraderFullConfig // trader_id -> config cache
cacheMutex sync.RWMutex
}
// NewOrderSyncManager 创建订单同步管理器
// NewOrderSyncManager Create order synchronization manager
func NewOrderSyncManager(st *store.Store, interval time.Duration) *OrderSyncManager {
if interval == 0 {
interval = 10 * time.Second
@@ -34,32 +34,32 @@ func NewOrderSyncManager(st *store.Store, interval time.Duration) *OrderSyncMana
}
}
// Start 启动订单同步服务
// Start Start order synchronization service
func (m *OrderSyncManager) Start() {
m.wg.Add(1)
go m.run()
logger.Info("📦 订单同步管理器已启动")
logger.Info("📦 Order sync manager started")
}
// Stop 停止订单同步服务
// Stop Stop order synchronization service
func (m *OrderSyncManager) Stop() {
close(m.stopCh)
m.wg.Wait()
// 清理缓存
// Clear cache
m.cacheMutex.Lock()
m.traderCache = make(map[string]Trader)
m.configCache = make(map[string]*store.TraderFullConfig)
m.cacheMutex.Unlock()
logger.Info("📦 订单同步管理器已停止")
logger.Info("📦 Order sync manager stopped")
}
// run 主循环
// run Main loop
func (m *OrderSyncManager) run() {
defer m.wg.Done()
// 启动时立即执行一次
// Execute immediately on startup
m.syncOrders()
ticker := time.NewTicker(m.interval)
@@ -75,12 +75,12 @@ func (m *OrderSyncManager) run() {
}
}
// syncOrders 同步所有待处理订单
// syncOrders Synchronize all pending orders
func (m *OrderSyncManager) syncOrders() {
// 获取所有 NEW 状态的订单
// Get all NEW status orders
orders, err := m.store.Order().GetAllPendingOrders()
if err != nil {
logger.Infof("⚠️ 获取待处理订单失败: %v", err)
logger.Infof("⚠️ Failed to get pending orders: %v", err)
return
}
@@ -88,26 +88,26 @@ func (m *OrderSyncManager) syncOrders() {
return
}
logger.Infof("📦 开始同步 %d 个待处理订单...", len(orders))
logger.Infof("📦 Starting to sync %d pending orders...", len(orders))
// 按 trader_id 分组
// Group by trader_id
ordersByTrader := make(map[string][]*store.TraderOrder)
for _, order := range orders {
ordersByTrader[order.TraderID] = append(ordersByTrader[order.TraderID], order)
}
// 逐个 trader 处理
// Process each trader
for traderID, traderOrders := range ordersByTrader {
m.syncTraderOrders(traderID, traderOrders)
}
}
// syncTraderOrders 同步单个 trader 的订单
// syncTraderOrders Synchronize orders for a single trader
func (m *OrderSyncManager) syncTraderOrders(traderID string, orders []*store.TraderOrder) {
// 获取或创建 trader 实例
// Get or create trader instance
trader, err := m.getOrCreateTrader(traderID)
if err != nil {
logger.Infof("⚠️ 获取 trader 实例失败 (ID: %s): %v", traderID, err)
logger.Infof("⚠️ Failed to get trader instance (ID: %s): %v", traderID, err)
return
}
@@ -116,13 +116,13 @@ func (m *OrderSyncManager) syncTraderOrders(traderID string, orders []*store.Tra
}
}
// syncSingleOrder 同步单个订单状态
// syncSingleOrder Synchronize single order status
func (m *OrderSyncManager) syncSingleOrder(trader Trader, order *store.TraderOrder) {
status, err := trader.GetOrderStatus(order.Symbol, order.OrderID)
if err != nil {
// 查询失败，检查订单创建时间，超过一定时间假设已成交
// Query failed, check order creation time, assume filled after certain time
if time.Since(order.CreatedAt) > 5*time.Minute {
logger.Infof("⚠️ 订单查询超时，假设已成交 (ID: %s)", order.OrderID)
logger.Infof("⚠️ Order query timeout, assuming filled (ID: %s)", order.OrderID)
m.markOrderFilled(order, 0, 0, 0)
}
return
@@ -136,7 +136,7 @@ func (m *OrderSyncManager) syncSingleOrder(trader Trader, order *store.TraderOrd
executedQty, _ := status["executedQty"].(float64)
commission, _ := status["commission"].(float64)
// 如果 API 未返回数量，使用原始数量
// If API doesn't return quantity, use original quantity
if executedQty == 0 {
executedQty = order.Quantity
}
@@ -146,16 +146,16 @@ func (m *OrderSyncManager) syncSingleOrder(trader Trader, order *store.TraderOrd
case "CANCELED", "EXPIRED":
order.Status = statusStr
if err := m.store.Order().Update(order); err != nil {
logger.Infof("⚠️ 更新订单状态失败: %v", err)
logger.Infof("⚠️ Failed to update order status: %v", err)
} else {
logger.Infof("📦 订单状态更新: %s (ID: %s)", statusStr, order.OrderID)
logger.Infof("📦 Order status updated: %s (ID: %s)", statusStr, order.OrderID)
}
}
}
// markOrderFilled 标记订单已成交
// markOrderFilled Mark order as filled
func (m *OrderSyncManager) markOrderFilled(order *store.TraderOrder, avgPrice, executedQty, commission float64) {
// 如果 avgPrice 为 0，使用订单价格
// If avgPrice is 0, use order price
if avgPrice == 0 {
avgPrice = order.Price
}
@@ -163,14 +163,14 @@ func (m *OrderSyncManager) markOrderFilled(order *store.TraderOrder, avgPrice, e
executedQty = order.Quantity
}
// 计算已实现盈亏（仅平仓订单）
// Calculate realized PnL (only for closing orders)
var realizedPnL float64
if (order.Action == "close_long" || order.Action == "close_short") && order.EntryPrice > 0 && avgPrice > 0 {
if order.Action == "close_long" {
// 平多盈亏 = (平仓价 - 开仓价) * 数量
// Long close PnL = (close price - entry price) * quantity
realizedPnL = (avgPrice - order.EntryPrice) * executedQty
} else {
// 平空盈亏 = (开仓价 - 平仓价) * 数量
// Short close PnL = (entry price - close price) * quantity
realizedPnL = (order.EntryPrice - avgPrice) * executedQty
}
}
@@ -183,19 +183,19 @@ func (m *OrderSyncManager) markOrderFilled(order *store.TraderOrder, avgPrice, e
order.FilledAt = time.Now()
if err := m.store.Order().Update(order); err != nil {
logger.Infof("⚠️ 更新订单状态失败: %v", err)
logger.Infof("⚠️ Failed to update order status: %v", err)
} else {
if realizedPnL != 0 {
logger.Infof("✅ 订单已成交 (ID: %s, avgPrice: %.4f, qty: %.4f, PnL: %.2f)",
logger.Infof("✅ Order filled (ID: %s, avgPrice: %.4f, qty: %.4f, PnL: %.2f)",
order.OrderID, avgPrice, executedQty, realizedPnL)
} else {
logger.Infof("✅ 订单已成交 (ID: %s, avgPrice: %.4f, qty: %.4f)",
logger.Infof("✅ Order filled (ID: %s, avgPrice: %.4f, qty: %.4f)",
order.OrderID, avgPrice, executedQty)
}
}
}
// getOrCreateTrader 获取或创建 trader 实例
// getOrCreateTrader Get or create trader instance
func (m *OrderSyncManager) getOrCreateTrader(traderID string) (Trader, error) {
m.cacheMutex.RLock()
trader, exists := m.traderCache[traderID]
@@ -205,17 +205,17 @@ func (m *OrderSyncManager) getOrCreateTrader(traderID string) (Trader, error) {
return trader, nil
}
// 需要创建新的 trader 实例
// 首先获取 trader 配置
// Need to create new trader instance
// First get trader config
config, err := m.getTraderConfig(traderID)
if err != nil {
return nil, fmt.Errorf("获取 trader 配置失败: %w", err)
return nil, fmt.Errorf("failed to get trader config: %w", err)
}
// 根据交易所类型创建 trader
// Create trader based on exchange type
trader, err = m.createTrader(config)
if err != nil {
return nil, fmt.Errorf("创建 trader 实例失败: %w", err)
return nil, fmt.Errorf("failed to create trader instance: %w", err)
}
m.cacheMutex.Lock()
@@ -225,7 +225,7 @@ func (m *OrderSyncManager) getOrCreateTrader(traderID string) (Trader, error) {
return trader, nil
}
// getTraderConfig 获取 trader 配置
// getTraderConfig Get trader configuration
func (m *OrderSyncManager) getTraderConfig(traderID string) (*store.TraderFullConfig, error) {
m.cacheMutex.RLock()
config, exists := m.configCache[traderID]
@@ -235,11 +235,11 @@ func (m *OrderSyncManager) getTraderConfig(traderID string) (*store.TraderFullCo
return config, nil
}
// 从数据库获取 - 需要找到 trader 对应的 userID
// 首先查询所有 traders 找到对应的 userID
// Get from database - need to find trader's corresponding userID
// First query all traders to find corresponding userID
traders, err := m.store.Trader().ListAll()
if err != nil {
return nil, fmt.Errorf("获取 trader 列表失败: %w", err)
return nil, fmt.Errorf("failed to get trader list: %w", err)
}
var userID string
@@ -251,7 +251,7 @@ func (m *OrderSyncManager) getTraderConfig(traderID string) (*store.TraderFullCo
}
if userID == "" {
return nil, fmt.Errorf("找不到 trader: %s", traderID)
return nil, fmt.Errorf("trader not found: %s", traderID)
}
config, err = m.store.Trader().GetFullConfig(userID, traderID)
@@ -266,11 +266,11 @@ func (m *OrderSyncManager) getTraderConfig(traderID string) (*store.TraderFullCo
return config, nil
}
// createTrader 根据配置创建 trader 实例
// createTrader Create trader instance based on configuration
func (m *OrderSyncManager) createTrader(config *store.TraderFullConfig) (Trader, error) {
exchange := config.Exchange
// 使用 exchange.ID 判断具体的交易所，而不是 exchange.Type (cex/dex)
// Use exchange.ID to determine specific exchange, not exchange.Type (cex/dex)
switch exchange.ID {
case "binance":
return NewFuturesTrader(exchange.APIKey, exchange.SecretKey, config.Trader.UserID), nil
@@ -299,11 +299,11 @@ func (m *OrderSyncManager) createTrader(config *store.TraderFullConfig) (Trader,
return NewLighterTrader(exchange.LighterPrivateKey, exchange.LighterWalletAddr, exchange.Testnet)
default:
return nil, fmt.Errorf("不支持的交易所: %s", exchange.ID)
return nil, fmt.Errorf("unsupported exchange: %s", exchange.ID)
}
}
// InvalidateCache 使缓存失效（当配置变更时调用）
// InvalidateCache Invalidate cache (call when configuration changes)
func (m *OrderSyncManager) InvalidateCache(traderID string) {
m.cacheMutex.Lock()
defer m.cacheMutex.Unlock()