From d152a999c9b32b7c822d071f3ecf362e7d2d71c9 Mon Sep 17 00:00:00 2001 From: Artus Date: Thu, 9 Jan 2020 15:12:51 +0100 Subject: [PATCH] fixes errors --- lootalot_db/src/lib.rs | 258 ++---------------------------- lootalot_db/src/models/history.rs | 14 +- lootalot_db/src/models/item.rs | 104 ++++++------ src/api.rs | 102 +++++------- src/server.rs | 36 ++--- 5 files changed, 128 insertions(+), 386 deletions(-) diff --git a/lootalot_db/src/lib.rs b/lootalot_db/src/lib.rs index 91403d1..416e794 100644 --- a/lootalot_db/src/lib.rs +++ b/lootalot_db/src/lib.rs @@ -43,36 +43,36 @@ pub fn create_pool() -> Pool { } /// Every possible update which can happen during a query +/// Updates are relative to a Player #[derive(Serialize, Deserialize, Debug)] pub enum Update { Wealth(Wealth), ItemAdded(Item), ItemRemoved(Item), + ItemBought(Item), + ItemSold(Item), ClaimAdded(Claim), ClaimRemoved(Claim), } impl Update { /// Change back what has been updated - fn undo(&self, conn: &DbConnection, id: i32) -> UpdateResult { - Ok(match self { - Update::Wealth(diff) => AsPlayer(conn, id).update_wealth(-diff.to_gp())?, - Update::ItemAdded(item) => LootManager(conn, id).find(item.id)?.remove(conn)?, - Update::ItemRemoved(item) => LootManager(conn, id).add_from(&item)?, + fn undo(&self, conn: &DbConnection, id: i32) -> QueryResult<()> { + match self { + Update::Wealth(diff) => { AsPlayer(conn, id).update_wealth(-diff.to_gp())?; }, + Update::ItemAdded(item) => { diesel::delete(crate::schema::loot::table.find(item.id)) + .execute(conn)?; }, + Update::ItemRemoved(item) => { LootManager(conn, id).add_from(&item)?; }, + Update::ItemBought(item) => { LootManager(conn, id).change_owner(item.id, models::item::OF_SHOP)?;}, + Update::ItemSold(item) => { LootManager(conn, models::item::SOLD).change_owner(item.id, id)?; }, // Unused for now - Update::ClaimAdded(claim) => vec!(Update::ClaimRemoved(*claim)), - Update::ClaimRemoved(claim) => vec!(Update::ClaimAdded(*claim)), - }) + Update::ClaimAdded(claim) => {}, + Update::ClaimRemoved(claim) => {}, + }; + Ok(()) } } -/// TODO: use this to wrap update in UpdateResult, allowing unified interface -/// whether a query makes multiple updates or just one. -enum OneOrMore { - One(Update), - More(Vec), -} - /// Every value which can be queried #[derive(Debug)] pub enum Value { @@ -166,231 +166,3 @@ pub fn split_and_share( Ok(vec!(Update::Wealth(Wealth::from_gp(shared_total)))) }) } - -#[cfg(none)] -mod tests_old { - use super::*; - type TestConnection = DbConnection; - - /// Return a connection to a fresh database (stored in memory) - fn test_connection() -> TestConnection { - let test_conn = DbConnection::establish(":memory:").unwrap(); - diesel_migrations::run_pending_migrations(&test_conn).unwrap(); - test_conn - } - - /// When migrations are run, a special player with id 0 and name "Groupe" - /// must be created. - #[test] - fn global_group_is_autocreated() { - let conn = test_connection(); - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - assert_eq!(players.len(), 1); - let group = players.get(0).unwrap(); - assert_eq!(group.id, 0); - assert_eq!(group.name, "Groupe".to_string()); - } - - /// When a player updates wealth, a difference is returned by API. - /// Added to the previous amount of coins, it should equal the updated weath. - #[test] - fn as_player_updates_wealth() { - let conn = test_connection(); - DbApi::with_conn(&conn) - .as_admin() - .add_player("PlayerName", 403.21) - .unwrap(); - let diff = DbApi::with_conn(&conn) - .as_player(1) - .update_wealth(-401.21) - .ok(); - // Check the returned diff - assert_eq!(diff, Some((-1, -2, -1, -4))); - let diff = diff.unwrap(); - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - let player = players.get(1).unwrap(); - // Check that we can add old value to return diff to get resulting value - assert_eq!( - (player.cp, player.sp, player.gp, player.pp), - (1 + diff.0, 2 + diff.1, 3 + diff.2, 4 + diff.3) - ); - } - - #[test] - fn as_admin_add_player() { - let conn = test_connection(); - let result = DbApi::with_conn(&conn) - .as_admin() - .add_player("PlayerName", 403.21); - assert_eq!(result.is_ok(), true); - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - assert_eq!(players.len(), 2); - let new_player = players.get(1).unwrap(); - assert_eq!(new_player.name, "PlayerName"); - assert_eq!( - (new_player.cp, new_player.sp, new_player.gp, new_player.pp), - (1, 2, 3, 4) - ); - } - - #[test] - fn as_admin_resolve_claims() { - let conn = test_connection(); - let claims = DbApi::with_conn(&conn).fetch_claims().unwrap(); - assert_eq!(claims.len(), 0); - - // Add items - assert_eq!( - DbApi::with_conn(&conn) - .as_admin() - .add_loot(vec![("Épée", 40), ("Arc", 40),]) - .is_ok(), - true - ); - // Add players - DbApi::with_conn(&conn) - .as_admin() - .add_player("Player1", 0.0) - .unwrap(); - DbApi::with_conn(&conn) - .as_admin() - .add_player("Player2", 0.0) - .unwrap(); - // Put claims on one different item each - DbApi::with_conn(&conn).as_player(1).claim(1).unwrap(); - DbApi::with_conn(&conn).as_player(2).claim(2).unwrap(); - let result = DbApi::with_conn(&conn).as_admin().resolve_claims(); - assert_eq!(result.is_ok(), true); - // Check that both players received an item - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - for &i in [1, 2].into_iter() { - assert_eq!( - DbApi::with_conn(&conn).as_player(i).loot().unwrap().len(), - 1 - ); - let player = players.get(i as usize).unwrap(); - assert_eq!(player.debt, 20); - } - } - - #[test] - fn as_player_claim_item() { - let conn = test_connection(); - DbApi::with_conn(&conn) - .as_admin() - .add_player("Player", 0.0) - .unwrap(); - DbApi::with_conn(&conn) - .as_admin() - .add_loot(vec![("Épée", 25)]) - .unwrap(); - // Claim an existing item - let result = DbApi::with_conn(&conn).as_player(1).claim(1); - assert_eq!(result.is_ok(), true); - let claims = DbApi::with_conn(&conn).fetch_claims().unwrap(); - assert_eq!(claims.len(), 1); - let claim = claims.get(0).unwrap(); - assert_eq!(claim.player_id, 1); - assert_eq!(claim.loot_id, 1); - // Claim an inexistant item - let result = DbApi::with_conn(&conn).as_player(1).claim(2); - assert_eq!(result.is_ok(), false); - } - - #[test] - fn as_player_unclaim_item() { - let conn = test_connection(); - DbApi::with_conn(&conn) - .as_admin() - .add_player("Player", 0.0) - .unwrap(); - DbApi::with_conn(&conn) - .as_admin() - .add_loot(vec![("Épée", 25)]) - .unwrap(); - // Claim an existing item - let result = DbApi::with_conn(&conn).as_player(1).claim(1); - assert_eq!(result.is_ok(), true); - // Claiming twice is an error - let result = DbApi::with_conn(&conn).as_player(1).claim(1); - assert_eq!(result.is_ok(), false); - // Unclaiming and item - let result = DbApi::with_conn(&conn).as_player(1).unclaim(1); - assert_eq!(result.is_ok(), true); - // Check that not claimed items will not be unclaimed... - let result = DbApi::with_conn(&conn).as_player(1).unclaim(1); - assert_eq!(result.is_ok(), false); - let claims = DbApi::with_conn(&conn).fetch_claims().unwrap(); - assert_eq!(claims.len(), 0); - } - - /// All-in-one checks one a simple buy/sell procedure - /// - /// Checks that player's chest and wealth are updated. - /// Checks that items are sold at half their value. - /// Checks that a player cannot sell item he does not own. - #[test] - fn as_player_simple_buy_sell() { - let conn = test_connection(); - // Adds a sword into inventory - { - use schema::items::dsl::*; - diesel::insert_into(items) - .values((name.eq("Sword"), base_price.eq(800))) - .execute(&conn) - .expect("Could not set up items table"); - } - DbApi::with_conn(&conn) - .as_admin() - .add_player("Player", 1000.0) - .unwrap(); - // Buy an item - let bought = DbApi::with_conn(&conn).as_player(1).buy(&vec![(1, None)]); - assert_eq!(bought.ok(), Some((0, 0, 0, -8))); // Returns diff of player wealth ? - let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap(); - assert_eq!(chest.len(), 1); - let loot = chest.get(0).unwrap(); - assert_eq!(loot.name, "Sword"); - assert_eq!(loot.base_price, 800); - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - let player = players.get(1).unwrap(); - assert_eq!(player.pp, 2); - // A player cannot sell loot from an other's chest - let result = DbApi::with_conn(&conn) - .as_player(0) - .sell(&vec![(loot.id, None)]); - assert_eq!(result.is_ok(), false); - // Sell back - let sold = DbApi::with_conn(&conn) - .as_player(1) - .sell(&vec![(loot.id, None)]); - assert_eq!(sold.ok(), Some((0, 0, 0, 4))); - let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap(); - assert_eq!(chest.len(), 0); - let players = DbApi::with_conn(&conn).fetch_players().unwrap(); - let player = players.get(1).unwrap(); - assert_eq!(player.pp, 6); - } - - #[test] - fn as_admin_add_loot() { - let conn = test_connection(); - assert_eq!( - 0, - DbApi::with_conn(&conn).as_player(0).loot().unwrap().len() - ); - let loot_to_add = vec![("Cape d'invisibilité", 8000), ("Arc long", 25)]; - let result = DbApi::with_conn(&conn) - .as_admin() - .add_loot(loot_to_add.clone()); - assert_eq!(result.is_ok(), true); - let looted = DbApi::with_conn(&conn).as_player(0).loot().unwrap(); - assert_eq!(looted.len(), 2); - // NB: Not a problem now, but this adds constraints of items being - // created in the same order. - for (added, to_add) in looted.into_iter().zip(loot_to_add) { - assert_eq!(added.name, to_add.0); - assert_eq!(added.base_price, to_add.1); - } - } -} diff --git a/lootalot_db/src/models/history.rs b/lootalot_db/src/models/history.rs index d23681b..40a2463 100644 --- a/lootalot_db/src/models/history.rs +++ b/lootalot_db/src/models/history.rs @@ -39,18 +39,14 @@ impl Event { /// TODO: why a move here ?? /// Undo all updates in a single transaction - pub fn undo(self, conn: &DbConnection) -> QueryResult { + pub fn undo(self, conn: &DbConnection) -> QueryResult<()> { conn.transaction(move || { if let Some(ref updates) = self.updates { - let undone = updates.0.iter() - // TODO: swallow errors ! - .filter_map(|u| u.undo(conn, self.player_id).ok()) - .collect(); - diesel::delete(history::table.find(self.id)).execute(conn)?; - Ok(UpdateList(undone)) - } else { - Ok(UpdateList(vec![])) + for update in updates.inner() { + update.undo(conn, self.player_id)?; + } } + Ok(()) }) } } diff --git a/lootalot_db/src/models/item.rs b/lootalot_db/src/models/item.rs index b1b9099..63b5a0d 100644 --- a/lootalot_db/src/models/item.rs +++ b/lootalot_db/src/models/item.rs @@ -3,7 +3,7 @@ use diesel::expression::exists::Exists; use diesel::prelude::*; use crate::schema::{items, loot}; -use crate::{DbConnection, QueryResult, Update, UpdateResult, Claims }; +use crate::{Claims, DbConnection, QueryResult, Update, UpdateResult}; type ItemColumns = (loot::id, loot::name, loot::base_price); const ITEM_COLUMNS: ItemColumns = (loot::id, loot::name, loot::base_price); type OwnedBy = Select; @@ -33,9 +33,9 @@ impl Item { } // Owner status -const OF_GROUP: i32 = 0; -const OF_SHOP: i32 = -1; -const SOLD: i32 = -2; +pub(crate) const OF_GROUP: i32 = 0; +pub(crate) const OF_SHOP: i32 = -1; +pub(crate) const SOLD: i32 = -2; type WithOwner = Eq; type OwnedLoot = Filter; @@ -46,24 +46,19 @@ type OwnedLoot = Filter; /// OR the SOLD state. #[derive(Identifiable, Debug, Queryable)] #[table_name = "loot"] -pub(super) struct Loot { +pub(crate) struct Loot { id: i32, name: String, base_price: i32, owner_id: i32, } - impl Loot { /// A filter on Loot that is owned by given player pub(super) fn owned_by(id: i32) -> OwnedLoot { loot::table.filter(loot::owner_id.eq(id)) } - fn exists(id: i32) -> Exists> { - exists(loot::table.find(id)) - } - pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> { diesel::update(loot::table.find(self.id)) .set(loot::dsl::owner_id.eq(owner)) @@ -98,7 +93,9 @@ impl<'q> Inventory<'q> { } pub fn find_by_name(&self, item_name: &str) -> QueryResult { - Ok(items::table.filter(items::dsl::name.like(item_name)).first(self.0)?) + Ok(items::table + .filter(items::dsl::name.like(item_name)) + .first(self.0)?) } /// Check the inventory against a list of item names @@ -139,53 +136,48 @@ impl<'q> Shop<'q> { self.0.transaction(|| { let mut updates = AsPlayer(self.0, buyer).update_wealth(-sell_price)?; item.set_owner(buyer, self.0)?; - updates.push(Update::ItemAdded(item.into_item())); + updates.push(Update::ItemBought(item.into_item())); Ok(updates) }) } pub fn buy(&self, items: Vec<(i32, Option)>, buyer: i32) -> UpdateResult { - // TODO: check that player has enough money ! - let has_enough_gold = true; + // TODO: check that player has enough money ! + let has_enough_gold = true; - if has_enough_gold { - let mut updates = Vec::new(); - for (item_id, price_mod) in items.into_iter() { - updates.append( - &mut self.buy_single(buyer, item_id, price_mod)? - ) - } - Ok(updates) - } else { - unimplemented!(); + if has_enough_gold { + let mut updates = Vec::new(); + for (item_id, price_mod) in items.into_iter() { + updates.append(&mut self.buy_single(buyer, item_id, price_mod)?) } + Ok(updates) + } else { + unimplemented!(); + } } - fn get(&self, id: i32) -> QueryResult { + pub(crate) fn get(&self, id: i32) -> QueryResult { Loot::owned_by(OF_SHOP).find(&id).first::(self.0) } pub fn replace_list(&self, items: Vec) -> QueryResult<()> { use self::loot::dsl::*; - self.0.transaction( - || -> QueryResult<()> - { - // Remove all content - diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?; - // Adds new list - for item in &items { - let new_item = NewLoot { - name: &item.name, - base_price: item.base_price, - owner_id: OF_SHOP, - }; - diesel::insert_into(loot) - .values(&new_item) - .execute(self.0)?; - } - Ok(()) + self.0.transaction(|| -> QueryResult<()> { + // Remove all content + diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?; + // Adds new list + for item in &items { + let new_item = NewLoot { + name: &item.name, + base_price: item.base_price, + owner_id: OF_SHOP, + }; + diesel::insert_into(loot) + .values(&new_item) + .execute(self.0)?; } - ) + Ok(()) + }) } } @@ -198,10 +190,14 @@ impl<'q> LootManager<'q> { Ok(Item::owned_by(self.1).load(self.0)?) } - fn get(&self, item_id: i32) -> QueryResult { + pub(crate) fn get(&self, item_id: i32) -> QueryResult { Ok(Loot::owned_by(self.1).find(item_id).first(self.0)?) } + pub(crate) fn change_owner(&self, item_id: i32, new_owner: i32) -> QueryResult<()> { + Ok(self.get(item_id)?.set_owner(new_owner, self.0)?) + } + /// Finds an item by id /// /// Returns a NotFound error if an item is found by it @@ -217,27 +213,23 @@ impl<'q> LootManager<'q> { sell_value *= modifier; } self.0.transaction(|| { - let mut updates = - crate::AsPlayer(self.0, self.1) - .update_wealth(sell_value)?; + let mut updates = crate::AsPlayer(self.0, self.1).update_wealth(sell_value)?; to_sell.set_owner(SOLD, self.0)?; - updates.push(Update::ItemRemoved(to_sell.into_item())); + updates.push(Update::ItemSold(to_sell.into_item())); Ok(updates) }) } pub fn sell(&self, items: Vec<(i32, Option)>) -> UpdateResult { self.0.transaction(|| { - let mut updates = Vec::new(); - for (loot_id, price_mod) in items.into_iter() { - updates.append(&mut self.sell_single(loot_id, price_mod)?); - } - Ok(updates) + let mut updates = Vec::new(); + for (loot_id, price_mod) in items.into_iter() { + updates.append(&mut self.sell_single(loot_id, price_mod)?); + } + Ok(updates) }) } - - /// The last item added to the chest pub fn last(&self) -> QueryResult { Ok(Item::owned_by(self.1) @@ -263,7 +255,7 @@ impl<'q> LootManager<'q> { diesel::insert_into(loot::table) .values(&new_item) .execute(self.0)?; - Ok(vec!(Update::ItemAdded(self.last()?))) + Ok(vec![Update::ItemAdded(self.last()?)]) } } diff --git a/src/api.rs b/src/api.rs index 47d9c28..8a84ac3 100644 --- a/src/api.rs +++ b/src/api.rs @@ -40,7 +40,7 @@ pub struct ApiResponse { } impl ApiResponse { - fn push_updates(&mut self, updates: Vec) { + fn push_updates(&mut self, mut updates: Vec) { if let Some(v) = self.updates.as_mut() { v.append(&mut updates); } else { @@ -48,6 +48,10 @@ impl ApiResponse { } } + fn push_update(&mut self, update: db::Update) { + self.push_updates(vec!(update)) + } + fn push_error>(&mut self, error: S) { if let Some(errors) = self.errors.as_mut() { *errors = format!("{}\n{}", errors, error.into()); @@ -70,35 +74,7 @@ pub enum ApiError { InvalidAction(String), } -/// Every allowed queries on the database -pub enum ApiActions { - // Application level - FetchPlayers, - FetchInventory, - FetchShopInventory, - FetchClaims, - CheckItemList(Vec), - // Player level - FetchPlayer(i32), - FetchPlayerClaims(i32), - FetchNotifications(i32), - FetchLoot(i32), - UpdateWealth(i32, f64), - BuyItems(i32, BuySellParams), - SellItems(i32, BuySellParams), - ClaimItems(i32, IdList), - UndoLastAction(i32), - // Group level - AddLoot(NewGroupLoot), - // Admin level - RefreshShopInventory(ItemList), - AddPlayer(NewPlayer), - //AddInventoryItem(pub String, pub i32), - //ResolveClaims, - //SetClaimsTimeout(pub i32), -} - -pub enum ApiEndpoints { +pub enum ApiEndpoint { InventoryList, InventoryCheck(Vec), InventoryAdd(String, i32), // db::Inventory(conn)::add(new_item) @@ -124,65 +100,69 @@ pub enum ApiEndpoints { ResolveClaims, // db::Group(conn)::resolve_claims() } -static ErrorMsg : &str = "Une erreur est survenue"; +static ERROR_MSG : &str = "Une erreur est survenue"; pub fn execute( conn: &DbConnection, - query: ApiEndpoints, + query: ApiEndpoint, ) -> Result { let mut response = ApiResponse::default(); // Return an Option that describes what happened. // If there is some value, store the actions in db so that it can be reversed. let action_text: Option<(i32, &str)> = match query { // Inventory - ApiEndpoints::FetchInventory => { + ApiEndpoint::InventoryList => { match db::Inventory(conn).all() { Ok(items) => response.set_value(Value::ItemList(items)), - Err(_) => response.set_error(ErrorMsg), + Err(_) => response.push_error(ERROR_MSG), } None } - ApiEnpoints::InventoryCheck(names) => { + ApiEndpoint::InventoryCheck(names) => { match db::Inventory(conn).check_list(names) { Ok((items, errors)) => { response.set_value(Value::ItemList(items)); response.push_error(errors); } - Err(_) => response.set_error(ErrorMsg), + Err(_) => response.push_error(ERROR_MSG), } None } - ApiEndpoints::InventoryAdd((name, value)) => { - response.set_error("Not implemented"); + ApiEndpoint::InventoryAdd(name, value) => { + response.push_error("Not implemented"); None } //Shop - ApiEnpoints::ShopList => { + ApiEndpoint::ShopList => { match db::Shop(conn).all() { Ok(items) => response.set_value(Value::ItemList(items)), - Err(_) => response.set_error(ErrorMsg), + Err(_) => response.push_error(ERROR_MSG), } None } - ApiEndpoints::BuyItems(buyer, params) => { - match db::Shop(conn).buy(params, buyer) { + ApiEndpoint::BuyItems(buyer, params) => { + match db::Shop(conn).buy(params.items, buyer) { Ok(updates) => { - response.notifiy("Objets achetés !"); + response.notify("Objets achetés !"); response.push_updates(updates); - Some((id, "Achat d'objets")) + Some((buyer, "Achat d'objets")) }, Err(_) => { - response.set_error(ErrorMsg); + response.push_error(ERROR_MSG); None } } } // Players - ApiEndpoints::PlayerList => { + ApiEndpoint::PlayerList => { response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?)); None } - ApiEndpoint::ClaimList => { + ApiEndpoint::PlayerFetch(id) => { + response.set_value(Value::Player(db::Players(conn).find(id)?)); + None + } + ApiEndpoint::ClaimsList => { response.set_value(Value::ClaimList(db::Claims(conn).all()?)); None } @@ -209,16 +189,20 @@ pub fn execute( // Group sells item like players then split the total amount among players. ApiEndpoint::SellItems(id, params) => { conn.transaction(|| -> Result, diesel::result::Error> { - let sold = LootManager(conn, id).sell(params.items)?; + let mut updates = db::LootManager(conn, id).sell(params.items)?; + let total_amount: i32 = updates.iter() + .filter_map(|u| match u { + Update::Wealth(diff) => Some(diff.to_gp() as i32), + _ => None + }).sum(); match id { 0 => { let players = params.players.unwrap_or_default(); - updates.push( - db::split_and_share(conn, total_amount.to_gp() as i32, players)? + updates.append( + &mut db::split_and_share(conn, total_amount, players)? ); response.notify("Les objets ont été vendus"); response.push_updates(updates); - }; } _ => { response.notify("Objets vendus !"); @@ -239,11 +223,11 @@ pub fn execute( let new_claims: HashSet = items.into_iter().collect(); // Claims to delete for item in current_claims.difference(&new_claims) { - response.push_update(db::Claims(conn).remove(id, *item)?); + response.push_updates(db::Claims(conn).remove(id, *item)?); } // Claims to add for item in new_claims.difference(¤t_claims) { - response.push_update(db::Claims(conn).add(id, *item)?); + response.push_updates(db::Claims(conn).add(id, *item)?); } Ok(None) })? @@ -251,9 +235,7 @@ pub fn execute( ApiEndpoint::UndoLastAction(id) => { if let Ok(event) = db::models::history::get_last_of_player(conn, id) { let name = String::from(event.name()); - for undone in event.undo(conn)?.into_inner().into_iter() { - response.push_update(undone); - } + event.undo(conn)?; response.notify(format!("'{}' annulé(e)", name)); } else { response.push_error("Aucune action trouvée") @@ -265,7 +247,7 @@ pub fn execute( let mut added_items = 0; for item in data.items.into_iter() { if let Ok(added) = db::LootManager(conn, 0).add_from(&item) { - response.push_update(added); + response.push_updates(added); added_items += 1; } else { response.push_error(format!("Error adding {:?}", item)); @@ -280,17 +262,17 @@ pub fn execute( }; Some((0, "Nouveau loot")) } - ApiEndpoints::ResolveClaims => { + ApiEndpoint::ResolveClaims => { response.push_error("Not implemented!"); None } // Admin actions - ApiEndpoints::RefreshShop(items) => { + ApiEndpoint::RefreshShop(items) => { db::Shop(conn).replace_list(items)?; response.notify("Inventaire du marchand renouvelé !"); None } - ApiEnpoints::AddPlayer(data) => { + ApiEndpoint::PlayerAdd(data) => { db::Players(conn).add(&data.name, data.wealth)?; response.notify("Joueur ajouté !"); None diff --git a/src/server.rs b/src/server.rs index 495cc09..ed11b93 100644 --- a/src/server.rs +++ b/src/server.rs @@ -30,7 +30,7 @@ type MaybeForbidden = /// Wraps call to the database query and convert its result as a async HttpResponse fn db_call( pool: AppPool, - query: api::ApiActions, + query: api::ApiEndpoint, ) -> impl Future { let conn = pool.get().unwrap(); web::block(move || api::execute(&conn, query)).then(|res| match res { @@ -42,7 +42,7 @@ fn db_call( }) } -fn restricted_to_group(id: i32, params: (AppPool, api::ApiActions)) -> MaybeForbidden { +fn restricted_to_group(id: i32, params: (AppPool, api::ApiEndpoint)) -> MaybeForbidden { if id != 0 { actix_web::Either::B(HttpResponse::Forbidden().finish()) } else { @@ -101,7 +101,7 @@ where } fn configure_api(config: &mut web::ServiceConfig) { - use api::ApiActions as Q; + use api::ApiEndpoint as Q; config.service( web::scope("/api") .wrap(RestrictedAccess) @@ -109,31 +109,31 @@ fn configure_api(config: &mut web::ServiceConfig) { web::scope("/players") .service( web::resource("/") - .route(web::get().to_async(|pool| db_call(pool, Q::FetchPlayers))) + .route(web::get().to_async(|pool| db_call(pool, Q::PlayerList))) .route(web::post().to_async( |pool, player: web::Json| { - db_call(pool, Q::AddPlayer(player.into_inner())) + db_call(pool, Q::PlayerAdd(player.into_inner())) }, )), ) // List of players .service( web::scope("/{player_id}") - .route( + /*.route( "/", web::get().to_async(|pool, player: PlayerId| { db_call(pool, Q::FetchPlayer(*player)) }), - ) + )*/ .route( "/notifications", web::get().to_async(|pool, player: PlayerId| { - db_call(pool, Q::FetchNotifications(*player)) + db_call(pool, Q::PlayerNotifications(*player)) }), ) .service( web::resource("/claims") .route(web::get().to_async(|pool, player: PlayerId| { - db_call(pool, Q::FetchPlayerClaims(*player)) + db_call(pool, Q::PlayerClaims(*player)) })) .route(web::post().to_async( |pool, (player, data): (PlayerId, IdList)| { @@ -146,14 +146,14 @@ fn configure_api(config: &mut web::ServiceConfig) { //.route(web::get().to_async(...)) .route(web::put().to_async( |pool, (player, data): (PlayerId, web::Json)| { - db_call(pool, Q::UpdateWealth(*player, *data)) + db_call(pool, Q::PlayerUpdateWealth(*player, *data)) }, )), ) .service( web::resource("/loot") .route(web::get().to_async(|pool, player: PlayerId| { - db_call(pool, Q::FetchLoot(*player)) + db_call(pool, Q::PlayerLoot(*player)) })) .route(web::put().to_async( move |pool, (player, data): (PlayerId, BuySellParams)| { @@ -184,25 +184,25 @@ fn configure_api(config: &mut web::ServiceConfig) { ) .route( "/claims", - web::get().to_async(|pool| db_call(pool, Q::FetchClaims)), + web::get().to_async(|pool| db_call(pool, Q::ClaimsList)), ) .service( web::resource("/shop") - .route(web::get().to_async(|pool| db_call(pool, Q::FetchShopInventory))) + .route(web::get().to_async(|pool| db_call(pool, Q::ShopList))) .route( web::post().to_async(|pool, items: web::Json| { - db_call(pool, Q::RefreshShopInventory(items.into_inner())) + db_call(pool, Q::RefreshShop(items.into_inner())) }), ), ) .service( web::resource("/items") .route( - web::get().to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)), + web::get().to_async(move |pool: AppPool| db_call(pool, Q::InventoryList)), ) .route(web::post().to_async( move |pool: AppPool, items: web::Json>| { - db_call(pool, Q::CheckItemList(items.into_inner())) + db_call(pool, Q::InventoryCheck(items.into_inner())) }, )), ), @@ -277,8 +277,8 @@ fn enter_session(id: Identity, pool: AppPool) -> impl Future api::ApiActions::FetchPlayer(id), - SessionKind::Admin => api::ApiActions::FetchPlayers, + SessionKind::Player(id) => api::ApiEndpoint::PlayerFetch(id), + SessionKind::Admin => api::ApiEndpoint::PlayerList, }, ) })