use std::{
collections::HashMap,
fmt::Display,
ops::{Deref, DerefMut},
};
use nautilus_core::{nanos::UnixNanos, uuid::UUID4};
use serde::{Deserialize, Serialize};
use ustr::Ustr;
use super::{
any::OrderAny,
base::{Order, OrderCore, OrderError},
};
use crate::{
enums::{
ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, TimeInForce,
TrailingOffsetType, TriggerType,
},
events::order::{OrderEventAny, OrderInitialized, OrderUpdated},
identifiers::{
AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
},
types::{price::Price, quantity::Quantity},
};
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(
feature = "python",
pyo3::pyclass(module = "nautilus_trader.core.nautilus_pyo3.model")
)]
pub struct StopLimitOrder {
pub price: Price,
pub trigger_price: Price,
pub trigger_type: TriggerType,
pub expire_time: Option<UnixNanos>,
pub is_post_only: bool,
pub display_qty: Option<Quantity>,
pub trigger_instrument_id: Option<InstrumentId>,
pub is_triggered: bool,
pub ts_triggered: Option<UnixNanos>,
core: OrderCore,
}
impl StopLimitOrder {
#[allow(clippy::too_many_arguments)]
pub fn new(
trader_id: TraderId,
strategy_id: StrategyId,
instrument_id: InstrumentId,
client_order_id: ClientOrderId,
order_side: OrderSide,
quantity: Quantity,
price: Price,
trigger_price: Price,
trigger_type: TriggerType,
time_in_force: TimeInForce,
expire_time: Option<UnixNanos>,
post_only: bool,
reduce_only: bool,
quote_quantity: bool,
display_qty: Option<Quantity>,
emulation_trigger: Option<TriggerType>,
trigger_instrument_id: Option<InstrumentId>,
contingency_type: Option<ContingencyType>,
order_list_id: Option<OrderListId>,
linked_order_ids: Option<Vec<ClientOrderId>>,
parent_order_id: Option<ClientOrderId>,
exec_algorithm_id: Option<ExecAlgorithmId>,
exec_algorithm_params: Option<HashMap<Ustr, Ustr>>,
exec_spawn_id: Option<ClientOrderId>,
tags: Option<Vec<Ustr>>,
init_id: UUID4,
ts_init: UnixNanos,
) -> Self {
let init_order = OrderInitialized::new(
trader_id,
strategy_id,
instrument_id,
client_order_id,
order_side,
OrderType::StopLimit,
quantity,
time_in_force,
post_only,
reduce_only,
quote_quantity,
false,
init_id,
ts_init,
ts_init,
Some(price),
Some(trigger_price),
Some(trigger_type),
None,
None,
None,
expire_time,
display_qty,
emulation_trigger,
trigger_instrument_id,
contingency_type,
order_list_id,
linked_order_ids,
parent_order_id,
exec_algorithm_id,
exec_algorithm_params,
exec_spawn_id,
tags,
);
Self {
core: OrderCore::new(init_order),
price,
trigger_price,
trigger_type,
expire_time,
is_post_only: post_only,
display_qty,
trigger_instrument_id,
is_triggered: false,
ts_triggered: None,
}
}
}
impl Deref for StopLimitOrder {
type Target = OrderCore;
fn deref(&self) -> &Self::Target {
&self.core
}
}
impl DerefMut for StopLimitOrder {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.core
}
}
impl PartialEq for StopLimitOrder {
fn eq(&self, other: &Self) -> bool {
self.client_order_id == other.client_order_id
}
}
impl Order for StopLimitOrder {
fn into_any(self) -> OrderAny {
OrderAny::StopLimit(self)
}
fn status(&self) -> OrderStatus {
self.status
}
fn trader_id(&self) -> TraderId {
self.trader_id
}
fn strategy_id(&self) -> StrategyId {
self.strategy_id
}
fn instrument_id(&self) -> InstrumentId {
self.instrument_id
}
fn symbol(&self) -> Symbol {
self.instrument_id.symbol
}
fn venue(&self) -> Venue {
self.instrument_id.venue
}
fn client_order_id(&self) -> ClientOrderId {
self.client_order_id
}
fn venue_order_id(&self) -> Option<VenueOrderId> {
self.venue_order_id
}
fn position_id(&self) -> Option<PositionId> {
self.position_id
}
fn account_id(&self) -> Option<AccountId> {
self.account_id
}
fn last_trade_id(&self) -> Option<TradeId> {
self.last_trade_id
}
fn side(&self) -> OrderSide {
self.side
}
fn order_type(&self) -> OrderType {
self.order_type
}
fn quantity(&self) -> Quantity {
self.quantity
}
fn time_in_force(&self) -> TimeInForce {
self.time_in_force
}
fn expire_time(&self) -> Option<UnixNanos> {
self.expire_time
}
fn price(&self) -> Option<Price> {
Some(self.price)
}
fn trigger_price(&self) -> Option<Price> {
Some(self.trigger_price)
}
fn trigger_type(&self) -> Option<TriggerType> {
Some(self.trigger_type)
}
fn liquidity_side(&self) -> Option<LiquiditySide> {
self.liquidity_side
}
fn is_post_only(&self) -> bool {
self.is_post_only
}
fn is_reduce_only(&self) -> bool {
self.is_reduce_only
}
fn is_quote_quantity(&self) -> bool {
self.is_quote_quantity
}
fn display_qty(&self) -> Option<Quantity> {
self.display_qty
}
fn limit_offset(&self) -> Option<Price> {
None
}
fn trailing_offset(&self) -> Option<Price> {
None
}
fn trailing_offset_type(&self) -> Option<TrailingOffsetType> {
None
}
fn emulation_trigger(&self) -> Option<TriggerType> {
self.emulation_trigger
}
fn trigger_instrument_id(&self) -> Option<InstrumentId> {
self.trigger_instrument_id
}
fn contingency_type(&self) -> Option<ContingencyType> {
self.contingency_type
}
fn order_list_id(&self) -> Option<OrderListId> {
self.order_list_id
}
fn linked_order_ids(&self) -> Option<&[ClientOrderId]> {
self.linked_order_ids.as_deref()
}
fn parent_order_id(&self) -> Option<ClientOrderId> {
self.parent_order_id
}
fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId> {
self.exec_algorithm_id
}
fn exec_algorithm_params(&self) -> Option<&HashMap<Ustr, Ustr>> {
self.exec_algorithm_params.as_ref()
}
fn exec_spawn_id(&self) -> Option<ClientOrderId> {
self.exec_spawn_id
}
fn tags(&self) -> Option<&[Ustr]> {
self.tags.as_deref()
}
fn filled_qty(&self) -> Quantity {
self.filled_qty
}
fn leaves_qty(&self) -> Quantity {
self.leaves_qty
}
fn avg_px(&self) -> Option<f64> {
self.avg_px
}
fn slippage(&self) -> Option<f64> {
self.slippage
}
fn init_id(&self) -> UUID4 {
self.init_id
}
fn ts_init(&self) -> UnixNanos {
self.ts_init
}
fn ts_last(&self) -> UnixNanos {
self.ts_last
}
fn events(&self) -> Vec<&OrderEventAny> {
self.events.iter().collect()
}
fn venue_order_ids(&self) -> Vec<&VenueOrderId> {
self.venue_order_ids.iter().collect()
}
fn trade_ids(&self) -> Vec<&TradeId> {
self.trade_ids.iter().collect()
}
fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
if let OrderEventAny::Updated(ref event) = event {
self.update(event);
};
let is_order_filled = matches!(event, OrderEventAny::Filled(_));
self.core.apply(event)?;
if is_order_filled {
self.core.set_slippage(self.price);
};
Ok(())
}
fn update(&mut self, event: &OrderUpdated) {
self.quantity = event.quantity;
if let Some(price) = event.price {
self.price = price;
}
if let Some(trigger_price) = event.trigger_price {
self.trigger_price = trigger_price;
}
self.quantity = event.quantity;
self.leaves_qty = self.quantity - self.filled_qty;
}
}
impl From<OrderAny> for StopLimitOrder {
fn from(order: OrderAny) -> StopLimitOrder {
match order {
OrderAny::StopLimit(order) => order,
_ => {
panic!(
"Invalid `OrderAny` not `{}`, was {order:?}",
stringify!(StopLimitOrder),
)
}
}
}
}
impl From<OrderInitialized> for StopLimitOrder {
fn from(event: OrderInitialized) -> Self {
Self::new(
event.trader_id,
event.strategy_id,
event.instrument_id,
event.client_order_id,
event.order_side,
event.quantity,
event
.price .expect("Error initializing order: `price` was `None` for `StopLimitOrder"),
event
.trigger_price .expect("Error initializing order: `trigger_price` was `None` for `StopLimitOrder"),
event
.trigger_type
.expect("Error initializing order: `trigger_type` was `None`"),
event.time_in_force,
event.expire_time,
event.post_only,
event.reduce_only,
event.quote_quantity,
event.display_qty,
event.emulation_trigger,
event.trigger_instrument_id,
event.contingency_type,
event.order_list_id,
event.linked_order_ids,
event.parent_order_id,
event.exec_algorithm_id,
event.exec_algorithm_params,
event.exec_spawn_id,
event.tags,
event.event_id,
event.ts_event,
)
}
}
impl Display for StopLimitOrder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"StopLimitOrder({} {} {} {} @ {}-STOP[{}] {}-LIMIT {}, status={}, client_order_id={}, venue_order_id={}, position_id={}, tags={})",
self.side,
self.quantity.to_formatted_string(),
self.instrument_id,
self.order_type,
self.trigger_price,
self.trigger_type,
self.price,
self.time_in_force,
self.status,
self.client_order_id,
self.venue_order_id.map_or("None".to_string(), |venue_order_id| format!("{venue_order_id}")),
self.position_id.map_or("None".to_string(), |position_id| format!("{position_id}")),
self.tags.clone().map_or("None".to_string(), |tags| tags.iter().map(|s| s.to_string()).collect::<Vec<String>>().join(", ")),
)
}
}