1use crate::client::Client;
2use crate::errors::*;
3use crate::model;
4use rust_decimal::Decimal;
5
6#[derive(Clone)]
7pub struct OrdersClient {
8 client: Client,
9}
10
11impl OrdersClient {
12 pub fn new(api_key: Option<String>, secret_key: Option<String>) -> Self {
13 OrdersClient {
14 client: Client::new(api_key, secret_key),
15 }
16 }
17
18 pub fn get_open_orders<S>(&self, symbol: S) -> Result<Vec<model::OrderInfo>>
19 where
20 S: Into<String>,
21 {
22 let payload: String = format!("{}", "{}");
23 let endpoint = format!("/orders?market={}", symbol.into());
24 let data = self.client.get_signed(endpoint.into(), payload, None)?;
25
26 let open_orders: model::ResultData<Vec<model::OrderInfo>> =
27 serde_json::from_str(data.as_str())?;
28 Ok(open_orders.result)
29 }
30
31 pub fn get_order_history<S>(
32 &self,
33 symbol: S,
34 side: Option<String>,
35 order_type: String,
36 start_time: i64,
37 end_time: i64,
38 ) -> Result<model::ResultData<Vec<model::OrderInfo>>>
39 where
40 S: Into<String>,
41 {
42 let mut payload =
43 json!({ "orderType": order_type, "start_time": start_time, "end_time": end_time });
44 if let Some(s) = side {
45 payload = json!({ "side": s, "orderType": order_type, "start_time": start_time, "end_time": end_time });
46 }
47 let endpoint = format!("/orders/history?market={}", symbol.into());
48 let data = self
49 .client
50 .get_signed(endpoint.into(), payload.to_string(), None)?;
51 let history_orders: model::ResultData<Vec<model::OrderInfo>> =
52 serde_json::from_str(data.as_str())?;
53 Ok(history_orders)
54 }
55
56 pub fn get_open_trigger_orders<S>(
57 &self,
58 symbol: S,
59 option_type: Option<String>,
60 ) -> Result<Vec<model::TriggerOrderInfo>>
61 where
62 S: Into<String>,
63 {
64 let mut payload: String = format!("{}", "{}");
65 if let Some(t) = option_type {
66 payload = json!({ "type": t }).to_string();
67 }
68 let endpoint = format!("/conditional_orders?market={}", symbol.into());
69 let data = self
70 .client
71 .get_signed(endpoint.into(), payload.to_string(), None)?;
72 let trigger_orders: model::ResultData<Vec<model::TriggerOrderInfo>> =
73 serde_json::from_str(data.as_str())?;
74 Ok(trigger_orders.result)
75 }
76
77 pub fn place_order<S>(
78 &self,
79 symbol: S,
80 side: String,
81 price: Decimal,
82 option_type: String,
83 size: Decimal,
84 reduce_only: bool,
85 ioc: bool,
86 post_only: bool,
87 client_id: Option<String>,
88 reject_on_price_band: bool,
89 ) -> Result<model::OrderInfo>
90 where
91 S: Into<String>,
92 {
93 let payload = json!({
94 "market": symbol.into(),
95 "side": side,
96 "price": price,
97 "type": option_type,
98 "size": size,
99 "reduceOnly": reduce_only,
100 "ioc": ioc,
101 "postOnly": post_only,
102 "clientId": client_id,
103 "rejectOnPriceBand": reject_on_price_band
104 });
105 let data = self
106 .client
107 .post_signed("/orders".into(), payload.to_string(), None)?;
108 let order: model::ResultData<model::OrderInfo> = serde_json::from_str(data.as_str())?;
109 Ok(order.result)
110 }
111
112 pub fn modify_order(
113 &self,
114 order_id: i64,
115 price: Decimal,
116 size: Decimal,
117 client_id: Option<String>,
118 ) -> Result<model::OrderInfo> {
119 let mut payload = json!({
120 "price": price,
121 "size": size,
122 });
123 if let Some(c) = client_id {
124 payload = json!({
125 "price": price,
126 "size": size,
127 "clientId": c,
128 });
129 }
130 let endpoint = format!("/orders/{}/modify", order_id);
131 let data = self
132 .client
133 .post_signed(endpoint.into(), payload.to_string(), None)?;
134 let order: model::ResultData<model::OrderInfo> = serde_json::from_str(data.as_str())?;
135 Ok(order.result)
136 }
137
138 pub fn modify_order_by_client_id(
139 &self,
140 client_id: String,
141 price: Decimal,
142 size: Decimal,
143 ) -> Result<model::OrderInfo> {
144 let payload = json!({
145 "price": price,
146 "size": size,
147 });
148 let endpoint = format!("/orders/by_client_id/{}/modify", client_id);
149 let data = self
150 .client
151 .post_signed(endpoint.into(), payload.to_string(), None)?;
152 let order: model::ResultData<model::OrderInfo> = serde_json::from_str(data.as_str())?;
153 Ok(order.result)
154 }
155
156 pub fn get_order_status(&self, order_id: i64) -> Result<model::OrderInfo> {
157 let payload: String = format!("{}", "{}");
158 let endpoint = format!("/orders/{}", order_id);
159 let data = self.client.get_signed(endpoint.into(), payload, None)?;
160 let order: model::ResultData<model::OrderInfo> = serde_json::from_str(data.as_str())?;
161 Ok(order.result)
162 }
163
164 pub fn get_order_status_by_client_id(&self, client_id: String) -> Result<model::OrderInfo> {
165 let payload: String = format!("{}", "{}");
166 let endpoint = format!("/orders/by_client_id/{}", client_id);
167 let data = self.client.get_signed(endpoint.into(), payload, None)?;
168 let order: model::ResultData<model::OrderInfo> = serde_json::from_str(data.as_str())?;
169 Ok(order.result)
170 }
171
172 pub fn cancel_order(&self, order_id: i64) -> Result<bool> {
173 let payload: String = format!("{}", "{}");
174 let endpoint = format!("/orders/{}", order_id);
175 let data = self.client.delete_signed(endpoint.into(), payload, None)?;
176 let result: model::ResultData<String> = serde_json::from_str(data.as_str())?;
177 Ok(result.success)
178 }
179
180 pub fn cancel_order_by_client_id(&self, client_id: String) -> Result<bool> {
181 let payload: String = format!("{}", "{}");
182 let endpoint = format!("/orders/by_client_id/{}", client_id);
183 let data = self.client.delete_signed(endpoint.into(), payload, None)?;
184 println!("{:?}", data);
185 let result: model::ResultData<String> = serde_json::from_str(data.as_str())?;
186 Ok(result.success)
187 }
188
189 pub fn cancel_all_orders<S>(
190 &self,
191 symbol: S,
192 side: Option<String>,
193 conditional_orders_only: bool,
194 limit_orders_only: bool,
195 ) -> Result<bool>
196 where
197 S: Into<String> + Copy,
198 {
199 let mut payload = json!({
200 "market": &symbol.into(),
201 "conditionalOrdersOnly": conditional_orders_only,
202 "limitOrdersOnly": limit_orders_only,
203 });
204 if let Some(s) = side {
205 payload = json!({
206 "market": &symbol.into(),
207 "side": s,
208 "conditionalOrdersOnly": conditional_orders_only,
209 "limitOrdersOnly": limit_orders_only,
210 });
211 }
212 let data = self
213 .client
214 .delete_signed("/orders".into(), payload.to_string(), None)?;
215 let result: model::ResultData<String> = serde_json::from_str(data.as_str())?;
216 Ok(result.success)
217 }
218}