use serde_json::Value;
use tera::{Context, Tera};
use crate::block::{self, BlockField};
use crate::widget::{Widget, WidgetKind};
#[must_use]
pub fn render_stream_editor(
widget: &Widget,
tera: &Tera,
) -> String {
render_stream_editor_with(widget, tera, None)
}
#[must_use]
pub fn render_stream_editor_with(
widget: &Widget,
tera: &Tera,
dyn_set: Option<&crate::page_builder::DynBlockSet>,
) -> String {
let parsed: Value = serde_json::from_str(&widget.value).unwrap_or(Value::Array(Vec::new()));
let blocks_arr = parsed.as_array().cloned().unwrap_or_default();
let mut out = String::new();
out.push_str(r#"<div class="rcms-stream-list" data-stream-list>"#);
for entry in &blocks_arr {
if let Some(html) = render_block_entry(entry, tera, dyn_set) {
out.push_str(&html);
}
}
out.push_str("</div>");
let mut needed: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
let mut frontier: Vec<String> = widget.allowed.to_vec();
while let Some(name) = frontier.pop() {
if !needed.insert(name.clone()) {
continue;
}
if let Some(block) = crate::page_builder::resolve_block(dyn_set, &name) {
for field in block.fields() {
match field {
BlockField::Stream { allowed, .. } => {
for a in allowed {
if !needed.contains(&a) {
frontier.push(a);
}
}
}
BlockField::Repeat { item_type, .. } => {
if !needed.contains(&item_type) {
frontier.push(item_type);
}
}
_ => {}
}
}
}
}
for ref_name in &needed {
let is_dyn = dyn_set.map_or(false, |s| s.get(ref_name).is_some());
if is_dyn {
if let Some(block) = crate::page_builder::resolve_block(dyn_set, ref_name) {
let empty_body = render_block_inline(
&*block,
&Value::Object(Default::default()),
None,
tera,
dyn_set,
);
out.push_str(&format!(
r#"<template data-block-template="{}">{}</template>"#,
tera::escape_html(ref_name),
empty_body,
));
}
continue;
}
let key = ref_name.clone();
if let Some(hit) = template_cache()
.lock()
.ok()
.and_then(|c| c.get(&key).cloned())
{
out.push_str(&hit);
continue;
}
if let Some(block) = crate::page_builder::resolve_block(dyn_set, ref_name) {
let empty_body = render_block_inline(
&*block,
&Value::Object(Default::default()),
None,
tera,
dyn_set,
);
let rendered = format!(
r#"<template data-block-template="{}">{}</template>"#,
tera::escape_html(ref_name),
empty_body,
);
if let Ok(mut c) = template_cache().lock() {
c.insert(key, rendered.clone());
}
out.push_str(&rendered);
}
}
out
}
type TemplateCache = std::sync::Mutex<std::collections::HashMap<String, String>>;
fn template_cache() -> &'static TemplateCache {
static CACHE: std::sync::OnceLock<TemplateCache> = std::sync::OnceLock::new();
CACHE.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
}
fn render_block_entry(
entry: &Value,
tera: &Tera,
dyn_set: Option<&crate::page_builder::DynBlockSet>,
) -> Option<String> {
let type_name = entry.get("type").and_then(Value::as_str)?;
let id = entry.get("id").and_then(Value::as_str).map(str::to_owned);
let value = entry.get("value").unwrap_or(&Value::Null);
let block = crate::page_builder::resolve_block(dyn_set, type_name)?;
Some(render_block_inline(
&*block,
value,
id.as_deref(),
tera,
dyn_set,
))
}
fn render_block_inline(
block: &dyn block::Block,
value: &Value,
id: Option<&str>,
tera: &Tera,
dyn_set: Option<&crate::page_builder::DynBlockSet>,
) -> String {
let mut html = String::new();
let id_attr = match id {
Some(s) => format!(r#" data-id="{}""#, tera::escape_html(s)),
None => String::new(),
};
let label_format_attr = match block.label_format() {
Some(fmt) => format!(r#" data-label-format="{}""#, tera::escape_html(fmt),),
None => String::new(),
};
html.push_str(&format!(
r#"<div class="rcms-stream-block" data-stream-block data-type="{type}"{id} data-version="{version}"{label_format}>"#,
type = tera::escape_html(block.type_name()),
id = id_attr,
version = block.version(),
label_format = label_format_attr,
));
let initial_label = match block.label_format() {
Some(fmt) => {
let rendered = format_label(fmt, value);
if rendered.trim().is_empty() {
block.verbose_name().to_owned()
} else {
rendered
}
}
None => block.verbose_name().to_owned(),
};
html.push_str(r#"<div class="rcms-stream-block-header">"#);
if let Some(icon) = block.icon() {
html.push_str(&format!(
r#"<span class="material-symbols-rounded sm rcms-stream-block-icon">{}</span>"#,
tera::escape_html(icon),
));
}
html.push_str(&format!(
r#"<strong class="rcms-stream-block-title" data-stream-block-title>{}</strong>"#,
tera::escape_html(&initial_label),
));
html.push_str(concat!(
r#"<span class="rcms-stream-block-actions">"#,
r#"<button type="button" class="rcms-btn" data-action="toggle-collapse" title="Collapse / expand"><span class="material-symbols-rounded sm">unfold_less</span></button>"#,
r#"<button type="button" class="rcms-btn" data-action="move-up" title="Move up"><span class="material-symbols-rounded sm">arrow_upward</span></button>"#,
r#"<button type="button" class="rcms-btn" data-action="move-down" title="Move down"><span class="material-symbols-rounded sm">arrow_downward</span></button>"#,
r#"<button type="button" class="rcms-btn" data-action="duplicate" title="Duplicate"><span class="material-symbols-rounded sm">content_copy</span></button>"#,
r#"<button type="button" class="rcms-btn" data-action="remove" title="Remove"><span class="material-symbols-rounded sm">close</span></button>"#,
r#"</span>"#,
));
html.push_str("</div>");
html.push_str(r#"<div class="rcms-stream-block-body">"#);
for field in block.fields() {
match field {
BlockField::Widget {
name,
label,
widget,
options,
help,
required,
meta,
} => {
let field_value = value.get(&name).cloned().unwrap_or(Value::Null);
let widget_value = json_to_widget_value(&field_value, &widget);
let instance_name = match id {
Some(block_id) => format!("blk_{block_id}__{name}"),
None => format!("blk_tpl__{name}"),
};
let mut w = Widget::new(widget, instance_name, label);
w.value = widget_value;
if let Some(h) = help {
w.help = h;
}
w.required = required;
w.options = options
.iter()
.map(|(v, l)| (v.clone(), l.clone()))
.collect();
if let Some(n) = meta.min_length {
w.min_length = Some(n);
}
if let Some(n) = meta.max_length {
w.max_length = Some(n);
}
if let Some(p) = meta.pattern.clone() {
w.pattern = p;
}
if let Some(v) = meta.min_value {
w.min = Some(v);
}
if let Some(v) = meta.max_value {
w.max = Some(v);
}
if let Some(f) = meta.chooser_filter.clone() {
w.custom_name = f;
}
if w.value.is_empty() {
if let Some(d) = meta.default_value.clone() {
w.value = d;
}
}
let widget_html = render_widget_via_macro(&w, tera);
html.push_str(&format!(
r#"<div class="rcms-stream-field" data-stream-field="{}">{}</div>"#,
tera::escape_html(&name),
widget_html,
));
}
BlockField::Stream {
name,
label,
allowed,
..
} => {
let nested_value = value
.get(&name)
.cloned()
.unwrap_or(Value::Array(Vec::new()));
let nested_arr = nested_value.as_array().cloned().unwrap_or_default();
let allowed_csv = allowed.join(",");
html.push_str(&format!(
r#"<fieldset class="rcms-stream-nested" data-stream-field="{name}"><legend>{label}</legend>"#,
name = tera::escape_html(&name),
label = tera::escape_html(&label),
));
html.push_str(&format!(
r#"<div class="rcms-stream-list" data-stream-list data-allowed="{}">"#,
tera::escape_html(&allowed_csv),
));
for entry in &nested_arr {
if let Some(inner) = render_block_entry(entry, tera, dyn_set) {
html.push_str(&inner);
}
}
html.push_str("</div>");
html.push_str(
r#"<div class="rcms-stream-picker"><button type="button" class="rcms-btn" data-action="open-picker" data-insert-at="end"><span class="material-symbols-rounded sm">add</span> Add block</button></div>"#,
);
html.push_str("</fieldset>");
}
BlockField::Repeat {
name,
label,
item_type,
..
} => {
let nested_value = value
.get(&name)
.cloned()
.unwrap_or(Value::Array(Vec::new()));
let nested_arr = nested_value.as_array().cloned().unwrap_or_default();
html.push_str(&format!(
r#"<fieldset class="rcms-stream-nested" data-stream-field="{name}"><legend>{label}</legend>"#,
name = tera::escape_html(&name),
label = tera::escape_html(&label),
));
html.push_str(&format!(
r#"<div class="rcms-stream-list" data-stream-list data-allowed="{}" data-repeat="1">"#,
tera::escape_html(&item_type),
));
for entry in &nested_arr {
if let Some(inner) = render_block_entry(entry, tera, dyn_set) {
html.push_str(&inner);
}
}
html.push_str("</div>");
html.push_str(&format!(
r#"<div class="rcms-stream-picker"><button type="button" class="rcms-btn" data-action="open-picker" data-insert-at="end"><span class="material-symbols-rounded sm">add</span> Add {}</button></div>"#,
tera::escape_html(&item_type),
));
html.push_str("</fieldset>");
}
BlockField::Computed {
name,
label,
render,
..
} => {
let value_html = render(value, &block::BlockRenderCtx::new(tera));
html.push_str(&format!(
r#"<div class="rcms-stream-field rcms-stream-field-computed" data-stream-field="{name}"><label>{label}</label><div class="rcms-computed-value">{value_html}</div></div>"#,
name = tera::escape_html(&name),
label = tera::escape_html(&label),
value_html = value_html,
));
}
}
}
html.push_str("</div>"); html.push_str("</div>"); html
}
fn json_to_widget_value(value: &Value, kind: &WidgetKind) -> String {
match value {
Value::Null => String::new(),
Value::String(s) => s.clone(),
Value::Bool(b) => {
if *b {
"true".to_owned()
} else {
String::new()
}
}
Value::Number(n) => n.to_string(),
Value::Array(_) | Value::Object(_) => {
if matches!(
kind,
WidgetKind::Checkboxes | WidgetKind::MultiSelect | WidgetKind::Stream
) {
serde_json::to_string(value).unwrap_or_else(|_| "[]".to_owned())
} else {
value.to_string()
}
}
}
}
pub fn render_widget_via_macro(w: &Widget, tera: &Tera) -> String {
render_widget_via_macro_with(w, tera, &[])
}
#[must_use]
pub fn render_widget_via_macro_with(
w: &Widget,
tera: &Tera,
picker_options: &[PickerOption],
) -> String {
let mut ctx = Context::new();
ctx.insert("w", w);
ctx.insert("picker_options", picker_options);
ctx.insert("LANG", "en");
if let Ok(html) = tera.render(SHARED_WRAPPER, &ctx) {
return html;
}
let mut t = tera.clone();
if t.add_raw_template(SHARED_WRAPPER, WRAPPER_SRC).is_err() {
return String::new();
}
t.render(SHARED_WRAPPER, &ctx).unwrap_or_default()
}
const SHARED_WRAPPER: &str = "rcms_admin/_stream_widget.html";
const WRAPPER_SRC: &str =
"{% import \"rcms_admin/_widget.html\" as widget %}{{ widget::render(w=w) }}";
#[derive(serde::Serialize)]
pub struct PickerOption {
pub type_name: String,
pub verbose_name: String,
pub icon: Option<String>,
pub group: Option<String>,
pub description: Option<String>,
pub default_value: Option<serde_json::Value>,
pub collapsed: bool,
pub preview_html: String,
}
#[must_use]
pub fn picker_options(tera: &Tera) -> Vec<PickerOption> {
let render_ctx = block::BlockRenderCtx::new(tera);
block::registered_blocks()
.map(|b| {
let preview_html = match b.preview_value() {
Some(sample) => {
match b.preview_template() {
Some(custom_tpl) => {
render_with_template(custom_tpl, &sample, b.type_name(), tera)
}
None => b.render(&sample, &render_ctx).unwrap_or_default(),
}
}
None => String::new(),
};
PickerOption {
type_name: b.type_name().to_owned(),
verbose_name: b.verbose_name().to_owned(),
icon: b.icon().map(str::to_owned),
group: b.group().map(str::to_owned),
description: b.description().map(str::to_owned),
default_value: b.default_value(),
collapsed: b.collapsed(),
preview_html,
}
})
.collect()
}
fn render_with_template(
template: &str,
sample_value: &Value,
type_name: &str,
tera: &Tera,
) -> String {
let mut ctx = Context::new();
ctx.insert("value", sample_value);
ctx.insert("block_type", type_name);
ctx.insert("computed", &Value::Object(serde_json::Map::new()));
tera.render(template, &ctx).unwrap_or_default()
}
fn format_label(fmt: &str, value: &Value) -> String {
let obj = value.as_object();
let mut out = String::with_capacity(fmt.len());
let mut chars = fmt.chars().peekable();
while let Some(c) = chars.next() {
if c == '{' {
let mut name = String::new();
let mut closed = false;
while let Some(&next) = chars.peek() {
chars.next();
if next == '}' {
closed = true;
break;
}
name.push(next);
}
if !closed {
out.push('{');
out.push_str(&name);
continue;
}
let resolved = obj
.and_then(|m| m.get(name.trim()))
.map(|v| match v {
Value::String(s) => s.clone(),
Value::Null => String::new(),
other => other.to_string().trim_matches('"').to_owned(),
})
.unwrap_or_default();
out.push_str(&resolved);
} else {
out.push(c);
}
}
out
}
#[cfg(test)]
mod label_format_tests {
use super::*;
#[test]
fn substitutes_single_field() {
let v = serde_json::json!({"text": "Welcome"});
assert_eq!(format_label("{text}", &v), "Welcome");
}
#[test]
fn substitutes_multiple_fields() {
let v = serde_json::json!({"text": "Welcome", "level": "2"});
assert_eq!(format_label("{text} (H{level})", &v), "Welcome (H2)");
}
#[test]
fn empty_for_missing_fields() {
let v = serde_json::json!({"text": "Welcome"});
assert_eq!(format_label("{text} — {missing}", &v), "Welcome — ");
}
#[test]
fn unterminated_brace_passes_through() {
let v = serde_json::json!({});
assert_eq!(format_label("hello {oops", &v), "hello {oops");
}
#[test]
fn null_field_is_empty() {
let v = serde_json::json!({"text": null});
assert_eq!(format_label("[{text}]", &v), "[]");
}
}