Skip to main content

openapi_rs/
spotware.rs

1use std::collections::HashMap;
2use std::pin::Pin;
3use std::sync::Arc;
4use std::sync::atomic::{AtomicU64, Ordering};
5
6use chrono::{DateTime, Duration, SecondsFormat, Utc};
7use ctrader_rs::proto::common::{
8    ProtoOaExecutionEvent, ProtoOaGetTrendbarsReq, ProtoOaGetTrendbarsRes, ProtoOaNewOrderReq,
9    ProtoOaOrderType, ProtoOaTradeSide, ProtoOaTrendbarPeriod,
10};
11use ctrader_rs::{Client as CtraderClient, Config as CtraderConfig};
12use futures_core::Stream;
13use rust_decimal::Decimal;
14use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
15use tokio::sync::Mutex as TokioMutex;
16use tonic::{Request, Response, Status};
17
18use crate::pb;
19use crate::{
20    AccountBalance, OpenApiError, OpenPosition, OrderSide, Timeframe, VolumeQuote,
21};
22
23const OA_NEW_ORDER_REQ: u32 = 2106;
24const OA_EXECUTION_EVENT: u32 = 2126;
25const OA_GET_TRENDBARS_REQ: u32 = 2137;
26const OA_GET_TRENDBARS_RES: u32 = 2138;
27
28#[derive(Debug, Clone)]
29pub struct SpotwareAdapterConfig {
30    pub client_id: String,
31    pub client_secret: String,
32    pub access_token: String,
33    pub trader_account_id: i64,
34    pub live: bool,
35    pub openapi_username: String,
36    pub openapi_password: String,
37}
38
39#[derive(Debug, Clone)]
40struct SpotwareSymbolMeta {
41    symbol_id: i64,
42    digits: i32,
43    lot_size_cents: i64,
44    min_volume_cents: i64,
45    max_volume_cents: i64,
46    step_volume_cents: i64,
47}
48
49#[derive(Debug, Clone)]
50struct SpotwareSession {
51    username: String,
52}
53
54pub struct SpotwareGrpcAdapterServer {
55    client: Arc<CtraderClient>,
56    trader_account_id: i64,
57    openapi_username: String,
58    openapi_password: String,
59    sessions: Arc<TokioMutex<HashMap<String, SpotwareSession>>>,
60    next_session_id: AtomicU64,
61    symbols: Arc<TokioMutex<HashMap<String, SpotwareSymbolMeta>>>,
62}
63
64impl SpotwareGrpcAdapterServer {
65    pub async fn connect(config: SpotwareAdapterConfig) -> Result<Self, OpenApiError> {
66        let mut client_cfg = CtraderConfig::new(config.client_id, config.client_secret);
67        if config.live {
68            client_cfg = client_cfg.live();
69        }
70
71        let client = CtraderClient::start(client_cfg)
72            .await
73            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware client start failed: {e}")))?;
74        client
75            .account_auth(config.trader_account_id, &config.access_token)
76            .await
77            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware account auth failed: {e}")))?;
78
79        let symbols = load_symbol_map(&client, config.trader_account_id).await?;
80
81        Ok(Self {
82            client: Arc::new(client),
83            trader_account_id: config.trader_account_id,
84            openapi_username: config.openapi_username,
85            openapi_password: config.openapi_password,
86            sessions: Arc::new(TokioMutex::new(HashMap::new())),
87            next_session_id: AtomicU64::new(1),
88            symbols: Arc::new(TokioMutex::new(symbols)),
89        })
90    }
91
92    pub fn into_tonic_service(self) -> pb::open_api_service_server::OpenApiServiceServer<Self> {
93        pb::open_api_service_server::OpenApiServiceServer::new(self)
94    }
95
96    async fn require_session(&self, token: &str) -> Result<(), OpenApiError> {
97        let sessions = self.sessions.lock().await;
98        if sessions.contains_key(token) {
99            Ok(())
100        } else {
101            Err(OpenApiError::SessionNotFound)
102        }
103    }
104
105    async fn resolve_symbol(&self, symbol: &str) -> Result<SpotwareSymbolMeta, OpenApiError> {
106        let symbols = self.symbols.lock().await;
107        let key = normalize_symbol(symbol);
108        symbols
109            .get(&key)
110            .cloned()
111            .ok_or_else(|| OpenApiError::SymbolNotFound(symbol.to_string()))
112    }
113
114    fn lot_constraints(meta: &SpotwareSymbolMeta) -> Result<(Decimal, Decimal, Decimal), OpenApiError> {
115        let lot_size = Decimal::from_i64(meta.lot_size_cents)
116            .ok_or_else(|| OpenApiError::GrpcStatus("invalid lot_size_cents".to_string()))?;
117        if lot_size <= Decimal::ZERO {
118            return Err(OpenApiError::GrpcStatus("lot_size_cents must be > 0".to_string()));
119        }
120
121        let min = Decimal::from_i64(meta.min_volume_cents)
122            .ok_or_else(|| OpenApiError::GrpcStatus("invalid min_volume_cents".to_string()))?
123            / lot_size;
124        let max = Decimal::from_i64(meta.max_volume_cents)
125            .ok_or_else(|| OpenApiError::GrpcStatus("invalid max_volume_cents".to_string()))?
126            / lot_size;
127        let step = Decimal::from_i64(meta.step_volume_cents)
128            .ok_or_else(|| OpenApiError::GrpcStatus("invalid step_volume_cents".to_string()))?
129            / lot_size;
130
131        Ok((min, max, step))
132    }
133
134    fn quote_for_lot(symbol: String, lot_size: Decimal, meta: &SpotwareSymbolMeta) -> Result<VolumeQuote, OpenApiError> {
135        if lot_size <= Decimal::ZERO {
136            return Err(OpenApiError::NonPositiveLotSize);
137        }
138
139        let (min_lot, max_lot, lot_step) = Self::lot_constraints(meta)?;
140        if lot_size < min_lot || lot_size > max_lot {
141            return Err(OpenApiError::LotOutOfRange {
142                lot_size,
143                min_lot,
144                max_lot,
145            });
146        }
147
148        let remainder = (lot_size - min_lot) % lot_step;
149        if !remainder.is_zero() {
150            return Err(OpenApiError::InvalidLotStep {
151                lot_size,
152                lot_step,
153                min_lot,
154            });
155        }
156
157        let contract_size = Decimal::from_i64(meta.lot_size_cents)
158            .ok_or_else(|| OpenApiError::GrpcStatus("invalid lot_size_cents".to_string()))?
159            / Decimal::new(100, 0);
160        Ok(VolumeQuote {
161            symbol,
162            lot_size,
163            volume: lot_size * contract_size,
164        })
165    }
166
167    fn lot_to_volume_cents(lot_size: Decimal, meta: &SpotwareSymbolMeta) -> Result<i64, OpenApiError> {
168        let lot_size_cents = Decimal::from_i64(meta.lot_size_cents)
169            .ok_or_else(|| OpenApiError::GrpcStatus("invalid lot_size_cents".to_string()))?;
170        let volume = lot_size * lot_size_cents;
171        volume
172            .to_i64()
173            .ok_or_else(|| OpenApiError::GrpcStatus("computed volume out of range".to_string()))
174    }
175
176    async fn fetch_balance_domain(&self) -> Result<AccountBalance, OpenApiError> {
177        let trader_res = self
178            .client
179            .get_trader(self.trader_account_id)
180            .await
181            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware get_trader failed: {e}")))?;
182
183        let trader = trader_res.trader;
184
185        let money_digits = trader.money_digits.unwrap_or(2) as u32;
186        let balance = Decimal::new(trader.balance, money_digits);
187
188        let reconcile = self
189            .client
190            .reconcile(self.trader_account_id, false)
191            .await
192            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware reconcile failed: {e}")))?;
193
194        let mut used_margin = Decimal::ZERO;
195        for position in reconcile.position {
196            if let Some(um) = position.used_margin {
197                let md = position.money_digits.unwrap_or(money_digits) as u32;
198                used_margin += Decimal::new(um as i64, md);
199            }
200        }
201
202        Ok(AccountBalance {
203            account_id: self.trader_account_id.to_string(),
204            balance,
205            used_margin,
206            free_margin: balance - used_margin,
207        })
208    }
209
210    async fn fetch_open_positions_domain(&self) -> Result<Vec<OpenPosition>, OpenApiError> {
211        let reconcile = self
212            .client
213            .reconcile(self.trader_account_id, false)
214            .await
215            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware reconcile failed: {e}")))?;
216
217        let symbols = self.symbols.lock().await;
218
219        let mut reverse = HashMap::new();
220        for (name, meta) in symbols.iter() {
221            reverse.insert(meta.symbol_id, name.clone());
222        }
223
224        let mut out = Vec::new();
225        for pos in reconcile.position {
226            let td = pos.trade_data;
227
228            let symbol = reverse
229                .get(&td.symbol_id)
230                .cloned()
231                .unwrap_or_else(|| td.symbol_id.to_string());
232
233            let side = match ProtoOaTradeSide::try_from(td.trade_side) {
234                Ok(ProtoOaTradeSide::Buy) => OrderSide::Buy,
235                Ok(ProtoOaTradeSide::Sell) => OrderSide::Sell,
236                _ => return Err(OpenApiError::UnsupportedOrderSide(td.trade_side)),
237            };
238
239            let volume_units = Decimal::new(td.volume, 2);
240            let lot_size = if let Some(meta) = symbols.get(&symbol) {
241                let denom = Decimal::from_i64(meta.lot_size_cents)
242                    .ok_or_else(|| OpenApiError::GrpcStatus("invalid lot_size_cents".to_string()))?;
243                Decimal::new(td.volume, 0) / denom
244            } else {
245                Decimal::ZERO
246            };
247
248            out.push(OpenPosition {
249                position_id: pos.position_id as u64,
250                account_id: self.trader_account_id.to_string(),
251                symbol,
252                lot_size,
253                volume: volume_units,
254                side,
255            });
256        }
257
258        Ok(out)
259    }
260
261    async fn get_candles_domain(
262        &self,
263        symbol: String,
264        timeframe: Timeframe,
265        from: DateTime<Utc>,
266        to: DateTime<Utc>,
267        limit: u32,
268    ) -> Result<Vec<crate::Candle>, OpenApiError> {
269        let meta = self.resolve_symbol(&symbol).await?;
270
271        let req = ProtoOaGetTrendbarsReq {
272            payload_type: Some(OA_GET_TRENDBARS_REQ as i32),
273            ctid_trader_account_id: self.trader_account_id,
274            from_timestamp: Some(from.timestamp_millis()),
275            to_timestamp: Some(to.timestamp_millis()),
276            period: spotware_period_from_timeframe(timeframe) as i32,
277            symbol_id: meta.symbol_id,
278            count: Some(limit),
279        };
280
281        let res: ProtoOaGetTrendbarsRes = self
282            .client
283            .command(OA_GET_TRENDBARS_REQ, req, OA_GET_TRENDBARS_RES)
284            .await
285            .map_err(|e| OpenApiError::GrpcStatus(format!("spotware get trendbars failed: {e}")))?;
286
287        let mut candles = Vec::new();
288        let step = timeframe_seconds(timeframe);
289        let scale = meta.digits as u32;
290        for bar in res.trendbar {
291            let low_raw = bar.low.unwrap_or_default();
292            let open_raw = low_raw + bar.delta_open.unwrap_or_default() as i64;
293            let close_raw = low_raw + bar.delta_close.unwrap_or_default() as i64;
294            let high_raw = low_raw + bar.delta_high.unwrap_or_default() as i64;
295
296            let open_time = DateTime::<Utc>::from_timestamp((bar.utc_timestamp_in_minutes.unwrap_or_default() as i64) * 60, 0)
297                .ok_or_else(|| OpenApiError::GrpcStatus("invalid trendbar timestamp".to_string()))?;
298            let close_time = open_time + Duration::seconds(step);
299
300            candles.push(crate::Candle {
301                symbol: symbol.clone(),
302                timeframe,
303                open_time,
304                close_time,
305                open: Decimal::new(open_raw, scale),
306                high: Decimal::new(high_raw, scale),
307                low: Decimal::new(low_raw, scale),
308                close: Decimal::new(close_raw, scale),
309                volume: Decimal::new(bar.volume, 0),
310            });
311        }
312
313        Ok(candles)
314    }
315}
316
317#[tonic::async_trait]
318impl pb::open_api_service_server::OpenApiService for SpotwareGrpcAdapterServer {
319    type StreamCandlesStream =
320        Pin<Box<dyn Stream<Item = Result<pb::StreamCandlesResponse, Status>> + Send + 'static>>;
321
322    async fn register_user(
323        &self,
324        _request: Request<pb::RegisterUserRequest>,
325    ) -> Result<Response<pb::RegisterUserResponse>, Status> {
326        Ok(Response::new(pb::RegisterUserResponse { success: true }))
327    }
328
329    async fn login(
330        &self,
331        request: Request<pb::LoginRequest>,
332    ) -> Result<Response<pb::LoginResponse>, Status> {
333        let req = request.into_inner();
334        if normalize_username(&req.username) != normalize_username(&self.openapi_username)
335            || req.password != self.openapi_password
336        {
337            return Err(Status::unauthenticated("invalid credentials"));
338        }
339
340        let id = self.next_session_id.fetch_add(1, Ordering::Relaxed);
341        let token = format!("spotware-sess-{id}");
342        self.sessions.lock().await.insert(
343            token.clone(),
344            SpotwareSession {
345                username: req.username,
346            },
347        );
348
349        Ok(Response::new(pb::LoginResponse {
350            session_token: token,
351        }))
352    }
353
354    async fn logout(
355        &self,
356        request: Request<pb::LogoutRequest>,
357    ) -> Result<Response<pb::LogoutResponse>, Status> {
358        let token = request.into_inner().session_token;
359        let removed = self.sessions.lock().await.remove(&token).is_some();
360        if !removed {
361            return Err(Status::unauthenticated("session token not found"));
362        }
363
364        Ok(Response::new(pb::LogoutResponse { success: true }))
365    }
366
367    async fn fetch_balance(
368        &self,
369        request: Request<pb::FetchBalanceRequest>,
370    ) -> Result<Response<pb::FetchBalanceResponse>, Status> {
371        let token = request.into_inner().session_token;
372        self.require_session(&token)
373            .await
374            .map_err(open_api_error_to_status)?;
375
376        let balance = self
377            .fetch_balance_domain()
378            .await
379            .map_err(open_api_error_to_status)?;
380
381        Ok(Response::new(pb::FetchBalanceResponse {
382            balance: Some(pb::AccountBalance {
383                account_id: balance.account_id,
384                balance: balance.balance.to_string(),
385                used_margin: balance.used_margin.to_string(),
386                free_margin: balance.free_margin.to_string(),
387            }),
388        }))
389    }
390
391    async fn fetch_open_positions(
392        &self,
393        request: Request<pb::FetchOpenPositionsRequest>,
394    ) -> Result<Response<pb::FetchOpenPositionsResponse>, Status> {
395        let token = request.into_inner().session_token;
396        self.require_session(&token)
397            .await
398            .map_err(open_api_error_to_status)?;
399
400        let positions = self
401            .fetch_open_positions_domain()
402            .await
403            .map_err(open_api_error_to_status)?;
404
405        Ok(Response::new(pb::FetchOpenPositionsResponse {
406            positions: positions
407                .into_iter()
408                .map(|p| pb::OpenPosition {
409                    position_id: p.position_id,
410                    account_id: p.account_id,
411                    symbol: p.symbol,
412                    lot_size: p.lot_size.to_string(),
413                    volume: p.volume.to_string(),
414                    side: match p.side {
415                        OrderSide::Buy => pb::OrderSide::Buy as i32,
416                        OrderSide::Sell => pb::OrderSide::Sell as i32,
417                    },
418                })
419                .collect(),
420        }))
421    }
422
423    async fn place_market_order(
424        &self,
425        request: Request<pb::PlaceMarketOrderRequest>,
426    ) -> Result<Response<pb::PlaceMarketOrderResponse>, Status> {
427        let req = request.into_inner();
428        self.require_session(&req.session_token)
429            .await
430            .map_err(open_api_error_to_status)?;
431
432        let lot_size = req
433            .lot_size
434            .parse::<Decimal>()
435            .map_err(|_| Status::invalid_argument("invalid lot_size"))?;
436        let symbol = normalize_symbol(req.symbol);
437        let meta = self
438            .resolve_symbol(&symbol)
439            .await
440            .map_err(open_api_error_to_status)?;
441
442        let quote = Self::quote_for_lot(symbol.clone(), lot_size, &meta)
443            .map_err(open_api_error_to_status)?;
444        let volume_cents = Self::lot_to_volume_cents(lot_size, &meta)
445            .map_err(open_api_error_to_status)?;
446
447        let side = match pb::OrderSide::try_from(req.side) {
448            Ok(pb::OrderSide::Buy) => ProtoOaTradeSide::Buy,
449            Ok(pb::OrderSide::Sell) => ProtoOaTradeSide::Sell,
450            _ => return Err(Status::invalid_argument("unsupported order side")),
451        };
452
453        let order_req = ProtoOaNewOrderReq {
454            payload_type: Some(OA_NEW_ORDER_REQ as i32),
455            ctid_trader_account_id: self.trader_account_id,
456            symbol_id: meta.symbol_id,
457            trade_side: side as i32,
458            volume: volume_cents,
459            order_type: ProtoOaOrderType::Market as i32,
460            ..Default::default()
461        };
462
463        let event: ProtoOaExecutionEvent = self
464            .client
465            .command(OA_NEW_ORDER_REQ, order_req, OA_EXECUTION_EVENT)
466            .await
467            .map_err(|e| Status::internal(format!("spotware new order failed: {e}")))?;
468
469        let order_id = event
470            .order
471            .as_ref()
472            .map(|o| o.order_id as u64)
473            .unwrap_or_default();
474
475        let margin_used = event
476            .position
477            .as_ref()
478            .and_then(|p| p.used_margin)
479            .map(|um| {
480                let md = event
481                    .position
482                    .as_ref()
483                    .and_then(|p| p.money_digits)
484                    .unwrap_or(2) as u32;
485                Decimal::new(um as i64, md)
486            })
487            .unwrap_or(Decimal::ZERO);
488
489        Ok(Response::new(pb::PlaceMarketOrderResponse {
490            execution: Some(pb::OrderExecution {
491                order_id,
492                account_id: self.trader_account_id.to_string(),
493                symbol,
494                lot_size: quote.lot_size.to_string(),
495                volume: quote.volume.to_string(),
496                side: req.side,
497                margin_used: margin_used.to_string(),
498            }),
499        }))
500    }
501
502    async fn quote_volume(
503        &self,
504        request: Request<pb::QuoteVolumeRequest>,
505    ) -> Result<Response<pb::QuoteVolumeResponse>, Status> {
506        let req = request.into_inner();
507        let lot_size = req
508            .lot_size
509            .parse::<Decimal>()
510            .map_err(|_| Status::invalid_argument("invalid lot_size"))?;
511        let symbol = normalize_symbol(req.symbol);
512        let meta = self
513            .resolve_symbol(&symbol)
514            .await
515            .map_err(open_api_error_to_status)?;
516
517        let quote = Self::quote_for_lot(symbol, lot_size, &meta).map_err(open_api_error_to_status)?;
518
519        Ok(Response::new(pb::QuoteVolumeResponse {
520            quote: Some(pb::VolumeQuote {
521                symbol: quote.symbol,
522                lot_size: quote.lot_size.to_string(),
523                volume: quote.volume.to_string(),
524            }),
525        }))
526    }
527
528    async fn get_candles(
529        &self,
530        request: Request<pb::GetCandlesRequest>,
531    ) -> Result<Response<pb::GetCandlesResponse>, Status> {
532        let req = request.into_inner();
533
534        let timeframe = pb_timeframe_to_domain(req.timeframe).map_err(open_api_error_to_status)?;
535        let limit = if req.limit == 0 { 100 } else { req.limit };
536        if limit > 2000 {
537            return Err(Status::invalid_argument("limit too large"));
538        }
539
540        let (from, to) = resolve_time_range(&req.from_time, &req.to_time, timeframe, limit)
541            .map_err(open_api_error_to_status)?;
542        let candles = self
543            .get_candles_domain(req.symbol, timeframe, from, to, limit)
544            .await
545            .map_err(open_api_error_to_status)?;
546
547        let out = candles
548            .into_iter()
549            .map(|c| pb::Candle {
550                symbol: c.symbol,
551                timeframe: domain_timeframe_to_pb(c.timeframe) as i32,
552                open_time: format_utc(c.open_time),
553                close_time: format_utc(c.close_time),
554                open: c.open.to_string(),
555                high: c.high.to_string(),
556                low: c.low.to_string(),
557                close: c.close.to_string(),
558                volume: c.volume.to_string(),
559            })
560            .collect();
561
562        Ok(Response::new(pb::GetCandlesResponse { candles: out }))
563    }
564
565    async fn stream_candles(
566        &self,
567        request: Request<pb::StreamCandlesRequest>,
568    ) -> Result<Response<Self::StreamCandlesStream>, Status> {
569        let req = request.into_inner();
570        let timeframe = pb_timeframe_to_domain(req.timeframe).map_err(open_api_error_to_status)?;
571        let limit = if req.limit == 0 { 100 } else { req.limit };
572        if limit > 2000 {
573            return Err(Status::invalid_argument("limit too large"));
574        }
575
576        let (from, to) = resolve_time_range(&req.from_time, &req.to_time, timeframe, limit)
577            .map_err(open_api_error_to_status)?;
578        let candles = self
579            .get_candles_domain(req.symbol, timeframe, from, to, limit)
580            .await
581            .map_err(open_api_error_to_status)?;
582
583        let stream = tokio_stream::iter(candles.into_iter().map(|c| {
584            Ok(pb::StreamCandlesResponse {
585                candle: Some(pb::Candle {
586                    symbol: c.symbol,
587                    timeframe: domain_timeframe_to_pb(c.timeframe) as i32,
588                    open_time: format_utc(c.open_time),
589                    close_time: format_utc(c.close_time),
590                    open: c.open.to_string(),
591                    high: c.high.to_string(),
592                    low: c.low.to_string(),
593                    close: c.close.to_string(),
594                    volume: c.volume.to_string(),
595                }),
596            })
597        }));
598
599        Ok(Response::new(Box::pin(stream) as Self::StreamCandlesStream))
600    }
601
602    async fn get_server_time(
603        &self,
604        _request: Request<pb::GetServerTimeRequest>,
605    ) -> Result<Response<pb::GetServerTimeResponse>, Status> {
606        Ok(Response::new(pb::GetServerTimeResponse {
607            server_time: format_utc(Utc::now()),
608        }))
609    }
610}
611
612async fn load_symbol_map(
613    client: &CtraderClient,
614    account_id: i64,
615) -> Result<HashMap<String, SpotwareSymbolMeta>, OpenApiError> {
616    let light = client
617        .symbols_list(account_id, false)
618        .await
619        .map_err(|e| OpenApiError::GrpcStatus(format!("spotware symbols_list failed: {e}")))?;
620
621    let mut name_to_id = HashMap::new();
622    let mut ids = Vec::new();
623    for s in light.symbol {
624        if let Some(name) = s.symbol_name {
625            let key = normalize_symbol(name);
626            name_to_id.insert(key, s.symbol_id);
627            ids.push(s.symbol_id);
628        }
629    }
630
631    let details_req = ctrader_rs::proto::common::ProtoOaSymbolByIdReq {
632        payload_type: Some(2116),
633        ctid_trader_account_id: account_id,
634        symbol_id: ids,
635    };
636
637    let details: ctrader_rs::proto::common::ProtoOaSymbolByIdRes = client
638        .command(2116, details_req.clone(), 2117)
639        .await
640        .map_err(|e| OpenApiError::GrpcStatus(format!("spotware symbol_by_id failed: {e}")))?;
641
642    let mut by_id = HashMap::new();
643    for s in details.symbol {
644        by_id.insert(s.symbol_id, s);
645    }
646
647    let mut out = HashMap::new();
648    for (name, symbol_id) in name_to_id {
649        if let Some(s) = by_id.get(&symbol_id) {
650            out.insert(
651                name,
652                SpotwareSymbolMeta {
653                    symbol_id,
654                    digits: s.digits,
655                    lot_size_cents: s.lot_size.unwrap_or(10_000_000),
656                    min_volume_cents: s.min_volume.unwrap_or(100_000),
657                    max_volume_cents: s.max_volume.unwrap_or(10_000_000_000),
658                    step_volume_cents: s.step_volume.unwrap_or(100_000),
659                },
660            );
661        }
662    }
663
664    Ok(out)
665}
666
667fn resolve_time_range(
668    from_time: &str,
669    to_time: &str,
670    timeframe: Timeframe,
671    limit: u32,
672) -> Result<(DateTime<Utc>, DateTime<Utc>), OpenApiError> {
673    let from_empty = from_time.trim().is_empty();
674    let to_empty = to_time.trim().is_empty();
675
676    let (from, to) = match (from_empty, to_empty) {
677        (true, true) => {
678            let to = Utc::now();
679            let from = to - Duration::seconds(timeframe_seconds(timeframe) * limit as i64);
680            (from, to)
681        }
682        (false, false) => (
683            parse_utc_timestamp_field("from_time", from_time)?,
684            parse_utc_timestamp_field("to_time", to_time)?,
685        ),
686        _ => {
687            return Err(OpenApiError::InvalidUtcTimestamp {
688                field: if from_empty { "from_time" } else { "to_time" },
689                value: if from_empty {
690                    from_time.to_string()
691                } else {
692                    to_time.to_string()
693                },
694            })
695        }
696    };
697
698    if from >= to {
699        return Err(OpenApiError::InvalidTimeRange {
700            from_time: format_utc(from),
701            to_time: format_utc(to),
702        });
703    }
704
705    Ok((from, to))
706}
707
708fn parse_utc_timestamp_field(field: &'static str, value: &str) -> Result<DateTime<Utc>, OpenApiError> {
709    let parsed = DateTime::parse_from_rfc3339(value).map_err(|_| OpenApiError::InvalidUtcTimestamp {
710        field,
711        value: value.to_string(),
712    })?;
713
714    if parsed.offset().local_minus_utc() != 0 {
715        return Err(OpenApiError::InvalidUtcTimestamp {
716            field,
717            value: value.to_string(),
718        });
719    }
720
721    Ok(parsed.with_timezone(&Utc))
722}
723
724fn format_utc(time: DateTime<Utc>) -> String {
725    time.to_rfc3339_opts(SecondsFormat::Secs, true)
726}
727
728fn normalize_symbol(symbol: impl Into<String>) -> String {
729    symbol.into().trim().to_ascii_uppercase()
730}
731
732fn normalize_username(username: impl Into<String>) -> String {
733    username.into().trim().to_ascii_lowercase()
734}
735
736fn pb_timeframe_to_domain(value: i32) -> Result<Timeframe, OpenApiError> {
737    match pb::Timeframe::try_from(value) {
738        Ok(pb::Timeframe::M1) => Ok(Timeframe::M1),
739        Ok(pb::Timeframe::M5) => Ok(Timeframe::M5),
740        Ok(pb::Timeframe::M15) => Ok(Timeframe::M15),
741        Ok(pb::Timeframe::H1) => Ok(Timeframe::H1),
742        Ok(pb::Timeframe::H4) => Ok(Timeframe::H4),
743        Ok(pb::Timeframe::D1) => Ok(Timeframe::D1),
744        _ => Err(OpenApiError::UnsupportedTimeframe(value)),
745    }
746}
747
748fn domain_timeframe_to_pb(value: Timeframe) -> pb::Timeframe {
749    match value {
750        Timeframe::M1 => pb::Timeframe::M1,
751        Timeframe::M5 => pb::Timeframe::M5,
752        Timeframe::M15 => pb::Timeframe::M15,
753        Timeframe::H1 => pb::Timeframe::H1,
754        Timeframe::H4 => pb::Timeframe::H4,
755        Timeframe::D1 => pb::Timeframe::D1,
756    }
757}
758
759fn timeframe_seconds(value: Timeframe) -> i64 {
760    match value {
761        Timeframe::M1 => 60,
762        Timeframe::M5 => 300,
763        Timeframe::M15 => 900,
764        Timeframe::H1 => 3600,
765        Timeframe::H4 => 14_400,
766        Timeframe::D1 => 86_400,
767    }
768}
769
770fn spotware_period_from_timeframe(value: Timeframe) -> ProtoOaTrendbarPeriod {
771    match value {
772        Timeframe::M1 => ProtoOaTrendbarPeriod::M1,
773        Timeframe::M5 => ProtoOaTrendbarPeriod::M5,
774        Timeframe::M15 => ProtoOaTrendbarPeriod::M15,
775        Timeframe::H1 => ProtoOaTrendbarPeriod::H1,
776        Timeframe::H4 => ProtoOaTrendbarPeriod::H4,
777        Timeframe::D1 => ProtoOaTrendbarPeriod::D1,
778    }
779}
780
781fn open_api_error_to_status(error: OpenApiError) -> Status {
782    match error {
783        OpenApiError::SymbolNotFound(_) => Status::not_found(error.to_string()),
784        OpenApiError::SessionNotFound => Status::unauthenticated(error.to_string()),
785        OpenApiError::InvalidCredentials => Status::unauthenticated(error.to_string()),
786        OpenApiError::UserAlreadyExists(_) | OpenApiError::AccountAlreadyExists(_) => {
787            Status::already_exists(error.to_string())
788        }
789        OpenApiError::InsufficientMargin { .. } => Status::failed_precondition(error.to_string()),
790        OpenApiError::GrpcStatus(_) => Status::internal(error.to_string()),
791        _ => Status::invalid_argument(error.to_string()),
792    }
793}