def on_order(self, order: OrderData):
""""""
if order.vt_symbol == self.active_vt_symbol:
if not order.is_active():
self.active_vt_orderid = ""
elif order.vt_symbol == self.passive_vt_symbol:
if not order.is_active():
self.passive_vt_orderid = ""
self.put_variables_event()
def cross_order(self, order: OrderData, tick: TickData):
""""""
contract = self.main_engine.get_contract(order.vt_symbol)
trade_price = 0
# Cross market order immediately after received
if order.type == OrderType.MARKET:
if order.direction == Direction.LONG:
trade_price = tick.ask_price_1 + self.trade_slippage * contract.pricetick
else:
trade_price = tick.bid_price_1 - self.trade_slippage * contract.pricetick
# Cross limit order only if price touched
elif order.type == OrderType.LIMIT:
if order.direction == Direction.LONG:
if order.price >= tick.ask_price_1:
trade_price = tick.ask_price_1
else:
if order.price <= tick.bid_price_1:
trade_price = tick.bid_price_1
# Cross limit order only if price broken
elif order.type == OrderType.STOP:
if order.direction == Direction.LONG:
if tick.ask_price_1 >= order.price:
trade_price = tick.ask_price_1 + self.trade_slippage * contract.pricetick
else:
if tick.bid_price_1 <= order.price:
trade_price = tick.bid_price_1 - self.trade_slippage * contract.pricetick
if trade_price:
order.status = Status.ALLTRADED
order.traded = order.volume
self.put_event(EVENT_ORDER, order)
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=order.orderid,
direction=order.direction,
offset=order.offset,
price=trade_price,
volume=order.volume,
datetime=datetime.now(LOCAL_TZ),
gateway_name=order.gateway_name
)
self.put_event(EVENT_TRADE, trade)
self.update_position(trade, contract)
def on_query_order(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询活动委托"):
return
for d in data["data"]["orders"]:
timestamp = d["created_at"]
dt = generate_datetime(timestamp / 1000)
if d["client_order_id"]:
orderid = d["client_order_id"]
else:
orderid = d["order_id"]
order = OrderData(
orderid=orderid,
symbol=d["contract_code"],
exchange=Exchange.HUOBI,
price=d["price"],
volume=d["volume"],
type=ORDERTYPE_HUOBIO2VT[d["order_price_type"]],
direction=DIRECTION_HUOBIO2VT[d["direction"]],
offset=OFFSET_HUOBIO2VT[d["offset"]],
traded=d["trade_volume"],
status=STATUS_HUOBIO2VT[d["status"]],
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("活动委托信息查询成功")
def on_query_orders(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询委托"):
return
for d in data["data"]:
direction, order_type = ORDERTYPE_HUOBI2VT[d["type"]]
dt = generate_datetime(d["created-at"] / 1000)
order = OrderData(
orderid=d["client-order-id"],
symbol=d["symbol"],
exchange=Exchange.HUOBI,
price=float(d["price"]),
volume=float(d["amount"]),
type=order_type,
direction=direction,
traded=float(d["filled-amount"]),
status=STATUS_HUOBI2VT.get(d["state"], None),
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("委托信息查询成功")
def send_order(self, strategy: StrategyTemplate, vt_symbol: str,
direction: Direction, offset: Offset, price: float,
volume: float, lock: bool) -> List[str]:
""""""
price = round_to(price, self.priceticks[vt_symbol])
symbol, exchange = extract_vt_symbol(vt_symbol)
self.limit_order_count += 1
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=str(self.limit_order_count),
direction=direction,
offset=offset,
price=price,
volume=volume,
status=Status.SUBMITTING,
datetime=self.datetime,
gateway_name=self.gateway_name,
)
self.active_limit_orders[order.vt_orderid] = order
self.limit_orders[order.vt_orderid] = order
return [order.vt_orderid]
def on_order(self, order: OrderData):
""""""
self.traded = order.traded
self.order_status = order.status
if not order.is_active():
self.stop()
self.put_variables_event()
def update_order(self, order: OrderData):
"""
Callback when order status is updated.
"""
if not order.is_active() and order.vt_orderid in self.vt_orderids:
self.vt_orderids.remove(order.vt_orderid)
self.on_order(order)
def update_order(self, order: OrderData) -> None:
"""
Callback of new order data update.
"""
self.orders[order.vt_orderid] = order
if not order.is_active() and order.vt_orderid in self.active_orderids:
self.active_orderids.remove(order.vt_orderid)
def on_order(self, order: OrderData):
""""""
msg = f"委托号：{order.vt_orderid}，委托状态：{order.status.value}"
self.write_log(msg)
if not order.is_active():
self.vt_orderid = ""
self.put_variables_event()
def update_order(self, order: OrderData):
""""""
if self.active:
if order.is_active():
self.active_orders[order.vt_orderid] = order
elif order.vt_orderid in self.active_orders:
self.active_orders.pop(order.vt_orderid)
self.on_order(order)
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
vt_orderid = order.vt_orderid
if not order.is_active():
if vt_orderid in self.active_orderids:
self.active_orderids.remove(vt_orderid)
if vt_orderid in self.cancel_orderids:
self.cancel_orderids.remove(vt_orderid)
def check_order_valid(self, order: OrderData, contract: ContractData) -> Optional[PositionData]:
""""""
# Reject unsupported order type
if order.type in {OrderType.FAK, OrderType.FOK, OrderType.RFQ}:
order.status = Status.REJECTED
elif order.type == OrderType.STOP and not contract.stop_supported:
order.status = Status.REJECTED
if order.status == Status.REJECTED:
self.write_log(f"委托被拒单，不支持的委托类型{order.type.value}")
# Reject close order if no more available position
if contract.net_position or order.offset == Offset.OPEN:
return
if order.direction == Direction.LONG:
short_position = self.get_position(order.vt_symbol, Direction.SHORT)
available = short_position.volume - short_position.frozen
if order.volume > available:
order.status = Status.REJECTED
else:
short_position.frozen += order.volume
return short_position
else:
long_position = self.get_position(order.vt_symbol, Direction.LONG)
available = long_position.volume - long_position.frozen
if order.volume > available:
order.status = Status.REJECTED
else:
long_position.frozen += order.volume
return long_position
if order.status == Status.REJECTED:
self.write_log(f"委托被拒单，可平仓位不足")
def on_order(self, data: dict) -> None:
""""""
dt = generate_datetime(data["created_at"] / 1000)
if data["client_order_id"]:
orderid = data["client_order_id"]
else:
orderid = data["order_id"]
order = OrderData(
symbol=data["contract_code"],
exchange=Exchange.HUOBI,
orderid=orderid,
type=ORDERTYPE_HUOBIO2VT[data["order_price_type"]],
direction=DIRECTION_HUOBIO2VT[data["direction"]],
offset=OFFSET_HUOBIO2VT[data["offset"]],
price=data["price"],
volume=data["volume"],
traded=data["trade_volume"],
status=STATUS_HUOBIO2VT[data["status"]],
datetime=dt,
gateway_name=self.gateway_name
)
self.gateway.on_order(order)
# Push trade event
trades = data["trade"]
if not trades:
return
for d in trades:
dt = generate_datetime(d["created_at"] / 1000)
trade = TradeData(
symbol=order.symbol,
exchange=Exchange.HUOBI,
orderid=order.orderid,
tradeid=str(d["id"]),
direction=order.direction,
offset=order.offset,
price=d["trade_price"],
volume=d["trade_volume"],
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def send_limit_order(self, direction: Direction, offset: Offset,
price: float, volume: float):
""""""
self.limit_order_count += 1
order = OrderData(symbol=self.symbol,
exchange=self.exchange,
orderid=str(self.limit_order_count),
direction=direction,
offset=offset,
price=price,
volume=volume,
status=Status.SUBMITTING,
gateway_name=self.gateway_name,
datetime=self.datetime)
self.active_limit_orders[order.vt_orderid] = order
self.limit_orders[order.vt_orderid] = order
return order.vt_orderid
def cross_stop_order(self):
"""
Cross stop order with last bar/tick data.
"""
if self.mode == BacktestingMode.BAR:
long_cross_price = self.bar.high_price
short_cross_price = self.bar.low_price
long_best_price = self.bar.open_price
short_best_price = self.bar.open_price
else:
long_cross_price = self.tick.last_price
short_cross_price = self.tick.last_price
long_best_price = long_cross_price
short_best_price = short_cross_price
for stop_order in list(self.active_stop_orders.values()):
# Check whether stop order can be triggered.
long_cross = (stop_order.direction == Direction.LONG
and stop_order.price <= long_cross_price)
short_cross = (stop_order.direction == Direction.SHORT
and stop_order.price >= short_cross_price)
if not long_cross and not short_cross:
continue
# Create order data.
self.limit_order_count += 1
order = OrderData(symbol=self.symbol,
exchange=self.exchange,
orderid=str(self.limit_order_count),
direction=stop_order.direction,
offset=stop_order.offset,
price=stop_order.price,
volume=stop_order.volume,
traded=stop_order.volume,
status=Status.ALLTRADED,
gateway_name=self.gateway_name,
datetime=self.datetime)
self.limit_orders[order.vt_orderid] = order
# Create trade data.
if long_cross:
trade_price = max(stop_order.price, long_best_price)
pos_change = order.volume
else:
trade_price = min(stop_order.price, short_best_price)
pos_change = -order.volume
self.trade_count += 1
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=str(self.trade_count),
direction=order.direction,
offset=order.offset,
price=trade_price,
volume=order.volume,
datetime=self.datetime,
gateway_name=self.gateway_name,
)
self.trades[trade.vt_tradeid] = trade
# Update stop order.
stop_order.vt_orderids.append(order.vt_orderid)
stop_order.status = StopOrderStatus.TRIGGERED
if stop_order.stop_orderid in self.active_stop_orders:
self.active_stop_orders.pop(stop_order.stop_orderid)
# Push update to strategy.
self.strategy.on_stop_order(stop_order)
self.strategy.on_order(order)
self.strategy.pos += pos_change
self.strategy.on_trade(trade)
def on_order(self, order: OrderData):
""""""
if not order.is_active():
self.vt_orderid = ""
self.put_variables_event()
