use askama_web to make template responses more ergonomic

crates/frontend/Cargo.toml

@@ -8,6 +8,7 @@ publish = false
 
 [dependencies]
 askama.workspace = true
+askama_web.workspace = true
 actix-session = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }

crates/frontend/src/lib.rs

@@ -1,15 +1,16 @@
 use actix_session::{
-    config::CookieContentSecurity, storage::CookieSessionStore, SessionMiddleware,
+    SessionMiddleware, config::CookieContentSecurity, storage::CookieSessionStore,
 };
 use actix_web::{
+    HttpRequest, HttpResponse, Responder,
     cookie::{Key, SameSite},
     dev::ServiceResponse,
     http::{Method, StatusCode},
     middleware::{ErrorHandlerResponse, ErrorHandlers},
-    web::{self, Data, Html, Path},
-    HttpRequest, HttpResponse, Responder,
+    web::{self, Data, Path},
 };
 use askama::Template;
+use askama_web::WebTemplate;
 use assets::{Assets, EmbedService};
 use routes::{
     addressbook::{route_addressbook, route_addressbook_restore},
@@ -17,8 +18,8 @@ use routes::{
     login::{route_get_login, route_post_login},
 };
 use rustical_store::{
-    auth::{AuthenticationMiddleware, AuthenticationProvider, User},
     Addressbook, AddressbookStore, Calendar, CalendarStore,
+    auth::{AuthenticationMiddleware, AuthenticationProvider, User},
 };
 use std::sync::Arc;
 
@@ -28,7 +29,7 @@ mod routes;
 
 pub use config::FrontendConfig;
 
-#[derive(Template)]
+#[derive(Template, WebTemplate)]
 #[template(path = "pages/user.html")]
 struct UserPage {
     pub user_id: String,
@@ -51,19 +52,14 @@ async fn route_user<CS: CalendarStore, AS: AddressbookStore>(
         return actix_web::HttpResponse::Unauthorized().body("Unauthorized");
     }
 
-    Html::new(
-        UserPage {
-            calendars: cal_store.get_calendars(&user.id).await.unwrap(),
-            deleted_calendars: cal_store.get_deleted_calendars(&user.id).await.unwrap(),
-            addressbooks: addr_store.get_addressbooks(&user.id).await.unwrap(),
-            deleted_addressbooks: addr_store.get_deleted_addressbooks(&user.id).await.unwrap(),
-            user_id: user.id,
-        }
-        .render()
-        .unwrap(),
-    )
+    UserPage {
+        calendars: cal_store.get_calendars(&user.id).await.unwrap(),
+        deleted_calendars: cal_store.get_deleted_calendars(&user.id).await.unwrap(),
+        addressbooks: addr_store.get_addressbooks(&user.id).await.unwrap(),
+        deleted_addressbooks: addr_store.get_deleted_addressbooks(&user.id).await.unwrap(),
+        user_id: user.id,
+    }
     .respond_to(&req)
-    .map_into_boxed_body()
 }
 
 async fn route_root(user: Option<User>, req: HttpRequest) -> impl Responder {

crates/frontend/src/routes/addressbook.rs

@@ -1,12 +1,13 @@
 use actix_web::{
-    http::{header, StatusCode},
-    web::{self, Data, Html, Path},
     HttpRequest, HttpResponse, Responder,
+    http::{StatusCode, header},
+    web::{self, Data, Path},
 };
 use askama::Template;
-use rustical_store::{auth::User, Addressbook, AddressbookStore};
+use askama_web::WebTemplate;
+use rustical_store::{Addressbook, AddressbookStore, auth::User};
 
-#[derive(Template)]
+#[derive(Template, WebTemplate)]
 #[template(path = "pages/addressbook.html")]
 struct AddressbookPage {
     addressbook: Addressbook,
@@ -22,15 +23,10 @@ pub async fn route_addressbook<AS: AddressbookStore>(
     if !user.is_principal(&owner) {
         return Ok(HttpResponse::Unauthorized().body("Unauthorized"));
     }
-    Ok(Html::new(
-        AddressbookPage {
-            addressbook: store.get_addressbook(&owner, &addrbook_id).await?,
-        }
-        .render()
-        .unwrap(),
-    )
-    .respond_to(&req)
-    .map_into_boxed_body())
+    Ok(AddressbookPage {
+        addressbook: store.get_addressbook(&owner, &addrbook_id).await?,
+    }
+    .respond_to(&req))
 }
 
 pub async fn route_addressbook_restore<AS: AddressbookStore>(

crates/frontend/src/routes/calendar.rs

@@ -1,12 +1,13 @@
 use actix_web::{
-    http::{header, StatusCode},
-    web::{self, Data, Html, Path},
     HttpRequest, HttpResponse, Responder,
+    http::{StatusCode, header},
+    web::{self, Data, Path},
 };
 use askama::Template;
-use rustical_store::{auth::User, Calendar, CalendarStore};
+use askama_web::WebTemplate;
+use rustical_store::{Calendar, CalendarStore, auth::User};
 
-#[derive(Template)]
+#[derive(Template, WebTemplate)]
 #[template(path = "pages/calendar.html")]
 struct CalendarPage {
     calendar: Calendar,
@@ -22,15 +23,10 @@ pub async fn route_calendar<C: CalendarStore>(
     if !user.is_principal(&owner) {
         return Ok(HttpResponse::Unauthorized().body("Unauthorized"));
     }
-    Ok(Html::new(
-        CalendarPage {
-            calendar: store.get_calendar(&owner, &cal_id).await?,
-        }
-        .render()
-        .unwrap(),
-    )
-    .respond_to(&req)
-    .map_into_boxed_body())
+    Ok(CalendarPage {
+        calendar: store.get_calendar(&owner, &cal_id).await?,
+    }
+    .respond_to(&req))
 }
 
 pub async fn route_calendar_restore<CS: CalendarStore>(

crates/frontend/src/routes/login.rs

@@ -1,21 +1,20 @@
 use actix_session::Session;
 use actix_web::{
-    error::ErrorUnauthorized,
-    web::{Data, Form, Html, Redirect},
     HttpRequest, HttpResponse, Responder,
+    error::ErrorUnauthorized,
+    web::{Data, Form, Redirect},
 };
 use askama::Template;
+use askama_web::WebTemplate;
 use rustical_store::auth::AuthenticationProvider;
 use serde::Deserialize;
 
-#[derive(Template)]
+#[derive(Template, WebTemplate)]
 #[template(path = "pages/login.html")]
 struct LoginPage;
 
-pub async fn route_get_login(req: HttpRequest) -> impl Responder {
-    Html::new(LoginPage.render().unwrap())
-        .respond_to(&req)
-        .map_into_boxed_body()
+pub async fn route_get_login() -> impl Responder {
+    LoginPage
 }
 
 #[derive(Deserialize)]