def OnRtnTrade(self, info: CTORATstpTradeField) -> None:
""""""
try:
trade_data = TradeData(
gateway_name=self.gateway.gateway_name,
symbol=info.SecurityID,
exchange=EXCHANGE_TORA2VT[info.ExchangeID],
orderid=info.OrderRef,
tradeid=info.TradeID,
direction=DIRECTION_TORA2VT[info.Direction],
offset=Offset.OPEN,
price=info.Price,
volume=info.Volume,
time=info.TradeTime,
)
self.gateway.on_trade(trade_data)
except KeyError:
return
def on_trade(self, data: dict) -> None:
"""成交更新推送"""
sys_id: str = data["order_id"]
local_id: str = self.sys_local_map[sys_id]
trade: TradeData = TradeData(
symbol=data["instrument_name"],
exchange=Exchange.DERIBIT,
orderid=local_id,
tradeid=data["trade_id"],
direction=DIRECTION_DERIBIT2VT[data["direction"]],
price=data["price"],
volume=data["amount"],
datetime=generate_datetime(data["timestamp"]),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_trade(self, data: list, orderid):
""""""
sys_id = data["order_id"]
local_id = self.sys_local_map[sys_id]
trade = TradeData(
symbol=data["instrument_name"],
exchange=Exchange.DERIBIT,
orderid=local_id,
tradeid=data["trade_id"],
direction=DIRECTION_DERIBIT2VT[data["direction"]],
price=float(data["price"]),
volume=float(data["amount"]),
time=str(datetime.fromtimestamp(data["timestamp"] / 1000)),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order(self, data: dict):
""""""
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_HUOBIF2VT[data["order_price_type"]],
direction=DIRECTION_HUOBIF2VT[data["direction"]],
offset=OFFSET_HUOBIF2VT[data["offset"]],
price=data["price"],
volume=data["volume"],
traded=data["trade_volume"],
status=STATUS_HUOBIF2VT[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 on_market_trade(self, packet):
""""""
channel = packet["channel"]
data = packet["data"]
tick = self.ticks[channel]
tick.last_price = data["price"]
tick.last_volume = data["amount"]
dt = datetime.fromtimestamp(int(data["timestamp"]))
tick.datetime = dt.replace(tzinfo=UTC_TZ)
self.gateway.on_tick(copy(tick))
# Order status check
buy_orderid = str(data["buy_order_id"])
sell_orderid = str(data["sell_order_id"])
for sys_orderid in [buy_orderid, sell_orderid]:
order = self.order_manager.get_order_with_sys_orderid(
sys_orderid)
if order:
order.traded += data["amount"]
if order.traded < order.volume:
order.status = Status.PARTTRADED
else:
order.status = Status.ALLTRADED
self.order_manager.on_order(copy(order))
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=data["id"],
direction=order.direction,
price=data["price"],
volume=data["amount"],
datetime=tick.datetime,
gateway_name=self.gateway_name
)
self.gateway.on_trade(trade)
def on_order(self, packet: dict):
""""""
dt = datetime.fromtimestamp(packet["O"] / 1000)
time = dt.strftime("%Y-%m-%d %H:%M:%S")
if packet["C"] == "null":
orderid = packet["c"]
else:
orderid = packet["C"]
order = OrderData(symbol=packet["s"],
exchange=Exchange.TradeAgent,
orderid=orderid,
type=ORDERTYPE_TradeAgent2VT[packet["o"]],
direction=DIRECTION_TradeAgent2VT[packet["S"]],
price=float(packet["p"]),
volume=float(packet["q"]),
traded=float(packet["z"]),
status=STATUS_TradeAgent2VT[packet["X"]],
time=time,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
# Push trade event
trade_volume = float(packet["l"])
if not trade_volume:
return
trade_dt = datetime.fromtimestamp(packet["T"] / 1000)
trade_time = trade_dt.strftime("%Y-%m-%d %H:%M:%S")
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=packet["t"],
direction=order.direction,
price=float(packet["L"]),
volume=trade_volume,
time=trade_time,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order(self, packet: dict) -> None:
""""""
ord_data = packet["o"]
key = (ord_data["o"], ord_data["f"])
order_type = ORDERTYPE_BINANCES2VT.get(key, None)
if not order_type:
return
order = OrderData(
symbol=ord_data["s"],
exchange=Exchange.BINANCE,
orderid=str(ord_data["c"]),
type=order_type,
direction=DIRECTION_BINANCES2VT[ord_data["S"]],
price=float(ord_data["p"]),
volume=float(ord_data["q"]),
traded=float(ord_data["z"]),
status=STATUS_BINANCES2VT[ord_data["X"]],
datetime=generate_datetime(packet["E"]),
gateway_name=self.gateway_name,
offset=OFFSET_BINANCES2VT[ord_data['R']]
)
self.gateway.on_order(order)
# Push trade event
trade_volume = float(ord_data["l"])
if not trade_volume:
return
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=ord_data["t"],
direction=order.direction,
price=float(ord_data["L"]),
volume=trade_volume,
datetime=generate_datetime(ord_data["T"]),
gateway_name=self.gateway_name,
offset=order.offset
)
self.gateway.on_trade(trade)
def on_order_match(self, packet: dict):
""""""
if packet['maker_order_id'] in sys_order_map:
order = sys_order_map[packet['maker_order_id']]
else:
order = sys_order_map[packet['taker_order_id']]
trade = TradeData(
symbol=packet['product_id'],
exchange=Exchange.COINBASE,
orderid=order.orderid,
tradeid=packet['trade_id'],
direction=DIRECTION_COINBASE2VT[packet['side']],
price=float(packet['price']),
volume=float(packet['size']),
time=packet['time'],
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order_match(self, packet: dict):
""""""
if packet["maker_order_id"] in sys_order_map:
order = sys_order_map[packet["maker_order_id"]]
else:
order = sys_order_map[packet["taker_order_id"]]
trade = TradeData(
symbol=packet["product_id"],
exchange=Exchange.COINBASE,
orderid=order.orderid,
tradeid=packet["trade_id"],
direction=DIRECTION_COINBASE2VT[packet["side"]],
price=float(packet["price"]),
volume=float(packet["size"]),
datetime=generate_datetime(packet["time"]),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order(self, data):
""""""
# Update order
d = data["order"]
sys_orderid = d["id"]
local_orderid = d["client_order_id"]
LOCAL_SYS_MAP[local_orderid] = sys_orderid
direction = DIRECTION_ALPACA2VT[d["side"]]
order_type = ORDERTYPE_ALPACA2VT[d["type"]]
order = OrderData(
orderid=local_orderid,
symbol=d["symbol"],
exchange=Exchange.SMART,
price=float(d["limit_price"]),
volume=float(d["qty"]),
type=order_type,
direction=direction,
traded=float(d["filled_qty"]),
status=STATUS_ALPACA2VT.get(d["status"], Status.SUBMITTING),
time=d["created_at"],
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
# Update Trade
event = data.get("event", "")
if event != "fill":
return
self.trade_count += 1
trade = TradeData(symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=str(self.trade_count),
direction=order.direction,
price=float(data["price"]),
volume=int(data["qty"]),
time=data["timestamp"],
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def on_order_change(self, tiger_account: str, data: list):
""""""
data = dict(data)
symbol, exchange = convert_symbol_tiger2vt(data["origin_symbol"])
status = STATUS_TIGER2VT[data["status"]]
dt = datetime.fromtimestamp(data["order_time"] / 1000)
dt = dt.replace(tzinfo=CHINA_TZ)
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=self.ID_TIGER2VT.get(str(data["order_id"]),
self.get_new_local_id()),
direction=Direction.NET,
price=data.get("limit_price", 0),
volume=data["quantity"],
traded=data["filled"],
status=status,
datetime=dt,
gateway_name=self.gateway_name,
)
self.ID_TIGER2VT[str(data["order_id"])] = order.orderid
self.on_order(order)
if status == Status.ALLTRADED:
dt = datetime.fromtimestamp(data["trade_time"] / 1000)
dt = dt.replace(tzinfo=CHINA_TZ)
self.tradeid += 1
trade = TradeData(
symbol=symbol,
exchange=exchange,
direction=Direction.NET,
tradeid=self.tradeid,
orderid=self.ID_TIGER2VT[str(data["order_id"])],
price=data["avg_fill_price"],
volume=data["filled"],
datetime=dt,
gateway_name=self.gateway_name,
)
self.on_trade(trade)
def on_order_filled(self, data: dict, request: "Request"):
order_id = data.get('clientOrderID', None)
if order_id is None:
order_id = data['orderID']
order: OrderData = self.gateway.orders[order_id]
# # new API:
# price = 0.0
# if 'tradeOpened' in data:
# price += float(data['tradeOpened']['price'])
# if 'tradeReduced' in data:
# price += float(data['tradeReduced']['price'])
# if 'tradeClosed' in data:
# price += sum([float(i['price']) for i in data['tradeClosed']])
# note: 'price' record is Deprecated
# but since this is faster and easier, we use this record.
price = float(data['price'])
# for Oanda, one order fill is a single trade.
trade = TradeData(
gateway_name=self.gateway_name,
symbol=order.symbol,
exchange=Exchange.OANDA,
orderid=order_id,
tradeid=order_id,
direction=order.direction,
offset=Offset.NONE,
price=price,
volume=order.volume,
time=parse_time(data['time']),
)
self.gateway.on_trade(trade)
# this message indicate that this order is full filled.
# ps: oanda's order has only two state: NOTTRADED, ALLTRADED. It it my settings error?
order.traded = order.volume
order.status = Status.ALLTRADED
# order.time = trade.time
order.time = parse_time(data['time'])
self.gateway.on_order(order)
def on_trade(self, packet: dict):
""""""
for d in packet["data"]:
order_id = d["order_link_id"]
if not order_id:
order_id = d["order_id"]
trade = TradeData(
symbol=d["symbol"],
exchange=Exchange.BYBIT,
orderid=order_id,
tradeid=d["exec_id"],
direction=DIRECTION_BYBIT2VT[d["side"]],
price=float(d["price"]),
volume=d["exec_qty"],
time=d["trade_time"],
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order(self, packet: dict) -> None:
""""""
dt = datetime.fromtimestamp(packet["E"] / 1000)
time = dt.strftime("%Y-%m-%d %H:%M:%S")
ord_data = packet["o"]
order = OrderData(symbol=ord_data["s"],
exchange=Exchange.BINANCE,
orderid=str(ord_data["c"]),
type=ORDERTYPE_BINANCEF2VT[ord_data["o"]],
direction=DIRECTION_BINANCEF2VT[ord_data["S"]],
price=float(ord_data["p"]),
volume=float(ord_data["q"]),
traded=float(ord_data["z"]),
status=STATUS_BINANCEF2VT[ord_data["X"]],
time=time,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
# Push trade event
trade_volume = float(ord_data["l"])
if not trade_volume:
return
trade_dt = datetime.fromtimestamp(ord_data["T"] / 1000)
trade_time = trade_dt.strftime("%Y-%m-%d %H:%M:%S")
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=ord_data["t"],
direction=order.direction,
price=float(ord_data["L"]),
volume=trade_volume,
time=trade_time,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def execDetails(self, reqId: int, contract: Contract,
execution: Execution): # pylint: disable=invalid-name
"""
Callback of trade data update.
"""
super().execDetails(reqId, contract, execution)
# today_date = datetime.now().strftime("%Y%m%d")
trade = TradeData(
symbol=contract.conId,
exchange=EXCHANGE_IB2VT.get(contract.exchange, contract.exchange),
orderid=str(execution.orderId),
tradeid=str(execution.execId),
direction=DIRECTION_IB2VT[execution.side],
price=execution.price,
volume=execution.shares,
time=datetime.strptime(execution.time, "%Y%m%d %H:%M:%S"),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def onTradeEvent(self, data: dict, session: int) -> None:
""""""
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"]]
trade = TradeData(symbol=symbol,
exchange=MARKET_XTP2VT[data["market"]],
orderid=str(data["order_xtp_id"]),
tradeid=str(data["exec_id"]),
direction=direction,
offset=offset,
price=data["price"],
volume=data["quantity"],
time=data["trade_time"],
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def update_trade(self, data: dict) -> None:
""""""
symbol = data["InstrumentID"]
exchange = EXCHANGE_UFT2VT[data["ExchangeID"]]
sessionid = data["SessionID"]
order_ref = data["OrderRef"]
orderid = f"{sessionid}_{order_ref}"
trade = TradeData(symbol=symbol,
exchange=exchange,
orderid=orderid,
tradeid=data["TradeID"],
direction=DIRECTION_UFT2VT[data["Direction"]],
offset=OFFSET_UFT2VT[data["OffsetFlag"]],
price=data["TradePrice"],
volume=data["TradeVolume"],
time=generate_time(data["TradeTime"]),
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
print("on_trade", trade.orderid, trade.volume)
def on_trade(self, data):
""""""
self.trade_id += 1
if data[4] > 0:
direction = Direction.LONG
else:
direction = Direction.SHORT
trade = TradeData(
symbol=str(data[1].replace("t", "")),
exchange=Exchange.BITFINEX,
orderid=data[-1],
direction=direction,
volume=abs(data[4]),
price=data[5],
tradeid=str(self.trade_id),
datetime=generate_datetime(data[2]),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_trade(self, l: List, t: int):
""""""
d = l[0]
sys_orderid = d["order_id"]
order = self.order_manager.get_order_with_sys_orderid(sys_orderid)
if not order:
return
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=d["id"],
direction=order.direction,
price=float(d["price"]),
volume=abs(d["size"]),
datetime=generate_datetime(d["create_time"]),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_trade(self, data: dict) -> None:
""""""
sys_orderid = str(data["orderID"])
order = self.order_manager.get_order_with_sys_orderid(sys_orderid)
order.status = STATUS_KAISA2VT[data["orderStatus"]]
order.traded = int(data["execQty"])
self.gateway.on_order(order)
self.gateway.rest_api.trader_count += 1
trade = TradeData(tradeid=str(self.gateway.rest_api.trader_count),
symbol=data["productCode"],
exchange=Exchange.HKSE,
orderid=order.orderid,
direction=order.direction,
price=float(data["execPrice"]),
volume=int(data["execQty"]),
datetime=generate_datetime(data["tradeTime"]),
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def on_order(self, packet: dict):
""""""
if packet["C"] == "":
orderid = packet["c"]
else:
orderid = packet["C"]
order = OrderData(
symbol=packet["s"].lower(),
exchange=Exchange.BINANCE,
orderid=orderid,
type=ORDERTYPE_BINANCE2VT[packet["o"]],
direction=DIRECTION_BINANCE2VT[packet["S"]],
price=float(packet["p"]),
volume=float(packet["q"]),
traded=float(packet["z"]),
status=STATUS_BINANCE2VT[packet["X"]],
datetime=generate_datetime(packet["O"]),
gateway_name=self.gateway_name
)
self.gateway.on_order(order)
# Push trade event
trade_volume = float(packet["l"])
if not trade_volume:
return
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=packet["t"],
direction=order.direction,
price=float(packet["L"]),
volume=trade_volume,
datetime=generate_datetime(packet["T"]),
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def onTradeEvent(self, data: dict, session: int) -> None:
""""""
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"]]
timestamp = str(data["trade_time"])
dt = datetime.strptime(timestamp, "%Y%m%d%H%M%S%f")
dt = CHINA_TZ.localize(dt)
trade = TradeData(
symbol=symbol,
exchange=MARKET_XTP2VT[data["market"]],
orderid=str(data["order_xtp_id"]),
tradeid=str(data["exec_id"]),
direction=direction,
offset=offset,
price=data["price"],
volume=data["quantity"],
datetime=dt,
gateway_name=self.gateway_name
)
if trade.orderid in self.orders:
order = self.orders[trade.orderid]
order.traded += trade.volume
if order.traded < order.volume:
order.status = Status.PARTTRADED
else:
order.status = Status.ALLTRADED
self.gateway.on_order(order)
else:
self.gateway.write_log(f"成交找不到对应委托{trade.orderid}")
self.gateway.on_trade(trade)
def on_order(self, d):
"""这里是将收到的order转换成本地OrderData"""
offset, direction = TYPE_OKEXF2VT[d["type"]]
order = OrderData(
symbol=d["instrument_id"],
exchange=Exchange.OKEXF,
type=ORDERTYPE_OKEXF2VT[d["order_type"]],
orderid=d["client_oid"],
offset=offset,
direction=direction,
price=float(d["price"]),
volume=float(d["size"]),
traded=float(d["filled_qty"]),
time=utc_to_local(
d["timestamp"]).strftime("%Y-%m-%d %H:%M:%S.%fZ"),
status=STATUS_OKEXF2VT[d["state"]],
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"futures{self.connect_time}{self.trade_count}"
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=tradeid,
direction=order.direction,
offset=order.offset,
price=float(d["last_fill_px"]),
volume=float(trade_volume),
time=order.time,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(copy(trade))
def on_order(self, d):
"""order的回调函数"""
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,
)
# 向gateway里面推送order
self.gateway.on_order(copy(order))
# 这个字段的意思就是最新成交数量
trade_volume = d.get("last_fill_qty", 0)
if not trade_volume or float(trade_volume) == 0:
return
# 如果有成交，数量不为0，则进行以下操作,推送成交
self.trade_count += 1
tradeid = f"spot{self.connect_time}{self.trade_count}"
# last_fill_px 最近成交价格，last_fill_time 最新成交时间
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: dict) -> None:
""""""
direction = SIDE_OKEXO2VT[data["side"]]
order = OrderData(
symbol=data["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEXO2VT[data["order_type"]],
orderid=data["client_oid"],
direction=direction,
price=float(data["price"]),
volume=float(data["size"]),
traded=float(data["filled_qty"]),
time=utc_to_local(data["timestamp"]).strftime("%H:%M:%S"),
status=STATE_OKEXO2VT[data["state"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
trade_volume = data.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,
offset=order.offset,
price=float(data["last_fill_px"]),
volume=float(trade_volume),
time=order.time,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_order(self, data):
""""""
order = _parse_order_info(data, gateway_name=self.gateway_name)
self.gateway.on_order(copy(order))
traded_volume = float(data.get("last_fill_qty", 0))
if traded_volume != 0:
tradeid = f"{self.connect_time}{self._last_trade_id}"
self._last_trade_id += 1
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=tradeid,
direction=order.direction,
offset=order.offset,
price=float(data["last_fill_px"]),
volume=float(traded_volume),
datetime=order.datetime,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def OnRtnTrade(self, data: dict) -> None:
"""
Callback of trade status update.
"""
symbol = data["SecurityID"]
exchange = EXCHANGE_TORA2VT[bytes.decode(data["ExchangeID"])]
orderid = self.sysid_orderid_map[data["OrderSysID"]]
timestamp = f"{data['TradeDate']} {data['TradeTime']}"
dt = datetime.strptime(timestamp, "%Y%m%d %H:%M:%S")
dt = CHINA_TZ.localize(dt)
trade = TradeData(symbol=symbol,
exchange=exchange,
orderid=orderid,
tradeid=data["TradeID"],
direction=Direction.NET,
price=data["Price"],
volume=data["Volume"],
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def execDetails(self, reqId: int, contract: Contract,
execution: Execution): # pylint: disable=invalid-name
"""
Callback of trade data update.
"""
super().execDetails(reqId, contract, execution)
dt = datetime.strptime(execution.time, "%Y%m%d %H:%M:%S")
dt = self.local_tz.localize(dt)
trade = TradeData(
symbol=generate_symbol(contract),
exchange=EXCHANGE_IB2VT.get(contract.exchange, Exchange.SMART),
orderid=str(execution.orderId),
tradeid=str(execution.execId),
direction=DIRECTION_IB2VT[execution.side],
price=execution.price,
volume=execution.shares,
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def process_deal(self, data):
"""
Process trade data for both query and update.
"""
for i in data:
if i.status == OrderStatus.PARTIALLY_FILLED or i.status == OrderStatus.FILLED:
symbol, exchange = convert_symbol_tiger2vt(str(i.contract))
self.tradeid += 1
trade = TradeData(
symbol=symbol,
exchange=exchange,
direction=Direction.NET,
tradeid=self.tradeid,
orderid=self.ID_TIGER2VT[str(i.order_id)],
price=i.avg_fill_price,
volume=i.filled,
time=datetime.fromtimestamp(i.trade_time /
1000).strftime("%H:%M:%S"),
gateway_name=self.gateway_name,
)
self.on_trade(trade)
def onRtnTrade(self, data: dict):
"""
Callback of trade status update.
"""
symbol = data["InstrumentID"]
exchange = symbol_exchange_map.get(symbol, "")
if not exchange:
self.trade_data.append(data)
return
orderid = self.sysid_orderid_map[data["OrderSysID"]]
trade = TradeData(symbol=symbol,
exchange=exchange,
orderid=orderid,
tradeid=data["TradeID"],
direction=DIRECTION_CTP2VT[data["Direction"]],
offset=OFFSET_CTP2VT[data["OffsetFlag"]],
price=data["Price"],
volume=data["Volume"],
time=data["TradeTime"],
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
