use cxmr_currency::{Currency, CurrencyPair};
use super::Error;
#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
pub struct Order {
pub side: OrderSide,
pub rate: f64,
pub amount: f64,
}
impl Order {
pub fn is_bid(&self) -> bool {
match self.side {
OrderSide::Ask => false,
OrderSide::Bid => true,
}
}
pub fn total(&self) -> f64 {
self.rate * self.amount
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum OrderStatus {
New,
PartiallyFilled,
Filled,
Canceled,
PendingCancel,
Rejected,
Expired,
}
impl Default for OrderStatus {
fn default() -> Self {
OrderStatus::New
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum OrderType {
Limit,
Market,
StopLoss,
StopLossLimit,
TakeProfit,
TakeProfitLimit,
LimitMaker,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum OrderTime {
GoodTilCancel,
ImmediateOrCancel,
FillOrKill,
}
#[derive(Serialize, Deserialize, PartialEq, Clone)]
pub enum OrderSide {
Ask,
Bid,
}
impl std::convert::TryFrom<i64> for OrderSide {
type Error = Error;
fn try_from(k: i64) -> Result<Self, Self::Error> {
match k {
0 => Ok(OrderSide::Ask),
1 => Ok(OrderSide::Bid),
_ => Err(Error::InvalidOrderSideId(k)),
}
}
}
impl std::fmt::Debug for OrderSide {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
OrderSide::Ask => write!(f, "{}", "ASK"),
OrderSide::Bid => write!(f, "{}", "BID"),
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct ExchangeOrder {
pub id: Option<String>,
pub pair: CurrencyPair,
pub side: OrderSide,
pub kind: OrderType,
pub amount: u64,
pub rate: Option<u64>,
pub stop: Option<u64>,
pub time: OrderTime,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct OrderExecution {
pub status: OrderStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub rate: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub stop: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub executed: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fills: Option<Vec<OrderFill>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct OrderFill {
pub rate: u64,
pub amount: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub fee: Option<OrderFee>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct OrderFee {
pub amount: u64,
pub currency: Currency,
}
impl OrderFee {
pub fn new(amount: u64, currency: Currency) -> Self {
OrderFee {
amount: amount,
currency: currency,
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct MarketOrder {
pub id: String,
pub pair: CurrencyPair,
pub side: OrderSide,
pub kind: OrderType,
pub rate: u64,
pub stop: Option<u64>,
pub amount: u64,
pub time: OrderTime,
pub status: OrderStatus,
pub executed: Option<u64>,
pub created_at: u64,
pub updated_at: u64,
}