♻️ (admin): Navegación del panel con Nav::admin()

La plantilla Admin ya no pinta la navegación del panel: la coloca la
aplicación con Nav::admin(), en una barra aparte o en la suya. Se
elimina AdminMenu y AdminFrame pasa a layout::AdminFrame.
This commit is contained in:
Manuel Cillero 2026-11-16 13:09:08 +01:00
parent a29f0f2b75
commit 105d5a81af
15 changed files with 375 additions and 107 deletions

View file

@ -83,7 +83,9 @@
//! [`DeclareAdminTasks`]: crate::base::action::admin::DeclareAdminTasks
//! [`DeclareAdminActions`]: crate::base::action::admin::DeclareAdminActions
use crate::core::component::Context;
use crate::core::AnyCast;
use crate::core::component::{Context, Contextual};
use crate::core::theme::CoreTemplates;
use crate::{global, util};
mod bag;
@ -136,3 +138,25 @@ pub fn can_access_admin(cx: &Context) -> bool {
.iter()
.any(|page| registry.section(page.section()).is_some() && page.is_accessible(cx))
}
/// Devuelve `true` si la página es del panel de administración y el usuario tiene acceso a él.
///
/// Concretamente, devuelve `true` cuando la página actual del contexto utiliza la plantilla
/// [`CoreTemplates::Admin`] y el usuario de la petición puede acceder a alguna de las páginas del
/// panel ([`can_access_admin()`]).
///
/// Es la condición con la que se muestra la navegación del panel ([`Nav::admin()`]). Una página del
/// panel puede responder a quien no tiene acceso (el error 403 se pinta con la plantilla de la
/// página), así que no basta con comprobar la plantilla.
///
/// Sirve también para ocultar en el panel uno o más menús, negando esta función en su
/// [`Nav::with_renderable()`].
///
/// [`Nav::admin()`]: crate::base::component::Nav::admin
/// [`Nav::with_renderable()`]: crate::base::component::Nav::with_renderable
pub fn is_admin_panel(cx: &Context) -> bool {
matches!(
cx.template().downcast_ref::<CoreTemplates>(),
Some(CoreTemplates::Admin)
) && can_access_admin(cx)
}

View file

@ -2,12 +2,6 @@
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

@ -1,60 +0,0 @@
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.sections() {
let pages: Vec<_> = registry
.pages_for_section(section.key())
.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

@ -1,4 +1,7 @@
//! Definiciones para la composición de documentos ([`Region`] y [`Template`]).
//! Definiciones para la composición de documentos ([`Region`], [`Template`] y [`AdminFrame`]).
mod admin_frame;
pub use admin_frame::AdminFrame;
mod region;
pub use region::Region;

View file

@ -2,7 +2,7 @@ use crate::prelude::*;
/// Marco de las páginas de administración, alrededor de [`CoreRegions::Content`].
///
/// Pinta, para la ruta de la petición actual, las migas de pan del panel, el título de la página
/// Muestra, para la ruta de la petición actual, el *breadcrumb* 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:
@ -17,10 +17,10 @@ use crate::prelude::*;
/// <div class="admin-content">...</div>
/// ```
///
/// La plantilla [`CoreTemplates::Admin`] lo pinta en lugar de la región `Content`, así que un
/// La plantilla [`CoreTemplates::Admin`] lo muestra 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`
/// pero entonces le corresponde mostrar 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),

View file

@ -10,9 +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`.
/// [`CoreTemplates::Admin`] añade el panel de administración: en lugar de `Content` pinta el marco
/// de la página ([`AdminFrame`]), que contiene la región; el contenedor lleva además la clase
/// `wrapper-admin`. La navegación del panel no forma parte de la plantilla: la coloca la aplicación
/// donde quiera, con [`Nav::admin()`] en una barra aparte o en la suya.
///
/// No incluye las regiones reservadas ([`ReservedRegions::PageTop`] y
/// [`ReservedRegions::PageBottom`]) porque el propio [`Page::render()`] las añade antes y después
@ -28,6 +29,8 @@ use std::fmt;
/// intervenir en su renderizado.
///
/// [`Region`]: crate::base::component::layout::Region
/// [`AdminFrame`]: crate::base::component::layout::AdminFrame
/// [`Nav::admin()`]: crate::base::component::Nav::admin
/// [`ReservedRegions::PageTop`]: crate::response::ReservedRegions::PageTop
/// [`ReservedRegions::PageBottom`]: crate::response::ReservedRegions::PageBottom
/// [`Page::render()`]: crate::response::Page::render
@ -76,9 +79,8 @@ impl Component for Template {
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::AdminFrame::new().render(cx).await)
(layout::Region::footer().render(cx).await)
}
} else {

View file

@ -8,6 +8,9 @@ use crate::prelude::*;
/// Si no contiene elementos, o si ninguno se muestra (ver [`Endpoint`]), el componente **no se
/// renderiza**.
///
/// Con [`with_renderable()`](Nav::with_renderable) se puede decidir en cada petición si se muestra,
/// y con [`Nav::admin()`] presenta la navegación del panel de administración.
///
/// # Ejemplo
///
/// ```rust,no_run
@ -32,6 +35,13 @@ pub struct Nav {
nav_layout: nav::Layout,
/// Devuelve la lista de elementos del menú.
items: Children,
/// Devuelve la función que decide en cada petición si se renderiza, si la hay (ver
/// [`with_renderable()`](Nav::with_renderable)).
#[getters(copy)]
renderable: Option<FnIsRenderable>,
/// Indica si presenta la navegación del panel de administración (ver [`Nav::admin()`]).
#[getters(copy)]
is_admin: bool,
}
#[async_trait]
@ -44,7 +54,11 @@ impl Component for Nav {
self.props.get_id()
}
fn setup(&mut self, _cx: &mut Context) {
fn is_renderable(&self, cx: &Context) -> bool {
self.renderable().is_none_or(|f| f(cx)) && (!self.is_admin() || is_admin_panel(cx))
}
fn setup(&mut self, cx: &mut Context) {
self.alter_prop(PropsOp::prepend_classes(match self.nav_layout() {
nav::Layout::Default => "nav",
nav::Layout::Start => "nav nav-start",
@ -54,6 +68,10 @@ impl Component for Nav {
nav::Layout::Fill => "nav nav-fill",
nav::Layout::Justified => "nav nav-justified",
}));
if self.is_admin() {
self.alter_prop(PropsOp::add_classes("nav-admin"));
self.add_admin_items(cx);
}
}
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
@ -70,6 +88,89 @@ impl Component for Nav {
}
}
impl Nav {
/// Crea la navegación del panel de administración para el usuario de la petición actual.
///
/// Al renderizarse añade 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. Los construye en cada petición a partir de [`AdminRegistry`],
/// detrás de los elementos que se hayan añadido con [`with_item()`](Self::with_item).
///
/// Sólo se renderiza en las páginas del panel y si el usuario puede acceder a él
/// ([`is_admin_panel()`]); en las demás no se despachan sus acciones ni intervienen los temas.
/// Así puede colocarse en una barra o región presente en todas las páginas. Para que ocupe en
/// el panel el sitio de otro menú, ese otro menú se oculta en el panel con
/// [`with_renderable()`](Self::with_renderable) (ver el ejemplo).
///
/// La plantilla [`CoreTemplates::Admin`] no la pinta: la coloca la aplicación donde quiera,
/// como cualquier otro menú, con su disposición, clases y propiedades. Lleva además la clase
/// `nav-admin`, para que los temas puedan darle un aspecto propio.
///
/// # Ejemplos
///
/// En una barra aparte bajo la cabecera, centrada:
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// let admin = Navbar::simple().with_item(navbar::Item::nav(
/// Nav::admin()
/// .with_layout(nav::Layout::Center)
/// .with_prop(FlexItem::new().with_grow(flex::ItemGrow::Is1)),
/// ));
///
/// InRegion::Global(&CoreRegions::Header).add(admin);
/// ```
///
/// En la barra principal, junto al menú de la aplicación y centrada en el espacio libre:
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// let navbar = Navbar::brand_left(Brand::new().with_title(Lc::n("My app")))
/// .with_item(navbar::Item::nav(
/// Nav::new().with_item(nav::Item::link(Lc::n("Home"), "/")),
/// ))
/// .with_item(navbar::Item::nav(
/// Nav::admin()
/// .with_layout(nav::Layout::Center)
/// .with_prop(FlexItem::new().with_grow(flex::ItemGrow::Is1)),
/// ));
///
/// InRegion::Global(&CoreRegions::Header).add(navbar);
/// ```
pub fn admin() -> Self {
Self {
is_admin: true,
..Self::default()
}
}
// Añade el enlace al *dashboard* y un desplegable por sección con las páginas a las que puede
// acceder el usuario de la petición.
fn add_admin_items(&mut self, cx: &Context) {
let registry = AdminRegistry::global();
self.alter_item(nav::Item::link(Lc::l("admin_dashboard"), admin_path("")));
for section in registry.sections() {
let mut pages = registry
.pages_for_section(section.key())
.iter()
.filter(|p| p.is_accessible(cx))
.peekable();
if pages.peek().is_none() {
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()),
));
}
self.alter_item(nav::Item::dropdown(menu));
}
}
}
#[builder_impl]
impl Nav {
// **< Nav BUILDER >****************************************************************************
@ -92,6 +193,38 @@ impl Nav {
self
}
/// Asigna una función que decide en cada petición si el menú se renderiza.
///
/// Se evalúa antes que cualquier otra fase de su ciclo: si devuelve `false`, el menú no se
/// renderiza, no se despachan sus acciones ni intervienen los temas. Así un menú creado una
/// sola vez (por ejemplo, en una barra registrada con [`InRegion`]) puede mostrarse sólo en
/// las páginas que corresponda. Un cierre sin capturas sirve como función.
///
/// # Ejemplo
///
/// Menú principal que, en las páginas del panel de administración, deja su sitio a la
/// navegación del panel ([`Nav::admin()`]). Como ésta se muestra justo cuando se cumple
/// [`is_admin_panel()`], el menú principal usa la condición contraria: en cada página se ve uno
/// de los dos, también en una página del panel que responde a quien no tiene acceso (un error
/// 403), donde se ve el menú principal:
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// let main = Nav::new()
/// .with_item(nav::Item::link(Lc::n("Home"), "/"))
/// .with_renderable(|cx| !is_admin_panel(cx));
///
/// let navbar = Navbar::brand_left(Brand::new().with_title(Lc::n("My app")))
/// .with_item(navbar::Item::nav(main))
/// .with_item(navbar::Item::nav(Nav::admin()));
///
/// InRegion::Global(&CoreRegions::Header).add(navbar);
/// ```
pub fn with_renderable(mut self, f: FnIsRenderable) -> Self {
self.renderable = Some(f);
self
}
/// Añade un nuevo elemento al menú o modifica la lista de elementos del menú con una
/// operación [`TypedOp`].
///

View file

@ -211,8 +211,10 @@ pub trait Contextual {
/// Establece el título del documento como un valor traducible.
///
/// Además de usarse en el `<head>`, lo ven las plantillas y los componentes al renderizarse,
/// como el marco de las páginas del panel de administración
/// ([`AdminFrame`](crate::base::component::AdminFrame)), que lo muestra como encabezado.
/// como el marco de las páginas del panel de administración ([`AdminFrame`]), que lo muestra
/// como encabezado.
///
/// [`AdminFrame`]: crate::base::component::layout::AdminFrame
fn with_title(self, title: Lc) -> Self {
self.context_mut().title = title;
self

View file

@ -177,13 +177,16 @@ pub enum CoreTemplates {
/// Plantilla para la **interfaz de administración**, de nombre `"admin"`.
///
/// Se utiliza para las páginas del panel de administración ([`Page::admin()`]): además de las
/// regiones de `Standard`, pinta la navegación del panel ([`AdminMenu`]) y el marco de la
/// página ([`AdminFrame`]) alrededor de la región de contenido.
/// Se utiliza para las páginas del panel de administración ([`Page::admin()`]). Además de las
/// regiones de `Standard`, muestra también el marco de la página ([`AdminFrame`]) alrededor de
/// la región de contenido.
///
/// Sin embargo, no muestra el menú de navegación del panel: será la aplicación la que decida
/// dónde colocarlo, usando [`Nav::admin()`].
///
/// [`Page::admin()`]: crate::response::Page::admin
/// [`AdminMenu`]: crate::base::component::AdminMenu
/// [`AdminFrame`]: crate::base::component::AdminFrame
/// [`AdminFrame`]: crate::base::component::layout::AdminFrame
/// [`Nav::admin()`]: crate::base::component::Nav::admin
Admin,
}