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
/// 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<Update>),
}
/// 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);
}
}
}

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

@@ -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<UpdateList> {
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(())
})
}
}

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

@@ -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<OwnedLoot, ItemColumns>;
@@ -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<loot::owner_id, i32>;
type OwnedLoot = Filter<loot::table, WithOwner>;
@@ -46,24 +46,19 @@ type OwnedLoot = Filter<loot::table, WithOwner>;
/// 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<Find<loot::table, i32>> {
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<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
@@ -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<f64>)>, 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<Loot> {
pub(crate) fn get(&self, id: i32) -> QueryResult<Loot> {
Loot::owned_by(OF_SHOP).find(&id).first::<Loot>(self.0)
}
pub fn replace_list(&self, items: Vec<Item>) -> 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<Loot> {
pub(crate) fn get(&self, item_id: i32) -> QueryResult<Loot> {
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<f64>)>) -> 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<Item> {
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()?)])
}
}

102
src/api.rs
View File

@@ -40,7 +40,7 @@ pub struct 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() {
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<S: Into<String>>(&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<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 {
pub enum ApiEndpoint {
InventoryList,
InventoryCheck(Vec<String>),
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<ApiResponse, diesel::result::Error> {
let mut response = ApiResponse::default();
// Return an Option<String> 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<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 {
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<i32> = 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(&current_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

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
fn db_call(
pool: AppPool,
query: api::ApiActions,
query: api::ApiEndpoint,
) -> impl Future<Item = HttpResponse, Error = Error> {
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<api::NewPlayer>| {
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<f64>)| {
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<api::ItemList>| {
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<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(
&conn,
match logged {
SessionKind::Player(id) => api::ApiActions::FetchPlayer(id),
SessionKind::Admin => api::ApiActions::FetchPlayers,
SessionKind::Player(id) => api::ApiEndpoint::PlayerFetch(id),
SessionKind::Admin => api::ApiEndpoint::PlayerList,
},
)
})