def on_query_order(self, data, request):
""""""
for d in data:
date, time = d['created_at'].split('T')
if d['status'] == 'open':
if not float(d['filled_size']):
status = Status.NOTTRADED
else:
status = Status.PARTTRADED
else:
if d['size'] == d['filled_size']:
status = Status.ALLTRADED
else:
status = Status.CANCELLED
order = OrderData(
symbol=d['product_id'],
gateway_name=self.gateway_name,
exchange=Exchange.COINBASE,
orderid=d['id'],
direction=DIRECTION_COINBASE2VT[d['side']],
price=float(d['price']),
volume=float(d['size']),
traded=float(d['filled_size']),
time=time.replace('Z', ""),
status=status,
)
self.gateway.on_order(copy(order))
sys_order_map[order.orderid] = order
self.gateway.write_log(
u' information inquiry commissioned successfully ')
def send_order(
self,
strategy: StrategyTemplate,
vt_symbol: str,
direction: Direction,
offset: Offset,
price: float,
volume: float,
lock: bool,
net: 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 onRtnOrder(self, data: dict):
"""
Callback of order status update.
"""
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, "")
if not exchange:
self.order_data.append(data)
return
frontid = data["FrontID"]
sessionid = data["SessionID"]
order_ref = data["OrderRef"]
orderid = f"{frontid}_{sessionid}_{order_ref}"
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=orderid,
type=ORDERTYPE_ROHON2VT[data["OrderPriceType"]],
direction=DIRECTION_ROHON2VT[data["Direction"]],
offset=OFFSET_ROHON2VT[data["CombOffsetFlag"]],
price=data["LimitPrice"],
volume=data["VolumeTotalOriginal"],
traded=data["VolumeTraded"],
status=STATUS_ROHON2VT[data["OrderStatus"]],
time=data["InsertTime"],
gateway_name=self.gateway_name
)
self.gateway.on_order(order)
self.sysid_orderid_map[data["OrderSysID"]] = orderid
def on_order(self, d):
""""""
if "ordStatus" not in d:
return
sysid = d["orderID"]
order = self.orders.get(sysid, None)
if not order:
if d["clOrdID"]:
orderid = d["clOrdID"]
else:
orderid = sysid
# time = d["timestamp"][11:19]
order = OrderData(
symbol=d["symbol"],
exchange=Exchange.BITMEX,
type=ORDERTYPE_BITMEX2VT[d["ordType"]],
orderid=orderid,
direction=DIRECTION_BITMEX2VT[d["side"]],
price=d["price"],
volume=d["orderQty"],
time=d["timestamp"][11:19],
gateway_name=self.gateway_name,
)
self.orders[sysid] = order
order.traded = d.get("cumQty", order.traded)
order.status = STATUS_BITMEX2VT.get(d["ordStatus"], order.status)
self.gateway.on_order(copy(order))
def OnErrRtnOrderInsert(self, data: dict, error: dict, reqid: int) -> None:
""""""
order_ref = data["OrderRef"]
order_id = f"{self.frontid}_{self.sessionid}_{order_ref}"
dt = datetime.now()
dt = CHINA_TZ.localize(dt)
order = OrderData(
symbol=data["SecurityID"],
exchange=EXCHANGE_TORA2VT[bytes.decode(data["ExchangeID"])],
orderid=order_id,
type=ORDERTYPE_TORA2VT[bytes.decode(data["OrderPriceType"])],
direction=DIRECTION_TORA2VT[bytes.decode(data["Direction"])],
offset=OFFSET_TORA2VT[data["CombOffsetFlag"]],
price=data["LimitPrice"],
volume=data["VolumeTotalOriginal"],
traded=0,
status=Status.REJECTED,
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
self.gateway.write_log(
f"拒单({order_id}):"
f"错误码:{error['ErrorID']}, 错误消息:{error['ErrorMsg']}")
def query_orders_today(self) -> None:
"""查询当日订单"""
if not self.login_status:
return
status, data = self.orders_today()
if status:
if not isinstance(data, str):
for d in data:
direction, offset = DIRECTION_STOCK_PT2VT[d["order_type"]]
order = OrderData(
symbol=d["code"],
exchange=EXCHANGE_PT2VT[d["exchange"]],
orderid=d["order_id"],
type=ORDERTYPE_PT2VT[d["price_type"]],
direction=direction,
offset=offset,
price=d["order_price"],
volume=d["volume"],
traded=d["traded"],
status=STATUS_PT2VT[d["status"]],
datetime=datetime.strptime(
d["order_date"] + d["order_time"],
"%Y%m%d%H:%M:%S"),
gateway_name=self.gateway_name,
)
self.on_order_event(order)
else:
error = dict()
error["error_id"] = "pt_api"
error["error_msg"] = data
self.on_error(error)
def on_order(self, d):
""""""
order = OrderData(
symbol=d["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEX2VT[d["type"]],
orderid=d["client_oid"],
direction=DIRECTION_OKEX2VT[d["side"]],
price=float(d["price"]),
volume=float(d["size"]),
traded=float(d["filled_size"]),
time=d["timestamp"][11:19],
status=STATUS_OKEX2VT[d["status"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
trade_volume = d.get("last_fill_qty", 0)
if not trade_volume or float(trade_volume) == 0:
return
self.trade_count += 1
tradeid = f"{self.connect_time}{self.trade_count}"
trade = TradeData(symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=tradeid,
direction=order.direction,
price=float(d["last_fill_px"]),
volume=float(trade_volume),
time=d["last_fill_time"][11:19],
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def on_order(self, data):
""""""
orderid = str(data[2])
if data[7] > 0:
direction = Direction.LONG
else:
direction = Direction.SHORT
order_status = str(data[13].split("@")[0]).replace(" ", "")
if order_status == "CANCELED":
order_time = self.generate_date_time(data[5])
else:
order_time = self.generate_date_time(data[4])
order = OrderData(
symbol=str(data[3].replace("t", "")),
exchange=Exchange.BITFINEX,
orderid=orderid,
status=STATUS_BITFINEX2VT[order_status],
direction=direction,
price=float(data[16]),
volume=abs(data[7]),
traded=abs(data[7]) - abs(data[6]),
time=order_time,
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
def openOrder( # pylint: disable=invalid-name
self,
orderId: OrderId,
ib_contract: Contract,
ib_order: Order,
orderState: OrderState,
):
"""
Callback when opening new order.
"""
super().openOrder(orderId, ib_contract, ib_order, orderState)
orderid = str(orderId)
order = OrderData(
symbol=generate_symbol(ib_contract),
exchange=EXCHANGE_IB2VT.get(ib_contract.exchange, Exchange.SMART),
type=ORDERTYPE_IB2VT[ib_order.orderType],
orderid=orderid,
direction=DIRECTION_IB2VT[ib_order.action],
volume=ib_order.totalQuantity,
gateway_name=self.gateway_name,
)
if order.type == OrderType.LIMIT:
order.price = ib_order.lmtPrice
elif order.type == OrderType.STOP:
order.price = ib_order.auxPrice
self.orders[orderid] = order
self.gateway.on_order(copy(order))
def onRtnOrder(self, data: dict):
"""
Callback of order status update.
"""
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, "")
if not exchange:
self.order_data.append(data)
return
orderid = data["OrderRef"]
self.order_ref = max(self.order_ref, int(orderid))
timestamp = f"{data['InsertDate']} {data['InsertTime']}"
dt = datetime.strptime(timestamp, "%Y%m%d %H:%M:%S")
dt = CHINA_TZ.localize(dt)
order = OrderData(symbol=symbol,
exchange=exchange,
orderid=orderid,
type=ORDERTYPE_SGIT2VT[data["OrderPriceType"]],
direction=DIRECTION_SGIT2VT[data["Direction"]],
offset=OFFSET_SGIT2VT[data["CombOffsetFlag"]],
price=data["LimitPrice"],
volume=data["VolumeTotalOriginal"],
traded=data["VolumeTraded"],
status=STATUS_SGIT2VT[data["OrderStatus"]],
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
def on_order_error(self, d):
""""""
if d[-2] != "ERROR":
return
data = d[4]
error_info = d[-1]
# Filter cancel of non-existing order
orderid = str(data[2])
if orderid == "None":
self.gateway.write_log("撤单失败，委托不存在")
return
if data[6] > 0:
direction = Direction.LONG
else:
direction = Direction.SHORT
order = OrderData(
symbol=str(data[3].replace("t", "")),
exchange=Exchange.BITFINEX,
orderid=orderid,
status=Status.REJECTED,
direction=direction,
price=float(data[16]),
volume=abs(data[6]),
time=self.generate_date_time(d[0]),
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
self.gateway.write_log(f"委托拒单：{error_info}")
def onRspOrderInsert(self, data: dict, error: dict, reqid: int,
last: bool):
""""""
if error["ErrorID"] == 0:
return
self.gateway.write_error("交易委托失败", error)
orderid = data["OrderRef"]
self.order_ref = max(self.order_ref, int(orderid))
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, None)
if not exchange:
return
order = OrderData(symbol=symbol,
exchange=exchange,
orderid=orderid,
direction=DIRECTION_SGIT2VT[data["Direction"]],
offset=OFFSET_SGIT2VT.get(data["CombOffsetFlag"],
Offset.NONE),
price=data["LimitPrice"],
volume=data["VolumeTotalOriginal"],
status=Status.REJECTED,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
def on_query_order(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 on_query_order(self, data, request):
"""获取委托订单"""
for d in data:
sys_orderid = d["id"]
local_orderid = self.order_manager.get_local_orderid(sys_orderid)
direction = DIRECTION_BITSTAMP2VT[d["type"]]
name = d["currency_pair"]
symbol = name_symbol_map[name]
order = OrderData(
orderid=local_orderid,
symbol=symbol,
exchange=Exchange.BITSTAMP,
price=float(d["price"]),
volume=float(d["amount"]),
traded=float(0),
direction=direction,
status=Status.NOTTRADED,
time=d["datetime"],
gateway_name=self.gateway_name,
)
self.order_manager.on_order(order)
self.gateway.write_log("委托信息查询成功")
def openOrder( # pylint: disable=invalid-name
self,
orderId: OrderId,
ib_contract: Contract,
ib_order: Order,
orderState: OrderState,
):
"""
Callback when opening new order.
"""
super(IbApi, self).openOrder(
orderId, ib_contract, ib_order, orderState
)
orderid = str(orderId)
order = OrderData(
symbol=ib_contract.conId,
exchange=EXCHANGE_IB2VT.get(
ib_contract.exchange, ib_contract.exchange),
type=ORDERTYPE_IB2VT[ib_order.orderType],
orderid=orderid,
direction=DIRECTION_IB2VT[ib_order.action],
price=ib_order.lmtPrice,
volume=ib_order.totalQuantity,
gateway_name=self.gateway_name,
)
self.orders[orderid] = order
self.gateway.on_order(copy(order))
def onOrderEvent(self, data: dict, error: dict, session: int) -> None:
""""""
if error["error_id"]:
self.gateway.write_error("交易委托失败", error)
symbol = data["ticker"]
if len(symbol) == 8:
direction = DIRECTION_OPTION_XTP2VT[data["side"]]
offset = OFFSET_XTP2VT[data["position_effect"]]
else:
direction, offset = DIRECTION_STOCK_XTP2VT[data["side"]]
order = OrderData(symbol=symbol,
exchange=MARKET_XTP2VT[data["market"]],
orderid=str(data["order_xtp_id"]),
type=ORDERTYPE_XTP2VT[data["price_type"]],
direction=direction,
offset=offset,
price=data["price"],
volume=data["quantity"],
traded=data["qty_traded"],
status=STATUS_XTP2VT[data["order_status"]],
time=data["insert_time"],
gateway_name=self.gateway_name)
self.gateway.on_order(order)
def update_order(self, data: dict) -> None:
"""
Convert TAP order data structure into OrderData event and push it.
"""
self.local_sys_map[data["ClientOrderNo"]] = data["OrderNo"]
self.sys_local_map[data["OrderNo"]] = data["ClientOrderNo"]
self.sys_server_map[data["OrderNo"]] = data["ServerFlag"]
order = OrderData(symbol=data["CommodityNo"] + data["ContractNo"],
exchange=EXCHANGE_TAP2VT.get(data["ExchangeNo"],
None),
orderid=data["ClientOrderNo"],
type=ORDERTYPE_TAP2VT.get(data["OrderType"],
data["OrderType"]),
direction=DIRECTION_TAP2VT[data["OrderSide"]],
price=data["OrderPrice"],
volume=data["OrderQty"],
traded=data["OrderMatchQty"],
status=STATUS_TAP2VT.get(data["OrderState"],
Status.SUBMITTING),
time=data["OrderInsertTime"],
gateway_name=self.gateway_name)
self.gateway.on_order(order)
# Send waiting cancel request to server
if data["ClientOrderNo"] in self.cancel_reqs:
req = self.cancel_reqs.pop(data["ClientOrderNo"])
self.cancel_order(req)
def onRspQryOrder(self, data: dict, error: dict, reqid: int, last: bool):
"""
Callback of order query.
"""
if data["TreatyCode"]:
timestamp = f"{data['OrderDate']} {data['OrderTime']}"
dt = datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S")
dt = dt.replace(tzinfo=CHINA_TZ)
order = OrderData(symbol=data["TreatyCode"],
exchange=EXCHANGE_DA2VT[data["ExchangeCode"]],
orderid=data["LocalNo"],
type=ORDERTYPE_DA2VT[data["PriceType"]],
direction=DIRECTION_DA2VT[data["BuySale"]],
offset=OFFSET_DA2VT[data["AddReduce"]],
price=float(data["OrderPrice"]),
volume=int(data["OrderNumber"]),
traded=int(data["FilledNumber"]),
status=STATUS_DA2VT[data["OrderState"]],
datetime=dt,
gateway_name=self.gateway_name)
self.local_no = max(self.local_no, int(data["LocalNo"]))
self.orders[order.orderid] = order
self.order_info[order.orderid] = (data["OrderNo"],
data["SystemNo"])
self.gateway.on_order(copy(order))
if last:
self.gateway.write_log("委托信息查询成功")
def process_order(self, data):
""""""
for i in data:
try:
symbol = contract2symbol(i.contract)
symbol, exchange = self.get_vt_symbol_exchange(symbol)
local_id = self.get_new_local_id()
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=local_id,
direction=DIRECTION_TIGER2VT[i.action],
price=i.limit_price if i.limit_price else 0.0,
volume=i.quantity,
traded=i.filled,
status=STATUS_TIGER2VT[i.status],
time=datetime.fromtimestamp(i.order_time /
1000).strftime("%H:%M:%S"),
gateway_name=self.gateway_name,
)
self.ID_TIGER2VT[str(i.id)] = local_id
self.on_order(order)
except:
pass
self.ID_VT2TIGER = {v: k for k, v in self.ID_TIGER2VT.items()}
def onRtnOrder(self, data: dict):
"""
Callback of order status update.
"""
# 更新最大报单编号
self.localid = max(self.localid,
int(data["UserOrderLocalID"])) # 检查并增加本地报单编号
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, "")
if not exchange:
self.order_data.append(data)
return
orderid = data["UserOrderLocalID"]
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=orderid,
direction=DIRECTION_FEMAS2VT[data["Direction"]],
offset=OFFSET_FEMAS2VT[data["OffsetFlag"]],
price=data["LimitPrice"],
volume=data["Volume"],
traded=data["VolumeTraded"],
status=STATUS_FEMAS2VT[data["OrderStatus"]],
time=data["InsertTime"],
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.sysid_orderid_map[data["OrderSysID"]] = orderid
def on_query_history_order(self, data, request):
""""""
if self.check_error(data, "查询历史委托"):
return
for d in data["data"]["orders"]:
timestamp = d["create_date"]
dt = datetime.fromtimestamp(timestamp / 1000)
time = dt.strftime("%H:%M:%S")
orderid = d["order_id"]
order = OrderData(
orderid=orderid,
symbol=d["contract_code"],
exchange=Exchange.HUOBI,
price=d["price"],
volume=d["volume"],
type=ORDERTYPE_HBDM2VT[d["order_price_type"]],
direction=DIRECTION_HBDM2VT[d["direction"]],
offset=OFFSET_HBDM2VT[d["offset"]],
traded=d["trade_volume"],
status=STATUS_HBDM2VT[d["status"]],
time=time,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log(f"{request.extra}历史委托信息查询成功")
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 onRtnOrder(self, data: dict):
"""
Callback of order status update.
"""
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, "")
if not exchange:
self.order_data.append(data)
return
frontid = data["FrontID"]
sessionid = data["SessionID"]
order_ref = data["OrderRef"]
orderid = f"{frontid}_{sessionid}_{order_ref}"
timestamp = f"{data['InsertDate']} {data['InsertTime']}"
dt = datetime.strptime(timestamp, "%Y%m%d %H:%M:%S")
dt = dt.replace(tzinfo=CHINA_TZ)
order = OrderData(symbol=symbol,
exchange=exchange,
orderid=orderid,
type=ORDERTYPE_SOPT2VT[data["OrderPriceType"]],
direction=DIRECTION_SOPT2VT[data["Direction"]],
offset=OFFSET_SOPT2VT[data["CombOffsetFlag"]],
price=data["LimitPrice"],
volume=data["VolumeTotalOriginal"],
traded=data["VolumeTraded"],
status=STATUS_SOPT2VT[data["OrderStatus"]],
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
self.sysid_orderid_map[data["OrderSysID"]] = orderid
def on_query_order(self, data: List[Dict[str, str]]) -> None:
""""""
if not data:
self.gateway.write_log("委托信息查询成功")
self.query_trade()
return
for d in data:
batch_no = d["batch_no"]
self.batch_no = max(self.batch_no, int(batch_no))
self.batch_entrust_id[batch_no] = d["entrust_no"]
self.entrust_batch_id[d["entrust_no"]] = batch_no
order = OrderData(
symbol=d["option_code"],
exchange=EXCHANGE_HSOPTION2VT[d["exchange_type"]],
direction=DIRECTION_HSOPTION2VT[d["entrust_bs"]],
status=STATUS_HSOPTION2VT.get(d["entrust_status"],
Status.SUBMITTING),
orderid=batch_no,
offset=OFFSET_HSOPTION2VT[d["entrust_oc"]],
volume=int(float(d["entrust_amount"])),
traded=int(float(d["business_amount"])),
price=float(d["opt_entrust_price"]),
datetime=generate_datetime(d["entrust_time"]),
gateway_name=self.gateway_name)
self.gateway.on_order(order)
self.orders[batch_no] = order
self.gateway.write_log("委托信息查询成功")
self.query_trade()
def process_order(self, data):
""""""
for i in data:
symbol, exchange = convert_symbol_tiger2vt(str(i.contract))
local_id = self.get_new_local_id()
dt = datetime.fromtimestamp(i.order_time / 1000)
dt = CHINA_TZ.localize(dt)
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=local_id,
direction=Direction.NET,
price=i.limit_price if i.limit_price else 0.0,
volume=i.quantity,
traded=i.filled,
status=STATUS_TIGER2VT[i.status],
datetime=dt,
gateway_name=self.gateway_name,
)
self.ID_TIGER2VT[str(i.order_id)] = local_id
self.on_order(order)
self.ID_VT2TIGER = {v: k for k, v in self.ID_TIGER2VT.items()}
def onRspQryOrder(self, data: dict, error: dict, reqid: int, last: bool):
"""
Callback of order query.
"""
if data["TreatyCode"]:
order = OrderData(
symbol=data["TreatyCode"],
exchange=EXCHANGE_DA2VT[data["ExchangeCode"]],
orderid=data["LocalNo"],
type=ORDERTYPE_DA2VT[data["PriceType"]],
direction=DIRECTION_DA2VT[data["BuySale"]],
offset=OFFSET_DA2VT[data["AddReduce"]],
price=float(data["OrderPrice"]),
volume=int(data["OrderNumber"]),
traded=int(data["FilledNumber"]),
status=STATUS_DA2VT[data["OrderState"]],
time=data["OrderTime"],
gateway_name=self.gateway_name
)
self.local_no = max(self.local_no, int(data["LocalNo"]))
self.orders[order.orderid] = order
self.order_info[order.orderid] = (data["OrderNo"], data["SystemNo"])
self.gateway.on_order(copy(order))
if last:
self.gateway.write_log(" information inquiry commissioned successfully ")
def on_query_order(self, data, request):
""""""
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_HUOBIF2VT[d["order_price_type"]],
direction=DIRECTION_HUOBIF2VT[d["direction"]],
offset=OFFSET_HUOBIF2VT[d["offset"]],
traded=d["trade_volume"],
status=STATUS_HUOBIF2VT[d["status"]],
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log(f"{request.extra}活动委托信息查询成功")
def onOrderReport(self, head: dict, data: dict) -> None:
""""""
sysid = data["clOrdId"]
orderid = data["origClOrdId"]
self.sys_local_ids[sysid] = orderid
self.local_sys_ids[orderid] = sysid
timestamp = f"{data['ordDate']} {data['ordCnfmTime']}"
dt = datetime.strptime(timestamp, "%Y%m%d %H%M%S%f")
status = STATUS_OES2VT[data["ordStatus"]]
order = self.orders.get(orderid, None)
if not order:
symbol = data["securityId"]
direction = DIRECTION_OES2VT.get(data["bsType"], None)
offset = Offset.NONE
if len(symbol) > 6:
(direction, offset) = OPTION_DIRECTION_OES2VT[data["bsType"]]
order = OrderData(orderid=orderid,
symbol=symbol,
exchange=EXCHANGE_OES2VT[data["mktId"]],
type=ORDERTYPE_OES2VT[data["ordType"]],
direction=direction,
offset=offset,
price=data["ordPrice"] / 10000,
volume=data["ordQty"],
status=status,
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
else:
order.status = status
order.datetime = dt
self.gateway.on_order(order)
def on_query_order(self, data, request):
""""""
if self.check_error(data, "查询委托"):
return
for d in data["data"]:
sys_orderid = d["id"]
local_orderid = self.order_manager.get_local_orderid(sys_orderid)
direction, order_type = ORDERTYPE_HUOBI2VT[d["type"]]
dt = datetime.fromtimestamp(d["created-at"] / 1000)
time = dt.strftime("%H:%M:%S")
order = OrderData(
orderid=local_orderid,
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),
time=time,
gateway_name=self.gateway_name,
)
self.order_manager.on_order(order)
self.gateway.write_log("委托信息查询成功")
def update_order(self, data: dict) -> None:
""""""
sessionid = data["SessionID"]
order_ref = data["OrderRef"]
orderid = f"{sessionid}_{order_ref}"
order = self.orders.get(orderid, None)
insert_time = generate_time(data["InsertTime"])
timestamp = f"{data['InsertDate']} {insert_time}"
dt = datetime.strptime(timestamp, "%Y%m%d %H:%M:%S")
dt = CHINA_TZ.localize(dt)
if not order:
order = OrderData(symbol=data["InstrumentID"],
exchange=EXCHANGE_UFT2VT[data["ExchangeID"]],
orderid=orderid,
type=ORDERTYPE_UFT2VT[data["OrderCommand"]],
direction=DIRECTION_UFT2VT[data["Direction"]],
offset=OFFSET_UFT2VT[data["OffsetFlag"]],
price=data["OrderPrice"],
volume=data["OrderVolume"],
traded=data["TradeVolume"],
status=STATUS_UFT2VT.get(data["OrderStatus"],
Status.SUBMITTING),
datetime=dt,
gateway_name=self.gateway_name)
self.orders[orderid] = order
else:
order.traded = data["TradeVolume"]
order.status = STATUS_UFT2VT.get(data["OrderStatus"],
Status.SUBMITTING)
self.gateway.on_order(order)
