moved template logic into own module.

src/webui/mod.rs

@@ -1,65 +1,30 @@
-#![feature(future_join)]
-
 use std::{env, path::PathBuf};
 
 use actix_files;
 use actix_web::{
     dev::ServiceResponse,
-    error,
     http::{header::ContentType, StatusCode},
     middleware::{ErrorHandlerResponse, ErrorHandlers, Logger},
-    web, App, FromRequest, HttpRequest, HttpResponse, HttpServer, Responder, Result, Scope,
+    web, App, FromRequest, HttpResponse, HttpServer, Responder, Result, Scope,
 };
-use actix_web_lab::respond::Html;
+
 use async_channel;
 use futures::{pin_mut, select, FutureExt};
 use minijinja;
 use minijinja_autoreload::AutoReloader;
-use rusqlite::Connection;
+
 
 use crate::events::Event;
 use crate::util::{CustomResult, Error, SQLiteConnectionFactory};
+use crate::webui::templates::MiniJinjaRenderer;
 use crate::webui::worker::event_processor_loop;
 
 mod index_views;
 mod services;
+mod templates;
 mod views;
 mod worker;
 
-struct MiniJinjaRenderer {
-    tmpl_env: web::Data<minijinja_autoreload::AutoReloader>,
-}
-
-impl MiniJinjaRenderer {
-    fn render(&self, tmpl: &str, ctx: impl Into<minijinja::value::Value>) -> Result<Html> {
-        log::info!("Rendering template {:?}", tmpl);
-        self.tmpl_env
-            .acquire_env()
-            .map_err(|_| error::ErrorInternalServerError("could not acquire template env"))?
-            .get_template(tmpl)
-            .map_err(|e| error::ErrorInternalServerError(format!("{:?}", e)))?
-            .render(ctx.into())
-            .map(Html)
-            .map_err(|err| {
-                log::error!("{err}");
-                error::ErrorInternalServerError("template error")
-            })
-    }
-}
-
-impl FromRequest for MiniJinjaRenderer {
-    type Error = actix_web::Error;
-    type Future = actix_utils::future::Ready<Result<Self, Self::Error>>;
-
-    fn from_request(req: &HttpRequest, _pl: &mut actix_web::dev::Payload) -> Self::Future {
-        let tmpl_env = <web::Data<minijinja_autoreload::AutoReloader>>::extract(req)
-            .into_inner()
-            .unwrap();
-
-        actix_utils::future::ready(Ok(Self { tmpl_env }))
-    }
-}
-
 fn create_auto_reloader(enable_template_autoreload: bool) -> AutoReloader {
     AutoReloader::new(move |notifier| {
         let mut env: minijinja::Environment<'static> = minijinja::Environment::new();
@@ -102,21 +67,17 @@ pub async fn web_ui_main(
     port: u16,
     enable_template_autoreload: bool,
 ) -> CustomResult<()> {
-    // The closure is invoked every time the environment is outdated to recreate it.
-    let tmpl_reloader = create_auto_reloader(enable_template_autoreload);
-
     let (event_sender, event_receiver) = async_channel::unbounded::<Event>();
 
-    let tmpl_reloader = web::Data::new(tmpl_reloader);
-
     // use r2d2 for connection pools (https://github.com/sfackler/r2d2 &
     // https://github.com/ivanceras/r2d2-sqlite) use
     // https://docs.rs/actix-web/4.3.1/actix_web/web/fn.block.html
     // in handlers.
     let cloned_conn_fact = conn_fact.clone();
     let server = HttpServer::new(move || {
+        let template_reloader = create_auto_reloader(enable_template_autoreload);
         App::new()
-            .app_data(tmpl_reloader.clone())
+            .app_data(web::Data::new(template_reloader))
             .app_data(web::Data::new(event_sender.clone()))
             .app_data(web::Data::new(cloned_conn_fact.clone()))
             .service(create_static_scope())