Manuel Cillero
9354894b3a
`prepare()` de `Component`, `render()` de `Region` y `Template`, y la implementación de `ComponentRender` pasan a ser funciones async. Se actualizan todos los componentes base, helpers, tests y ejemplos.
108 lines
4.2 KiB
Rust
108 lines
4.2 KiB
Rust
use axum::extract::Request;
|
|
use axum::middleware::Next;
|
|
|
|
use crate::core::component::Contextual;
|
|
use crate::locale::L10n;
|
|
use crate::util;
|
|
use crate::web::{HttpRequest, IntoResponse, Response, http};
|
|
|
|
use super::Page;
|
|
|
|
/// Página de error asociada a un código de estado HTTP.
|
|
///
|
|
/// Este enumerado agrupa tipos esenciales de error que pueden devolverse como página HTML completa.
|
|
/// Cada variante encapsula la solicitud original ([`HttpRequest`]) y se corresponde con un código
|
|
/// de estado concreto.
|
|
///
|
|
/// Para cada error se construye una [`Page`] usando el tema activo, lo que permite personalizar la
|
|
/// plantilla y el contenido del mensaje mediante los métodos específicos del tema (por ejemplo,
|
|
/// [`Theme::error_403()`](crate::core::theme::Theme::error_403),
|
|
/// [`Theme::error_404()`](crate::core::theme::Theme::error_404) o
|
|
/// [`Theme::error_fatal()`](crate::core::theme::Theme::error_fatal)).
|
|
#[derive(Clone, Debug)]
|
|
pub enum ErrorPage {
|
|
BadRequest(HttpRequest),
|
|
AccessDenied(HttpRequest),
|
|
NotFound(HttpRequest),
|
|
InternalError(HttpRequest),
|
|
ServiceUnavailable(HttpRequest),
|
|
GatewayTimeout(HttpRequest),
|
|
}
|
|
|
|
impl ErrorPage {
|
|
/// Devuelve el código de estado HTTP asociado a la variante de error.
|
|
pub fn status_code(&self) -> http::StatusCode {
|
|
match self {
|
|
ErrorPage::BadRequest(_) => http::StatusCode::BAD_REQUEST,
|
|
ErrorPage::AccessDenied(_) => http::StatusCode::FORBIDDEN,
|
|
ErrorPage::NotFound(_) => http::StatusCode::NOT_FOUND,
|
|
ErrorPage::InternalError(_) => http::StatusCode::INTERNAL_SERVER_ERROR,
|
|
ErrorPage::ServiceUnavailable(_) => http::StatusCode::SERVICE_UNAVAILABLE,
|
|
ErrorPage::GatewayTimeout(_) => http::StatusCode::GATEWAY_TIMEOUT,
|
|
}
|
|
}
|
|
|
|
// Renderiza la página de error y construye la respuesta HTTP completa con el HTML generado. Si
|
|
// el renderizado falla, devuelve sólo el código de estado sin cuerpo.
|
|
async fn render_html(self) -> Response {
|
|
let status = self.status_code();
|
|
let mut page = match self {
|
|
Self::AccessDenied(request) => {
|
|
let mut page = Page::new(request);
|
|
page.theme().error_403(&mut page);
|
|
page
|
|
}
|
|
Self::NotFound(request) => {
|
|
let mut page = Page::new(request);
|
|
page.theme().error_404(&mut page);
|
|
page
|
|
}
|
|
Self::BadRequest(request)
|
|
| Self::InternalError(request)
|
|
| Self::ServiceUnavailable(request)
|
|
| Self::GatewayTimeout(request) => {
|
|
let mut page = Page::new(request);
|
|
page.theme().error_fatal(
|
|
&mut page,
|
|
status,
|
|
L10n::l(util::join!("error", status.as_str(), "_title")),
|
|
L10n::l(util::join!("error", status.as_str(), "_alert")),
|
|
L10n::l(util::join!("error", status.as_str(), "_help")),
|
|
);
|
|
page
|
|
}
|
|
};
|
|
match page.render().await {
|
|
Ok(rendered) => (
|
|
status,
|
|
[(http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
|
|
rendered.into_string(),
|
|
)
|
|
.into_response(),
|
|
Err(_) => status.into_response(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Convierte un [`ErrorPage`] en una respuesta HTTP que luego se convertirá en una página HTML
|
|
/// completa usando el tema activo.
|
|
impl IntoResponse for ErrorPage {
|
|
fn into_response(self) -> Response {
|
|
let status = self.status_code();
|
|
let mut response = status.into_response();
|
|
response.extensions_mut().insert(self);
|
|
response
|
|
}
|
|
}
|
|
|
|
// Intercepta respuestas con un [`ErrorPage`] pendiente y las convierte en páginas HTML completas
|
|
// usando el tema activo.
|
|
//
|
|
// Se registra globalmente sobre el router principal desde [`crate::app`].
|
|
pub(crate) async fn render_error_pages(req: Request, next: Next) -> Response {
|
|
let mut response = next.run(req).await;
|
|
if let Some(error_page) = response.extensions_mut().remove::<ErrorPage>() {
|
|
return error_page.render_html().await;
|
|
}
|
|
response
|
|
}
|