adds newtype

works on making event models work
blanket impl of Update.undo()
2019-10-28 00:22:28 +01:00 · 2019-10-27 21:56:24 +01:00 · 2019-10-27 16:20:11 +01:00 · 2019-10-27 16:13:29 +01:00 · 2019-10-27 15:53:01 +01:00 · 2019-10-27 15:52:46 +01:00
46 changed files with 4347 additions and 16667 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,11 +1,10 @@
 /target
 **/*.rs.bk

-node_modules
-fontawesome
-package-lock.json
-
 Cargo.lock
 **/*.sqlite3
 **/.env

+package-lock.json
+fontawesome
+
--- a/README.md
+++ b/README.md
@@ -6,47 +6,21 @@ Un gestionnaire de trésors pour des joueurs de Donjon&Dragons(tm).

 ## Fonctionnalités prévues

-  * Ajouter des objets "lootés"
-  * Répartir les objets entre les joueurs et le groupe
-  * Vendre les objets du groupe et répartir équitablement leur valeur entre les joueurs
-    * Possibilité d'indiquer une variation du prix de vente pour chaque objet ou globale
-  * Gérer les comptes du groupe et des joueurs
-  * Historique des transactions par propriétaire
+  * Ajouter des objets  
+    ☑ Acheter  
+    ☐ Ajouter un trésor (objet par objet ou par liste)  
+  * Répartir les objets entre les joueurs et le groupe  
+    ☑ Demander un objet  
+    ☐ Résoudre un conflit  
+    ☐ 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 ?_
-
--- a/lootalot_db/Cargo.toml
+++ b/lootalot_db/Cargo.toml
@@ -9,6 +9,7 @@ dotenv = "*"
 diesel_migrations = "*"
 serde = "*"
 serde_derive = "*"
+serde_json = "*"

 [dependencies.diesel]
 version = "1.4"
--- a/lootalot_db/db.sqlite3
+++ b/lootalot_db/db.sqlite3
--- a/lootalot_db/migrations/2019-10-19-194459_notifications/down.sql
+++ b/lootalot_db/migrations/2019-10-19-194459_notifications/down.sql
@@ -0,0 +1 @@
+DROP TABLE notifications;
--- a/lootalot_db/migrations/2019-10-19-194459_notifications/up.sql
+++ b/lootalot_db/migrations/2019-10-19-194459_notifications/up.sql
@@ -0,0 +1,6 @@
+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)
+);
--- a/lootalot_db/migrations/2019-10-27-135235_history/down.sql
+++ b/lootalot_db/migrations/2019-10-27-135235_history/down.sql
@@ -0,0 +1 @@
+DROP TABLE history;
--- a/lootalot_db/migrations/2019-10-27-135235_history/up.sql
+++ b/lootalot_db/migrations/2019-10-27-135235_history/up.sql
@@ -0,0 +1,8 @@
+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)
+);
--- a/lootalot_db/res/items.csv
+++ b/lootalot_db/res/items.csv
--- a/lootalot_db/src/lib.rs
+++ b/lootalot_db/src/lib.rs
@@ -13,10 +13,14 @@ 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},
+    item::{Item, LootManager, Inventory},
+    player::{Player, Wealth, Players, AsPlayer},
+};

 /// The connection used
 pub type DbConnection = SqliteConnection;
@@ -24,271 +28,6 @@ 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 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)
@@ -301,8 +40,160 @@ pub fn create_pool() -> Pool {
        .expect("Failed to create pool.")
 }

-#[cfg(test)]
-mod tests {
+
+/// Every possible update which can happen during a query
+#[derive(Serialize, Deserialize, Debug)]
+pub enum Update {
+    Wealth(Wealth),
+    ItemAdded(Item),
+    ItemRemoved(Item),
+    ClaimAdded(Claim),
+    ClaimRemoved(Claim),
+}
+
+impl Update {
+    /// Change back what has been updated
+    fn undo(self) -> QueryResult<()> {
+        match self {
+            Update::Wealth(diff) => {},
+            Update::ItemAdded(item) => {},
+            Update::ItemRemoved(item) => {},
+            Update::ClaimAdded(claim) => {},
+            Update::ClaimRemoved(claim) => {},
+        };
+        Ok(())
+    }
+}
+
+/// 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<(Item, Wealth)> {
+    conn.transaction(|| {
+        let deleted = LootManager(conn, id)
+            .remove(loot_id)?;
+        let mut sell_value = deleted.sell_value() as f64;
+        if let Some(modifier) = price_mod {
+            sell_value *= modifier;
+        }
+        let wealth = AsPlayer(conn, id)
+            .update_wealth(sell_value)?;
+        Ok((deleted, wealth))
+    })
+}
+
+/// 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<(Item, 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() as f64 * modifier,
+            None => item.value() as f64,
+        };
+        AsPlayer(conn, id)
+            .update_wealth(-sell_price)
+            .map(|diff| (new_item, diff))
+    })
+}
+
+/// Fetch all existing claims
+pub fn fetch_claims(conn: &DbConnection) -> QueryResult<Vec<models::Claim>> {
+    schema::claims::table.load::<models::Claim>(conn)
+}
+
+/// 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())?;
+        }
+        Ok(())
+    })
+}
+
+/// Split up and share group money among selected players
+pub fn split_and_share(conn: &DbConnection, amount: i32, players: Vec<i32>) -> QueryResult<Wealth> {
+    let share = (
+        amount / (players.len() + 1) as i32  // +1 share for the group
+    ) as f64;
+    conn.transaction(|| {
+        for p in players.into_iter() {
+            let player = Players(conn).find(p)?;
+            // Take debt into account
+            match share - player.debt as f64 {
+                rest if rest > 0.0 => {
+                    AsPlayer(conn, p).update_debt(-player.debt)?;
+                    AsPlayer(conn, p).update_wealth(rest)?;
+                    AsPlayer(conn, 0).update_wealth(-rest)?;
+                },
+                _ => {
+                    AsPlayer(conn, p).update_debt(-share as i32)?;
+                }
+            }
+        }
+        Ok(Wealth::from_gp(share))
+    })
+}
+
+
+
+#[cfg(none)]
+mod tests_old {
    use super::*;
    type TestConnection = DbConnection;

@@ -316,7 +207,7 @@ mod tests {
    /// When migrations are run, a special player with id 0 and name "Groupe"
    /// must be created.
    #[test]
-    fn test_group_is_autocreated() {
+    fn global_group_is_autocreated() {
        let conn = test_connection();
        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
        assert_eq!(players.len(), 1);
@@ -328,20 +219,19 @@ mod tests {
    /// 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 test_player_updates_wealth() {
+    fn as_player_updates_wealth() {
        let conn = test_connection();
        DbApi::with_conn(&conn)
            .as_admin()
-            .add_player("PlayerName".to_string(), 403.21)
+            .add_player("PlayerName", 403.21)
            .unwrap();
        let diff = DbApi::with_conn(&conn)
            .as_player(1)
            .update_wealth(-401.21)
-            .unwrap()
-            .response
-            .unwrap();
+            .ok();
        // Check the returned diff
-        assert_eq!(diff, (-1, -2, -1, -4));
+        assert_eq!(diff, Some((-1, -2, -1, -4)));
+        let diff = diff.unwrap();
        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
        let player = players.get(1).unwrap();
        // Check that we can add old value to return diff to get resulting value
@@ -352,13 +242,12 @@ mod tests {
    }

    #[test]
-    fn test_admin_add_player() {
+    fn as_admin_add_player() {
        let conn = test_connection();
        let result = DbApi::with_conn(&conn)
            .as_admin()
-            .add_player("PlayerName".to_string(), 403.21)
-            .unwrap();
-        assert_eq!(result.executed, true);
+            .add_player("PlayerName", 403.21);
+        assert_eq!(result.is_ok(), true);
        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
        assert_eq!(players.len(), 2);
        let new_player = players.get(1).unwrap();
@@ -370,56 +259,92 @@ mod tests {
    }

    #[test]
-    fn test_admin_resolve_claims() {
+    fn as_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 test_player_claim_item() {
+    fn as_player_claim_item() {
        let conn = test_connection();
        DbApi::with_conn(&conn)
            .as_admin()
-            .add_player("Player".to_string(), 0.0)
+            .add_player("Player", 0.0)
            .unwrap();
        DbApi::with_conn(&conn)
            .as_admin()
            .add_loot(vec![("Épée", 25)])
            .unwrap();
        // Claim an existing item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
-        assert_eq!(result.executed, true);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
+        assert_eq!(result.is_ok(), true);
        let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
        assert_eq!(claims.len(), 1);
        let claim = claims.get(0).unwrap();
        assert_eq!(claim.player_id, 1);
        assert_eq!(claim.loot_id, 1);
        // Claim an inexistant item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(2).unwrap();
-        assert_eq!(result.executed, false);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(2);
+        assert_eq!(result.is_ok(), false);
    }

    #[test]
-    fn test_player_unclaim_item() {
+    fn as_player_unclaim_item() {
        let conn = test_connection();
        DbApi::with_conn(&conn)
            .as_admin()
-            .add_player("Player".to_string(), 0.0)
+            .add_player("Player", 0.0)
            .unwrap();
        DbApi::with_conn(&conn)
            .as_admin()
            .add_loot(vec![("Épée", 25)])
            .unwrap();
        // Claim an existing item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
-        assert_eq!(result.executed, true);
-        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1).unwrap();
-        assert_eq!(result.executed, true);
-        // Check that unclaimed items will not be unclaimed...
-        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1).unwrap();
-        assert_eq!(result.executed, false);
+        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
+        assert_eq!(result.is_ok(), true);
+        // Claiming twice is an error
+        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
+        assert_eq!(result.is_ok(), false);
+        // Unclaiming and item
+        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
+        assert_eq!(result.is_ok(), true);
+        // Check that not claimed items will not be unclaimed...
+        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
+        assert_eq!(result.is_ok(), false);
        let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
        assert_eq!(claims.len(), 0);
    }
@@ -428,20 +353,25 @@ mod tests {
    ///
    /// 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 test_buy_sell_simple() {
+    fn as_player_simple_buy_sell() {
        let conn = test_connection();
+        // Adds a sword into inventory
+        {
+            use schema::items::dsl::*;
+            diesel::insert_into(items)
+                .values((name.eq("Sword"), base_price.eq(800)))
+                .execute(&conn)
+                .expect("Could not set up items table");
+        }
        DbApi::with_conn(&conn)
            .as_admin()
-            .add_player("Player".to_string(), 1000.0)
+            .add_player("Player", 1000.0)
            .unwrap();
        // Buy an item
-        let bought = DbApi::with_conn(&conn)
-            .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 bought = DbApi::with_conn(&conn).as_player(1).buy(&vec![(1, None)]);
+        assert_eq!(bought.ok(), Some((0, 0, 0, -8))); // Returns diff of player wealth ?
        let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
        assert_eq!(chest.len(), 1);
        let loot = chest.get(0).unwrap();
@@ -450,13 +380,16 @@ mod tests {
        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(loot.id, None)
-            .unwrap();
-        assert_eq!(sold.executed, true);
-        assert_eq!(sold.response, Some((0, 0, 0, 4)));
+            .sell(&vec![(loot.id, None)]);
+        assert_eq!(sold.ok(), Some((0, 0, 0, 4)));
        let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
        assert_eq!(chest.len(), 0);
        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
@@ -465,7 +398,7 @@ mod tests {
    }

    #[test]
-    fn test_admin_add_loot() {
+    fn as_admin_add_loot() {
        let conn = test_connection();
        assert_eq!(
            0,
@@ -474,9 +407,8 @@ mod tests {
        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())
-            .unwrap();
-        assert_eq!(result.executed, true);
+            .add_loot(loot_to_add.clone());
+        assert_eq!(result.is_ok(), true);
        let looted = DbApi::with_conn(&conn).as_player(0).loot().unwrap();
        assert_eq!(looted.len(), 2);
        // NB: Not a problem now, but this adds constraints of items being
--- a/lootalot_db/src/models/claim.rs
+++ b/lootalot_db/src/models/claim.rs
@@ -1,8 +1,11 @@
-use crate::models::item::Loot;
+use crate::{DbConnection, QueryResult};
+use diesel::prelude::*;
+
+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, Debug)]
+#[derive(Identifiable, Queryable, Associations, Serialize, Deserialize, Debug)]
 #[belongs_to(Loot)]
 pub struct Claim {
    /// DB Identifier
@@ -15,15 +18,150 @@ 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)
+    }
+
+    /// 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) -> QueryResult<Claim> {
+        // 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
+        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) -> QueryResult<Claim> {
+        let claim = self.find(player_id, loot_id)?;
+        claim.remove(self.0)?;
+        Ok(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 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"]
-pub(crate) struct NewClaim {
+struct NewClaim {
    player_id: i32,
    loot_id: i32,
 }

 impl NewClaim {
-    pub(crate) fn new(player_id: i32, loot_id: i32) -> Self {
+    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(())
+    }
+}
--- a/lootalot_db/src/models/history.rs
+++ b/lootalot_db/src/models/history.rs
@@ -0,0 +1,69 @@
+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>);
+
+/// An event in history
+#[derive(Debug, Queryable)]
+pub struct Event {
+    id: i32,
+    player_id: i32,
+    event_date: String,
+    text: String,
+    updates: Option<UpdateList>,
+}
+
+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
+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() {
+
+    }
+}
--- a/lootalot_db/src/models/item.rs
+++ b/lootalot_db/src/models/item.rs
@@ -1,38 +1,59 @@
-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};
+use crate::{DbConnection, QueryResult};
 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 unique item in inventory
-///
-/// 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)]
+/// Represents a basic item
+#[derive(Debug, Queryable, Serialize, Deserialize, Clone)]
 pub struct Item {
    pub id: i32,
    pub name: String,
-    pub base_price: i32,
+    base_price: i32,
 }

 impl Item {
-    /// Public proxy for Loot::owned_by that selects only Item fields
-    pub fn owned_by(player: i32) -> OwnedBy {
+    /// Returns this item value
+    pub fn value(&self) -> i32 {
+        self.base_price
+    }
+
+    /// Returns this item sell value
+    pub fn sell_value(&self) -> i32 {
+        self.base_price / 2
+    }
+
+    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)
+    }
+}
+
 type WithOwner = Eq<looted::owner_id, i32>;
 type OwnedLoot = Filter<looted::table, WithOwner>;

-/// Represents an item that has been looted
-#[derive(Identifiable, Debug, Queryable, Serialize)]
+/// Represents an item that has been looted,
+/// hence has an owner.
+#[derive(Identifiable, Debug, Queryable)]
 #[table_name = "looted"]
-pub(crate) struct Loot {
+pub(super) struct Loot {
    id: i32,
    name: String,
    base_price: i32,
@@ -41,21 +62,95 @@ pub(crate) struct Loot {

 impl Loot {
    /// A filter on Loot that is owned by given player
-    pub(crate) fn owned_by(id: i32) -> OwnedLoot {
+    pub(super) fn owned_by(id: i32) -> OwnedLoot {
        looted::table.filter(looted::owner_id.eq(id))
    }

-    pub(crate) fn owns(player: i32, item: i32) -> Exists<Find<OwnedLoot, i32>> {
-        exists(Loot::owned_by(player).find(item))
+    fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
+        exists(looted::table.find(id))
    }

-    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)
    }
 }

-/// Description of an item : (name, value in gold)
-pub type ItemDesc<'a> = (&'a str, i32);
+/// Manager for a *single* player loot
+pub struct LootManager<'q>(pub &'q DbConnection, pub 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) -> QueryResult<Item> {
+        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) -> QueryResult<Item> {
+        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)?;
+        self.last()
+    }
+
+    pub fn remove(self, item_id: i32) -> QueryResult<Item> {
+        let deleted = self.find(item_id)?;
+        diesel::delete(looted::table.find(deleted.id)).execute(self.0)?;
+        Ok(deleted)
+    }
+}

 /// An item being looted or bought.
 ///
@@ -63,28 +158,8 @@ pub type ItemDesc<'a> = (&'a str, i32);
 /// to the id of buying player otherwise.
 #[derive(Insertable)]
 #[table_name = "looted"]
-pub(crate) struct NewLoot<'a> {
+struct NewLoot<'a> {
    name: &'a str,
    base_price: i32,
    owner_id: i32,
 }
-
-impl<'a> NewLoot<'a> {
-    /// A new loot going to the group (loot procedure)
-    pub(crate) fn to_group(desc: ItemDesc<'a>) -> Self {
-        Self {
-            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,
-        }
-    }
-}
--- a/lootalot_db/src/models/mod.rs
+++ b/lootalot_db/src/models/mod.rs
@@ -1,8 +1,8 @@
-pub(super) mod claim;
-pub(super) mod item;
-pub(super) mod player;
+pub mod claim;
+pub mod item;
+pub mod player;
+pub mod history;

 pub use claim::Claim;
 pub use item::Item;
-pub(crate) use item::Loot;
 pub use player::{Player, Wealth};
--- a/lootalot_db/src/models/player/mod.rs
+++ b/lootalot_db/src/models/player/mod.rs
@@ -0,0 +1,123 @@
+use crate::schema::players;
+use crate::{DbConnection, QueryResult};
+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)
+    }
+
+    /// 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) -> QueryResult<Wealth> {
+        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(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,
+        }
+    }
+}
--- a/lootalot_db/src/models/player/notification.rs
+++ b/lootalot_db/src/models/player/notification.rs
@@ -0,0 +1,44 @@
+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,
+}
--- a/lootalot_db/src/models/player/wealth.rs
+++ b/lootalot_db/src/models/player/wealth.rs
@@ -1,26 +1,6 @@
 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
+/// Unpack a floating value of gold pieces to integer
 /// values of copper, silver, gold and platinum pieces
 ///
 /// # Note
@@ -28,7 +8,7 @@ pub struct Player {
 /// The conversion is slightly different than standard rules :
 /// ``` 1pp = 100gp = 1000sp = 10000 cp ```
 ///
-fn unpack_gold_value(gold: f32) -> (i32, i32, i32, i32) {
+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;
@@ -42,7 +22,7 @@ fn unpack_gold_value(gold: f32) -> (i32, i32, i32, i32) {
 ///
 /// Values are held as individual pieces counts.
 /// Allows conversion from and to a floating amount of gold pieces.
-#[derive(Queryable, AsChangeset, Debug)]
+#[derive(Queryable, AsChangeset, Serialize, Deserialize, Debug)]
 #[table_name = "players"]
 pub struct Wealth {
    pub cp: i32,
@@ -60,7 +40,7 @@ impl Wealth {
    /// let wealth = Wealth::from_gp(403.21);
    /// assert_eq!(wealth.as_tuple(), (1, 2, 3, 4));
    /// ```
-    pub fn from_gp(gp: f32) -> Self {
+    pub fn from_gp(gp: f64) -> Self {
        let (cp, sp, gp, pp) = unpack_gold_value(gp);
        Self { cp, sp, gp, pp }
    }
@@ -69,13 +49,13 @@ impl Wealth {
    /// # Examples
    /// ```
    /// # use lootalot_db::models::Wealth;
-    /// let wealth = Wealth{ pp: 4, gp: 3, sp: 2, cp: 1};
-    /// assert_eq!(wealth.to_gp(), 403.21);
+    /// let wealth = Wealth{ pp: 4, gp: 5, sp: 8, cp: 4};
+    /// assert_eq!(wealth.to_gp(), 405.84);
    /// ```
-    pub fn to_gp(&self) -> f32 {
+    pub fn to_gp(&self) -> f64 {
        let i = self.pp * 100 + self.gp;
-        let f = (self.sp * 10 + self.cp) as f32 / 100.0;
-        i as f32 + f
+        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) {
@@ -83,26 +63,30 @@ impl Wealth {
    }
 }

-/// 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 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 {
+            cp: self.cp - other.cp,
+            sp: self.sp - other.sp,
+            gp: self.gp - other.gp,
+            pp: self.pp - other.pp,
+        }
+    }
 }

-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,
+impl std::ops::Add for Wealth {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Wealth {
+            cp: self.cp + other.cp,
+            sp: self.sp + other.sp,
+            gp: self.gp + other.gp,
+            pp: self.pp + other.pp
        }
    }
 }
@@ -114,12 +98,16 @@ mod tests {
    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)),
        ];

--- a/lootalot_db/src/schema.rs
+++ b/lootalot_db/src/schema.rs
@@ -7,6 +7,16 @@ table! {
    }
 }

+table! {
+    history (id) {
+        id -> Integer,
+        player_id -> Integer,
+        event_date -> Timestamp,
+        text -> Text,
+        updates -> Nullable<Text>,
+    }
+}
+
 table! {
    items (id) {
        id -> Integer,
@@ -24,6 +34,14 @@ table! {
    }
 }

+table! {
+    notifications (id) {
+        id -> Integer,
+        player_id -> Integer,
+        text -> Text,
+    }
+}
+
 table! {
    players (id) {
        id -> Integer,
@@ -38,6 +56,15 @@ table! {

 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!(claims, items, looted, players,);
+allow_tables_to_appear_in_same_query!(
+    claims,
+    history,
+    items,
+    looted,
+    notifications,
+    players,
+);
--- a/lootalot_db/src/transactions.rs
+++ b/lootalot_db/src/transactions.rs
@@ -1,295 +0,0 @@
-//!  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;
-
-
-}
--- a/lootalot_front/.browserslistrc
+++ b/lootalot_front/.browserslistrc
@@ -0,0 +1,2 @@
+> 1%
+last 2 versions
--- a/lootalot_front/.eslintrc.js
+++ b/lootalot_front/.eslintrc.js
@@ -0,0 +1,27 @@
+module.exports = {
+  root: true,
+  env: {
+    node: true
+  },
+  'extends': [
+    'plugin:vue/essential',
+    'eslint:recommended'
+  ],
+  rules: {
+    'no-console': process.env.NODE_ENV === 'production' ? 'error' : 'off',
+    'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off'
+  },
+  parserOptions: {
+    parser: 'babel-eslint'
+  },
+  overrides: [
+    {
+      files: [
+        '**/__tests__/*.{j,t}s?(x)'
+      ],
+      env: {
+        mocha: true
+      }
+    }
+  ]
+}
--- a/lootalot_front/babel.config.js
+++ b/lootalot_front/babel.config.js
@@ -1,11 +1,5 @@
 module.exports = {
  presets: [
    '@vue/app'
-  ],
-  "presets": [["env", { "modules": false }]],
-  "env": {
-    "test": {
-      "presets": [["env", { "targets": { "node": "current" } }]]
-    }
-  }
+  ]
 }
--- a/lootalot_front/package-lock.json
+++ b/lootalot_front/package-lock.json
--- a/lootalot_front/package.json
+++ b/lootalot_front/package.json
@@ -3,12 +3,10 @@
  "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"
+    "test:unit": "vue-cli-service test:unit"
  },
  "main": "sass/scroll.scss",
  "dependencies": {
@@ -17,52 +15,15 @@
    "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",
+    "@vue/cli-plugin-babel": "^3.11.0",
+    "@vue/cli-plugin-eslint": "^3.11.0",
+    "@vue/cli-plugin-unit-mocha": "^3.11.0",
+    "@vue/cli-service": "^3.11.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",
+    "chai": "^4.1.2",
    "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"
-    }
  }
 }
--- a/lootalot_front/postcss.config.js
+++ b/lootalot_front/postcss.config.js
@@ -0,0 +1,5 @@
+module.exports = {
+  plugins: {
+    autoprefixer: {}
+  }
+}
--- a/lootalot_front/public/index.html
+++ b/lootalot_front/public/index.html
@@ -8,7 +8,7 @@
        <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>
+        <script defer src="<%= BASE_URL %>fontawesome/js/all.js"></script>
 </head>
 <body>
    <div id="app"></div>
--- a/lootalot_front/src/App.vue
+++ b/lootalot_front/src/App.vue
@@ -1,18 +1,98 @@
 <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>
+  <PlayerView
+    :id="player_id"
+    v-slot="{ player, loot, notifications, actions, claims }"
+  >
+    <main id="app" class="container">
+      <header>
+        <HeaderBar>
+          <template v-slot:title>
+            {{ player.name }}
+          </template>
+          <template v-slot:links>
+            <a class="navbar-item">History of Loot</a>
+            <template v-if="playerIsGroup">
+              <hr class="navbar-divider">
+              <div class="navbar-item heading">Admin</div>
+              <a class="navbar-item">"Resolve claims"</a>
+              <a class="navbar-item">"Add player"</a>
+            </template>
+            <hr class="navbar-divider">
+            <div class="navbar-item heading">Changer</div>
+            <a v-for="(p,i) in playerList" :key="i"
+              @click="setActivePlayer(i)"
+              href="#" class="navbar-item">
+              {{ p.name }}</a>
+          </template>
+        </HeaderBar>
+        <Wealth 
+            :wealth="[player.cp, player.sp, player.gp, player.pp]" 
+            :debt="player.debt"
+            @update="actions.updateWealth"
+        ></Wealth>
+        <p v-show="notifications.length > 0">{{ notifications }}</p>
+      </header>
+      <nav>
+        <div class="tabs is-centered is-boxed is-medium">
+          <ul>
+            <li :class="{ 'is-active': activeView == 'group' }">
+              <a @click="switchView('group')">
+                Coffre de groupe
+              </a>
+            </li>
+            <li v-show="!playerIsGroup" :class="{ 'is-active': activeView == 'player' }">
+              <a @click="switchView('player')">
+                Mon coffre
+              </a>
+            </li>
+            <li :class="{'is-active': activeView == 'adding' }">
+              <a class="has-text-grey-light"
+                 @click="switchView('adding')">
+                + {{ playerIsGroup ? 'Nouveau Loot' : 'Acheter' }}
+              </a>
+            </li>
+           </ul>
+        </div>
+      </nav>
+      <main class="section">
+        <template v-if="isAdding">
+          <Loot v-if="playerIsGroup"
+            :inventory="itemsInventory"
+            @addItem="item => pending_loot.push(item)"
+            @confirmAction="addNewLoot"
+          ></Loot>
+          <AddingChest
+              :player="player.id"
+              :claims="claims"
+              :items="playerIsGroup ? pending_loot : itemsInShop"
+              :perms="playerIsGroup ? {} : { canBuy: true }"
+              @buy="(data) => { switchView('player'); actions.buyItems(data); }">
+          </AddingChest>
+        </template>
+        <Chest v-else
+            :player="player.id"
+            :claims="claims"
+            :items="showPlayerChest ? loot : groupLoot"
+            :perms="{ 
+                canGrab: !(showPlayerChest || playerIsGroup), 
+                canSell: showPlayerChest || playerIsGroup
+            }"
+            @sell="actions.sellItems"
+            @claim="actions.putClaim"
+            @unclaim="actions.withdrawClaim">
+        </Chest>
+      </main>
+    </main>
+  </PlayerView>
 </template>

 <script>
-import Player from './components/Player.vue'
+import PlayerView from './components/PlayerView.js'
+import HeaderBar from './components/HeaderBar.vue'
+import Wealth from './components/Wealth.vue'
 import Chest from './components/Chest.vue'
-import { AppStorage } from './AppStorage'
+import Loot from './components/Loot.vue'
+import { api } from './lootalot.js'

 function getCookie(cname) {
  var name = cname + "=";
@@ -34,33 +114,74 @@ export default {
  name: 'app',
  data () {
      return {
-  	state: AppStorage.state,
+        player_id: 0,
+        playerList: [],
+        activeView: 'group',
+        groupLoot: [],
+        itemsInventory: [],
+        itemsInShop: [{id: 1, name: "Item from shop #1", base_price: 2000}],
+        pending_loot: [],
+        initiated: false,
      };
  },
  components: {
-    Player,
-    Chest
+    PlayerView,
+    HeaderBar,
+    'AddingChest': Chest, // Alias to prevent component re-use 
+    Chest,
+    Wealth,
+    Loot,
  },
  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);
+      const cookie = getCookie("player_id");
+      this.player_id = cookie ? Number(cookie) : 0;
+      Promise.all([
+          api.fetch("players/", "GET", null),
+          api.fetch("players/0/loot", "GET", null),
+          api.fetch("items", "GET", null),
+      ])
+          .then(([players, loot, items]) => {
+              this.playerList = players.value;
+              this.groupLoot = loot.value;
+              this.itemsInventory = items.value;
+          })
+          .catch(r => alert("Error ! \n" + r))
+          .then(() => this.initiated = true);
  },
+  methods: {
+    setActivePlayer (idx) { 
+        if (idx == 0) this.switchView('group');
+        this.player_id = Number(idx)
+        document.cookie = `player_id=${idx};`;
+    },
+    switchView (viewId) {
+        if (!['group', 'player', 'adding'].includes(viewId)) {
+            console.error("Not a valid view ID :", viewId);
+        }
+        this.activeView = viewId;
+    },
+    addNewLoot () {
+        api.fetch("players/0/loot", "POST", {
+            source_name: "Dummy name",
+            items: this.pending_loot,
+        })
+           .then(() => {
+               this.pending_loot = []
+               this.switchView('group');
+           })
+           .catch(r => alert("Error: " + r));
+    }
+  },
+  computed: {
+    showPlayerChest () { return this.activeView == 'player' },
+    isAdding () { return this.activeView == 'adding' },
+    playerIsGroup () { return this.player_id == 0 },
+  }
 }
 </script>

-<style>
-#app {
-  font-family: 'Montserrat', Helvetica, Arial, sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  text-align: center;
-}
+<style scoped>
+    header {
+        padding-bottom: 1.5em;
+    }
 </style>
--- a/lootalot_front/src/AppStorage.js
+++ b/lootalot_front/src/AppStorage.js
@@ -1,163 +0,0 @@
-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'")
-              }
-          });
-    }
-}
-
--- a/lootalot_front/src/components/Chest.vue
+++ b/lootalot_front/src/components/Chest.vue
@@ -1,168 +1,166 @@
 <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" >
+  <article>
+    <p class="control has-icons-left">
+      <input type="text" class="input" v-model="searchText">
+      <span class="icon is-small is-left"><i class="fas fa-search"></i></span>
+    </p>
+    <table 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"
-                >
+          <th width="100%">Objets</th>
+          <th>Valeur</th>
+          <th>
+            <div v-if="perms.canSell" class="buttons" :class="{'has-addons': is_selling}">
+              <button class="button"
+                :class="is_selling ? 'is-danger' : 'is-warning'"
+                @click="sellSelectedItems"
+              >
                <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>
+                <p v-if="!is_selling">Vendre</p>
+                <p v-else>{{ selected_items.length > 0 ? `${totalSelectedValue} po` : 'Annuler' }}</p>
+              </button>
+              <PercentInput v-show="is_selling" v-model="global_mod"></PercentInput>
+            </div>
+            <div v-else-if="perms.canBuy">
+              <button class="button is-danger is-fullwidth"
+                :disabled="selected_items.length == 0"
+                @click="buySelectedItems"
+              >Acheter ({{ totalSelectedValue}}po)</button>
+            </div>
+            <div v-else-if="perms.canGrab">
+              <button class="button is-static is-fullwidth">Demander</button>
+            </div>
+          </th>
+        </tr>
+      </thead>
      <tbody>
-        <template v-for="(item, idx) in content">
+        <template v-for="(item, idx) in shownItems">
          <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>
+            <td>
+              <strong>{{item.name}}</strong>
+            </td>
+            <td>
+              {{ is_selling ? item.base_price / 2 : item.base_price }}po
+            </td>
+            <td>
+              <Request
+                v-if="perms.canGrab"
+                :id="player"
+                :claims="claims"
+                :item="item.id"
+                @claim="(data) => $emit('claim', data)"
+                @unclaim="(data) => $emit('unclaim', data)"
+              ></Request>
+              <Selector
+                v-else-if="showSelectors"
+                :id="item.id"
+                v-model="selected_items"
+              ></Selector>
+            </td>
+          </tr>
+        </template>
+      </tbody>
+    </table>
+  </article>
 </template>

 <script>
-    import { AppStorage } from '../AppStorage'
    import Request from './Request.vue'
    import PercentInput from './PercentInput.vue'
-    import Loot from './Loot.vue'
+    import Selector from './Selector.vue'
+    import { api } from '../lootalot.js'
    /*
-        The chest displays the collection of items owned by a player
+        The chest displays a collection of items.

-        TO TEST :
-            - Possible interactions depends on player_id and current chest
-            - Objects are displayed as a table
+        A set of permissions is passed as props, to update
+        the possible actions of active user upon these items.

-        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
-            }
+            },
+            items: {
+                type: Array,
+                required: true,
+            },
+            perms: {
+                type: Object,
+                required: true,
+            },
+            claims: {
+                type: Object,
+                required: true,
+            },
        },
        components: {
            Request,
            PercentInput,
-            Loot,
+            Selector,
        },
        data () {
            return {
-                app_state: AppStorage.state,
                is_selling: false,
-                is_adding: false,
-                sell_selected: [],
+                selected_items: [],
+                global_mod: 0,
+                searchText: "",
            };
        },
        methods: {
-       	    fetchLoot () {
-
-       	    }
+            buySelectedItems () {
+                this.$emit("buy", this.selected_items);
+                this.selected_items = [];
+            },
+            sellSelectedItems () {
+                if (!this.is_selling) {
+                    this.is_selling = true;
+                } else {
+                    this.is_selling = false;
+                    if (this.selected_items.length > 0) {
+                        this.$emit("sell", this.selected_items);
+                        this.selected_items = [];
+                    }
+                }
+            },
        },
        computed: {
-            content () {
-            	const playerId = this.player;
-            	console.log("Refresh chest of", playerId);
-            	return this.app_state.player_loot[playerId];
+            shownItems () {
+                if (this.searchText != "") {
+                    const searchText = this.searchText.toUpperCase();
+                    return this.items.filter(item => item.name.toUpperCase().includes(searchText));
+                } else {
+                    return this.items;
+                }
            },
-            // Can the active user sell items from this chest ?
-            canSell () {
-                return this.player == this.app_state.player_id;
+            showSelectors () {
+                return !this.perms.canGrab
+                    && (this.is_selling || this.perms.canBuy);
            },
-            totalSellValue () {
-                const selected = this.sell_selected;
-                return this.content
-                    .filter(item => selected.includes(item.id))
-                    .map(item => item.base_price / 2)
+            totalSelectedValue () {
+                var total = this.selected_items
+                    .map(([id, mod]) => {
+                        const item = this.items.find(item => item.id == id);
+                        var price = item.base_price * mod;
+                        if (this.is_selling) { 
+                            price = price / 2;
+                        }
+                        return price;
+                    })
                    .reduce((total,value) => total + value, 0);
+                return (1 + this.global_mod / 100) * total;
            },
-            // 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; }
+    .buttons { flex-wrap: nowrap; }
+    label.is-checkbox {
+        background-color: #eee;
+    }
 </style>
--- a/lootalot_front/src/components/HeaderBar.vue
+++ b/lootalot_front/src/components/HeaderBar.vue
@@ -0,0 +1,36 @@
+<template>
+  <nav class="navbar is-info">
+    <div class="navbar-brand">
+      <p class="navbar-item is-size-4"><slot name="title">...</slot></p>
+      <a role="button" class="navbar-burger" aria-label="menu" aria-expanded="false"
+         @click="switchMobileVisibility">
+        <span aria-hidden="true"></span>
+        <span aria-hidden="true"></span>
+        <span aria-hidden="true"></span>
+      </a>
+    </div>
+    <div id="menu" class="navbar-menu" :class="{'is-active': showOnMobile }">
+      <div class="navbar-end">
+      <div class="navbar-item has-dropdown is-hoverable">
+        <a class="navbar-link">Autres</a>
+        <div class="navbar-dropdown is-right" @click="switchMobileVisibility">
+          <slot name="links">
+          <a class="navbar-item">History of Loot</a>
+          </slot>
+        </div>
+      </div>
+      </div>
+    </div>
+  </nav>
+</template>
+
+<script>
+    export default {
+        data () { return { showOnMobile: false } },
+        methods: {
+            switchMobileVisibility () {
+                this.showOnMobile = !this.showOnMobile
+            }
+        }
+    }
+</script>
--- a/lootalot_front/src/components/ItemInput.vue
+++ b/lootalot_front/src/components/ItemInput.vue
@@ -1,93 +1,109 @@
 <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 class="field is-horizontal">
+        <div class="field-label">
+            <label class="label">Nouvel objet</label>
+        </div>
+        <div class="field-body">
+            <div class="field">
+                <div class="control is-expanded">
+                    <input type="text"
+                        name="name"
+                        placeholder="Nom de l'objet"
+                        v-model="item.name"
+                        @input="autoCompletion"
+                        class="input"
+                        autocomplete="on"
+                    >
+                </div>
+                <div class="dropdown" :class="{'is-active': showCompletionFrame}">
+                    <div class="dropdown-menu">
+                        <div class="dropdown-content">
+                            <a v-for="(result,i) in results"
+                                :key="i"
+                                @click="setResult(result)"
+                                class="dropdown-item"
+                            >{{ result.name }}</a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="field is-expanded has-addons" v-show="item.name != ''">
+                <p class="control"><a class="button is-static">PO</a></p>
+                <p class="control">
+                    <input type="text"
+                        name="base_price"
+                        placeholder="Prix"
+                        class="input"
+                        :class="{'is-danger': item.base_price == ''}"
+                        v-model.number="item.base_price"
+                    >
+                </p>
+            </div>
+            <div class="field">
+                <div class="control">
+                    <button class="button is-primary"
+                        @click="addItem"
+                        :disabled="!isItemValid"
+                    >Ajouter</button>
+                </div>
+            </div>
+        </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 {
+        props: ["source"],
        data () {
            return {
                is_loading: false,
-                no_results: false,
-                search: '',
+                item: {
+                    id: 0,
+                    name: '',
+                    base_price: '',
+                },
                results: [],
-                auto_open: false,
            };
        },
        methods: {
-            autoCompletion (ev) {
-                // TODO: a lot happens here that
-                //       need to be clarified
-                if (this.search == '') {
-                    this.auto_open = false;
+            autoCompletion () {
+                // Unset any previous value on input (for every field except item's name)
+                this.item.base_price = '';
+                if (this.item.name == '') {
                    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;
-                    }
+                    this.results = this.source.filter(
+                        item => item.name.toUpperCase().includes(this.item.name.toUpperCase())
+                    );
                }
            },
            setResult(result) {
-                this.search = result;
-                this.auto_open = false;
+                this.item.id = result.id;
+                this.item.name = result.name;
+                this.item.base_price = result.base_price;
+                // Clear results to close completionFrame
+                this.results = [];
            },
            addItem () {
-                this.$emit("addItem", this.search);        
-                this.search = '';
+                this.$emit("addItem", this.item);
+                this.item = {
+                    name: '',
+                    base_price: '',
+                };
                this.results = [];
-                this.no_results = false;
-                this.auto_open = false;
-            }
+            },
        },
+        computed: {
+            showCompletionFrame () { return this.results.length > 0 },
+            isItemValid () { return this.item.name != '' && this.item.base_price != '' },
+        }
    }
 </script>

 <style scoped>
-    .dropdown, .dropdown-menu { min-width: 100%; margin-top: 0; padding-top: 0;}
-    .dropdown { top: -0.75rem; }
+.dropdown, .dropdown-menu {
+    min-width: 100%;
+    margin-top: 0;
+    padding-top: 0;
+}
 </style>
--- a/lootalot_front/src/components/Loot.vue
+++ b/lootalot_front/src/components/Loot.vue
@@ -1,40 +1,33 @@
 <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 class="box">
+    <ItemInput
+      @addItem="onAddItem"
+      :source="inventory"
+    ></ItemInput>
+    <div class="field is-horizontal">
+      <div class="field-label"><label class="label">ou</label></div>
+      <div class="field-body">
+        <div class="field">
+            <div class="control">
+                <button class="button is-primary">Depuis une liste</button>
            </div>
-          </div>
+        </div>
      </div>
+    </div>
+    <button class="button is-danger" @click="$emit('confirmAction')">Finaliser</button>
+  </div>
 </template>

 <script>
    import ItemInput from './ItemInput.vue'

    export default {
+        props: ["inventory"],
        components: { ItemInput },
-        data () { return {
-            looted: [],
-        }; 
-        },
+        data () { return {}; },
        methods: {
            onAddItem (item) {
-                this.looted.push(item);
-            },
-            onClose () {
-                this.$emit('done');
+                this.$emit('addItem', item);
            },
        }

--- a/lootalot_front/src/components/NumberInput.vue
+++ b/lootalot_front/src/components/NumberInput.vue
@@ -1,27 +0,0 @@
-<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>
--- a/lootalot_front/src/components/PercentInput.vue
+++ b/lootalot_front/src/components/PercentInput.vue
@@ -1,28 +1,41 @@
 <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>
+  <div class="field has-addons">
+    <div v-show="is_opened" class="control has-icons-left">
+      <input class="input" :value="value" @input="input" type="number" size="3" min="-50" max=50 step=5>
+      <span class="icon is-left">
+        <i class="fas fa-percent"></i>
+      </span>
+    </div>
+    <div class="control">
+      <button class="button" @click="switchOpenedState">
+        <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 {
+        props: ["value"],
        data () {
            return {
                is_opened: false,
            };
+        },
+        methods: {
+            input (event) { this.$emit("input", event.target.value); },
+            switchOpenedState () {
+                this.is_opened = !this.is_opened;
+                // Reset the modifier in closed state
+                if (!this.is_opened) {
+                    this.$emit("input", 0);
+                }
+            }
        }
    }
 </script>
+
+<style scoped>
+  .input { width: 6em; }
+</style>
--- a/lootalot_front/src/components/Player.vue
+++ b/lootalot_front/src/components/Player.vue
@@ -1,165 +0,0 @@
-<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>
--- a/lootalot_front/src/components/PlayerView.js
+++ b/lootalot_front/src/components/PlayerView.js
@@ -0,0 +1,107 @@
+import { api } from '../lootalot.js'
+
+export default {
+    props: ["id"],
+    data () { return {
+        player: {
+            name: "Loading",
+            id: 0,
+            cp: '-', sp: '-', gp: '-', pp: '-',
+            debt: 0,
+        },
+        notifications: [],
+        loot: [],
+        claims: {},
+    }},
+    created () {
+        api.fetch("claims", "GET", null)
+            .then(r => {
+                for (var idx in r.value) {
+                    var claim = r.value[idx];
+                    if (!(claim.player_id in this.claims)) {
+                        this.$set(this.claims, claim.player_id, []);
+                    }
+                    this.claims[claim.player_id].push(claim.loot_id);
+                }
+            });
+    },
+    methods: {
+        parseUpdate (update) {
+            if (update.Wealth) {
+                var w = update.Wealth;
+                this.player.cp += w.cp;
+                this.player.sp += w.sp;
+                this.player.gp += w.gp;
+                this.player.pp += w.pp;
+            }
+            else if (update.ItemAdded) {
+                var i = update.ItemAdded;
+                this.loot.push(i);
+            }
+            else if (update.ItemRemoved) {
+                var i = update.ItemRemoved;
+                this.loot.splice(this.loot.indexOf(i), 1);
+            }
+            else if (update.ClaimAdded) {
+                var c = update.ClaimAdded;
+                this.claims[c.player_id].push(c.loot_id);
+            }
+            else if (update.ClaimRemoved) {
+                var c = update.ClaimRemoved;
+                this.claims[c.player_id].splice(
+                    this.claims[c.player_id].indexOf(c.loot_id),
+                    1
+                );
+            }
+        },
+        call (resource, method, payload) {
+            return api.fetch(`players/${this.id}/${resource}`, method, payload)
+                .then(response => {
+                    if (response.notification) {
+                        this.notifications.push(response.notification)
+                    }
+                    if (response.errors) {
+                        this.notifications.push(response.errors)
+                    }
+                    if (response.updates) {
+                        for (var idx in response.updates) {
+                            this.parseUpdate(response.updates[idx]);
+                        }
+                    }
+                    return response.value;
+                })
+        },
+        updateWealth (value) { this.call("wealth", "PUT", Number(value)) },
+        putClaim (itemId) { this.call("claims", "PUT", itemId) },
+        withdrawClaim (itemId) { this.call("claims", "DELETE", itemId) },
+        buyItems(items) { this.call("loot", "PUT", items) },
+        sellItems (items) { this.call("loot", "DELETE", items) },
+    },
+    watch: {
+        id: {
+            immediate: true,
+            handler: function(newId) {
+                this.call("", "GET", null)
+                    .then(p => this.player = p)
+                this.call("loot", "GET", null)
+                    .then(l => this.loot = l)
+            }
+        },
+    },
+    computed: {},
+    render () {
+        return this.$scopedSlots.default({
+            player: this.player, 
+            loot: this.loot,
+            notifications: this.notifications,
+            actions: {
+                    updateWealth: this.updateWealth,
+                    putClaim: this.putClaim,
+                    withdrawClaim: this.withdrawClaim,
+                    buyItems: this.buyItems,
+                    sellItems: this.sellItems,
+            },
+            claims: this.claims,
+        })
+    }
+}
--- a/lootalot_front/src/components/Request.vue
+++ b/lootalot_front/src/components/Request.vue
@@ -1,26 +1,22 @@
 <template>
-  <div class="buttons is-right" >
+  <div class="buttons">
    <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>
+        @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"
-    >
+    <button class="button is-primary"
+      @click="putRequest"
+      :disabled="isRequested">
      <span class="icon is-small">
        <i class="fas fa-praying-hands"></i>
      </span>
@@ -29,30 +25,41 @@
 </template>

 <script>
-    import { AppStorage } from '../AppStorage'
    export default {
-        props: ["item"],
-        data () { 
-            return {
-                state: AppStorage.state,
-            };
+        props: {
+            // Id of active player
+            id: {
+                type: Number,
+                required: true,
+            },
+            // Map of all claims
+            claims: {
+                type: Object,
+                required: true,
+            },
+            // Id of item we are bound to
+            item: {
+                type: Number,
+                required: true,
+            }
        },
        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);
+                if (this.claims[this.id]) {
+                    return this.claims[this.id].includes(this.item);
+                } else {
+                    return false;
+                }
            },
            // 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);
+                for (var id in this.claims) {
+                    const isReq = this.claims[id].includes(this.item);
                    if (isReq) {
-                        if (key == playerId) {
+                        if (id == this.id) {
                            reqByPlayer = true;
                        } else {
                            reqByOther = true;
@@ -65,11 +72,11 @@
        methods: {
            // The active player claims the item
            putRequest () {
-                AppStorage.putRequest(this.item)
+                this.$emit("claim", this.item);
            },
            // The active player withdraws his request
            cancelRequest () {
-                AppStorage.cancelRequest(this.item)
+                this.$emit("unclaim", this.item);
            },
            // The active player insist on his claim
            // TODO: Find a simple and fun system to express
@@ -79,3 +86,7 @@
        },
    }
 </script>
+
+<style scoped>
+    .buttons, .button { margin-bottom: 0; }
+</style>
--- a/lootalot_front/src/components/Selector.vue
+++ b/lootalot_front/src/components/Selector.vue
@@ -0,0 +1,57 @@
+<template>
+  <div class="buttons has-addons">
+    <label class="button is-fullwidth">
+        <input type="checkbox" class="checkbox" v-model="selected">
+    </label>
+    <PercentInput v-show="selected" v-model.number="mod_value"></PercentInput>
+  </div>
+</template>
+
+<script>
+import PercentInput from './PercentInput.vue'
+
+/*  Selector for a specific item, with an associated price modifier.
+    Acts as checkbox on a v-model, except it populates an array with [value, modifier] instead of value alone
+*/
+
+export default {
+    props: ["id", "value"],
+    components: { PercentInput },
+    data () {
+        return {
+            selected: false,
+            mod_value: 0,
+        };
+    },
+    computed: {
+        modifier () {
+            return 1 + this.mod_value / 100;
+        }
+    },
+    watch: {
+        selected (newState) {
+            let idx = this._findData();
+            var updated = this.value;
+            if (newState == true && idx == -1) {
+                updated.push([this.id, this.modifier]);
+            } else if (newState == false && idx != -1 ) {
+                updated.splice(idx, 1);
+            }
+            this.$emit('input', updated);
+        },
+        mod_value (newState) {
+            let idx = this._findData();
+            var updated = this.value;
+            if (idx != -1) {
+                updated.splice(idx, 1, [this.id, this.modifier]);
+                this.$emit('input', updated);
+            }
+        }
+    },
+    methods: {
+        _findData () {
+            return this.value.findIndex(([val,mod]) => this.id == val);
+        }
+    }
+  }
+</script>
--- a/lootalot_front/src/components/Wealth.vue
+++ b/lootalot_front/src/components/Wealth.vue
@@ -1,92 +1,97 @@
 <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>
+  <section class="level is-mobile">
+    <div class="level-left">
+      <div class="level-item">
+	    <span class="icon is-large" @click="editing = !editing">
+	      <i class="fas fa-2x fa-piggy-bank"></i>
+	    </span>
+      </div>
+      <template v-if="editing">
+      <div class="level-item">
+        <div class="field has-addons">
+          <p class="control">
+    	    <input class="input" type="number" step="0.01" v-model="edit_value"></input>
+          </p>
+          <p class="control">
+            <a class="button is-static">po</a>
+          </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>
+      </div>
+      <div class="level-item">
+        <button class="button is-danger" @click="updateWealth()">
+          Modifier
        </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>
+      </template>
+      <template v-else>
+      <div class="level-item ">
+       <p class="is-size-4">{{ pp }}</p>
+       <p class="heading">PP</p>
+      </div>
+     <div class="level-item ">
+       <p class="is-size-4">{{ gp }}</p>
+       <p class="heading">PO</p>
+     	</div>
+     <div class="level-item ">
+       <p class="is-size-4 has-text-grey-light">{{ sp }}</p>
+       <p class="heading">PA</p>
+       </div>
+     <div class="level-item ">
+       <p class="is-size-4 has-text-grey-light">{{ cp }}</p>
+       <p class="heading">PC</p>
+       </div>
+    </template>
    </div>
-  </div>
+    <div class="level-right" v-if="debt">
+      <div class="level-item">
+        <p class="heading is-size-4 has-text-danger">Dette: {{ debt }}gp </p>
+      </div>
+    </div>
+    </div>
+  </section>
 </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,
+              editing: 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');
-		        }
-                    });
+            updateWealth () {
+                this.$emit("update", this.edit_value);
+                this.resetValues();
            },
            resetValues () {
-            	this.edit = false;
-                this.edit_value = 0;
+              this.editing = false;
+              this.edit_value = 0;
            }
+        },
+        computed: {
+            pp () {
+                return this.wealth[3];
+            },
+            gp () {
+                const gp = this.wealth[2];
+                if (gp < 10) {
+                    return "0" + gp;
+                } else {
+                    return gp;
+                }
+            },
+            sp () {
+                return this.wealth[1];
+            },
+            cp () {
+                return this.wealth[0];
+            },
        }
    }
 </script>
+
+<style scoped>
+    .input { max-width: 9em; }
+</style>
--- a/lootalot_front/src/lootalot.js
+++ b/lootalot_front/src/lootalot.js
@@ -0,0 +1,20 @@
+const API_BASEURL = "http://localhost:8088/api/"
+const API_ENDPOINT = function (tailString) {
+  return API_BASEURL + tailString;
+}
+
+export const api = {
+    fetch: function(endpoint, method, payload) {
+        var config = {
+            method,
+             headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        if (payload) {
+            config.body = JSON.stringify(payload);
+        }
+        return fetch(API_ENDPOINT(endpoint), config)
+            .then(r => r.json());
+    }
+}
--- a/lootalot_front/tests/unit/.eslintrc.js
+++ b/lootalot_front/tests/unit/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+  env: {
+    mocha: true
+  }
+}
--- a/lootalot_front/tests/unit/ItemInput.spec.js
+++ b/lootalot_front/tests/unit/ItemInput.spec.js
@@ -0,0 +1,94 @@
+import { expect } from 'chai'
+import { mount } from '@vue/test-utils'
+import ItemInput from '@/components/ItemInput.vue'
+
+const MOCK_SOURCE = [
+    { id: 1, name: "Épée", base_price: 20 },
+    { id: 2, name: "Arc", base_price: 30 },
+]
+
+const withItemFactory = function (item) {
+    const wrapper = mount(ItemInput, {
+        propsData: {
+            source: MOCK_SOURCE,
+        }
+    })
+    wrapper.setData({ item })
+    return wrapper
+}
+
+describe('ItemInput.vue', () => {
+
+    // Tests on validation of the item data
+    it('item with name and price is valid', () => {
+        const localItem = {
+            item: {
+                id: 0,
+                name: 'Epee',
+                base_price: 200
+            }
+        }
+        expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(true)
+    })
+
+    it('item without data is not valid', () => {
+        const localItem = {
+            item: {
+                id: 0,
+                name: '',
+                base_price: ''
+            }
+        }
+        expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
+    })
+
+    it('item without price is not valid', () => {
+        const localItem = {
+            item: {
+                id: 0,
+                name: 'Epee',
+                base_price: ''
+            }
+        }
+        expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
+    })
+
+    it('item without name is not valid', () => {
+        const localItem = {
+            item: {
+                id: 0,
+                name: '',
+                base_price: 200
+            }
+        }
+        expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
+    })
+
+    it('item price must be a number', () => {
+        const localItem = {
+            item: {
+                id: 0,
+                name: 'Epee',
+                base_price: 'cheap'
+            }
+        }
+        expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
+    })
+
+    // Test on auto-completion
+    it('show completion suggestions on input', () => {
+        const wrapper = withItemFactory({ id: 0, name: '', base_price: '' })
+        const input = wrapper.find({ name: "name" })
+        const suggestionBox = wrapper.find('.dropdown')
+        console.log(input)
+        expect(suggestionBox.classes('is-active')).to.equal(true)
+    })
+
+    it('hides suggestion box when no suggestions are available', () => {
+
+    })
+
+    it('click on suggestion sets the item', () => {
+
+    })
+})
--- a/lootalot_front/tests/unit/Wealth.spec.js
+++ b/lootalot_front/tests/unit/Wealth.spec.js
@@ -0,0 +1,14 @@
+import { expect } from 'chai'
+import { shallowMount  } from '@vue/test-utils'
+import Wealth from '@/components/Wealth.vue'
+
+describe('Wealth.vue', () => {
+    it('renders wealth when passed', () => {
+        const wealth = [1, 2, 3, 4]
+        const wrapper = shallowMount(Wealth, {
+            propsData: { wealth }
+        })
+        var divs = wrapper.findAll('div')
+        expect(wrapper.text()).to.include(wealth)
+    })
+})
--- a/src/api.rs
+++ b/src/api.rs
@@ -0,0 +1,233 @@
+use lootalot_db::{self as db, DbConnection, Update, Value};
+
+pub type ItemListWithMods = Vec<(i32, Option<f64>)>;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SellParams {
+    pub items: ItemListWithMods,
+    players: Option<Vec<i32>>,
+    global_mod: Option<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,
+    FetchClaims,
+    // Player level
+    FetchPlayer(i32),
+    FetchNotifications(i32),
+    FetchLoot(i32),
+    UpdateWealth(i32, f64),
+    BuyItems(i32, Vec<(i32, Option<f64>)>),
+    SellItems(i32, SellParams),
+    ClaimItem(i32, i32),
+    UnclaimItem(i32, i32),
+    // Group level
+    AddLoot(Vec<db::Item>),
+    // Admin level
+    //AddPlayer(String, f64),
+    //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<&str> = match query {
+        ApiActions::FetchPlayers => {
+            response.set_value(Value::PlayerList(db::Players(conn).all()?));
+            None
+        }
+        ApiActions::FetchInventory => {
+            response.set_value(Value::ItemList(db::Inventory(conn).all()?));
+            None
+        }
+        ApiActions::FetchClaims => {
+            response.set_value(Value::ClaimList(db::fetch_claims(conn)?));
+            None
+        }
+        ApiActions::FetchPlayer(id) => {
+            response.set_value(Value::Player(db::Players(conn).find(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(Update::Wealth(
+                db::AsPlayer(conn, id).update_wealth(amount)?,
+            ));
+            response.notify(format!("Mis à jour ({}po)!", amount));
+            Some("Argent mis à jour")
+        }
+        ApiActions::BuyItems(id, params) => {
+            // TODO: check that player has enough money !
+            let mut cumulated_diff: Vec<db::Wealth> = Vec::with_capacity(params.len());
+            let mut added_items: u16 = 0;
+            for (item_id, price_mod) in params.into_iter() {
+                if let Ok((item, diff)) = db::buy_item_from_inventory(conn, id, item_id, price_mod)
+                {
+                    cumulated_diff.push(diff);
+                    response.push_update(Update::ItemAdded(item));
+                    added_items += 1;
+                } else {
+                    response.push_error(format!("Error adding {}", item_id));
+                }
+            }
+            let total_amount = cumulated_diff
+                .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("Achat d'objets")
+        }
+        // Behavior differs if player is group or regular.
+        // Group sells item like players then split the total amount among players.
+        ApiActions::SellItems(id, params) => {
+            let mut all_results: Vec<db::Wealth> = Vec::with_capacity(params.items.len());
+            let mut sold_items: u16 = 0;
+            for (loot_id, price_mod) in params.items.iter() {
+                if let Ok((deleted, diff)) =
+                    db::sell_item_transaction(conn, id, *loot_id, *price_mod)
+                {
+                    all_results.push(diff);
+                    response.push_update(Update::ItemRemoved(deleted));
+                    sold_items += 1;
+                } else {
+                    response.push_error(format!("Erreur lors de la vente (loot_id : {})", loot_id));
+                }
+            }
+            let total_amount = all_results
+                .into_iter()
+                .fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
+            match id {
+                0 => {
+                    let share = db::split_and_share(
+                        conn,
+                        total_amount.to_gp() as i32,
+                        params.players.expect("Should not be None"),
+                    )?;
+                    response.notify(format!(
+                        "Les objets ont été vendus, chaque joueur a reçu {} po",
+                        share.to_gp()
+                    ));
+                    response.push_update(Update::Wealth(share));
+                }
+                _ => {
+                    response.notify(format!(
+                        "{} objet(s) vendu(s) pour {} po",
+                        sold_items,
+                        total_amount.to_gp()
+                    ));
+                    response.push_update(Update::Wealth(total_amount));
+                }
+            }
+            Some("Vente d'objets")
+        }
+        ApiActions::ClaimItem(id, item) => {
+            response.push_update(Update::ClaimAdded(db::Claims(conn).add(id, item)?));
+            response.notify("Pour moi !".to_string());
+            None
+        }
+        ApiActions::UnclaimItem(id, item) => {
+            response.push_update(Update::ClaimRemoved(db::Claims(conn).remove(id, item)?));
+            response.notify("Bof! Finalement non.".to_string());
+            None
+        }
+        // Group actions
+        ApiActions::AddLoot(items) => {
+            let mut added_items = 0;
+            for item in items.into_iter() {
+                if let Ok(added) = db::LootManager(conn, 0).add_from(&item) {
+                    response.push_update(Update::ItemAdded(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("Nouveau loot")
+        }
+    };
+
+    // match _action_text -> Save updates in DB
+    dbg!(&action_text);
+    Ok(response)
+}
+
+/// Reverts the last action stored for player
+fn revert_last_action(conn: &DbConnection, id: i32) -> Result<ApiResponse, diesel::result::Error> {
+    let mut response = ApiResponse::default();
+    // 1. Load the last action
+    // 2. Iterate trought updates and reverse them (in a single transaction)
+    // 3. Send nice message back ("'action desc text' annulé !")
+    Ok(response)
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,8 +2,10 @@ 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");
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,47 +1,33 @@
 use actix_cors::Cors;
 use actix_files as fs;
-use actix_web::{web, App, Error, HttpResponse, HttpServer};
-use futures::Future;
-use lootalot_db::{DbApi, Pool, QueryResult};
+use actix_web::{web, middleware, App, Error, HttpResponse, HttpServer, Either};
+use futures::{Future, IntoFuture};
 use std::env;

-type AppPool = web::Data<Pool>;
+use lootalot_db as db;
+use crate::api;

-/// Wraps call to the DbApi and process its result as a async HttpResponse
-///
-/// Provides a convenient way to call the api inside a route definition. Given a connection pool,
-/// access to the api is granted in a closure. The closure is called in a blocking way and should
-/// return a QueryResult.
-/// If the query succeeds, it's result is returned as JSON data. Otherwise, an InternalServerError
-/// is returned.
-///
-/// # Usage
-/// ```
-///     (...)
-///     .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,
->(
+type AppPool = web::Data<db::Pool>;
+type PlayerId = web::Path<i32>;
+type ItemId = web::Json<i32>;
+
+#[derive(Serialize, Deserialize, Debug)]
+struct NewGroupLoot {
+    source_name: String,
+    items: Vec<db::Item>,
+}
+
+type MaybeForbidden = actix_web::Either<Box<dyn Future<Item = HttpResponse, Error = Error>>, HttpResponse>;
+
+/// Wraps call to the database query and convert its result as a async HttpResponse
+fn db_call(
    pool: AppPool,
-    query: Q,
-) -> impl Future<Item = HttpResponse, Error = Error> {
+    query: api::ApiActions,
+) -> impl Future<Item = HttpResponse, Error = Error>
+{
    let conn = pool.get().unwrap();
-    web::block(move || {
-        let api = DbApi::with_conn(&conn);
-        query(api)
-    })
-    .then(|res| match res {
-        Ok(players) => HttpResponse::Ok().json(players),
+    web::block(move || api::execute(&conn, query)).then(|res| match res {
+        Ok(r) => HttpResponse::Ok().json(r),
        Err(e) => {
            dbg!(&e);
            HttpResponse::InternalServerError().finish()
@@ -49,75 +35,111 @@ pub fn db_call<
    })
 }

-pub(crate) fn serve() -> std::io::Result<()> {
+fn forbidden_to_players(id: i32, params: (AppPool, api::ApiActions)) -> MaybeForbidden {
+    if id != 0 {
+        Either::B(HttpResponse::Forbidden().finish())
+    } else {
+        Either::A(Box::new(db_call(params.0, params.1)))
+    }
+
+}
+
+fn configure_app(config: &mut web::ServiceConfig) {
+    use api::ApiActions as Q;
+    config.service(
+        web::scope("/api")
+            .service(
+                web::scope("/players")
+                    .service(
+                        web::resource("/").route(
+                            web::get().to_async(|pool| db_call(pool, Q::FetchPlayers)),
+                        ), //.route(web::post().to_async(endpoints::new_player))
+                    ) // 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(endpoints::player_claims))
+                                    .route(web::put().to_async(
+                                        |pool, (player, data): (PlayerId, ItemId)| {
+                                            db_call(pool, Q::ClaimItem(*player, *data))
+                                        },
+                                    ))
+                                    .route(web::delete().to_async(
+                                        |pool, (player, data): (PlayerId, ItemId)| {
+                                            db_call(
+                                                pool,
+                                                Q::UnclaimItem(*player, *data),
+                                            )
+                                        },
+                                    )),
+                            )
+                            .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, web::Json<api::ItemListWithMods>)| {
+                                            db_call(pool, Q::BuyItems(*player, data.into_inner()))
+                                        },
+                                    ))
+                                    .route(web::post().to(
+                                        move |pool, (player, data): (PlayerId, web::Json<NewGroupLoot>)| {
+                                            forbidden_to_players(*player, (pool, Q::AddLoot(data.into_inner().items)))
+                                        },
+                                    ))
+                                    .route(web::delete().to_async(
+                                        move |pool, (player, data): (PlayerId, web::Json<api::SellParams>)| {
+                                               db_call(pool, Q::SellItems(*player, data.into_inner()))
+                                        },
+                                    )),
+                            ),
+                    ),
+            )
+            .route("/claims", web::get().to_async(|pool| db_call(pool, Q::FetchClaims)))
+            .route(
+                "/items",
+                web::get()
+                    .to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)),
+            ),
+    );
+}
+
+pub fn serve() -> std::io::Result<()> {
    let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
+    let pool = db::create_pool();
    dbg!(&www_root);
-    let pool = lootalot_db::create_pool();

    HttpServer::new(move || {
        App::new()
            .data(pool.clone())
+            .configure(configure_app)
            .wrap(
                Cors::new()
                    .allowed_origin("http://localhost:8080")
-                    .allowed_methods(vec!["GET", "POST"])
+                    .allowed_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
                    .max_age(3600),
            )
-            .service(
-                web::scope("/api")
-                    .route(
-                        "/players",
-                        web::get().to_async(move |pool: AppPool| {
-                            db_call(pool, move |api| api.fetch_players())
-                        }),
-                    )
-                    .route(
-                        "/claims",
-                        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)
-                                })
-                            },
-                        ),
-                    ),
-            )
+            .wrap(middleware::Logger::default())
            .service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
    })
    .bind("127.0.0.1:8088")?
Author	SHA1	Message	Date
Artus	0ac2bce183	adds newtype	2019-10-28 00:22:28 +01:00
Artus	d880d9528e	works on making event models work	2019-10-27 21:56:24 +01:00
Artus	9ee8cb867c	blanket impl of Update.undo()	2019-10-27 16:20:11 +01:00
Artus	df06e2cf4a	removes some unused warnings	2019-10-27 16:13:29 +01:00
Artus	ae991bf4dc	preps historic events management	2019-10-27 15:53:01 +01:00
Artus	40e39d5a65	adds history table	2019-10-27 15:52:46 +01:00
Artus	559ce804a7	makes resolve_claims a single transaction	2019-10-27 14:50:49 +01:00
Artus	9a3744e340	fixes resolve_claims & split_and_share	2019-10-27 14:45:54 +01:00
Artus	dc0874bd12	preps undo actions	2019-10-26 11:06:08 +02:00
Artus	49dfd8bb14	adds selling procedure for 'group'	2019-10-26 10:58:03 +02:00
Artus	74ee4a831b	works on selling group items	2019-10-20 22:03:06 +02:00
Artus	05a08ea337	adds forbidden_to_players wrapper for db_call	2019-10-20 21:23:57 +02:00
Artus	edf236ef8c	routing the rest of implemented features, hits response problem	2019-10-20 16:09:16 +02:00
Artus	ed3ac2abcb	adds notifications table and models	2019-10-19 21:59:17 +02:00
Artus	2248e25aec	split player module	2019-10-19 21:44:10 +02:00
Artus	24807615f7	adds docs, removes some useless pub statements	2019-10-19 16:12:27 +02:00
Arthur Gerbaud	a552d7beee	Merge branch 'refactoring' of rust/lootalot into master	2019-10-19 14:39:07 +02:00
Artus	ce04b77a15	removes unused file	2019-10-19 14:29:42 +02:00
Artus	622d746446	removes obsolete AppStorage.js	2019-10-19 14:23:55 +02:00
Artus	b0441f3402	fixes bug (float precision) by using f64	2019-10-18 21:39:23 +02:00
Artus	61c9a4e6d4	moves all api logic inside PlayerView, found weird bug in unpack_gold_value (floating error)	2019-10-18 16:21:00 +02:00
Artus	3fce1dc7d0	adds nicer notifications to user	2019-10-18 14:48:27 +02:00
Artus	60a6e69f67	refactor PlayerView, plans to replace ApiStorage.js by lootalot.js api module	2019-10-18 14:35:06 +02:00
Artus	08397e7b25	fixes API consumer	2019-10-18 12:42:27 +02:00
Artus	ec36403dc3	adds custom serializer for api::Value	2019-10-17 13:25:07 +02:00
Artus	80585eb1cd	removes useless file	2019-10-17 13:01:33 +02:00
Artus	185e1403e3	moves API logic inside its own module	2019-10-17 12:56:07 +02:00
Artus	3cc45397da	fixes errors, cleans up	2019-10-17 11:58:00 +02:00
Artus	2222422f8a	removes ApiResponse from server	2019-10-16 22:32:58 +02:00
Artus	8cfa21eccf	stablizing ApiResponse inside lootalot_db crate	2019-10-16 22:29:38 +02:00
Artus	8af7790d17	try out a generic ApiResponse	2019-10-15 16:22:46 +02:00
Artus	6101aaa9e9	thoughts on new api structure, formats code	2019-10-15 14:42:57 +02:00
Artus	8399ffebf7	refactors claims unit tests	2019-10-15 14:16:45 +02:00
Artus	de4aad5679	updates README	2019-10-14 23:40:38 +02:00
Artus	a05cab9974	fixes claims routes	2019-10-14 23:38:29 +02:00
Artus	c72169281d	refactors, makes Loot private to module	2019-10-14 16:28:18 +02:00
Artus	b2e319dc15	works on resolve_claims	2019-10-14 15:27:49 +02:00
Artus	0df875d6a6	moves db logic inside model's managers	2019-10-13 16:02:47 +02:00
Artus	068b2e7169	reorganizes api endpoints	2019-10-11 16:07:09 +02:00
Artus	3a1f8ec4f6	thinking in progress	2019-10-10 16:38:59 +02:00
Artus	77728cfdc4	reinitialize lootalot_front to add unit testing	2019-10-10 10:14:02 +02:00
Artus	70eed30bee	makes adding loot working	2019-10-07 15:10:35 +02:00
Artus	4f6970c423	works on Loot adding UI	2019-10-04 16:02:22 +02:00
Artus	1ff2429244	starts working on ItemInput	2019-10-04 14:47:45 +02:00
Artus	f1548aedfa	adds search filter on Chest	2019-10-04 14:21:50 +02:00
Artus	c99a38a738	makes selector work	2019-10-03 21:27:42 +02:00
Artus	d6fe5b71f5	extracts Selector component	2019-10-03 19:57:48 +02:00
Artus	47b5d27a0b	makes modifier kind-of work, needs refactoring	2019-10-03 16:13:05 +02:00
Artus	60b489e8fd	finish add/buy in frontend	2019-10-03 12:37:22 +02:00
Artus	2e7afa9bb0	small fixes	2019-10-01 16:18:30 +02:00
Artus	34bb1977a5	small fix	2019-10-01 15:43:16 +02:00
Artus	cb98b97126	adds buy/sell endpoints	2019-08-07 15:34:08 +02:00
Artus	6e7a0f6211	updates readme	2019-08-05 21:15:12 +02:00
Artus	6f1a0530d0	updates readme	2019-08-05 21:14:44 +02:00
Artus	8fbca0f7d8	updates README	2019-08-05 21:12:10 +02:00
Artus	3cfa12570d	small fixes	2019-08-05 15:54:54 +02:00
Artus	10d157a9af	adds a working inventory	2019-08-05 15:41:41 +02:00
Artus	894f5f8200	small fixes, cleans up API	2019-08-05 14:41:36 +02:00
Artus	3b39428e76	aliases Chest to force creation of distinct ones	2019-08-04 21:38:32 +02:00
Artus	a0e4a02e0f	starts improving REST Api	2019-08-04 21:23:01 +02:00
Artus	e56c8df121	UI fixes, adds blanket impls of buy/sell signals	2019-08-01 21:57:47 +02:00
Artus	f1d088596d	adds basic 'views' concept for main content	2019-08-01 15:46:38 +02:00
Artus	dde7dc3770	removes Chest use of AppStorage, various fixes	2019-08-01 14:46:25 +02:00
Artus	15d87e3b47	more refactoring, removing imports	2019-07-31 21:48:59 +02:00
Artus	dae7633c11	moves logic to PlayerView, adds simple notifications when debugging	2019-07-31 15:37:35 +02:00
Artus	e07b236313	removes useless test	2019-07-31 15:12:48 +02:00
Artus	fccd9b999b	Starts refactor using a PlayerView renderless component for Player logic	2019-07-31 15:11:51 +02:00
Artus	2991a88a30	small fixes while reviewing code	2019-07-29 15:43:14 +02:00
Artus	a3eaeed807	redraws frontend UI	2019-07-28 15:56:19 +02:00
Artus	d280d0f095	fix type error	2019-07-28 13:37:59 +02:00
Artus	dbb084b0ec	little fixes	2019-07-24 16:02:44 +02:00
Artus	7350d5222c	adds basic resolve_claims + test	2019-07-24 15:55:08 +02:00
Artus	89172177eb	makes ActionResult simpler, uses SQL transactions	2019-07-24 15:07:04 +02:00