diff --git a/backend/src/services/mod.rs b/backend/src/services/mod.rs
index d514328..8be34d9 100644
--- a/backend/src/services/mod.rs
+++ b/backend/src/services/mod.rs
@@ -110,7 +110,6 @@ pub async fn dev_panel(
 
 #[derive(Deserialize)]
 pub struct LogsParams {
-    #[serde(default)]
     pub log_file: String,
 }
 
diff --git a/backend/src/services/user.rs b/backend/src/services/user.rs
index 9b897a4..b35ecf4 100644
--- a/backend/src/services/user.rs
+++ b/backend/src/services/user.rs
@@ -31,6 +31,11 @@ use crate::{
 
 const VALIDATION_TOKEN_KEY: &str = "validation_token";
 
+#[derive(Deserialize)]
+pub struct ValidationTokenParams {
+    validation_token: String,
+}
+
 /// SIGN UP ///
 
 #[debug_handler]
@@ -205,7 +210,7 @@ pub async fn sign_up_validation(
     State(connection): State<db::Connection>,
     Extension(context): Extension<Context>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
-    Query(query): Query<HashMap<String, String>>,
+    Query(params): Query<ValidationTokenParams>,
     headers: HeaderMap,
 ) -> Result<(CookieJar, impl IntoResponse)> {
     let mut jar = CookieJar::from_headers(&headers);
@@ -223,73 +228,62 @@ pub async fn sign_up_validation(
         ));
     }
     let (client_ip, client_user_agent) = utils::get_ip_and_user_agent(&headers, addr);
-    match query.get(VALIDATION_TOKEN_KEY) {
-        // 'validation_token' exists only when a user tries to validate a new account.
-        Some(token) => {
-            match connection
-                .validation(
-                    token,
-                    Duration::seconds(consts::VALIDATION_TOKEN_DURATION),
-                    &client_ip,
-                    &client_user_agent,
-                )
-                .await?
-            {
-                db::user::ValidationResult::Ok(token, user_id) => {
-                    let cookie = Cookie::build((consts::COOKIE_AUTH_TOKEN_NAME, token))
-                        .secure(true)
-                        .same_site(cookie::SameSite::Strict);
-                    jar = jar.add(cookie);
-                    let user = connection.load_user(user_id).await?;
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::SignUpEmailValidationSuccess),
-                                Context { user, ..context },
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-                db::user::ValidationResult::ValidationExpired => {
-                    warn!("Unable to validate: validation expired. Token: {}", token);
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::SignUpValidationExpired),
-                                context,
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-                db::user::ValidationResult::UnknownUser => {
-                    warn!("Unable to validate: unknown user. Token: {}", token);
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::SignUpValidationErrorTryAgain),
-                                context,
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-            }
-        }
-        None => {
-            warn!("Unable to validate: no token provided");
+
+    match connection
+        .validation(
+            &params.validation_token,
+            Duration::seconds(consts::VALIDATION_TOKEN_DURATION),
+            &client_ip,
+            &client_user_agent,
+        )
+        .await?
+    {
+        db::user::ValidationResult::Ok(token, user_id) => {
+            let cookie = Cookie::build((consts::COOKIE_AUTH_TOKEN_NAME, token))
+                .secure(true)
+                .same_site(cookie::SameSite::Strict);
+            jar = jar.add(cookie);
+            let user = connection.load_user(user_id).await?;
             Ok((
                 jar,
                 Html(
-                    MessageTemplate::new(context.tr.t(Sentence::ValidationError), context)
+                    MessageTemplate::new(
+                        context.tr.t(Sentence::SignUpEmailValidationSuccess),
+                        Context { user, ..context },
+                    )
+                    .render()?,
+                ),
+            ))
+        }
+        db::user::ValidationResult::ValidationExpired => {
+            warn!(
+                "Unable to validate: validation expired. Token: {}",
+                &params.validation_token
+            );
+            Ok((
+                jar,
+                Html(
+                    MessageTemplate::new(context.tr.t(Sentence::SignUpValidationExpired), context)
                         .render()?,
                 ),
             ))
         }
+        db::user::ValidationResult::UnknownUser => {
+            warn!(
+                "Unable to validate: unknown user. Token: {}",
+                &params.validation_token
+            );
+            Ok((
+                jar,
+                Html(
+                    MessageTemplate::new(
+                        context.tr.t(Sentence::SignUpValidationErrorTryAgain),
+                        context,
+                    )
+                    .render()?,
+                ),
+            ))
+        }
     }
 }
 
@@ -560,38 +554,35 @@ pub async fn ask_reset_password_post(
     }
 }
 
+#[derive(Deserialize)]
+pub struct ResetPasswordGetParams {
+    reset_token: String,
+}
+
 #[debug_handler]
 pub async fn reset_password_get(
     State(connection): State<db::Connection>,
     Extension(context): Extension<Context>,
-    Query(query): Query<HashMap<String, String>>,
+    Query(params): Query<ResetPasswordGetParams>,
 ) -> Result<Response> {
-    if let Some(reset_token) = query.get("reset_token") {
-        // Check if the token is valid.
-        if connection
-            .is_reset_password_token_valid(
-                reset_token,
-                Duration::seconds(consts::VALIDATION_PASSWORD_RESET_TOKEN_DURATION),
-            )
-            .await?
-        {
-            Ok(Html(
-                ResetPasswordTemplate {
-                    context,
-                    reset_token,
-                    message: "",
-                    message_password: "",
-                }
-                .render()?,
-            )
-            .into_response())
-        } else {
-            Ok(Html(
-                MessageTemplate::new(context.tr.t(Sentence::AskResetTokenMissing), context)
-                    .render()?,
-            )
-            .into_response())
-        }
+    // Check if the token is valid.
+    if connection
+        .is_reset_password_token_valid(
+            &params.reset_token,
+            Duration::seconds(consts::VALIDATION_PASSWORD_RESET_TOKEN_DURATION),
+        )
+        .await?
+    {
+        Ok(Html(
+            ResetPasswordTemplate {
+                context,
+                reset_token: &params.reset_token,
+                message: "",
+                message_password: "",
+            }
+            .render()?,
+        )
+        .into_response())
     } else {
         Ok(Html(
             MessageTemplate::new(context.tr.t(Sentence::AskResetTokenMissing), context).render()?,
@@ -948,7 +939,7 @@ pub async fn email_revalidation(
     State(connection): State<db::Connection>,
     Extension(context): Extension<Context>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
-    Query(query): Query<HashMap<String, String>>,
+    Query(params): Query<ValidationTokenParams>,
     headers: HeaderMap,
 ) -> Result<(CookieJar, impl IntoResponse)> {
     let mut jar = CookieJar::from_headers(&headers);
@@ -962,66 +953,55 @@ pub async fn email_revalidation(
         ));
     }
     let (client_ip, client_user_agent) = utils::get_ip_and_user_agent(&headers, addr);
-    match query.get(VALIDATION_TOKEN_KEY) {
-        // 'validation_token' exists only when a user must validate a new email.
-        Some(token) => {
-            match connection
-                .validation(
-                    token,
-                    Duration::seconds(consts::VALIDATION_TOKEN_DURATION),
-                    &client_ip,
-                    &client_user_agent,
-                )
-                .await?
-            {
-                db::user::ValidationResult::Ok(token, user_id) => {
-                    let cookie = Cookie::build((consts::COOKIE_AUTH_TOKEN_NAME, token))
-                        .secure(true)
-                        .same_site(cookie::SameSite::Strict);
-                    jar = jar.add(cookie);
-                    let user = connection.load_user(user_id).await?;
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::ValidationSuccessful),
-                                Context { user, ..context },
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-                error @ db::user::ValidationResult::ValidationExpired => {
-                    error!("Token: {}: {}", token, error);
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::ValidationExpired),
-                                context,
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-                error @ db::user::ValidationResult::UnknownUser => {
-                    error!("(email={}): {}", token, error);
-                    Ok((
-                        jar,
-                        Html(
-                            MessageTemplate::new(
-                                context.tr.t(Sentence::ValidationErrorTryToSignUpAgain),
-                                context,
-                            )
-                            .render()?,
-                        ),
-                    ))
-                }
-            }
+
+    match connection
+        .validation(
+            &params.validation_token,
+            Duration::seconds(consts::VALIDATION_TOKEN_DURATION),
+            &client_ip,
+            &client_user_agent,
+        )
+        .await?
+    {
+        db::user::ValidationResult::Ok(token, user_id) => {
+            let cookie = Cookie::build((consts::COOKIE_AUTH_TOKEN_NAME, token))
+                .secure(true)
+                .same_site(cookie::SameSite::Strict);
+            jar = jar.add(cookie);
+            let user = connection.load_user(user_id).await?;
+            Ok((
+                jar,
+                Html(
+                    MessageTemplate::new(
+                        context.tr.t(Sentence::ValidationSuccessful),
+                        Context { user, ..context },
+                    )
+                    .render()?,
+                ),
+            ))
+        }
+        error @ db::user::ValidationResult::ValidationExpired => {
+            error!("Token: {}: {}", &params.validation_token, error);
+            Ok((
+                jar,
+                Html(
+                    MessageTemplate::new(context.tr.t(Sentence::ValidationExpired), context)
+                        .render()?,
+                ),
+            ))
+        }
+        error @ db::user::ValidationResult::UnknownUser => {
+            error!("(email={}): {}", &params.validation_token, error);
+            Ok((
+                jar,
+                Html(
+                    MessageTemplate::new(
+                        context.tr.t(Sentence::ValidationErrorTryToSignUpAgain),
+                        context,
+                    )
+                    .render()?,
+                ),
+            ))
         }
-        None => Ok((
-            jar,
-            Html(MessageTemplate::new(context.tr.t(Sentence::ValidationError), context).render()?),
-        )),
     }
 }