Skip to main content

aylis_core/
date.rs

1//! As datas e as horas do calendário (sem fuso): o `DateEdit`, o `Calendar` e o acesso
2//! tipado as usam, e o `aylis-data` também (os campos de data dos datasets).
3
4use std::fmt;
5
6/// Data do calendário (sem fuso).
7#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
8pub struct Date {
9    year: i32,
10    month: u8,
11    day: u8,
12}
13
14impl Date {
15    /// `None` se a data não existir (31/02, mês 13...).
16    pub fn new(year: i32, month: u8, day: u8) -> Option<Date> {
17        (1..=12).contains(&month).then_some(())?;
18        (day >= 1 && day <= days_in_month(year, month)).then_some(Date { year, month, day })
19    }
20
21    pub fn year(&self) -> i32 {
22        self.year
23    }
24
25    pub fn month(&self) -> u8 {
26        self.month
27    }
28
29    pub fn day(&self) -> u8 {
30        self.day
31    }
32
33    /// Dias desde 1970-01-01 (negativos antes).
34    pub fn to_days(&self) -> i64 {
35        let (y, m, d) = (self.year as i64 - i64::from(self.month <= 2), self.month as i64, self.day as i64);
36        let era = y.div_euclid(400);
37        let yoe = y - era * 400;
38        let doy = (153 * (m + if m > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;
39        era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468
40    }
41
42    /// A data `days` dias depois de 1970-01-01.
43    pub fn from_days(days: i64) -> Option<Date> {
44        let z = days + 719_468;
45        let era = z.div_euclid(146_097);
46        let doe = z - era * 146_097;
47        let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
48        let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
49        let mp = (5 * doy + 2) / 153;
50        let d = (doy - (153 * mp + 2) / 5 + 1) as u8;
51        let m = if mp < 10 { mp + 3 } else { mp - 9 } as u8;
52        let y = yoe + era * 400 + i64::from(m <= 2);
53        Date::new(i32::try_from(y).ok()?, m, d)
54    }
55
56    /// Hoje, no horário local: em Brasília, às 22h ainda é hoje.
57    pub fn today() -> Date {
58        DateTime::now().date
59    }
60
61    /// Lê `yyyy-mm-dd`.
62    pub fn parse_iso(text: &str) -> Option<Date> {
63        let mut parts = text.trim().splitn(3, '-');
64        let y = parts.next()?.parse().ok()?;
65        let m = parts.next()?.parse().ok()?;
66        let d = parts.next()?.parse().ok()?;
67        Date::new(y, m, d)
68    }
69}
70
71impl fmt::Display for Date {
72    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73        write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
74    }
75}
76
77pub fn is_leap_year(year: i32) -> bool {
78    (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
79}
80
81pub fn days_in_month(year: i32, month: u8) -> u8 {
82    match month {
83        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
84        4 | 6 | 9 | 11 => 30,
85        2 if is_leap_year(year) => 29,
86        2 => 28,
87        _ => 0,
88    }
89}
90
91/// Hora do dia.
92#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
93pub struct Time {
94    hour: u8,
95    minute: u8,
96    second: u8,
97    millisecond: u16,
98}
99
100impl Time {
101    pub fn new(hour: u8, minute: u8, second: u8) -> Option<Time> {
102        Self::with_millis(hour, minute, second, 0)
103    }
104
105    pub fn with_millis(hour: u8, minute: u8, second: u8, millisecond: u16) -> Option<Time> {
106        (hour < 24 && minute < 60 && second < 60 && millisecond < 1000).then_some(Time { hour, minute, second, millisecond })
107    }
108
109    pub fn hour(&self) -> u8 {
110        self.hour
111    }
112
113    pub fn minute(&self) -> u8 {
114        self.minute
115    }
116
117    pub fn second(&self) -> u8 {
118        self.second
119    }
120
121    pub fn millisecond(&self) -> u16 {
122        self.millisecond
123    }
124
125    /// Lê `hh:nn`, `hh:nn:ss` ou `hh:nn:ss.fff` (sem fuso; veja [`DateTime::parse_iso`]).
126    pub fn parse_iso(text: &str) -> Option<Time> {
127        let mut parts = text.trim().split(':');
128        let h = parts.next()?.parse().ok()?;
129        let m = parts.next()?.parse().ok()?;
130        let (s, ms) = match parts.next() {
131            None => (0, 0),
132            Some(s) => {
133                let (whole, frac) = s.split_once('.').unwrap_or((s, ""));
134                // Os três primeiros dígitos da fração (o resto não cabe em milissegundos).
135                let digits: String = frac.chars().take(3).collect();
136                let ms = if digits.is_empty() { 0 } else { format!("{digits:0<3}").parse().ok()? };
137                (whole.parse().ok()?, ms)
138            }
139        };
140        if parts.next().is_some() {
141            return None;
142        }
143        Time::with_millis(h, m, s, ms)
144    }
145
146    fn seconds_of_day(&self) -> i64 {
147        self.hour as i64 * 3600 + self.minute as i64 * 60 + self.second as i64
148    }
149}
150
151impl fmt::Display for Time {
152    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
153        write!(f, "{:02}:{:02}:{:02}", self.hour, self.minute, self.second)
154    }
155}
156
157/// Data e hora.
158#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
159pub struct DateTime {
160    pub date: Date,
161    pub time: Time,
162}
163
164impl DateTime {
165    pub fn new(date: Date, time: Time) -> Self {
166        Self { date, time }
167    }
168
169    /// Lê `yyyy-mm-ddThh:nn:ss` (ou com espaço no lugar do `T`, com fração de segundo). Com
170    /// fuso (`Z`, `-03:00`, `+0530`), o instante vira o horário local desta tela: um backend
171    /// que manda `13:00:00Z` mostra 10:00 em Brasília. O fuso nunca é ignorado.
172    pub fn parse_iso(text: &str) -> Option<DateTime> {
173        let text = text.trim();
174        let (d, t) = text.split_once(['T', ' ']).unwrap_or((text, "00:00:00"));
175        let (t, offset) = split_offset(t)?;
176        let local = DateTime { date: Date::parse_iso(d)?, time: Time::parse_iso(t)? };
177        match offset {
178            None => Some(local),
179            Some(offset) => DateTime::from_unix_local(local.to_unix() - offset, local.time.millisecond()),
180        }
181    }
182
183    /// Segundos desde 1970, lendo esta data e hora como se fosse UTC.
184    pub fn to_unix(&self) -> i64 {
185        self.date.to_days() * 86_400 + self.time.seconds_of_day()
186    }
187
188    /// A data e a hora (sem fuso) de `secs` segundos desde 1970.
189    pub fn from_unix(secs: i64, millisecond: u16) -> Option<DateTime> {
190        let date = Date::from_days(secs.div_euclid(86_400))?;
191        let s = secs.rem_euclid(86_400);
192        let time = Time::with_millis((s / 3600) as u8, (s / 60 % 60) as u8, (s % 60) as u8, millisecond)?;
193        Some(DateTime { date, time })
194    }
195
196    /// O instante `utc` (segundos desde 1970) no horário local desta tela (com horário de
197    /// verão, pelo sistema; sem a plataforma, como nos testes, o local é o UTC).
198    pub fn from_unix_local(utc: i64, millisecond: u16) -> Option<DateTime> {
199        DateTime::from_unix(utc + crate::platform::local_offset(utc), millisecond)
200    }
201
202    /// Agora, no horário local.
203    pub fn now() -> DateTime {
204        let since = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).unwrap_or_default();
205        DateTime::from_unix_local(since.as_secs() as i64, since.subsec_millis() as u16).expect("o relógio do sistema dá uma data válida")
206    }
207}
208
209/// Separa o fuso do fim da hora: `"10:00:00-03:00"` → (`"10:00:00"`, −10800 segundos);
210/// `Z` é o UTC; sem fuso, `None`. `None` no todo se o fuso for inválido.
211#[doc(hidden)]
212pub fn split_offset(time: &str) -> Option<(&str, Option<i64>)> {
213    if let Some(t) = time.strip_suffix(['Z', 'z']) {
214        return Some((t, Some(0)));
215    }
216    // O sinal do fuso vem depois dos dois-pontos da hora (não confunde com nada antes).
217    let Some(at) = time.rfind(['+', '-']).filter(|&i| i > 0) else { return Some((time, None)) };
218    let (t, zone) = time.split_at(at);
219    let sign = if zone.starts_with('-') { -1 } else { 1 };
220    let digits: String = zone[1..].chars().filter(|c| *c != ':').collect();
221    let (h, m) = match digits.len() {
222        2 => (digits.parse::<i64>().ok()?, 0),
223        4 => (digits[..2].parse::<i64>().ok()?, digits[2..].parse::<i64>().ok()?),
224        _ => return None,
225    };
226    (h <= 14 && m < 60).then_some((t, Some(sign * (h * 3600 + m * 60))))
227}
228
229impl fmt::Display for DateTime {
230    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
231        write!(f, "{}T{}", self.date, self.time)
232    }
233}