refactoring: new structure and mailer

src/server/routes/html/auth.rs

@@ -0,0 +1,56 @@
+use axum::{
+    extract::State,
+    response::{IntoResponse, Redirect},
+    Form,
+};
+use axum_htmx::HxBoosted;
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use serde::{Deserialize, Serialize};
+use surrealdb::{engine::any::Any, Surreal};
+
+use crate::{error::ApiError, server::AppState, storage::types::user::User};
+
+use super::{render_block, render_template};
+
+#[derive(Deserialize, Serialize)]
+pub struct SignupParams {
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Serialize)]
+struct PageData {
+    // name: String,
+}
+
+pub async fn show_signup_form(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    HxBoosted(boosted): HxBoosted,
+) -> Result<impl IntoResponse, ApiError> {
+    if auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+    let output = match boosted {
+        true => render_block(
+            "auth/signup_form.html",
+            "body",
+            PageData {},
+            state.templates,
+        )?,
+        false => render_template("auth/signup_form.html", PageData {}, state.templates)?,
+    };
+
+    Ok(output.into_response())
+}
+
+pub async fn signup_handler(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<SignupParams>,
+) -> Result<impl IntoResponse, ApiError> {
+    let user = User::create_new(form.email, form.password, &state.surreal_db_client).await?;
+    auth.login_user(user.id);
+    Ok(())
+}

src/server/routes/html/index.rs

@@ -0,0 +1,31 @@
+use axum::{extract::State, response::Html};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use crate::{
+    error::ApiError,
+    page_data,
+    server::{routes::html::render_template, AppState},
+    storage::types::user::User,
+};
+
+page_data!(IndexData, {
+    queue_length: u32,
+});
+
+pub async fn index_handler(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<Html<String>, ApiError> {
+    info!("Displaying index page");
+
+    info!("{:?}", auth.current_user);
+
+    let queue_length = state.rabbitmq_consumer.get_queue_length().await?;
+
+    let output = render_template("index.html", IndexData { queue_length }, state.templates)?;
+
+    Ok(output)
+}

src/server/routes/html/mod.rs

@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use axum::response::Html;
+use minijinja_autoreload::AutoReloader;
+
+pub mod auth;
+pub mod index;
+pub mod search_result;
+
+pub fn render_template<T>(
+    template_name: &str,
+    context: T,
+    templates: Arc<AutoReloader>,
+) -> Result<Html<String>, minijinja::Error>
+where
+    T: serde::Serialize,
+{
+    let env = templates.acquire_env()?;
+    let tmpl = env.get_template(template_name)?;
+
+    let context = minijinja::Value::from_serialize(&context);
+    let output = tmpl.render(context)?;
+
+    Ok(output.into())
+}
+
+pub fn render_block<T>(
+    template_name: &str,
+    block: &str,
+    context: T,
+    templates: Arc<AutoReloader>,
+) -> Result<Html<String>, minijinja::Error>
+where
+    T: serde::Serialize,
+{
+    let env = templates.acquire_env()?;
+    let tmpl = env.get_template(template_name)?;
+
+    let context = minijinja::Value::from_serialize(&context);
+    let output = tmpl.eval_to_state(context)?.render_block(block)?;
+
+    Ok(output.into())
+}
+
+#[macro_export]
+macro_rules! page_data {
+    ($name:ident, {$($(#[$attr:meta])* $field:ident: $ty:ty),*$(,)?}) => {
+        use serde::{Serialize, Deserialize};
+
+        #[derive(Debug, Deserialize, Serialize)]
+        pub struct $name {
+            $($(#[$attr])* pub $field: $ty),*
+        }
+    };
+}

src/server/routes/html/search_result.rs

@@ -0,0 +1,50 @@
+use axum::{
+    extract::{Query, State},
+    response::Html,
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use serde::Deserialize;
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use crate::{
+    error::ApiError, retrieval::query_helper::get_answer_with_references, server::AppState,
+    storage::types::user::User,
+};
+#[derive(Deserialize)]
+pub struct SearchParams {
+    query: String,
+}
+
+pub async fn search_result_handler(
+    State(state): State<AppState>,
+    Query(query): Query<SearchParams>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<Html<String>, ApiError> {
+    info!("Displaying search results");
+
+    let user_id = auth.current_user.ok_or_else(|| ApiError::AuthRequired)?.id;
+
+    let answer = get_answer_with_references(
+        &state.surreal_db_client,
+        &state.openai_client,
+        &query.query,
+        &user_id,
+    )
+    .await?;
+
+    Ok(Html("Hello".to_string()))
+    // let output = state
+    //     .tera
+    //     .render(
+    //         "search_result.html",
+    //         &Context::from_value(
+    //             json!({"result": answer.content, "references": answer.references}),
+    //         )
+    //         .unwrap(),
+    //     )
+    //     .unwrap();
+
+    // Ok(output.into())
+}