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}