graphs renamed to web

web/src/pages/add_table/logic.rs

@@ -0,0 +1,98 @@
+use axum::{
+    Form,
+    extract::State,
+    http::{HeaderMap, HeaderValue, StatusCode, header},
+    response::{Html, IntoResponse, Redirect, Response},
+};
+
+use crate::{AppState, services::authenticated_request};
+
+use super::{
+    loader::{LoadError, load_page},
+    state::CreateTableForm,
+    ui,
+};
+
+pub(crate) async fn new_table_page(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+) -> Response {
+    render_loaded(load_page(state, &headers, CreateTableForm::default(), None).await)
+}
+
+pub(crate) async fn create_table(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Form(form): Form<CreateTableForm>,
+) -> Response {
+    let submitted_form = form.clone();
+    if let Err(error) = load_page(state.clone(), &headers, form.clone(), None).await {
+        return render_loaded(Err(error));
+    }
+    if headers
+        .get("sec-fetch-site")
+        .is_some_and(|value| value == "cross-site")
+    {
+        return (StatusCode::FORBIDDEN, "Cross-site form submission rejected").into_response();
+    }
+    let request = match form.into_request() {
+        Ok(request) => request,
+        Err(message) => {
+            return render_loaded(
+                load_page(state, &headers, submitted_form, Some(message)).await,
+            );
+        }
+    };
+    let profile_name = request.profile_name.clone();
+    let mut definitions = state.definitions;
+    let request = match authenticated_request(&headers, request) {
+        Ok(request) => request,
+        Err(_) => return Redirect::to("/login").into_response(),
+    };
+    match definitions.post_table_definition(request).await {
+        Ok(response) if response.get_ref().success => {
+            let location = format!("/admin?profile={profile_name}");
+            let Ok(location) = HeaderValue::try_from(location) else {
+                return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid redirect").into_response();
+            };
+            let mut response = StatusCode::SEE_OTHER.into_response();
+            response.headers_mut().insert(header::LOCATION, location.clone());
+            response.headers_mut().insert("hx-redirect", location);
+            response
+        }
+        Ok(response) => {
+            let detail = if response.get_ref().sql.is_empty() {
+                "The backend did not create the table.".to_string()
+            } else {
+                response.get_ref().sql.clone()
+            };
+            (
+                StatusCode::UNPROCESSABLE_ENTITY,
+                Html(ui::render_submission_error(&detail)),
+            )
+                .into_response()
+        }
+        Err(error) => (
+            StatusCode::UNPROCESSABLE_ENTITY,
+            Html(ui::render_submission_error(error.message())),
+        )
+            .into_response(),
+    }
+}
+
+fn render_loaded(result: Result<super::state::AddTablePageState, LoadError>) -> Response {
+    match result {
+        Ok(page) => Html(ui::render_page(&page)).into_response(),
+        Err(LoadError::Unauthenticated) => Redirect::to("/login").into_response(),
+        Err(LoadError::Forbidden) => (
+            StatusCode::FORBIDDEN,
+            Html(ui::render_submission_error("Administrator access is required.")),
+        )
+            .into_response(),
+        Err(LoadError::Backend(message)) => (
+            StatusCode::BAD_GATEWAY,
+            Html(ui::render_submission_error(&message)),
+        )
+            .into_response(),
+    }
+}