cripsy_binary_api/broker/
historico.rs1use crate::broker::error::BrokerError;
23use crate::broker::trait_::Broker;
24use crate::domain::{Candle, CandleRequest};
25
26pub const VELAS_POR_PAGINA: usize = 1000;
28
29pub const PAGINAS_MAXIMAS: usize = 5_000;
31
32#[derive(Debug, Clone, PartialEq)]
34pub struct Ventana {
35 pub velas: Vec<Candle>,
37 pub paginas: usize,
39 pub completa: bool,
41 pub truncada: bool,
43 pub faltantes: usize,
46}
47
48pub fn ultimo_cierre(ahora: i64, intervalo: u64) -> i64 {
51 let paso = intervalo.max(1) as i64;
52 (ahora / paso) * paso - paso
53}
54
55pub fn paginas_estimadas(intervalo: u64, desde: i64, hasta: i64) -> usize {
57 if hasta <= desde {
58 return 0;
59 }
60 let paso = intervalo.max(1) as i64;
61 let velas = ((hasta - desde) as f64 / paso as f64).ceil().max(0.0) as usize;
62 velas.div_ceil(VELAS_POR_PAGINA)
63}
64
65pub async fn descargar(
69 broker: &dyn Broker,
70 simbolo: &str,
71 intervalo: u64,
72 desde: i64,
73 hasta: i64,
74) -> Result<Ventana, BrokerError> {
75 if intervalo == 0 {
76 return Err(BrokerError::Internal("intervalo de vela 0".into()));
77 }
78 if hasta <= desde {
79 return Ok(Ventana {
80 velas: Vec::new(),
81 paginas: 0,
82 completa: true,
83 truncada: false,
84 faltantes: 0,
85 });
86 }
87
88 let mut velas: Vec<Candle> = Vec::new();
89 let mut paginas = 0usize;
90 let mut to = hasta;
91 let mut truncada = false;
92
93 loop {
94 if paginas >= PAGINAS_MAXIMAS {
95 truncada = true;
96 break;
97 }
98 if to < desde {
99 break;
100 }
101 let request = CandleRequest {
102 symbol: simbolo.to_string(),
103 interval: intervalo,
104 count: VELAS_POR_PAGINA,
105 end_time: Some(to),
106 };
107 let pagina = broker.get_candles(request).await?;
108 paginas += 1;
109 if pagina.is_empty() {
110 break;
112 }
113
114 let antes = velas.len();
115 velas.extend(pagina.into_iter().filter(|v| v.from >= desde));
116 velas.sort_by_key(|v| v.from);
117 velas.dedup_by_key(|v| v.from);
118
119 let Some(mas_vieja) = velas.first().map(|v| v.from) else {
120 break;
121 };
122 if mas_vieja <= desde {
123 break;
124 }
125 if velas.len() == antes {
126 break;
128 }
129 to = mas_vieja - intervalo as i64;
132 }
133
134 let completa = velas.first().map(|v| v.from <= desde).unwrap_or(true);
135 let faltantes = faltantes(&velas, intervalo);
136 Ok(Ventana {
137 velas,
138 paginas,
139 completa,
140 truncada,
141 faltantes,
142 })
143}
144
145pub fn faltantes(velas: &[Candle], intervalo: u64) -> usize {
147 let (Some(primera), Some(ultima)) = (velas.first(), velas.last()) else {
148 return 0;
149 };
150 let paso = intervalo.max(1) as i64;
151 let esperadas = ((ultima.to - primera.from) / paso).max(0) as usize;
152 esperadas.saturating_sub(velas.len())
153}
154
155#[cfg(test)]
156mod tests {
157 use super::*;
158
159 fn vela(from: i64, precio: f64) -> Candle {
160 Candle {
161 from,
162 to: from + 1,
163 open: precio,
164 close: precio,
165 high: precio,
166 low: precio,
167 volume: Some(1.0),
168 }
169 }
170
171 #[test]
172 fn ultimo_cierre_excluye_la_vela_en_curso() {
173 assert_eq!(ultimo_cierre(1_000, 60), 900);
174 assert_eq!(ultimo_cierre(1_000, 1), 999);
175 assert_eq!(ultimo_cierre(120, 60), 60);
176 }
177
178 #[test]
179 fn paginas_estimadas_cubre_la_semana() {
180 assert_eq!(paginas_estimadas(1, 0, 7 * 86_400), 605);
181 assert_eq!(paginas_estimadas(1, 0, 7_200), 8);
182 assert_eq!(paginas_estimadas(60, 0, 3_600), 1);
183 assert_eq!(paginas_estimadas(1, 100, 100), 0);
184 assert_eq!(paginas_estimadas(1, 200, 100), 0);
185 }
186
187 #[test]
188 fn faltantes_detecta_un_hueco() {
189 let velas = vec![vela(0, 1.0), vela(1, 1.1), vela(4, 1.2)];
190 assert_eq!(faltantes(&velas, 1), 2);
191 assert_eq!(faltantes(&velas[..2], 1), 0);
192 assert_eq!(faltantes(&[], 1), 0);
193 }
194}