✨ (admin): Integra el panel de administración

El núcleo reúne al arrancar las secciones, páginas, pestañas y
botones que declaran las extensiones. La plantilla Admin pinta la
navegación (AdminMenu) y el marco de cada página (AdminFrame), y
PageTop monta el dashboard y las páginas de sección. La raíz del
panel se configura con admin_path.
This commit is contained in:
Manuel Cillero 2026-11-07 07:16:15 +01:00
parent ecba7b2bd8
commit 8e0c887ba6
24 changed files with 1737 additions and 19 deletions

View file

@ -2,6 +2,12 @@
pub mod layout;
mod admin_frame;
pub use admin_frame::AdminFrame;
mod admin_menu;
pub use admin_menu::AdminMenu;
mod badge;
pub use badge::Badge;

View file

@ -0,0 +1,175 @@
use crate::prelude::*;
/// Marco de una página del panel de administración, alrededor de la región
/// [`CoreRegions::Content`].
///
/// Pinta, para la ruta de la petición actual, las migas de pan del panel, el título de la página
/// ([`Contextual::title()`]) con sus botones de acción ([`AdminAction`]), las pestañas de la
/// página ([`AdminTask`]) y, después, el contenido. Si la página no tiene título, usa el de la
/// página declarada para esa ruta, también en el `<title>` del documento:
///
/// ```html
/// <nav class="breadcrumb">...</nav>
/// <header class="admin-header">
/// <h1 class="admin-page-title">Title</h1>
/// <ul class="admin-actions-list">...</ul>
/// </header>
/// <nav class="admin-local-tasks">...</nav>
/// <div class="admin-content">...</div>
/// ```
///
/// La plantilla [`CoreTemplates::Admin`] lo pinta en lugar de la región `Content`, así que un
/// *handler* sólo tiene que crear la página con [`Page::admin()`], darle título y añadir su
/// contenido. Un tema puede capturarlo en [`Theme::render_component()`] para darle otro aspecto,
/// pero entonces le corresponde pintar también la región `Content`
/// ([`layout::Region::content()`](crate::base::component::layout::Region::content)).
///
/// Para una ruta que no es una página declarada (p. ej. la edición de un elemento de un listado),
/// las migas enlazan con la página declarada más cercana que la contiene.
///
/// [`Page::admin()`]: crate::response::Page::admin
/// [`Theme::render_component()`]: crate::core::theme::Theme::render_component
#[derive(AutoDefault, Clone, Debug)]
pub struct AdminFrame;
#[async_trait]
impl Component for AdminFrame {
fn new() -> Self {
Self
}
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
// Ruta de la petición relativa a la raíz del panel, como se guarda en el registro.
let path = cx
.request()
.and_then(|r| strip_admin_path(r.path()))
.unwrap_or_default()
.to_owned();
// Sin título propio, la página declarada aporta el suyo, también al `<head>` (que se
// renderiza después del `<body>`).
if cx.title().is_none()
&& let Some(page) = AdminRegistry::global().pages().get(&path)
{
cx.alter_title(page.title.clone());
}
let breadcrumbs = breadcrumbs(cx, &path).render(cx).await;
let actions = local_actions(cx, &path);
let tasks = local_tasks(cx, &path);
let content = layout::Region::content().render(cx).await;
let title = cx.title().using(cx);
Ok(html! {
(breadcrumbs)
header class="admin-header" {
@if !title.is_empty() {
h1 class="admin-page-title" { (title) }
}
(actions)
}
@if !tasks.is_empty() {
nav class="admin-local-tasks" { (tasks) }
}
div class="admin-content" {
(content)
}
})
}
}
// Inicio del panel, sección y página de la ruta. La última miga es la página actual, sin enlace.
fn breadcrumbs(cx: &Context, path: &str) -> Breadcrumb {
if path.is_empty() {
return Breadcrumb::new().with_crumb(breadcrumb::Crumb::current(Lc::l("admin_dashboard")));
}
let registry = AdminRegistry::global();
let mut bc = Breadcrumb::new().with_crumb(breadcrumb::Crumb::new(
Lc::l("admin_dashboard"),
admin_path(""),
));
if let Some(page) = registry.nearest_page(path) {
if let Some(section) = registry.sections().get(&page.section) {
bc = bc.with_crumb(breadcrumb::Crumb::new(
section.title.clone(),
admin_path(&section.path),
));
}
if page.path == path {
bc = bc.with_crumb(breadcrumb::Crumb::current(page.title.clone()));
} else {
bc = bc.with_crumb(breadcrumb::Crumb::new(
page.title.clone(),
admin_path(&page.path),
));
if !cx.title().is_none() {
bc = bc.with_crumb(breadcrumb::Crumb::current(cx.title().clone()));
}
}
} else if let Some(section) = registry.sections().values().find(|s| s.path == path) {
// La ruta es la propia sección (su página de aterrizaje), no una página declarada en ella.
bc = bc.with_crumb(breadcrumb::Crumb::current(section.title.clone()));
}
bc
}
// Pestañas de la página de la ruta, también cuando la ruta es una de ellas. Las que exigen un
// permiso que el usuario no tiene no se muestran.
fn local_tasks(cx: &Context, path: &str) -> Markup {
let registry = AdminRegistry::global();
let parent = registry
.tasks()
.values()
.flatten()
.find(|task| task.path == path)
.map_or(path, |task| task.parent_path.as_str());
let tasks: Vec<_> = registry
.tasks_for(parent)
.into_iter()
.filter(|task| is_granted(cx, task.permission))
.collect();
if tasks.is_empty() {
return html! {};
}
html! {
ul class="admin-tasks-list" {
@for task in tasks {
li class="admin-task" .admin-task-active[task.path == path] {
a href=(cx.route(admin_path(&task.path))) { (task.title.using(cx)) }
}
}
}
}
}
// Botones de acción de la página de la ruta. Los que exigen un permiso que el usuario no tiene no
// se muestran.
fn local_actions(cx: &Context, path: &str) -> Markup {
let actions: Vec<_> = AdminRegistry::global()
.actions_for(path)
.into_iter()
.filter(|action| is_granted(cx, action.permission))
.collect();
if actions.is_empty() {
return html! {};
}
html! {
ul class="admin-actions-list" {
@for action in actions {
li class="admin-action" {
a class="admin-action-link" href=(cx.route(admin_path(&action.url))) {
(action.title.using(cx))
}
}
}
}
}
}
// Sin permiso propio (`None`) basta con ver la página, cuyo permiso ya ha exigido su ruta.
fn is_granted(cx: &Context, permission: Option<PermissionRef>) -> bool {
permission.is_none_or(|permission| {
cx.request()
.is_some_and(|request| has_permission(request, permission))
})
}

View file

@ -0,0 +1,60 @@
use crate::prelude::*;
/// Navegación del panel de administración para el usuario de la petición actual.
///
/// Es una [`Navbar`] con un enlace al inicio del panel (*dashboard*) seguido de un desplegable por
/// sección, con las páginas de cada una a las que el usuario puede acceder; las secciones sin
/// ninguna no se muestran. Lo construye en cada petición a partir de [`AdminRegistry`].
///
/// La plantilla [`CoreTemplates::Admin`] lo pinta tras la región [`CoreRegions::Header`]. Se
/// construye sólo con componentes del núcleo (`Navbar`, `Nav` y `Dropdown`), así que un tema le da
/// su aspecto capturando esos componentes o éste mismo en [`Theme::render_component()`].
///
/// Sin acceso a ninguna página del panel ([`can_access_admin()`]) no se renderiza: no se despachan
/// sus acciones ni intervienen los temas.
///
/// [`Theme::render_component()`]: crate::core::theme::Theme::render_component
#[derive(AutoDefault, Clone, Debug)]
pub struct AdminMenu;
#[async_trait]
impl Component for AdminMenu {
fn new() -> Self {
Self
}
fn is_renderable(&self, cx: &Context) -> bool {
can_access_admin(cx)
}
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let registry = AdminRegistry::global();
let mut nav =
Nav::new().with_item(nav::Item::link(Lc::l("admin_dashboard"), admin_path("")));
for section in registry.ordered_sections() {
let pages: Vec<_> = registry
.pages_for_section(&section.key)
.into_iter()
.filter(|p| p.is_accessible(cx))
.collect();
if pages.is_empty() {
continue;
}
let mut menu = Dropdown::new().with_title(section.title.clone());
for page in pages {
menu = menu.with_item(dropdown::Item::link(
page.title.clone(),
admin_path(&page.path),
));
}
nav = nav.with_item(nav::Item::dropdown(menu));
}
Ok(Navbar::simple()
.with_prop(PropsOp::add_classes("admin-menu"))
.with_item(navbar::Item::nav(nav))
.render(cx)
.await)
}
}

View file

@ -10,6 +10,10 @@ use std::fmt;
/// su gusto (por ejemplo, usando CSS Grid, para que `Aside` se muestre como columna lateral junto a
/// `Content`). Si `Aside`, o cualquier otra región, no tiene contenido, no se renderiza.
///
/// [`CoreTemplates::Admin`] añade el panel de administración: tras `Header` pinta la navegación
/// del panel ([`AdminMenu`]) y, en lugar de `Content`, el marco de la página ([`AdminFrame`]), que
/// contiene la región; el contenedor lleva además la clase `wrapper-admin`.
///
/// No incluye las regiones reservadas ([`ReservedRegions::PageTop`] y
/// [`ReservedRegions::PageBottom`]) porque el propio [`Page::render()`] las añade antes y después
/// del resultado de [`Theme::render_page_body()`] para que se rendericen siempre,
@ -65,11 +69,25 @@ impl Component for Template {
}
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let body = html! {
(layout::Region::header().render(cx).await)
(layout::Region::aside().render(cx).await)
(layout::Region::content().render(cx).await)
(layout::Region::footer().render(cx).await)
let admin = matches!(
self.template().downcast_ref::<CoreTemplates>(),
Some(CoreTemplates::Admin)
);
let body = if admin {
html! {
(layout::Region::header().render(cx).await)
(AdminMenu::new().render(cx).await)
(layout::Region::aside().render(cx).await)
(AdminFrame::new().render(cx).await)
(layout::Region::footer().render(cx).await)
}
} else {
html! {
(layout::Region::header().render(cx).await)
(layout::Region::aside().render(cx).await)
(layout::Region::content().render(cx).await)
(layout::Region::footer().render(cx).await)
}
};
if body.is_empty() {
@ -77,7 +95,7 @@ impl Component for Template {
}
Ok(html! {
div class="wrapper" {
div class="wrapper" .wrapper-admin[admin] {
(body)
}
})