完善UI操作逻辑

core/sfgrid_strategy.py

@@ -1,10 +1,13 @@
+from peewee import IntegerField
+
+
 from core import strategy_db
 from core.eventbus import MarketDataUpdate, event_bus
-from core.strategy_db import TradeTarget
+from core.strategy_db import OrderTypeBuy, OrderTypeInit, OrderTypeSell, TradeTarget
 from core.util import queryPendingOrder
 
 from xtquant import xttrader, xtconstant
-from xtquant.xttype import StockAccount, XtOrder, XtOrderResponse, XtTrade
+from xtquant.xttype import StockAccount, XtOrder, XtTrade
 import sfgrid_constants
 import threading
 
@@ -16,8 +19,9 @@ class SFGridStrategy:
         self.xt_trader: xttrader.XtQuantTrader = xt_trader
         self.account:StockAccount = account
         self.enabledTrading(bool(tradeTarget.enabled))  # 修复类型兼容性问题
+        
+        event_bus.publish(MarketDataUpdate, self.tradeTarget)
         self.dataUpdateLock = threading.Lock()
-        print(f'标的{self.tradeTarget.targetName()}交易启动状态 {self.tradeTarget.enabled}')
 
 
     def enabledTrading(self, enabled: bool) -> TradeTarget:
@@ -25,26 +29,11 @@ class SFGridStrategy:
         self.saveProxy()
 
         if enabled:
+            self.refreshPlanPrice()
             print(f"  |- 标的{self.tradeTarget.targetName()}交易启动, 持仓量：{self.tradeTarget.current_position}")
             if self.tradeTarget.status == 0: # 未建仓
-                print(f"  |- 标的{self.tradeTarget.targetName()}初始状态，检查订单")
-                orders = queryPendingOrder(str(self.tradeTarget.stock_code),self.getName(), self.xt_trader,self.account)
-                if len([order for order in orders if order.order_type == xtconstant.STOCK_BUY and order.price == sfgrid_constants.grid_price[1]]) > 0:
-                    # 已存在未交易的多单
-                    order = [order for order in orders if order.order_type == xtconstant.STOCK_BUY and order.price == sfgrid_constants.grid_price[1]][0]
-                    print(f'  |- 已存在未交易的建仓单，不重复下单:{order.order_id}')
-                else:
-                    # 建仓
-                    self.tradeTarget.grid_index = 1  # pyright: ignore[reportAttributeAccessIssue]
-                    self.tradeTarget.current_order_no = self.xt_trader.order_stock_async(
-                        self.account, 
-                        str(self.tradeTarget.stock_code), 
-                        xtconstant.STOCK_BUY, 
-                        sfgrid_constants.grid_volume,
-                        xtconstant.FIX_PRICE,
-                        sfgrid_constants.grid_price[int(self.tradeTarget.grid_index)],  # type: ignore
-                        self.getName(), strategy_db.OrderTypeInit)
-                    print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 建初始仓 买单已发出 InitBuyOrderSeq: {self.tradeTarget.current_order_no} Price: {sfgrid_constants.grid_price[int(self.tradeTarget.grid_index)]} Volume: {sfgrid_constants.grid_volume}\n")  # type: ignore
+                print(f"  |- 标的{self.tradeTarget.targetName()}初始状态, 设置网格序号 1")
+                self.tradeTarget.grid_index = 1  # pyright: ignore[reportAttributeAccessIssue]
             else: # 已建仓
                 # 交易阶段，检查仓位，检查现有订单
                 print(f"  |- 标的{self.tradeTarget.targetName()}已有仓位或非初始状态 无需建初始仓 当前仓位: {self.tradeTarget.current_position} 状态: {self.tradeTarget.status}")
@@ -52,7 +41,9 @@ class SFGridStrategy:
                 if minRequirePosition <= int(self.tradeTarget.current_position):  # type: ignore
                     print(f'  |- 仓位检查: 持仓需求充足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}')
                 else:
-                    print(f'  |- 仓位检查: 持仓需求不足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}')
+                    print(f'  |- 仓位检查: 持仓需求不足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}, 交易启动失败')
+                    self.tradeTarget.enabled = False  # type: ignore
+                    self.saveProxy()
         else:
             print(f"  |- 标的{self.tradeTarget.targetName()}交易监控暂停")
         return self.tradeTarget
@@ -68,61 +59,72 @@ class SFGridStrategy:
         self.tradeTarget.market_price = lastPrice  # type: ignore
         self.saveProxy()
 
-        if not(self.tradeTarget.enabled and self.tradeTarget.status == 1): # 已建仓，常规自动交易中
+        if not self.tradeTarget.enabled: # 未建仓，自动交易暂停
             print(f"|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 未建仓或交易监控暂停，不进行自动交易")
             return
-
+        
         self.dataUpdateLock.acquire()
         print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - LOCKED')
-        try:
-            index =  self.tradeTarget.grid_index
-            price =  -1 if index>=len(sfgrid_constants.grid_price) else sfgrid_constants.grid_price[int(index)]  # pyright: ignore[reportArgumentType]
-            lowPrice = -1 if index+1>=len(sfgrid_constants.grid_price) else sfgrid_constants.grid_price[int(index) + 1]  # pyright: ignore[reportArgumentType]
-            highPrice = sfgrid_constants.grid_price[int(index) - 1]  # pyright: ignore[reportArgumentType]
 
-            if lastPrice <= lowPrice: # 下下方多单
+        try:
+            orderPrice:float = -1
+            orderType = -1
+            index: int =  self.tradeTarget.grid_index  # pyright: ignore[reportAssignmentType]
+            orderRemark= ""
+            
+            gridBasePrice  =  -1 if index>=len(sfgrid_constants.grid_price) or index < 0 else sfgrid_constants.grid_price[int(index)]  # pyright: ignore[reportArgumentType]
+
+            if self.tradeTarget.enabled and self.tradeTarget.status == 0: # 已启用，未建仓，建仓
+                orderPrice =  sfgrid_constants.grid_price[index]
+                orderType = xtconstant.STOCK_BUY
+                orderRemark = OrderTypeInit
+                
+            if self.tradeTarget.enabled and self.tradeTarget.status == 1: # 已启用，已建仓，网格单
+                lowPrice = -1 if index+1>=len(sfgrid_constants.grid_price) else sfgrid_constants.grid_price[int(index) + 1]  # pyright: ignore[reportArgumentType]
+                highPrice = sfgrid_constants.grid_price[index - 1] 
+
+                if lastPrice <= lowPrice: # 下下方多单
+                    orderPrice = lowPrice
+                    orderType = xtconstant.STOCK_BUY
+                    orderRemark = OrderTypeBuy
+                
+                elif lastPrice >= highPrice: # 下上方空单
+                    orderPrice = highPrice
+                    orderType = xtconstant.STOCK_SELL
+                    orderRemark = OrderTypeSell
+                
+            if orderType != -1:
                 orders = queryPendingOrder(str(self.tradeTarget.stock_code), self.getName(), self.xt_trader, self.account)
-                if len([order for order in orders if order.order_type == xtconstant.STOCK_BUY and order.price == lowPrice]) > 0:
+                if len([order for order in orders if order.order_type == orderType and order.price == orderPrice]) > 0:
                     # 已存在未交易的多单
-                    print(f'  |- 已存在未交易的多单，不重复下单')
+                    print(f'  |- 已存在未交易的{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}，不重复下单')
                 else:
-                    print(f'  |- 下网格多单')
+                    print(f'  |- 下网格{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}')
                     self.tradeTarget.current_order_no = self.xt_trader.order_stock_async(
                             self.account, 
                             str(self.tradeTarget.stock_code), 
-                            xtconstant.STOCK_BUY, 
+                            orderType, 
                             sfgrid_constants.grid_volume,
                             xtconstant.FIX_PRICE,
-                            lowPrice,
+                            orderPrice,
                             self.getName(), # strategy_name
-                            strategy_db.OrderTypeBuy # remark  # type: ignore
+                            orderRemark # remark  # type: ignore
                             )
-                    self.tradeTarget.plan_buy_price = float(lowPrice)  # type: ignore
-                    print(f'  |- 下网格多单号 {self.tradeTarget.current_order_no}, 网格基准价 {price}, 下单价 {lowPrice}, 下单量 {sfgrid_constants.grid_volume}')
-            elif lastPrice == highPrice: # 下上方空单
-                orders = queryPendingOrder(str(self.tradeTarget.stock_code), self.getName(), self.xt_trader, self.account)
-                if len([order for order in orders if order.order_type == xtconstant.STOCK_SELL and order.price == highPrice]) > 0:
-                    # 已存在未交易的空单
-                    print(f'  |- 已存在未交易的空单，不重复下单')
-                else:
-                    print(f'  |- 下网格空单')
-                    self.tradeTarget.current_order_no = self.xt_trader.order_stock_async(
-                                self.account, 
-                                str(self.tradeTarget.stock_code), 
-                                xtconstant.STOCK_SELL, 
-                                sfgrid_constants.grid_volume,
-                                xtconstant.FIX_PRICE,
-                                highPrice, 
-                                self.getName(), 
-                                strategy_db.OrderTypeBuy)  # type: ignore
-                    self.tradeTarget.plan_sell_price = float(highPrice)  # type: ignore
-                    print(f'  |- 下网格空单号 {self.tradeTarget.current_order_no}, 网格基准价 {price}, 下单价 {highPrice}, 下单量 {sfgrid_constants.grid_volume}')
+                orderTypeName = ""
+                if orderRemark == OrderTypeBuy:
+                    orderTypeName = "多单"
+                elif orderRemark == OrderTypeSell:
+                    orderTypeName = "空单"
+                elif orderRemark == OrderTypeInit:
+                    orderTypeName = "建仓单"
+                print(f'  |- {orderTypeName}委托, 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice}, 下单价 {orderPrice}, 下单量 {sfgrid_constants.grid_volume}')
         finally:
             print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - release lock')
             self.saveProxy()
             self.dataUpdateLock.release()
             print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - END')
 
+
     def onAsyncOrderResponse(self, order:XtOrder):
         print(f'  |- 委托回调[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{order.order_id}]:START')
         self.dataUpdateLock.acquire()
@@ -153,6 +155,8 @@ class SFGridStrategy:
                 self.tradeTarget.current_position = int(self.tradeTarget.current_position) + trade.traded_volume # 当前持仓数，账户原有持仓不在策略范围内  # type: ignore
                 self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
                 self.tradeTarget.grid_index = 1  # type: ignore
+                self.tradeTarget.plan_buy_price = float(sfgrid_constants.grid_price[2]) # type: ignore
+                self.tradeTarget.plan_sell_price = float(sfgrid_constants.grid_price[0]) # type: ignore
                 self.tradeTarget.status = 1  # type: ignore
                 self.saveProxy()
                 print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 建初始仓订单ID: {self.tradeTarget.current_order_no}已成交 ")
@@ -164,7 +168,6 @@ class SFGridStrategy:
                 self.tradeTarget.current_position = int(self.tradeTarget.current_position) - trade.traded_volume  # type: ignore
                 self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
                 self.tradeTarget.grid_index = int(self.tradeTarget.grid_index) - 1  # type: ignore
-                self.saveProxy()
                 print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 上涨 卖单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {sfgrid_constants.grid_price[int(self.tradeTarget.grid_index)]} Volume: {sfgrid_constants.grid_volume} 手续费: {trade.commission}\n")  # type: ignore
                 print(f'   成交价: {trade.traded_price} 成交量: {trade.traded_volume}')
                 print(f'   当前持仓: {self.tradeTarget.current_position}')
@@ -174,7 +177,6 @@ class SFGridStrategy:
                 self.tradeTarget.current_position = int(self.tradeTarget.current_position) + trade.traded_volume  # type: ignore
                 self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
                 self.tradeTarget.grid_index = int(self.tradeTarget.grid_index) + 1  # type: ignore
-                self.saveProxy()
                 print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 下跌 买单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {trade.traded_price} Volume: {sfgrid_constants.grid_volume} 手续费: {trade.commission}")
                 print(f'   成交价: {trade.traded_price} 成交量: {trade.traded_volume}')
                 print(f'   当前持仓: {self.tradeTarget.current_position}')
@@ -183,10 +185,27 @@ class SFGridStrategy:
                 # 打印订单信息和订单状态
                 print(f'|- 非策略内部订单，或订单状态不满足监控条件 {trade.order_id} {trade.stock_code}-{trade.instrument_name} {trade.commission}')
         finally:
+            self.refreshPlanPrice()
             print(f'  |- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{trade.order_id}]:release lock')
             self.dataUpdateLock.release()
         print(f'  |- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{trade.order_id}]:END')
     
+    def refreshPlanPrice(self):
+        if self.tradeTarget.status == 1:
+            buyIdx: int = self.tradeTarget.grid_index + 1  # pyright: ignore[reportAssignmentType]
+            sellIdx: int = self.tradeTarget.grid_index - 1
+            if self.tradeTarget.grid_index > 0: # 可以下空单
+                self.tradeTarget.plan_sell_price = float(sfgrid_constants.grid_price[sellIdx])  # pyright: ignore[reportAttributeAccessIssue]
+            else:
+                self.tradeTarget.plan_sell_price = -1.0  # type: ignore
+            if self.tradeTarget.grid_index < len(sfgrid_constants.grid_price) - 1:
+                self.tradeTarget.plan_buy_price = float(sfgrid_constants.grid_price[buyIdx])  # pyright: ignore[reportAttributeAccessIssue]
+            else:
+                self.tradeTarget.plan_buy_price = -1.0  # pyright: ignore[reportAttributeAccessIssue]
+        else:
+            self.tradeTarget.plan_buy_price = 10.0  # type: ignore
+            self.tradeTarget.plan_sell_price = -1.0  # type: ignore
+        self.saveProxy()
     
     def getName(self):
         return "SFGRID"