//! Mesures de pluviométrie : saisie, liste, graphique et cumuls mensuels. pub mod graph; use chrono::NaiveDate; use leptos::prelude::*; use serde::{Deserialize, Serialize}; pub use graph::{GraphPoint, MonthlySummary, Period}; use crate::errors::field_error; #[cfg(feature = "ssr")] use crate::server; /// Taille d'une page de la liste des mesures (comme le `paginate(15)` de Laravel). pub const PAGE_SIZE: i64 = 15; pub const VALUE_MIN: i64 = 1; pub const VALUE_MAX: i64 = 1000; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct Rainfall { pub id: i64, /// AAAA-MM-JJ pub date: String, /// Hauteur d'eau en mm. pub value: i64, } impl Rainfall { /// Date au format français (JJ/MM/AAAA). pub fn date_fr(&self) -> String { format_date_fr(&self.date) } } pub fn format_date_fr(date: &str) -> String { NaiveDate::parse_from_str(date, "%Y-%m-%d") .map(|d| d.format("%d/%m/%Y").to_string()) .unwrap_or_else(|_| date.to_string()) } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct RainfallPage { pub items: Vec, pub total: i64, } /// Date du jour (fuseau du serveur côté SSR, du navigateur côté client). pub fn today() -> NaiveDate { chrono::Local::now().date_naive() } /// Lit une date `AAAA-MM-JJ` (format des ``). pub fn parse_date(field: &str, value: &str) -> Result { NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d") .ok() .filter(|d| (1900..=2200).contains(&chrono::Datelike::year(d))) .ok_or_else(|| field_error(field, "Veuillez saisir une date valide.")) } /// Lit une hauteur d'eau entière entre 1 et 1000 mm. pub fn parse_value(value: &str) -> Result { let message = format!("La mesure doit être un nombre entier entre {VALUE_MIN} et {VALUE_MAX}."); let number: i64 = value .trim() .parse() .map_err(|_| field_error("value", message.clone()))?; if !(VALUE_MIN..=VALUE_MAX).contains(&number) { return Err(field_error("value", message)); } Ok(number) } #[server] pub async fn add_rainfall(date: String, value: String) -> Result<(), ServerFnError> { let user_id = server::require_user_id().await?; let date = parse_date("date", &date)?; let value = parse_value(&value)?; sqlx::query("INSERT INTO rainfalls (user_id, date, value) VALUES (?1, ?2, ?3)") .bind(user_id) .bind(date.format("%Y-%m-%d").to_string()) .bind(value) .execute(&server::pool()?) .await .map_err(server::internal_error)?; Ok(()) } #[server] pub async fn update_rainfall(id: i64, date: String, value: String) -> Result<(), ServerFnError> { let user_id = server::require_user_id().await?; let date = parse_date("date", &date)?; let value = parse_value(&value)?; let done = sqlx::query( "UPDATE rainfalls SET date = ?1, value = ?2, updated_at = CURRENT_TIMESTAMP \ WHERE id = ?3 AND user_id = ?4", ) .bind(date.format("%Y-%m-%d").to_string()) .bind(value) .bind(id) .bind(user_id) .execute(&server::pool()?) .await .map_err(server::internal_error)?; if done.rows_affected() == 0 { return Err(ServerFnError::new("Mesure introuvable.")); } Ok(()) } #[server] pub async fn delete_rainfall(id: i64) -> Result<(), ServerFnError> { let user_id = server::require_user_id().await?; sqlx::query("DELETE FROM rainfalls WHERE id = ?1 AND user_id = ?2") .bind(id) .bind(user_id) .execute(&server::pool()?) .await .map_err(server::internal_error)?; Ok(()) } /// Les `limit` mesures les plus récentes, et le nombre total de mesures. #[server] pub async fn list_rainfalls(limit: i64) -> Result { let user_id = server::require_user_id().await?; let pool = server::pool()?; let items = sqlx::query_as::<_, (i64, String, i64)>( "SELECT id, date, value FROM rainfalls WHERE user_id = ?1 ORDER BY date DESC, id DESC LIMIT ?2", ) .bind(user_id) .bind(limit.clamp(1, 10_000)) .fetch_all(&pool) .await .map_err(server::internal_error)? .into_iter() .map(|(id, date, value)| Rainfall { id, date, value }) .collect(); let total = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM rainfalls WHERE user_id = ?1") .bind(user_id) .fetch_one(&pool) .await .map_err(server::internal_error)?; Ok(RainfallPage { items, total }) } /// Cumuls à afficher dans le graphique de la page Pluviométrie. #[server] pub async fn graph_data( start: String, end: String, period: String, ) -> Result, ServerFnError> { use std::collections::HashMap; let user_id = server::require_user_id().await?; let start = parse_date("start", &start)?; let end = parse_date("end", &end)?; let period = Period::parse(&period).ok_or_else(|| field_error("period", "Période invalide."))?; if end < start { return Err(field_error( "end", "La date de fin doit être postérieure à la date de début.", )); } if (end - start).num_days() > period.max_days() { return Err(field_error( "start", "Intervalle trop long pour ce regroupement : choisissez une période plus courte ou un regroupement plus large.", )); } let rows = sqlx::query_as::<_, (String, i64)>( "SELECT date, SUM(value) FROM rainfalls \ WHERE user_id = ?1 AND date BETWEEN ?2 AND ?3 GROUP BY date", ) .bind(user_id) .bind(start.format("%Y-%m-%d").to_string()) .bind(end.format("%Y-%m-%d").to_string()) .fetch_all(&server::pool()?) .await .map_err(server::internal_error)?; let daily: HashMap = rows .into_iter() .filter_map(|(date, sum)| Some((NaiveDate::parse_from_str(&date, "%Y-%m-%d").ok()?, sum))) .collect(); Ok(graph::group(start, end, period, &daily)) } /// Nombre maximal d'années précédentes affichées sur l'accueil (une couleur de série /// chacune, en plus de l'année en cours). pub const MAX_YEARS_BACK: u32 = 7; /// Cumuls mensuels de l'année en cours et des `years_back` précédentes (page d'accueil). #[server] pub async fn last_months(years_back: u32) -> Result { use chrono::Datelike; use std::collections::HashMap; let user_id = server::require_user_id().await?; let pool = server::pool()?; let today = today(); let first_year: Option = sqlx::query_scalar::<_, Option>( "SELECT MIN(date) FROM rainfalls WHERE user_id = ?1", ) .bind(user_id) .fetch_one(&pool) .await .map_err(server::internal_error)? .and_then(|date| date.get(..4)?.parse().ok()); // Pas plus loin que la première mesure. let years_back = first_year .map_or(1, |first| (today.year() - first).max(1) as u32) .min(MAX_YEARS_BACK) .min(years_back) .max(1); let rows = sqlx::query_as::<_, (String, i64)>( "SELECT substr(date, 1, 7) AS month, SUM(value) FROM rainfalls \ WHERE user_id = ?1 AND date >= ?2 GROUP BY month", ) .bind(user_id) .bind(format!("{}-01-01", today.year() - years_back as i32)) .fetch_all(&pool) .await .map_err(server::internal_error)?; let sums: HashMap<(i32, u32), i64> = rows .into_iter() .filter_map(|(month, sum)| { let (year, month) = month.split_once('-')?; Some(((year.parse().ok()?, month.parse().ok()?), sum)) }) .collect(); Ok(graph::monthly_summary(today, &sums, first_year, years_back)) } #[cfg(test)] mod tests { use super::*; #[test] fn values_must_be_between_1_and_1000() { assert_eq!(parse_value("1").unwrap(), 1); assert_eq!(parse_value(" 1000 ").unwrap(), 1000); for value in ["0", "1001", "-3", "2.5", "", "abc"] { assert!(parse_value(value).is_err(), "{value:?}"); } } #[test] fn dates_are_parsed() { assert_eq!( parse_date("date", "2023-02-28").unwrap(), NaiveDate::from_ymd_opt(2023, 2, 28).unwrap() ); for value in ["2023-02-30", "28/02/2023", "", "0001-01-01"] { assert!(parse_date("date", value).is_err(), "{value:?}"); } } #[test] fn french_dates() { assert_eq!(format_date_fr("2023-02-08"), "08/02/2023"); } }