def send_order(self, vt_req: OrderRequest):
""""""
seq_id = self._get_new_seq_index()
order_id = seq_id
oes_req = OesOrdReqT()
oes_req.clSeqNo = seq_id
oes_req.mktId = EXCHANGE_VT2OES[vt_req.exchange]
oes_req.ordType = ORDER_TYPE_VT2OES[(vt_req.exchange, vt_req.type)]
oes_req.bsType = BUY_SELL_TYPE_VT2OES[(vt_req.exchange, vt_req.offset, vt_req.direction)]
oes_req.invAcctId = ""
oes_req.securityId = vt_req.symbol
oes_req.ordQty = int(vt_req.volume)
oes_req.ordPrice = int(vt_req.price * 10000)
oes_req.origClOrdId = order_id
order = vt_req.create_order_data(str(order_id), self.gateway.gateway_name)
order.direction = Direction.NET # fix direction into NET: stock only
self._order_manager.save_order(order_id, order)
ret = OesApi_SendOrderReq(self._env.ordChannel,
oes_req
)
if ret >= 0:
order.status = Status.SUBMITTING
else:
order.status = Status.REJECTED
self.gateway.write_log(_("下单失败")) # todo: can I stringify error?
if is_disconnected(ret):
self.gateway.write_log(_("下单时连接发现连接已断开，正在尝试重连"))
self._schedule_reconnect_ord_channel()
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
side = DIRECTION_VT2FUTU[req.direction]
price_type = OrderType.NORMAL # Only limit order is supported.
# Set price adjustment mode to inside adjustment.
if req.direction is Direction.LONG:
adjust_limit = 0.05
else:
adjust_limit = -0.05
futu_symbol = convert_symbol_vt2futu(req.symbol, req.exchange)
code, data = self.trade_ctx.place_order(
req.price,
req.volume,
futu_symbol,
side,
price_type,
trd_env=self.env,
adjust_limit=adjust_limit,
)
if code:
self.write_log(f"委托失败：{data}")
return ""
for ix, row in data.iterrows():
orderid = str(row["order_id"])
order = req.create_order_data(orderid, self.gateway_name)
self.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
self.order_count += 1
orderid = str(self.connect_time + self.order_count)
data = {
"symbol": req.symbol,
"side": DIRECTION_VT2BITMEX[req.direction],
"ordType": PRICETYPE_VT2BITMEX[req.price_type],
"price": req.price,
"orderQty": int(req.volume),
"clOrdID": orderid,
}
# Only add price for limit order.
if req.price_type == PriceType.LIMIT:
data["price"] = req.price
order = req.create_order_data(orderid, self.gateway_name)
self.add_request(
"POST",
"/order",
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
"""
Send a new order.
"""
if not self.status:
return ""
if req.exchange not in EXCHANGE_VT2IB:
self.gateway.write_log(f"不支持的交易所：{req.exchange}")
return ""
if req.type not in ORDERTYPE_VT2IB:
self.gateway.write_log(f"不支持的价格类型：{req.type}")
return ""
self.orderid += 1
ib_contract = Contract()
ib_contract.conId = str(req.symbol)
ib_contract.exchange = EXCHANGE_VT2IB[req.exchange]
ib_order = Order()
ib_order.orderId = self.orderid
ib_order.clientId = self.clientid
ib_order.action = DIRECTION_VT2IB[req.direction]
ib_order.orderType = ORDERTYPE_VT2IB[req.type]
ib_order.lmtPrice = req.price
ib_order.totalQuantity = req.volume
self.client.placeOrder(self.orderid, ib_contract, ib_order)
self.client.reqIds(1)
order = req.create_order_data(str(self.orderid), self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
local_id = self.get_new_local_id()
order = req.create_order_data(local_id, self.gateway_name)
self.on_order(order)
self.add_task(self._send_order, req, local_id)
return order.vt_orderid
def send_order(self, req: OrderRequest):
"""
Send new order.
"""
self.order_ref += 1
rohon_req = {
"InstrumentID": req.symbol,
"ExchangeID": req.exchange.value,
"LimitPrice": req.price,
"VolumeTotalOriginal": int(req.volume),
"OrderPriceType": ORDERTYPE_VT2ROHON.get(req.type, ""),
"Direction": DIRECTION_VT2ROHON.get(req.direction, ""),
"CombOffsetFlag": OFFSET_VT2ROHON.get(req.offset, ""),
"OrderRef": str(self.order_ref),
"InvestorID": self.userid,
"UserID": self.userid,
"BrokerID": self.brokerid,
"CombHedgeFlag": THOST_FTDC_HF_Speculation,
"ContingentCondition": THOST_FTDC_CC_Immediately,
"ForceCloseReason": THOST_FTDC_FCC_NotForceClose,
"IsAutoSuspend": 0,
"TimeCondition": THOST_FTDC_TC_GFD,
"VolumeCondition": THOST_FTDC_VC_AV,
"MinVolume": 1
}
if req.type == OrderType.FAK:
rohon_req["OrderPriceType"] = THOST_FTDC_OPT_LimitPrice
rohon_req["TimeCondition"] = THOST_FTDC_TC_IOC
rohon_req["VolumeCondition"] = THOST_FTDC_VC_AV
elif req.type == OrderType.FOK:
rohon_req["OrderPriceType"] = THOST_FTDC_OPT_LimitPrice
rohon_req["TimeCondition"] = THOST_FTDC_TC_IOC
rohon_req["VolumeCondition"] = THOST_FTDC_VC_CV
self.reqid += 1
self.reqOrderInsert(rohon_req, self.reqid)
orderid = f"{self.frontid}_{self.sessionid}_{self.order_ref}"
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
"""委托下单"""
if req.offset not in OFFSET_VT2CTP:
self.gateway.write_log("请选择开平方向")
return ""
if req.type not in ORDERTYPE_VT2CTP:
self.gateway.write_log(f"当前接口不支持该类型的委托{req.type.value}")
return ""
self.order_ref += 1
tp = ORDERTYPE_VT2CTP[req.type]
price_type, time_condition, volume_condition = tp
ctp_req: dict = {
"InstrumentID": req.symbol,
"ExchangeID": req.exchange.value,
"LimitPrice": req.price,
"VolumeTotalOriginal": int(req.volume),
"OrderPriceType": price_type,
"Direction": DIRECTION_VT2CTP.get(req.direction, ""),
"CombOffsetFlag": OFFSET_VT2CTP.get(req.offset, ""),
"OrderRef": str(self.order_ref),
"InvestorID": self.userid,
"UserID": self.userid,
"BrokerID": self.brokerid,
"CombHedgeFlag": THOST_FTDC_HF_Speculation,
"ContingentCondition": THOST_FTDC_CC_Immediately,
"ForceCloseReason": THOST_FTDC_FCC_NotForceClose,
"IsAutoSuspend": 0,
"TimeCondition": time_condition,
"VolumeCondition": volume_condition,
"MinVolume": 1
}
self.reqid += 1
self.reqOrderInsert(ctp_req, self.reqid)
orderid: str = f"{self.frontid}_{self.sessionid}_{self.order_ref}"
order: OrderData = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
orderid = str(self.connect_time + self._new_order_id())
data = {
"symbol": req.symbol,
"side": DIRECTION_VT2BITMEX[req.direction],
"ordType": ORDERTYPE_VT2BITMEX[req.type],
"orderQty": int(req.volume),
"clOrdID": orderid,
}
inst = [] # Order special instructions
# Only add price for limit order.
if req.type == OrderType.LIMIT:
data["price"] = req.price
elif req.type == OrderType.STOP:
data["stopPx"] = req.price
inst.append("LastPrice")
# Check for close order
if req.offset == Offset.CLOSE:
inst.append("ReduceOnly")
# Generate execInst
if inst:
data["execInst"] = ",".join(inst)
order = req.create_order_data(orderid, self.gateway_name)
self.add_request(
"POST",
"/order",
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
"""
Send a new order.
"""
if not self.status:
return ""
if req.exchange not in EXCHANGE_VT2IB:
self.gateway.write_log(f"不支持的交易所：{req.exchange}")
return ""
if req.type not in ORDERTYPE_VT2IB:
self.gateway.write_log(f"不支持的价格类型：{req.type}")
return ""
ib_contract = generate_ib_contract(req.symbol, req.exchange)
if not ib_contract:
return ""
ib_order = Order()
ib_order.clientId = self.clientid
ib_order.action = DIRECTION_VT2IB[req.direction]
ib_order.orderType = ORDERTYPE_VT2IB[req.type]
ib_order.totalQuantity = req.volume
ib_order.outsideRth = True
ib_order.orderRef = req.orderRef
ib_order.account = self.account
if req.type == OrderType.LIMIT:
ib_order.lmtPrice = req.price
elif req.type == OrderType.STOP:
ib_order.auxPrice = req.price
self.orderLock.acquire()
self.orderid += 1
ib_order.orderId = self.orderid
self.client.placeOrder(self.orderid, ib_contract, ib_order)
# self.client.reqIds(1)
order = req.create_order_data(str(self.orderid), self.gateway_name)
self.orderLock.release()
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest, gateway_name: str) -> str:
""""""
contract: ContractData = self.main_engine.get_contract(req.vt_symbol)
if not contract:
self.write_log(f"委托失败，找不到该合约{req.vt_symbol}")
return ""
self.order_count += 1
now = datetime.now().strftime("%y%m%d%H%M%S")
orderid = now + str(self.order_count)
vt_orderid = f"{GATEWAY_NAME}.{orderid}"
# Put simulated order update event from gateway
order = req.create_order_data(orderid, GATEWAY_NAME)
self.put_event(EVENT_ORDER, copy(order))
# Check if order is valid
updated_position = self.check_order_valid(order, contract)
# Put simulated order update event from exchange
if order.status != Status.REJECTED:
order.datetime = datetime.now(LOCAL_TZ)
order.status = Status.NOTTRADED
active_orders = self.active_orders.setdefault(order.vt_symbol, {})
active_orders[orderid] = order
self.put_event(EVENT_ORDER, copy(order))
# Update position frozen for close order
if updated_position:
self.put_event(EVENT_POSITION, copy(updated_position))
# Cross order immediately with last tick data
if self.instant_trade:
tick = self.ticks.get(order.vt_symbol, None)
if tick:
self.cross_order(order, tick)
if not order.is_active():
active_orders = self.active_orders[order.vt_symbol]
active_orders.pop(orderid)
return vt_orderid
def send_order(self, req: OrderRequest):
"""
Send new order.
"""
self.localid += 1
orderid = str(self.localid).rjust(12, "0")
femas_req = {
"InstrumentID": req.symbol,
"ExchangeID": str(req.exchange).split(".")[1],
"BrokerID": self.brokerid,
"InvestorID": self.userid,
"UserID": self.userid,
"LimitPrice": req.price,
"Volume": int(req.volume),
"OrderPriceType": ORDERTYPE_VT2FEMAS.get(req.type, ""),
"Direction": DIRECTION_VT2FEMAS.get(req.direction, ""),
"OffsetFlag": OFFSET_VT2FEMAS.get(req.offset, ""),
"UserOrderLocalID": orderid,
"HedgeFlag": USTP_FTDC_CHF_Speculation,
"ForceCloseReason": USTP_FTDC_FCR_NotForceClose,
"IsAutoSuspend": 0,
"TimeCondition": USTP_FTDC_TC_GFD,
"VolumeCondition": USTP_FTDC_VC_AV,
"MinVolume": 1,
}
if req.type == OrderType.FAK:
femas_req["OrderPriceType"] = USTP_FTDC_OPT_LimitPrice
femas_req["TimeCondition"] = USTP_FTDC_TC_IOC
femas_req["VolumeCondition"] = USTP_FTDC_VC_AV
elif req.type == OrderType.FOK:
femas_req["OrderPriceType"] = USTP_FTDC_OPT_LimitPrice
femas_req["TimeCondition"] = USTP_FTDC_TC_IOC
femas_req["VolumeCondition"] = USTP_FTDC_VC_CV
self.reqid += 1
self.reqOrderInsert(femas_req, self.reqid)
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
"""
Send new order.
"""
self.order_ref += 1
ctp_req = {
"InstrumentID": req.symbol,
"LimitPrice": req.price,
"VolumeTotalOriginal": int(req.volume),
"OrderPriceType": ORDERTYPE_VT2CTP.get(req.type, ""),
"Direction": DIRECTION_VT2CTP.get(req.direction, ""),
"CombOffsetFlag": OFFSET_VT2CTP.get(req.offset, ""),
"OrderRef": str(self.order_ref),
"InvestorID": self.userid,
"UserID": self.userid,
"BrokerID": self.brokerid,
"CombHedgeFlag": THOST_FTDC_HF_Speculation,
"ContingentCondition": THOST_FTDC_CC_Immediately,
"ForceCloseReason": THOST_FTDC_FCC_NotForceClose,
"IsAutoSuspend": 0,
"TimeCondition": THOST_FTDC_TC_GFD,
"VolumeCondition": THOST_FTDC_VC_AV,
"MinVolume": 1
}
if req.type == OrderType.FAK:
ctp_req["OrderPriceType"] = THOST_FTDC_OPT_LimitPrice
ctp_req["TimeCondition"] = THOST_FTDC_TC_IOC
ctp_req["VolumeCondition"] = THOST_FTDC_VC_AV
elif req.type == OrderType.FOK:
ctp_req["OrderPriceType"] = THOST_FTDC_OPT_LimitPrice
ctp_req["TimeCondition"] = THOST_FTDC_TC_IOC
ctp_req["VolumeCondition"] = THOST_FTDC_VC_CV
self.reqid += 1
self.reqOrderInsert(ctp_req, self.reqid)
orderid = f"{self.frontid}_{self.sessionid}_{self.order_ref}"
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
if not self.login_status:
self.gateway.write_log(f"委托失败，未登录交易服务器{req.exchange.value}")
return ""
if req.exchange not in EXCHANGE_VT2PT:
self.gateway.write_log(f"委托失败，不支持的交易所{req.exchange.value}")
return ""
if req.type not in ORDERTYPE:
self.gateway.write_log(f"委托失败，不支持的委托类型{req.type.value}")
return ""
date, time = datetime.now().strftime("%Y%m%d %H:%S:%M").split(" ")
pt_req = {
"code": req.symbol,
"exchange": EXCHANGE_VT2PT[req.exchange],
"account_id": self.token,
"order_price": req.price,
"volume": int(req.volume),
"price_type": req.type.value,
"order_date": date,
"order_time": time,
}
pt_req["order_type"] = DIRECTION_STOCK_VT2PT.get(
(req.direction, Offset.NONE), "")
status, data = self.order_send(pt_req)
if status:
order = req.create_order_data(str(data.get("order_id", "")),
self.gateway_name)
self.on_order_event(order)
return order.vt_orderid
else:
error = dict()
error["error_id"] = "pt_api"
error["error_msg"] = data
self.gateway.write_error("交易委托失败", error)
def send_order(self, req: OrderRequest):
"""
Send a new order.
"""
if not self.status:
return ""
if req.exchange not in EXCHANGE_VT2IB:
self.gateway.write_log(
f" it does not support exchange ：{req.exchange}")
return ""
if req.type not in ORDERTYPE_VT2IB:
self.gateway.write_log(
f" the price type is not supported ：{req.type}")
return ""
self.orderid += 1
ib_contract = Contract()
ib_contract.conId = str(req.symbol)
ib_contract.exchange = EXCHANGE_VT2IB[req.exchange]
ib_order = Order()
ib_order.orderId = self.orderid
ib_order.clientId = self.clientid
ib_order.action = DIRECTION_VT2IB[req.direction]
ib_order.orderType = ORDERTYPE_VT2IB[req.type]
ib_order.totalQuantity = req.volume
if req.type == OrderType.LIMIT:
ib_order.lmtPrice = req.price
elif req.type == OrderType.STOP:
ib_order.auxPrice = req.price
self.client.placeOrder(self.orderid, ib_contract, ib_order)
self.client.reqIds(1)
order = req.create_order_data(str(self.orderid), self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
"""委托下单"""
# 检查委托类型是否正确
if req.type not in ORDERTYPE_VT2OKEX:
self.gateway.write_log(f"委托失败，不支持的委托类型：{req.type.value}")
return
# 检查合约代码是否正确
contract: ContractData = symbol_contract_map.get(req.symbol, None)
if not contract:
self.gateway.write_log(f"委托失败，找不到该合约代码{req.symbol}")
return
# 生成本地委托号
self.order_count += 1
count_str = str(self.order_count).rjust(6, "0")
orderid = f"{self.connect_time}{count_str}"
# 生成委托亲求
args: dict = {
"instId": req.symbol,
"clOrdId": orderid,
"side": DIRECTION_VT2OKEX[req.direction],
"ordType": ORDERTYPE_VT2OKEX[req.type],
"px": str(req.price),
"sz": str(req.volume)
}
if contract.product == Product.SPOT:
args["tdMode"] = "cash"
else:
args["tdMode"] = "cross"
self.reqid += 1
okex_req: dict = {"id": str(self.reqid), "op": "order", "args": [args]}
self.send_packet(okex_req)
# 推送提交中事件
order: OrderData = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
if req.exchange not in MARKET_VT2XTP:
self.gateway.write_log(f"委托失败，不支持的交易所{req.exchange.value}")
return ""
if req.type not in ORDERTYPE_VT2XTP:
self.gateway.write_log(f"委托失败，不支持的委托类型{req.type.value}")
return ""
# check for option type
if len(req.symbol) == 8:
xtp_req = {
"ticker": req.symbol,
"market": MARKET_VT2XTP[req.exchange],
"price": req.price,
"quantity": int(req.volume),
"side": DIRECTION_OPTION_VT2XTP.get(req.direction, ""),
"position_effect": OFFSET_VT2XTP[req.offset],
"price_type": ORDERTYPE_VT2XTP[req.type],
"business_type": BUSINESS_VT2XTP["OPTION"]
}
# stock type
else:
xtp_req = {
"ticker": req.symbol,
"market": MARKET_VT2XTP[req.exchange],
"price": req.price,
"quantity": int(req.volume),
"side": DIRECTION_STOCK_VT2XTP.get((req.direction, req.offset), ""),
"price_type": ORDERTYPE_VT2XTP[req.type],
"business_type": BUSINESS_VT2XTP[req.offset]
}
orderid = self.insertOrder(xtp_req, self.session_id)
order = req.create_order_data(str(orderid), self.gateway_name)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
"""币币下单"""
# Id组成用margin做前缀来下单
orderid = f"margin{self.connect_time}{self._new_order_id()}"
# 公用字段：client_id, type, side, instrument_id, order_type
data = {
"client_oid": orderid,
"type": ORDERTYPE_VT2OKEX[req.type],
"side": DIRECTION_VT2OKEX[req.direction],
"instrument_id": req.symbol,
"margin_trading": "2"
}
# 如果是市价单，卖出必填size，买入必填notional
if req.type == OrderType.MARKET:
if req.direction == Direction.LONG:
data["notional"] = req.volume
else:
data["size"] = req.volume
# 如果是限价单，必填price和size
else:
data["price"] = req.price
data["size"] = req.volume
order = req.create_order_data(orderid, self.gateway_name)
self.add_request(
"POST",
"/api/margin/v3/orders",
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
self.reqid += 1
orderid = self.reqid
oes_exchange = STOCK_EXCHANGE_VT2OES[req.exchange]
oes_direction = DIRECTION_VT2OES[req.direction]
# Check product
if len(req.symbol) > 6:
oes_exchange = OPTION_EXCHANGE_VT2OES[req.exchange]
oes_direction = OPTION_DIRECTION_VT2OES[(req.direction,
req.offset)]
# Check market
if req.exchange == Exchange.SSE:
oes_investorid = self.investoridsh
elif req.exchange == Exchange.SZSE:
oes_investorid = self.investoridsz
else:
self.gateway.write_log("暂不支持其它市场")
oes_req = {
"clSeqNo": self.reqid,
"mktId": oes_exchange,
"ordType": ORDERTYPE_VT2OES[req.type],
"bsType": oes_direction,
"invAcctId": oes_investorid,
"securityId": req.symbol,
"ordQty": int(req.volume),
"ordPrice": int(req.price * 10000),
"origClOrdId": orderid,
}
self.sendOrder(oes_req)
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
self.orders[orderid] = order
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
orderid = self.new_orderid()
order = req.create_order_data(orderid, self.gateway_name)
data = {
"symbol": req.symbol,
"side": DIRECTION_VT2BYBIT[req.direction],
"qty": req.volume,
"order_link_id": orderid,
"time_in_force": "GoodTillCancel",
"close_on_trigger": False
}
if req.offset == Offset.CLOSE:
data['reduce_only'] = True
else:
data['reduce_only'] = False
data["order_type"] = ORDER_TYPE_VT2BYBIT[req.type]
data["price"] = req.price
if self.usdt_base:
path = "/private/linear/order/create"
else:
path = "/v2/private/order/create"
self.add_request(
"POST",
path,
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
# Need both offset and direction for sending order.
orderid = f"a{self.connect_time}{self._new_order_id()}"
if req.direction == Direction.LONG:
side = "buy"
else:
side = "sell"
data = {
"client_oid": orderid,
"instrument_id": req.symbol,
"price": str(req.price),
"size": str(int(req.volume)),
"side": side,
}
if req.type == OrderType.MARKET:
data["match_price"] = "1"
else:
data["match_price"] = "0"
order = req.create_order_data(orderid, self.gateway_name)
self.add_request(
"POST",
"/api/option/v3/order",
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, vt_req: OrderRequest):
""""""
seq_id = self._get_new_seq_index()
order_id = seq_id
oes_req = OesOrdReqT()
oes_req.clSeqNo = seq_id
oes_req.mktId = EXCHANGE_VT2OES[vt_req.exchange]
oes_req.ordType = ORDER_TYPE_VT2OES[(vt_req.exchange, vt_req.type)]
oes_req.bsType = BUY_SELL_TYPE_VT2OES[(vt_req.exchange, vt_req.offset,
vt_req.direction)]
oes_req.invAcctId = ""
oes_req.securityId = vt_req.symbol
oes_req.ordQty = int(vt_req.volume)
oes_req.ordPrice = int(vt_req.price * 10000)
oes_req.origClOrdId = order_id
order = vt_req.create_order_data(str(order_id),
self.gateway.gateway_name)
order.direction = Direction.NET # fix direction into NET: stock only
self._order_manager.save_order(order_id, order)
ret = OesApi_SendOrderReq(self._env.ordChannel, oes_req)
if ret >= 0:
order.status = Status.SUBMITTING
else:
order.status = Status.REJECTED
self.gateway.write_log(
_(" single failure ")) # todo: can I stringify error?
if is_disconnected(ret):
self.gateway.write_log(
_(" when connecting single disconnected found ， we are trying to reconnect "
))
self._schedule_reconnect_ord_channel()
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
orderid = "328hhn6c-" + str(self.connect_time + self._new_order_id())
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
data = {"security": Security.SIGNED}
order_type, time_condition = ORDERTYPE_VT2BINANCES[req.type]
params = {
"symbol": req.symbol,
"side": DIRECTION_VT2BINANCES[req.direction],
"type": order_type,
"timeInForce": time_condition,
"price": float(req.price),
"quantity": float(req.volume),
"newClientOrderId": orderid,
}
if req.offset == Offset.CLOSE:
params["reduceOnly"] = True
if self.usdt_base:
path = "/fapi/v1/order"
else:
path = "/dapi/v1/order"
self.add_request(method="POST",
path=path,
callback=self.on_send_order,
data=data,
params=params,
extra=order,
on_error=self.on_send_order_error,
on_failed=self.on_send_order_failed)
return order.vt_orderid
def send_order(self, req: OrderRequest):
orderid = self._gen_unqiue_cid()
if req.direction == Direction.LONG:
amount = req.volume
else:
amount = -req.volume
o = {
"cid": orderid,
"type": ORDERTYPE_VT2BITFINEX[req.type],
"symbol": "t" + req.symbol,
"amount": str(amount),
"price": str(req.price),
}
request = [0, "on", None, o]
order = req.create_order_data(orderid, self.gateway_name)
self.send_packet(request)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
if self.usdt_base:
path = "/linear-swap-api/v1/swap_cross_order"
else:
path = "/swap-api/v1/swap_order"
local_orderid = self.new_local_orderid()
order = req.create_order_data(
local_orderid,
self.gateway_name
)
order.datetime = datetime.now(CHINA_TZ)
data = {
"contract_code": req.symbol,
"client_order_id": int(local_orderid),
"price": req.price,
"volume": int(req.volume),
"direction": DIRECTION_VT2HUOBIS.get(req.direction, ""),
"offset": OFFSET_VT2HUOBIS.get(req.offset, ""),
"order_price_type": ORDERTYPE_VT2HUOBIS.get(req.type, ""),
"lever_rate": 20
}
self.add_request(
method="POST",
path=path,
callback=self.on_send_order,
data=data,
extra=order,
on_error=self.on_send_order_error,
on_failed=self.on_send_order_failed
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
local_orderid = self.order_manager.new_local_orderid()
order = req.create_order_data(
local_orderid,
self.gateway_name
)
order.datetime = datetime.now(UTC_TZ)
if req.direction == Direction.SHORT:
volume = -int(req.volume)
else:
volume = int(req.volume)
request_body = {
"contract": req.symbol,
"size": volume,
"price": str(req.price),
"close": False,
"tif": "gtc",
"text": f"t-{local_orderid}"
}
data = json.dumps(request_body)
self.add_request(
method="POST",
path="/api/v4/futures/orders",
callback=self.on_send_order,
data=data,
extra=order,
on_error=self.on_send_order_error,
on_failed=self.on_send_order_failed
)
self.order_manager.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
"""委托下单"""
# 检查委托类型是否正确
if req.type not in ORDERTYPE_VT2DERIBIT:
self.gateway.write_log(f"委托失败，不支持的委托类型：{req.type.value}")
return
# 生成本地委托号
self.order_count += 1
orderid: str = str(self.connect_time + self.order_count)
self.localids.add(orderid)
side: str = DIRECTION_VT2DERIBIT[req.direction]
method: str = "private/" + side
# 生成委托请求
params: dict = {
"instrument_name": req.symbol,
"amount": req.volume,
"type": ORDERTYPE_VT2DERIBIT[req.type],
"label": orderid,
"price": req.price
}
reqid: str = self.send_request(
method,
params,
self.on_send_order
)
# 推送委托提交中状态
order: OrderData = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
self.reqid_order_map[reqid] = order
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
orderid = str(self.connect_time + self._new_order_id())
order = req.create_order_data(
orderid,
self.gateway_name
)
self.gateway.on_order(order)
data = {
"security": Security.SIGNED
}
params = {
"symbol": req.symbol,
"timeInForce": "GTC",
"side": DIRECTION_VT2BINANCE[req.direction],
"type": ORDERTYPE_VT2BINANCE[req.type],
"price": str(req.price),
"quantity": str(req.volume),
"newClientOrderId": orderid,
"newOrderRespType": "ACK"
}
self.add_request(
method="POST",
path="/api/v3/order",
callback=self.on_send_order,
data=data,
params=params,
extra=order,
on_error=self.on_send_order_error,
on_failed=self.on_send_order_failed
)
return order.vt_orderid
def send_order(self, req: OrderRequest):
""""""
# Need both offset and direction for sending order.
if (req.offset, req.direction) not in TYPE_VT2OKEXF:
return ""
orderid = f"a{self.connect_time}{self._new_order_id()}"
data = {
"client_oid": orderid,
"type": TYPE_VT2OKEXF[(req.offset, req.direction)],
"instrument_id": req.symbol,
"price": str(req.price),
"size": str(int(req.volume)),
"leverage": self.leverage,
}
if req.type == OrderType.MARKET:
data["match_price"] = "4"
else:
data["match_price"] = "0"
order = req.create_order_data(orderid, self.gateway_name)
self.add_request(
"POST",
"/api/futures/v3/order",
callback=self.on_send_order,
data=data,
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
"""
Send new order to TAP server.
"""
contract_info = contract_infos.get((req.symbol, req.exchange), None)
if not contract_info:
self.gateway.write_log(
f"找不到匹配的合约：{req.symbol}和{req.exchange.value}")
return ""
if req.type not in ORDERTYPE_VT2TAP:
self.gateway.write_log(f"不支持的委托类型: {req.type.value}")
return ""
order_req = {
"AccountNo": self.account_no,
"ExchangeNo": contract_info.exchange_no,
"CommodityType": contract_info.commodity_type,
"CommodityNo": contract_info.commodity_no,
"ContractNo": contract_info.contract_no,
"OrderType": ORDERTYPE_VT2TAP[req.type],
"OrderSide": DIRECTION_VT2TAP[req.direction],
"OrderPrice": req.price,
"OrderQty": int(req.volume),
}
error_id, sesion, order_id = self.insertOrder(order_req)
order = req.create_order_data(order_id, self.gateway_name)
if error_id:
self.gateway.write_log(f"委托请求失败，错误号：{error_id}")
order.status = Status.REJECTED
self.gateway.on_order(order)
return order.vt_orderid
def send_order(self, req: OrderRequest) -> str:
""""""
orderid = "328hhn6c-" + str(self.connect_time + self._new_order_id())
order = req.create_order_data(orderid, self.gateway_name)
self.gateway.on_order(order)
data = {"security": Security.SIGNED}
order_type, time_condition = ORDERTYPE_VT2BINANCES[req.type]
params = {
"symbol": req.symbol,
"side": DIRECTION_VT2BINANCES[req.direction],
"type": order_type,
"timeInForce": time_condition,
"price": float(req.price),
"quantity": float(req.volume),
"newClientOrderId": orderid,
"recvWindow": 20000
}
if self.dualSidePosition:
if req.offset == Offset.OPEN:
positionSide = SIDE_VT2BINANCEF[req.direction]
else:
if req.direction == Direction.LONG:
positionSide = SIDE_VT2BINANCEF[Direction.SHORT]
else:
positionSide = SIDE_VT2BINANCEF[Direction.LONG]
params['positionSide'] = positionSide
if order_type == "STOP":
params['stopPrice'] = float(req.price)
if order_type == "MARKET":
params.pop('price', None)
params.pop('timeInForce', None)
# if req.offset == Offset.CLOSE:
# params["reduceOnly"] = True
if self.usdt_base:
path = "/fapi/v1/order"
else:
path = "/dapi/v1/order"
resp = self.request(method="POST", path=path, data=data, params=params)
if isinstance(resp, requests.Response):
if resp.status_code // 100 != 2:
msg = f"委托下单失败，状态码：{resp.status_code}，信息：{resp.text}, {req.symbol}, {orderid}"
self.gateway.write_log(msg)
data = resp.json()
if data['code'] == -2021:
req.type = OrderType.LIMIT
return self.send_order(req)
else:
return False
else:
return order.vt_orderid
else:
msg = f"网络连接失败，委托下单失败。{req.symbol} {orderid}"
self.gateway.write_log(msg)
return self.send_order(req)
def send_swap_futures_order(self, req: OrderRequest) -> str:
"""
Send a new order to server.
implementation should finish the tasks blow:
* create an OrderData from req using OrderRequest.create_order_data
* assign a unique(gateway instance scope) id to OrderData.orderid
* send request to server
* if request is sent, OrderData.status should be set to Status.SUBMITTING
* if request is failed to sent, OrderData.status should be set to Status.REJECTED
* response on_order:
* return OrderData.vt_orderid
:return str vt_orderid for created OrderData
调用例子：
order_req = OrderRequest(symbol="EOS-USD-191227", exchange=Exchange.OKEX,
direction=Direction.LONG, type=OrderType.LIMIT, volume=1, price=3.5, offset=Offset.OPEN)
ret = self.send_order(order_req)
"""
# Need both offset and direction for sending order.
# 多 空 开 平
if (req.offset, req.direction) not in TYPE_VT2OKEXF:
return ""
orderid = f"a{self.connect_time}{self._new_order_id()}"
data = {
"client_oid": orderid,
"type": TYPE_VT2OKEXF[(req.offset, req.direction)],
"instrument_id": req.symbol,
"price": str(req.price),
"size": str(int(req.volume)),
"leverage": self.leverage,
}
if req.type == OrderType.MARKET:
data["match_price"] = "1"
else:
data["match_price"] = "0"
order = req.create_order_data(orderid, self.gateway_name)
for _ in range(20):
# 1发送order
ret = self.__create_swap_futures_order(
symbol=data["instrument_id"],
type=data["type"],
amount=data["size"],
price=data["price"],
params={"client_oid": data["client_oid"]})
if ret["info"]["result"]:
# True 发送订单成功
self.on_order(order)
# 成功返回 vt_orderid
return order.vt_orderid
else:
pass
# -----------------------------------
time.sleep(3)
# 2发送order failed
# 3发送order error
self.send_order_failed(status_code=str(ret["info"]), order=order)
return "create_order_failed"
def update_order_request(self, req: OrderRequest, vt_orderid: str):
""""""
gateway_name, orderid = vt_orderid.split(".")
order = req.create_order_data(orderid, gateway_name)
self.update_order(order)
def update_order_request(self, req: OrderRequest, vt_orderid: str):
""""""
gateway_name, orderid = vt_orderid.split(".")
order = req.create_order_data(orderid, gateway_name)
self.update_order(order)
def send_order(self, req: OrderRequest) -> str:
""""""
if req.exchange not in MARKET_VT2XTP:
self.gateway.write_log(f"委托失败，不支持的交易所{req.exchange.value}")
return ""
if self.margin_trading and req.offset == Offset.NONE:
self.gateway.write_log(f"委托失败，两融交易需要选择开平方向")
return ""
# check for option type
if len(req.symbol) == 8:
if req.type not in OPTION_ORDERTYPE_VT2XTP:
self.gateway.write_log(f"委托失败，不支持的期权委托类型{req.type.value}")
return ""
xtp_req = {
"ticker": req.symbol,
"market": MARKET_VT2XTP[req.exchange],
"price": req.price,
"quantity": int(req.volume),
"side": DIRECTION_OPTION_VT2XTP.get(req.direction, ""),
"position_effect": OFFSET_VT2XTP[req.offset],
"price_type": OPTION_ORDERTYPE_VT2XTP[req.type],
"business_type": 10
}
# stock type
else:
# STAR of SSE
if req.symbol.startswith("688"):
type_map = STAR_ORDERTYPE_VT2XTP
# Other
else:
type_map = EQUITY_ORDERTYPE_VT2XTP
if req.type not in type_map:
self.gateway.write_log(f"委托失败，不支持的股票委托类型{req.type.value}")
return ""
xtp_req = {
"ticker": req.symbol,
"market": MARKET_VT2XTP[req.exchange],
"price": req.price,
"quantity": int(req.volume),
"price_type": type_map[req.type],
}
if self.margin_trading:
xtp_req["side"] = DIRECTION_STOCK_VT2XTP.get(
(req.direction, req.offset), "")
xtp_req["business_type"] = 4
else:
xtp_req["side"] = DIRECTION_STOCK_VT2XTP.get(
(req.direction, Offset.NONE), "")
xtp_req["business_type"] = 0
orderid = self.insertOrder(xtp_req, self.session_id)
orderid = str(orderid)
order = req.create_order_data(orderid, self.gateway_name)
self.orders[orderid] = order
self.gateway.on_order(copy(order))
return order.vt_orderid
