use std::collections::HashMap;
use std::sync::Arc;
use axum::http::{HeaderMap, StatusCode, Uri};
use axum::response::{IntoResponse, Response};
use rustango::extractors::Tenant;
pub use rustango::messages::Level as MessageLevel;
use crate::permissions::Action;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SidebarSection {
Content,
Site,
Settings,
Custom(&'static str),
}
impl SidebarSection {
#[must_use]
pub fn label(&self) -> &'static str {
match self {
Self::Content => "Content",
Self::Site => "Site",
Self::Settings => "Settings",
Self::Custom(name) => name,
}
}
}
pub struct AdminPageCtx<'a> {
pub tera: &'a Arc<tera::Tera>,
pub tenant: &'a Tenant,
pub headers: &'a HeaderMap,
pub user: Option<&'a rustango::tenancy::auth::User>,
pub uri: &'a Uri,
pub action: Option<&'a str>,
}
impl AdminPageCtx<'_> {
#[must_use]
pub fn query(&self) -> HashMap<String, String> {
self.uri
.query()
.and_then(|q| serde_urlencoded::from_str(q).ok())
.unwrap_or_default()
}
#[must_use]
pub fn query_param(&self, name: &str) -> Option<String> {
self.query()
.remove(name)
.map(|v| v.trim().to_owned())
.filter(|v| !v.is_empty())
}
pub async fn render(&self, template: &str, ctx: &mut tera::Context) -> Response {
let slug = self.slug();
super::handlers::add_chrome(ctx, self.tenant, &format!("custom:{slug}"), self.user).await;
super::handlers::add_admin_theme(ctx, self.tenant.pool()).await;
ctx.insert("admin_page_slug", &slug);
match super::handlers::render_tera(self.tera, self.headers, template, ctx) {
Ok(resp) => resp,
Err(e) => e.into_response(),
}
}
#[must_use]
pub fn redirect(&self, to: &str, level: MessageLevel, message: &str) -> Response {
let body = super::i18n::tr(self.headers, message, &[]);
rustango::messages::redirect_with_message(
super::handlers::messages_secret(),
self.headers,
level,
&body,
to,
)
}
pub async fn has_perm(&self, codename: &str) -> bool {
let Some(user) = self.user else { return false };
user.is_superuser
|| crate::permissions::user_codenames(self.tenant.pool(), user.id.get().copied().unwrap_or_default())
.await
.is_ok_and(|codes| codes.iter().any(|c| c == codename))
}
#[must_use]
pub fn page_url(&self) -> String {
format!("/cms-admin/x/{}", self.slug())
}
fn slug(&self) -> &str {
self.uri
.path()
.strip_prefix("/cms-admin/x/")
.and_then(|rest| rest.split('/').next())
.unwrap_or_default()
}
}
#[derive(Debug, Clone, Default)]
pub struct AdminForm {
pairs: Vec<(String, String)>,
}
impl AdminForm {
#[must_use]
pub fn parse(body: &[u8]) -> Self {
Self { pairs: serde_urlencoded::from_bytes(body).unwrap_or_default() }
}
#[must_use]
pub fn get(&self, name: &str) -> Option<&str> {
self.pairs.iter().rev().find(|(k, _)| k == name).map(|(_, v)| v.as_str())
}
#[must_use]
pub fn text(&self, name: &str) -> String {
self.get(name).map(str::trim).unwrap_or_default().to_owned()
}
#[must_use]
pub fn opt_text(&self, name: &str) -> Option<String> {
Some(self.text(name)).filter(|v| !v.is_empty())
}
#[must_use]
pub fn checked(&self, name: &str) -> bool {
matches!(self.get(name).map(str::trim), Some("on" | "true" | "1" | "yes"))
}
#[must_use]
pub fn int(&self, name: &str) -> Option<i64> {
self.get(name).and_then(|v| v.trim().parse().ok())
}
#[must_use]
pub fn float(&self, name: &str) -> Option<f64> {
self.get(name).and_then(|v| v.trim().parse().ok())
}
#[must_use]
pub fn all(&self, name: &str) -> Vec<&str> {
self.pairs.iter().filter(|(k, _)| k == name).map(|(_, v)| v.as_str()).collect()
}
#[must_use]
pub fn ints(&self, name: &str) -> Vec<i64> {
self.all(name).into_iter().filter_map(|v| v.trim().parse().ok()).collect()
}
#[must_use]
pub fn to_map(&self) -> HashMap<String, String> {
self.pairs.iter().cloned().collect()
}
#[must_use]
pub fn pairs(&self) -> &[(String, String)] {
&self.pairs
}
}
#[async_trait::async_trait]
pub trait AdminPageHandler: Send + Sync + 'static {
fn slug(&self) -> &'static str;
fn label(&self) -> &'static str;
fn icon(&self) -> Option<&'static str> {
None
}
fn section(&self) -> SidebarSection {
SidebarSection::Custom("Tools")
}
fn sort_order(&self) -> i32 {
100
}
fn permission_resource(&self) -> Option<&'static str> {
None
}
fn permission_actions(&self) -> &'static [Action] {
&[Action::View, Action::Edit]
}
async fn render(&self, ctx: AdminPageCtx<'_>) -> Response;
async fn post(&self, _ctx: AdminPageCtx<'_>, _form: AdminForm) -> Response {
StatusCode::METHOD_NOT_ALLOWED.into_response()
}
}
#[must_use]
pub fn required_codename(slug: &str, reads: bool, action: Option<&str>) -> Option<String> {
let handler = find_admin_page(slug)?;
let resource = handler.permission_resource()?;
let declared = handler.permission_actions();
let verb = if reads {
Action::View
} else {
match action {
Some("delete") if declared.contains(&Action::Delete) => Action::Delete,
Some("new") if declared.contains(&Action::Add) => Action::Add,
_ => Action::Edit,
}
};
Some(format!("{resource}.{}", verb.as_str()))
}
pub struct AdminPageHandlerRegistration {
pub factory: fn() -> Box<dyn AdminPageHandler>,
}
inventory::collect!(AdminPageHandlerRegistration);
pub fn registered_admin_pages() -> impl Iterator<Item = Box<dyn AdminPageHandler>> {
inventory::iter::<AdminPageHandlerRegistration>
.into_iter()
.map(|r| (r.factory)())
}
#[must_use]
pub fn find_admin_page(slug: &str) -> Option<Box<dyn AdminPageHandler>> {
registered_admin_pages().find(|h| h.slug() == slug)
}