meals support

src/http.rs

@@ -16,18 +16,23 @@ use axum::{
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, de::DeserializeOwned};
 use thiserror::Error;
-use tower_http::{services::ServeDir, trace::TraceLayer};
+use tower_http::{
+    services::ServeDir,
+    set_header::SetResponseHeaderLayer,
+    trace::TraceLayer,
+};
 use tracing::{error, warn};
 
 use crate::domain::{DomainError, SessionUser};
 use crate::ports::{HubEvent, RealtimeNotifier};
-use crate::services::{AuthService, InvitationService, ListService};
+use crate::services::{AuthService, InvitationService, ListService, MealService};
 use crate::views;
 
 #[derive(Clone)]
 pub struct AppState {
     pub auth: Arc<AuthService>,
     pub lists: Arc<ListService>,
+    pub meals: Arc<MealService>,
     pub invitations: Arc<InvitationService>,
     pub realtime: Arc<dyn RealtimeNotifier>,
     pub cookie_secure: bool,
@@ -76,10 +81,27 @@ pub fn build_router(state: AppState) -> Router {
         .route("/lists/{list_id}/items/{item_id}/delete", post(delete_item))
         .route("/categories", post(create_category))
         .route("/invitations", post(create_invitation))
+        .route("/meals", get(meals_page).post(create_meal))
+        .route("/meals/new", get(new_meal_page))
+        .route("/meals/{meal_id}", get(meal_page))
+        .route("/meals/{meal_id}/edit", post(edit_meal))
+        .route("/meals/{meal_id}/delete", post(delete_meal))
+        .route("/meals/{meal_id}/ingredients", post(add_ingredient))
+        .route("/meals/{meal_id}/ingredients/{ingredient_id}/edit", post(edit_ingredient))
+        .route("/meals/{meal_id}/ingredients/{ingredient_id}/delete", post(delete_ingredient))
+        .route("/lists/{list_id}/add-meal", post(add_meal_to_list))
         .route("/lists/{list_id}/stream", get(list_stream))
         .route("/invite/{token}", get(invitation_page))
         .route("/invite/{token}/accept", post(accept_invitation))
-        .nest_service("/static", ServeDir::new("static"))
+        .nest_service(
+            "/static",
+            tower::ServiceBuilder::new()
+                .layer(SetResponseHeaderLayer::overriding(
+                    header::CACHE_CONTROL,
+                    HeaderValue::from_static("public, max-age=0, must-revalidate"),
+                ))
+                .service(ServeDir::new("static")),
+        )
         .layer(TraceLayer::new_for_http())
         .layer(middleware::from_fn(log_response_status))
         .with_state(state)
@@ -203,6 +225,37 @@ struct CategoryForm {
     csrf: String,
 }
 
+#[derive(Debug, Deserialize)]
+struct MealForm {
+    name: String,
+    #[serde(default)]
+    description: String,
+    csrf: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct IngredientForm {
+    name: String,
+    #[serde(default)]
+    quantity: String,
+    #[serde(default)]
+    note: String,
+    #[serde(default)]
+    category_id: Option<String>,
+    csrf: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct AddMealForm {
+    meal_id: i64,
+    csrf: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct MealPickerQuery {
+    picker: Option<i64>,
+}
+
 async fn home() -> Redirect {
     Redirect::to("/lists")
 }
@@ -473,6 +526,178 @@ async fn create_category(
     Ok(Redirect::to("/lists").into_response())
 }
 
+async fn meals_page(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Query(query): Query<MealPickerQuery>,
+) -> Result<Response, AppError> {
+    let meals = state.meals.list_meals().await?;
+    if let Some(list_id) = query.picker {
+        return Ok(html_response(views::meal_picker(
+            &meals,
+            list_id,
+            &user.session.csrf_token,
+        )));
+    }
+    Ok(html_response(views::meals_page(&user.session.user, &meals)))
+}
+
+async fn new_meal_page(user: CurrentUser) -> Result<Response, AppError> {
+    Ok(html_response(views::meal_form_page(
+        &user.session.user,
+        None,
+        &user.session.csrf_token,
+    )))
+}
+
+async fn create_meal(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    LoggedForm(form): LoggedForm<MealForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    let name = form.name.trim().to_owned();
+    if name.is_empty() || name.chars().count() > 120 {
+        return Err(AppError::BadRequest(
+            "Meal names must be between 1 and 120 characters.".into(),
+        ));
+    }
+    let meal = state
+        .meals
+        .create_meal(name, form.description.trim().to_owned())
+        .await?;
+    Ok(Redirect::to(&format!("/meals/{}", meal.id)).into_response())
+}
+
+async fn meal_page(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(meal_id): Path<i64>,
+) -> Result<Response, AppError> {
+    let meal = state
+        .meals
+        .get_meal(meal_id)
+        .await?
+        .ok_or(AppError::NotFound)?;
+    let categories = state.lists.categories().await?;
+    Ok(html_response(views::meal_page(
+        &user.session.user,
+        &meal,
+        &categories,
+        &user.session.csrf_token,
+    )))
+}
+
+async fn edit_meal(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(meal_id): Path<i64>,
+    LoggedForm(form): LoggedForm<MealForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    let name = form.name.trim().to_owned();
+    if name.is_empty() || name.chars().count() > 120 {
+        return Err(AppError::BadRequest(
+            "Meal names must be between 1 and 120 characters.".into(),
+        ));
+    }
+    state
+        .meals
+        .update_meal(meal_id, name, form.description.trim().to_owned())
+        .await?;
+    Ok(Redirect::to(&format!("/meals/{meal_id}")).into_response())
+}
+
+async fn delete_meal(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(meal_id): Path<i64>,
+    LoggedForm(form): LoggedForm<CsrfForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    state.meals.delete_meal(meal_id).await?;
+    Ok(Redirect::to("/meals").into_response())
+}
+
+async fn add_ingredient(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(meal_id): Path<i64>,
+    LoggedForm(form): LoggedForm<IngredientForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    let name = form.name.trim().to_owned();
+    if name.is_empty() || name.chars().count() > 120 {
+        return Err(AppError::BadRequest(
+            "Ingredient names must be between 1 and 120 characters.".into(),
+        ));
+    }
+    state
+        .meals
+        .add_ingredient(
+            meal_id,
+            name,
+            form.quantity.trim().to_owned(),
+            form.note.trim().to_owned(),
+            parse_category_id(form.category_id),
+        )
+        .await?;
+    Ok(Redirect::to(&format!("/meals/{meal_id}")).into_response())
+}
+
+async fn edit_ingredient(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path((meal_id, ingredient_id)): Path<(i64, i64)>,
+    LoggedForm(form): LoggedForm<IngredientForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    let name = form.name.trim().to_owned();
+    if name.is_empty() || name.chars().count() > 120 {
+        return Err(AppError::BadRequest(
+            "Ingredient names must be between 1 and 120 characters.".into(),
+        ));
+    }
+    state
+        .meals
+        .update_ingredient(
+            meal_id,
+            ingredient_id,
+            name,
+            form.quantity.trim().to_owned(),
+            form.note.trim().to_owned(),
+            parse_category_id(form.category_id),
+        )
+        .await?;
+    Ok(Redirect::to(&format!("/meals/{meal_id}")).into_response())
+}
+
+async fn delete_ingredient(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path((meal_id, ingredient_id)): Path<(i64, i64)>,
+    LoggedForm(form): LoggedForm<CsrfForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    state
+        .meals
+        .delete_ingredient(meal_id, ingredient_id)
+        .await?;
+    Ok(Redirect::to(&format!("/meals/{meal_id}")).into_response())
+}
+
+async fn add_meal_to_list(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(list_id): Path<i64>,
+    LoggedForm(form): LoggedForm<AddMealForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    require_list(&state, list_id).await?;
+    state.meals.add_meal_to_list(form.meal_id, list_id).await?;
+    list_fragment_response(&state, &user, list_id).await
+}
+
 async fn create_invitation(
     State(state): State<AppState>,
     user: CurrentUser,