//! Blocking HTTP listen: page shell, `/_part/{id}`, `/_form/{id}`, `/admin` CRUD. use std::collections::HashMap; use std::net::SocketAddr; use std::sync::Arc; use axum::extract::{Form, Path, State}; use axum::http::Uri; use axum::response::{Html, IntoResponse, Redirect, Response}; use axum::routing::get; use axum::Router; use serde_json::{json, Map, Value}; use tokio::runtime::Runtime; use crate::db; use crate::form; use crate::render; #[derive(Clone)] struct AppState { page: Value, db_url: Option, admin: bool, forms: HashMap, /// Page that owns an embedded form (for re-render on validation errors). form_owners: HashMap, routes: HashMap, } fn collect_page_forms( page: &Value, forms: &mut HashMap, owners: &mut HashMap, ) { if let Some(obj) = page.get("forms").and_then(|v| v.as_object()) { for (k, v) in obj { forms.insert(k.clone(), v.clone()); owners.insert(k.clone(), page.clone()); } } if let (Some(id), Some(f)) = ( page.get("form_id").and_then(|v| v.as_str()), page.get("form"), ) { if !id.is_empty() { forms.insert(id.to_string(), f.clone()); owners.insert(id.to_string(), page.clone()); } } } pub fn listen( page: &Value, db_url: Option<&str>, host: &str, port: u16, admin: bool, mut forms: HashMap, routes: HashMap, ) -> Result { let mut form_owners = HashMap::new(); collect_page_forms(page, &mut forms, &mut form_owners); for p in routes.values() { collect_page_forms(p, &mut forms, &mut form_owners); } let state = Arc::new(AppState { page: page.clone(), db_url: db_url.map(|s| s.to_string()), admin, forms, form_owners, routes: routes.clone(), }); let mut app = Router::new() .route("/", get(home)) .route("/_part/{id}", get(home_part)) .route("/_form/{id}", get(form_get).post(form_post)) .route("/admin", get(admin_home)) .route("/admin/{table}", get(admin_table)) .route("/admin/{table}/new", get(admin_new_get).post(admin_new_post)) .route( "/admin/{table}/{id}/edit", get(admin_edit_get).post(admin_edit_post), ) .route("/admin/{table}/{id}/delete", get(admin_delete)); // Register each author route as an exact GET path + `{path}/_part/{id}`. let mut paths: Vec = routes.keys().cloned().collect(); paths.sort(); for path in paths { app = app.route(&path, get(routed_page)); let part_path = format!("{path}/_part/{{id}}"); app = app.route(&part_path, get(routed_part)); } let app = app.with_state(state); let addr: SocketAddr = format!("{host}:{port}") .parse() .map_err(|e| format!("bad listen addr {host}:{port}: {e}"))?; let rt = Runtime::new().map_err(|e| e.to_string())?; rt.block_on(async move { let listener = tokio::net::TcpListener::bind(addr) .await .map_err(|e| format!("bind {addr}: {e}"))?; eprintln!("marqdo web listening on http://{addr}"); axum::serve(listener, app) .await .map_err(|e| format!("serve: {e}")) })?; Ok(json!({ "ok": true })) } async fn home(State(st): State>) -> Html { let html = render::render_page(&st.page, st.db_url.as_deref()); Html(html) } async fn routed_page(State(st): State>, uri: Uri) -> Response { let mut path = uri.path().to_string(); while path.len() > 1 && path.ends_with('/') { path.pop(); } let Some(page) = st.routes.get(&path) else { return Html(format!("

404 not found: {}

", esc(&path))).into_response(); }; Html(render::render_page(page, st.db_url.as_deref())).into_response() } fn render_part_from_page(page: &Value, id: &str, db_url: Option<&str>) -> Response { let Some(parts) = page.get("parts").and_then(|v| v.as_object()) else { return Html(String::from("

no parts

")).into_response(); }; let Some(cfg) = parts.get(id) else { return Html(format!("

unknown part {id}

")).into_response(); }; Html(render::render_fragment(cfg, db_url)).into_response() } async fn home_part(State(st): State>, Path(id): Path) -> Response { render_part_from_page(&st.page, &id, st.db_url.as_deref()) } /// `{route}/_part/{id}` — resolve part against the page mounted at `route`. async fn routed_part( State(st): State>, uri: Uri, Path(id): Path, ) -> Response { let full = uri.path(); let marker = format!("/_part/{id}"); let Some(page_path) = full.strip_suffix(&marker) else { return Html(format!("

bad part path {}

", esc(full))).into_response(); }; if page_path.is_empty() || page_path == "/" { return render_part_from_page(&st.page, &id, st.db_url.as_deref()); } let Some(page) = st.routes.get(page_path) else { return Html(format!("

404 not found: {}

", esc(page_path))).into_response(); }; render_part_from_page(page, &id, st.db_url.as_deref()) } async fn form_get(State(st): State>, Path(id): Path) -> Response { let Some(frm) = st.forms.get(&id) else { return Html(format!("

unknown form {id}

")).into_response(); }; Html(form::render(frm, &id, None, None)).into_response() } async fn form_post( State(st): State>, Path(id): Path, Form(posted): Form>, ) -> Response { let Some(frm) = st.forms.get(&id) else { return Html(format!("

unknown form {id}

")).into_response(); }; let Some(url) = st.db_url.as_deref() else { return Html(String::from("

no database

")).into_response(); }; submit_and_respond(&st, frm, &id, url, posted) } fn posted_to_value(posted: HashMap) -> Value { let mut data = Map::new(); for (k, v) in posted { data.insert(k, json!(v)); } Value::Object(data) } fn submit_and_respond( st: &AppState, frm: &Value, form_id: &str, url: &str, posted: HashMap, ) -> Response { let data_v = posted_to_value(posted); match form::submit(frm, &data_v, url) { Ok(res) if res.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) => { let redirect = res .get("redirect") .and_then(|v| v.as_str()) .unwrap_or("/"); Redirect::to(redirect).into_response() } Ok(res) => { let errors = res.get("errors"); if let Some(page) = st.form_owners.get(form_id) { Html(render::render_page_ex( page, st.db_url.as_deref(), Some(&data_v), errors, )) .into_response() } else { Html(form::render(frm, form_id, Some(&data_v), errors)).into_response() } } Err(e) => Html(format!("

submit error: {}

", esc(&e))).into_response(), } } fn admin_gate(st: &AppState) -> Option { if !st.admin { return Some(Html(String::from("

admin disabled

")).into_response()); } if st.db_url.is_none() { return Some(Html(String::from("

no database

")).into_response()); } None } fn admin_shell(title: &str, inner: &str) -> String { format!( r#"{title} {inner}"#, title = esc(title), inner = inner ) } async fn admin_home(State(st): State>) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); let tables = db::list_tables(url).unwrap_or_default(); let mut inner = String::from("

admin

tables

    "); for t in &tables { inner.push_str(&format!("
  • {t}
  • ")); } inner.push_str("
"); if !st.forms.is_empty() { inner.push_str("

mounted forms

    "); for id in st.forms.keys() { inner.push_str(&format!("
  • {id}
  • ")); } inner.push_str("
"); } Html(admin_shell("admin", &inner)).into_response() } async fn admin_table(State(st): State>, Path(table): Path) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); let Ok(data) = db::select(url, &table, 200) else { return Html(format!("

cannot read {table}

")).into_response(); }; let rows = data .get("rows") .and_then(|v| v.as_array()) .cloned() .unwrap_or_default(); let mut cols: Vec = rows .first() .and_then(|r| r.as_object()) .map(|m| m.keys().cloned().collect()) .unwrap_or_default(); if cols.is_empty() { if let Ok(info) = db::table_info(url, &table) { cols = info.into_iter().map(|c| c.name).collect(); } } // prefer id first if let Some(i) = cols.iter().position(|c| c == "id") { let idc = cols.remove(i); cols.insert(0, idc); } let mut inner = format!("

{table}

"); inner.push_str(&format!( "" )); inner.push_str(""); for c in &cols { inner.push_str(&format!("", esc(c))); } inner.push_str(""); for row in &rows { let m = row.as_object().cloned().unwrap_or_else(Map::new); inner.push_str(""); for c in &cols { let cell = m .get(c) .map(|v| match v { Value::String(s) => s.clone(), Value::Null => String::new(), other => other.to_string(), }) .unwrap_or_default(); inner.push_str(&format!("", esc(&cell))); } let id = m .get("id") .map(|v| match v { Value::String(s) => s.clone(), other => other.to_string(), }) .unwrap_or_default(); if !id.is_empty() { inner.push_str(&format!( "" )); } else { inner.push_str(""); } inner.push_str(""); } if rows.is_empty() { inner.push_str(""); } inner.push_str("
{}
{}edit · delete
(empty)
"); Html(admin_shell(&table, &inner)).into_response() } async fn admin_new_get(State(st): State>, Path(table): Path) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); match form::from_schema(url, &table, "insert", None) { Ok(frm) => Html(form::render(&frm, &format!("admin-{table}-new"), None, None)) .into_response(), Err(e) => Html(format!("

{}

", esc(&e))).into_response(), } } async fn admin_new_post( State(st): State>, Path(table): Path, Form(posted): Form>, ) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); match form::from_schema(url, &table, "insert", None) { Ok(frm) => submit_and_respond(&st, &frm, &format!("admin-{table}-new"), url, posted), Err(e) => Html(format!("

{}

", esc(&e))).into_response(), } } async fn admin_edit_get( State(st): State>, Path((table, id)): Path<(String, String)>, ) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); let row = match db::get(url, &table, &id) { Ok(Value::Null) => { return Html(format!("

row {id} not found

")).into_response(); } Ok(v) => v, Err(e) => return Html(format!("

{}

", esc(&e))).into_response(), }; match form::from_schema(url, &table, "update", Some(&id)) { Ok(frm) => Html(form::render( &frm, &format!("admin-{table}-edit"), Some(&row), None, )) .into_response(), Err(e) => Html(format!("

{}

", esc(&e))).into_response(), } } async fn admin_edit_post( State(st): State>, Path((table, id)): Path<(String, String)>, Form(posted): Form>, ) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); match form::from_schema(url, &table, "update", Some(&id)) { Ok(frm) => submit_and_respond(&st, &frm, &format!("admin-{table}-edit"), url, posted), Err(e) => Html(format!("

{}

", esc(&e))).into_response(), } } async fn admin_delete( State(st): State>, Path((table, id)): Path<(String, String)>, ) -> Response { if let Some(r) = admin_gate(&st) { return r; } let url = st.db_url.as_deref().unwrap(); if let Err(e) = db::delete(url, &table, &id) { return Html(format!("

delete failed: {}

", esc(&e))).into_response(); } Redirect::to(&format!("/admin/{table}")).into_response() } fn esc(s: &str) -> String { s.replace('&', "&") .replace('<', "<") .replace('>', ">") }