tradestation_rs/responses/
execution.rs1use crate::{
2 execution::{ActivationTrigger, Order, OrderConfirmation},
3 Error, Route,
4};
5use serde::{Deserialize, Serialize};
6
7#[derive(Clone, Debug, Deserialize, Serialize)]
8#[serde(rename_all = "PascalCase")]
9pub struct OrderRespRaw {
12 orders: Option<Vec<Order>>,
14
15 error: Option<String>,
19
20 message: Option<String>,
24}
25#[derive(Debug)]
26pub struct OrderResp {
29 pub orders: Option<Vec<Order>>,
31
32 pub error: Option<Error>,
36}
37impl From<OrderRespRaw> for OrderResp {
38 fn from(raw: OrderRespRaw) -> Self {
39 let error_enum =
40 if let (Some(err), Some(msg)) = (raw.error.as_deref(), raw.message.as_deref()) {
41 Error::from_tradestation_api_error(err, msg)
42 } else {
43 None
44 };
45
46 OrderResp {
47 orders: raw.orders,
48 error: error_enum,
49 }
50 }
51}
52
53#[derive(Clone, Debug, Deserialize, Serialize)]
54#[serde(rename_all = "PascalCase")]
55pub struct ConfirmOrderRespRaw {
58 confirmations: Option<Vec<OrderConfirmation>>,
60 error: Option<String>,
64 message: Option<String>,
68}
69#[derive(Debug)]
70pub struct ConfirmOrderResp {
73 pub confirmations: Option<Vec<OrderConfirmation>>,
75 pub error: Option<Error>,
79}
80impl From<ConfirmOrderRespRaw> for ConfirmOrderResp {
81 fn from(raw: ConfirmOrderRespRaw) -> Self {
82 let error_enum =
83 if let (Some(err), Some(msg)) = (raw.error.as_deref(), raw.message.as_deref()) {
84 Error::from_tradestation_api_error(err, msg)
85 } else {
86 None
87 };
88
89 ConfirmOrderResp {
90 confirmations: raw.confirmations,
91 error: error_enum,
92 }
93 }
94}
95
96#[derive(Clone, Debug, Deserialize, Serialize)]
97#[serde(rename_all = "PascalCase")]
98pub struct GetExecutionRoutesRespRaw {
101 routes: Option<Vec<Route>>,
102 error: Option<String>,
106 message: Option<String>,
110}
111#[derive(Debug)]
112pub struct GetExecutionRoutesResp {
114 pub routes: Option<Vec<Route>>,
116 pub error: Option<Error>,
120}
121impl From<GetExecutionRoutesRespRaw> for GetExecutionRoutesResp {
122 fn from(raw: GetExecutionRoutesRespRaw) -> Self {
123 let error_enum =
124 if let (Some(err), Some(msg)) = (raw.error.as_deref(), raw.message.as_deref()) {
125 Error::from_tradestation_api_error(err, msg)
126 } else {
127 None
128 };
129
130 GetExecutionRoutesResp {
131 routes: raw.routes,
132 error: error_enum,
133 }
134 }
135}
136
137#[derive(Clone, Debug, Deserialize, Serialize)]
138#[serde(rename_all = "PascalCase")]
139pub struct GetActivationTriggersRespRaw {
142 activation_triggers: Option<Vec<ActivationTrigger>>,
144
145 error: Option<String>,
149
150 message: Option<String>,
154}
155#[derive(Debug)]
156pub struct GetActivationTriggersResp {
158 pub activation_triggers: Option<Vec<ActivationTrigger>>,
160
161 pub error: Option<Error>,
165}
166impl From<GetActivationTriggersRespRaw> for GetActivationTriggersResp {
167 fn from(raw: GetActivationTriggersRespRaw) -> Self {
168 let error_enum =
169 if let (Some(err), Some(msg)) = (raw.error.as_deref(), raw.message.as_deref()) {
170 Error::from_tradestation_api_error(err, msg)
171 } else {
172 None
173 };
174
175 GetActivationTriggersResp {
176 activation_triggers: raw.activation_triggers,
177 error: error_enum,
178 }
179 }
180}