tradestation_api/
execution.rs1use serde::{Deserialize, Serialize};
14
15use crate::Client;
16use crate::Error;
17
18#[derive(Debug, Serialize)]
37#[serde(rename_all = "PascalCase")]
38pub struct OrderRequest {
39 pub account_id: String,
41 pub symbol: String,
43 pub quantity: String,
45 pub order_type: String,
47 pub trade_action: String,
49 pub time_in_force: TimeInForce,
51 #[serde(skip_serializing_if = "Option::is_none")]
53 pub limit_price: Option<String>,
54 #[serde(skip_serializing_if = "Option::is_none")]
56 pub stop_price: Option<String>,
57}
58
59#[derive(Debug, Serialize, Deserialize)]
64pub struct TimeInForce {
65 #[serde(rename = "Duration")]
67 pub duration: String,
68}
69
70impl TimeInForce {
71 pub fn day() -> Self {
73 Self {
74 duration: "DAY".to_string(),
75 }
76 }
77
78 pub fn gtc() -> Self {
80 Self {
81 duration: "GTC".to_string(),
82 }
83 }
84}
85
86#[derive(Debug, Serialize)]
101#[serde(rename_all = "PascalCase")]
102pub struct OrderGroupRequest {
103 #[serde(rename = "Type")]
105 pub group_type: String,
106 pub orders: Vec<OrderRequest>,
108}
109
110#[derive(Debug, Deserialize)]
112#[serde(rename_all = "PascalCase")]
113pub struct OrderResponse {
114 pub orders: Option<Vec<OrderConfirmation>>,
116 pub errors: Option<Vec<OrderError>>,
118}
119
120#[derive(Debug, Deserialize)]
122#[serde(rename_all = "PascalCase")]
123pub struct OrderConfirmation {
124 pub order_id: Option<String>,
126 pub message: Option<String>,
128}
129
130#[derive(Debug, Deserialize)]
132#[serde(rename_all = "PascalCase")]
133pub struct OrderError {
134 pub error: Option<String>,
136 pub message: Option<String>,
138}
139
140#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(rename_all = "PascalCase")]
145pub struct ActivationTrigger {
146 pub key: String,
148 pub name: String,
150 #[serde(default)]
152 pub description: Option<String>,
153}
154
155#[derive(Debug, Deserialize)]
157#[serde(rename_all = "PascalCase")]
158struct ActivationTriggersResponse {
159 activation_triggers: Vec<ActivationTrigger>,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(rename_all = "PascalCase")]
167pub struct Route {
168 pub id: String,
170 pub name: String,
172 #[serde(default)]
174 pub asset_types: Vec<String>,
175}
176
177#[derive(Debug, Deserialize)]
179#[serde(rename_all = "PascalCase")]
180struct RoutesResponse {
181 routes: Vec<Route>,
182}
183
184impl Client {
185 pub async fn place_order(&mut self, order: &OrderRequest) -> Result<OrderResponse, Error> {
191 let resp = self.post("/v3/orderexecution/orders", order).await?;
192 Ok(resp.json().await?)
193 }
194
195 pub async fn confirm_order(&mut self, order: &OrderRequest) -> Result<OrderResponse, Error> {
199 let resp = self.post("/v3/orderexecution/orderconfirm", order).await?;
200 Ok(resp.json().await?)
201 }
202
203 pub async fn cancel_order(&mut self, order_id: &str) -> Result<OrderResponse, Error> {
205 let resp = self
206 .delete(&format!("/v3/orderexecution/orders/{order_id}"))
207 .await?;
208 Ok(resp.json().await?)
209 }
210
211 pub async fn replace_order(
213 &mut self,
214 order_id: &str,
215 order: &OrderRequest,
216 ) -> Result<OrderResponse, Error> {
217 let resp = self
218 .put(&format!("/v3/orderexecution/orders/{order_id}"), order)
219 .await?;
220 Ok(resp.json().await?)
221 }
222
223 pub async fn place_order_group(
225 &mut self,
226 group: &OrderGroupRequest,
227 ) -> Result<OrderResponse, Error> {
228 let resp = self.post("/v3/orderexecution/ordergroups", group).await?;
229 Ok(resp.json().await?)
230 }
231
232 pub async fn confirm_order_group(
234 &mut self,
235 group: &OrderGroupRequest,
236 ) -> Result<OrderResponse, Error> {
237 let resp = self
238 .post("/v3/orderexecution/ordergroupconfirm", group)
239 .await?;
240 Ok(resp.json().await?)
241 }
242
243 pub async fn get_activation_triggers(&mut self) -> Result<Vec<ActivationTrigger>, Error> {
245 let resp = self.get("/v3/orderexecution/activationtriggers").await?;
246 let data: ActivationTriggersResponse = resp.json().await?;
247 Ok(data.activation_triggers)
248 }
249
250 pub async fn get_routes(&mut self) -> Result<Vec<Route>, Error> {
252 let resp = self.get("/v3/orderexecution/routes").await?;
253 let data: RoutesResponse = resp.json().await?;
254 Ok(data.routes)
255 }
256}