use leptos::prelude::*; use leptos::server_fn::codec::Json; use crate::model::{Item, ItemInput, ListColor, Member, ShoppingList, Suggestion, User}; pub const NOT_LOGGED_IN: &str = "Session expirée, reconnecte-toi."; #[cfg(feature = "ssr")] mod server { use leptos::prelude::*; use sqlx::SqlitePool; use crate::db::Role; use crate::model::User; pub fn pool() -> Result { use_context::().ok_or_else(|| ServerFnError::new("database pool missing")) } pub fn db_err(err: sqlx::Error) -> ServerFnError { leptos::logging::error!("database error: {err}"); ServerFnError::new("Erreur de base de données") } pub async fn require_user(pool: &SqlitePool) -> Result { crate::auth::current_user(pool) .await .map_err(db_err)? .ok_or_else(|| ServerFnError::new(super::NOT_LOGGED_IN)) } fn not_found() -> ServerFnError { ServerFnError::new("Liste introuvable.") } /// Fails unless the user owns the list or it is shared with them. pub async fn require_list(pool: &SqlitePool, user: &User, list_id: i64) -> Result { crate::db::list_role(pool, user.id, list_id) .await .map_err(db_err)? .ok_or_else(not_found) } pub async fn require_owner(pool: &SqlitePool, user: &User, list_id: i64) -> Result<(), ServerFnError> { match require_list(pool, user, list_id).await? { Role::Owner => Ok(()), Role::Member => Err(ServerFnError::new("Seul le propriétaire de la liste peut faire ça.")), } } /// Fails unless the item belongs to a list the user can access. pub async fn require_item(pool: &SqlitePool, user: &User, item_id: i64) -> Result<(), ServerFnError> { let list_id = crate::db::item_list_id(pool, item_id) .await .map_err(db_err)? .ok_or_else(|| ServerFnError::new("Article introuvable."))?; require_list(pool, user, list_id).await.map(|_| ()) } pub fn clean_name(name: &str, max: usize) -> Result { let name = name.trim(); if name.is_empty() || name.chars().count() > max { return Err(ServerFnError::new(format!("Le nom doit faire entre 1 et {max} caractères."))); } Ok(name.to_owned()) } pub fn clean_email(email: &str) -> Result { let email = email.trim().to_lowercase(); let valid = email.len() <= 254 && email .split_once('@') .is_some_and(|(local, domain)| !local.is_empty() && domain.contains('.') && !domain.starts_with('.')); if !valid { return Err(ServerFnError::new("Adresse email invalide.")); } Ok(email) } pub async fn blocking(f: impl FnOnce() -> T + Send + 'static) -> Result { tokio::task::spawn_blocking(f) .await .map_err(|_| ServerFnError::new("Erreur interne")) } } // --- Account ---------------------------------------------------------------- #[server] pub async fn get_me() -> Result, ServerFnError> { use server::*; crate::auth::current_user(&pool()?).await.map_err(db_err) } #[server] pub async fn register(name: String, email: String, password: String) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let name = clean_name(&name, 40)?; let email = clean_email(&email)?; if !(8..=128).contains(&password.chars().count()) { return Err(ServerFnError::new("Le mot de passe doit faire au moins 8 caractères.")); } let hash = blocking(move || crate::auth::hash_password(&password)) .await? .map_err(|_| ServerFnError::new("Erreur interne"))?; let user_id = match crate::db::register(&pool, &email, &name, &hash).await { Ok(id) => id, Err(sqlx::Error::Database(err)) if err.is_unique_violation() => { return Err(ServerFnError::new("Un compte existe déjà avec cet email.")); } Err(err) => return Err(db_err(err)), }; crate::auth::start_session(&pool, user_id).await.map_err(db_err)?; leptos_axum::redirect("/"); Ok(()) } #[server] pub async fn login(email: String, password: String) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let found = crate::db::user_by_email(&pool, email.trim()).await.map_err(db_err)?; let (user, hash) = match found { Some((user, hash)) => (Some(user), hash), None => (None, crate::auth::dummy_hash().to_owned()), }; let valid = blocking(move || crate::auth::verify_password(&password, &hash)).await?; let Some(user) = user.filter(|_| valid) else { return Err(ServerFnError::new("Email ou mot de passe incorrect.")); }; crate::auth::start_session(&pool, user.id).await.map_err(db_err)?; leptos_axum::redirect("/"); Ok(()) } #[server] pub async fn logout() -> Result<(), ServerFnError> { use server::*; crate::auth::end_session(&pool()?).await.map_err(db_err)?; leptos_axum::redirect("/connexion"); Ok(()) } // --- Lists ------------------------------------------------------------------ #[server] pub async fn get_lists() -> Result, ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; crate::db::lists(&pool, user.id).await.map_err(db_err) } #[server] pub async fn create_list(name: String, color: ListColor) -> Result { use server::*; let pool = pool()?; let user = require_user(&pool).await?; let name = clean_name(&name, 60)?; crate::db::create_list(&pool, user.id, &name, color).await.map_err(db_err) } #[server] pub async fn rename_list(id: i64, name: String) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_owner(&pool, &user, id).await?; let name = clean_name(&name, 60)?; crate::db::rename_list(&pool, id, &name).await.map_err(db_err) } #[server] pub async fn delete_list(id: i64) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_owner(&pool, &user, id).await?; crate::db::delete_list(&pool, id).await.map_err(db_err) } #[server] pub async fn get_members(list_id: i64) -> Result, ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_list(&pool, &user, list_id).await?; crate::db::members(&pool, list_id).await.map_err(db_err) } #[server] pub async fn share_list(list_id: i64, email: String) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_owner(&pool, &user, list_id).await?; let email = clean_email(&email)?; let (friend, _) = crate::db::user_by_email(&pool, &email) .await .map_err(db_err)? .ok_or_else(|| ServerFnError::new("Aucun compte avec cet email."))?; if friend.id == user.id { return Err(ServerFnError::new("Tu es déjà propriétaire de cette liste.")); } crate::db::add_member(&pool, list_id, friend.id).await.map_err(db_err) } /// The owner removes someone, or a member leaves (`user_id` = themself). #[server] pub async fn remove_member(list_id: i64, user_id: i64) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; if user_id != user.id { require_owner(&pool, &user, list_id).await?; } crate::db::remove_member(&pool, list_id, user_id).await.map_err(db_err) } // --- Items ------------------------------------------------------------------ #[server] pub async fn get_items(list_id: i64) -> Result, ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_list(&pool, &user, list_id).await?; crate::db::items(&pool, list_id).await.map_err(db_err) } #[server(input = Json)] pub async fn add_item(list_id: i64, input: ItemInput) -> Result { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_list(&pool, &user, list_id).await?; let input = ItemInput { name: clean_name(&input.name, 60)?, ..input }; crate::db::add_item(&pool, user.id, list_id, &input).await.map_err(db_err) } #[server(input = Json)] pub async fn update_item(id: i64, input: ItemInput) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_item(&pool, &user, id).await?; let input = ItemInput { name: clean_name(&input.name, 60)?, ..input }; crate::db::update_item(&pool, id, &input).await.map_err(db_err) } #[server] pub async fn delete_item(id: i64) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_item(&pool, &user, id).await?; crate::db::delete_item(&pool, id).await.map_err(db_err) } #[server] pub async fn set_checked(id: i64, checked: bool) -> Result<(), ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_item(&pool, &user, id).await?; crate::db::set_checked(&pool, id, checked).await.map_err(db_err) } #[server] pub async fn get_suggestions(list_id: i64) -> Result, ServerFnError> { use server::*; let pool = pool()?; let user = require_user(&pool).await?; require_list(&pool, &user, list_id).await?; crate::db::suggestions(&pool, user.id, list_id, 3).await.map_err(db_err) }