code002lover/game_list
1
0
Fork 0
Code Issues 1 Pull Requests 10 Actions Packages Projects Releases Wiki Activity

do stuffs

Browse Source
This commit is contained in:
code002lover
2026-01-12 23:30:36 +01:00
parent 5729940a62
commit 4abe8a53df
8 changed files with 349 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/main.rs
+85 -36
View File
@@ -4,9 +4,12 @@ use rocket::futures::lock::Mutex;
use backend::auth;
use backend::auth::AdminState;
use backend::csrf::{CsrfFairing, CsrfToken};
use backend::items::{self, Game};
use backend::proto_utils;
use backend::security_headers::SecurityHeaders;
use backend::store::{self, User, save_state};
use backend::validation;
#[macro_use]
extern crate rocket;
@@ -17,6 +20,10 @@ async fn get_user(
user_list: &rocket::State<Mutex<Vec<User>>>,
name: &str,
) -> Option<items::Person> {
if validation::validate_username(name).is_err() {
return None;
}
let users = user_list.lock().await;
users
.iter()
@@ -41,6 +48,10 @@ async fn get_game(
game_list: &rocket::State<Mutex<Vec<Game>>>,
title: &str,
) -> Option<items::Game> {
if validation::validate_game_title(title).is_err() {
return None;
}
let games = game_list.lock().await;
games
.iter()
@@ -53,12 +64,16 @@ async fn get_games_batch(
_token: auth::Token,
game_list: &rocket::State<Mutex<Vec<Game>>>,
req: proto_utils::Proto<items::GetGameInfoRequest>,
) -> items::GameList {
let games = game_list.lock().await;
) -> Result<items::GameList, String> {
let req = req.into_inner();
let games_set: std::collections::HashSet<String> = req.games.into_iter().collect();
validation::validate_game_titles_batch(&games_set)?;
let games = game_list.lock().await;
let mut games = games.clone();
games.retain(|g| req.games.contains(&g.title));
items::GameList { games }
games.retain(|g| games_set.contains(&g.title));
Ok(items::GameList { games })
}
#[get("/games")]
@@ -72,55 +87,77 @@ async fn get_games(
}
}
#[post("/game", data = "<game>")]
#[post("/game", data = "<game>", rank = 1)]
async fn add_game(
_token: auth::Token,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
game: proto_utils::Proto<items::Game>,
) -> Option<items::Game> {
let mut games = game_list.lock().await;
) -> Result<Option<items::Game>, String> {
let mut game = game.into_inner();
game.title = game.title.trim().to_string();
if game.remote_id == 0 {
return None;
validation::validate_game_title(&game.title)?;
validation::validate_remote_id(game.remote_id)?;
validation::validate_player_count(game.min_players, game.max_players)?;
validation::validate_price(game.price)?;
if game.title.len() > validation::MAX_GAME_TITLE_TRIMMED_LENGTH {
game.title = game
.title
.chars()
.take(validation::MAX_GAME_TITLE_TRIMMED_LENGTH)
.collect();
}
let users = user_list.lock().await;
let mut games = game_list.lock().await;
if let Some(existing) = games.iter().find(|g| {
g.title == game.title || (g.remote_id == game.remote_id && g.source == game.source)
}) {
return Some(existing.clone());
return Ok(Some(existing.clone()));
}
games.push(game.clone());
games.sort_unstable_by(|g1, g2| g1.title.cmp(&g2.title));
let users = user_list.lock().await;
save_state(&games, &users);
Some(game)
Ok(Some(game))
}
#[patch("/game", data = "<game>")]
#[patch("/game", data = "<game>", rank = 1)]
async fn update_game(
_token: auth::AdminToken,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
game: proto_utils::Proto<items::Game>,
) -> Option<items::Game> {
let mut games = game_list.lock().await;
let mut users = user_list.lock().await;
) -> Result<Option<items::Game>, String> {
let mut game = game.into_inner();
game.title = game.title.trim().to_string();
if game.remote_id == 0 {
return None;
validation::validate_game_title(&game.title)?;
validation::validate_remote_id(game.remote_id)?;
validation::validate_player_count(game.min_players, game.max_players)?;
validation::validate_price(game.price)?;
if game.title.len() > validation::MAX_GAME_TITLE_TRIMMED_LENGTH {
game.title = game
.title
.chars()
.take(validation::MAX_GAME_TITLE_TRIMMED_LENGTH)
.collect();
}
let mut users = user_list.lock().await;
let mut games = game_list.lock().await;
let mut r_existing = None;
if let Some(existing) = games.iter_mut().find(|g| {
@@ -128,7 +165,6 @@ async fn update_game(
}) {
if existing.title != game.title {
let old_title = existing.title.clone();
// Update title for every opinion
for person in users.iter_mut() {
let opinion = person
.person
@@ -154,16 +190,20 @@ async fn update_game(
save_state(&games, &users);
r_existing
Ok(r_existing)
}
#[delete("/game/<title>")]
#[delete("/game/<title>", rank = 1)]
async fn delete_game(
_token: auth::AdminToken,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
title: &str,
) -> Option<items::Game> {
) -> Result<Option<items::Game>, String> {
validation::validate_game_title(title)?;
let mut users = user_list.lock().await;
let mut games = game_list.lock().await;
if let Some(pos) = games
@@ -172,30 +212,29 @@ async fn delete_game(
{
let game = games.remove(pos);
let mut users = user_list.lock().await;
for person in users.iter_mut() {
person.person.opinion.retain_mut(|o| o.title != game.title);
}
save_state(&games, &users);
return Some(game);
return Ok(Some(game));
}
None
Ok(None)
}
#[post("/refresh")]
#[post("/refresh", rank = 1)]
async fn refresh_state(
_token: auth::AdminToken,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
admin_state: &rocket::State<AdminState>,
) -> items::RefreshResponse {
if let Some((new_games, new_users)) = store::load_state() {
let mut games = game_list.lock().await;
let mut users = user_list.lock().await;
let mut games = game_list.lock().await;
let mut admins = admin_state.admins.lock().await;
*games = new_games;
@@ -214,20 +253,22 @@ async fn refresh_state(
}
}
#[post("/opinion", data = "<req>")]
#[post("/opinion", data = "<req>", rank = 1)]
async fn add_opinion(
token: auth::Token,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
req: proto_utils::Proto<items::AddOpinionRequest>,
) -> Option<items::Person> {
) -> Result<Option<items::Person>, String> {
validation::validate_username(&token.username)?;
let games = game_list.lock().await;
let mut users = user_list.lock().await;
let mut result = None;
// Validate game exists
if !games.iter().any(|g| g.title == req.game_title) {
return None;
return Err("Game not found".to_string());
}
if let Some(user) = users
@@ -235,6 +276,8 @@ async fn add_opinion(
.find(|u| u.person.name.to_lowercase() == token.username.to_lowercase())
{
let req = req.into_inner();
validation::validate_game_title(&req.game_title)?;
let opinion = items::Opinion {
title: req.game_title.clone(),
would_play: req.would_play,
@@ -260,16 +303,19 @@ async fn add_opinion(
if result.is_some() {
save_state(&games, &users);
}
result
Ok(result)
}
#[patch("/opinion", data = "<req>")]
#[patch("/opinion", data = "<req>", rank = 1)]
async fn remove_opinion(
token: auth::Token,
_csrf: CsrfToken,
game_list: &rocket::State<Mutex<Vec<Game>>>,
user_list: &rocket::State<Mutex<Vec<User>>>,
req: proto_utils::Proto<items::RemoveOpinionRequest>,
) -> Option<items::Person> {
) -> Result<Option<items::Person>, String> {
validation::validate_username(&token.username)?;
let games = game_list.lock().await;
let mut users = user_list.lock().await;
let mut result = None;
@@ -279,6 +325,7 @@ async fn remove_opinion(
.find(|u| u.person.name.to_lowercase() == token.username.to_lowercase())
{
let req = req.into_inner();
validation::validate_game_title(&req.game_title)?;
if let Some(existing) = user
.person
@@ -294,7 +341,7 @@ async fn remove_opinion(
if result.is_some() {
save_state(&games, &users);
}
result
Ok(result)
}
mod cached_option;
@@ -447,6 +494,8 @@ async fn main() -> Result<(), std::io::Error> {
});
rocket::build()
.attach(SecurityHeaders)
.attach(CsrfFairing)
.manage(Mutex::new(user_list))
.manage(auth::AuthState::new())
.manage(auth::AdminState::new())