philipp/aef-website
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove cookie flash-messages; simply show uuid

Browse Source
This commit is contained in:
Philipp Hofer
2025-08-13 11:22:18 +02:00
parent e991818c7d
commit 652ea26b32
5 changed files with 89 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
src/game.rs
View File

@@ -1,13 +1,16 @@
use crate::{language::language, page::Page, Backend, NameUpdateError};
use crate::{
language::language,
page::{MyMessage, Page},
Backend, NameUpdateError,
};
use axum::{
extract::{Path, State},
http::HeaderMap,
response::{IntoResponse, Redirect, Response},
response::{IntoResponse, Response},
routing::{get, post},
Form, Router,
};
use axum_extra::extract::CookieJar;
use axum_messages::Messages;
use maud::{html, Markup, PreEscaped};
use serde::Deserialize;
use std::sync::Arc;
@@ -16,13 +19,18 @@ use uuid::Uuid;
async fn index(
State(backend): State<Arc<Backend>>,
cookies: CookieJar,
messages: Messages,
headers: HeaderMap,
) -> Response {
tracing::info!("in /index");
retu(backend, cookies, headers, None).await
}
async fn retu(
backend: Arc<Backend>,
cookies: CookieJar,
headers: HeaderMap,
message: Option<MyMessage>,
) -> Response {
let (cookies, req) = backend.client_full(cookies, &headers).await;
tracing::info!("cookies = {cookies:#?}");
tracing::info!("req = {req:#?}");
let client = req.client;
rust_i18n::set_locale(&req.lang.to_string());
@@ -31,7 +39,9 @@ async fn index(
let highscore = backend.highscore().await;
let mut page = Page::new(req.lang);
page.messages(messages);
if let Some(message) = message {
page.set_message(message);
}
let markup = page.content(html! {
hgroup {
h1 { (t!("game_title")) }
@@ -98,33 +108,31 @@ async fn game(
State(backend): State<Arc<Backend>>,
cookies: CookieJar,
headers: HeaderMap,
messages: Messages,
Path(uuid): Path<String>,
) -> Result<Redirect, Response> {
) -> Response {
let (cookies, req) = backend.client_full(cookies, &headers).await;
let client = req.client;
rust_i18n::set_locale(req.lang.to_locale());
let Ok(uuid) = Uuid::parse_str(&uuid) else {
return Err(not_found(cookies, headers).await.into_response());
return not_found(cookies, headers).await.into_response();
};
let Some(camera) = backend.get_camera(&uuid).await else {
return Err(not_found(cookies, headers).await.into_response());
return not_found(cookies, headers).await.into_response();
};
if let Ok(number) = backend.client_found_camera(&client, &camera).await {
messages.info(format!("found-cam|{}|{number}", camera.name));
let message = if let Ok(number) = backend.client_found_camera(&client, &camera).await {
MyMessage::FoundCam(camera.name, number)
} else {
messages.info(format!(
"err|{}|{}|{}",
t!("error_already_found_title"),
t!("error_already_found_body"),
t!("error_already_found_footer")
));
}
MyMessage::Error(
t!("error_already_found_title").into(),
t!("error_already_found_body").into(),
t!("error_already_found_footer").into(),
)
};
Ok(Redirect::to("/game"))
retu(backend, cookies, headers, Some(message)).await
}
async fn not_found(cookies: CookieJar, headers: HeaderMap) -> Markup {
@@ -142,7 +150,6 @@ struct NameForm {
async fn set_name(
State(backend): State<Arc<Backend>>,
cookies: CookieJar,
messages: Messages,
headers: HeaderMap,
Form(form): Form<NameForm>,
) -> Response {
@@ -150,32 +157,26 @@ async fn set_name(
let client = req.client;
rust_i18n::set_locale(req.lang.to_locale());
match backend.set_client_name(&client, &form.name).await {
Ok(()) => messages.info("set-name-succ"),
Err(NameUpdateError::TooShort(expected, actual)) => messages.info(format!(
"err|{}|{}|{}: {}",
t!("error_name_too_short_title"),
t!("error_name_too_short_body", expected = expected),
t!("received_characters"),
actual
)),
Err(NameUpdateError::TooLong(expected, actual)) => messages.info(format!(
"err|{}|{}|{}: {}",
t!("error_name_too_long_title"),
t!("error_name_too_long_body", expected = expected),
t!("received_characters"),
actual
)),
Err(NameUpdateError::ContainsBadWord) => messages.info(format!(
"err|{}|{}|{}",
t!("error_bad_word_title"),
t!("error_bad_word_body"),
t!("error_bad_word_footer")
)),
let message = match backend.set_client_name(&client, &form.name).await {
Ok(()) => MyMessage::NameChanged,
Err(NameUpdateError::TooShort(expected, actual)) => MyMessage::Error(
t!("error_name_too_short_title").into(),
t!("error_name_too_short_body", expected = expected).into(),
format!("{}: {actual}", t!("received_characters")),
),
Err(NameUpdateError::TooLong(expected, actual)) => MyMessage::Error(
t!("error_name_too_long_title").into(),
t!("error_name_too_long_body", expected = expected).into(),
format!("{}: {actual}", t!("received_characters")),
),
Err(NameUpdateError::ContainsBadWord) => MyMessage::Error(
t!("error_bad_word_title").into(),
t!("error_bad_word_body").into(),
t!("error_bad_word_footer").into(),
),
};
// Redirect back to the game page
(cookies, Redirect::to("/game")).into_response()
retu(backend, cookies, headers, Some(message)).await
}
pub(super) fn routes() -> Router<Arc<Backend>> {

9
src/main.rs
View File

@@ -1,7 +1,6 @@
use crate::model::client::Client;
use axum::{http::HeaderMap, routing::get, Router};
use axum_extra::extract::{cookie::Cookie, CookieJar};
use axum_messages::MessagesManagerLayer;
use sqlx::{pool::PoolOptions, sqlite::SqliteConnectOptions, SqlitePool};
use std::{
collections::HashSet,
@@ -10,7 +9,6 @@ use std::{
sync::{Arc, LazyLock},
};
use tower_http::services::ServeDir;
use tower_sessions::{MemoryStore, SessionManagerLayer};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
use uuid::Uuid;
@@ -199,9 +197,6 @@ async fn main() {
.with(EnvFilter::from_default_env())
.init();
let session_store = MemoryStore::default();
let session_layer = SessionManagerLayer::new(session_store).with_secure(false);
let connection_options = SqliteConnectOptions::from_str("sqlite://db.sqlite").unwrap();
let db: SqlitePool = PoolOptions::new()
.connect_with(connection_options)
@@ -212,9 +207,7 @@ async fn main() {
.route("/", get(index::index))
.nest_service("/static", ServeDir::new("./static/serve"))
.merge(game::routes())
.with_state(Arc::new(Backend::Sqlite(db)))
.layer(MessagesManagerLayer)
.layer(session_layer);
.with_state(Arc::new(Backend::Sqlite(db)));
// run our app with hyper, listening globally on port 3000
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

101
src/page.rs
View File

@@ -1,52 +1,27 @@
use crate::Language;
use axum_messages::Messages;
use maud::{DOCTYPE, Markup, html};
use maud::{html, Markup, DOCTYPE};
pub(crate) struct Page {
lang: Language,
found_camera: Option<(String, i64)>,
new_name: bool,
err: Option<(String, String, String)>,
message: Option<MyMessage>,
}
pub(crate) enum MyMessage {
NameChanged,
FoundCam(String, i64),
Error(String, String, String),
}
impl Page {
pub fn new(lang: Language) -> Self {
Self {
lang,
found_camera: None,
new_name: false,
err: None,
message: None,
}
}
pub fn messages(&mut self, messages: Messages) {
for message in messages {
let text = &message.to_string()[..];
match (message.level, text) {
(_, "set-name-succ") => {
self.new_name = true;
}
(_, msg) if msg.starts_with("found-cam|") => {
let mut parts = msg.splitn(3, '|');
let _ = parts.next().expect("just checked |");
if let (Some(name), Some(amount)) = (parts.next(), parts.next()) {
if let Ok(amount) = amount.parse::<i64>() {
self.found_camera = Some((name.into(), amount));
}
}
}
(_, msg) if msg.starts_with("err|") => {
let mut parts = msg.splitn(4, '|');
let _ = parts.next().expect("just checked |");
if let (Some(title), Some(body), Some(footer)) =
(parts.next(), parts.next(), parts.next())
{
self.err = Some((title.into(), body.into(), footer.into()));
}
}
(_, _) => {}
}
}
pub(crate) fn set_message(&mut self, message: MyMessage) {
self.message = Some(message);
}
pub fn content(self, content: Markup) -> Markup {
@@ -92,35 +67,39 @@ impl Page {
}
main.container {
@if let Some(found_camera) = &self.found_camera {
div.flex {
article class="succ msg" {
header { (t!("found_camera_title", name = found_camera.0)) }
(t!("found_camera_body", amount = found_camera.1))
footer {
a href="#ranking" { (t!("see_ranking")) }
@if let Some(message) = &self.message {
@match message {
MyMessage::FoundCam(name, amount) => {
div.flex {
article class="succ msg" {
header { (t!("found_camera_title", name = name)) }
(t!("found_camera_body", amount = amount))
footer {
a href="#ranking" { (t!("see_ranking")) }
}
}
}
},
MyMessage::NameChanged => {
div.flex {
article class="name msg" {
header { (t!("new_name_title")) }
(t!("new_name_message"))
}
}
},
MyMessage::Error(header, body, footer) => {
div.flex {
article class="error msg" {
header { (header) }
(body)
footer { (footer) }
}
}
}
}
}
@if self.new_name {
div.flex {
article class="name msg" {
header { (t!("new_name_title")) }
(t!("new_name_message"))
}
}
}
@if let Some(err) = &self.err {
div.flex {
article class="error msg" {
header { (err.0) }
(err.1)
footer { (err.2) }
}
}
}
}
section { (content) }
}