def calculate_total_commission_for_broker_order(self, broker_order: brokerOrder) -> brokerOrder:
"""
This turns a broker_order with non-standard commission field (list of tuples) into a single figure
in base currency
:return: broker_order
"""
if broker_order is missing_order:
return broker_order
if broker_order.commission is None:
return broker_order
currency_data = dataCurrency(self.data)
if isinstance(broker_order.commission, float):
base_values = [broker_order.commission]
else:
base_values = [
currency_data.currency_value_in_base(ccy_value)
for ccy_value in broker_order.commission
]
commission = sum(base_values)
broker_order.commission = commission
return broker_order
def put_balance_trades_on_stack(
self,
instrument_order: instrumentOrder,
contract_order: contractOrder,
broker_order: brokerOrder,
):
log = instrument_order.log_with_attributes(self.log)
log.msg("Putting balancing trades on stacks")
try:
instrument_order_id = (
self.instrument_stack.
put_manual_order_on_stack_and_return_order_id(instrument_order)
)
except Exception as e:
log.error(
"Couldn't add balancing instrument trade error condition %s" %
str(e))
return failure, missing_order, missing_order, missing_order
try:
contract_order.parent = instrument_order_id
contract_order_id = self.contract_stack.put_order_on_stack(
contract_order)
except Exception as e:
log.error(
"Couldn't add balancing contract trade error condition %s " %
str(e))
return failure, instrument_order_id, missing_order, missing_order
try:
self.instrument_stack.add_children_to_order_without_existing_children(
instrument_order_id, [contract_order_id])
except Exception as e:
log.error("Couldn't add children to instrument order error %s" %
str(e))
return failure, instrument_order_id, contract_order_id, missing_order
broker_order.parent = contract_order_id
try:
broker_order_id = self.broker_stack.put_order_on_stack(
broker_order)
except Exception as e:
log.error(
"Couldn't add balancing broker trade error condition %s" %
str(e))
return failure, instrument_order_id, contract_order_id, missing_order
try:
self.contract_stack.add_children_to_order_without_existing_children(
contract_order_id, [broker_order_id])
except Exception as e:
log.error("Couldn't add children to contract order exception %s" %
str(e))
return failure, instrument_order_id, contract_order_id, broker_order_id
log.msg("All balancing trades added to stacks")
return success, instrument_order_id, contract_order_id, broker_order_id
def cancel_order_on_stack(self, broker_order: brokerOrder):
log = broker_order.log_with_attributes(self.log)
matched_control_order = (
self.match_db_broker_order_to_control_order_from_brokers(broker_order))
if matched_control_order is missing_order:
log.warn("Couldn't cancel non existent order")
return None
self.cancel_order_given_control_object(matched_control_order)
log.msg("Sent cancellation for %s" % str(broker_order))
def create_balance_trade(self, broker_order: brokerOrder):
log = broker_order.log_with_attributes(self.log)
contract_order = create_balance_contract_order_from_broker_order(
broker_order)
instrument_order = create_balance_instrument_order_from_contract_order(
contract_order)
log.msg("Putting balancing trades on stacks")
(
result,
instrument_order_id,
contract_order_id,
broker_order_id,
) = self.put_balance_trades_on_stack(instrument_order, contract_order,
broker_order)
if result is failure:
log.error("Something went wrong, rolling back")
self.rollback_balance_trades(instrument_order_id,
contract_order_id, broker_order_id)
return None
contract_order.order_id = contract_order_id
instrument_order.order_id = instrument_order_id
log.msg("Updating positions")
self.apply_position_change_to_stored_contract_positions(
contract_order, contract_order.fill, apply_entire_trade=True)
self.apply_position_change_to_instrument(instrument_order,
instrument_order.fill,
apply_entire_trade=True)
log.msg(
"Marking balancing trades as completed and historic order data")
self.handle_completed_instrument_order(instrument_order_id,
treat_inactive_as_complete=True)
return success
def _send_broker_order_to_IB(self, broker_order: brokerOrder) -> tradeWithContract:
"""
:param broker_order: key properties are instrument_code, contract_id, quantity
:return: tradeWithContract object or missing_order
"""
log = broker_order.log_with_attributes(self.log)
log.msg("Going to submit order %s to IB" % str(broker_order))
trade_list = broker_order.trade
order_type = broker_order.order_type
limit_price = broker_order.limit_price
account = broker_order.broker_account
contract_object = broker_order.futures_contract
contract_object_with_ib_data = (
self.futures_contract_data.get_contract_object_with_IB_data(
contract_object
)
)
placed_broker_trade_object = self.ib_client.broker_submit_order(
contract_object_with_ib_data,
trade_list=trade_list,
account=account,
order_type=order_type,
limit_price=limit_price,
)
if placed_broker_trade_object is missing_order:
log.warn("Couldn't submit order")
return missing_order
log.msg("Order submitted to IB")
return placed_broker_trade_object
