diff --git a/examples/web-site/components/nav.mq.md b/examples/web-site/components/nav.mq.md
index f6e9dcf..c6518b3 100644
--- a/examples/web-site/components/nav.mq.md
+++ b/examples/web-site/components/nav.mq.md
@@ -7,7 +7,7 @@ Static top links for the shell.
| 属性 | 值 | 样式 |
|------|-----|------|
| Home | / | |
-| About | /about | |
+| New | /_form/article | |
| Admin | /admin | |
**`nav`**
diff --git a/examples/web-site/index.mq.md b/examples/web-site/index.mq.md
index a55a875..edc011d 100644
--- a/examples/web-site/index.mq.md
+++ b/examples/web-site/index.mq.md
@@ -1,6 +1,6 @@
---
title: web-site
-description: Home = page table; main inline; class methods assemble.
+description: Home = page table; main inline; class methods assemble; form §5.5.
> ext/web/web.mq.md
> styles/shell.mq.md
> components/nav.mq.md
@@ -29,9 +29,32 @@ Main content is not a reusable component, so it is authored here.
| `title` | articles.`articles`.title | shell.`card_title` |
| `body` | articles.`articles`.body | shell.`card_body` |
+Article create form (design §5.5): field table + rules table.
+
+`article_fields` =
+
+| 字段 | 标签 | 类型 | 必填 | 默认 |
+|------|------|------|------|------|
+| title | Title | text | true | |
+| body | Body | textarea | false | |
+
+`article_rules` =
+
+| 字段 | 规则 | 消息 |
+|------|------|------|
+| title | required | Title is required |
+| title | max:120 | Title is too long |
+| body | max:8000 | Body is too long |
+
*`store` = > db.open *
*`page` = > web.page title="Marqdo Web Site" intro="
Web Site
Tables + class methods.
" *
*`page` = > `page`.compose_components components=`home` *
*`page` = > `page`.compose_main main=`index` *
+
+*`article_form` = > web.form table=articles action=insert *
+*`article_form` = > `article_form`.fields fields=`article_fields` *
+*`article_form` = > `article_form`.rules rules=`article_rules` *
+
*`app` = > web.app page=`page` db=`store` admin=True host=127.0.0.1 port=18081 *
+*`app` = > `app`.mount_form id=article form=`article_form` *
> `app`.listen
diff --git a/ext/web/README.md b/ext/web/README.md
index 5b4f84d..9a9a2be 100644
--- a/ext/web/README.md
+++ b/ext/web/README.md
@@ -1,24 +1,26 @@
# ext/web
-Official dynamic website extension. Design: [`doc/design/ext-web.md`](../../doc/design/ext-web.md).
+Official dynamic website extension: **GFM tables + class methods**.
+Design: [`doc/design/ext-web.md`](../../doc/design/ext-web.md).
+
+| Surface | Import | Classes |
+|---------|--------|---------|
+| English | `> ext/web/web.mq.md` | `page` · `db` · `app` · `form` · `style` |
+| Chinese | `> ext/web/网页.mq.md` | `页面` · `数据库` · `应用` · `表单` · `样式` |
```bash
cargo build -p marqdo_plugin_web
+# optional install into ~/.marqdo/ext
marqdo ext add web
```
-```markdown
----
-> ext/web/web.mq.md
----
+Canonical sample (design §4): [`examples/web-site/`](../../examples/web-site/).
-# main
-> web.ensure_plugin
-*`page` = > web.page title=Hi *
-*`app` = > web.app page=`page` *
-> `app`.listen
+```bash
+cargo run -- run examples/web-site/index.mq.md
+# http://127.0.0.1:18081/ · /admin
```
-Scaffold: `> web.scaffold dest=./myapp`
+Offline assemble smoke: `tests/ext/web-smoke.mq.md`.
-Multipage site pack (compose + table CSS + `/_part`): see [`examples/web-site/`](../../examples/web-site/).
+**Form / validate / submit** (§5.5): field table + rules + `mount_form` → `GET|POST /_form/{id}`.
diff --git a/ext/web/web.mq.md b/ext/web/web.mq.md
index dd996d5..45ce23b 100644
--- a/ext/web/web.mq.md
+++ b/ext/web/web.mq.md
@@ -127,30 +127,40 @@ Style tables live as `##` exports in site style modules; compose resolves them b
+ `action`=insert
+ `id`=None
-Form API is planned (design §5.5); first trial ships the class shell only.
+Field table + rules table; submit writes through `# db`.
-**`self`**
+> ensure_plugin
+**> web_form_new table=`table` action=`action` id=`id`**
## fields
+ `fields`
-**`self`**
+**> web_form_fields form=`self` fields=`fields`**
+
+## rules
+ + `rules`
+
+**> web_form_rules form=`self` rules=`rules`**
## validate
+ `rules`=None
+ `data`
-**`data`**
+**> web_form_validate form=`self` rules=`rules` data=`data`**
## render
+ + `id`=form
+ + `data`=None
+ + `errors`=None
-**""**
+**> web_form_render form=`self` id=`id` data=`data` errors=`errors`**
## submit
+ `data`
+ `db`
-**`data`**
+*`url` = > json.get value=`db` key=url *
+**> web_form_submit form=`self` data=`data` url=`url`**
# app
+ `page`
@@ -168,8 +178,16 @@ Form API is planned (design §5.5); first trial ships the class shell only.
**`self`**
+## mount_form
+ + `id`
+ + `form`
+
+Register `GET|POST /_form/{id}` for listen.
+
+**> web_app_mount_form app=`self` id=`id` form=`form`**
+
## listen
-Serve `/`, `/_part/{id}`, and optional `/admin` from the assembled page.
+Serve `/`, `/_part/{id}`, `/_form/{id}`, and optional `/admin`.
**> web_listen app=`self`**
diff --git a/ext/web/网页.mq.md b/ext/web/网页.mq.md
index 2b592d0..2b6c2b1 100644
--- a/ext/web/网页.mq.md
+++ b/ext/web/网页.mq.md
@@ -119,30 +119,40 @@ description: 官方网站类(中文)。表格 + 方法;不写袋式胶水
+ `动作`=插入
+ `id`=None
-表单 API 已锁定(设计 §5.5);本试运行仅留类壳。
+字段表 + 校验表;提交经 `# 数据库` 写入。
-**`self`**
+> 确保插件
+**> web_form_new table=`表` action=`动作` id=`id`**
## 字段
+ `字段`
-**`self`**
+**> web_form_fields form=`self` fields=`字段`**
+
+## 规则
+ + `规则`
+
+**> web_form_rules form=`self` rules=`规则`**
## 校验
+ `规则`=None
+ `数据`
-**`数据`**
+**> web_form_validate form=`self` rules=`规则` data=`数据`**
## 渲染
+ + `id`=form
+ + `数据`=None
+ + `错误`=None
-**""**
+**> web_form_render form=`self` id=`id` data=`数据` errors=`错误`**
## 提交
+ `数据`
+ `数据库`
-**`数据`**
+*`url` = > json.get value=`数据库` key=url *
+**> web_form_submit form=`self` data=`数据` url=`url`**
# 应用
+ `页面`
@@ -160,6 +170,12 @@ description: 官方网站类(中文)。表格 + 方法;不写袋式胶水
**`self`**
+## 挂载表单
+ + `id`
+ + `表单`
+
+**> web_app_mount_form app=`self` id=`id` form=`表单`**
+
## 监听
**> web_listen app=`self`**
diff --git a/plugins/web/src/form.rs b/plugins/web/src/form.rs
new file mode 100644
index 0000000..bb1c88c
--- /dev/null
+++ b/plugins/web/src/form.rs
@@ -0,0 +1,507 @@
+//! Form fields / validate / render / submit (design §5.5).
+
+use serde_json::{json, Map, Value};
+
+use crate::db;
+use crate::table::normalize_ref;
+
+const FIELD_KEYS: &[&str] = &["字段", "name", "field", "列"];
+const LABEL_KEYS: &[&str] = &["标签", "label"];
+const TYPE_KEYS: &[&str] = &["类型", "type"];
+const REQ_KEYS: &[&str] = &["必填", "required"];
+const DEF_KEYS: &[&str] = &["默认", "default"];
+const RULE_FIELD_KEYS: &[&str] = &["字段", "field", "name"];
+const RULE_KEYS: &[&str] = &["规则", "rule"];
+const MSG_KEYS: &[&str] = &["消息", "message", "msg"];
+
+fn cell_str(v: &Value) -> String {
+ match v {
+ Value::Null => String::new(),
+ Value::String(s) => s.clone(),
+ Value::Bool(b) => b.to_string(),
+ Value::Number(n) => n.to_string(),
+ other => other.to_string(),
+ }
+}
+
+fn as_str_list(v: &Value) -> Vec {
+ match v {
+ Value::Array(a) => a.iter().map(cell_str).collect(),
+ Value::Null => Vec::new(),
+ other => vec![cell_str(other)],
+ }
+}
+
+fn pick<'a>(m: &'a Map, keys: &[&str]) -> Option<&'a Value> {
+ keys.iter().find_map(|k| m.get(*k))
+}
+
+fn boolish(v: &Value) -> bool {
+ match v {
+ Value::Bool(b) => *b,
+ Value::String(s) => matches!(
+ s.trim(),
+ "1" | "true" | "True" | "yes" | "是" | "必填" | "required"
+ ),
+ Value::Number(n) => n.as_i64().unwrap_or(0) != 0,
+ _ => false,
+ }
+}
+
+fn esc(s: &str) -> String {
+ s.replace('&', "&")
+ .replace('<', "<")
+ .replace('>', ">")
+ .replace('"', """)
+}
+
+/// Normalize author field table → `[{name,label,type,required,default}, …]`
+pub fn as_form_fields(table: &Value) -> Value {
+ match table {
+ Value::Array(rows) => {
+ let mut out = Vec::new();
+ for row in rows {
+ if let Some(m) = row.as_object() {
+ let name = normalize_ref(&pick(m, FIELD_KEYS).map(cell_str).unwrap_or_default());
+ if name.is_empty() {
+ continue;
+ }
+ let label = pick(m, LABEL_KEYS).map(cell_str).unwrap_or_else(|| name.clone());
+ let ty = pick(m, TYPE_KEYS)
+ .map(cell_str)
+ .unwrap_or_else(|| "text".into());
+ let required = pick(m, REQ_KEYS).map(boolish).unwrap_or(false);
+ let default = pick(m, DEF_KEYS).map(cell_str).unwrap_or_default();
+ out.push(json!({
+ "name": name,
+ "label": label,
+ "type": ty,
+ "required": required,
+ "default": default,
+ }));
+ }
+ }
+ Value::Array(out)
+ }
+ Value::Object(m) => {
+ let names = pick(m, FIELD_KEYS).map(as_str_list).unwrap_or_default();
+ let labels = pick(m, LABEL_KEYS).map(as_str_list).unwrap_or_default();
+ let types = pick(m, TYPE_KEYS).map(as_str_list).unwrap_or_default();
+ let reqs = pick(m, REQ_KEYS).map(as_str_list).unwrap_or_default();
+ let defs = pick(m, DEF_KEYS).map(as_str_list).unwrap_or_default();
+ let mut out = Vec::new();
+ for (i, name_raw) in names.iter().enumerate() {
+ let name = normalize_ref(name_raw);
+ if name.is_empty() {
+ continue;
+ }
+ let label = labels.get(i).cloned().unwrap_or_else(|| name.clone());
+ let ty = types.get(i).cloned().unwrap_or_else(|| "text".into());
+ let required = reqs
+ .get(i)
+ .map(|s| boolish(&Value::String(s.clone())))
+ .unwrap_or(false);
+ let default = defs.get(i).cloned().unwrap_or_default();
+ out.push(json!({
+ "name": name,
+ "label": label,
+ "type": ty,
+ "required": required,
+ "default": default,
+ }));
+ }
+ Value::Array(out)
+ }
+ _ => json!([]),
+ }
+}
+
+/// Normalize rules table → `[{field,rule,message}, …]`
+pub fn as_form_rules(table: &Value) -> Value {
+ match table {
+ Value::Array(rows) => {
+ let mut out = Vec::new();
+ for row in rows {
+ if let Some(m) = row.as_object() {
+ let field =
+ normalize_ref(&pick(m, RULE_FIELD_KEYS).map(cell_str).unwrap_or_default());
+ let rule = pick(m, RULE_KEYS).map(cell_str).unwrap_or_default();
+ if field.is_empty() || rule.is_empty() {
+ continue;
+ }
+ let message = pick(m, MSG_KEYS).map(cell_str).unwrap_or_default();
+ out.push(json!({ "field": field, "rule": rule, "message": message }));
+ }
+ }
+ Value::Array(out)
+ }
+ Value::Object(m) => {
+ let fields = pick(m, RULE_FIELD_KEYS).map(as_str_list).unwrap_or_default();
+ let rules = pick(m, RULE_KEYS).map(as_str_list).unwrap_or_default();
+ let msgs = pick(m, MSG_KEYS).map(as_str_list).unwrap_or_default();
+ let n = fields.len().max(rules.len());
+ let mut out = Vec::new();
+ for i in 0..n {
+ let field = normalize_ref(&fields.get(i).cloned().unwrap_or_default());
+ let rule = rules.get(i).cloned().unwrap_or_default();
+ if field.is_empty() || rule.is_empty() {
+ continue;
+ }
+ let message = msgs.get(i).cloned().unwrap_or_default();
+ out.push(json!({ "field": field, "rule": rule, "message": message }));
+ }
+ Value::Array(out)
+ }
+ _ => json!([]),
+ }
+}
+
+pub fn form_new(table: Option<&str>, action: &str, id: Option<&str>) -> Value {
+ let action = match action {
+ "update" | "更新" => "update",
+ _ => "insert",
+ };
+ let mut m = Map::new();
+ if let Some(t) = table.filter(|s| !s.is_empty()) {
+ m.insert("table".into(), json!(t));
+ }
+ m.insert("action".into(), json!(action));
+ if let Some(i) = id.filter(|s| !s.is_empty()) {
+ m.insert("id".into(), json!(i));
+ }
+ m.insert("fields".into(), json!([]));
+ m.insert("rules".into(), json!([]));
+ m.insert("redirect".into(), json!("/"));
+ Value::Object(m)
+}
+
+pub fn set_fields(form: &Value, fields: &Value) -> Value {
+ let mut obj = form.as_object().cloned().unwrap_or_default();
+ obj.insert("fields".into(), as_form_fields(fields));
+ Value::Object(obj)
+}
+
+pub fn set_rules(form: &Value, rules: &Value) -> Value {
+ let mut obj = form.as_object().cloned().unwrap_or_default();
+ obj.insert("rules".into(), as_form_rules(rules));
+ Value::Object(obj)
+}
+
+fn data_map(data: &Value) -> Map {
+ let rows = crate::table::as_rows(data);
+ if let Some(Value::Object(m)) = rows.as_array().and_then(|a| a.first()) {
+ return m.clone();
+ }
+ match data {
+ Value::Object(m) => m.clone(),
+ _ => Map::new(),
+ }
+}
+
+fn field_text(data: &Map, name: &str) -> String {
+ data.get(name).map(cell_str).unwrap_or_default()
+}
+
+fn default_message(rule: &str, field: &str) -> String {
+ if let Some(rest) = rule.strip_prefix("min:") {
+ return format!("{field} must be at least {rest}");
+ }
+ if let Some(rest) = rule.strip_prefix("max:") {
+ return format!("{field} must be at most {rest}");
+ }
+ if let Some(other) = rule.strip_prefix("match:") {
+ return format!("{field} must match {other}");
+ }
+ if rule.starts_with("in:") {
+ return format!("{field} is not an allowed value");
+ }
+ match rule {
+ "required" => format!("{field} is required"),
+ "email" => format!("{field} must be an email"),
+ "url" => format!("{field} must be a URL"),
+ _ => format!("{field} failed `{rule}`"),
+ }
+}
+
+fn check_rule(rule: &str, field: &str, data: &Map) -> Option {
+ let val = field_text(data, field);
+ let trimmed = val.trim();
+ if rule == "required" {
+ return if trimmed.is_empty() {
+ Some(default_message(rule, field))
+ } else {
+ None
+ };
+ }
+ if trimmed.is_empty() {
+ return None; // other rules skip empty (required covers emptiness)
+ }
+ if let Some(n) = rule.strip_prefix("min:") {
+ if let Ok(min) = n.parse::() {
+ if let Ok(num) = trimmed.parse::() {
+ if num < min as f64 {
+ return Some(default_message(rule, field));
+ }
+ } else if (trimmed.chars().count() as i64) < min {
+ return Some(default_message(rule, field));
+ }
+ }
+ return None;
+ }
+ if let Some(n) = rule.strip_prefix("max:") {
+ if let Ok(max) = n.parse::() {
+ if let Ok(num) = trimmed.parse::() {
+ if num > max as f64 {
+ return Some(default_message(rule, field));
+ }
+ } else if (trimmed.chars().count() as i64) > max {
+ return Some(default_message(rule, field));
+ }
+ }
+ return None;
+ }
+ if let Some(other) = rule.strip_prefix("match:") {
+ let other_val = field_text(data, other);
+ if val != other_val {
+ return Some(default_message(rule, field));
+ }
+ return None;
+ }
+ if let Some(list) = rule.strip_prefix("in:") {
+ let allowed: Vec<&str> = list.split(',').map(|s| s.trim()).collect();
+ if !allowed.contains(&trimmed) {
+ return Some(default_message(rule, field));
+ }
+ return None;
+ }
+ match rule {
+ "email" => {
+ if !(trimmed.contains('@') && trimmed.contains('.')) {
+ Some(default_message(rule, field))
+ } else {
+ None
+ }
+ }
+ "url" => {
+ if !(trimmed.starts_with("http://") || trimmed.starts_with("https://")) {
+ Some(default_message(rule, field))
+ } else {
+ None
+ }
+ }
+ _ => None,
+ }
+}
+
+/// Merge field-required + author rules; return `{ok, errors:[{field,message}]}`.
+pub fn validate(form: &Value, extra_rules: Option<&Value>, data: &Value) -> Value {
+ let data = data_map(data);
+ let fields = form
+ .get("fields")
+ .cloned()
+ .unwrap_or(json!([]));
+ let mut rules = form
+ .get("rules")
+ .and_then(|v| v.as_array())
+ .cloned()
+ .unwrap_or_default();
+ if let Some(extra) = extra_rules {
+ if let Some(arr) = as_form_rules(extra).as_array() {
+ rules.extend(arr.clone());
+ }
+ }
+ // Auto required from field table (message overridable by later explicit rules)
+ if let Some(arr) = fields.as_array() {
+ for f in arr {
+ let name = f.get("name").and_then(|v| v.as_str()).unwrap_or("");
+ let required = f.get("required").and_then(|v| v.as_bool()).unwrap_or(false);
+ if required && !name.is_empty() {
+ let already = rules.iter().any(|r| {
+ r.get("field").and_then(|v| v.as_str()) == Some(name)
+ && r.get("rule").and_then(|v| v.as_str()) == Some("required")
+ });
+ if !already {
+ rules.insert(
+ 0,
+ json!({
+ "field": name,
+ "rule": "required",
+ "message": format!("{name} is required"),
+ }),
+ );
+ }
+ }
+ }
+ }
+
+ let mut errors = Vec::new();
+ for r in &rules {
+ let field = r.get("field").and_then(|v| v.as_str()).unwrap_or("");
+ let rule = r.get("rule").and_then(|v| v.as_str()).unwrap_or("");
+ let msg = r.get("message").and_then(|v| v.as_str()).unwrap_or("");
+ if field.is_empty() || rule.is_empty() {
+ continue;
+ }
+ if let Some(default_msg) = check_rule(rule, field, &data) {
+ errors.push(json!({
+ "field": field,
+ "message": if msg.is_empty() { default_msg } else { msg.to_string() },
+ }));
+ }
+ }
+ json!({
+ "ok": errors.is_empty(),
+ "errors": errors,
+ })
+}
+
+pub fn render(form: &Value, form_id: &str, data: Option<&Value>, errors: Option<&Value>) -> String {
+ let fields = form
+ .get("fields")
+ .and_then(|v| v.as_array())
+ .cloned()
+ .unwrap_or_default();
+ let data = data.map(data_map).unwrap_or_default();
+ let mut err_map = Map::new();
+ if let Some(Value::Array(errs)) = errors {
+ for e in errs {
+ if let (Some(f), Some(m)) = (
+ e.get("field").and_then(|v| v.as_str()),
+ e.get("message").and_then(|v| v.as_str()),
+ ) {
+ err_map.insert(f.to_string(), json!(m));
+ }
+ }
+ } else if let Some(Value::Object(m)) = errors {
+ err_map = m.clone();
+ }
+
+ let action = form
+ .get("action")
+ .and_then(|v| v.as_str())
+ .unwrap_or("insert");
+ let table = form
+ .get("table")
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
+
+ let mut body = String::from(
+ r#""#,
+ );
+ body.push_str(&format!("form {id}", id = esc(form_id)));
+ body.push_str(
+ r#""#,
+ );
+ body.push_str(&format!(
+ "{}
table={} · action={}
",
+ esc(form_id),
+ esc(table),
+ esc(action)
+ ));
+ body.push_str(&format!(
+ "");
+ body
+}
+
+pub fn submit(form: &Value, data: &Value, db_url: &str) -> Result {
+ let v = validate(form, None, data);
+ if !v.get("ok").and_then(|x| x.as_bool()).unwrap_or(false) {
+ return Ok(json!({
+ "ok": false,
+ "errors": v.get("errors").cloned().unwrap_or(json!([])),
+ }));
+ }
+ let table = form
+ .get("table")
+ .and_then(|v| v.as_str())
+ .ok_or_else(|| "form missing `table`".to_string())?;
+ let action = form
+ .get("action")
+ .and_then(|v| v.as_str())
+ .unwrap_or("insert");
+ let row = Value::Object(data_map(data));
+ let result = if action == "update" {
+ let id = form
+ .get("id")
+ .map(cell_str)
+ .filter(|s| !s.is_empty())
+ .or_else(|| data_map(data).get("id").map(cell_str))
+ .ok_or_else(|| "update requires `id`".to_string())?;
+ db::update(db_url, table, &id, &row)?
+ } else {
+ db::insert(db_url, table, &json!([row]))?
+ };
+ let redirect = form
+ .get("redirect")
+ .and_then(|v| v.as_str())
+ .unwrap_or("/");
+ Ok(json!({
+ "ok": true,
+ "result": result,
+ "redirect": redirect,
+ }))
+}
diff --git a/plugins/web/src/http.rs b/plugins/web/src/http.rs
index 6ff62ad..8139712 100644
--- a/plugins/web/src/http.rs
+++ b/plugins/web/src/http.rs
@@ -1,9 +1,10 @@
-//! Blocking HTTP listen: page shell, `/_part/{id}`, optional `/admin`.
+//! Blocking HTTP listen: page shell, `/_part/{id}`, `/_form/{id}`, optional `/admin`.
+use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;
-use axum::extract::{Path, State};
+use axum::extract::{Form, Path, State};
use axum::response::{Html, IntoResponse, Redirect, Response};
use axum::routing::get;
use axum::Router;
@@ -11,6 +12,7 @@ use serde_json::{json, Map, Value};
use tokio::runtime::Runtime;
use crate::db;
+use crate::form;
use crate::render;
#[derive(Clone)]
@@ -18,6 +20,7 @@ struct AppState {
page: Value,
db_url: Option,
admin: bool,
+ forms: HashMap,
}
pub fn listen(
@@ -26,16 +29,19 @@ pub fn listen(
host: &str,
port: u16,
admin: bool,
+ forms: HashMap,
) -> Result {
let state = Arc::new(AppState {
page: page.clone(),
db_url: db_url.map(|s| s.to_string()),
admin,
+ forms,
});
let app = Router::new()
.route("/", get(home))
.route("/_part/{id}", get(part))
+ .route("/_form/{id}", get(form_get).post(form_post))
.route("/admin", get(admin_home))
.route("/admin/{table}", get(admin_table))
.with_state(state);
@@ -73,6 +79,45 @@ async fn part(State(st): State>, Path(id): Path) -> Respon
Html(html).into_response()
}
+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();
+ };
+ let mut data = Map::new();
+ for (k, v) in posted {
+ data.insert(k, json!(v));
+ }
+ let data_v = Value::Object(data);
+ 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");
+ Html(form::render(frm, &id, Some(&data_v), errors)).into_response()
+ }
+ Err(e) => Html(format!("submit error: {}
", esc(&e))).into_response(),
+ }
+}
+
async fn admin_home(State(st): State>) -> Response {
if !st.admin {
return Html(String::from("admin disabled
")).into_response();
@@ -88,6 +133,12 @@ async fn admin_home(State(st): State>) -> Response {
for t in &tables {
body.push_str(&format!("{t}"));
}
+ if !st.forms.is_empty() {
+ body.push_str("forms
");
+ for id in st.forms.keys() {
+ body.push_str(&format!("- {id}
"));
+ }
+ }
body.push_str("
home