this looks this overdoing it... going back to master

.gitignore

@@ -1,10 +1,11 @@
 /target
 **/*.rs.bk
 
+node_modules
+fontawesome
+package-lock.json
+
 Cargo.lock
 **/*.sqlite3
 **/.env
 
-package-lock.json
-fontawesome
-

Cargo.toml

@@ -7,15 +7,12 @@ edition = "2018"
 [dependencies]
 actix-web = "1.0.*"
 actix-files = "*"
-actix-service = "*"
-actix-identity = "*"
 lootalot-db = { version = "0.1", path = "./lootalot_db" }
 dotenv = "*"
 env_logger = "*"
 futures = "0.1"
 diesel = "*"
 serde = "*"
-serde_json = "*"
 actix-cors = "0.1.0"
 
 [workspace]

README.md

@@ -6,21 +6,47 @@ Un gestionnaire de trésors pour des joueurs de Donjon&Dragons(tm).
 
 ## Fonctionnalités prévues
 
-  * Ajouter des objets  
+  * Ajouter des objets "lootés"
-    ☑ Acheter  
+  * Répartir les objets entre les joueurs et le groupe
-    ☐ Ajouter un trésor (objet par objet ou par liste)  
+  * Vendre les objets du groupe et répartir équitablement leur valeur entre les joueurs
-  * Répartir les objets entre les joueurs et le groupe  
+    * Possibilité d'indiquer une variation du prix de vente pour chaque objet ou globale
-    ☑ Demander un objet  
+  * Gérer les comptes du groupe et des joueurs
-    ☐ Résoudre un conflit  
+  * Historique des transactions par propriétaire
-    ☐ Finaliser la répartition après un délai défini  
-  * Vendre les objets du groupe et répartir équitablement leur valeur entre les joueurs  
-    ☑ Possibilité d'indiquer une variation du prix de vente globale et/ou pour chaque objet  
-    ☐ Possibilité d'indiquer des joueurs exclus de la répartition  
-  * Gérer les comptes du groupe et des joueurs  
-    ☑ Afficher le solde actuel et la dette envers le groupe  
-    ☑ Mettre à jour facilement  
-  * Historique  
-    ☐ Annuler une action  
-    ☐ Consulter l'historique des objets 'looté' par le groupe  
 
 
+## Base de données
+
+### Objets (items)
+
+L'inventaire des objets qui peuvent être lootés.  
+PK: id
+
+### Objets lootés (looted)
+
+Les objets actuellement looté.
+Même schéma que `items` plus une colonne supplémentaire : `owner_id` -> players(id)
+
+### Joueurs (players)
+
+Le "groupe" est un propriétaire spécial, avec un ID réservé : 0
+
+La table conserve l'état actuel des finances du propriétaire. L'attribut `dette` représente la dette envers le groupe.
+
+```
+PK: id  
+ATTRS: name, debt (in gp), pp, sp, gp, cp  
+```
+### Requêtes (claims)
+
+Table associative entre objets lootés et joueurs.
+Représente les requêtes des joueurs. La colonne `resolve` permettra d'établir un classement de détermination entre les joueurs.
+```
+PK: id  
+FK: loot_id, player_id  
+ATTRS: resolve  
+```
+
+### Opérations
+
+_Doit-on garder un historique des opérations ?_
+

lootalot_db/Cargo.toml

@@ -9,7 +9,6 @@ dotenv = "*"
 diesel_migrations = "*"
 serde = "*"
 serde_derive = "*"
-serde_json = "*"
 
 [dependencies.diesel]
 version = "1.4"

lootalot_db/migrations/2019-06-10-123922_create_items/down.sql

@@ -1,3 +1,3 @@
 DROP TABLE items;
 DROP TABLE looted;
-DROP TABLE shop;
+

lootalot_db/migrations/2019-06-10-123922_create_items/up.sql

@@ -13,10 +13,3 @@ CREATE TABLE looted (
   owner_id INTEGER NOT NULL,
   FOREIGN KEY (owner_id) REFERENCES players(id)
 );
-
--- The items that are available in shop
-CREATE TABLE shop (
-  id INTEGER PRIMARY KEY NOT NULL,
-  name VARCHAR NOT NULL,
-  base_price INTEGER NOT NULL
-);

lootalot_db/migrations/2019-10-19-194459_notifications/down.sql

@@ -1 +0,0 @@
-DROP TABLE notifications;

lootalot_db/migrations/2019-10-19-194459_notifications/up.sql

@@ -1,6 +0,0 @@
-CREATE TABLE notifications (
-    id INTEGER PRIMARY KEY NOT NULL,
-    player_id INTEGER NOT NULL,
-    text VARCHAR NOT NULL,
-    FOREIGN KEY (player_id) REFERENCES players(id)
-);

lootalot_db/migrations/2019-10-27-135235_history/down.sql

@@ -1 +0,0 @@
-DROP TABLE history;

lootalot_db/migrations/2019-10-27-135235_history/up.sql

@@ -1,8 +0,0 @@
-CREATE TABLE history (
-       id INTEGER PRIMARY KEY NOT NULL,
-       player_id INTEGER NOT NULL,
-       event_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-       text VARCHAR NOT NULL,
-       updates VARCHAR,
-       FOREIGN KEY (player_id) REFERENCES players(id)
-);

lootalot_db/src/lib.rs

@@ -13,15 +13,10 @@ use diesel::prelude::*;
 use diesel::query_dsl::RunQueryDsl;
 use diesel::r2d2::{self, ConnectionManager};
 
+mod transactions;
 pub mod models;
 mod schema;
-
+use transactions::{DbTransaction};
-pub use models::{
-    claim::{Claim, Claims},
-    history::{Event, UpdateList},
-    item::{Inventory, Shop, Item, LootManager},
-    player::{AsPlayer, Player, Players, Wealth},
-};
 
 /// The connection used
 pub type DbConnection = SqliteConnection;
@@ -29,7 +24,271 @@ pub type DbConnection = SqliteConnection;
 pub type Pool = r2d2::Pool<ConnectionManager<DbConnection>>;
 /// The result of a query on DB
 pub type QueryResult<T> = Result<T, diesel::result::Error>;
-pub type UpdateResult = QueryResult<Update>;
+pub type ActionResult<T> = QueryResult<ActionStatus<T>>;
+/// Return status of an Action
+#[derive(Serialize, Debug)]
+pub struct ActionStatus<R: serde::Serialize> {
+    /// Has the action made changes ?
+    pub executed: bool,
+    /// Response payload
+    pub response: R,
+}
+
+impl ActionStatus<()> {
+    pub fn was_updated(updated_lines: usize) -> Self {
+        match updated_lines {
+            1 => Self::ok(),
+            _ => Self::nop(),
+        }
+    }
+    pub fn ok() -> ActionStatus<()> {
+        Self {
+            executed: true,
+            response: (),
+        }
+    }
+}
+
+impl<T: Default + serde::Serialize> ActionStatus<T> {
+    pub fn nop() -> ActionStatus<T> {
+        Self {
+            executed: false,
+            response: Default::default(),
+        }
+    }
+}
+/// A wrapper providing an API over the database
+/// It offers a convenient way to deal with connection.
+///
+/// # Note
+/// All methods consumes the DbApi, so that only one action
+/// can be performed using a single instance.
+///
+/// # Todo list
+/// ```text
+///  v  .as_player()
+///          // Needs an action's history (one entry only should be enough)
+///  x       .undo_last_action() -> Success status
+///  v  .as_admin()
+///          // When adding loot, an identifier should be used to build some kind of history
+///  vx      .add_loot(identifier, [items_desc]) -> Success status
+///  x       .sell_loot([players], [excluded_item_ids]) -> Success status (bool, player_share)
+///  // Claims should be resolved after a certain delay
+///  x       .set_claims_timeout()
+///  x       .resolve_claims()
+///  v       .add_player(player_data)
+/// ```
+///
+pub struct DbApi<'q>(&'q DbConnection);
+
+impl<'q> DbApi<'q> {
+    /// Returns a DbApi using the user given connection
+    ///
+    /// # Usage
+    /// ```
+    /// use lootalot_db::{DbConnection, DbApi};
+    /// # use diesel::connection::Connection;
+    /// let conn = DbConnection::establish(":memory:").unwrap();
+    /// let api = DbApi::with_conn(&conn);
+    /// ```
+    pub fn with_conn(conn: &'q DbConnection) -> Self {
+        Self(conn)
+    }
+    /// Fetch the list of all players
+    pub fn fetch_players(self) -> QueryResult<Vec<models::Player>> {
+        Ok(schema::players::table.load::<models::Player>(self.0)?)
+    }
+    /// Fetch the inventory of items
+    pub fn fetch_inventory(self) -> QueryResult<Vec<models::Item>> {
+        Ok(schema::items::table.load::<models::Item>(self.0)?)
+    }
+    /// Fetch all existing claims
+    pub fn fetch_claims(self) -> QueryResult<Vec<models::Claim>> {
+        Ok(schema::claims::table.load::<models::Claim>(self.0)?)
+    }
+    /// Wrapper for acting as a specific player
+    ///
+    /// # Usage
+    /// ```
+    /// # use lootalot_db::{DbConnection, DbApi};
+    /// # use diesel::connection::Connection;
+    /// # let conn = DbConnection::establish(":memory:").unwrap();
+    /// # let api = DbApi::with_conn(&conn);
+    /// let player_id: i32 = 1; // Id that references player in DB
+    /// let player = api.as_player(player_id);
+    /// ```
+    pub fn as_player(self, id: i32) -> AsPlayer<'q> {
+        AsPlayer { id, conn: self.0 }
+    }
+
+    /// Wrapper for acting as the admin
+    pub fn as_admin(self) -> AsAdmin<'q> {
+        AsAdmin(self.0)
+    }
+}
+
+/// A wrapper for interactions of players with the database.
+/// Possible actions are exposed as methods
+pub struct AsPlayer<'q> {
+    id: i32,
+    conn: &'q DbConnection,
+}
+
+impl<'q> AsPlayer<'q> {
+    /// Fetch the content of a player's chest
+    ///
+    /// # Usage
+    /// ```
+    /// # extern crate diesel_migrations;
+    /// # use lootalot_db::{DbConnection, DbApi};
+    /// # use diesel::connection::Connection;
+    /// # let conn = DbConnection::establish(":memory:").unwrap();
+    /// # diesel_migrations::run_pending_migrations(&conn).unwrap();
+    /// # let api = DbApi::with_conn(&conn);
+    /// // Get loot of player with id of 1
+    /// let loot = api.as_player(1).loot().unwrap();
+    /// assert_eq!(format!("{:?}", loot), "[]".to_string());
+    /// ```
+    pub fn loot(self) -> QueryResult<Vec<models::Item>> {
+        Ok(models::Item::owned_by(self.id).load(self.conn)?)
+    }
+    /// Buy an item and add it to this player chest
+    ///
+    /// TODO: Items should be picked from a custom list
+    ///
+    /// # Panics
+    ///
+    /// This currently panics if player wealth fails to be updated, as this is
+    /// a serious error. TODO: handle deletion of bought item in case of wealth update failure.
+    pub fn buy<S: Into<String>>(self, name: S, price: i32) -> ActionResult<Option<(i32, i32, i32, i32)>> {
+        match transactions::player::Buy.execute(
+            self.conn,
+            transactions::player::AddLootParams {
+                player_id: self.id,
+                loot_name: name.into(),
+                loot_price: price,
+            },
+        ) {
+            Ok(res) => Ok(ActionStatus { executed: true, response: Some(res.loot_cost) }),
+            Err(e) => { dbg!(&e); Ok(ActionStatus { executed: false, response: None}) },
+        }
+    }
+    /// Sell an item from this player chest
+    ///
+    /// # Panics
+    ///
+    /// This currently panics if player wealth fails to be updated, as this is
+    /// a serious error. TODO: handle restoring of sold item in case of wealth update failure.
+    pub fn sell(
+        self,
+        loot_id: i32,
+        _price_mod: Option<f32>,
+    ) -> ActionResult<Option<(i32, i32, i32, i32)>> {
+        // Check that the item belongs to player
+        let exists_and_owned: bool =
+            diesel::select(models::Loot::owns(self.id, loot_id))
+                .get_result(self.conn)?;
+        if !exists_and_owned {
+            return Ok(ActionStatus::nop());
+        }
+        transactions::player::Sell.execute(
+            self.conn,
+            transactions::player::LootParams {
+                player_id: self.id,
+                loot_id,
+            },
+        )
+            .map(|res| ActionStatus { executed: true, response: Some(res.loot_cost) })
+            .or_else(|e| { dbg!(&e); Ok(ActionStatus::nop()) })
+    }
+
+    /// Adds the value in gold to the player's wealth.
+    ///
+    /// Value can be negative to substract wealth.
+    pub fn update_wealth(self, value_in_gp: f32) -> ActionResult<Option<(i32, i32, i32, i32)>> {
+        transactions::player::UpdateWealth.execute(
+            self.conn,
+            transactions::player::WealthParams {
+                player_id: self.id,
+                value_in_gp,
+            },
+        )
+        .map(|res| ActionStatus { executed: true, response: Some(res) })
+        .or_else(|e| { dbg!(&e); Ok(ActionStatus::nop())})
+    }
+    /// Put a claim on a specific item
+    pub fn claim(self, item: i32) -> ActionResult<()> {
+        let exists: bool =
+            diesel::select(models::Loot::exists(item)).get_result(self.conn)?;
+        if !exists {
+            return Ok(ActionStatus::nop());
+        };
+        transactions::player::PutClaim.execute(
+            self.conn,
+            transactions::player::LootParams {
+                player_id: self.id,
+                loot_id: item,
+            },
+        )
+        .map(|_| ActionStatus { executed: true, response: () })
+        .or_else(|e| { dbg!(&e); Ok(ActionStatus::nop())})
+    }
+    /// Withdraw claim
+    pub fn unclaim(self, item: i32) -> ActionResult<()> {
+        transactions::player::WithdrawClaim.execute(
+            self.conn,
+            transactions::player::LootParams {
+                player_id: self.id,
+                loot_id: item,
+            },
+        )
+        .map(|_| ActionStatus { executed: true, response: () })
+        .or_else(|e| { dbg!(&e); Ok(ActionStatus::nop())})
+    }
+}
+
+/// Wrapper for interactions of admins with the DB.
+pub struct AsAdmin<'q>(&'q DbConnection);
+
+impl<'q> AsAdmin<'q> {
+    /// Adds a player to the database
+    ///
+    /// Takes the player name and starting wealth (in gold value).
+    pub fn add_player(self, name: String, start_wealth: f32) -> ActionResult<()> {
+        diesel::insert_into(schema::players::table)
+            .values(&models::player::NewPlayer::create(&name, start_wealth))
+            .execute(self.0)
+            .map(ActionStatus::was_updated)
+    }
+
+    /// Adds a list of items to the group loot
+    pub fn add_loot<'a>(self, items: Vec<(&'a str, i32)>) -> ActionResult<()> {
+        for item_desc in items.into_iter() {
+            let new_item = models::item::NewLoot::to_group(item_desc);
+            diesel::insert_into(schema::looted::table)
+                .values(&new_item)
+                .execute(self.0)?;
+        }
+        Ok(ActionStatus::ok())
+    }
+
+    /// Resolve all pending claims and dispatch claimed items.
+    ///
+    /// When a player gets an item, it's debt is increased by this item sell value
+    pub fn resolve_claims(self) -> ActionResult<()> {
+        // Fetch all claims, grouped by items.
+        let loot = models::Loot::owned_by(0).load(self.0)?;
+        let claims = schema::claims::table
+            .load::<models::Claim>(self.0)?
+            .grouped_by(&loot);
+        // For each claimed item
+        let data = loot.into_iter().zip(claims).collect::<Vec<_>>();
+        dbg!(data);
+        // If mutiples claims -> find highest resolve, give to this player
+        // If only one claim -> give to claiming
+        Ok(ActionStatus::nop())
+    }
+}
 
 /// Sets up a connection pool and returns it.
 /// Uses the DATABASE_URL environment variable (must be set)
@@ -42,209 +301,8 @@ pub fn create_pool() -> Pool {
         .expect("Failed to create pool.")
 }
 
-/// Every possible update which can happen during a query
+#[cfg(test)]
-#[derive(Serialize, Deserialize, Debug)]
+mod tests {
-pub enum Update {
-    Wealth(Wealth),
-    ItemAdded(Item),
-    ItemRemoved(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)?,
-            // Unused for now
-            Update::ClaimAdded(claim) => Update::ClaimRemoved(*claim),
-            Update::ClaimRemoved(claim) => Update::ClaimAdded(*claim),
-        })
-    }
-}
-
-/// 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 {
-    Player(Player),
-    Item(Item),
-    Claim(Claim),
-    ItemList(Vec<Item>),
-    ClaimList(Vec<Claim>),
-    PlayerList(Vec<Player>),
-    Notifications(Vec<String>),
-}
-
-impl serde::Serialize for Value {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        match self {
-            Value::Player(v) => v.serialize(serializer),
-            Value::Item(v) => v.serialize(serializer),
-            Value::Claim(v) => v.serialize(serializer),
-            Value::ItemList(v) => v.serialize(serializer),
-            Value::ClaimList(v) => v.serialize(serializer),
-            Value::PlayerList(v) => v.serialize(serializer),
-            Value::Notifications(v) => v.serialize(serializer),
-        }
-    }
-}
-
-/// Sells a single item inside a transaction
-///
-/// # Returns
-/// The deleted entity and the updated Wealth (as a difference from previous value)
-pub fn sell_item_transaction(
-    conn: &DbConnection,
-    id: i32,
-    loot_id: i32,
-    price_mod: Option<f64>,
-) -> QueryResult<(Update, Wealth)> {
-    conn.transaction(|| {
-        let to_delete = LootManager(conn, id).find(loot_id)?;
-        let mut sell_value = to_delete.sell_value() as f64;
-        if let Some(modifier) = price_mod {
-            sell_value *= modifier;
-        }
-        let deleted = to_delete.remove(conn)?;
-        if let Update::Wealth(wealth) = AsPlayer(conn, id).update_wealth(sell_value)? {
-            Ok((deleted, wealth))
-        } else {
-            Err(diesel::result::Error::RollbackTransaction)
-        }
-    })
-}
-
-/// Buys a single item, copied from inventory.
-/// Runs inside a transaction
-///
-/// # Returns
-/// The created entity and the updated Wealth (as a difference from previous value)
-pub fn buy_item_from_inventory(
-    conn: &DbConnection,
-    id: i32,
-    item_id: i32,
-    price_mod: Option<f64>,
-) -> QueryResult<(Update, Wealth)> {
-    conn.transaction(|| {
-        // Find item in inventory
-        let item = Inventory(conn).find(item_id)?;
-        let new_item = LootManager(conn, id).add_from(&item)?;
-        let sell_price = match price_mod {
-            Some(modifier) => item.value() * modifier,
-            None => item.value(),
-        };
-        if let Update::Wealth(diff) = AsPlayer(conn, id).update_wealth(-sell_price)? {
-            Ok((new_item, diff))
-        } else {
-            Err(diesel::result::Error::RollbackTransaction)
-        }
-    })
-}
-
-pub fn buy_item_from_shop(
-    conn: &DbConnection,
-    id: i32,
-    item_id: i32,
-    price_mod: Option<f64>,
-) -> QueryResult<(Update, Wealth)> {
-    conn.transaction(|| {
-        let shop = Shop(conn);
-        // Find item in inventory
-        let item = shop.get(item_id)?;
-        let new_item = LootManager(conn, id).add_from(&item)?;
-        let _deleted = shop.remove(item_id)?;
-        let sell_price = match price_mod {
-            Some(modifier) => item.value() * modifier,
-            None => item.value(),
-        };
-        if let Update::Wealth(diff) = AsPlayer(conn, id).update_wealth(-sell_price)? {
-            Ok((new_item, diff))
-        } else {
-            Err(diesel::result::Error::RollbackTransaction)
-        }
-    })
-}
-
-
-/// Resolve all pending claims and dispatch claimed items.
-///
-/// When a player gets an item, it's debt is increased by this item sell value
-pub fn resolve_claims(conn: &DbConnection) -> QueryResult<()> {
-    let data = models::claim::Claims(conn).grouped_by_item()?;
-    dbg!(&data);
-    conn.transaction(move || {
-        for (item, mut claims) in data {
-            if claims.len() > 1 {
-                // TODO: better sorting mechanism :)
-                claims.sort_by(|a, b| a.resolve.cmp(&b.resolve));
-            }
-            let winner = claims.get(0).expect("Claims should not be empty !");
-            let player_id = winner.player_id;
-            winner.resolve_claim(conn)?;
-            models::player::AsPlayer(conn, player_id).update_debt(item.sell_value() as i32)?;
-        }
-        Ok(())
-    })
-}
-
-/// Split up and share an certain amount of group money among selected players
-///
-/// The group first solve players debts,
-/// then give what's left.
-///
-/// # Returns
-///
-/// A Wealth update with the amount of money shared with players
-pub fn split_and_share(
-    conn: &DbConnection,
-    amount: i32,
-    players: Vec<i32>,
-) -> UpdateResult {
-    let players = match players.is_empty() {
-        true => Players(conn)
-            .all_except_group()?
-            .iter()
-            .map(|p| p.id)
-            .collect(),
-        false => players
-    };
-    let share = (
-        amount / (players.len() + 1) as i32
-        // +1 share for the group
-    ) as f64;
-    conn.transaction(|| {
-        let mut shared_total = 0.0;
-        for id in players {
-            let player = Players(conn).find(id)?;
-            // Take debt into account
-            match share - player.debt as f64 {
-                rest if rest > 0.0 => {
-                    AsPlayer(conn, id).update_debt(-player.debt)?;
-                    AsPlayer(conn, id).update_wealth(rest)?;
-                    AsPlayer(conn, 0).update_wealth(-rest)?;
-                    shared_total += rest;
-                }
-                _ => {
-                    AsPlayer(conn, id).update_debt(-share as i32)?;
-                }
-            }
-        }
-        Ok(Update::Wealth(Wealth::from_gp(shared_total)))
-    })
-}
-
-#[cfg(none)]
-mod tests_old {
     use super::*;
     type TestConnection = DbConnection;
 
@@ -258,7 +316,7 @@ mod tests_old {
     /// When migrations are run, a special player with id 0 and name "Groupe"
     /// must be created.
     #[test]
-    fn global_group_is_autocreated() {
+    fn test_group_is_autocreated() {
         let conn = test_connection();
         let players = DbApi::with_conn(&conn).fetch_players().unwrap();
         assert_eq!(players.len(), 1);
@@ -270,19 +328,20 @@ mod tests_old {
     /// 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() {
+    fn test_player_updates_wealth() {
         let conn = test_connection();
         DbApi::with_conn(&conn)
             .as_admin()
-            .add_player("PlayerName", 403.21)
+            .add_player("PlayerName".to_string(), 403.21)
             .unwrap();
         let diff = DbApi::with_conn(&conn)
             .as_player(1)
             .update_wealth(-401.21)
-            .ok();
+            .unwrap()
+            .response
+            .unwrap();
         // Check the returned diff
-        assert_eq!(diff, Some((-1, -2, -1, -4)));
+        assert_eq!(diff, (-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
@@ -293,12 +352,13 @@ mod tests_old {
     }
 
     #[test]
-    fn as_admin_add_player() {
+    fn test_admin_add_player() {
         let conn = test_connection();
         let result = DbApi::with_conn(&conn)
             .as_admin()
-            .add_player("PlayerName", 403.21);
+            .add_player("PlayerName".to_string(), 403.21)
-        assert_eq!(result.is_ok(), true);
+            .unwrap();
+        assert_eq!(result.executed, true);
         let players = DbApi::with_conn(&conn).fetch_players().unwrap();
         assert_eq!(players.len(), 2);
         let new_player = players.get(1).unwrap();
@@ -310,92 +370,56 @@ mod tests_old {
     }
 
     #[test]
-    fn as_admin_resolve_claims() {
+    fn test_admin_resolve_claims() {
         let conn = test_connection();
         let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
         assert_eq!(claims.len(), 0);
-
+        assert_eq!(true, false); // Failing as test is not complete
-        // 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() {
+    fn test_player_claim_item() {
         let conn = test_connection();
         DbApi::with_conn(&conn)
             .as_admin()
-            .add_player("Player", 0.0)
+            .add_player("Player".to_string(), 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);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
-        assert_eq!(result.is_ok(), true);
+        assert_eq!(result.executed, 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);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(2).unwrap();
-        assert_eq!(result.is_ok(), false);
+        assert_eq!(result.executed, false);
     }
 
     #[test]
-    fn as_player_unclaim_item() {
+    fn test_player_unclaim_item() {
         let conn = test_connection();
         DbApi::with_conn(&conn)
             .as_admin()
-            .add_player("Player", 0.0)
+            .add_player("Player".to_string(), 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);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
-        assert_eq!(result.is_ok(), true);
+        assert_eq!(result.executed, true);
-        // Claiming twice is an error
+        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1).unwrap();
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
+        assert_eq!(result.executed, true);
-        assert_eq!(result.is_ok(), false);
+        // Check that unclaimed items will not be unclaimed...
-        // Unclaiming and item
+        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1).unwrap();
-        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
+        assert_eq!(result.executed, false);
-        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);
     }
@@ -404,25 +428,20 @@ mod tests_old {
     ///
     /// 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() {
+    fn test_buy_sell_simple() {
         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)
+            .add_player("Player".to_string(), 1000.0)
             .unwrap();
         // Buy an item
-        let bought = DbApi::with_conn(&conn).as_player(1).buy(&vec![(1, None)]);
+        let bought = DbApi::with_conn(&conn)
-        assert_eq!(bought.ok(), Some((0, 0, 0, -8))); // Returns diff of player wealth ?
+            .as_player(1)
+            .buy("Sword", 800)
+            .unwrap();
+        assert_eq!(bought.executed, true); // Was updated ?
+        assert_eq!(bought.response, 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();
@@ -431,16 +450,13 @@ mod tests_old {
         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)]);
+            .sell(loot.id, None)
-        assert_eq!(sold.ok(), Some((0, 0, 0, 4)));
+            .unwrap();
+        assert_eq!(sold.executed, true);
+        assert_eq!(sold.response, 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();
@@ -449,7 +465,7 @@ mod tests_old {
     }
 
     #[test]
-    fn as_admin_add_loot() {
+    fn test_admin_add_loot() {
         let conn = test_connection();
         assert_eq!(
             0,
@@ -458,8 +474,9 @@ mod tests_old {
         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());
+            .add_loot(loot_to_add.clone())
-        assert_eq!(result.is_ok(), true);
+            .unwrap();
+        assert_eq!(result.executed, 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

lootalot_db/src/models/claim.rs

@@ -1,11 +1,8 @@
-use diesel::prelude::*;
+use crate::models::item::Loot;
-
-use crate::{DbConnection, QueryResult, Update, UpdateResult};
-use crate::models::{self, item::Loot};
 use crate::schema::claims;
 
 /// A Claim is a request by a single player on an item from group chest.
-#[derive(Identifiable, Queryable, Associations, Serialize, Deserialize, Clone, Copy, Debug)]
+#[derive(Identifiable, Queryable, Associations, Serialize, Debug)]
 #[belongs_to(Loot)]
 pub struct Claim {
     /// DB Identifier
@@ -18,170 +15,15 @@ pub struct Claim {
     pub resolve: i32,
 }
 
-impl Claim {
-    /// Resolves this claim (player wins the item) and deletes it
-    pub fn resolve_claim(&self, conn: &DbConnection) -> QueryResult<()> {
-        let loot: Loot = Loot::find(self.loot_id).first(conn)?;
-        loot.set_owner(self.player_id, conn)?;
-        self.remove(conn)?;
-        Ok(())
-    }
-
-    fn remove(&self, conn: &DbConnection) -> QueryResult<()> {
-        diesel::delete(claims::table.find(self.id)).execute(conn)?;
-        Ok(())
-    }
-}
-
-pub struct Claims<'q>(pub &'q DbConnection);
-
-impl<'q> Claims<'q> {
-    /// Get all claims from database
-    pub fn all(&self) -> QueryResult<Vec<Claim>> {
-        claims::table.load(self.0)
-    }
-
-    pub fn by_player(&self, id: i32) -> QueryResult<Vec<Claim>> {
-        claims::table.filter(claims::dsl::player_id.eq(id))
-            .load(self.0)
-    }
-
-    /// Finds a single claim by association of player and loot ids.
-    pub fn find(&self, player_id: i32, loot_id: i32) -> QueryResult<Claim> {
-        claims::table
-            .filter(claims::dsl::player_id.eq(player_id))
-            .filter(claims::dsl::loot_id.eq(loot_id))
-            .first(self.0)
-    }
-
-    /// Adds a claim in database and returns it.
-    ///
-    /// Will validate that the claimed item exists and is
-    /// actually owned by the group.
-    /// Duplicates are also ignored.
-    pub fn add(self, player_id: i32, loot_id: i32) -> UpdateResult {
-        // We need to validate that the claimed item exists
-        // AND is actually owned by group (id 0)
-        let _item = models::item::LootManager(self.0, 0).find(loot_id)?;
-        // We also check if claims does not already exists
-        if let Ok(_) = self.find(player_id, loot_id) {
-            return Err(diesel::result::Error::RollbackTransaction);
-        }
-
-        let claim = NewClaim::new(player_id, loot_id);
-        diesel::insert_into(claims::table)
-            .values(&claim)
-            .execute(self.0)?;
-        // Return the created claim
-        Ok(
-            Update::ClaimAdded(
-                claims::table
-                    .order(claims::dsl::id.desc())
-                    .first::<Claim>(self.0)?
-            )
-        )
-    }
-
-    /// Removes a claim from database, returning it
-    pub fn remove(self, player_id: i32, loot_id: i32) -> UpdateResult {
-        let claim = self.find(player_id, loot_id)?;
-        claim.remove(self.0)?;
-        Ok(
-            Update::ClaimRemoved(claim)
-        )
-    }
-
-    pub fn filtered_by_loot(&self, loot_id: i32) -> QueryResult<Vec<Claim>> {
-        claims::table
-            .filter(claims::dsl::loot_id.eq(loot_id))
-            .load(self.0)
-    }
-
-    pub(crate) fn delete_for_loot(&self, loot_id: i32) -> QueryResult<usize> {
-        diesel::delete(
-            claims::table
-                .filter(claims::dsl::loot_id.eq(loot_id))
-        )
-            .execute(self.0)
-
-    }
-
-    pub(crate) fn grouped_by_item(&self) -> QueryResult<Vec<(models::item::Item, Vec<Claim>)>> {
-        let group_loot: Vec<Loot> = Loot::owned_by(0).load(self.0)?;
-        let claims = claims::table.load(self.0)?.grouped_by(&group_loot);
-        Ok(group_loot
-            .into_iter()
-            .map(|loot| loot.into_item())
-            .zip(claims)
-            .collect::<Vec<_>>())
-    }
-}
-
 #[derive(Insertable, Debug)]
 #[table_name = "claims"]
-struct NewClaim {
+pub(crate) struct NewClaim {
     player_id: i32,
     loot_id: i32,
 }
 
 impl NewClaim {
-    fn new(player_id: i32, loot_id: i32) -> Self {
+    pub(crate) fn new(player_id: i32, loot_id: i32) -> Self {
         Self { player_id, loot_id }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    type TestResult = Result<(), diesel::result::Error>;
-
-    fn test_connection() -> Result<DbConnection, diesel::result::Error> {
-        let conn =
-            DbConnection::establish(":memory:").map_err(|_| diesel::result::Error::NotFound)?;
-        diesel_migrations::run_pending_migrations(&conn)
-            .map_err(|_| diesel::result::Error::NotFound)?;
-        let manager = models::player::Players(&conn);
-        manager.add("Player1", 0.0)?;
-        manager.add("Player2", 0.0)?;
-        crate::LootManager(&conn, 0).add("Epee", 30)?;
-        crate::LootManager(&conn, 1).add("Arc", 20)?;
-        Ok(conn)
-    }
-
-    #[test]
-    fn add_claim() -> TestResult {
-        let conn = test_connection()?;
-        Claims(&conn).add(1, 1)?;
-        assert_eq!(Claims(&conn).all()?.len(), 1);
-        Ok(())
-    }
-
-    #[test]
-    fn cannot_duplicate_by_adding() -> TestResult {
-        let conn = test_connection()?;
-        Claims(&conn).add(1, 1)?;
-        let res = Claims(&conn).add(1, 1);
-        assert_eq!(res.is_err(), true);
-        assert_eq!(Claims(&conn).all()?.len(), 1);
-        Ok(())
-    }
-
-    #[test]
-    fn remove_claim() -> TestResult {
-        let conn = test_connection()?;
-        let claim = Claims(&conn).add(1, 1)?;
-        claim.remove(&conn);
-        assert_eq!(Claims(&conn).all()?.len(), 0);
-        Ok(())
-    }
-
-    #[test]
-    fn cannot_only_claim_from_group() -> TestResult {
-        let conn = test_connection()?;
-        let claim = Claims(&conn).add(1, 2);
-        assert_eq!(claim.is_err(), true);
-        assert_eq!(Claims(&conn).all()?.len(), 0);
-        Ok(())
-    }
-}

lootalot_db/src/models/history.rs

@@ -1,109 +0,0 @@
-use serde_json;
-use diesel::prelude::*;
-use diesel::sql_types::Text;
-use diesel::deserialize::FromSql;
-use diesel::backend::Backend;
-use crate::schema::history;
-use crate::{DbConnection, QueryResult, Update};
-
-#[derive(Debug, FromSqlRow)]
-pub struct UpdateList(Vec<Update>);
-
-impl UpdateList {
-    pub fn inner(&self) -> &Vec<Update> {
-        &self.0
-    }
-
-    pub fn into_inner(self) -> Vec<Update> {
-        self.0
-    }
-}
-
-// TODO: decide if updates is really optionnal or not
-// (like if storing an event without update is usefull ?)
-
-/// An event in history
-#[derive(Debug, Queryable)]
-pub struct Event {
-    id: i32,
-    player_id: i32,
-    event_date: String,
-    text: String,
-    updates: Option<UpdateList>,
-}
-
-impl Event {
-    pub fn name(&self) -> &str {
-        &self.text
-    }
-
-    /// TODO: why a move here ??
-    /// Undo all updates in a single transaction
-    pub fn undo(self, conn: &DbConnection) -> QueryResult<UpdateList> {
-        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![]))
-            }
-        })
-    }
-}
-
-impl<DB: Backend> FromSql<Text, DB> for UpdateList
-where
-    String: FromSql<Text, DB>,
-{
-    fn from_sql(bytes: Option<&DB::RawValue>) -> diesel::deserialize::Result<Self> {
-        let repr = String::from_sql(bytes)?;
-        Ok(UpdateList(serde_json::from_str::<Vec<Update>>(&repr)?))
-    }
-}
-
-
-#[derive(Debug, Insertable)]
-#[table_name = "history"]
-struct NewEvent<'a> {
-    player_id: i32,
-    text: &'a str,
-    updates: Option<String>,
-}
-
-
-/// Insert a new event
-///
-/// # Warning
-/// This actually swallow up conversion errors
-pub fn insert_event(conn: &DbConnection, id: i32, text: &str, updates: &Vec<Update>) -> QueryResult<Event> {
-    diesel::insert_into(history::table)
-        .values(&NewEvent {
-            player_id: id,
-            text,
-            updates: serde_json::to_string(updates).ok(),
-        })
-        .execute(conn)?;
-    history::table
-        .order(history::dsl::id.desc())
-        .first(conn)
-}
-
-pub fn get_last_of_player(conn: &DbConnection, id: i32) -> QueryResult<Event> {
-    history::table
-        .filter(history::dsl::player_id.eq(id))
-        .order(history::dsl::id.desc())
-        .first(conn)
-}
-
-#[cfg(test)]
-mod tests {
-
-    #[test]
-    fn test_insert_event_with_updates() {
-
-    }
-}

lootalot_db/src/models/item.rs

@@ -1,112 +1,38 @@
+use crate::schema::looted;
 use diesel::dsl::{exists, Eq, Filter, Find, Select};
 use diesel::expression::exists::Exists;
 use diesel::prelude::*;
 
-use crate::schema::{items, looted, shop};
-use crate::{DbConnection, QueryResult, Update, UpdateResult, Claims };
 type ItemColumns = (looted::id, looted::name, looted::base_price);
 const ITEM_COLUMNS: ItemColumns = (looted::id, looted::name, looted::base_price);
 type OwnedBy = Select<OwnedLoot, ItemColumns>;
 
-/// Represents a basic item
+/// Represents a unique item in inventory
-#[derive(Debug, Queryable, Serialize, Deserialize, Clone)]
+///
+/// It is also used as a public representation of Loot, since owner
+/// information is implicit.
+/// Or maybe this is a little too confusing ??
+#[derive(Debug, Queryable, Serialize)]
 pub struct Item {
     pub id: i32,
     pub name: String,
-    base_price: i32,
+    pub base_price: i32,
 }
 
 impl Item {
-    /// Returns this item value
+    /// Public proxy for Loot::owned_by that selects only Item fields
-    pub fn value(&self) -> f64 {
+    pub fn owned_by(player: i32) -> OwnedBy {
-        self.base_price as f64
-    }
-
-    /// Returns this item sell value
-    pub fn sell_value(&self) -> f64 {
-        self.base_price as f64 / 2.0
-    }
-
-    pub fn remove(self, conn: &DbConnection) -> UpdateResult {
-        conn.transaction(
-            || -> UpdateResult
-            {
-                Claims(conn).delete_for_loot(self.id)?;
-                diesel::delete(looted::table.find(self.id)).execute(conn)?;
-
-                Ok(Update::ItemRemoved(self))
-            }
-        )
-    }
-
-    fn owned_by(player: i32) -> OwnedBy {
         Loot::owned_by(player).select(ITEM_COLUMNS)
     }
 }
 
-pub struct Inventory<'q>(pub &'q DbConnection);
-
-impl<'q> Inventory<'q> {
-    /// Get all items from Inventory
-    pub fn all(&self) -> QueryResult<Vec<Item>> {
-        items::table.load::<Item>(self.0)
-    }
-
-    /// Find an item in Inventory
-    pub fn find(&self, item_id: i32) -> QueryResult<Item> {
-        items::table.find(item_id).first::<Item>(self.0)
-    }
-}
-
-pub struct Shop<'q>(pub &'q DbConnection);
-
-impl<'q> Shop<'q> {
-    pub fn all(&self) -> QueryResult<Vec<Item>> {
-        shop::table.load(self.0)
-    }
-
-    pub fn get(&self, id: i32) -> QueryResult<Item> {
-        shop::table.find(&id).first::<Item>(self.0)
-    }
-
-    pub fn remove(&self, id: i32) -> QueryResult<()> {
-        diesel::delete(
-            shop::table.find(&id)
-        ).execute(self.0)?;
-        Ok(())
-    }
-
-    pub fn replace_list(&self, items: Vec<Item>) -> QueryResult<()> {
-        self.0.transaction(
-            || -> QueryResult<()>
-            {
-                // Remove all content
-                diesel::delete(shop::table).execute(self.0)?;
-                // Adds new list
-                for item in &items {
-                    let new_item = NewItem {
-                        name: &item.name,
-                        base_price: item.base_price,
-                    };
-                    diesel::insert_into(shop::table)
-                        .values(&new_item)
-                        .execute(self.0)?;
-
-                }
-                Ok(())
-            }
-        )
-    }
-}
-
 type WithOwner = Eq<looted::owner_id, i32>;
 type OwnedLoot = Filter<looted::table, WithOwner>;
 
-/// Represents an item that has been looted,
+/// Represents an item that has been looted
-/// hence has an owner.
+#[derive(Identifiable, Debug, Queryable, Serialize)]
-#[derive(Identifiable, Debug, Queryable)]
 #[table_name = "looted"]
-pub(super) struct Loot {
+pub(crate) struct Loot {
     id: i32,
     name: String,
     base_price: i32,
@@ -115,89 +41,21 @@ pub(super) struct Loot {
 
 impl Loot {
     /// A filter on Loot that is owned by given player
-    pub(super) fn owned_by(id: i32) -> OwnedLoot {
+    pub(crate) fn owned_by(id: i32) -> OwnedLoot {
         looted::table.filter(looted::owner_id.eq(id))
     }
 
-    fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
+    pub(crate) fn owns(player: i32, item: i32) -> Exists<Find<OwnedLoot, i32>> {
+        exists(Loot::owned_by(player).find(item))
+    }
+
+    pub(crate) fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
         exists(looted::table.find(id))
     }
-
-    pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> {
-        diesel::update(looted::table.find(self.id))
-            .set(looted::dsl::owner_id.eq(owner))
-            .execute(conn)?;
-        Ok(())
-    }
-
-    pub(super) fn into_item(self) -> Item {
-        Item {
-            id: self.id,
-            name: self.name,
-            base_price: self.base_price,
-        }
-    }
-
-    pub(super) fn find(id: i32) -> Find<looted::table, i32> {
-        looted::table.find(id)
-    }
 }
 
-/// Manager for a *single* player loot
+/// Description of an item : (name, value in gold)
-pub struct LootManager<'q>(pub &'q DbConnection, pub i32);
+pub type ItemDesc<'a> = (&'a str, i32);
-
-impl<'q> LootManager<'q> {
-    /// All items from this player chest
-    pub fn all(&self) -> QueryResult<Vec<Item>> {
-        Ok(Item::owned_by(self.1).load(self.0)?)
-    }
-
-    /// Finds an item by id
-    ///
-    /// Returns a NotFound error if an item is found by it
-    /// does not belong to this player
-    pub fn find(&self, loot_id: i32) -> QueryResult<Item> {
-        Ok(Loot::find(loot_id).first(self.0).and_then(|loot: Loot| {
-            if loot.owner != self.1 {
-                Err(diesel::result::Error::NotFound)
-            } else {
-                Ok(Item {
-                    id: loot.id,
-                    name: loot.name,
-                    base_price: loot.base_price,
-                })
-            }
-        })?)
-    }
-
-    /// The last item added to the chest
-    pub fn last(&self) -> QueryResult<Item> {
-        Ok(Item::owned_by(self.1)
-            .order(looted::dsl::id.desc())
-            .first(self.0)?)
-    }
-
-    pub(crate) fn add<S: Into<String>>(self, name: S, base_price: i32) -> UpdateResult {
-        self.add_from(&Item {
-            id: 0,
-            name: name.into(),
-            base_price,
-        })
-    }
-
-    /// Adds a copy of the given item inside player chest
-    pub fn add_from(self, item: &Item) -> UpdateResult {
-        let new_item = NewLoot {
-            name: &item.name,
-            base_price: item.base_price,
-            owner_id: self.1,
-        };
-        diesel::insert_into(looted::table)
-            .values(&new_item)
-            .execute(self.0)?;
-        Ok(Update::ItemAdded(self.last()?))
-    }
-}
 
 /// An item being looted or bought.
 ///
@@ -205,15 +63,28 @@ impl<'q> LootManager<'q> {
 /// to the id of buying player otherwise.
 #[derive(Insertable)]
 #[table_name = "looted"]
-struct NewLoot<'a> {
+pub(crate) struct NewLoot<'a> {
     name: &'a str,
     base_price: i32,
     owner_id: i32,
 }
 
-#[derive(Insertable)]
+impl<'a> NewLoot<'a> {
-#[table_name = "shop"]
+    /// A new loot going to the group (loot procedure)
-struct NewItem<'a> {
+    pub(crate) fn to_group(desc: ItemDesc<'a>) -> Self {
-    name: &'a str,
+        Self {
-    base_price: i32,
+            name: desc.0,
+            base_price: desc.1,
+            owner_id: 0,
+        }
+    }
+
+    /// A new loot going to a specific player (buy procedure)
+    pub(crate) fn to_player(player: i32, desc: ItemDesc<'a>) -> Self {
+        Self {
+            name: desc.0,
+            base_price: desc.1,
+            owner_id: player,
+        }
+    }
 }

lootalot_db/src/models/mod.rs

@@ -1,8 +1,8 @@
-pub mod claim;
+pub(super) mod claim;
-pub mod item;
+pub(super) mod item;
-pub mod player;
+pub(super) mod player;
-pub mod history;
 
 pub use claim::Claim;
 pub use item::Item;
+pub(crate) use item::Loot;
 pub use player::{Player, Wealth};

lootalot_db/src/models/player.rs

@@ -0,0 +1,131 @@
+use crate::schema::players;
+
+/// Representation of a player in database
+#[derive(Debug, Queryable, Serialize)]
+pub struct Player {
+    /// DB Identitier
+    pub id: i32,
+    /// Full name of the character
+    pub name: String,
+    /// Amount of gold coins owed to the group.
+    /// Taking a looted items will increase the debt by it's sell value
+    pub debt: i32,
+    /// Count of copper pieces
+    pub cp: i32,
+    /// Count of silver pieces
+    pub sp: i32,
+    /// Count of gold pieces
+    pub gp: i32,
+    /// Count of platinum pieces
+    pub pp: i32,
+}
+
+/// Unpack a floating value in gold pieces to integer
+/// values of copper, silver, gold and platinum pieces
+///
+/// # Note
+///
+/// The conversion is slightly different than standard rules :
+/// ``` 1pp = 100gp = 1000sp = 10000 cp ```
+///
+fn unpack_gold_value(gold: f32) -> (i32, i32, i32, i32) {
+    let rest = (gold.fract() * 100.0).round() as i32;
+    let gold = gold.trunc() as i32;
+    let pp = gold / 100;
+    let gp = gold % 100;
+    let sp = rest / 10;
+    let cp = rest % 10;
+    (cp, sp, gp, pp)
+}
+
+/// State of a player's wealth
+///
+/// Values are held as individual pieces counts.
+/// Allows conversion from and to a floating amount of gold pieces.
+#[derive(Queryable, AsChangeset, Debug)]
+#[table_name = "players"]
+pub struct Wealth {
+    pub cp: i32,
+    pub sp: i32,
+    pub gp: i32,
+    pub pp: i32,
+}
+
+impl Wealth {
+    /// Unpack individual pieces counts from gold value
+    ///
+    /// # Examples
+    /// ```
+    /// # use lootalot_db::models::Wealth;
+    /// let wealth = Wealth::from_gp(403.21);
+    /// assert_eq!(wealth.as_tuple(), (1, 2, 3, 4));
+    /// ```
+    pub fn from_gp(gp: f32) -> Self {
+        let (cp, sp, gp, pp) = unpack_gold_value(gp);
+        Self { cp, sp, gp, pp }
+    }
+    /// Convert total value to a floating value in gold pieces
+    ///
+    /// # Examples
+    /// ```
+    /// # use lootalot_db::models::Wealth;
+    /// let wealth = Wealth{ pp: 4, gp: 3, sp: 2, cp: 1};
+    /// assert_eq!(wealth.to_gp(), 403.21);
+    /// ```
+    pub fn to_gp(&self) -> f32 {
+        let i = self.pp * 100 + self.gp;
+        let f = (self.sp * 10 + self.cp) as f32 / 100.0;
+        i as f32 + f
+    }
+    /// Pack the counts inside a tuple, from lower to higher coin value.
+    pub fn as_tuple(&self) -> (i32, i32, i32, i32) {
+        (self.cp, self.sp, self.gp, self.pp)
+    }
+}
+
+/// Representation of a new player record
+#[derive(Insertable)]
+#[table_name = "players"]
+pub(crate) struct NewPlayer<'a> {
+    name: &'a str,
+    cp: i32,
+    sp: i32,
+    gp: i32,
+    pp: i32,
+}
+
+impl<'a> NewPlayer<'a> {
+    pub(crate) fn create(name: &'a str, wealth_in_gp: f32) -> Self {
+        let (cp, sp, gp, pp) = Wealth::from_gp(wealth_in_gp).as_tuple();
+        Self {
+            name,
+            cp,
+            sp,
+            gp,
+            pp,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_unpack_gold_values() {
+        use super::unpack_gold_value;
+        let test_values = [
+            (1.0, (0, 0, 1, 0)),
+            (1.23, (3, 2, 1, 0)),
+            (1.03, (3, 0, 1, 0)),
+            (100.23, (3, 2, 0, 1)),
+            (-100.23, (-3, -2, -0, -1)),
+            (10189.23, (3, 2, 89, 101)),
+            (-8090.20, (0, -2, -90, -80)),
+        ];
+
+        for (tested, expected) in test_values.into_iter() {
+            assert_eq!(unpack_gold_value(*tested), *expected);
+        }
+    }
+
+}

lootalot_db/src/models/player/mod.rs

@@ -1,126 +0,0 @@
-use crate::schema::players;
-use crate::{DbConnection, QueryResult, Update, UpdateResult};
-use diesel::prelude::*;
-
-mod notification;
-pub mod wealth;
-pub use wealth::Wealth;
-
-/// Representation of a player in database
-#[derive(Identifiable, Queryable, Serialize, Deserialize, Debug)]
-pub struct Player {
-    /// DB Identitier
-    pub id: i32,
-    /// Full name of the character
-    pub name: String,
-    /// Amount of gold coins owed to the group.
-    /// Taking a looted items will increase the debt by it's sell value
-    pub debt: i32,
-    /// Count of copper pieces
-    pub cp: i32,
-    /// Count of silver pieces
-    pub sp: i32,
-    /// Count of gold pieces
-    pub gp: i32,
-    /// Count of platinum pieces
-    pub pp: i32,
-}
-
-/// Manager for players
-pub struct Players<'q>(pub &'q DbConnection);
-
-impl<'q> Players<'q> {
-    /// Get all players from database
-    pub fn all(&self) -> QueryResult<Vec<Player>> {
-        players::table.load(self.0)
-    }
-
-    /// Get all non-group players
-    pub fn all_except_group(&self) -> QueryResult<Vec<Player>> {
-        use diesel::dsl::not;
-        players::table.filter(not(players::id.eq(0))).load(self.0)
-    }
-
-    /// Find a player by id
-    pub fn find(&self, id: i32) -> QueryResult<Player> {
-        players::table.find(id).first(self.0)
-    }
-
-    /// Add a new player with name and starting wealth
-    pub fn add(&self, name: &str, wealth: f64) -> QueryResult<Player> {
-        diesel::insert_into(players::table)
-            .values(&NewPlayer::create(name, wealth))
-            .execute(self.0)?;
-        players::table.order(players::dsl::id.desc()).first(self.0)
-    }
-
-    /// Notify all players of an event
-    pub fn notifiy_all(&self, text: &str) -> QueryResult<()> {
-        for id in self.all()?.into_iter().map(|p| p.id) {
-            self.notify(id, text);
-        }
-        Ok(())
-    }
-
-    /// Notify a single player of an event
-    pub fn notify(&self, id: i32, text: &str) -> QueryResult<()> {
-        let _ = notification::Notification::add(self.0, id, text)?;
-        Ok(())
-    }
-}
-
-/// Wrapper for action of a single player
-pub struct AsPlayer<'q>(pub &'q DbConnection, pub i32);
-
-impl<'q> AsPlayer<'q> {
-    /// Fetch notifications for this player
-    pub fn notifications(&self) -> QueryResult<Vec<String>> {
-        notification::pop_all_for(self.1, self.0)
-    }
-    /// Updates this player's wealth, returning the difference
-    pub fn update_wealth(&self, value_in_gp: f64) -> UpdateResult {
-        use crate::schema::players::dsl::*;
-        let current_wealth = players
-            .find(self.1)
-            .select((cp, sp, gp, pp))
-            .first::<Wealth>(self.0)?;
-        let updated_wealth = Wealth::from_gp(current_wealth.to_gp() + value_in_gp);
-        diesel::update(players)
-            .filter(id.eq(self.1))
-            .set(&updated_wealth)
-            .execute(self.0)?;
-        Ok(Update::Wealth(updated_wealth - current_wealth))
-    }
-
-    /// Updates this player's debt
-    pub fn update_debt(&self, value_in_gp: i32) -> QueryResult<()> {
-        diesel::update(players::table.find(self.1))
-            .set(players::dsl::debt.eq(players::dsl::debt + value_in_gp))
-            .execute(self.0)?;
-        Ok(())
-    }
-}
-
-/// Representation of a new player record
-#[derive(Insertable)]
-#[table_name = "players"]
-struct NewPlayer<'a> {
-    name: &'a str,
-    cp: i32,
-    sp: i32,
-    gp: i32,
-    pp: i32,
-}
-
-impl<'a> NewPlayer<'a> {
-    fn create(name: &'a str, wealth_in_gp: f64) -> Self {
-        let (cp, sp, gp, pp) = Wealth::from_gp(wealth_in_gp).as_tuple();
-        Self {
-            name,
-            cp,
-            sp,
-            gp,
-            pp,
-        }
-    }
-}

lootalot_db/src/models/player/notification.rs

@@ -1,44 +0,0 @@
-use diesel::prelude::*;
-use crate::{
-    DbConnection,
-    schema::notifications,
-    models::player::Player,
-};
-
-
-/// Pops all notification for a player, deleting the database entities
-pub(super) fn pop_all_for(id: i32, conn: &DbConnection) -> QueryResult<Vec<String>> {
-    let select = notifications::table.filter(notifications::dsl::player_id.eq(id));
-    let popped = select.load(conn)?;
-    diesel::delete(select).execute(conn)?;
-    Ok(popped.into_iter().map(|n: Notification| n.text).collect())
-}
-
-#[derive(Identifiable, Queryable, Associations, Serialize, Debug)]
-#[belongs_to(Player)]
-pub(super) struct Notification {
-    pub id: i32,
-    pub player_id: i32,
-    pub text: String,
-}
-
-impl Notification {
-    pub(super) fn add<'a, S: Into<&'a str>>(conn: &DbConnection, id: i32, text: S) -> QueryResult<Notification> {
-        diesel::insert_into(notifications::table)
-            .values(&NewNotification {
-                player_id: id,
-                text: text.into(),
-            })
-            .execute(conn)?;
-        notifications::table
-            .order(notifications::dsl::id.desc())
-            .first(conn)
-    }
-}
-
-#[derive(Insertable)]
-#[table_name="notifications"]
-struct NewNotification<'a> {
-    player_id: i32,
-    text: &'a str,
-}

lootalot_db/src/models/player/wealth.rs

@@ -1,157 +0,0 @@
-use crate::schema::players;
-
-/// Unpack a floating value of gold pieces to integer
-/// values of copper, silver, gold and platinum pieces
-///
-/// # Note
-///
-/// The conversion is slightly different than standard rules :
-/// ``` 1pp = 100gp = 1000sp = 10000 cp ```
-///
-fn unpack_gold_value(gold: f64) -> (i32, i32, i32, i32) {
-    let rest = (gold.fract() * 100.0).round() as i32;
-    let gold = gold.trunc() as i32;
-    let pp = gold / 100;
-    let gp = gold % 100;
-    let sp = rest / 10;
-    let cp = rest % 10;
-    (cp, sp, gp, pp)
-}
-
-/// State of a player's wealth
-///
-/// Values are held as individual pieces counts.
-/// Allows conversion from and to a floating amount of gold pieces.
-#[derive(Queryable, AsChangeset, Serialize, Deserialize, PartialEq, Copy, Clone, Debug)]
-#[table_name = "players"]
-pub struct Wealth {
-    pub cp: i32,
-    pub sp: i32,
-    pub gp: i32,
-    pub pp: i32,
-}
-
-impl Wealth {
-    /// Unpack individual pieces counts from gold value
-    ///
-    /// # Examples
-    /// ```
-    /// # use lootalot_db::models::Wealth;
-    /// let wealth = Wealth::from_gp(403.21);
-    /// assert_eq!(wealth.as_tuple(), (1, 2, 3, 4));
-    /// ```
-    pub fn from_gp(gp: f64) -> Self {
-        let (cp, sp, gp, pp) = unpack_gold_value(gp);
-        Self { cp, sp, gp, pp }
-    }
-    /// Convert total value to a floating value in gold pieces
-    ///
-    /// # Examples
-    /// ```
-    /// # use lootalot_db::models::Wealth;
-    /// let wealth = Wealth{ pp: 4, gp: 5, sp: 8, cp: 4};
-    /// assert_eq!(wealth.to_gp(), 405.84);
-    /// ```
-    pub fn to_gp(&self) -> f64 {
-        let i = self.pp * 100 + self.gp;
-        let f = (self.sp * 10 + self.cp) as f64 / 100.0;
-        i as f64 + f
-    }
-    /// Pack the counts inside a tuple, from lower to higher coin value.
-    pub fn as_tuple(&self) -> (i32, i32, i32, i32) {
-        (self.cp, self.sp, self.gp, self.pp)
-    }
-}
-
-
-impl std::ops::Sub for Wealth {
-    type Output = Self;
-    /// What needs to be added to 'other' so that
-    /// the result equals 'self'
-    fn sub(self, other: Self) -> Self {
-        Wealth::from_gp(self.to_gp() - other.to_gp())
-    }
-}
-
-impl std::ops::Add for Wealth {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        Wealth::from_gp(self.to_gp() + other.to_gp())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    #[test]
-    fn test_unpack_gold_values() {
-        use super::unpack_gold_value;
-        let test_values = [
-            (0.01, (1, 0, 0, 0)),
-            (0.1, (0, 1, 0, 0)),
-            (1.0, (0, 0, 1, 0)),
-            (1.23, (3, 2, 1, 0)),
-            (1.03, (3, 0, 1, 0)),
-            (100.23, (3, 2, 0, 1)),
-            (-100.23, (-3, -2, -0, -1)),
-            (10189.23, (3, 2, 89, 101)),
-            (141805.9, (0, 9, 5, 1418)),
-            (123141805.9, (0, 9, 5, 1231418)),
-            (-8090.20, (0, -2, -90, -80)),
-        ];
-
-        for (tested, expected) in test_values.into_iter() {
-            assert_eq!(unpack_gold_value(*tested), *expected);
-        }
-    }
-
-    #[test]
-    fn test_negative_wealth() {
-        use super::Wealth;
-
-        assert_eq!(
-            Wealth{ cp: 3, sp: 2, gp: 1, pp: 0 } + Wealth{ cp: -8, pp: 0, sp: 0, gp: 0 },
-            Wealth::from_gp(1.23 - 0.08)
-        )
-
-    }
-    #[test]
-    fn test_negative_wealth_inverse() {
-        use super::Wealth;
-
-        assert_eq!(
-            (Wealth{ cp: 3, sp: 2, gp: 1, pp: 0 } + Wealth{ cp: -8, pp: 0, sp: 0, gp: 0 }).to_gp(),
-            1.23 - 0.08
-        )
-
-    }
-    #[test]
-    fn test_diff_adding() {
-        use super::Wealth;
-
-        // Let say we add 0.08 gp
-        // 1.23 + 0.08 gold is 1.31, diff is cp: -2, sp: +1
-        let old = Wealth::from_gp(1.23);
-        let new = Wealth::from_gp(1.31);
-        let diff = new - old;
-        assert_eq!(diff.as_tuple(), (-2, 1, 0, 0));
-        assert_eq!(diff.to_gp(), 0.08);
-        assert_eq!(new - diff, old);
-
-    }
-    #[test]
-    fn test_diff_subbing() {
-        use super::Wealth;
-
-        // Let say we sub 0.08 gp
-        // 1.31 - 0.08 gold is 1.23, diff is cp: +2, sp: -1
-        let old = Wealth::from_gp(1.31);
-        let new = Wealth::from_gp(1.23);
-        let diff = new - old;
-        assert_eq!(diff.as_tuple(), (2, -1, 0, 0));
-        assert_eq!(diff.to_gp(), -0.08);
-        assert_eq!(new - diff, old);
-    }
-
-}

lootalot_db/src/schema.rs

@@ -7,16 +7,6 @@ table! {
     }
 }
 
-table! {
-    history (id) {
-        id -> Integer,
-        player_id -> Integer,
-        event_date -> Timestamp,
-        text -> Text,
-        updates -> Nullable<Text>,
-    }
-}
-
 table! {
     items (id) {
         id -> Integer,
@@ -34,14 +24,6 @@ table! {
     }
 }
 
-table! {
-    notifications (id) {
-        id -> Integer,
-        player_id -> Integer,
-        text -> Text,
-    }
-}
-
 table! {
     players (id) {
         id -> Integer,
@@ -54,26 +36,8 @@ table! {
     }
 }
 
-table! {
-    shop (id) {
-        id -> Integer,
-        name -> Text,
-        base_price -> Integer,
-    }
-}
-
 joinable!(claims -> looted (loot_id));
 joinable!(claims -> players (player_id));
-joinable!(history -> players (player_id));
 joinable!(looted -> players (owner_id));
-joinable!(notifications -> players (player_id));
 
-allow_tables_to_appear_in_same_query!(
+allow_tables_to_appear_in_same_query!(claims, items, looted, players,);
-    claims,
-    history,
-    items,
-    looted,
-    notifications,
-    players,
-    shop,
-);

lootalot_db/src/transactions.rs

@@ -0,0 +1,295 @@
+//!  TODO:
+//!     Extract actions provided by API into their dedicated module.
+//!     Will allow more flexibilty to combinate them inside API methods.
+//!     Should make it easier to add a new feature : Reverting an action
+//!
+use crate::models;
+use crate::schema;
+use crate::DbConnection;
+use diesel::prelude::*;
+// TODO: revertable actions :
+//          - Buy
+//          - Sell
+//          - UpdateWealth
+pub type TransactionResult<T> = Result<T, diesel::result::Error>;
+
+
+pub trait DbTransaction {
+    type Params;
+    type Response: serde::Serialize;
+
+    fn execute<'q>(
+        self,
+        conn: &'q DbConnection,
+        params: Self::Params,
+    ) -> TransactionResult<Self::Response>;
+}
+
+pub trait Revertable : DbTransaction {
+    fn revert<'q>(
+        self,
+        conn: &'q DbConnection,
+        player_id: i32,
+        params: <Self as DbTransaction>::Response,
+    ) -> TransactionResult<<Self as DbTransaction>::Response>;
+
+}
+
+/// Return status of an Action
+#[derive(Serialize, Debug)]
+pub struct ActionStatus<R: serde::Serialize> {
+    /// Has the action made changes ?
+    pub executed: bool,
+    /// Response payload
+    pub response: R,
+}
+
+impl ActionStatus<()> {
+    pub fn was_updated(updated_lines: usize) -> Self {
+        match updated_lines {
+            1 => Self::ok(),
+            _ => Self::nop(),
+        }
+    }
+    pub fn ok() -> ActionStatus<()> {
+        Self {
+            executed: true,
+            response: (),
+        }
+    }
+}
+
+impl<T: Default + serde::Serialize> ActionStatus<T> {
+    pub fn nop() -> ActionStatus<T> {
+        Self {
+            executed: false,
+            response: Default::default(),
+        }
+    }
+}
+// Or a module ?
+pub(crate) mod player {
+    use super::*;
+
+    pub struct AddLootParams {
+        pub player_id: i32,
+        pub loot_name: String,
+        pub loot_price: i32,
+    }
+    pub struct Buy;
+
+    enum LootTransactionKind {
+        Buy,
+        Sell,
+    }
+    #[derive(Serialize, Debug)]
+    pub struct LootTransaction {
+        player_id: i32,
+        loot_id: i32,
+        kind: LootTransactionKind,
+        pub loot_cost: (i32, i32, i32, i32),
+    }
+
+    impl DbTransaction for Buy {
+        type Params = AddLootParams;
+        type Response = LootTransaction;
+
+        fn execute<'q>(
+            self,
+            conn: &'q DbConnection,
+            params: Self::Params,
+        ) -> TransactionResult<Self::Response> {
+            let added_item = {
+                let new_item = models::item::NewLoot::to_player(
+                    params.player_id,
+                    (&params.loot_name, params.loot_price),
+                );
+                diesel::insert_into(schema::looted::table)
+                    .values(&new_item)
+                    .execute(conn)?
+                    // TODO: return ID of inserted item
+            };
+            let updated_wealth = UpdateWealth.execute(
+                conn,
+                WealthParams {
+                    player_id: params.player_id,
+                    value_in_gp: -(params.loot_price as f32),
+                },
+            );
+            match (added_item, updated_wealth) {
+                (1, Ok(loot_cost)) => Ok(LootTransaction {
+                    kind: LootTransactionKind::Buy,
+                    player_id: params.player_id,
+                    loot_id: 0, //TODO:  find added item ID
+                    loot_cost,
+                }),
+                // TODO: Handle other cases
+                _ => panic!()
+            }
+
+        }
+    }
+
+    impl Revertable for Buy {
+        fn revert<'q>(self, conn: &'q DbConnection, player_id: i32, params: <Self as DbTransaction>::Response)
+        -> TransactionResult<<Self as DbTransaction>::Response> {
+            unimplemented!()
+        }
+    }
+
+    pub struct LootParams {
+        pub player_id: i32,
+        pub loot_id: i32,
+    }
+    pub struct Sell;
+    impl DbTransaction for Sell {
+        type Params = LootParams;
+        type Response = LootTransaction;
+        fn execute<'q>(
+            self,
+            conn: &DbConnection,
+            params: Self::Params,
+        ) -> TransactionResult<Self::Response> {
+            use schema::looted::dsl::*;
+            let loot_value = looted
+                .find(params.loot_id)
+                .select(base_price)
+                .first::<i32>(conn)?;
+            let sell_value = (loot_value / 2) as f32;
+            diesel::delete(looted.find(params.loot_id))
+                .execute(conn)
+                .and_then(|r| match r {
+                    // On deletion, update this player wealth
+                    1 => Ok(UpdateWealth
+                        .execute(
+                            conn,
+                            WealthParams {
+                                player_id: params.player_id,
+                                value_in_gp: sell_value as f32,
+                            },
+                        )
+                        .unwrap()),
+                    _ => Ok(ActionStatus {
+                        executed: false,
+                        response: None,
+                    }),
+                })
+        }
+    }
+
+    pub struct PutClaim;
+    impl DbTransaction for PutClaim {
+        type Params = LootParams;
+        type Response = ();
+        fn execute<'q>(
+            self,
+            conn: &DbConnection,
+            params: Self::Params,
+        ) -> TransactionResult<Self::Response> {
+            let claim = models::claim::NewClaim::new(params.player_id, params.loot_id);
+            diesel::insert_into(schema::claims::table)
+                .values(&claim)
+                .execute(conn)
+                .and_then(|_| Ok(()))
+        }
+    }
+
+    pub struct WithdrawClaim;
+    impl DbTransaction for WithdrawClaim {
+        type Params = LootParams;
+        type Response = ();
+        fn execute<'q>(
+            self,
+            conn: &DbConnection,
+            params: Self::Params,
+        ) -> TransactionResult<Self::Response> {
+            use schema::claims::dsl::*;
+            diesel::delete(
+                claims
+                    .filter(loot_id.eq(params.loot_id))
+                    .filter(player_id.eq(params.player_id)),
+            )
+            .execute(conn)
+            .and_then(|_| Ok(()))
+        }
+    }
+
+    pub struct WealthParams {
+        pub player_id: i32,
+        pub value_in_gp: f32,
+    }
+    pub struct UpdateWealth;
+
+    impl DbTransaction for UpdateWealth {
+        type Params = WealthParams;
+        type Response = (i32, i32, i32, i32);
+
+        fn execute<'q>(
+            self,
+            conn: &'q DbConnection,
+            params: WealthParams,
+        ) -> TransactionResult<Self::Response> {
+            use schema::players::dsl::*;
+            let current_wealth = players
+                .find(params.player_id)
+                .select((cp, sp, gp, pp))
+                .first::<models::Wealth>(conn)?;
+            // TODO: improve thisdiesel dependant transaction
+            //       should be move inside a WealthUpdate method
+            let updated_wealth =
+                models::Wealth::from_gp(current_wealth.to_gp() + params.value_in_gp);
+            // Difference in coins that is sent back
+            let (old, new) = (current_wealth.as_tuple(), updated_wealth.as_tuple());
+            let diff = (new.0 - old.0, new.1 - old.1, new.2 - old.2, new.3 - old.3);
+            diesel::update(players)
+                .filter(id.eq(params.player_id))
+                .set(&updated_wealth)
+                .execute(conn)
+                .and_then(|r| match r {
+                    1 => Ok(diff),
+                    _ => panic!("UpdateWealth made no changes !"),
+                })
+        }
+    }
+
+    impl Revertable for UpdateWealth {
+        fn revert<'q>(
+            self,
+            conn: &'q DbConnection,
+            player_id: i32,
+            params: <Self as DbTransaction>::Response,
+        ) -> TransactionResult<<Self as DbTransaction>::Response> {
+            use schema::players::dsl::*;
+            let cur_wealth = players
+                .find(player_id)
+                .select((cp, sp, gp, pp))
+                .first::<models::Wealth>(conn)?;
+            let reverted_wealth = models::player::Wealth {
+                cp: cur_wealth.cp - params.0,
+                sp: cur_wealth.cp - params.1,
+                gp: cur_wealth.cp - params.2,
+                pp: cur_wealth.cp - params.3,
+            };
+            // Difference in coins that is sent back
+            let diff = ( -params.0, -params.1, -params.2, -params.3);
+            diesel::update(players)
+                .filter(id.eq(params.0))
+                .set(&reverted_wealth)
+                .execute(conn)
+                .and_then(|r| match r {
+                    1 => Ok(diff),
+                    _ => panic!("RevertableWealthUpdate made no changes"),
+                })
+        }
+    }
+}
+
+
+pub(crate) mod admin {
+    pub struct AddPlayer;
+    pub struct AddLoot;
+    pub struct SellLoot;
+    pub struct ResolveClaims;
+
+
+}

lootalot_front/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+node_modules
+/dist
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

lootalot_front/README.md

@@ -0,0 +1,29 @@
+# lootalot_front
+
+## Project setup
+```
+npm install
+```
+
+### Compiles and hot-reloads for development
+```
+npm run serve
+```
+
+### Compiles and minifies for production
+```
+npm run build
+```
+
+### Run your tests
+```
+npm run test
+```
+
+### Lints and fixes files
+```
+npm run lint
+```
+
+### Customize configuration
+See [Configuration Reference](https://cli.vuejs.org/config/).

lootalot_front/babel.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  presets: [
+    '@vue/app'
+  ],
+  "presets": [["env", { "modules": false }]],
+  "env": {
+    "test": {
+      "presets": [["env", { "targets": { "node": "current" } }]]
+    }
+  }
+}

lootalot_front/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "lootalot_front",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "css-build": "node-sass --omit-source-map-url sass/scroll.scss public/css/scroll.css",
+    "css-watch": "npm run css-build -- --watch",
+    "serve": "vue-cli-service serve",
+    "build": "vue-cli-service build",
+    "lint": "vue-cli-service lint",
+    "test": "jest"
+  },
+  "main": "sass/scroll.scss",
+  "dependencies": {
+    "bulma": "^0.7.5",
+    "core-js": "^2.6.5",
+    "vue": "^2.6.10"
+  },
+  "devDependencies": {
+    "@vue/cli-plugin-babel": "^3.8.0",
+    "@vue/cli-plugin-eslint": "^3.8.0",
+    "@vue/cli-service": "^3.8.0",
+    "@vue/test-utils": "^1.0.0-beta.29",
+    "babel-eslint": "^10.0.1",
+    "babel-jest": "^24.8.0",
+    "babel-preset-env": "^1.7.0",
+    "eslint": "^5.16.0",
+    "eslint-plugin-vue": "^5.0.0",
+    "jest": "^24.8.0",
+    "node-sass": "^4.12.0",
+    "vue-jest": "^3.0.4",
+    "vue-template-compiler": "^2.6.10"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "node": true
+    },
+    "extends": [
+      "plugin:vue/essential",
+      "eslint:recommended"
+    ],
+    "rules": {},
+    "parserOptions": {
+      "parser": "babel-eslint"
+    }
+  },
+  "postcss": {
+    "plugins": {
+      "autoprefixer": {}
+    }
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions"
+  ],
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "vue"
+    ],
+    "transform": {
+      ".*\\.(vue)$": "vue-jest",
+      "^.+\\.js$": "<rootDir>/node_modules/babel-jest"
+    }
+  }
+}

lootalot_front/public/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="viewport" content="width=device-width,initial-scale=1.0">
+        <link rel="icon" href="<%= BASE_URL %>favicon.ico">
+        <link rel="stylesheet" href="<%= BASE_URL %>css/scroll.css">
+        <title>Loot-a-Lot !</title>
+        <script defer src="fontawesome/js/all.js"></script>
+</head>
+<body>
+    <div id="app"></div>
+    <!-- built files will be auto injected -->
+    <noscript>
+      <strong>We're sorry but lootalot_front doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
+    </noscript>
+  </body>
+</html>

lootalot_front/sass/scroll.scss

@@ -0,0 +1,21 @@
+@charset "utf-8";
+
+$brown: #757763;
+$beige: #C9AD6A;
+$beige-light: #E0E5C1;
+$beige-lighter: #EEE5CE;
+$red: #B7321B;
+$dark-red: #58180D;
+$yellow-light: #FCF2C5;
+
+$link: $brown;
+$primary: $brown;
+$info: $beige;
+$danger: $red;
+
+$table-cell-border: 1px solid $dark-red;
+$table-striped-row-even-background-color: $yellow-light;
+
+$button-padding-horizontal: 1em;
+
+@import "../node_modules/bulma/bulma.sass";

lootalot_front/src/App.vue

@@ -0,0 +1,66 @@
+<template>
+  <main id="app" class="section">
+  <section id="content" class="columns is-desktop">
+    <Player></Player>
+    <div class="column">
+      <Chest :player="0" v-if="state.initiated"></Chest>
+    </div>
+  </section>
+  </main>
+</template>
+
+<script>
+import Player from './components/Player.vue'
+import Chest from './components/Chest.vue'
+import { AppStorage } from './AppStorage'
+
+function getCookie(cname) {
+  var name = cname + "=";
+  var decodedCookie = decodeURIComponent(document.cookie);
+  var ca = decodedCookie.split(';');
+  for(var i = 0; i <ca.length; i++) {
+    var c = ca[i];
+    while (c.charAt(0) == ' ') {
+      c = c.substring(1);
+    }
+    if (c.indexOf(name) == 0) {
+      return c.substring(name.length, c.length);
+    }
+  }
+  return "";
+}
+
+export default {
+  name: 'app',
+  data () {
+      return {
+  	state: AppStorage.state,
+      };
+  },
+  components: {
+    Player,
+    Chest
+  },
+  created () {
+    // Initiate with active player set to value found in cookie
+    // or as group by default.
+    const cookie = getCookie("player_id");
+    let playerId;
+    if (cookie == "") {
+        playerId = 0;
+    } else {
+        playerId = Number(cookie);
+    }
+    AppStorage.initStorage(playerId);
+  },
+}
+</script>
+
+<style>
+#app {
+  font-family: 'Montserrat', Helvetica, Arial, sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-align: center;
+}
+</style>

lootalot_front/src/AppStorage.js

@@ -0,0 +1,163 @@
+import Vue from 'vue'
+
+const API_BASEURL = "http://localhost:8088/api/"
+const API_ENDPOINT = function (tailString) {
+  return API_BASEURL + tailString;
+}
+
+const Api = {
+  fetchPlayerList () {
+      return fetch(API_ENDPOINT("players"))
+          .then(r => r.json())
+          .catch(e => console.error("Fetch error ", e));
+  },
+  fetchClaims () {
+      return fetch(API_ENDPOINT("claims"))
+          .then(r => r.json())
+          .catch(e => console.error("Fetch error ", e));
+  },
+  fetchLoot (playerId) {
+      return fetch(API_ENDPOINT(playerId + "/loot"))
+       	  .then(r => r.json())
+       	  .catch(e => console.error("Fetch error", e));
+  },
+  putClaim (playerId, itemId) {
+      return fetch(API_ENDPOINT(playerId + "/claim/" + itemId))
+       	  .then(r => r.json())
+       	  .catch(e => console.error("Fetch error", e));
+  },
+  unClaim (playerId, itemId) {
+       return fetch(API_ENDPOINT(playerId + "/unclaim/" + itemId))
+       	  .then(r => r.json())
+       	  .catch(e => console.error("Fetch error", e));
+  },
+  updateWealth (playerId, goldValue) {
+      return fetch(API_ENDPOINT(playerId + "/update-wealth/" + goldValue))
+          .then(r => r.json())
+          .catch(e => console.error("Fetch error", e));
+  }
+};
+
+
+export const AppStorage = {
+    debug: true,
+    state: {
+        player_id: 0,
+        player_list: {},
+        player_loot: {},
+        player_claims: {},
+        initiated: false,
+        show_player_chest: false,
+    },
+    // Initiate the state
+    initStorage (playerId) {
+        if (this.debug) console.log('Initiates with player : ', playerId)
+        this.state.player_id = playerId;
+        // Fetch initial data
+        return Promise
+            .all([ Api.fetchPlayerList(), Api.fetchClaims(), ])
+            .then(data => {
+                const [players, claims] = data;
+                this.__initPlayerList(players);
+                this.__initClaimsStore(claims);
+            });
+            // TODO: when __initPlayerList won't use promises
+            //.then(_ => this.state.initiated = true);
+    },
+    __initClaimsStore(data) {
+      for (var idx in data) {
+        var claimDesc = data[idx];
+        this.state.player_claims[claimDesc.player_id].push(claimDesc.loot_id);
+      }
+    },
+    __initPlayerList(data) {
+        for (var idx in data) {
+          var playerDesc = data[idx];
+          const playerId = Number(playerDesc.id);
+          if (this.debug) console.log("Creates", playerId, playerDesc.name)
+          // Initiate data for a single Player.
+          Vue.set(this.state.player_list, playerId, playerDesc);
+          Vue.set(this.state.player_loot, playerId, []);
+          Vue.set(this.state.player_claims, playerId, []);
+        }
+        // Hack for now !!
+        // Fetch all players loot and wait to set initiated to true
+        var promises = [];
+        for (var idx in data) {
+          const playerId = data[idx].id;
+          var promise = Api.fetchLoot(playerId)
+             .then(data => data.forEach(
+                item => {
+                  if (this.debug) console.log("add looted item", item, playerId)
+                  this.state.player_loot[playerId].push(item)
+                }
+             ));
+          promises.push(promise);
+        }
+        Promise.all(promises).then(_ => this.state.initiated = true);
+    },
+    // User actions
+    // Sets a new active player by id
+    setActivePlayer (newPlayerId) {
+        if (this.debug) console.log('setActivePlayer to ', newPlayerId)
+        this.state.player_id = newPlayerId
+        document.cookie = `player_id=${newPlayerId};`;
+    },
+    // Show/Hide player's chest
+    switchPlayerChestVisibility () {
+        if (this.debug) console.log('switchPlayerChestVisibility', !this.state.show_player_chest)
+        this.state.show_player_chest = !this.state.show_player_chest
+    },
+    // TODO
+    // get the content of a player Chest, retrieve form cache or fetched
+    // will replace hack that loads *all* chest...
+    getPlayerLoot (playerId) {
+
+    },
+    updatePlayerWealth (goldValue) {
+        return Api.updateWealth(this.state.player_id, goldValue)
+          .then(done => {
+            if (done.executed) {
+              // Update player wealth
+              var diff = done.response;
+              if (this.debug) console.log('updatePlayerWealth', diff)
+              this.state.player_list[this.state.player_id].cp += diff[0];
+              this.state.player_list[this.state.player_id].sp += diff[1];
+              this.state.player_list[this.state.player_id].gp += diff[2];
+              this.state.player_list[this.state.player_id].pp += diff[3];
+            }
+            return done.executed;
+          });
+    },
+    // Put a claim on an item from group chest.
+    putRequest (itemId) {
+        const playerId = this.state.player_id
+        Api.putClaim(playerId, itemId)
+           .then(done => {
+              if (done.executed) {
+                // Update cliend-side state
+                this.state.player_claims[playerId].push(itemId);
+              } else {
+                if (this.debug) console.log("API responded with 'false'")
+              }
+           });
+    },
+    // Withdraws a claim.
+    cancelRequest(itemId) {
+        const playerId = this.state.player_id
+        Api.unClaim(playerId, itemId)
+          .then(done => {
+              if (done.executed) {
+                var idx = this.state.player_claims[playerId].indexOf(itemId);
+                if (idx > -1) {
+                    this.state.player_claims[playerId].splice(idx, 1);
+                } else {
+                    if (this.debug) console.log("cancel a non-existent request")
+                }
+              } else {
+                if (this.debug) console.log("API responded with 'false'")
+              }
+          });
+    }
+}
+

lootalot_front/src/components/Chest.vue

@@ -0,0 +1,168 @@
+<template>
+  <div class="container is-paddingless">
+    <div v-if="mainControlsDisplayed" 
+         class="columns is-mobile is-vcentered"
+      >
+      <div class="column is-narrow">
+        <span class="icon is-large">
+          <i class="fas fa-2x fa-dragon"></i>
+          </span>
+        </div>
+      <div class="column has-text-left">
+        <h1 class="title">Coffre de groupe</h1>
+        </div>
+      <div class="column" v-show="canAdd">
+        <div v-show="mainControlsDisplayed" class="buttons is-right">
+          <button v-if="canAdd" 
+            class="button is-inverted is-info"
+            @click="is_adding = true"
+            >
+            <span class="icon">
+              <i class="fas fa-box-open"></i>
+            </span>
+            <p>Nouveau loot</p>
+            </button>
+          <button class="button is-inverted is-primary">
+            <span class="icon">
+              <i class="fas fa-coins"></i>
+              </span>
+            <p>Tout vendre</p>
+            </button>
+          </div>
+        </div>
+      </div>
+    <Loot v-if="is_adding" @done="is_adding = false"></Loot>
+    <table v-else class="table is-fullwidth is-striped" >
+      <thead>
+        <tr>
+          <th>Objets de {{ player }}</th>
+          <th v-if="canGrab"></th>
+          <th v-if="canSell">
+            <div class="buttons is-right">
+              <button class="button" 
+                  :class="is_selling ? 'is-danger' :  'is-warning'"
+                  @click="is_selling = !is_selling"
+                >
+                <span class="icon">
+                  <i class="fas fa-coins"></i>
+                </span>
+                <p v-if="!is_selling">
+                  Vendre</p>
+                <p v-else>
+                  {{ totalSellValue ? totalSellValue : 'Annuler' }}</p>
+                </button>
+                <PercentInput v-show="is_selling">
+                  </PercentInput>
+              </div>
+            </th>
+          </tr>
+        </thead>
+      <tbody>
+        <template v-for="(item, idx) in content">
+          <tr :key="`row-${idx}`">
+            <td>{{item.name}}</td>
+            <td v-if="canGrab">
+              <Request :item="item.id"></Request>
+              </td>
+            <td v-if="canSell">
+              <div class="field is-grouped is-pulled-right" v-show="is_selling">
+                <div class="control">
+                  <label class="label">
+                    <input type="checkbox" 
+                        id="`item-${idx}`" 
+                        :value="item.id"
+                        v-model="sell_selected">
+                      {{item.base_price / 2}} GP
+                    </label>
+                  </div>
+                <PercentInput></PercentInput>
+                </div>
+              </td>
+            </tr>
+          </template>
+        </tbody>
+      </table>
+    </div>
+</template>
+
+<script>
+    import { AppStorage } from '../AppStorage'
+    import Request from './Request.vue'
+    import PercentInput from './PercentInput.vue'
+    import Loot from './Loot.vue'
+    /*
+        The chest displays the collection of items owned by a player
+
+        TO TEST :
+            - Possible interactions depends on player_id and current chest
+            - Objects are displayed as a table
+
+        Sell workflow :
+            1. Click sell (sell becomes danger)
+            2. Check objects to sell (sell button displays total value)
+            3. Click sell to confirm
+    */
+    export default {
+        props: {
+            player: {
+                type: Number,
+                required: true,
+                default: 0
+            }
+        },
+        components: {
+            Request,
+            PercentInput,
+            Loot,
+        },
+        data () {
+            return {
+                app_state: AppStorage.state,
+                is_selling: false,
+                is_adding: false,
+                sell_selected: [],
+            };
+        },
+        methods: {
+       	    fetchLoot () {
+
+       	    }
+        },
+        computed: {
+            content () {
+            	const playerId = this.player;
+            	console.log("Refresh chest of", playerId);
+            	return this.app_state.player_loot[playerId];
+            },
+            // Can the active user sell items from this chest ?
+            canSell () {
+                return this.player == this.app_state.player_id;
+            },
+            totalSellValue () {
+                const selected = this.sell_selected;
+                return this.content
+                    .filter(item => selected.includes(item.id))
+                    .map(item => item.base_price / 2)
+                    .reduce((total,value) => total + value, 0);
+            },
+            // Can the user grab items from this chest ?
+            canGrab () {
+                return (this.app_state.player_id != 0  // User is not the group
+                     && this.player == 0);  // This is the group chest
+            },
+            canAdd () {
+                return (this.app_state.player_id == 0 
+                    && this.player == 0);
+            },
+            // The main controls are only displayed on group chest
+            mainControlsDisplayed () {
+                return (this.player == 0 
+                     && !this.is_adding);
+            }
+        },
+    }
+</script>
+
+<style scoped>
+    .table td, .table th { vertical-align: middle; }
+</style>

lootalot_front/src/components/ItemInput.vue

@@ -0,0 +1,93 @@
+<template>
+<div class="container is-paddingless">
+  <div class="field has-addons">
+    <div class="control is-expanded" 
+        :class="{'is-loading': is_loading }">
+      <input type="text" 
+        v-model="search"
+        @input="autoCompletion" 
+        class="input" 
+       :class="{'is-danger': no_results, 
+                'is-warning': auto_open}"
+        autocomplete="on">
+        </input>
+      </div>
+    <div class="control">
+      <button class="button is-primary"
+        :disabled="no_results"
+        @click="addItem"
+        >+</button>
+      </div>
+    </div>
+    <div class="dropdown" :class="{'is-active': auto_open}">
+      <div class="dropdown-menu">
+        <div class="dropdown-content">
+            <a v-for="(result,i) in results" :key="i"
+              @click="setResult(result.name)"
+              class="dropdown-item"
+              >
+              {{ result.name }}
+              </a>
+            </div>
+            </div>
+      </div>
+  </div>
+</template>
+
+<script>
+    // List of items for autocomplete
+    const MOCK_ITEMS = [
+        {id: 35, name: "Cape d'invisibilité", sell_value: 30000}, 
+        {id: 8, name: "Arc long", sell_value: 10}, 
+    ];
+ 
+    export default {
+        data () {
+            return {
+                is_loading: false,
+                no_results: false,
+                search: '',
+                results: [],
+                auto_open: false,
+            };
+        },
+        methods: {
+            autoCompletion (ev) {
+                // TODO: a lot happens here that
+                //       need to be clarified
+                if (this.search == '') {
+                    this.auto_open = false;
+                    this.results = [];
+                    this.no_results = false;
+                } else {
+                    this.results = MOCK_ITEMS.filter(item => {
+                        return item.name.includes(this.search);
+                    });
+                    // Update status 
+                    if (this.results.length == 0) {
+                        this.no_results = true;
+                    } else {
+                        this.no_results = false;
+                        this.auto_open = true;
+                    }
+                }
+            },
+            setResult(result) {
+                this.search = result;
+                this.auto_open = false;
+            },
+            addItem () {
+                this.$emit("addItem", this.search);        
+                this.search = '';
+                this.results = [];
+                this.no_results = false;
+                this.auto_open = false;
+            }
+        },
+    }
+</script>
+
+<style scoped>
+    .dropdown, .dropdown-menu { min-width: 100%; margin-top: 0; padding-top: 0;}
+    .dropdown { top: -0.75rem; }
+</style>

lootalot_front/src/components/Loot.vue

@@ -0,0 +1,42 @@
+<template>
+    <div class="card is-shadowless">
+        <div class="card-header">
+          <p class="card-header-title">
+            Nouveau loot - {{ looted.length }} objet(s)</p>
+          </div>
+        <div class="card-content">
+          <ItemInput @addItem="onAddItem"></ItemInput>
+          <p v-for="(item, idx) in looted" :key="idx"
+             class="has-text-left is-size-5">
+            {{ item }}
+          </p>
+          </div>
+        <div class="card-footer">
+          <div class="card-footer-item buttons is-center">
+            <a class="button is-primary">Confirmer</a>
+            <a @click="onClose" class="button is-danger">Annuler</a>
+            </div>
+          </div>
+      </div>
+</template>
+
+<script>
+    import ItemInput from './ItemInput.vue'
+
+    export default {
+        components: { ItemInput },
+        data () { return {
+            looted: [],
+        }; 
+        },
+        methods: {
+            onAddItem (item) {
+                this.looted.push(item);
+            },
+            onClose () {
+                this.$emit('done');
+            },
+        }
+
+    }
+</script>

lootalot_front/src/components/NumberInput.vue

@@ -0,0 +1,27 @@
+<template>
+    <input type="text" 
+        class="input" 
+        :class="{'is-danger': has_error}"
+        :value="value"
+        @input="checkError"
+    ></input>
+</template>
+
+<script>
+    export default {
+        props: ["value"],
+        data () {
+            return { has_error: false};
+        },
+        methods: {
+            checkError (ev) {
+                const newValue = ev.target.value;
+                this.has_error = isNaN(newValue);
+	        this.$emit(
+	            'input',
+	            this.has_error ? 0 : Number(newValue)
+	        );
+            }
+        },
+    }
+</script>

lootalot_front/src/components/PercentInput.vue

@@ -0,0 +1,28 @@
+<template>
+        <div class="field has-addons">
+          <div v-show="is_opened" class="control has-icons-left">
+            <input class="input is-small" type="number" size="3" min=-50 max=50 step=5>
+            <span class="icon is-small is-left">
+              <i class="fas fa-percent"></i>
+            </span>
+          </div>
+          <div class="control">
+            <button class="button is-small is-outlined"
+              @click="is_opened = !is_opened"
+            >
+              <small v-if="!is_opened">Mod.</small>
+              <span v-else class="icon"><i class="fas fa-times-circle"></i></span>
+            </button>
+          </div>
+        </div>
+</template>
+
+<script>
+    export default {
+        data () {
+            return {
+                is_opened: false,
+            };
+        }
+    }
+</script>

lootalot_front/src/components/Player.vue

@@ -0,0 +1,165 @@
+<template>
+  <div class="column is-one-third-desktop">
+    <div id="sidebar" class="card">
+      <header id="sidebar-heading" class="card-header">
+        <p class="card-header-title">
+          {{ app_state.initiated ? player.name : "..." }}</p>
+        <div class="dropdown is-right"
+            :class="{ 'is-active': show_dropdown }">
+          <div class="dropdown-trigger" ref="dropdown_btn">
+            <a id="change_player" class="card-header-icon"
+               @click="show_dropdown = !show_dropdown"
+               aria-haspopup="true" aria-controls="dropdown-menu">
+              <span class="icon is-small">
+                <i class="fas fa-exchange-alt"></i>
+              </span>
+            </a>
+          </div>
+          <div class="dropdown-menu" id="dropdown-menu" role="menu"
+            v-closable="{ exclude: ['dropdown_btn'], handler: 'closeDropdown', visible: show_dropdown }">
+            <div class="dropdown-content" v-if="app_state.initiated">
+              <a v-for="(p,i) in app_state.player_list" :key="i"
+                 @click="setActivePlayer(i)" 
+                 href="#" class="dropdown-item">
+                {{ p.name }}</a>
+              </div>
+            </div>
+          </div>
+        </header>
+      <div class="card-content">
+      <Wealth :wealth="wealth" :debt="player.debt"></Wealth>
+      <div class="box is-shadowless" v-show="!playerIsGroup">
+      	 <div class="columns is-vcentered" @click="switchPlayerChestVisibility">
+      	   <div class="column is-one-fifth">
+		<span class="icon is-large">
+		<i class="fas fa-2x fa-box"></i>
+		</span>
+	   </div>
+	   <div class="column if-four-fifth has-text-left">
+	     <p class="is-size-3">Coffre</p>
+	   </div>
+	 </div>
+      </div>
+	 <Chest :player="app_state.player_id"
+	   v-show="app_state.show_player_chest">
+	   </Chest>
+      <a href="#" class="button is-link is-fullwidth is-hidden" disabled>Historique</a>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+    import { AppStorage } from '../AppStorage'
+    import Chest from './Chest.vue'
+    import Wealth from './Wealth.vue'
+    /*
+    The Player control board.
+    To test :
+        - Player name is displayed
+        - Player's wealth is displayed -> Inside Wealth component
+        - Dropdown:
+            - The first item is the group
+            - Opened by activator
+            - Closed when clicked outside
+            - Click on item does switch active player
+        - Switch player :
+            - Name is updated when player_id is updated
+            - Wealth is updated -> Inside Wealth component
+        - Chest button controls Chest visibility
+            
+    */
+    let handleOutsideClick;
+    export default {
+        components: { Chest, Wealth },
+        data () {
+            return {
+                app_state: AppStorage.state,
+                show_dropdown: false,
+                edit_wealth: false,
+                handleOutsideClick: null,
+            };
+        },
+        computed: {
+            player () {
+            	if (!this.app_state.initiated) return {}
+                const idx = this.app_state.player_id;
+                return this.app_state.player_list[idx];
+            },
+            wealth () {
+            	if (!this.app_state.initiated) {
+            	    return ["-", "-", "-", "-"];
+            	} else {
+		    const cp = this.player.cp
+		    const sp = this.player.sp
+		    const gp = this.player.gp
+		    const pp = this.player.pp
+		    return [cp, sp, gp, pp];
+		}
+            },
+            // Check if the active player is the special 'Group' player
+            playerIsGroup () {
+                return this.app_state.player_id == 0;
+            }
+        },
+        methods: {
+            switchPlayerChestVisibility () {
+                AppStorage.switchPlayerChestVisibility();
+            },
+            hidePlayerChest () {
+                if (this.app_state.show_player_chest) {
+                    this.switchPlayerChestVisibility();
+                }
+            },
+            setActivePlayer (playerIdx) {
+            	var playerIdx = Number(playerIdx);
+                AppStorage.setActivePlayer(playerIdx);
+                if (playerIdx == 0) { this.hidePlayerChest() }
+            },
+            closeDropdown () {
+                this.show_dropdown = false
+            }
+        },
+        directives: {
+            'closable': {
+                bind: function(el, binding, vnode) { 
+                    handleOutsideClick = (e) => {
+                        e.stopPropagation();
+                        const { exclude, handler } = binding.value;
+                        let excludedElClicked = false;
+                        exclude.forEach(refName => {
+                            if (!excludedElClicked) {
+                                const elt = vnode.context.$refs[refName];
+                                excludedElClicked = elt.contains(e.target);
+                            }
+                        });
+                    
+                        if (!excludedElClicked) {
+                            console.log('outsideCloseDropdown');
+                            vnode.context[handler]()
+                        }
+                    };
+                },
+                // Bind custom handler only when dropdown is visible
+                update: function(el, binding, vnode, _) {
+                    const { visible } = binding.value;
+                    if (visible) {
+                        document.addEventListener('click', handleOutsideClick);
+                        document.addEventListener('touchstart', handleOutsideClick);
+                    } else {
+                        document.removeEventListener('click', handleOutsideClick);
+                        document.removeEventListener('touchstart', handleOutsideClick);
+                    }
+                },
+                unbind: function() { console.log("unbind"); 
+                    document.removeEventListener('click', handleOutsideClick);
+                    document.removeEventListener('touchstart', handleOutsideClick);
+                }
+            }
+        }
+    }
+</script>
+
+<style scoped>
+  .fa-exchange-alt.disabled { opacity: 0.4; }
+</style>

lootalot_front/src/components/Request.vue

@@ -0,0 +1,81 @@
+<template>
+  <div class="buttons is-right" >
+    <template v-if="isInConflict">
+      <button class="button is-success" 
+            @click="cancelRequest"
+        >
+          <span class="icon is-small">
+            <i class="fas fa-hand-peace"></i>
+          </span>
+        </button>
+        <button class="button is-danger" 
+            @click="hardenRequest"
+          >
+          <span class="icon is-small">
+            <i class="fas fa-hand-middle-finger"></i>
+          </span>
+        </button>
+    </template>
+    <button class="button is-primary" 
+        @click="putRequest"
+        :class="{'is-outlined': isRequested}"
+        :disabled="isRequested"
+    >
+      <span class="icon is-small">
+        <i class="fas fa-praying-hands"></i>
+      </span>
+    </button>
+  </div>
+</template>
+
+<script>
+    import { AppStorage } from '../AppStorage'
+    export default {
+        props: ["item"],
+        data () { 
+            return {
+                state: AppStorage.state,
+            };
+        },
+        computed: {
+            // Check if item is requested by active player
+            isRequested () {
+                const reqs = this.state.player_claims[this.state.player_id];
+                return reqs.includes(this.item);
+            },
+            // Check if item is requested by multiple players including active one
+            isInConflict () {
+                const reqs = this.state.player_claims;
+                const playerId = this.state.player_id;
+                var reqByPlayer = false;
+                var reqByOther = false;
+                for (var key in reqs) {
+                    const isReq = reqs[key].includes(this.item);
+                    if (isReq) {
+                        if (key == playerId) {
+                            reqByPlayer = true;
+                        } else {
+                            reqByOther = true;
+                        }
+                    }
+                }
+                return reqByPlayer && reqByOther;
+            },
+        },
+        methods: {
+            // The active player claims the item
+            putRequest () {
+                AppStorage.putRequest(this.item)
+            },
+            // The active player withdraws his request
+            cancelRequest () {
+                AppStorage.cancelRequest(this.item)
+            },
+            // The active player insist on his claim
+            // TODO: Find a simple and fun system to express
+            //       how much each player want an item
+            hardenRequest () {
+            }
+        },
+    }
+</script>

lootalot_front/src/components/Wealth.vue

@@ -0,0 +1,92 @@
+<template>
+  <div class="box is-shadowless">
+    <nav class="columns is-mobile is-multiline is-vcentered">
+      <div class="column">
+	<span class="icon is-large"
+	  @click="edit = !edit">
+	  <i class="fas fa-2x fa-piggy-bank"></i>
+	  </span>
+	<p v-if="debt" class="has-text-danger">-{{ debt }}gp </p>
+	</div>
+      <div class="column has-text-info">
+        <p class="heading">PP</p>
+        <p class="is-size-4">{{ wealth[3] }}</p>
+      	</div>
+      <div class="column has-text-warning">
+        <p class="heading">PO</p>
+        <p class="is-size-4">{{ wealth[2] }}</p>
+      	</div>
+      <div class="column has-text-grey">
+        <p class="heading">PA</p>
+        <p class="is-size-4">{{ wealth[1] }}</p>
+        </div>
+      <div class="column has-text-grey">
+        <p class="heading">PC</p>
+        <p class="is-size-4">{{ wealth[0] }}</p>
+        </div>
+      </nav>
+    <div v-if="edit"> <!-- or v-show ? -->
+    <nav class="columns is-mobile">
+      <div class="column">
+    	<NumberInput v-model="edit_value"></NumberInput>
+    	</div>
+      <div class="column is-2">
+        <button class="button is-outlined is-fullwidth is-danger"
+            @click="updateWealth('minus')">
+          <span class="icon"><i class="fas fa-2x fa-minus"></i></span>
+        </button>
+        </div>
+      <div class="column is-2">
+        <button class="button is-outlined is-primary is-fullwidth"
+            @click="updateWealth('plus')">
+          <span class="icon"><i class="fas fa-2x fa-plus"></i></span>
+        </button>
+        </div>
+      </nav>
+    </div>
+  </div>
+</template>
+
+<script>
+    import { AppStorage } from '../AppStorage.js'
+    import NumberInput from './NumberInput.vue'
+    export default {
+        components: { NumberInput },
+        props: ["wealth", "debt"],
+        data () { 
+            return {
+            	edit: false,
+                edit_value: 0,
+            }; 
+        },
+        methods: {
+            updateWealth (op) {
+            	var goldValue;
+            	switch (op) {
+            	  case 'plus':
+            	    goldValue = this.edit_value;
+            	    break;
+            	  case 'minus':
+            	    goldValue = -this.edit_value;
+            	    break;
+            	  default:
+            	    console.log("Error, bad operator !", op);
+            	    return;
+            	}
+                AppStorage.updatePlayerWealth(goldValue)
+                    .then(done => {
+                   	if (done) {
+		            this.$emit('updated');
+		            this.resetValues();
+		        } else {
+		            console.log('correct errors');
+		        }
+                    });
+            },
+            resetValues () {
+            	this.edit = false;
+                this.edit_value = 0;
+            }
+        }
+    }
+</script>

lootalot_front/src/main.js

@@ -0,0 +1,8 @@
+import Vue from 'vue'
+import App from './App.vue'
+
+Vue.config.productionTip = false
+
+new Vue({
+  render: h => h(App),
+}).$mount('#app')

src/api.rs

@@ -1,323 +0,0 @@
-use diesel::connection::Connection;
-use lootalot_db::{self as db, DbConnection, Update, Value};
-use std::collections::HashSet;
-
-pub type IdList = Vec<i32>;
-pub type ItemListWithMods = Vec<(i32, Option<f64>)>;
-pub type ItemList = Vec<db::Item>;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct BuySellParams {
-    pub items: ItemListWithMods,
-    players: Option<IdList>,
-    global_mod: Option<f64>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct NewGroupLoot {
-    source_name: String,
-    // claims_limit_date: String
-    pub items: ItemList,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct NewPlayer {
-    name : String,
-    wealth : f64,
-}
-
-/// A generic response for all queries
-#[derive(Serialize, Debug, Default)]
-pub struct ApiResponse {
-    /// The value requested, if any
-    pub value: Option<Value>,
-    /// A text to notify user, if relevant
-    pub notification: Option<String>,
-    /// A list of updates, if any
-    pub updates: Option<Vec<Update>>,
-    /// A text describing errors, if any
-    pub errors: Option<String>,
-}
-
-impl ApiResponse {
-    fn push_update(&mut self, update: db::Update) {
-        if let Some(v) = self.updates.as_mut() {
-            v.push(update);
-        } else {
-            self.updates = Some(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());
-        } else {
-            self.errors = Some(error.into())
-        }
-    }
-
-    fn set_value(&mut self, value: db::Value) {
-        self.value = Some(value);
-    }
-
-    fn notify<S: Into<String>>(&mut self, text: S) {
-        self.notification = Some(text.into());
-    }
-}
-
-pub enum ApiError {
-    DieselError(diesel::result::Error),
-    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 fn execute(
-    conn: &DbConnection,
-    query: ApiActions,
-) -> 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 {
-        ApiActions::CheckItemList(names) => {
-            let (items, errors) = {
-                let mut found = Vec::new();
-                let mut errors = String::new();
-                let items = db::Inventory(conn).all()?;
-                for name in &names {
-                    if let Some(item) = items.iter().filter(|i| &i.name == name).take(1).next() {
-                        found.push(item.clone())
-                    } else {
-                        errors.push_str(&format!("{},\n", name));
-                    }
-                }
-                (found, errors)
-            };
-
-            response.set_value(Value::ItemList(items));
-            response.push_error(errors);
-            dbg!(&names, &response);
-            None
-        }
-        ApiActions::FetchPlayers => {
-            response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?));
-            None
-        }
-        ApiActions::FetchInventory => {
-            response.set_value(Value::ItemList(db::Inventory(conn).all()?));
-            None
-        }
-        ApiActions::FetchShopInventory => {
-            response.set_value(Value::ItemList(db::Shop(conn).all()?));
-            None
-        }
-        ApiActions::FetchClaims => {
-            response.set_value(Value::ClaimList(db::Claims(conn).all()?));
-            None
-        }
-        ApiActions::FetchPlayer(id) => {
-            response.set_value(Value::Player(db::Players(conn).find(id)?));
-            None
-        }
-        ApiActions::FetchPlayerClaims(id) => {
-            response.set_value(Value::ClaimList(db::Claims(conn).by_player(id)?));
-            None
-        }
-        ApiActions::FetchNotifications(id) => {
-            response.set_value(Value::Notifications(
-                db::AsPlayer(conn, id).notifications()?,
-            ));
-            None
-        }
-        ApiActions::FetchLoot(id) => {
-            response.set_value(Value::ItemList(db::LootManager(conn, id).all()?));
-            None
-        }
-        ApiActions::UpdateWealth(id, amount) => {
-            response.push_update(db::AsPlayer(conn, id).update_wealth(amount)?);
-            response.notify(format!("Mis à jour ({}po)!", amount));
-            Some((id, "Argent mis à jour"))
-        }
-        ApiActions::BuyItems(id, params) => {
-            // TODO: check that player has enough money !
-            let has_enough_gold = true;
-
-            if has_enough_gold {
-                let mut gains: Vec<db::Wealth> = Vec::with_capacity(params.items.len());
-                for (item_id, price_mod) in params.items.into_iter() {
-                    if let Ok((item, diff)) = db::buy_item_from_shop(conn, id, item_id, price_mod) {
-                        response.push_update(item);
-                        gains.push(diff);
-                    } else {
-                        response.push_error(format!("Error adding {}", item_id));
-                    }
-                }
-                let added_items = gains.len();
-                let total_amount = gains
-                    .into_iter()
-                    .fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
-                response.notify(format!(
-                    "{} objets achetés pour {}po",
-                    added_items,
-                    total_amount.to_gp()
-                ));
-                response.push_update(Update::Wealth(total_amount));
-                Some((id, "Achat d'objets"))
-            } else {
-                response.push_error("Vous n'avez pas assez d'argent !");
-                None
-            }
-        }
-        // Behavior differs if player is group or regular.
-        // Group sells item like players then split the total amount among players.
-        ApiActions::SellItems(id, params) => {
-            conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
-                let mut gains: Vec<db::Wealth> = Vec::with_capacity(params.items.len());
-                for (loot_id, price_mod) in params.items.iter() {
-                    if let Ok((deleted, diff)) =
-                        db::sell_item_transaction(conn, id, *loot_id, *price_mod)
-                    {
-                        response.push_update(deleted);
-                        gains.push(diff);
-                    } else {
-                        response
-                            .push_error(format!("Erreur lors de la vente (loot_id : {})", loot_id));
-                    }
-                }
-                let sold_items = gains.len();
-                let total_amount = gains
-                    .into_iter()
-                    .fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
-                match id {
-                    0 => {
-                        let players = params.players.unwrap_or_default();
-                        if let Update::Wealth(shared) =
-                            db::split_and_share(conn, total_amount.to_gp() as i32, players)?
-                        {
-                            response.notify(format!(
-                                "Les objets ont été vendus, les joueurs ont reçu (au total) {} po",
-                                shared.to_gp()
-                            ));
-                            response.push_update(Update::Wealth(total_amount - shared));
-                        };
-                    }
-                    _ => {
-                        response.notify(format!(
-                            "{} objet(s) vendu(s) pour {} po",
-                            sold_items,
-                            total_amount.to_gp()
-                        ));
-                        response.push_update(Update::Wealth(total_amount));
-                    }
-                }
-                Ok(Some((id, "Vente d'objets")))
-            })?
-        }
-        ApiActions::ClaimItems(id, items) => {
-            conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
-                let current_claims: HashSet<i32> = db::Claims(conn)
-                    .all()?
-                    .iter()
-                    .filter(|c| c.player_id == id)
-                    .map(|c| c.loot_id)
-                    .collect();
-                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)?);
-                }
-                // Claims to add
-                for item in new_claims.difference(&current_claims) {
-                    response.push_update(db::Claims(conn).add(id, *item)?);
-                }
-                Ok(None)
-            })?
-        }
-        ApiActions::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);
-                }
-                response.notify(format!("'{}' annulé(e)", name));
-            } else {
-                response.push_error("Aucune action trouvée")
-            };
-            None
-        }
-        // Group actions
-        ApiActions::AddLoot(data) => {
-            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);
-                    added_items += 1;
-                } else {
-                    response.push_error(format!("Error adding {:?}", item));
-                }
-            }
-            response.notify(format!("{} objets lootés !", added_items));
-            // Notify players through persistent notifications
-            if let Err(e) = db::Players(conn)
-                .notifiy_all("De nouveaux objets ont été ajoutés au coffre de groupe !")
-            {
-                response.push_error(format!("Erreur durant la notification : {:?}", e));
-            };
-            Some((0, "Nouveau loot"))
-        }
-        // Admin actions
-        ApiActions::RefreshShopInventory(items) => {
-            db::Shop(conn).replace_list(items)?;
-            response.notify("Inventaire du marchand renouvelé !");
-            None
-        }
-        ApiActions::AddPlayer(data) => {
-            db::Players(conn).add(&data.name, data.wealth)?;
-            response.notify("Joueur ajouté !");
-            None
-        }
-    };
-
-    // Store the event if it can be undone.
-    dbg!(&action_text);
-    if let Some((id, text)) = action_text {
-        db::models::history::insert_event(
-            conn,
-            id,
-            text,
-            response
-                .updates
-                .as_ref()
-                .expect("there should be updates in here !"),
-        )?;
-    }
-    // match _action_text -> Save updates in DB
-    Ok(response)
-}

src/main.rs

@@ -2,10 +2,8 @@ extern crate actix_web;
 extern crate dotenv;
 extern crate env_logger;
 extern crate lootalot_db;
-#[macro_use] extern crate serde;
 
 mod server;
-mod api;
 
 fn main() {
     std::env::set_var("RUST_LOG", "actix_web=info");

src/server.rs

@@ -1,40 +1,47 @@
 use actix_cors::Cors;
 use actix_files as fs;
-use actix_identity::{CookieIdentityPolicy, Identity, IdentityService, RequestIdentity};
+use actix_web::{web, App, Error, HttpResponse, HttpServer};
-use actix_service::{Service, Transform};
+use futures::Future;
-use actix_web::{
+use lootalot_db::{DbApi, Pool, QueryResult};
-    dev::{ServiceRequest, ServiceResponse},
-    http::{header, StatusCode},
-    middleware, web, App, Error, HttpResponse, HttpServer,
-};
-use futures::{
-    future::{ok, Either, FutureResult},
-    Future,
-};
-use serde_json;
 use std::env;
 
-use crate::api;
+type AppPool = web::Data<Pool>;
-use lootalot_db as db;
 
-type AppPool = web::Data<db::Pool>;
+/// Wraps call to the DbApi and process its result as a async HttpResponse
-type PlayerId = web::Path<i32>;
+///
-type ItemId = web::Json<i32>;
+/// Provides a convenient way to call the api inside a route definition. Given a connection pool,
-type IdList = web::Json<api::IdList>;
+/// access to the api is granted in a closure. The closure is called in a blocking way and should
-type BuySellParams = web::Json<api::BuySellParams>;
+/// return a QueryResult.
-type NewGroupLoot = web::Json<api::NewGroupLoot>;
+/// If the query succeeds, it's result is returned as JSON data. Otherwise, an InternalServerError
-
+/// is returned.
-type MaybeForbidden =
+///
-    actix_web::Either<Box<dyn Future<Item = HttpResponse, Error = Error>>, HttpResponse>;
+/// # Usage
-
+/// ```
-/// Wraps call to the database query and convert its result as a async HttpResponse
+///     (...)
-fn db_call(
+///     .route("path/to/",
+///         move |pool: web::Data<Pool>| {
+///             // user data can be processed here
+///             // ...
+///             db_call(pool, move |api| {
+///                 // ...do what you want with the api
+///             }
+///         }
+///     )
+/// ```
+pub fn db_call<
+    J: serde::ser::Serialize + Send + 'static,
+    Q: Fn(DbApi) -> QueryResult<J> + Send + 'static,
+>(
     pool: AppPool,
-    query: api::ApiActions,
+    query: Q,
 ) -> impl Future<Item = HttpResponse, Error = Error> {
     let conn = pool.get().unwrap();
-    web::block(move || api::execute(&conn, query)).then(|res| match res {
+    web::block(move || {
-        Ok(r) => HttpResponse::Ok().json(r),
+        let api = DbApi::with_conn(&conn);
+        query(api)
+    })
+    .then(|res| match res {
+        Ok(players) => HttpResponse::Ok().json(players),
         Err(e) => {
             dbg!(&e);
             HttpResponse::InternalServerError().finish()
@@ -42,283 +49,76 @@ fn db_call(
     })
 }
 
-fn restricted_to_group(id: i32, params: (AppPool, api::ApiActions)) -> MaybeForbidden {
+pub(crate) fn serve() -> std::io::Result<()> {
-    if id != 0 {
+    let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
-        actix_web::Either::B(HttpResponse::Forbidden().finish())
+    dbg!(&www_root);
-    } else {
+    let pool = lootalot_db::create_pool();
-        actix_web::Either::A(Box::new(db_call(params.0, params.1)))
-    }
-}
-
-struct RestrictedAccess;
-
-impl<S, B> Transform<S> for RestrictedAccess
-where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
-    S::Future: 'static,
-{
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
-    type Error = Error;
-    type InitError = ();
-    type Transform = RestrictedAccessMiddleware<S>;
-    type Future = FutureResult<Self::Transform, Self::InitError>;
-
-    fn new_transform(&self, service: S) -> Self::Future {
-        ok(RestrictedAccessMiddleware { service })
-    }
-}
-
-struct RestrictedAccessMiddleware<S> {
-    service: S,
-}
-
-impl<S, B> Service for RestrictedAccessMiddleware<S>
-where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
-    S::Future: 'static,
-{
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
-    type Error = Error;
-    type Future = Either<S::Future, FutureResult<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-        self.service.poll_ready()
-    }
-
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
-        let is_logged_in = req.get_identity().is_some();
-
-        if is_logged_in {
-            Either::A(self.service.call(req))
-        } else {
-            Either::B(ok(
-                req.into_response(HttpResponse::Forbidden().finish().into_body())
-            ))
-        }
-    }
-}
-
-fn configure_api(config: &mut web::ServiceConfig) {
-    use api::ApiActions as Q;
-    config.service(
-        web::scope("/api")
-            .wrap(RestrictedAccess)
-            .service(
-                web::scope("/players")
-                    .service(
-                        web::resource("/")
-                            .route(web::get().to_async(|pool| db_call(pool, Q::FetchPlayers)))
-                            .route(web::post().to_async(
-                                |pool, player: web::Json<api::NewPlayer>| {
-                                    db_call(pool, Q::AddPlayer(player.into_inner()))
-                                },
-                            )),
-                    ) // List of players
-                    .service(
-                        web::scope("/{player_id}")
-                            .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))
-                                }),
-                            )
-                            .service(
-                                web::resource("/claims")
-                                    .route(web::get().to_async(|pool, player: PlayerId| {
-                                        db_call(pool, Q::FetchPlayerClaims(*player))
-                                    }))
-                                    .route(web::post().to_async(
-                                        |pool, (player, data): (PlayerId, IdList)| {
-                                            db_call(pool, Q::ClaimItems(*player, data.into_inner()))
-                                        },
-                                    )),
-                            )
-                            .service(
-                                web::resource("/wealth")
-                                    //.route(web::get().to_async(...))
-                                    .route(web::put().to_async(
-                                        |pool, (player, data): (PlayerId, web::Json<f64>)| {
-                                            db_call(pool, Q::UpdateWealth(*player, *data))
-                                        },
-                                    )),
-                            )
-                            .service(
-                                web::resource("/loot")
-                                    .route(web::get().to_async(|pool, player: PlayerId| {
-                                        db_call(pool, Q::FetchLoot(*player))
-                                    }))
-                                    .route(web::put().to_async(
-                                        move |pool, (player, data): (PlayerId, BuySellParams)| {
-                                            db_call(pool, Q::BuyItems(*player, data.into_inner()))
-                                        },
-                                    ))
-                                    .route(web::post().to(
-                                        move |pool, (player, data): (PlayerId, NewGroupLoot)| {
-                                            restricted_to_group(
-                                                *player,
-                                                (pool, Q::AddLoot(data.into_inner())),
-                                            )
-                                        },
-                                    ))
-                                    .route(web::delete().to_async(
-                                        move |pool, (player, data): (PlayerId, BuySellParams)| {
-                                            db_call(pool, Q::SellItems(*player, data.into_inner()))
-                                        },
-                                    )),
-                            )
-                            .service(web::scope("/events").route(
-                                "/last",
-                                web::delete().to_async(|pool, player: PlayerId| {
-                                    db_call(pool, Q::UndoLastAction(*player))
-                                }),
-                            )),
-                    ),
-            )
-            .route(
-                "/claims",
-                web::get().to_async(|pool| db_call(pool, Q::FetchClaims)),
-            )
-            .service(
-                web::resource("/shop")
-                    .route(web::get().to_async(|pool| db_call(pool, Q::FetchShopInventory)))
-                    .route(
-                        web::post().to_async(|pool, items: web::Json<api::ItemList>| {
-                            db_call(pool, Q::RefreshShopInventory(items.into_inner()))
-                        }),
-                    ),
-            )
-            .service(
-                web::resource("/items")
-                    .route(
-                        web::get().to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)),
-                    )
-                    .route(web::post().to_async(
-                        move |pool: AppPool, items: web::Json<Vec<String>>| {
-                            db_call(pool, Q::CheckItemList(items.into_inner()))
-                        },
-                    )),
-            ),
-    );
-}
-
-#[derive(Deserialize)]
-struct AuthRequest {
-    key: String,
-}
-
-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
-enum SessionKind {
-    Player(i32),
-    Admin,
-}
-
-use std::collections::HashMap;
-
-fn check_key(key: &str, db: HashMap<&str, SessionKind>) -> Option<SessionKind> {
-    db.get(&key).map(Clone::clone)
-}
-
-fn login(id: Identity, key: web::Query<AuthRequest>) -> HttpResponse {
-    if let Some(session_kind) = check_key(
-        &key.key.to_string(),
-        [
-            ("0", SessionKind::Player(0)),
-            ("1", SessionKind::Player(1)),
-            ("2", SessionKind::Player(2)),
-            ("admin", SessionKind::Admin),
-        ]
-        .iter()
-        .cloned()
-        .collect::<HashMap<&str, SessionKind>>(),
-    ) {
-        id.remember(serde_json::to_string(&session_kind).expect("Serialize SessionKind error"));
-        HttpResponse::build(StatusCode::TEMPORARY_REDIRECT)
-            .header(header::LOCATION, "/")
-            .finish()
-    } else {
-        HttpResponse::Forbidden().finish()
-    }
-}
-
-fn logout(id: Identity) -> HttpResponse {
-    id.forget();
-    HttpResponse::build(StatusCode::TEMPORARY_REDIRECT)
-        .header(header::LOCATION, "/")
-        .finish()
-}
-
-/// This endpoint shall be called by client,
-/// at initialization, to retrieve the current
-/// logging session info.
-///
-/// # Returns
-///
-/// The player data if a player is logged in
-/// The admin data if the admin is logged in
-/// A Forbidden response otherwise
-fn enter_session(id: Identity, pool: AppPool) -> impl Future<Item = HttpResponse, Error = Error> {
-    let conn = pool.get().unwrap();
-    let logged: SessionKind = id
-        .identity()
-        .map(|s| serde_json::from_str(&s).expect("Deserialize SessionKind error"))
-        // This will fail, fastest way to handle
-        // unlogged case with web::block below
-        .unwrap_or(SessionKind::Player(-1));
-
-    web::block(move || {
-        api::execute(
-            &conn,
-            match logged {
-                SessionKind::Player(id) => api::ApiActions::FetchPlayer(id),
-                SessionKind::Admin => api::ApiActions::FetchPlayers,
-            },
-        )
-    })
-    .then(|res| match res {
-        Ok(r) => HttpResponse::Ok().json(r.value),
-        Err(e) => {
-            dbg!(&e);
-            HttpResponse::Forbidden().finish()
-        }
-    })
-}
-
-pub fn serve() -> std::io::Result<()> {
-    let domain: String = env::var("DOMAIN").expect("DOMAIN must be set");
-    let pool = db::create_pool();
-    println!("Serving Loot-a-lot on {}", domain);
-
-    let key = [0; 32]; // TODO: Use a real key
 
     HttpServer::new(move || {
         App::new()
             .data(pool.clone())
-            .configure(configure_api)
             .wrap(
                 Cors::new()
-                    .allowed_origin(&domain)
+                    .allowed_origin("http://localhost:8080")
-                    .allowed_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
+                    .allowed_methods(vec!["GET", "POST"])
                     .max_age(3600),
             )
-            .wrap(IdentityService::new(
+            .service(
-                CookieIdentityPolicy::new(&key)
+                web::scope("/api")
-                    .name("logged-in")
+                    .route(
-                    .secure(false),
+                        "/players",
-            ))
+                        web::get().to_async(move |pool: AppPool| {
-            //.wrap(middleware::Logger::default())
+                            db_call(pool, move |api| api.fetch_players())
-            .wrap(middleware::Logger::new("%r -> %s (%{User-Agent}i)"))
+                        }),
-            .route("/session", web::get().to_async(enter_session))
+                    )
-            .route("/login", web::get().to(login))
+                    .route(
-            .route("/logout", web::get().to(logout))
+                        "/claims",
-        //.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
+                        web::get().to_async(move |pool: AppPool| {
+                            db_call(pool, move |api| api.fetch_claims())
+                        }),
+                    )
+                    .route(
+                        "/{player_id}/update-wealth/{amount}",
+                        web::get().to_async(move |pool: AppPool, data: web::Path<(i32, f32)>| {
+                            db_call(pool, move |api| api.as_player(data.0).update_wealth(data.1))
+                        }),
+                    )
+                    .route(
+                        "/{player_id}/loot",
+                        web::get().to_async(move |pool: AppPool, player_id: web::Path<i32>| {
+                            db_call(pool, move |api| api.as_player(*player_id).loot())
+                        }),
+                    )
+                    .route(
+                        "/{player_id}/claim/{item_id}",
+                        web::get().to_async(move |pool: AppPool, data: web::Path<(i32, i32)>| {
+                            db_call(pool, move |api| api.as_player(data.0).claim(data.1))
+                        }),
+                    )
+                    .route(
+                        "/{player_id}/unclaim/{item_id}",
+                        web::get().to_async(move |pool: AppPool, data: web::Path<(i32, i32)>| {
+                            db_call(pool, move |api| api.as_player(data.0).unclaim(data.1))
+                        }),
+                    )
+                    .route(
+                        "/admin/resolve-claims",
+                        web::get().to_async(move |pool: AppPool| {
+                            db_call(pool, move |api| api.as_admin().resolve_claims())
+                        }),
+                    )
+                    .route(
+                        "/admin/add-player/{name}/{wealth}",
+                        web::get().to_async(
+                            move |pool: AppPool, data: web::Path<(String, f32)>| {
+                                db_call(pool, move |api| {
+                                    api.as_admin().add_player(data.0.clone(), data.1)
+                                })
+                            },
+                        ),
+                    ),
+            )
+            .service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
     })
     .bind("127.0.0.1:8088")?
     .run()