minijinja running

src/server/mod.rs

@@ -3,7 +3,6 @@ use crate::rabbitmq::publisher::RabbitMQProducer;
 use crate::storage::db::SurrealDbClient;
 use minijinja_autoreload::AutoReloader;
 use std::sync::Arc;
-// use tera::Tera;
 
 pub mod middleware_api_auth;
 pub mod routes;
@@ -13,7 +12,6 @@ pub struct AppState {
     pub rabbitmq_producer: Arc<RabbitMQProducer>,
     pub rabbitmq_consumer: Arc<RabbitMQConsumer>,
     pub surreal_db_client: Arc<SurrealDbClient>,
-    // pub tera: Arc<Tera>,
     pub openai_client: Arc<async_openai::Client<async_openai::config::OpenAIConfig>>,
     pub templates: Arc<AutoReloader>,
 }

src/server/routes/auth.rs

@@ -1,5 +1,6 @@
 use axum::{
     extract::State,
+    http::Response,
     response::{Html, IntoResponse},
     Form,
 };
@@ -11,23 +12,34 @@ 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>,
     HxBoosted(boosted): HxBoosted,
-) -> Html<String> {
-    let mut context = tera::Context::new();
-    context.insert("boosted", &boosted);
-    // let html = state
-    //     .tera
-    //     .render("auth/signup_form.html", &context)
-    //     .unwrap_or_else(|_| "<h1>Error rendering template</h1>".to_string());
-    Html("html".to_string())
+) -> Result<Html<String>, ApiError> {
+    let output = match boosted {
+        true => render_block(
+            "auth/signup_form.html",
+            "content",
+            PageData {},
+            state.templates,
+        )?,
+        false => render_template("auth/signup_form.html", PageData {}, state.templates)?,
+    };
+
+    Ok(output)
 }
 
 pub async fn signup_handler(

src/server/routes/index.rs

@@ -2,13 +2,23 @@ use axum::{extract::State, response::Html};
 use axum_session_auth::AuthSession;
 use axum_session_surreal::SessionSurrealPool;
 use minijinja::context;
+use serde::Serialize;
 use serde_json::json;
 use surrealdb::{engine::any::Any, sql::Relation, Surreal};
 use tera::Context;
 // use tera::Context;
 use tracing::info;
 
-use crate::{error::ApiError, server::AppState, storage::types::user::User};
+use crate::{
+    error::ApiError,
+    server::{routes::render_template, AppState},
+    storage::types::user::User,
+};
+
+#[derive(Serialize)]
+struct PageData<'a> {
+    queue_length: &'a str,
+}
 
 pub async fn index_handler(
     State(state): State<AppState>,
@@ -20,21 +30,13 @@ pub async fn index_handler(
 
     let queue_length = state.rabbitmq_consumer.get_queue_length().await?;
 
-    // let output = state
-    //     .tera
-    //     .render(
-    //         "index.html",
-    //         &Context::from_value(json!({"adjective": "CRAYCRAY", "queue_length": queue_length}))
-    //             .unwrap(),
-    //     )
-    //     .unwrap();
+    let output = render_template(
+        "index.html",
+        PageData {
+            queue_length: "1000",
+        },
+        state.templates,
+    )?;
 
-    // Ok(output.into())
-    //
-    let env = state.templates.acquire_env().unwrap();
-    let context = context!(queue_length => "2000");
-    let tmpl = env.get_template("index.html").unwrap();
-    let output = tmpl.render(context).unwrap();
-
-    Ok(output.into())
+    Ok(output)
 }

src/server/routes/mod.rs

@@ -1,3 +1,8 @@
+use std::sync::Arc;
+
+use axum::response::Html;
+use minijinja_autoreload::AutoReloader;
+
 pub mod auth;
 pub mod file;
 pub mod index;
@@ -5,3 +10,38 @@ pub mod ingress;
 pub mod query;
 pub mod queue_length;
 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())
+}