✨ (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:
parent
ecba7b2bd8
commit
8e0c887ba6
24 changed files with 1737 additions and 19 deletions
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
175
src/base/component/admin_frame.rs
Normal file
175
src/base/component/admin_frame.rs
Normal 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(§ion.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))
|
||||
})
|
||||
}
|
||||
60
src/base/component/admin_menu.rs
Normal file
60
src/base/component/admin_menu.rs
Normal 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(§ion.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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
})
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue