- Inscription / connexion par email + mot de passe (argon2), prénom ou pseudo enregistré ; session par cookie HttpOnly, jeton haché en base. - Listes privées par propriétaire, partageables par email ; les membres peuvent gérer les articles et quitter la liste. - Contrôle d'accès dans chaque server function. - Suggestions propres à chaque utilisateur. - Avatar avec initiales et feuille de compte (déconnexion). - La page 404 reçoit le pool SQLite. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
279 lines
9.6 KiB
Rust
279 lines
9.6 KiB
Rust
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<SqlitePool, ServerFnError> {
|
|
use_context::<SqlitePool>().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<User, ServerFnError> {
|
|
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<Role, ServerFnError> {
|
|
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<String, ServerFnError> {
|
|
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<String, ServerFnError> {
|
|
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<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static) -> Result<T, ServerFnError> {
|
|
tokio::task::spawn_blocking(f)
|
|
.await
|
|
.map_err(|_| ServerFnError::new("Erreur interne"))
|
|
}
|
|
}
|
|
|
|
// --- Account ----------------------------------------------------------------
|
|
|
|
#[server]
|
|
pub async fn get_me() -> Result<Option<User>, 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<Vec<ShoppingList>, 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<i64, ServerFnError> {
|
|
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<Vec<Member>, 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<Vec<Item>, 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<i64, ServerFnError> {
|
|
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<Vec<Suggestion>, 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)
|
|
}
|