modularized

2025-12-03 16:33:40 +01:00
parent 98a7df2931
commit 4e596d0699
3 changed files with 136 additions and 125 deletions
@@ -0,0 +1,20 @@
+use crate::handlers::AppConfig;
+
+/// Load config from path
+pub fn load_config(path: &str) -> anyhow::Result<AppConfig> {
+    let raw = std::fs::read_to_string(path)?;
+    let cfg: AppConfig = toml::from_str(&raw)?;
+
+    // field names must be unique and non-empty
+    let mut seen = std::collections::HashSet::new();
+    for f in &cfg.fields {
+        if f.name.trim().is_empty() {
+            anyhow::bail!("field with empty name in config");
+        }
+        if !seen.insert(f.name.clone()) {
+            anyhow::bail!("duplicate field name in config: {}", f.name);
+        }
+    }
+
+    Ok(cfg)
+}
@@ -0,0 +1,109 @@
+use askama::Template;
+use axum::{
+    extract::{Form, State},
+    http::StatusCode,
+    response::{Html, IntoResponse},
+};
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, sync::Arc};
+use tokio::sync::Mutex;
+
+#[derive(Debug, Deserialize)]
+pub struct FieldDef {
+    pub name: String,
+    title: String,
+    description: String,
+    answer_type: String,
+    html_before: Option<String>,
+    html_after: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct ResponseEntry {
+    timestamp: chrono::DateTime<chrono::Utc>,
+    answers: HashMap<String, String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct AppConfig {
+    submit_button: String,
+    pub fields: Vec<FieldDef>,
+}
+
+#[derive(Clone)]
+pub struct AppState {
+    pub cfg: Arc<AppConfig>,
+    pub file_lock: Arc<Mutex<()>>,
+    pub output_file: String,
+}
+
+pub async fn render_form(State(state): State<AppState>) -> impl IntoResponse {
+    #[derive(Template)]
+    #[template(path = "form.html")]
+    struct FormTemplate<'a> {
+        fields: &'a [FieldDef],
+        lang: &'a str,
+        submit_button: &'a str,
+    }
+
+    let tmpl = FormTemplate {
+        fields: &state.cfg.fields,
+        lang: "en",
+        submit_button: &state.cfg.submit_button,
+    };
+    match tmpl.render() {
+        Ok(html) => Html(html).into_response(),
+        Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Template render error").into_response(),
+    }
+}
+
+pub async fn submit(
+    State(state): State<AppState>,
+    Form(form): Form<HashMap<String, String>>,
+) -> impl IntoResponse {
+    let entry = ResponseEntry {
+        timestamp: Utc::now(),
+        answers: form,
+    };
+
+    let _guard = state.file_lock.lock().await;
+    let path = &state.output_file;
+
+    let mut existing: Vec<ResponseEntry> = match std::fs::read_to_string(path) {
+        Ok(raw) => serde_json::from_str(&raw).unwrap_or(Vec::new()),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(),
+        Err(e) => {
+            tracing::error!("Failed to read {}: {}", path, e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to read storage file",
+            )
+                .into_response();
+        }
+    };
+
+    existing.push(entry.clone());
+
+    if let Err(e) = std::fs::write(path, serde_json::to_string_pretty(&existing).unwrap()) {
+        tracing::error!("Failed to write {}: {}", path, e);
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to write storage file",
+        )
+            .into_response();
+    }
+
+    // tracing::info!("Entry submitted: {:?}", entry.answers);
+
+    Html(
+        r#"
+        <html>
+            <body>
+                <p>Saved. <a href="/">Back</a></p>
+            </body>
+        </html>
+        "#,
+    )
+    .into_response()
+}
@@ -1,22 +1,22 @@
-use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
+use std::{net::SocketAddr, sync::Arc, time::Duration};

 use anyhow::Context;
-use askama::Template;
 use axum::{
    Router,
-    extract::{Form, State},
-    http::{Method, StatusCode, header},
-    response::{Html, IntoResponse},
+    http::{Method, header},
    routing::{get, post},
 };
-use chrono::Utc;
-use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use tower_governor::{GovernorLayer, governor::GovernorConfigBuilder};
 use tower_http::cors::{Any, CorsLayer};

 use clap::Parser;

+mod handlers;
+use handlers::{AppState, render_form, submit};
+mod config;
+use config::load_config;
+
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 pub struct Cli {
@@ -33,35 +33,6 @@ pub struct Cli {
    verbose: bool,
 }

-#[derive(Debug, Deserialize)]
-struct FieldDef {
-    name: String,
-    title: String,
-    description: String,
-    answer_type: String,
-    html_before: Option<String>,
-    html_after: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AppConfig {
-    submit_button: String,
-    fields: Vec<FieldDef>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct ResponseEntry {
-    timestamp: chrono::DateTime<chrono::Utc>,
-    answers: HashMap<String, String>,
-}
-
-#[derive(Clone)]
-struct AppState {
-    cfg: Arc<AppConfig>,
-    file_lock: Arc<Mutex<()>>,
-    output_file: String,
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
@@ -130,92 +101,3 @@ async fn main() -> anyhow::Result<()> {

    Ok(())
 }
-
-async fn render_form(State(state): State<AppState>) -> impl IntoResponse {
-    #[derive(Template)]
-    #[template(path = "form.html")]
-    struct FormTemplate<'a> {
-        fields: &'a [FieldDef],
-        lang: &'a str,
-        submit_button: &'a str,
-    }
-
-    let tmpl = FormTemplate {
-        fields: &state.cfg.fields,
-        lang: "en",
-        submit_button: &state.cfg.submit_button,
-    };
-    match tmpl.render() {
-        Ok(html) => Html(html).into_response(),
-        Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Template render error").into_response(),
-    }
-}
-
-async fn submit(
-    State(state): State<AppState>,
-    Form(form): Form<HashMap<String, String>>,
-) -> impl IntoResponse {
-    let entry = ResponseEntry {
-        timestamp: Utc::now(),
-        answers: form,
-    };
-
-    let _guard = state.file_lock.lock().await;
-    let path = &state.output_file;
-
-    let mut existing: Vec<ResponseEntry> = match std::fs::read_to_string(path) {
-        Ok(raw) => serde_json::from_str(&raw).unwrap_or(Vec::new()),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(),
-        Err(e) => {
-            tracing::error!("Failed to read {}: {}", path, e);
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Failed to read storage file",
-            )
-                .into_response();
-        }
-    };
-
-    existing.push(entry.clone());
-
-    if let Err(e) = std::fs::write(path, serde_json::to_string_pretty(&existing).unwrap()) {
-        tracing::error!("Failed to write {}: {}", path, e);
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Failed to write storage file",
-        )
-            .into_response();
-    }
-
-    // tracing::info!("Entry submitted: {:?}", entry.answers);
-
-    Html(
-        r#"
-        <html>
-            <body>
-                <p>Saved. <a href="/">Back</a></p>
-            </body>
-        </html>
-        "#,
-    )
-    .into_response()
-}
-
-/// Load config from path
-fn load_config(path: &str) -> anyhow::Result<AppConfig> {
-    let raw = std::fs::read_to_string(path)?;
-    let cfg: AppConfig = toml::from_str(&raw)?;
-
-    // field names must be unique and non-empty
-    let mut seen = std::collections::HashSet::new();
-    for f in &cfg.fields {
-        if f.name.trim().is_empty() {
-            anyhow::bail!("field with empty name in config");
-        }
-        if !seen.insert(f.name.clone()) {
-            anyhow::bail!("duplicate field name in config: {}", f.name);
-        }
-    }
-
-    Ok(cfg)
-}