use RenderInfo guard everywhere and start to use FlashMessage

15 files changed, 163 insertions, 324 deletions

diff --git a/server/src/helper/accept.rs b/server/src/helper/accept.rs
index 3ac53c8..11210d1 100644
--- a/server/src/helper/accept.rs
+++ b/server/src/helper/accept.rs
@@ -32,6 +32,10 @@ impl Accept {
             Accept::Other
         }
     }
+
+    pub fn is_json(&self) -> bool {
+        matches!(self, Self::Json)
+    }
 }
 
 pub struct AcceptJson(bool);
diff --git a/server/src/helper/mod.rs b/server/src/helper/mod.rs
index 9e8ce79..a4e0e1f 100644
--- a/server/src/helper/mod.rs
+++ b/server/src/helper/mod.rs
@@ -13,8 +13,12 @@ pub mod session;
 
 use crate::ui::error::{MyError, MyResult};
 use accept::Accept;
+use jellyimport::is_importing;
 use jellylogic::session::Session;
-use jellyui::locale::Language;
+use jellyui::{
+    locale::Language,
+    scaffold::{RenderInfo, SessionInfo},
+};
 use language::lang_from_request;
 use rocket::{
     async_trait,
@@ -41,6 +45,15 @@ impl RequestInfo {
             session: session_from_request(request).await?,
         })
     }
+    pub fn render_info(&self) -> RenderInfo {
+        RenderInfo {
+            importing: is_importing(),
+            session: Some(SessionInfo {
+                user: self.session.user.clone(), // TODO no clone?
+            }),
+            lang: self.lang,
+        }
+    }
 }
 
 #[async_trait]
diff --git a/server/src/ui/account/mod.rs b/server/src/ui/account/mod.rs
index 2a513a9..8296e95 100644
--- a/server/src/ui/account/mod.rs
+++ b/server/src/ui/account/mod.rs
@@ -46,8 +46,8 @@ pub async fn r_account_register(lang: AcceptLanguage) -> RawHtml<String> {
         RenderInfo {
             importing: false,
             session: None,
+            lang,
         },
-        lang,
     ))
 }
 
@@ -73,8 +73,8 @@ pub fn r_account_login(session: Option<A<Session>>, lang: AcceptLanguage) -> Raw
         RenderInfo {
             session: session.map(|s| SessionInfo { user: s.0.user }),
             importing: is_importing(),
+            lang,
         },
-        lang,
     ))
 }
 
@@ -86,16 +86,16 @@ pub fn r_account_logout(session: Option<A<Session>>, lang: AcceptLanguage) -> Ra
         RenderInfo {
             session: session.map(|s| SessionInfo { user: s.0.user }),
             importing: is_importing(),
+            lang,
         },
-        lang,
     ))
 }
 
 #[post("/account/register", data = "<form>")]
 pub fn r_account_register_post<'a>(
     session: Option<A<Session>>,
-    form: Form<Contextual<'a, RegisterForm>>,
     lang: AcceptLanguage,
+    form: Form<Contextual<'a, RegisterForm>>,
 ) -> MyResult<RawHtml<String>> {
     let AcceptLanguage(lang) = lang;
     let logged_in = session.is_some();
@@ -114,8 +114,8 @@ pub fn r_account_register_post<'a>(
         RenderInfo {
             session: session.map(|s| SessionInfo { user: s.0.user }),
             importing: is_importing(),
+            lang,
         },
-        lang,
     )))
 }
 
diff --git a/server/src/ui/account/settings.rs b/server/src/ui/account/settings.rs
index 7d1b7af..677683b 100644
--- a/server/src/ui/account/settings.rs
+++ b/server/src/ui/account/settings.rs
@@ -5,24 +5,15 @@
 */
 use super::format_form_error;
 use crate::{
-    helper::{language::AcceptLanguage, A},
+    helper::{RequestInfo, A},
     ui::error::MyResult,
 };
 use jellycommon::user::{PlayerKind, Theme};
-use jellyimport::is_importing;
-use jellylogic::{
-    account::{
-        update_user_display_name, update_user_native_secret, update_user_password,
-        update_user_player_preference, update_user_theme,
-    },
-    session::Session,
-};
-use jellyui::{
-    account::settings::SettingsPage,
-    locale::{tr, Language},
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
+use jellylogic::account::{
+    update_user_display_name, update_user_native_secret, update_user_password,
+    update_user_player_preference, update_user_theme,
 };
+use jellyui::{account::settings::SettingsPage, locale::tr, render_page, scaffold::SessionInfo};
 use rocket::{
     form::{self, validate::len, Contextual, Form},
     get, post,
@@ -46,49 +37,36 @@ fn option_len<'v>(value: &Option<String>, range: Range<usize>) -> form::Result<'
     value.as_ref().map(|v| len(v, range)).unwrap_or(Ok(()))
 }
 
-fn settings_page(
-    session: Session,
-    flash: Option<Result<String, String>>,
-    lang: Language,
-) -> RawHtml<String> {
+// TODO use FlashMessage
+fn settings_page(flash: Option<Result<String, String>>, ri: RequestInfo) -> RawHtml<String> {
     RawHtml(render_page(
         &SettingsPage {
             flash,
             session: &SessionInfo {
-                user: session.user.clone(),
+                user: ri.session.user.clone(),
             },
-            lang: &lang,
-        },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo { user: session.user }),
+            lang: &ri.lang,
         },
-        lang,
+        ri.render_info(),
     ))
 }
 
 #[get("/account/settings")]
-pub fn r_account_settings(session: A<Session>, lang: AcceptLanguage) -> RawHtml<String> {
-    let AcceptLanguage(lang) = lang;
-    settings_page(session.0, None, lang)
+pub fn r_account_settings(ri: RequestInfo) -> RawHtml<String> {
+    settings_page(None, ri)
 }
 
 #[post("/account/settings", data = "<form>")]
 pub fn r_account_settings_post(
-    session: A<Session>,
+    ri: RequestInfo,
     form: Form<Contextual<SettingsForm>>,
-    lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
-    let AcceptLanguage(lang) = lang;
-    let A(session) = session;
-
     let form = match &form.value {
         Some(v) => v,
         None => {
             return Ok(settings_page(
-                session,
                 Some(Err(format_form_error(form).to_string())),
-                lang,
+                ri,
             ))
         }
     };
@@ -96,37 +74,36 @@ pub fn r_account_settings_post(
     let mut out = String::new();
 
     if let Some(password) = &form.password {
-        update_user_password(&session, password)?;
-        out += &*tr(lang, "settings.account.password.changed");
+        update_user_password(&ri.session, password)?;
+        out += &*tr(ri.lang, "settings.account.password.changed");
         out += "\n";
     }
     if let Some(display_name) = &form.display_name {
-        update_user_display_name(&session, display_name)?;
-        out += &*tr(lang, "settings.account.display_name.changed");
+        update_user_display_name(&ri.session, display_name)?;
+        out += &*tr(ri.lang, "settings.account.display_name.changed");
         out += "\n";
     }
     if let Some(theme) = form.theme {
-        update_user_theme(&session, theme.0)?;
-        out += &*tr(lang, "settings.account.theme.changed");
+        update_user_theme(&ri.session, theme.0)?;
+        out += &*tr(ri.lang, "settings.account.theme.changed");
         out += "\n";
     }
     if let Some(player_preference) = form.player_preference {
-        update_user_player_preference(&session, player_preference.0)?;
-        out += &*tr(lang, "settings.player_preference.changed");
+        update_user_player_preference(&ri.session, player_preference.0)?;
+        out += &*tr(ri.lang, "settings.player_preference.changed");
         out += "\n";
     }
     if let Some(native_secret) = &form.native_secret {
-        update_user_native_secret(&session, native_secret)?;
+        update_user_native_secret(&ri.session, native_secret)?;
         out += "Native secret updated.\n";
     }
 
     Ok(settings_page(
-        session, // using the old session here, results in outdated theme being displayed
         Some(Ok(if out.is_empty() {
-            tr(lang, "settings.no_change").to_string()
+            tr(ri.lang, "settings.no_change").to_string()
         } else {
             out
         })),
-        lang,
+        ri, // using the old session here, results in outdated theme being displayed
     ))
 }
diff --git a/server/src/ui/admin/log.rs b/server/src/ui/admin/log.rs
index c26b697..61d2ba7 100644
--- a/server/src/ui/admin/log.rs
+++ b/server/src/ui/admin/log.rs
@@ -4,10 +4,9 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use crate::{
-    helper::{language::AcceptLanguage, A},
+    helper::{RequestInfo, A},
     ui::error::MyResult,
 };
-use jellyimport::is_importing;
 use jellylogic::{
     admin::log::{get_log_buffer, get_log_stream},
     session::Session,
@@ -15,20 +14,14 @@ use jellylogic::{
 use jellyui::{
     admin::log::{render_log_line, ServerLogPage},
     render_page,
-    scaffold::{RenderInfo, SessionInfo},
 };
 use rocket::{get, response::content::RawHtml};
 use rocket_ws::{Message, Stream, WebSocket};
 use serde_json::json;
 
 #[get("/admin/log?<warnonly>", rank = 2)]
-pub fn r_admin_log<'a>(
-    session: A<Session>,
-    warnonly: bool,
-    lang: AcceptLanguage,
-) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
+pub fn r_admin_log<'a>(ri: RequestInfo, warnonly: bool) -> MyResult<RawHtml<String>> {
+    ri.session.assert_admin()?;
     let messages = get_log_buffer(warnonly)
         .into_iter()
         .map(|l| render_log_line(&l))
@@ -38,13 +31,7 @@ pub fn r_admin_log<'a>(
             messages: &messages,
             warnonly,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     )))
 }
 
diff --git a/server/src/ui/admin/mod.rs b/server/src/ui/admin/mod.rs
index 4e07afb..e124a13 100644
--- a/server/src/ui/admin/mod.rs
+++ b/server/src/ui/admin/mod.rs
@@ -7,40 +7,31 @@ pub mod log;
 pub mod user;
 
 use super::error::MyResult;
-use crate::helper::{language::AcceptLanguage, RequestInfo, A};
+use crate::helper::RequestInfo;
 use jellycommon::routes::u_admin_dashboard;
 use jellyimport::is_importing;
-use jellylogic::{
-    admin::{
-        create_invite, delete_invite, do_import, get_import_errors, list_invites,
-        update_search_index,
-    },
-    session::Session,
-};
-use jellyui::{
-    admin::AdminDashboardPage,
-    locale::tr,
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
+use jellylogic::admin::{
+    create_invite, delete_invite, do_import, get_import_errors, list_invites, update_search_index,
 };
+use jellyui::{admin::AdminDashboardPage, locale::tr, render_page};
 use rocket::{
     form::Form,
     get, post,
+    request::FlashMessage,
     response::{content::RawHtml, Flash, Redirect},
     FromForm,
 };
 
 #[get("/admin/dashboard")]
 pub async fn r_admin_dashboard(
-    session: A<Session>,
-    lang: AcceptLanguage,
+    ri: RequestInfo,
+    flash: Option<FlashMessage<'_>>,
 ) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
+    ri.session.assert_admin()?;
     let flash = None;
 
-    let invites = list_invites(&session.0)?;
-    let last_import_err = get_import_errors(&session.0).await;
+    let invites = list_invites(&ri.session)?;
+    let last_import_err = get_import_errors(&ri.session).await;
 
     let busy = if is_importing() {
         Some("An import is currently running.")
@@ -54,15 +45,9 @@ pub async fn r_admin_dashboard(
             last_import_err: &last_import_err,
             invites: &invites,
             flash,
-            lang: &lang,
-        },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
+            lang: &ri.lang,
         },
-        lang,
+        ri.render_info(),
     )))
 }
 
@@ -82,24 +67,33 @@ pub struct DeleteInvite {
 
 #[post("/admin/remove_invite", data = "<form>")]
 pub async fn r_admin_remove_invite(
-    session: A<Session>,
+    ri: RequestInfo,
     form: Form<DeleteInvite>,
-) -> MyResult<Redirect> {
-    session.0.assert_admin()?;
-    delete_invite(&session.0, &form.invite)?;
-    Ok(Redirect::temporary(u_admin_dashboard()))
+) -> MyResult<Flash<Redirect>> {
+    ri.session.assert_admin()?;
+    delete_invite(&ri.session, &form.invite)?;
+    Ok(Flash::success(
+        Redirect::to(u_admin_dashboard()),
+        tr(ri.lang, "admin.invite_delete_success"),
+    ))
 }
 
 #[post("/admin/import?<incremental>")]
-pub async fn r_admin_import(session: A<Session>, incremental: bool) -> MyResult<Redirect> {
-    session.0.assert_admin()?;
-    do_import(&session.0, incremental).await?.1?;
-    Ok(Redirect::temporary(u_admin_dashboard()))
+pub async fn r_admin_import(ri: RequestInfo, incremental: bool) -> MyResult<Flash<Redirect>> {
+    ri.session.assert_admin()?;
+    do_import(&ri.session, incremental).await?.1?;
+    Ok(Flash::success(
+        Redirect::to(u_admin_dashboard()),
+        tr(ri.lang, "admin.import_success"),
+    ))
 }
 
 #[post("/admin/update_search")]
-pub async fn r_admin_update_search(session: A<Session>) -> MyResult<Redirect> {
-    session.0.assert_admin()?;
-    update_search_index(&session.0).await?;
-    Ok(Redirect::temporary(u_admin_dashboard()))
+pub async fn r_admin_update_search(ri: RequestInfo) -> MyResult<Flash<Redirect>> {
+    ri.session.assert_admin()?;
+    update_search_index(&ri.session).await?;
+    Ok(Flash::success(
+        Redirect::to(u_admin_dashboard()),
+        tr(ri.lang, "admin.update_search_success"),
+    ))
 }
diff --git a/server/src/ui/admin/user.rs b/server/src/ui/admin/user.rs
index e8dc332..afbe8f0 100644
--- a/server/src/ui/admin/user.rs
+++ b/server/src/ui/admin/user.rs
@@ -3,68 +3,42 @@
     which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
-use crate::{
-    helper::{language::AcceptLanguage, A},
-    ui::error::MyResult,
-};
+use crate::{helper::RequestInfo, ui::error::MyResult};
 use anyhow::Context;
 use jellycommon::user::UserPermission;
-use jellyimport::is_importing;
-use jellylogic::{
-    admin::user::{admin_users, delete_user, get_user, update_user_perms, GrantState},
-    session::Session,
-};
+use jellylogic::admin::user::{admin_users, delete_user, get_user, update_user_perms, GrantState};
 use jellyui::{
     admin::user::{AdminUserPage, AdminUsersPage},
     render_page,
-    scaffold::{RenderInfo, SessionInfo},
 };
 use rocket::{form::Form, get, post, response::content::RawHtml, FromForm, FromFormField};
 
 #[get("/admin/users")]
-pub fn r_admin_users(session: A<Session>, lang: AcceptLanguage) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
-    let r = admin_users(&session.0)?;
+pub fn r_admin_users(ri: RequestInfo) -> MyResult<RawHtml<String>> {
+    ri.session.assert_admin()?;
+    let r = admin_users(&ri.session)?;
     Ok(RawHtml(render_page(
         &AdminUsersPage {
             flash: None,
-            lang: &lang,
+            lang: &ri.lang,
             users: &r.users,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     )))
 }
 
 #[get("/admin/user/<name>")]
-pub fn r_admin_user<'a>(
-    session: A<Session>,
-    name: &'a str,
-    lang: AcceptLanguage,
-) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
-    let user = get_user(&session.0, name)?;
+pub fn r_admin_user<'a>(ri: RequestInfo, name: &'a str) -> MyResult<RawHtml<String>> {
+    ri.session.assert_admin()?;
+    let user = get_user(&ri.session, name)?;
 
     Ok(RawHtml(render_page(
         &AdminUserPage {
             flash: None,
-            lang: &lang,
+            lang: &ri.lang,
             user: &user,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     )))
 }
 
@@ -83,18 +57,16 @@ pub enum UrlGrantState {
 
 #[post("/admin/user/<name>/update_permission", data = "<form>")]
 pub fn r_admin_user_permission(
-    session: A<Session>,
+    ri: RequestInfo,
     form: Form<UserPermissionForm>,
     name: &str,
-    lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
+    ri.session.assert_admin()?;
     let perm = serde_json::from_str::<UserPermission>(&form.permission)
         .context("parsing provided permission")?;
 
     update_user_perms(
-        &session.0,
+        &ri.session,
         name,
         perm,
         match form.action {
@@ -104,47 +76,30 @@ pub fn r_admin_user_permission(
         },
     )?;
 
-    let user = get_user(&session.0, name)?;
+    let user = get_user(&ri.session, name)?;
 
     Ok(RawHtml(render_page(
         &AdminUserPage {
             flash: Some(Ok("Permissions updated".to_string())),
-            lang: &lang,
+            lang: &ri.lang,
             user: &user,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     )))
 }
 
 #[post("/admin/<name>/remove")]
-pub fn r_admin_remove_user(
-    session: A<Session>,
-    name: &str,
-    lang: AcceptLanguage,
-) -> MyResult<RawHtml<String>> {
-    session.0.assert_admin()?;
-    let AcceptLanguage(lang) = lang;
-    delete_user(&session.0, name)?;
-    let r = admin_users(&session.0)?;
+pub fn r_admin_remove_user(ri: RequestInfo, name: &str) -> MyResult<RawHtml<String>> {
+    ri.session.assert_admin()?;
+    delete_user(&ri.session, name)?;
+    let r = admin_users(&ri.session)?;
 
     Ok(RawHtml(render_page(
         &AdminUsersPage {
             flash: Some(Ok("User removed".to_string())),
-            lang: &lang,
+            lang: &ri.lang,
             users: &r.users,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     )))
 }
diff --git a/server/src/ui/error.rs b/server/src/ui/error.rs
index d9716f5..6fc3284 100644
--- a/server/src/ui/error.rs
+++ b/server/src/ui/error.rs
@@ -33,8 +33,8 @@ pub fn r_catch<'a>(status: Status, _request: &Request) -> RawHtml<String> {
         RenderInfo {
             importing: false,
             session: None,
+            lang: Language::English,
         },
-        Language::English,
     ))
 }
 
diff --git a/server/src/ui/home.rs b/server/src/ui/home.rs
index 4a423cf..9e11900 100644
--- a/server/src/ui/home.rs
+++ b/server/src/ui/home.rs
@@ -5,39 +5,21 @@
 */
 
 use super::error::MyResult;
-use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
+use crate::helper::{accept::Accept, RequestInfo};
 use jellycommon::api::ApiHomeResponse;
-use jellyimport::is_importing;
-use jellylogic::session::Session;
-use jellyui::{
-    home::HomePage,
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-};
+use jellyui::{home::HomePage, render_page};
 use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/home")]
-pub fn r_home(
-    session: A<Session>,
-    aj: AcceptJson,
-    lang: AcceptLanguage,
-) -> MyResult<Either<RawHtml<String>, Json<ApiHomeResponse>>> {
-    let AcceptLanguage(lang) = lang;
+pub fn r_home(ri: RequestInfo) -> MyResult<Either<RawHtml<String>, Json<ApiHomeResponse>>> {
+    let r = jellylogic::home::home(&ri.session)?;
 
-    let r = jellylogic::home::home(&session.0)?;
-
-    Ok(if *aj {
+    Ok(if matches!(ri.accept, Accept::Json) {
         Either::Right(Json(r))
     } else {
         Either::Left(RawHtml(render_page(
-            &HomePage { lang: &lang, r },
-            RenderInfo {
-                importing: is_importing(),
-                session: Some(SessionInfo {
-                    user: session.0.user,
-                }),
-            },
-            lang,
+            &HomePage { lang: &ri.lang, r },
+            ri.render_info(),
         )))
     })
 }
diff --git a/server/src/ui/items.rs b/server/src/ui/items.rs
index 1ac2c09..915963c 100644
--- a/server/src/ui/items.rs
+++ b/server/src/ui/items.rs
@@ -4,46 +4,30 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use super::error::MyError;
-use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
+use crate::helper::{accept::Accept, RequestInfo, A};
 use jellycommon::api::{ApiItemsResponse, NodeFilterSort};
-use jellyimport::is_importing;
-use jellylogic::{items::all_items, session::Session};
-use jellyui::{
-    items::ItemsPage,
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-};
+use jellylogic::items::all_items;
+use jellyui::{items::ItemsPage, render_page};
 use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/items?<page>&<filter..>")]
 pub fn r_items(
-    session: A<Session>,
-    aj: AcceptJson,
+    ri: RequestInfo,
     page: Option<usize>,
     filter: A<NodeFilterSort>,
-    lang: AcceptLanguage,
 ) -> Result<Either<RawHtml<String>, Json<ApiItemsResponse>>, MyError> {
-    let AcceptLanguage(lang) = lang;
-
-    let r = all_items(&session.0, page, filter.0.clone())?;
-
-    Ok(if *aj {
+    let r = all_items(&ri.session, page, filter.0.clone())?;
+    Ok(if matches!(ri.accept, Accept::Json) {
         Either::Right(Json(r))
     } else {
         Either::Left(RawHtml(render_page(
             &ItemsPage {
-                lang: &lang,
+                lang: &ri.lang,
                 r,
                 filter: &filter.0,
                 page: page.unwrap_or(0),
             },
-            RenderInfo {
-                importing: is_importing(),
-                session: Some(SessionInfo {
-                    user: session.0.user,
-                }),
-            },
-            lang,
+            ri.render_info(),
         )))
     })
 }
diff --git a/server/src/ui/mod.rs b/server/src/ui/mod.rs
index e71b08d..e6da485 100644
--- a/server/src/ui/mod.rs
+++ b/server/src/ui/mod.rs
@@ -53,8 +53,8 @@ pub async fn r_index(
             RenderInfo {
                 importing: false,
                 session: None,
+                lang,
             },
-            lang,
         ))))
     }
 }
diff --git a/server/src/ui/node.rs b/server/src/ui/node.rs
index 0b1a92f..7085a5a 100644
--- a/server/src/ui/node.rs
+++ b/server/src/ui/node.rs
@@ -4,42 +4,34 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use super::error::MyResult;
-use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
+use crate::helper::{RequestInfo, A};
 use jellycommon::{
     api::{ApiNodeResponse, NodeFilterSort},
     NodeID,
 };
-use jellyimport::is_importing;
-use jellylogic::{node::get_node, session::Session};
-use jellyui::{
-    node_page::NodePage,
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-};
+use jellylogic::node::get_node;
+use jellyui::{node_page::NodePage, render_page};
 use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/n/<id>?<parents>&<children>&<filter..>")]
 pub async fn r_node<'a>(
-    session: A<Session>,
+    ri: RequestInfo,
     id: A<NodeID>,
-    aj: AcceptJson,
     filter: Option<A<NodeFilterSort>>,
-    lang: AcceptLanguage,
     parents: bool,
     children: bool,
 ) -> MyResult<Either<RawHtml<String>, Json<ApiNodeResponse>>> {
-    let AcceptLanguage(lang) = lang;
     let filter = filter.unwrap_or_default();
 
     let r = get_node(
-        &session.0,
+        &ri.session,
         id.0,
-        !*aj || children,
-        !*aj || parents,
+        !ri.accept.is_json() || children,
+        !ri.accept.is_json() || parents,
         filter.0.clone(),
     )?;
 
-    Ok(if *aj {
+    Ok(if ri.accept.is_json() {
         Either::Right(Json(r))
     } else {
         Either::Left(RawHtml(render_page(
@@ -50,16 +42,10 @@ pub async fn r_node<'a>(
                 parents: &r.parents,
                 similar: &[],
                 filter: &filter.0,
-                lang: &lang,
+                lang: &ri.lang,
                 player: false,
             },
-            RenderInfo {
-                importing: is_importing(),
-                session: Some(SessionInfo {
-                    user: session.0.user,
-                }),
-            },
-            lang,
+            ri.render_info(),
         )))
     })
 }
diff --git a/server/src/ui/player.rs b/server/src/ui/player.rs
index ae4468d..4938c14 100644
--- a/server/src/ui/player.rs
+++ b/server/src/ui/player.rs
@@ -5,7 +5,7 @@
 */
 use super::error::MyResult;
 use crate::{
-    helper::{language::AcceptLanguage, A},
+    helper::{RequestInfo, A},
     CONF,
 };
 use jellycommon::{
@@ -14,13 +14,8 @@ use jellycommon::{
     user::{PermissionSet, PlayerKind},
     NodeID,
 };
-use jellyimport::is_importing;
-use jellylogic::{node::get_node, session::Session};
-use jellyui::{
-    node_page::NodePage,
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-};
+use jellylogic::node::get_node;
+use jellyui::{node_page::NodePage, render_page};
 use rocket::{
     get,
     response::{content::RawHtml, Redirect},
@@ -44,30 +39,27 @@ fn jellynative_url(action: &str, seek: f64, secret: &str, node: &str, session: &
 
 #[get("/n/<id>/player?<t>", rank = 4)]
 pub fn r_player(
-    session: A<Session>,
-    lang: AcceptLanguage,
+    ri: RequestInfo,
     t: Option<f64>,
     id: A<NodeID>,
 ) -> MyResult<Either<RawHtml<String>, Redirect>> {
-    let AcceptLanguage(lang) = lang;
-
-    let r = get_node(&session.0, id.0, false, true, NodeFilterSort::default())?;
+    let r = get_node(&ri.session, id.0, false, true, NodeFilterSort::default())?;
 
     let native_session = |action: &str| {
         Ok(Either::Right(Redirect::temporary(jellynative_url(
             action,
             t.unwrap_or(0.),
-            &session.0.user.native_secret,
+            &ri.session.user.native_secret,
             &id.0.to_string(),
             &jellylogic::session::create(
-                session.0.user.name.clone(),
+                ri.session.user.name.clone(),
                 PermissionSet::default(), // TODO
                 Duration::from_hours(24),
             ),
         ))))
     };
 
-    match session.0.user.player_preference {
+    match ri.session.user.player_preference {
         PlayerKind::Browser => (),
         PlayerKind::Native => {
             return native_session("player-v2");
@@ -100,16 +92,10 @@ pub fn r_player(
             parents: &r.parents,
             similar: &[],
             filter: &NodeFilterSort::default(),
-            lang: &lang,
+            lang: &ri.lang,
             player: true,
         },
-        RenderInfo {
-            importing: is_importing(),
-            session: Some(SessionInfo {
-                user: session.0.user,
-            }),
-        },
-        lang,
+        ri.render_info(),
     ))))
 }
 
diff --git a/server/src/ui/search.rs b/server/src/ui/search.rs
index e4afdd8..1812130 100644
--- a/server/src/ui/search.rs
+++ b/server/src/ui/search.rs
@@ -4,33 +4,24 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use super::error::MyResult;
-use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
+use crate::helper::RequestInfo;
 use anyhow::anyhow;
 use jellycommon::api::ApiSearchResponse;
-use jellyimport::is_importing;
-use jellylogic::{search::search, session::Session};
-use jellyui::{
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-    search::SearchPage,
-};
+use jellylogic::search::search;
+use jellyui::{render_page, search::SearchPage};
 use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/search?<query>&<page>")]
 pub async fn r_search<'a>(
-    session: A<Session>,
-    aj: AcceptJson,
+    ri: RequestInfo,
     query: Option<&str>,
     page: Option<usize>,
-    lang: AcceptLanguage,
 ) -> MyResult<Either<RawHtml<String>, Json<ApiSearchResponse>>> {
-    let AcceptLanguage(lang) = lang;
-
     let r = query
-        .map(|query| search(&session.0, query, page))
+        .map(|query| search(&ri.session, query, page))
         .transpose()?;
 
-    Ok(if *aj {
+    Ok(if ri.accept.is_json() {
         let Some(r) = r else {
             Err(anyhow!("no query"))?
         };
@@ -38,17 +29,11 @@ pub async fn r_search<'a>(
     } else {
         Either::Left(RawHtml(render_page(
             &SearchPage {
-                lang: &lang,
+                lang: &ri.lang,
                 query: &query.map(|s| s.to_string()),
                 r,
             },
-            RenderInfo {
-                importing: is_importing(),
-                session: Some(SessionInfo {
-                    user: session.0.user,
-                }),
-            },
-            lang,
+            ri.render_info(),
         )))
     })
 }
diff --git a/server/src/ui/stats.rs b/server/src/ui/stats.rs
index 4ae592e..ff02e33 100644
--- a/server/src/ui/stats.rs
+++ b/server/src/ui/stats.rs
@@ -4,38 +4,24 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use super::error::MyError;
-use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
+use crate::helper::RequestInfo;
 use jellycommon::api::ApiStatsResponse;
-use jellyimport::is_importing;
-use jellylogic::{session::Session, stats::stats};
-use jellyui::{
-    render_page,
-    scaffold::{RenderInfo, SessionInfo},
-    stats::StatsPage,
-};
+use jellylogic::stats::stats;
+use jellyui::{render_page, stats::StatsPage};
 use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/stats")]
 pub fn r_stats(
-    session: A<Session>,
-    aj: AcceptJson,
-    lang: AcceptLanguage,
+    ri: RequestInfo,
 ) -> Result<Either<RawHtml<String>, Json<ApiStatsResponse>>, MyError> {
-    let AcceptLanguage(lang) = lang;
-    let r = stats(&session.0)?;
+    let r = stats(&ri.session)?;
 
-    Ok(if *aj {
+    Ok(if ri.accept.is_json() {
         Either::Right(Json(r))
     } else {
         Either::Left(RawHtml(render_page(
-            &StatsPage { lang: &lang, r },
-            RenderInfo {
-                importing: is_importing(),
-                session: Some(SessionInfo {
-                    user: session.0.user,
-                }),
-            },
-            lang,
+            &StatsPage { lang: &ri.lang, r },
+            ri.render_info(),
         )))
     })
 }