use crate::common::decimals::{Price, Volume};
use crate::common::errors::{ConnectorError, FixError};
use crate::common::ids::{OrderId, PositionId, SymbolId};
use crate::common::time::Timestamp;
use crate::fix::client::FixClient;
use crate::fix::messages::{
ExecType, ExecutionReport, Message, NewOrderSingle, OrderKind, OrderStatus, Side, TimeInForce,
};
const ORDER_PREFIX: &str = "o";
const TAG_ORDER_ID: u32 = 37;
const TAG_CL_ORD_ID: u32 = 11;
const TAG_SYMBOL: u32 = 55;
const TAG_SIDE: u32 = 54;
const TAG_ORDER_QTY: u32 = 38;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewOrder {
symbol: SymbolId,
side: Side,
quantity: Volume,
kind: OrderKind,
price: Option<Price>,
stop_price: Option<Price>,
expiry: Option<Timestamp>,
position: Option<PositionId>,
label: Option<String>,
}
impl NewOrder {
const fn new(symbol: SymbolId, side: Side, quantity: Volume, kind: OrderKind) -> Self {
Self {
symbol,
side,
quantity,
kind,
price: None,
stop_price: None,
expiry: None,
position: None,
label: None,
}
}
#[must_use]
pub const fn market(symbol: SymbolId, side: Side, quantity: Volume) -> Self {
Self::new(symbol, side, quantity, OrderKind::Market)
}
#[must_use]
pub const fn limit(symbol: SymbolId, side: Side, quantity: Volume, price: Price) -> Self {
let mut order = Self::new(symbol, side, quantity, OrderKind::Limit);
order.price = Some(price);
order
}
#[must_use]
pub const fn stop(symbol: SymbolId, side: Side, quantity: Volume, price: Price) -> Self {
let mut order = Self::new(symbol, side, quantity, OrderKind::Stop);
order.stop_price = Some(price);
order
}
#[must_use]
pub fn label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
#[must_use]
pub const fn position(mut self, position: PositionId) -> Self {
self.position = Some(position);
self
}
#[must_use]
pub const fn expires(mut self, at: Timestamp) -> Self {
self.expiry = Some(at);
self
}
#[must_use]
pub const fn kind(&self) -> OrderKind {
self.kind
}
fn message(&self, cl_ord_id: &str) -> NewOrderSingle {
NewOrderSingle {
cl_ord_id: cl_ord_id.to_owned(),
symbol: self.symbol,
side: self.side,
transact_time: Timestamp::now(),
order_qty: self.quantity,
ord_type: self.kind,
price: self.price,
stop_px: self.stop_price,
time_in_force: self.expiry.map(|_| TimeInForce::GoodTillDate),
expire_time: self.expiry,
position_id: self.position,
designation: self.label.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OrderReport {
pub order_id: OrderId,
pub cl_ord_id: String,
pub exec_type: ExecType,
pub status: OrderStatus,
pub symbol: SymbolId,
pub side: Side,
pub quantity: Volume,
pub kind: Option<OrderKind>,
pub price: Option<Price>,
pub stop_price: Option<Price>,
pub time_in_force: Option<TimeInForce>,
pub expiry: Option<Timestamp>,
pub filled: Option<Volume>,
pub remaining: Option<Volume>,
pub last_quantity: Option<Volume>,
pub average_price: Option<Price>,
pub position: Option<PositionId>,
pub label: Option<String>,
pub time: Option<Timestamp>,
pub text: Option<String>,
}
impl TryFrom<&ExecutionReport> for OrderReport {
type Error = FixError;
fn try_from(report: &ExecutionReport) -> Result<Self, FixError> {
let missing = |tag| FixError::MissingField {
msg_type: ExecutionReport::MSG_TYPE.to_owned(),
tag,
};
Ok(Self {
order_id: report.order_id.ok_or_else(|| missing(TAG_ORDER_ID))?,
cl_ord_id: report
.cl_ord_id
.clone()
.ok_or_else(|| missing(TAG_CL_ORD_ID))?,
exec_type: report.exec_type,
status: report.ord_status,
symbol: report.symbol.ok_or_else(|| missing(TAG_SYMBOL))?,
side: report.side.ok_or_else(|| missing(TAG_SIDE))?,
quantity: report.order_qty.ok_or_else(|| missing(TAG_ORDER_QTY))?,
kind: report.ord_type,
price: report.price,
stop_price: report.stop_px,
time_in_force: report.time_in_force,
expiry: report.expire_time,
filled: report.cum_qty,
remaining: report.leaves_qty,
last_quantity: report.last_qty,
average_price: report.avg_px,
position: report.position_id,
label: report.designation.clone(),
time: report.transact_time,
text: report.text.clone(),
})
}
}
pub(crate) fn refused(report: &ExecutionReport) -> ConnectorError {
FixError::OrderRejected {
cl_ord_id: report.cl_ord_id.clone(),
reason: report.ord_rej_reason,
text: report.text.clone(),
}
.into()
}
fn placed(
report: &ExecutionReport,
kind: OrderKind,
) -> Option<Result<OrderReport, ConnectorError>> {
match (report.exec_type, kind) {
(ExecType::New, OrderKind::Market) => None,
(ExecType::Rejected | ExecType::Canceled | ExecType::Expired, _) => {
Some(Err(refused(report)))
}
_ => Some(OrderReport::try_from(report).map_err(ConnectorError::from)),
}
}
impl FixClient {
pub async fn place(&self, order: NewOrder) -> Result<OrderReport, ConnectorError> {
let id = self.next_id(ORDER_PREFIX);
let kind = order.kind();
self.request_once(order.message(&id).into(), &id, |message| match message {
Message::ExecutionReport(report) if report.cl_ord_id.as_deref() == Some(&id) => {
placed(report, kind)
}
_ => None,
})
.await
}
}