From 105d5a81af5714f9dadff37578db717e09d518a0 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Mon, 16 Nov 2026 13:09:08 +0100 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20(admin):=20Navegaci=C3=B3n?= =?UTF-8?q?=20del=20panel=20con=20Nav::admin()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- extensions/pagetop-bootsier/README.md | 7 +- extensions/pagetop-bootsier/src/lib.rs | 9 +- extensions/pagetop-bootsier/src/theme.rs | 11 +- .../src/theme/bs/layout/template.rs | 12 +- src/admin.rs | 26 ++- src/base/component.rs | 6 - src/base/component/admin_menu.rs | 60 ------- src/base/component/layout.rs | 5 +- .../component/{ => layout}/admin_frame.rs | 6 +- src/base/component/layout/template.rs | 12 +- src/base/component/nav/component.rs | 135 +++++++++++++++- src/core/component/context/contextual.rs | 6 +- src/core/theme/layout.rs | 13 +- tests/admin_template.rs | 153 +++++++++++++++++- tests/admin_without_pages.rs | 21 +++ 15 files changed, 375 insertions(+), 107 deletions(-) delete mode 100644 src/base/component/admin_menu.rs rename src/base/component/{ => layout}/admin_frame.rs (95%) diff --git a/extensions/pagetop-bootsier/README.md b/extensions/pagetop-bootsier/README.md index 95a34c3c..fccc2566 100644 --- a/extensions/pagetop-bootsier/README.md +++ b/extensions/pagetop-bootsier/README.md @@ -95,9 +95,10 @@ async fn about(request: HttpRequest) -> Result { ## Panel de administración -En la plantilla `Admin`, Bootsier sigue la composición del núcleo: tras la cabecera pinta la -navegación del panel (`AdminMenu`) y, en lugar del contenido, el marco de la página (`AdminFrame`: -migas, título, botones y pestañas). Los dos se construyen con componentes del núcleo +En la plantilla `Admin`, Bootsier sigue la composición del núcleo: en lugar del contenido pinta el +marco de la página (`AdminFrame`: migas, título, botones y pestañas). La navegación del panel +(`Nav::admin()`) la coloca la aplicación, en una barra aparte o en su barra principal, donde se +pliega con su botón en pantallas pequeñas. Todo se construye con componentes del núcleo (`Navbar`/`Nav`/`Dropdown`, `Breadcrumb`), que Bootsier ya pinta con su aspecto. ## Selector de modo de color diff --git a/extensions/pagetop-bootsier/src/lib.rs b/extensions/pagetop-bootsier/src/lib.rs index fee94e47..a597b81f 100644 --- a/extensions/pagetop-bootsier/src/lib.rs +++ b/extensions/pagetop-bootsier/src/lib.rs @@ -96,9 +96,10 @@ async fn about(request: HttpRequest) -> Result { ## Panel de administración -En la plantilla `Admin`, Bootsier sigue la composición del núcleo: tras la cabecera pinta la -navegación del panel (`AdminMenu`) y, en lugar del contenido, el marco de la página (`AdminFrame`: -migas, título, botones y pestañas). Los dos se construyen con componentes del núcleo +En la plantilla `Admin`, Bootsier sigue la composición del núcleo: en lugar del contenido pinta el +marco de la página (`AdminFrame`: migas, título, botones y pestañas). La navegación del panel +(`Nav::admin()`) la coloca la aplicación, en una barra aparte o en su barra principal, donde se +pliega con su botón en pantallas pequeñas. Todo se construye con componentes del núcleo (`Navbar`/`Nav`/`Dropdown`, `Breadcrumb`), que Bootsier ya pinta con su aspecto. ## Selector de modo de color @@ -257,7 +258,7 @@ impl Theme for Bootsier { fn breakpoint_entry(&self, bp: Breakpoint) -> BreakpointEntry { use Breakpoint::*; - // Anchos mínimos de la rejilla de Bootstrap (`$grid-breakpoints`). Bootstrap no tiene un + // Anchos mínimos de los puntos de corte de Bootstrap (`$grid-breakpoints`). No tiene un // punto de corte por encima de `xxl`, así que `Xxxl` se resuelve como `xxl`. match bp { Xs => BreakpointEntry { breakpoint: Xs, name: "xs", min_width: "" }, diff --git a/extensions/pagetop-bootsier/src/theme.rs b/extensions/pagetop-bootsier/src/theme.rs index a7552e24..1286b959 100644 --- a/extensions/pagetop-bootsier/src/theme.rs +++ b/extensions/pagetop-bootsier/src/theme.rs @@ -35,10 +35,13 @@ //! //! # Panel de administración //! -//! En la plantilla `Admin`, Bootsier sigue la composición del núcleo: tras la cabecera pinta la -//! navegación del panel ([`AdminMenu`]) y, en lugar del contenido, el marco de la página -//! ([`AdminFrame`]: migas, título, botones y pestañas). Los dos se construyen con componentes del -//! núcleo ([`Navbar`]/[`Nav`]/[`Dropdown`], [`Breadcrumb`]), que Bootsier ya pinta con su aspecto. +//! En la plantilla `Admin`, Bootsier sigue la composición del núcleo: en lugar del contenido pinta +//! el marco de la página ([`AdminFrame`]: migas, título, botones y pestañas). La navegación del +//! panel ([`Nav::admin()`]) la coloca la aplicación, en una barra aparte o en su barra principal, +//! donde se pliega con su botón en pantallas pequeñas. Todo se construye con componentes del núcleo +//! ([`Navbar`]/[`Nav`]/[`Dropdown`], [`Breadcrumb`]), que Bootsier ya pinta con su aspecto. +//! +//! [`AdminFrame`]: pagetop::prelude::layout::AdminFrame //! //! # Selector de modo de color //! diff --git a/extensions/pagetop-bootsier/src/theme/bs/layout/template.rs b/extensions/pagetop-bootsier/src/theme/bs/layout/template.rs index 89a38358..bf340c99 100644 --- a/extensions/pagetop-bootsier/src/theme/bs/layout/template.rs +++ b/extensions/pagetop-bootsier/src/theme/bs/layout/template.rs @@ -8,9 +8,9 @@ use crate::theme::bs; // `CoreTemplates`, dejando que el resto de la cadena de temas (o el propio componente) resuelva el // renderizado por defecto. // -// `CoreTemplates::Admin` sigue la composición del núcleo: tras la cabecera, la navegación del -// panel (`AdminMenu`) y, en lugar del contenido, el marco de la página (`AdminFrame`), que -// contiene la región `Content`. +// `CoreTemplates::Admin` sigue la composición del núcleo: en lugar del contenido, el marco de la +// página (`AdminFrame`), que contiene la región `Content`. La navegación del panel la coloca la +// aplicación (`Nav::admin()`). pub(crate) async fn render( component: &layout::Template, cx: &mut Context, @@ -33,15 +33,13 @@ async fn render_standard(cx: &mut Context) -> Markup { .await } -// Como `render_standard()`, con la navegación del panel tras la cabecera y el marco de la página -// en lugar de la región `Content`. +// Como `render_standard()`, con el marco de la página en lugar de la región `Content`. async fn render_admin(cx: &mut Context) -> Markup { wrapper() .with_prop(PropsOp::add_classes("container-wrapper-admin")) .with_child(layout::Region::header()) - .with_child(AdminMenu::new()) .with_child(layout::Region::aside()) - .with_child(AdminFrame::new()) + .with_child(layout::AdminFrame::new()) .with_child(layout::Region::footer()) .render(cx) .await diff --git a/src/admin.rs b/src/admin.rs index 625ff7d7..95c040bb 100644 --- a/src/admin.rs +++ b/src/admin.rs @@ -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::(), + Some(CoreTemplates::Admin) + ) && can_access_admin(cx) +} diff --git a/src/base/component.rs b/src/base/component.rs index 73303c4f..dc39576a 100644 --- a/src/base/component.rs +++ b/src/base/component.rs @@ -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; diff --git a/src/base/component/admin_menu.rs b/src/base/component/admin_menu.rs deleted file mode 100644 index 80929429..00000000 --- a/src/base/component/admin_menu.rs +++ /dev/null @@ -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 { - 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) - } -} diff --git a/src/base/component/layout.rs b/src/base/component/layout.rs index b9cfdf0c..494655d9 100644 --- a/src/base/component/layout.rs +++ b/src/base/component/layout.rs @@ -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; diff --git a/src/base/component/admin_frame.rs b/src/base/component/layout/admin_frame.rs similarity index 95% rename from src/base/component/admin_frame.rs rename to src/base/component/layout/admin_frame.rs index cd9db2a5..7cd1d6c0 100644 --- a/src/base/component/admin_frame.rs +++ b/src/base/component/layout/admin_frame.rs @@ -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 `` 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), diff --git a/src/base/component/layout/template.rs b/src/base/component/layout/template.rs index a1a23ae7..822c4a21 100644 --- a/src/base/component/layout/template.rs +++ b/src/base/component/layout/template.rs @@ -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 { diff --git a/src/base/component/nav/component.rs b/src/base/component/nav/component.rs index a41bfe75..0c51f253 100644 --- a/src/base/component/nav/component.rs +++ b/src/base/component/nav/component.rs @@ -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`]. /// diff --git a/src/core/component/context/contextual.rs b/src/core/component/context/contextual.rs index 7587bb74..a589c7e5 100644 --- a/src/core/component/context/contextual.rs +++ b/src/core/component/context/contextual.rs @@ -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 diff --git a/src/core/theme/layout.rs b/src/core/theme/layout.rs index 8eadb1cb..1d856ffc 100644 --- a/src/core/theme/layout.rs +++ b/src/core/theme/layout.rs @@ -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, } diff --git a/tests/admin_template.rs b/tests/admin_template.rs index 64a4bb49..3f50a1a2 100644 --- a/tests/admin_template.rs +++ b/tests/admin_template.rs @@ -116,10 +116,8 @@ async fn the_admin_template_frames_the_content_of_the_page() { render(Page::admin(request("/admin/config/export/csv")).with_title(Lc::n("CSV"))).await; assert!(html.contains(r#"class="wrapper wrapper-admin""#), "{html}"); - // Navigation: only the sections with an accessible page. - assert!(html.contains("admin-menu"), "{html}"); - assert!(html.contains(r#"href="/admin/config/export""#), "{html}"); - assert!(!html.contains(r#"href="/admin/reports/audit""#), "{html}"); + // The template does not paint the navigation of the panel: the application places it. + assert!(!html.contains("nav-admin"), "{html}"); // Breadcrumbs up to the nearest declared page, then the page title. assert!(html.contains(r#"href="/admin/config""#), "{html}"); assert!( @@ -165,11 +163,156 @@ async fn the_standard_template_has_no_admin_frame() { let html = render(Page::new(request("/admin/config/export")).with_title(Lc::n("Export"))).await; assert!(!html.contains("wrapper-admin"), "{html}"); - assert!(!html.contains("admin-menu"), "{html}"); + assert!(!html.contains("nav-admin"), "{html}"); assert!(!html.contains("admin-content"), "{html}"); assert!(html.contains("Body of the page."), "{html}"); } +// Navigation of the panel in its own bar. +fn admin_navbar() -> Navbar { + Navbar::simple().with_item(navbar::Item::nav(Nav::admin())) +} + +#[pagetop::test] +async fn the_admin_menu_goes_where_the_application_places_it() { + let _ = Application::prepare(&Ext).await; + let page = Page::admin(request("/admin/config/export/csv")) + .with_child_in(&CoreRegions::Header, admin_navbar()); + let html = render(page).await; + + // Only the sections with an accessible page. + let header = &html[html.find(r#"id="header""#).unwrap()..html.find("admin-content").unwrap()]; + assert!(header.contains("nav-admin"), "{header}"); + assert!(header.contains("navbar-nav"), "{header}"); + assert!( + header.contains(r#"href="/admin/config/export""#), + "{header}" + ); + assert!( + !header.contains(r#"href="/admin/reports/audit""#), + "{header}" + ); +} + +#[pagetop::test] +async fn the_admin_menu_only_shows_in_the_panel() { + let _ = Application::prepare(&Ext).await; + let page = Page::new(request("/home")).with_child_in(&CoreRegions::Header, admin_navbar()); + let html = render(page).await; + + assert!(!html.contains("nav-admin"), "{html}"); + assert!(!html.contains(r#"href="/admin"#), "{html}"); +} + +#[pagetop::test] +async fn the_admin_menu_does_not_repeat_its_links_when_rendered_again() { + let _ = Application::prepare(&Ext).await; + // The same prototype for every page, as with `InRegion`. + let navbar = admin_navbar(); + for _ in 0..2 { + let page = Page::admin(request("/admin/config/export")) + .with_child_in(&CoreRegions::Header, navbar.clone()); + let html = render(page).await; + // Links of the menu only (the breadcrumbs also link to the dashboard). + let links = r#"class="nav-link" href="/admin""#; + assert_eq!(html.matches(links).count(), 1, "{html}"); + } +} + +// Main navbar of an application, with its own menu and the navigation of the panel. +fn main_navbar() -> Navbar { + Navbar::simple() + .with_item(navbar::Item::nav( + Nav::new().with_item(nav::Item::link(Lc::n("Home"), "/home")), + )) + .with_item(navbar::Item::nav(Nav::admin())) +} + +#[pagetop::test] +async fn the_admin_menu_can_go_in_the_main_navbar() { + let _ = Application::prepare(&Ext).await; + let page = Page::admin(request("/admin/config/export/csv")) + .with_child_in(&CoreRegions::Header, main_navbar()); + let html = render(page).await; + + // The navigation of the panel goes in the main navbar, with the accessible pages only. + let header = &html[html.find(r#"id="header""#).unwrap()..html.find("admin-content").unwrap()]; + assert!(header.contains(r#"href="/home""#), "{header}"); + assert!(header.contains(r#"href="/admin""#), "{header}"); + assert!( + header.contains(r#"href="/admin/config/export""#), + "{header}" + ); + assert!( + !header.contains(r#"href="/admin/reports/audit""#), + "{header}" + ); +} + +#[pagetop::test] +async fn the_admin_nav_keeps_its_layout_in_the_main_navbar() { + let _ = Application::prepare(&Ext).await; + let navbar = Navbar::simple().with_item(navbar::Item::nav( + Nav::admin() + .with_id("admin-nav") + .with_layout(nav::Layout::Center), + )); + let page = + Page::admin(request("/admin/config/export")).with_child_in(&CoreRegions::Header, navbar); + let html = render(page).await; + + let start = html + .find(r#"id="admin-nav""#) + .expect("the admin nav is rendered"); + let nav = &html[html[..start].rfind('<').unwrap()..]; + let nav = &nav[..nav.find('>').unwrap()]; + assert!(nav.contains("nav-center"), "{nav}"); + assert!(nav.contains("nav-admin"), "{nav}"); + assert!(html.contains(r#"href="/admin/config/export""#), "{html}"); +} + +// Main navbar whose own menu leaves its place to the navigation of the panel. +fn swapping_navbar() -> Navbar { + Navbar::simple() + .with_item(navbar::Item::nav( + Nav::new() + .with_item(nav::Item::link(Lc::n("Home"), "/home")) + .with_renderable(|cx| !is_admin_panel(cx)), + )) + .with_item(navbar::Item::nav(Nav::admin())) +} + +#[pagetop::test] +async fn the_admin_nav_takes_the_place_of_the_main_menu_in_the_panel() { + let _ = Application::prepare(&Ext).await; + let page = Page::admin(request("/admin/config/export")) + .with_child_in(&CoreRegions::Header, swapping_navbar()); + let html = render(page).await; + + assert!(html.contains(r#"href="/admin/config/export""#), "{html}"); + assert!(!html.contains(r#"href="/home""#), "{html}"); +} + +#[pagetop::test] +async fn the_main_menu_shows_outside_the_panel() { + let _ = Application::prepare(&Ext).await; + let page = Page::new(request("/home")).with_child_in(&CoreRegions::Header, swapping_navbar()); + let html = render(page).await; + + assert!(html.contains(r#"href="/home""#), "{html}"); + assert!(!html.contains(r#"href="/admin"#), "{html}"); +} + +#[pagetop::test] +async fn the_admin_menu_of_the_main_navbar_only_shows_in_the_panel() { + let _ = Application::prepare(&Ext).await; + let page = Page::new(request("/home")).with_child_in(&CoreRegions::Header, main_navbar()); + let html = render(page).await; + + assert!(html.contains(r#"href="/home""#), "{html}"); + assert!(!html.contains(r#"href="/admin"#), "{html}"); +} + async fn get(uri: &str) -> (u16, String) { let app = Application::prepare(&Ext).await.test(); let request = web::test::TestRequest::get().uri(uri).to_request(); diff --git a/tests/admin_without_pages.rs b/tests/admin_without_pages.rs index 720ad6a7..7882b546 100644 --- a/tests/admin_without_pages.rs +++ b/tests/admin_without_pages.rs @@ -13,3 +13,24 @@ async fn without_declared_pages_the_panel_is_not_mounted() { assert_eq!(response.status().as_u16(), 404, "{uri}"); } } + +#[pagetop::test] +async fn without_access_to_the_panel_its_pages_show_the_main_menu() { + let _ = Application::prepare(&Ext).await; + let navbar = Navbar::simple() + .with_item(navbar::Item::nav( + Nav::new() + .with_item(nav::Item::link(Lc::n("Home"), "/home")) + .with_renderable(|cx| !is_admin_panel(cx)), + )) + .with_item(navbar::Item::nav(Nav::admin())); + // A page with the admin template that nobody can access, as an error 403 would be. + let request = web::test::TestRequest::get() + .uri("/admin") + .to_http_request(); + let mut page = Page::admin(request).with_child_in(&CoreRegions::Header, navbar); + let html = page.render().await.unwrap().into_string(); + + assert!(html.contains(r#"href="/home""#), "{html}"); + assert!(!html.contains("nav-admin"), "{html}"); +}