Add ext/web forms (design §5.5): fields, validate, submit, GET|POST /_form.
Also fix static links (URLs with dots) being misread as db fields. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
9599303c4c
commit
ee019fb1c2
13 files changed
+890
-46
No files matched your search
@@ -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<String> {
|
||||
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<String, Value>, 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<String, Value> {
|
||||
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<String, Value>, 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<String, Value>) -> Option<String> {
|
||||
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::<i64>() {
|
||||
if let Ok(num) = trimmed.parse::<f64>() {
|
||||
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::<i64>() {
|
||||
if let Ok(num) = trimmed.parse::<f64>() {
|
||||
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#"<!DOCTYPE html><html lang="zh-CN"><head><meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>"#,
|
||||
);
|
||||
body.push_str(&format!("<title>form {id}</title>", id = esc(form_id)));
|
||||
body.push_str(
|
||||
r#"<style>
|
||||
body{font-family:"IBM Plex Sans","Noto Sans SC",sans-serif;margin:1.5rem;background:#fafaf9;color:#1c1917}
|
||||
form{max-width:28rem;display:grid;gap:.85rem}
|
||||
label{display:grid;gap:.25rem;font-size:.9rem}
|
||||
input,textarea{padding:.5rem .6rem;border:1px solid #e7e5e4;border-radius:4px;font:inherit}
|
||||
.err{color:#b91c1c;font-size:.85rem}
|
||||
.actions{display:flex;gap:.75rem;align-items:center}
|
||||
button{background:#0f766e;color:#fff;border:0;padding:.55rem 1rem;border-radius:4px;cursor:pointer}
|
||||
a{color:#0f766e}
|
||||
</style></head><body>"#,
|
||||
);
|
||||
body.push_str(&format!(
|
||||
"<h1>{}</h1><p class=\"meta\">table=<code>{}</code> · action=<code>{}</code></p>",
|
||||
esc(form_id),
|
||||
esc(table),
|
||||
esc(action)
|
||||
));
|
||||
body.push_str(&format!(
|
||||
"<form method=\"post\" action=\"/_form/{}\">",
|
||||
esc(form_id)
|
||||
));
|
||||
for f in &fields {
|
||||
let name = f.get("name").and_then(|v| v.as_str()).unwrap_or("");
|
||||
let label = f.get("label").and_then(|v| v.as_str()).unwrap_or(name);
|
||||
let ty = f.get("type").and_then(|v| v.as_str()).unwrap_or("text");
|
||||
let required = f.get("required").and_then(|v| v.as_bool()).unwrap_or(false);
|
||||
let default = f.get("default").and_then(|v| v.as_str()).unwrap_or("");
|
||||
let value = if data.contains_key(name) {
|
||||
field_text(&data, name)
|
||||
} else {
|
||||
default.to_string()
|
||||
};
|
||||
let req_attr = if required { " required" } else { "" };
|
||||
body.push_str("<label>");
|
||||
body.push_str(&esc(label));
|
||||
if ty == "textarea" {
|
||||
body.push_str(&format!(
|
||||
"<textarea name=\"{}\" rows=\"5\"{}>{}</textarea>",
|
||||
esc(name),
|
||||
req_attr,
|
||||
esc(&value)
|
||||
));
|
||||
} else {
|
||||
let input_type = match ty {
|
||||
"number" | "email" | "url" | "checkbox" => ty,
|
||||
_ => "text",
|
||||
};
|
||||
if ty == "checkbox" {
|
||||
let checked = matches!(value.as_str(), "1" | "true" | "on" | "yes");
|
||||
body.push_str(&format!(
|
||||
"<input type=\"checkbox\" name=\"{}\" value=\"1\"{}{}/>",
|
||||
esc(name),
|
||||
if checked { " checked" } else { "" },
|
||||
req_attr
|
||||
));
|
||||
} else {
|
||||
body.push_str(&format!(
|
||||
"<input type=\"{}\" name=\"{}\" value=\"{}\"{}/>",
|
||||
esc(input_type),
|
||||
esc(name),
|
||||
esc(&value),
|
||||
req_attr
|
||||
));
|
||||
}
|
||||
}
|
||||
if let Some(msg) = err_map.get(name).and_then(|v| v.as_str()) {
|
||||
body.push_str(&format!("<span class=\"err\">{}</span>", esc(msg)));
|
||||
}
|
||||
body.push_str("</label>");
|
||||
}
|
||||
body.push_str(
|
||||
"<div class=\"actions\"><button type=\"submit\">Submit</button><a href=\"/\">home</a></div>",
|
||||
);
|
||||
body.push_str("</form></body></html>");
|
||||
body
|
||||
}
|
||||
|
||||
pub fn submit(form: &Value, data: &Value, db_url: &str) -> Result<Value, String> {
|
||||
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,
|
||||
}))
|
||||
}
|
||||
+64
-8
@@ -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<String>,
|
||||
admin: bool,
|
||||
forms: HashMap<String, Value>,
|
||||
}
|
||||
|
||||
pub fn listen(
|
||||
@@ -26,16 +29,19 @@ pub fn listen(
|
||||
host: &str,
|
||||
port: u16,
|
||||
admin: bool,
|
||||
forms: HashMap<String, Value>,
|
||||
) -> Result<Value, String> {
|
||||
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<Arc<AppState>>, Path(id): Path<String>) -> Respon
|
||||
Html(html).into_response()
|
||||
}
|
||||
|
||||
async fn form_get(State(st): State<Arc<AppState>>, Path(id): Path<String>) -> Response {
|
||||
let Some(frm) = st.forms.get(&id) else {
|
||||
return Html(format!("<p>unknown form {id}</p>")).into_response();
|
||||
};
|
||||
Html(form::render(frm, &id, None, None)).into_response()
|
||||
}
|
||||
|
||||
async fn form_post(
|
||||
State(st): State<Arc<AppState>>,
|
||||
Path(id): Path<String>,
|
||||
Form(posted): Form<HashMap<String, String>>,
|
||||
) -> Response {
|
||||
let Some(frm) = st.forms.get(&id) else {
|
||||
return Html(format!("<p>unknown form {id}</p>")).into_response();
|
||||
};
|
||||
let Some(url) = st.db_url.as_deref() else {
|
||||
return Html(String::from("<p>no database</p>")).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!("<p>submit error: {}</p>", esc(&e))).into_response(),
|
||||
}
|
||||
}
|
||||
|
||||
async fn admin_home(State(st): State<Arc<AppState>>) -> Response {
|
||||
if !st.admin {
|
||||
return Html(String::from("<p>admin disabled</p>")).into_response();
|
||||
@@ -88,6 +133,12 @@ async fn admin_home(State(st): State<Arc<AppState>>) -> Response {
|
||||
for t in &tables {
|
||||
body.push_str(&format!("<li><a href=\"/admin/{t}\">{t}</a></li>"));
|
||||
}
|
||||
if !st.forms.is_empty() {
|
||||
body.push_str("</ul><h2>forms</h2><ul>");
|
||||
for id in st.forms.keys() {
|
||||
body.push_str(&format!("<li><a href=\"/_form/{id}\">{id}</a></li>"));
|
||||
}
|
||||
}
|
||||
body.push_str("</ul><p><a href=\"/\">home</a></p></body></html>");
|
||||
Html(body).into_response()
|
||||
}
|
||||
@@ -110,7 +161,9 @@ async fn admin_table(State(st): State<Arc<AppState>>, Path(table): Path<String>)
|
||||
let mut body = format!(
|
||||
"<!DOCTYPE html><html><head><meta charset=\"utf-8\"/><title>{table}</title></head><body>"
|
||||
);
|
||||
body.push_str(&format!("<h1>{table}</h1><p><a href=\"/admin\">back</a></p><table border=\"1\" cellpadding=\"6\"><thead><tr>"));
|
||||
body.push_str(&format!(
|
||||
"<h1>{table}</h1><p><a href=\"/admin\">back</a></p><table border=\"1\" cellpadding=\"6\"><thead><tr>"
|
||||
));
|
||||
let cols: Vec<String> = rows
|
||||
.first()
|
||||
.and_then(|r| r.as_object())
|
||||
@@ -124,11 +177,14 @@ async fn admin_table(State(st): State<Arc<AppState>>, Path(table): Path<String>)
|
||||
body.push_str("<tr>");
|
||||
let m = row.as_object().cloned().unwrap_or_else(Map::new);
|
||||
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();
|
||||
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();
|
||||
body.push_str(&format!("<td>{}</td>", esc(&cell)));
|
||||
}
|
||||
body.push_str("</tr>");
|
||||
|
||||
+106
-4
@@ -2,6 +2,7 @@
|
||||
|
||||
mod compose;
|
||||
mod db;
|
||||
mod form;
|
||||
mod http;
|
||||
mod render;
|
||||
mod table;
|
||||
@@ -330,11 +331,90 @@ web_ffi!(web_app_new, |args: &Value| {
|
||||
"host": host,
|
||||
"port": port,
|
||||
"admin": admin,
|
||||
"forms": {},
|
||||
}))
|
||||
});
|
||||
|
||||
web_ffi!(web_app_mount_form, |args: &Value| {
|
||||
let mut app = args.get("app").cloned().unwrap_or(json!({}));
|
||||
let id = arg_str(args, "id")?.to_string();
|
||||
let form_v = args
|
||||
.get("form")
|
||||
.cloned()
|
||||
.ok_or_else(|| "missing `form`".to_string())?;
|
||||
let obj = app.as_object_mut().ok_or_else(|| "app must be a map".to_string())?;
|
||||
let forms = obj
|
||||
.entry("forms".to_string())
|
||||
.or_insert_with(|| json!({}));
|
||||
let fmap = forms
|
||||
.as_object_mut()
|
||||
.ok_or_else(|| "app.forms must be a map".to_string())?;
|
||||
fmap.insert(id, form_v);
|
||||
Ok(app)
|
||||
});
|
||||
|
||||
web_ffi!(web_form_new, |args: &Value| {
|
||||
let table = arg_str_opt(args, "table");
|
||||
let action = arg_str_opt(args, "action").unwrap_or("insert");
|
||||
let id = arg_str_opt(args, "id");
|
||||
Ok(form::form_new(table, action, id))
|
||||
});
|
||||
|
||||
web_ffi!(web_form_fields, |args: &Value| {
|
||||
let form_v = args.get("form").cloned().unwrap_or(json!({}));
|
||||
let fields = args
|
||||
.get("fields")
|
||||
.cloned()
|
||||
.ok_or_else(|| "missing `fields`".to_string())?;
|
||||
Ok(form::set_fields(&form_v, &fields))
|
||||
});
|
||||
|
||||
web_ffi!(web_form_rules, |args: &Value| {
|
||||
let form_v = args.get("form").cloned().unwrap_or(json!({}));
|
||||
let rules = args
|
||||
.get("rules")
|
||||
.cloned()
|
||||
.ok_or_else(|| "missing `rules`".to_string())?;
|
||||
Ok(form::set_rules(&form_v, &rules))
|
||||
});
|
||||
|
||||
web_ffi!(web_form_validate, |args: &Value| {
|
||||
let form_v = args.get("form").cloned().unwrap_or(json!({}));
|
||||
let data = args
|
||||
.get("data")
|
||||
.cloned()
|
||||
.ok_or_else(|| "missing `data`".to_string())?;
|
||||
let rules = args.get("rules");
|
||||
Ok(form::validate(&form_v, rules, &data))
|
||||
});
|
||||
|
||||
web_ffi!(web_form_render, |args: &Value| {
|
||||
let form_v = args.get("form").cloned().unwrap_or(json!({}));
|
||||
let id = arg_str_opt(args, "id").unwrap_or("form");
|
||||
let data = args.get("data");
|
||||
let errors = args.get("errors");
|
||||
Ok(Value::String(form::render(
|
||||
&form_v,
|
||||
id,
|
||||
data,
|
||||
errors,
|
||||
)))
|
||||
});
|
||||
|
||||
web_ffi!(web_form_submit, |args: &Value| {
|
||||
let form_v = args.get("form").cloned().unwrap_or(json!({}));
|
||||
let data = args
|
||||
.get("data")
|
||||
.cloned()
|
||||
.ok_or_else(|| "missing `data`".to_string())?;
|
||||
let url = db_url_of(args)?;
|
||||
form::submit(&form_v, &data, &url)
|
||||
});
|
||||
|
||||
web_ffi!(web_listen, |args: &Value| {
|
||||
let (page, db_url, host, port, admin) = if args.get("page").is_some() || args.get("host").is_some()
|
||||
use std::collections::HashMap;
|
||||
let (page, db_url, host, port, admin, forms) = if args.get("page").is_some()
|
||||
|| args.get("host").is_some()
|
||||
{
|
||||
let page = args.get("page").cloned().unwrap_or(json!({}));
|
||||
let db_url = db_url_of(args).ok();
|
||||
@@ -347,7 +427,8 @@ web_ffi!(web_listen, |args: &Value| {
|
||||
Some(Value::Bool(b)) => *b,
|
||||
_ => false,
|
||||
};
|
||||
(page, db_url, host.to_string(), port, admin)
|
||||
let forms = HashMap::new();
|
||||
(page, db_url, host.to_string(), port, admin, forms)
|
||||
} else {
|
||||
let app = args.get("app").cloned().unwrap_or_else(|| args.clone());
|
||||
let page = app.get("page").cloned().unwrap_or(json!({}));
|
||||
@@ -370,9 +451,15 @@ web_ffi!(web_listen, |args: &Value| {
|
||||
.get("admin")
|
||||
.and_then(|v| v.as_bool())
|
||||
.unwrap_or(false);
|
||||
(page, db_url, host, port, admin)
|
||||
let mut forms = HashMap::new();
|
||||
if let Some(obj) = app.get("forms").and_then(|v| v.as_object()) {
|
||||
for (k, v) in obj {
|
||||
forms.insert(k.clone(), v.clone());
|
||||
}
|
||||
}
|
||||
(page, db_url, host, port, admin, forms)
|
||||
};
|
||||
http::listen(&page, db_url.as_deref(), &host, port, admin)
|
||||
http::listen(&page, db_url.as_deref(), &host, port, admin, forms)
|
||||
});
|
||||
|
||||
fn register(host: &MarqdoHostApi, name: &str, params: &str, fn_ptr: PluginFn) -> c_int {
|
||||
@@ -430,6 +517,21 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
|
||||
"page,db,admin,host,port",
|
||||
web_app_new as PluginFn,
|
||||
),
|
||||
(
|
||||
"web_app_mount_form",
|
||||
"app,id,form",
|
||||
web_app_mount_form as PluginFn,
|
||||
),
|
||||
("web_form_new", "table,action,id", web_form_new as PluginFn),
|
||||
("web_form_fields", "form,fields", web_form_fields as PluginFn),
|
||||
("web_form_rules", "form,rules", web_form_rules as PluginFn),
|
||||
(
|
||||
"web_form_validate",
|
||||
"form,rules,data",
|
||||
web_form_validate as PluginFn,
|
||||
),
|
||||
("web_form_render", "form,id", web_form_render as PluginFn),
|
||||
("web_form_submit", "form,data,url", web_form_submit as PluginFn),
|
||||
("web_listen", "app", web_listen as PluginFn),
|
||||
];
|
||||
for (name, params, f) in regs {
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
use crate::db;
|
||||
use crate::table::{as_bind, normalize_slot, project_rows};
|
||||
use crate::table::{as_bind, normalize_ref, normalize_slot, parse_site_path, project_rows, SitePath};
|
||||
|
||||
fn esc(s: &str) -> String {
|
||||
s.replace('&', "&")
|
||||
@@ -30,6 +30,33 @@ fn class_attr(css: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
fn is_simple_ident(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& s.chars()
|
||||
.all(|c| c.is_ascii_alphanumeric() || c == '_' || !c.is_ascii())
|
||||
}
|
||||
|
||||
/// True when `back` is a DB field path (`table.col` / `mod.table.col`), not a URL or site path.
|
||||
fn is_db_bind_back(back: &str) -> bool {
|
||||
let s = normalize_ref(back);
|
||||
if s.is_empty()
|
||||
|| s.contains("://")
|
||||
|| s.starts_with('/')
|
||||
|| s.starts_with('#')
|
||||
|| s.starts_with('?')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
match parse_site_path(&s) {
|
||||
SitePath::DbField { .. } => true,
|
||||
SitePath::LibMember { lib, member } => is_simple_ident(&lib) && is_simple_ident(&member),
|
||||
SitePath::Plain(p) => {
|
||||
let parts: Vec<&str> = p.split('.').filter(|x| !x.is_empty()).collect();
|
||||
parts.len() == 2 && parts.iter().all(|x| is_simple_ident(x))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_links(raw: Option<&Value>, db_url: Option<&str>) -> Vec<(String, String)> {
|
||||
let Some(raw) = raw else {
|
||||
return Vec::new();
|
||||
@@ -39,11 +66,9 @@ fn resolve_links(raw: Option<&Value>, db_url: Option<&str>) -> Vec<(String, Stri
|
||||
if arr.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let has_db = arr.iter().any(|b| {
|
||||
b.get("back")
|
||||
.and_then(|v| v.as_str())
|
||||
.is_some_and(|s| s.contains('.'))
|
||||
});
|
||||
let has_db = arr
|
||||
.iter()
|
||||
.any(|b| b.get("back").and_then(|v| v.as_str()).is_some_and(is_db_bind_back));
|
||||
if has_db {
|
||||
let Some(url) = db_url else {
|
||||
return Vec::new();
|
||||
@@ -80,7 +105,7 @@ fn resolve_links(raw: Option<&Value>, db_url: Option<&str>) -> Vec<(String, Stri
|
||||
}
|
||||
return out;
|
||||
}
|
||||
// static: front=label back=href
|
||||
// static: front=label back=href (URLs with `.` must stay here)
|
||||
arr.into_iter()
|
||||
.map(|b| {
|
||||
let label = b.get("front").map(text).unwrap_or_default();
|
||||
|
||||
Reference in new issue
Block a user