rust/lootalot
1
0
Fork 0
Code Issues 3 Pull Requests Releases Wiki Activity

fixes errors

Browse Source
This commit is contained in:
Arthur Gerbaud
2020-01-09 15:12:51 +01:00
parent f9cd09431d
commit d152a999c9
5 changed files with 128 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
lootalot_db/src/lib.rs
View File

@@ -43,36 +43,36 @@ pub fn create_pool() -> Pool {
} }
/// Every possible update which can happen during a query /// Every possible update which can happen during a query
/// Updates are relative to a Player
#[derive(Serialize, Deserialize, Debug)] #[derive(Serialize, Deserialize, Debug)]
pub enum Update { pub enum Update {
Wealth(Wealth), Wealth(Wealth),
ItemAdded(Item), ItemAdded(Item),
ItemRemoved(Item), ItemRemoved(Item),
ItemBought(Item),
ItemSold(Item),
ClaimAdded(Claim), ClaimAdded(Claim),
ClaimRemoved(Claim), ClaimRemoved(Claim),
} }
impl Update { impl Update {
/// Change back what has been updated /// Change back what has been updated
fn undo(&self, conn: &DbConnection, id: i32) -> UpdateResult { fn undo(&self, conn: &DbConnection, id: i32) -> QueryResult<()> {
Ok(match self { match self {
Update::Wealth(diff) => AsPlayer(conn, id).update_wealth(-diff.to_gp())?, Update::Wealth(diff) => { AsPlayer(conn, id).update_wealth(-diff.to_gp())?; },
Update::ItemAdded(item) => LootManager(conn, id).find(item.id)?.remove(conn)?, Update::ItemAdded(item) => { diesel::delete(crate::schema::loot::table.find(item.id))
Update::ItemRemoved(item) => LootManager(conn, id).add_from(&item)?, .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 // Unused for now
Update::ClaimAdded(claim) => vec!(Update::ClaimRemoved(*claim)), Update::ClaimAdded(claim) => {},
Update::ClaimRemoved(claim) => vec!(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<Update>),
}
/// Every value which can be queried /// Every value which can be queried
#[derive(Debug)] #[derive(Debug)]
pub enum Value { pub enum Value {
@@ -166,231 +166,3 @@ pub fn split_and_share(
Ok(vec!(Update::Wealth(Wealth::from_gp(shared_total)))) 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);
}
}
}

14
lootalot_db/src/models/history.rs
View File

@@ -39,18 +39,14 @@ impl Event {
/// TODO: why a move here ?? /// TODO: why a move here ??
/// Undo all updates in a single transaction /// Undo all updates in a single transaction
pub fn undo(self, conn: &DbConnection) -> QueryResult<UpdateList> { pub fn undo(self, conn: &DbConnection) -> QueryResult<()> {
conn.transaction(move || { conn.transaction(move || {
if let Some(ref updates) = self.updates { if let Some(ref updates) = self.updates {
let undone = updates.0.iter() for update in updates.inner() {
// TODO: swallow errors ! update.undo(conn, self.player_id)?;
.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![]))
} }
Ok(())
}) })
} }
} }

104
lootalot_db/src/models/item.rs
View File

@@ -3,7 +3,7 @@ use diesel::expression::exists::Exists;
use diesel::prelude::*; use diesel::prelude::*;
use crate::schema::{items, loot}; 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); type ItemColumns = (loot::id, loot::name, loot::base_price);
const ITEM_COLUMNS: ItemColumns = (loot::id, loot::name, loot::base_price); const ITEM_COLUMNS: ItemColumns = (loot::id, loot::name, loot::base_price);
type OwnedBy = Select<OwnedLoot, ItemColumns>; type OwnedBy = Select<OwnedLoot, ItemColumns>;
@@ -33,9 +33,9 @@ impl Item {
} }
// Owner status // Owner status
const OF_GROUP: i32 = 0; pub(crate) const OF_GROUP: i32 = 0;
const OF_SHOP: i32 = -1; pub(crate) const OF_SHOP: i32 = -1;
const SOLD: i32 = -2; pub(crate) const SOLD: i32 = -2;
type WithOwner = Eq<loot::owner_id, i32>; type WithOwner = Eq<loot::owner_id, i32>;
type OwnedLoot = Filter<loot::table, WithOwner>; type OwnedLoot = Filter<loot::table, WithOwner>;
@@ -46,24 +46,19 @@ type OwnedLoot = Filter<loot::table, WithOwner>;
/// OR the SOLD state. /// OR the SOLD state.
#[derive(Identifiable, Debug, Queryable)] #[derive(Identifiable, Debug, Queryable)]
#[table_name = "loot"] #[table_name = "loot"]
pub(super) struct Loot { pub(crate) struct Loot {
id: i32, id: i32,
name: String, name: String,
base_price: i32, base_price: i32,
owner_id: i32, owner_id: i32,
} }
impl Loot { impl Loot {
/// A filter on Loot that is owned by given player /// A filter on Loot that is owned by given player
pub(super) fn owned_by(id: i32) -> OwnedLoot { pub(super) fn owned_by(id: i32) -> OwnedLoot {
loot::table.filter(loot::owner_id.eq(id)) loot::table.filter(loot::owner_id.eq(id))
} }
fn exists(id: i32) -> Exists<Find<loot::table, i32>> {
exists(loot::table.find(id))
}
pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> { pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> {
diesel::update(loot::table.find(self.id)) diesel::update(loot::table.find(self.id))
.set(loot::dsl::owner_id.eq(owner)) .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<Item> { pub fn find_by_name(&self, item_name: &str) -> QueryResult<Item> {
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 /// Check the inventory against a list of item names
@@ -139,53 +136,48 @@ impl<'q> Shop<'q> {
self.0.transaction(|| { self.0.transaction(|| {
let mut updates = AsPlayer(self.0, buyer).update_wealth(-sell_price)?; let mut updates = AsPlayer(self.0, buyer).update_wealth(-sell_price)?;
item.set_owner(buyer, self.0)?; item.set_owner(buyer, self.0)?;
updates.push(Update::ItemAdded(item.into_item())); updates.push(Update::ItemBought(item.into_item()));
Ok(updates) Ok(updates)
}) })
} }
pub fn buy(&self, items: Vec<(i32, Option<f64>)>, buyer: i32) -> UpdateResult { pub fn buy(&self, items: Vec<(i32, Option<f64>)>, buyer: i32) -> UpdateResult {
// TODO: check that player has enough money ! // TODO: check that player has enough money !
let has_enough_gold = true; let has_enough_gold = true;
if has_enough_gold { if has_enough_gold {
let mut updates = Vec::new(); let mut updates = Vec::new();
for (item_id, price_mod) in items.into_iter() { for (item_id, price_mod) in items.into_iter() {
updates.append( updates.append(&mut self.buy_single(buyer, item_id, price_mod)?)
&mut self.buy_single(buyer, item_id, price_mod)?
)
}
Ok(updates)
} else {
unimplemented!();
} }
Ok(updates)
} else {
unimplemented!();
}
} }
fn get(&self, id: i32) -> QueryResult<Loot> { pub(crate) fn get(&self, id: i32) -> QueryResult<Loot> {
Loot::owned_by(OF_SHOP).find(&id).first::<Loot>(self.0) Loot::owned_by(OF_SHOP).find(&id).first::<Loot>(self.0)
} }
pub fn replace_list(&self, items: Vec<Item>) -> QueryResult<()> { pub fn replace_list(&self, items: Vec<Item>) -> QueryResult<()> {
use self::loot::dsl::*; use self::loot::dsl::*;
self.0.transaction( self.0.transaction(|| -> QueryResult<()> {
|| -> QueryResult<()> // Remove all content
{ diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?;
// Remove all content // Adds new list
diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?; for item in &items {
// Adds new list let new_item = NewLoot {
for item in &items { name: &item.name,
let new_item = NewLoot { base_price: item.base_price,
name: &item.name, owner_id: OF_SHOP,
base_price: item.base_price, };
owner_id: OF_SHOP, diesel::insert_into(loot)
}; .values(&new_item)
diesel::insert_into(loot) .execute(self.0)?;
.values(&new_item)
.execute(self.0)?;
}
Ok(())
} }
) Ok(())
})
} }
} }
@@ -198,10 +190,14 @@ impl<'q> LootManager<'q> {
Ok(Item::owned_by(self.1).load(self.0)?) Ok(Item::owned_by(self.1).load(self.0)?)
} }
fn get(&self, item_id: i32) -> QueryResult<Loot> { pub(crate) fn get(&self, item_id: i32) -> QueryResult<Loot> {
Ok(Loot::owned_by(self.1).find(item_id).first(self.0)?) 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 /// Finds an item by id
/// ///
/// Returns a NotFound error if an item is found by it /// Returns a NotFound error if an item is found by it
@@ -217,27 +213,23 @@ impl<'q> LootManager<'q> {
sell_value *= modifier; sell_value *= modifier;
} }
self.0.transaction(|| { self.0.transaction(|| {
let mut updates = let mut updates = crate::AsPlayer(self.0, self.1).update_wealth(sell_value)?;
crate::AsPlayer(self.0, self.1)
.update_wealth(sell_value)?;
to_sell.set_owner(SOLD, self.0)?; 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) Ok(updates)
}) })
} }
pub fn sell(&self, items: Vec<(i32, Option<f64>)>) -> UpdateResult { pub fn sell(&self, items: Vec<(i32, Option<f64>)>) -> UpdateResult {
self.0.transaction(|| { self.0.transaction(|| {
let mut updates = Vec::new(); let mut updates = Vec::new();
for (loot_id, price_mod) in items.into_iter() { for (loot_id, price_mod) in items.into_iter() {
updates.append(&mut self.sell_single(loot_id, price_mod)?); updates.append(&mut self.sell_single(loot_id, price_mod)?);
} }
Ok(updates) Ok(updates)
}) })
} }
/// The last item added to the chest /// The last item added to the chest
pub fn last(&self) -> QueryResult<Item> { pub fn last(&self) -> QueryResult<Item> {
Ok(Item::owned_by(self.1) Ok(Item::owned_by(self.1)
@@ -263,7 +255,7 @@ impl<'q> LootManager<'q> {
diesel::insert_into(loot::table) diesel::insert_into(loot::table)
.values(&new_item) .values(&new_item)
.execute(self.0)?; .execute(self.0)?;
Ok(vec!(Update::ItemAdded(self.last()?))) Ok(vec![Update::ItemAdded(self.last()?)])
} }
} }

102
src/api.rs
View File

@@ -40,7 +40,7 @@ pub struct ApiResponse {
} }
impl ApiResponse { impl ApiResponse {
fn push_updates(&mut self, updates: Vec<db::Update>) { fn push_updates(&mut self, mut updates: Vec<db::Update>) {
if let Some(v) = self.updates.as_mut() { if let Some(v) = self.updates.as_mut() {
v.append(&mut updates); v.append(&mut updates);
} else { } else {
@@ -48,6 +48,10 @@ impl ApiResponse {
} }
} }
fn push_update(&mut self, update: db::Update) {
self.push_updates(vec!(update))
}
fn push_error<S: Into<String>>(&mut self, error: S) { fn push_error<S: Into<String>>(&mut self, error: S) {
if let Some(errors) = self.errors.as_mut() { if let Some(errors) = self.errors.as_mut() {
*errors = format!("{}\n{}", errors, error.into()); *errors = format!("{}\n{}", errors, error.into());
@@ -70,35 +74,7 @@ pub enum ApiError {
InvalidAction(String), InvalidAction(String),
} }
/// Every allowed queries on the database pub enum ApiEndpoint {
pub enum ApiActions {
// Application level
FetchPlayers,
FetchInventory,
FetchShopInventory,
FetchClaims,
CheckItemList(Vec<String>),
// 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 {
InventoryList, InventoryList,
InventoryCheck(Vec<String>), InventoryCheck(Vec<String>),
InventoryAdd(String, i32), // db::Inventory(conn)::add(new_item) InventoryAdd(String, i32), // db::Inventory(conn)::add(new_item)
@@ -124,65 +100,69 @@ pub enum ApiEndpoints {
ResolveClaims, // db::Group(conn)::resolve_claims() ResolveClaims, // db::Group(conn)::resolve_claims()
} }
static ErrorMsg : &str = "Une erreur est survenue"; static ERROR_MSG : &str = "Une erreur est survenue";
pub fn execute( pub fn execute(
conn: &DbConnection, conn: &DbConnection,
query: ApiEndpoints, query: ApiEndpoint,
) -> Result<ApiResponse, diesel::result::Error> { ) -> Result<ApiResponse, diesel::result::Error> {
let mut response = ApiResponse::default(); let mut response = ApiResponse::default();
// Return an Option<String> that describes what happened. // Return an Option<String> that describes what happened.
// If there is some value, store the actions in db so that it can be reversed. // If there is some value, store the actions in db so that it can be reversed.
let action_text: Option<(i32, &str)> = match query { let action_text: Option<(i32, &str)> = match query {
// Inventory // Inventory
ApiEndpoints::FetchInventory => { ApiEndpoint::InventoryList => {
match db::Inventory(conn).all() { match db::Inventory(conn).all() {
Ok(items) => response.set_value(Value::ItemList(items)), Ok(items) => response.set_value(Value::ItemList(items)),
Err(_) => response.set_error(ErrorMsg), Err(_) => response.push_error(ERROR_MSG),
} }
None None
} }
ApiEnpoints::InventoryCheck(names) => { ApiEndpoint::InventoryCheck(names) => {
match db::Inventory(conn).check_list(names) { match db::Inventory(conn).check_list(names) {
Ok((items, errors)) => { Ok((items, errors)) => {
response.set_value(Value::ItemList(items)); response.set_value(Value::ItemList(items));
response.push_error(errors); response.push_error(errors);
} }
Err(_) => response.set_error(ErrorMsg), Err(_) => response.push_error(ERROR_MSG),
} }
None None
} }
ApiEndpoints::InventoryAdd((name, value)) => { ApiEndpoint::InventoryAdd(name, value) => {
response.set_error("Not implemented"); response.push_error("Not implemented");
None None
} }
//Shop //Shop
ApiEnpoints::ShopList => { ApiEndpoint::ShopList => {
match db::Shop(conn).all() { match db::Shop(conn).all() {
Ok(items) => response.set_value(Value::ItemList(items)), Ok(items) => response.set_value(Value::ItemList(items)),
Err(_) => response.set_error(ErrorMsg), Err(_) => response.push_error(ERROR_MSG),
} }
None None
} }
ApiEndpoints::BuyItems(buyer, params) => { ApiEndpoint::BuyItems(buyer, params) => {
match db::Shop(conn).buy(params, buyer) { match db::Shop(conn).buy(params.items, buyer) {
Ok(updates) => { Ok(updates) => {
response.notifiy("Objets achetés !"); response.notify("Objets achetés !");
response.push_updates(updates); response.push_updates(updates);
Some((id, "Achat d'objets")) Some((buyer, "Achat d'objets"))
}, },
Err(_) => { Err(_) => {
response.set_error(ErrorMsg); response.push_error(ERROR_MSG);
None None
} }
} }
} }
// Players // Players
ApiEndpoints::PlayerList => { ApiEndpoint::PlayerList => {
response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?)); response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?));
None 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()?)); response.set_value(Value::ClaimList(db::Claims(conn).all()?));
None None
} }
@@ -209,16 +189,20 @@ pub fn execute(
// Group sells item like players then split the total amount among players. // Group sells item like players then split the total amount among players.
ApiEndpoint::SellItems(id, params) => { ApiEndpoint::SellItems(id, params) => {
conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> { conn.transaction(|| -> Result<Option<(i32, &str)>, 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 { match id {
0 => { 0 => {
let players = params.players.unwrap_or_default(); let players = params.players.unwrap_or_default();
updates.push( updates.append(
db::split_and_share(conn, total_amount.to_gp() as i32, players)? &mut db::split_and_share(conn, total_amount, players)?
); );
response.notify("Les objets ont été vendus"); response.notify("Les objets ont été vendus");
response.push_updates(updates); response.push_updates(updates);
};
} }
_ => { _ => {
response.notify("Objets vendus !"); response.notify("Objets vendus !");
@@ -239,11 +223,11 @@ pub fn execute(
let new_claims: HashSet<i32> = items.into_iter().collect(); let new_claims: HashSet<i32> = items.into_iter().collect();
// Claims to delete // Claims to delete
for item in current_claims.difference(&new_claims) { 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 // Claims to add
for item in new_claims.difference(&current_claims) { for item in new_claims.difference(&current_claims) {
response.push_update(db::Claims(conn).add(id, *item)?); response.push_updates(db::Claims(conn).add(id, *item)?);
} }
Ok(None) Ok(None)
})? })?
@@ -251,9 +235,7 @@ pub fn execute(
ApiEndpoint::UndoLastAction(id) => { ApiEndpoint::UndoLastAction(id) => {
if let Ok(event) = db::models::history::get_last_of_player(conn, id) { if let Ok(event) = db::models::history::get_last_of_player(conn, id) {
let name = String::from(event.name()); let name = String::from(event.name());
for undone in event.undo(conn)?.into_inner().into_iter() { event.undo(conn)?;
response.push_update(undone);
}
response.notify(format!("'{}' annulé(e)", name)); response.notify(format!("'{}' annulé(e)", name));
} else { } else {
response.push_error("Aucune action trouvée") response.push_error("Aucune action trouvée")
@@ -265,7 +247,7 @@ pub fn execute(
let mut added_items = 0; let mut added_items = 0;
for item in data.items.into_iter() { for item in data.items.into_iter() {
if let Ok(added) = db::LootManager(conn, 0).add_from(&item) { if let Ok(added) = db::LootManager(conn, 0).add_from(&item) {
response.push_update(added); response.push_updates(added);
added_items += 1; added_items += 1;
} else { } else {
response.push_error(format!("Error adding {:?}", item)); response.push_error(format!("Error adding {:?}", item));
@@ -280,17 +262,17 @@ pub fn execute(
}; };
Some((0, "Nouveau loot")) Some((0, "Nouveau loot"))
} }
ApiEndpoints::ResolveClaims => { ApiEndpoint::ResolveClaims => {
response.push_error("Not implemented!"); response.push_error("Not implemented!");
None None
} }
// Admin actions // Admin actions
ApiEndpoints::RefreshShop(items) => { ApiEndpoint::RefreshShop(items) => {
db::Shop(conn).replace_list(items)?; db::Shop(conn).replace_list(items)?;
response.notify("Inventaire du marchand renouvelé !"); response.notify("Inventaire du marchand renouvelé !");
None None
} }
ApiEnpoints::AddPlayer(data) => { ApiEndpoint::PlayerAdd(data) => {
db::Players(conn).add(&data.name, data.wealth)?; db::Players(conn).add(&data.name, data.wealth)?;
response.notify("Joueur ajouté !"); response.notify("Joueur ajouté !");
None None

36
src/server.rs
View File

@@ -30,7 +30,7 @@ type MaybeForbidden =
/// Wraps call to the database query and convert its result as a async HttpResponse /// Wraps call to the database query and convert its result as a async HttpResponse
fn db_call( fn db_call(
pool: AppPool, pool: AppPool,
query: api::ApiActions, query: api::ApiEndpoint,
) -> impl Future<Item = HttpResponse, Error = Error> { ) -> impl Future<Item = HttpResponse, Error = Error> {
let conn = pool.get().unwrap(); let conn = pool.get().unwrap();
web::block(move || api::execute(&conn, query)).then(|res| match res { 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 { if id != 0 {
actix_web::Either::B(HttpResponse::Forbidden().finish()) actix_web::Either::B(HttpResponse::Forbidden().finish())
} else { } else {
@@ -101,7 +101,7 @@ where
} }
fn configure_api(config: &mut web::ServiceConfig) { fn configure_api(config: &mut web::ServiceConfig) {
use api::ApiActions as Q; use api::ApiEndpoint as Q;
config.service( config.service(
web::scope("/api") web::scope("/api")
.wrap(RestrictedAccess) .wrap(RestrictedAccess)
@@ -109,31 +109,31 @@ fn configure_api(config: &mut web::ServiceConfig) {
web::scope("/players") web::scope("/players")
.service( .service(
web::resource("/") 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( .route(web::post().to_async(
|pool, player: web::Json<api::NewPlayer>| { |pool, player: web::Json<api::NewPlayer>| {
db_call(pool, Q::AddPlayer(player.into_inner())) db_call(pool, Q::PlayerAdd(player.into_inner()))
}, },
)), )),
) // List of players ) // List of players
.service( .service(
web::scope("/{player_id}") web::scope("/{player_id}")
.route( /*.route(
"/", "/",
web::get().to_async(|pool, player: PlayerId| { web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchPlayer(*player)) db_call(pool, Q::FetchPlayer(*player))
}), }),
) )*/
.route( .route(
"/notifications", "/notifications",
web::get().to_async(|pool, player: PlayerId| { web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchNotifications(*player)) db_call(pool, Q::PlayerNotifications(*player))
}), }),
) )
.service( .service(
web::resource("/claims") web::resource("/claims")
.route(web::get().to_async(|pool, player: PlayerId| { .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( .route(web::post().to_async(
|pool, (player, data): (PlayerId, IdList)| { |pool, (player, data): (PlayerId, IdList)| {
@@ -146,14 +146,14 @@ fn configure_api(config: &mut web::ServiceConfig) {
//.route(web::get().to_async(...)) //.route(web::get().to_async(...))
.route(web::put().to_async( .route(web::put().to_async(
|pool, (player, data): (PlayerId, web::Json<f64>)| { |pool, (player, data): (PlayerId, web::Json<f64>)| {
db_call(pool, Q::UpdateWealth(*player, *data)) db_call(pool, Q::PlayerUpdateWealth(*player, *data))
}, },
)), )),
) )
.service( .service(
web::resource("/loot") web::resource("/loot")
.route(web::get().to_async(|pool, player: PlayerId| { .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( .route(web::put().to_async(
move |pool, (player, data): (PlayerId, BuySellParams)| { move |pool, (player, data): (PlayerId, BuySellParams)| {
@@ -184,25 +184,25 @@ fn configure_api(config: &mut web::ServiceConfig) {
) )
.route( .route(
"/claims", "/claims",
web::get().to_async(|pool| db_call(pool, Q::FetchClaims)), web::get().to_async(|pool| db_call(pool, Q::ClaimsList)),
) )
.service( .service(
web::resource("/shop") 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( .route(
web::post().to_async(|pool, items: web::Json<api::ItemList>| { web::post().to_async(|pool, items: web::Json<api::ItemList>| {
db_call(pool, Q::RefreshShopInventory(items.into_inner())) db_call(pool, Q::RefreshShop(items.into_inner()))
}), }),
), ),
) )
.service( .service(
web::resource("/items") web::resource("/items")
.route( .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( .route(web::post().to_async(
move |pool: AppPool, items: web::Json<Vec<String>>| { move |pool: AppPool, items: web::Json<Vec<String>>| {
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<Item = HttpResponse
api::execute( api::execute(
&conn, &conn,
match logged { match logged {
SessionKind::Player(id) => api::ApiActions::FetchPlayer(id), SessionKind::Player(id) => api::ApiEndpoint::PlayerFetch(id),
SessionKind::Admin => api::ApiActions::FetchPlayers, SessionKind::Admin => api::ApiEndpoint::PlayerList,
}, },
) )
}) })