longport/trade/requests/
get_history_orders.rs

1use serde::Serialize;
2use time::OffsetDateTime;
3
4use crate::{
5    Market, serde_utils,
6    trade::{OrderSide, OrderStatus},
7};
8
9/// Options for get history orders request
10#[derive(Debug, Default, Serialize, Clone)]
11pub struct GetHistoryOrdersOptions {
12    #[serde(skip_serializing_if = "Option::is_none")]
13    symbol: Option<String>,
14    #[serde(skip_serializing_if = "<[_]>::is_empty")]
15    status: Vec<OrderStatus>,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    side: Option<OrderSide>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    market: Option<Market>,
20    #[serde(
21        skip_serializing_if = "Option::is_none",
22        with = "serde_utils::timestamp_opt"
23    )]
24    start_at: Option<OffsetDateTime>,
25    #[serde(
26        skip_serializing_if = "Option::is_none",
27        with = "serde_utils::timestamp_opt"
28    )]
29    end_at: Option<OffsetDateTime>,
30}
31
32impl GetHistoryOrdersOptions {
33    /// Create a new `GetHistoryOrdersOptions`
34    #[inline]
35    pub fn new() -> Self {
36        Default::default()
37    }
38
39    /// Set the security symbol
40    #[inline]
41    #[must_use]
42    pub fn symbol(self, symbol: impl Into<String>) -> Self {
43        Self {
44            symbol: Some(symbol.into()),
45            ..self
46        }
47    }
48
49    /// Set the order status
50    #[inline]
51    #[must_use]
52    pub fn status(self, status: impl IntoIterator<Item = OrderStatus>) -> Self {
53        Self {
54            status: status.into_iter().collect(),
55            ..self
56        }
57    }
58
59    /// Set the order side
60    #[inline]
61    #[must_use]
62    pub fn side(self, side: OrderSide) -> Self {
63        Self {
64            side: Some(side),
65            ..self
66        }
67    }
68
69    /// Set the market
70    #[inline]
71    #[must_use]
72    pub fn market(self, market: Market) -> Self {
73        Self {
74            market: Some(market),
75            ..self
76        }
77    }
78
79    /// Set the start time
80    #[inline]
81    #[must_use]
82    pub fn start_at(self, start_at: OffsetDateTime) -> Self {
83        Self {
84            start_at: Some(start_at),
85            ..self
86        }
87    }
88
89    /// Set the end time
90    #[inline]
91    #[must_use]
92    pub fn end_at(self, end_at: OffsetDateTime) -> Self {
93        Self {
94            end_at: Some(end_at),
95            ..self
96        }
97    }
98}