fixes errors

merge shop and looted tables
will need to clean up db API
2020-01-09 15:12:51 +01:00 · 2020-01-09 13:25:36 +01:00 · 2020-01-05 15:37:40 +01:00 · 2019-12-18 15:22:20 +01:00 · 2019-12-15 16:03:25 +01:00 · 2019-12-15 16:02:00 +01:00
43 changed files with 955 additions and 8783 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,12 +7,15 @@ edition = "2018"
 [dependencies]
 actix-web = "1.0.*"
 actix-files = "*"
+actix-service = "*"
+actix-identity = "*"
 lootalot-db = { version = "0.1", path = "./lootalot_db" }
 dotenv = "*"
 env_logger = "*"
 futures = "0.1"
 diesel = "*"
 serde = "*"
+serde_json = "*"
 actix-cors = "0.1.0"

 [workspace]
--- 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/migrations/2019-06-10-123922_create_items/down.sql
+++ b/lootalot_db/migrations/2019-06-10-123922_create_items/down.sql
@@ -1,3 +1,2 @@
 DROP TABLE items;
-DROP TABLE looted;
-
+DROP TABLE loot;
--- a/lootalot_db/migrations/2019-06-10-123922_create_items/up.sql
+++ b/lootalot_db/migrations/2019-06-10-123922_create_items/up.sql
@@ -5,11 +5,12 @@ CREATE TABLE items (
  base_price INTEGER NOT NULL
 );

-- The items that have been looted
-CREATE TABLE looted (
+-- The loot
+CREATE TABLE loot (
  id INTEGER PRIMARY KEY NOT NULL,
  name VARCHAR NOT NULL,
  base_price INTEGER NOT NULL,
  owner_id INTEGER NOT NULL,
  FOREIGN KEY (owner_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/src/lib.rs
+++ b/lootalot_db/src/lib.rs
@@ -18,8 +18,9 @@ mod schema;

 pub use models::{
    claim::{Claim, Claims},
-    item::{Item, LootManager, Inventory},
-    player::{Player, Wealth, Players, AsPlayer},
+    history::{Event, UpdateList},
+    item::{Inventory, Shop, Item, LootManager},
+    player::{AsPlayer, Player, Players, Wealth},
 };

 /// The connection used
@@ -28,6 +29,7 @@ pub type DbConnection = SqliteConnection;
 pub type Pool = r2d2::Pool<ConnectionManager<DbConnection>>;
 /// The result of a query on DB
 pub type QueryResult<T> = Result<T, diesel::result::Error>;
+pub type UpdateResult = QueryResult<Vec<Update>>;

 /// Sets up a connection pool and returns it.
 /// Uses the DATABASE_URL environment variable (must be set)
@@ -40,324 +42,127 @@ pub fn create_pool() -> Pool {
        .expect("Failed to create pool.")
 }

-
-/// 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))
-    })
+/// Every possible update which can happen during a query
+/// Updates are relative to a Player
+#[derive(Serialize, Deserialize, Debug)]
+pub enum Update {
+    Wealth(Wealth),
+    ItemAdded(Item),
+    ItemRemoved(Item),
+    ItemBought(Item),
+    ItemSold(Item),
+    ClaimAdded(Claim),
+    ClaimRemoved(Claim),
 }

-/// 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,
+impl Update {
+    /// Change back what has been updated
+    fn undo(&self, conn: &DbConnection, id: i32) -> QueryResult<()> {
+        match self {
+            Update::Wealth(diff) => { AsPlayer(conn, id).update_wealth(-diff.to_gp())?; },
+            Update::ItemAdded(item) => { diesel::delete(crate::schema::loot::table.find(item.id))
+                                         .execute(conn)?; },
+            Update::ItemRemoved(item) => { LootManager(conn, id).add_from(&item)?; },
+            Update::ItemBought(item) => { LootManager(conn, id).change_owner(item.id, models::item::OF_SHOP)?;},
+            Update::ItemSold(item) => { LootManager(conn, models::item::SOLD).change_owner(item.id, id)?; },
+            // Unused for now
+            Update::ClaimAdded(claim) => {},
+            Update::ClaimRemoved(claim) => {},
        };
-        AsPlayer(conn, id)
-            .update_wealth(-sell_price)
-            .map(|diff| (new_item, diff))
-    })
+        Ok(())
+    }
 }

-/// Fetch all existing claims
-pub fn fetch_claims(conn: &DbConnection) -> QueryResult<Vec<models::Claim>> {
-    schema::claims::table.load::<models::Claim>(conn)
+/// 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),
+        }
+    }
+}
+
+
 /// 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);
-
-    for (item, claims) in data {
-        match claims.len() {
-            1 => {
-                let claim = claims.get(0).unwrap();
-                let player_id = claim.player_id;
-                conn.transaction(|| {
-                    claim.resolve_claim(conn)?;
-                    //models::item::LootManager(self.0, 0).set_owner(claim.loot_id, claim.player_id)?;
-                    models::player::AsPlayer(conn, player_id).update_debt(item.sell_value())
-                })?;
-            }
-            _ => (),
+    conn.transaction(move || {
+        for (item, mut claims) in data {
+            if claims.len() > 1 {
+                // TODO: better sorting mechanism :)
+                claims.sort_by(|a, b| a.resolve.cmp(&b.resolve));
            }
+            let winner = claims.get(0).expect("Claims should not be empty !");
+            let player_id = winner.player_id;
+            winner.resolve_claim(conn)?;
+            models::player::AsPlayer(conn, player_id).update_debt(item.sell_value() as i32)?;
        }
        Ok(())
-}
-
-/// Split up and share 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() {
-            AsPlayer(conn, p).update_wealth(share)?;
-            AsPlayer(conn, 0).update_wealth(-share)?;
-        }
-        Ok(Wealth::from_gp(share))
    })
 }

-
-
-#[cfg(none)]
-mod tests_old {
-    use super::*;
-    type TestConnection = DbConnection;
-
-    /// Return a connection to a fresh database (stored in memory)
-    fn test_connection() -> TestConnection {
-        let test_conn = DbConnection::establish(":memory:").unwrap();
-        diesel_migrations::run_pending_migrations(&test_conn).unwrap();
-        test_conn
-    }
-
-    /// When migrations are run, a special player with id 0 and name "Groupe"
-    /// must be created.
-    #[test]
-    fn global_group_is_autocreated() {
-        let conn = test_connection();
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        assert_eq!(players.len(), 1);
-        let group = players.get(0).unwrap();
-        assert_eq!(group.id, 0);
-        assert_eq!(group.name, "Groupe".to_string());
-    }
-
-    /// When a player updates wealth, a difference is returned by API.
-    /// Added to the previous amount of coins, it should equal the updated weath.
-    #[test]
-    fn as_player_updates_wealth() {
-        let conn = test_connection();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("PlayerName", 403.21)
-            .unwrap();
-        let diff = DbApi::with_conn(&conn)
-            .as_player(1)
-            .update_wealth(-401.21)
-            .ok();
-        // Check the returned diff
-        assert_eq!(diff, Some((-1, -2, -1, -4)));
-        let diff = diff.unwrap();
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        let player = players.get(1).unwrap();
-        // Check that we can add old value to return diff to get resulting value
-        assert_eq!(
-            (player.cp, player.sp, player.gp, player.pp),
-            (1 + diff.0, 2 + diff.1, 3 + diff.2, 4 + diff.3)
-        );
-    }
-
-    #[test]
-    fn as_admin_add_player() {
-        let conn = test_connection();
-        let result = DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("PlayerName", 403.21);
-        assert_eq!(result.is_ok(), true);
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        assert_eq!(players.len(), 2);
-        let new_player = players.get(1).unwrap();
-        assert_eq!(new_player.name, "PlayerName");
-        assert_eq!(
-            (new_player.cp, new_player.sp, new_player.gp, new_player.pp),
-            (1, 2, 3, 4)
-        );
-    }
-
-    #[test]
-    fn as_admin_resolve_claims() {
-        let conn = test_connection();
-        let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
-        assert_eq!(claims.len(), 0);
-
-        // Add items
-        assert_eq!(
-            DbApi::with_conn(&conn)
-                .as_admin()
-                .add_loot(vec![("Épée", 40), ("Arc", 40),])
-                .is_ok(),
-            true
-        );
-        // Add players
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("Player1", 0.0)
-            .unwrap();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("Player2", 0.0)
-            .unwrap();
-        // Put claims on one different item each
-        DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
-        DbApi::with_conn(&conn).as_player(2).claim(2).unwrap();
-        let result = DbApi::with_conn(&conn).as_admin().resolve_claims();
-        assert_eq!(result.is_ok(), true);
-        // Check that both players received an item
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        for &i in [1, 2].into_iter() {
-            assert_eq!(
-                DbApi::with_conn(&conn).as_player(i).loot().unwrap().len(),
-                1
-            );
-            let player = players.get(i as usize).unwrap();
-            assert_eq!(player.debt, 20);
-        }
-    }
-
-    #[test]
-    fn as_player_claim_item() {
-        let conn = test_connection();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("Player", 0.0)
-            .unwrap();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_loot(vec![("Épée", 25)])
-            .unwrap();
-        // Claim an existing item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
-        assert_eq!(result.is_ok(), true);
-        let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
-        assert_eq!(claims.len(), 1);
-        let claim = claims.get(0).unwrap();
-        assert_eq!(claim.player_id, 1);
-        assert_eq!(claim.loot_id, 1);
-        // Claim an inexistant item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(2);
-        assert_eq!(result.is_ok(), false);
-    }
-
-    #[test]
-    fn as_player_unclaim_item() {
-        let conn = test_connection();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("Player", 0.0)
-            .unwrap();
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_loot(vec![("Épée", 25)])
-            .unwrap();
-        // Claim an existing item
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
-        assert_eq!(result.is_ok(), true);
-        // Claiming twice is an error
-        let result = DbApi::with_conn(&conn).as_player(1).claim(1);
-        assert_eq!(result.is_ok(), false);
-        // Unclaiming and item
-        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
-        assert_eq!(result.is_ok(), true);
-        // Check that not claimed items will not be unclaimed...
-        let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
-        assert_eq!(result.is_ok(), false);
-        let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
-        assert_eq!(claims.len(), 0);
-    }
-
-    /// All-in-one checks one a simple buy/sell procedure
+/// Split up and share an certain amount of group money among selected players
 ///
-    /// Checks that player's chest and wealth are updated.
-    /// Checks that items are sold at half their value.
-    /// Checks that a player cannot sell item he does not own.
-    #[test]
-    fn as_player_simple_buy_sell() {
-        let conn = test_connection();
-        // Adds a sword into inventory
-        {
-            use schema::items::dsl::*;
-            diesel::insert_into(items)
-                .values((name.eq("Sword"), base_price.eq(800)))
-                .execute(&conn)
-                .expect("Could not set up items table");
+/// The group first solve players debts,
+/// then give what's left.
+///
+/// # Returns
+///
+/// A Wealth update with the amount of money shared with players
+pub fn split_and_share(
+    conn: &DbConnection,
+    amount: i32,
+    players: Vec<i32>,
+) -> UpdateResult {
+    let players = match players.is_empty() {
+        true => Players(conn)
+            .all_except_group()?
+            .iter()
+            .map(|p| p.id)
+            .collect(),
+        false => players
+    };
+    let share = (
+        amount / (players.len() + 1) as i32
+        // +1 share for the group
+    ) as f64;
+    conn.transaction(|| {
+        let mut shared_total = 0.0;
+        for id in players {
+            let player = Players(conn).find(id)?;
+            // Take debt into account
+            match share - player.debt as f64 {
+                rest if rest > 0.0 => {
+                    AsPlayer(conn, id).update_debt(-player.debt)?;
+                    AsPlayer(conn, id).update_wealth(rest)?;
+                    AsPlayer(conn, 0).update_wealth(-rest)?;
+                    shared_total += rest;
                }
-        DbApi::with_conn(&conn)
-            .as_admin()
-            .add_player("Player", 1000.0)
-            .unwrap();
-        // Buy an item
-        let bought = DbApi::with_conn(&conn).as_player(1).buy(&vec![(1, None)]);
-        assert_eq!(bought.ok(), Some((0, 0, 0, -8))); // Returns diff of player wealth ?
-        let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
-        assert_eq!(chest.len(), 1);
-        let loot = chest.get(0).unwrap();
-        assert_eq!(loot.name, "Sword");
-        assert_eq!(loot.base_price, 800);
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        let player = players.get(1).unwrap();
-        assert_eq!(player.pp, 2);
-        // A player cannot sell loot from an other's chest
-        let result = DbApi::with_conn(&conn)
-            .as_player(0)
-            .sell(&vec![(loot.id, None)]);
-        assert_eq!(result.is_ok(), false);
-        // Sell back
-        let sold = DbApi::with_conn(&conn)
-            .as_player(1)
-            .sell(&vec![(loot.id, None)]);
-        assert_eq!(sold.ok(), Some((0, 0, 0, 4)));
-        let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
-        assert_eq!(chest.len(), 0);
-        let players = DbApi::with_conn(&conn).fetch_players().unwrap();
-        let player = players.get(1).unwrap();
-        assert_eq!(player.pp, 6);
-    }
-
-    #[test]
-    fn as_admin_add_loot() {
-        let conn = test_connection();
-        assert_eq!(
-            0,
-            DbApi::with_conn(&conn).as_player(0).loot().unwrap().len()
-        );
-        let loot_to_add = vec![("Cape d'invisibilité", 8000), ("Arc long", 25)];
-        let result = DbApi::with_conn(&conn)
-            .as_admin()
-            .add_loot(loot_to_add.clone());
-        assert_eq!(result.is_ok(), true);
-        let looted = DbApi::with_conn(&conn).as_player(0).loot().unwrap();
-        assert_eq!(looted.len(), 2);
-        // NB: Not a problem now, but this adds constraints of items being
-        //     created in the same order.
-        for (added, to_add) in looted.into_iter().zip(loot_to_add) {
-            assert_eq!(added.name, to_add.0);
-            assert_eq!(added.base_price, to_add.1);
+                _ => {
+                    AsPlayer(conn, id).update_debt(-share as i32)?;
                }
            }
        }
+        Ok(vec!(Update::Wealth(Wealth::from_gp(shared_total))))
+    })
+}
--- a/lootalot_db/src/models/claim.rs
+++ b/lootalot_db/src/models/claim.rs
@@ -1,11 +1,11 @@
-use crate::{DbConnection, QueryResult};
 use diesel::prelude::*;

+use crate::{DbConnection, QueryResult, Update, UpdateResult};
 use crate::models::{self, item::Loot};
 use crate::schema::claims;

 /// A Claim is a request by a single player on an item from group chest.
-#[derive(Identifiable, Queryable, Associations, Serialize, Deserialize, Debug)]
+#[derive(Identifiable, Queryable, Associations, Serialize, Deserialize, Clone, Copy, Debug)]
 #[belongs_to(Loot)]
 pub struct Claim {
    /// DB Identifier
@@ -41,6 +41,11 @@ impl<'q> Claims<'q> {
        claims::table.load(self.0)
    }

+    pub fn by_player(&self, id: i32) -> QueryResult<Vec<Claim>> {
+        claims::table.filter(claims::dsl::player_id.eq(id))
+            .load(self.0)
+    }
+
    /// Finds a single claim by association of player and loot ids.
    pub fn find(&self, player_id: i32, loot_id: i32) -> QueryResult<Claim> {
        claims::table
@@ -54,7 +59,7 @@ impl<'q> Claims<'q> {
    /// 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> {
+    pub fn add(self, player_id: i32, loot_id: i32) -> UpdateResult {
        // We need to validate that the claimed item exists
        // AND is actually owned by group (id 0)
        let _item = models::item::LootManager(self.0, 0).find(loot_id)?;
@@ -68,16 +73,22 @@ impl<'q> Claims<'q> {
            .values(&claim)
            .execute(self.0)?;
        // Return the created claim
+        Ok(vec!(
+            Update::ClaimAdded(
                claims::table
                    .order(claims::dsl::id.desc())
-            .first::<Claim>(self.0)
+                    .first::<Claim>(self.0)?
+            )
+        ))
    }

    /// Removes a claim from database, returning it
-    pub fn remove(self, player_id: i32, loot_id: i32) -> QueryResult<Claim> {
+    pub fn remove(self, player_id: i32, loot_id: i32) -> UpdateResult {
        let claim = self.find(player_id, loot_id)?;
        claim.remove(self.0)?;
-        Ok(claim)
+        Ok(vec!(
+            Update::ClaimRemoved(claim)
+        ))
    }

    pub fn filtered_by_loot(&self, loot_id: i32) -> QueryResult<Vec<Claim>> {
@@ -86,6 +97,15 @@ impl<'q> Claims<'q> {
            .load(self.0)
    }

+    pub(crate) fn delete_for_loot(&self, loot_id: i32) -> QueryResult<usize> {
+        diesel::delete(
+            claims::table
+                .filter(claims::dsl::loot_id.eq(loot_id))
+        )
+            .execute(self.0)
+
+    }
+
    pub(crate) fn grouped_by_item(&self) -> QueryResult<Vec<(models::item::Item, Vec<Claim>)>> {
        let group_loot: Vec<Loot> = Loot::owned_by(0).load(self.0)?;
        let claims = claims::table.load(self.0)?.grouped_by(&group_loot);
--- a/lootalot_db/src/models/history.rs
+++ b/lootalot_db/src/models/history.rs
@@ -0,0 +1,105 @@
+use serde_json;
+use diesel::prelude::*;
+use diesel::sql_types::Text;
+use diesel::deserialize::FromSql;
+use diesel::backend::Backend;
+use crate::schema::history;
+use crate::{DbConnection, QueryResult, Update};
+
+#[derive(Debug, FromSqlRow)]
+pub struct UpdateList(Vec<Update>);
+
+impl UpdateList {
+    pub fn inner(&self) -> &Vec<Update> {
+        &self.0
+    }
+
+    pub fn into_inner(self) -> Vec<Update> {
+        self.0
+    }
+}
+
+// TODO: decide if updates is really optionnal or not
+// (like if storing an event without update is usefull ?)
+
+/// An event in history
+#[derive(Debug, Queryable)]
+pub struct Event {
+    id: i32,
+    player_id: i32,
+    event_date: String,
+    text: String,
+    updates: Option<UpdateList>,
+}
+
+impl Event {
+    pub fn name(&self) -> &str {
+        &self.text
+    }
+
+    /// TODO: why a move here ??
+    /// Undo all updates in a single transaction
+    pub fn undo(self, conn: &DbConnection) -> QueryResult<()> {
+        conn.transaction(move || {
+            if let Some(ref updates) = self.updates {
+                for update in updates.inner() {
+                    update.undo(conn, self.player_id)?;
+                }
+            }
+            Ok(())
+        })
+    }
+}
+
+impl<DB: Backend> FromSql<Text, DB> for UpdateList
+where
+    String: FromSql<Text, DB>,
+{
+    fn from_sql(bytes: Option<&DB::RawValue>) -> diesel::deserialize::Result<Self> {
+        let repr = String::from_sql(bytes)?;
+        Ok(UpdateList(serde_json::from_str::<Vec<Update>>(&repr)?))
+    }
+}
+
+
+#[derive(Debug, Insertable)]
+#[table_name = "history"]
+struct NewEvent<'a> {
+    player_id: i32,
+    text: &'a str,
+    updates: Option<String>,
+}
+
+
+/// Insert a new event
+///
+/// # Warning
+/// This actually swallow up conversion errors
+pub fn insert_event(conn: &DbConnection, id: i32, text: &str, updates: &Vec<Update>) -> QueryResult<Event> {
+    diesel::insert_into(history::table)
+        .values(&NewEvent {
+            player_id: id,
+            text,
+            updates: serde_json::to_string(updates).ok(),
+        })
+        .execute(conn)?;
+    history::table
+        .order(history::dsl::id.desc())
+        .first(conn)
+}
+
+pub fn get_last_of_player(conn: &DbConnection, id: i32) -> QueryResult<Event> {
+    history::table
+        .filter(history::dsl::player_id.eq(id))
+        .order(history::dsl::id.desc())
+        .first(conn)
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_insert_event_with_updates() {
+
+    }
+}
--- a/lootalot_db/src/models/item.rs
+++ b/lootalot_db/src/models/item.rs
@@ -2,10 +2,10 @@ 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);
+use crate::schema::{items, loot};
+use crate::{Claims, DbConnection, QueryResult, Update, UpdateResult};
+type ItemColumns = (loot::id, loot::name, loot::base_price);
+const ITEM_COLUMNS: ItemColumns = (loot::id, loot::name, loot::base_price);
 type OwnedBy = Select<OwnedLoot, ItemColumns>;

 /// Represents a basic item
@@ -18,13 +18,13 @@ pub struct Item {

 impl Item {
    /// Returns this item value
-    pub fn value(&self) -> i32 {
-        self.base_price
+    pub fn value(&self) -> f64 {
+        self.base_price as f64
    }

    /// Returns this item sell value
-    pub fn sell_value(&self) -> i32 {
-        self.base_price / 2
+    pub fn sell_value(&self) -> f64 {
+        self.base_price as f64 / 2.0
    }

    fn owned_by(player: i32) -> OwnedBy {
@@ -32,6 +32,53 @@ impl Item {
    }
 }

+// Owner status
+pub(crate) const OF_GROUP: i32 = 0;
+pub(crate) const OF_SHOP: i32 = -1;
+pub(crate) const SOLD: i32 = -2;
+
+type WithOwner = Eq<loot::owner_id, i32>;
+type OwnedLoot = Filter<loot::table, WithOwner>;
+
+/// An owned item
+///
+/// The owner is a Player, the Group, the Merchant
+/// OR the SOLD state.
+#[derive(Identifiable, Debug, Queryable)]
+#[table_name = "loot"]
+pub(crate) struct Loot {
+    id: i32,
+    name: String,
+    base_price: i32,
+    owner_id: i32,
+}
+
+impl Loot {
+    /// A filter on Loot that is owned by given player
+    pub(super) fn owned_by(id: i32) -> OwnedLoot {
+        loot::table.filter(loot::owner_id.eq(id))
+    }
+
+    pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> {
+        diesel::update(loot::table.find(self.id))
+            .set(loot::dsl::owner_id.eq(owner))
+            .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<loot::table, i32> {
+        loot::table.find(id)
+    }
+}
+
 pub struct Inventory<'q>(pub &'q DbConnection);

 impl<'q> Inventory<'q> {
@@ -44,49 +91,93 @@ impl<'q> Inventory<'q> {
    pub fn find(&self, item_id: i32) -> QueryResult<Item> {
        items::table.find(item_id).first::<Item>(self.0)
    }
+
+    pub fn find_by_name(&self, item_name: &str) -> QueryResult<Item> {
+        Ok(items::table
+            .filter(items::dsl::name.like(item_name))
+            .first(self.0)?)
    }

-type WithOwner = Eq<looted::owner_id, i32>;
-type OwnedLoot = Filter<looted::table, WithOwner>;
-
-/// Represents an item that has been looted,
-/// hence has an owner.
-#[derive(Identifiable, Debug, Queryable)]
-#[table_name = "looted"]
-pub(super) struct Loot {
-    id: i32,
-    name: String,
-    base_price: i32,
-    owner: i32,
+    /// Check the inventory against a list of item names
+    ///
+    /// # Returns
+    ///
+    /// A tuple of found items and errors
+    pub fn check_list(&self, item_names: Vec<String>) -> QueryResult<(Vec<Item>, String)> {
+        let all_items = self.all()?;
+        let mut found = Vec::new();
+        let mut errors = String::new();
+        for name in &item_names {
+            match self.find_by_name(name) {
+                Ok(item) => found.push(item),
+                Err(_) => errors.push_str(&format!("{},\n", name)),
+            }
+        }
+        Ok((found, errors))
+    }
 }

-impl Loot {
-    /// A filter on Loot that is owned by given player
-    pub(super) fn owned_by(id: i32) -> OwnedLoot {
-        looted::table.filter(looted::owner_id.eq(id))
+/// The shop resource
+pub struct Shop<'q>(pub &'q DbConnection);
+
+impl<'q> Shop<'q> {
+    // Rename to list
+    pub fn all(&self) -> QueryResult<Vec<Item>> {
+        Item::owned_by(OF_SHOP).load(self.0)
    }

-    fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
-        exists(looted::table.find(id))
+    fn buy_single(&self, buyer: i32, item_id: i32, price_mod: Option<f64>) -> UpdateResult {
+        use crate::AsPlayer;
+        let item = self.get(item_id)?;
+        let sell_price = match price_mod {
+            Some(modifier) => item.base_price as f64 * modifier,
+            None => item.base_price as f64,
+        };
+        self.0.transaction(|| {
+            let mut updates = AsPlayer(self.0, buyer).update_wealth(-sell_price)?;
+            item.set_owner(buyer, self.0)?;
+            updates.push(Update::ItemBought(item.into_item()));
+            Ok(updates)
+        })
    }

-    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)?;
+    pub fn buy(&self, items: Vec<(i32, Option<f64>)>, buyer: i32) -> UpdateResult {
+        // TODO: check that player has enough money !
+        let has_enough_gold = true;
+
+        if has_enough_gold {
+            let mut updates = Vec::new();
+            for (item_id, price_mod) in items.into_iter() {
+                updates.append(&mut self.buy_single(buyer, item_id, price_mod)?)
+            }
+            Ok(updates)
+        } else {
+            unimplemented!();
+        }
+    }
+
+    pub(crate) fn get(&self, id: i32) -> QueryResult<Loot> {
+        Loot::owned_by(OF_SHOP).find(&id).first::<Loot>(self.0)
+    }
+
+    pub fn replace_list(&self, items: Vec<Item>) -> QueryResult<()> {
+        use self::loot::dsl::*;
+        self.0.transaction(|| -> QueryResult<()> {
+            // Remove all content
+            diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?;
+            // Adds new list
+            for item in &items {
+                let new_item = NewLoot {
+                    name: &item.name,
+                    base_price: item.base_price,
+                    owner_id: OF_SHOP,
+                };
+                diesel::insert_into(loot)
+                    .values(&new_item)
+                    .execute(self.0)?;
+            }
            Ok(())
-    }
-
-    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)
+        })
    }
 }

@@ -99,32 +190,54 @@ impl<'q> LootManager<'q> {
        Ok(Item::owned_by(self.1).load(self.0)?)
    }

+    pub(crate) fn get(&self, item_id: i32) -> QueryResult<Loot> {
+        Ok(Loot::owned_by(self.1).find(item_id).first(self.0)?)
+    }
+
+    pub(crate) fn change_owner(&self, item_id: i32, new_owner: i32) -> QueryResult<()> {
+        Ok(self.get(item_id)?.set_owner(new_owner, self.0)?)
+    }
+
    /// Finds an item by id
    ///
    /// Returns a NotFound error if an item is found by it
    /// 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,
+        Ok(self.get(loot_id)?.into_item())
+    }
+
+    fn sell_single(&self, loot_id: i32, price_mod: Option<f64>) -> UpdateResult {
+        let to_sell = self.get(loot_id)?;
+        let mut sell_value = to_sell.base_price as f64 / 2.0;
+        if let Some(modifier) = price_mod {
+            sell_value *= modifier;
+        }
+        self.0.transaction(|| {
+            let mut updates = crate::AsPlayer(self.0, self.1).update_wealth(sell_value)?;
+            to_sell.set_owner(SOLD, self.0)?;
+            updates.push(Update::ItemSold(to_sell.into_item()));
+            Ok(updates)
        })
    }
-        })?)
+
+    pub fn sell(&self, items: Vec<(i32, Option<f64>)>) -> UpdateResult {
+        self.0.transaction(|| {
+            let mut updates = Vec::new();
+            for (loot_id, price_mod) in items.into_iter() {
+                updates.append(&mut self.sell_single(loot_id, price_mod)?);
+            }
+            Ok(updates)
+        })
    }

    /// The last item added to the chest
    pub fn last(&self) -> QueryResult<Item> {
        Ok(Item::owned_by(self.1)
-            .order(looted::dsl::id.desc())
+            .order(loot::dsl::id.desc())
            .first(self.0)?)
    }

-    pub(crate) fn add<S: Into<String>>(self, name: S, base_price: i32) -> QueryResult<Item> {
+    pub(crate) fn add<S: Into<String>>(self, name: S, base_price: i32) -> UpdateResult {
        self.add_from(&Item {
            id: 0,
            name: name.into(),
@@ -133,33 +246,34 @@ impl<'q> LootManager<'q> {
    }

    /// Adds a copy of the given item inside player chest
-    pub fn add_from(self, item: &Item) -> QueryResult<Item> {
+    pub fn add_from(self, item: &Item) -> UpdateResult {
        let new_item = NewLoot {
            name: &item.name,
            base_price: item.base_price,
            owner_id: self.1,
        };
-        diesel::insert_into(looted::table)
+        diesel::insert_into(loot::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)
+        Ok(vec![Update::ItemAdded(self.last()?)])
    }
 }

-/// An item being looted or bought.
+/// An item being loot or bought.
 ///
 /// The owner is set to 0 in case of looting,
 /// to the id of buying player otherwise.
 #[derive(Insertable)]
-#[table_name = "looted"]
+#[table_name = "loot"]
 struct NewLoot<'a> {
    name: &'a str,
    base_price: i32,
    owner_id: i32,
 }
+
+#[derive(Insertable)]
+#[table_name = "items"]
+struct NewItem<'a> {
+    name: &'a str,
+    base_price: i32,
+}
--- a/lootalot_db/src/models/mod.rs
+++ b/lootalot_db/src/models/mod.rs
@@ -1,6 +1,7 @@
 pub mod claim;
 pub mod item;
 pub mod player;
+pub mod history;

 pub use claim::Claim;
 pub use item::Item;
--- a/lootalot_db/src/models/player/mod.rs
+++ b/lootalot_db/src/models/player/mod.rs
@@ -1,5 +1,5 @@
 use crate::schema::players;
-use crate::{DbConnection, QueryResult};
+use crate::{DbConnection, QueryResult, Update, UpdateResult};
 use diesel::prelude::*;

 mod notification;
@@ -35,6 +35,12 @@ impl<'q> Players<'q> {
        players::table.load(self.0)
    }

+    /// Get all non-group players
+    pub fn all_except_group(&self) -> QueryResult<Vec<Player>> {
+        use diesel::dsl::not;
+        players::table.filter(not(players::id.eq(0))).load(self.0)
+    }
+
    /// Find a player by id
    pub fn find(&self, id: i32) -> QueryResult<Player> {
        players::table.find(id).first(self.0)
@@ -50,10 +56,7 @@ impl<'q> Players<'q> {

    /// 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)
-        {
+        for id in self.all()?.into_iter().map(|p| p.id) {
            self.notify(id, text);
        }
        Ok(())
@@ -75,7 +78,7 @@ impl<'q> AsPlayer<'q> {
        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> {
+    pub fn update_wealth(&self, value_in_gp: f64) -> UpdateResult {
        use crate::schema::players::dsl::*;
        let current_wealth = players
            .find(self.1)
@@ -86,7 +89,7 @@ impl<'q> AsPlayer<'q> {
            .filter(id.eq(self.1))
            .set(&updated_wealth)
            .execute(self.0)?;
-        Ok(updated_wealth - current_wealth)
+        Ok(vec!(Update::Wealth(updated_wealth - current_wealth)))
    }

    /// Updates this player's debt
--- a/lootalot_db/src/models/player/wealth.rs
+++ b/lootalot_db/src/models/player/wealth.rs
@@ -22,7 +22,7 @@ fn unpack_gold_value(gold: f64) -> (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, Serialize, Deserialize, Debug)]
+#[derive(Queryable, AsChangeset, Serialize, Deserialize, PartialEq, Copy, Clone, Debug)]
 #[table_name = "players"]
 pub struct Wealth {
    pub cp: i32,
@@ -69,12 +69,7 @@ impl std::ops::Sub for Wealth {
    /// 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,
-        }
+        Wealth::from_gp(self.to_gp() - other.to_gp())
    }
 }

@@ -82,12 +77,7 @@ 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
-        }
+        Wealth::from_gp(self.to_gp() + other.to_gp())
    }
 }

@@ -116,4 +106,52 @@ mod tests {
        }
    }

+    #[test]
+    fn test_negative_wealth() {
+        use super::Wealth;
+
+        assert_eq!(
+            Wealth{ cp: 3, sp: 2, gp: 1, pp: 0 } + Wealth{ cp: -8, pp: 0, sp: 0, gp: 0 },
+            Wealth::from_gp(1.23 - 0.08)
+        )
+
+    }
+    #[test]
+    fn test_negative_wealth_inverse() {
+        use super::Wealth;
+
+        assert_eq!(
+            (Wealth{ cp: 3, sp: 2, gp: 1, pp: 0 } + Wealth{ cp: -8, pp: 0, sp: 0, gp: 0 }).to_gp(),
+            1.23 - 0.08
+        )
+
+    }
+    #[test]
+    fn test_diff_adding() {
+        use super::Wealth;
+
+        // Let say we add 0.08 gp
+        // 1.23 + 0.08 gold is 1.31, diff is cp: -2, sp: +1
+        let old = Wealth::from_gp(1.23);
+        let new = Wealth::from_gp(1.31);
+        let diff = new - old;
+        assert_eq!(diff.as_tuple(), (-2, 1, 0, 0));
+        assert_eq!(diff.to_gp(), 0.08);
+        assert_eq!(new - diff, old);
+
+    }
+    #[test]
+    fn test_diff_subbing() {
+        use super::Wealth;
+
+        // Let say we sub 0.08 gp
+        // 1.31 - 0.08 gold is 1.23, diff is cp: +2, sp: -1
+        let old = Wealth::from_gp(1.31);
+        let new = Wealth::from_gp(1.23);
+        let diff = new - old;
+        assert_eq!(diff.as_tuple(), (2, -1, 0, 0));
+        assert_eq!(diff.to_gp(), -0.08);
+        assert_eq!(new - diff, old);
+    }
+
 }
--- 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,
@@ -16,7 +26,7 @@ table! {
 }

 table! {
-    looted (id) {
+    loot (id) {
        id -> Integer,
        name -> Text,
        base_price -> Integer,
@@ -44,15 +54,16 @@ table! {
    }
 }

-joinable!(claims -> looted (loot_id));
 joinable!(claims -> players (player_id));
-joinable!(looted -> players (owner_id));
+joinable!(history -> players (player_id));
+joinable!(loot -> players (owner_id));
 joinable!(notifications -> players (player_id));

 allow_tables_to_appear_in_same_query!(
    claims,
+    history,
    items,
-    looted,
+    loot,
    notifications,
    players,
 );
--- a/lootalot_front/.browserslistrc
+++ b/lootalot_front/.browserslistrc
@@ -1,2 +0,0 @@
-> 1%
-last 2 versions
--- a/lootalot_front/.eslintrc.js
+++ b/lootalot_front/.eslintrc.js
@@ -1,27 +0,0 @@
-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/.gitignore
+++ b/lootalot_front/.gitignore
@@ -1,21 +0,0 @@
-.DS_Store
-node_modules
-/dist
-
-# local env files
-.env.local
-.env.*.local
-
-# Log files
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Editor directories and files
-.idea
-.vscode
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
--- a/lootalot_front/README.md
+++ b/lootalot_front/README.md
@@ -1,29 +0,0 @@
-# lootalot_front
-
-## Project setup
-```
-npm install
-```
-
-### Compiles and hot-reloads for development
-```
-npm run serve
-```
-
-### Compiles and minifies for production
-```
-npm run build
-```
-
-### Run your tests
-```
-npm run test
-```
-
-### Lints and fixes files
-```
-npm run lint
-```
-
-### Customize configuration
-See [Configuration Reference](https://cli.vuejs.org/config/).
--- a/lootalot_front/babel.config.js
+++ b/lootalot_front/babel.config.js
@@ -1,5 +0,0 @@
-module.exports = {
-  presets: [
-    '@vue/app'
-  ]
-}
--- a/lootalot_front/package.json
+++ b/lootalot_front/package.json
@@ -1,29 +0,0 @@
-{
-  "name": "lootalot_front",
-  "version": "0.1.0",
-  "private": true,
-  "scripts": {
-    "serve": "vue-cli-service serve",
-    "build": "vue-cli-service build",
-    "lint": "vue-cli-service lint",
-    "test:unit": "vue-cli-service test:unit"
-  },
-  "main": "sass/scroll.scss",
-  "dependencies": {
-    "bulma": "^0.7.5",
-    "core-js": "^2.6.5",
-    "vue": "^2.6.10"
-  },
-  "devDependencies": {
-    "@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",
-    "chai": "^4.1.2",
-    "eslint": "^5.16.0",
-    "eslint-plugin-vue": "^5.0.0",
-    "vue-template-compiler": "^2.6.10"
-  }
-}
--- a/lootalot_front/postcss.config.js
+++ b/lootalot_front/postcss.config.js
@@ -1,5 +0,0 @@
-module.exports = {
-  plugins: {
-    autoprefixer: {}
-  }
-}
--- a/lootalot_front/public/css/scroll.css
+++ b/lootalot_front/public/css/scroll.css
--- a/lootalot_front/public/favicon.ico
+++ b/lootalot_front/public/favicon.ico
--- a/lootalot_front/public/index.html
+++ b/lootalot_front/public/index.html
@@ -1,20 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-        <meta charset="utf-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <meta http-equiv="X-UA-Compatible" content="IE=edge">
-        <meta name="viewport" content="width=device-width,initial-scale=1.0">
-        <link rel="icon" href="<%= BASE_URL %>favicon.ico">
-        <link rel="stylesheet" href="<%= BASE_URL %>css/scroll.css">
-        <title>Loot-a-Lot !</title>
-        <script defer src="<%= BASE_URL %>fontawesome/js/all.js"></script>
-</head>
-<body>
-    <div id="app"></div>
-    <!-- built files will be auto injected -->
-    <noscript>
-      <strong>We're sorry but lootalot_front doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
-    </noscript>
-  </body>
-</html>
--- a/lootalot_front/sass/scroll.scss
+++ b/lootalot_front/sass/scroll.scss
@@ -1,21 +0,0 @@
-@charset "utf-8";
-
-$brown: #757763;
-$beige: #C9AD6A;
-$beige-light: #E0E5C1;
-$beige-lighter: #EEE5CE;
-$red: #B7321B;
-$dark-red: #58180D;
-$yellow-light: #FCF2C5;
-
-$link: $brown;
-$primary: $brown;
-$info: $beige;
-$danger: $red;
-
-$table-cell-border: 1px solid $dark-red;
-$table-striped-row-even-background-color: $yellow-light;
-
-$button-padding-horizontal: 1em;
-
-@import "../node_modules/bulma/bulma.sass";
--- a/lootalot_front/src/App.vue
+++ b/lootalot_front/src/App.vue
@@ -1,187 +0,0 @@
-<template>
-  <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 PlayerView from './components/PlayerView.js'
-import HeaderBar from './components/HeaderBar.vue'
-import Wealth from './components/Wealth.vue'
-import Chest from './components/Chest.vue'
-import Loot from './components/Loot.vue'
-import { api } from './lootalot.js'
-
-function getCookie(cname) {
-  var name = cname + "=";
-  var decodedCookie = decodeURIComponent(document.cookie);
-  var ca = decodedCookie.split(';');
-  for(var i = 0; i <ca.length; i++) {
-    var c = ca[i];
-    while (c.charAt(0) == ' ') {
-      c = c.substring(1);
-    }
-    if (c.indexOf(name) == 0) {
-      return c.substring(name.length, c.length);
-    }
-  }
-  return "";
-}
-
-export default {
-  name: 'app',
-  data () {
-      return {
-        player_id: 0,
-        playerList: [],
-        activeView: 'group',
-        groupLoot: [],
-        itemsInventory: [],
-        itemsInShop: [{id: 1, name: "Item from shop #1", base_price: 2000}],
-        pending_loot: [],
-        initiated: false,
-      };
-  },
-  components: {
-    PlayerView,
-    HeaderBar,
-    'AddingChest': Chest, // Alias to prevent component re-use 
-    Chest,
-    Wealth,
-    Loot,
-  },
-  created () {
-      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 scoped>
-    header {
-        padding-bottom: 1.5em;
-    }
-</style>
--- a/lootalot_front/src/assets/logo.png
+++ b/lootalot_front/src/assets/logo.png
--- a/lootalot_front/src/components/Chest.vue
+++ b/lootalot_front/src/components/Chest.vue
@@ -1,166 +0,0 @@
-<template>
-  <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 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>{{ 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 shownItems">
-          <tr :key="`row-${idx}`">
-            <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 Request from './Request.vue'
-    import PercentInput from './PercentInput.vue'
-    import Selector from './Selector.vue'
-    import { api } from '../lootalot.js'
-    /*
-        The chest displays a collection of items.
-
-        A set of permissions is passed as props, to update
-        the possible actions of active user upon these items.
-
-    */
-    export default {
-        props: {
-            player: {
-                type: Number,
-                required: true,
-            },
-            items: {
-                type: Array,
-                required: true,
-            },
-            perms: {
-                type: Object,
-                required: true,
-            },
-            claims: {
-                type: Object,
-                required: true,
-            },
-        },
-        components: {
-            Request,
-            PercentInput,
-            Selector,
-        },
-        data () {
-            return {
-                is_selling: false,
-                selected_items: [],
-                global_mod: 0,
-                searchText: "",
-            };
-        },
-        methods: {
-            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: {
-            shownItems () {
-                if (this.searchText != "") {
-                    const searchText = this.searchText.toUpperCase();
-                    return this.items.filter(item => item.name.toUpperCase().includes(searchText));
-                } else {
-                    return this.items;
-                }
-            },
-            showSelectors () {
-                return !this.perms.canGrab
-                    && (this.is_selling || this.perms.canBuy);
-            },
-            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;
-            },
-        },
-    }
-</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
@@ -1,36 +0,0 @@
-<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,109 +0,0 @@
-<template>
-    <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>
-</template>
-
-<script>
-    export default {
-        props: ["source"],
-        data () {
-            return {
-                is_loading: false,
-                item: {
-                    id: 0,
-                    name: '',
-                    base_price: '',
-                },
-                results: [],
-            };
-        },
-        methods: {
-            autoCompletion () {
-                // Unset any previous value on input (for every field except item's name)
-                this.item.base_price = '';
-                if (this.item.name == '') {
-                    this.results = [];
-                } else {
-                    this.results = this.source.filter(
-                        item => item.name.toUpperCase().includes(this.item.name.toUpperCase())
-                    );
-                }
-            },
-            setResult(result) {
-                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.item);
-                this.item = {
-                    name: '',
-                    base_price: '',
-                };
-                this.results = [];
-            },
-        },
-        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;
-}
-</style>
--- a/lootalot_front/src/components/Loot.vue
+++ b/lootalot_front/src/components/Loot.vue
@@ -1,35 +0,0 @@
-<template>
-  <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>
-    <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 {}; },
-        methods: {
-            onAddItem (item) {
-                this.$emit('addItem', item);
-            },
-        }
-
-    }
-</script>
--- a/lootalot_front/src/components/PercentInput.vue
+++ b/lootalot_front/src/components/PercentInput.vue
@@ -1,41 +0,0 @@
-<template>
-  <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/PlayerView.js
+++ b/lootalot_front/src/components/PlayerView.js
@@ -1,107 +0,0 @@
-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,92 +0,0 @@
-<template>
-  <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>
-    </template>
-    <button class="button is-primary"
-      @click="putRequest"
-      :disabled="isRequested">
-      <span class="icon is-small">
-        <i class="fas fa-praying-hands"></i>
-      </span>
-    </button>
-  </div>
-</template>
-
-<script>
-    export default {
-        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 () {
-                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 () {
-                var reqByPlayer = false;
-                var reqByOther = false;
-                for (var id in this.claims) {
-                    const isReq = this.claims[id].includes(this.item);
-                    if (isReq) {
-                        if (id == this.id) {
-                            reqByPlayer = true;
-                        } else {
-                            reqByOther = true;
-                        }
-                    }
-                }
-                return reqByPlayer && reqByOther;
-            },
-        },
-        methods: {
-            // The active player claims the item
-            putRequest () {
-                this.$emit("claim", this.item);
-            },
-            // The active player withdraws his request
-            cancelRequest () {
-                this.$emit("unclaim", this.item);
-            },
-            // The active player insist on his claim
-            // TODO: Find a simple and fun system to express
-            //       how much each player want an item
-            hardenRequest () {
-            }
-        },
-    }
-</script>
-
-<style scoped>
-    .buttons, .button { margin-bottom: 0; }
-</style>
--- a/lootalot_front/src/components/Selector.vue
+++ b/lootalot_front/src/components/Selector.vue
@@ -1,57 +0,0 @@
-<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,97 +0,0 @@
-<template>
-  <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>
-      <div class="level-item">
-        <button class="button is-danger" @click="updateWealth()">
-          Modifier
-        </button>
-      </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 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>
-    export default {
-        props: ["wealth", "debt"],
-        data () { 
-            return {
-              editing: false,
-              edit_value: 0,
-            }; 
-        },
-        methods: {
-            updateWealth () {
-                this.$emit("update", this.edit_value);
-                this.resetValues();
-            },
-            resetValues () {
-              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
@@ -1,20 +0,0 @@
-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/src/main.js
+++ b/lootalot_front/src/main.js
@@ -1,8 +0,0 @@
-import Vue from 'vue'
-import App from './App.vue'
-
-Vue.config.productionTip = false
-
-new Vue({
-  render: h => h(App),
-}).$mount('#app')
--- a/lootalot_front/tests/unit/.eslintrc.js
+++ b/lootalot_front/tests/unit/.eslintrc.js
@@ -1,5 +0,0 @@
-module.exports = {
-  env: {
-    mocha: true
-  }
-}
--- a/lootalot_front/tests/unit/ItemInput.spec.js
+++ b/lootalot_front/tests/unit/ItemInput.spec.js
@@ -1,94 +0,0 @@
-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
@@ -1,14 +0,0 @@
-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
@@ -1,49 +1,29 @@
-use diesel::prelude::*;
-use lootalot_db::{self as db, DbConnection, QueryResult};
+use diesel::connection::Connection;
+use lootalot_db::{self as db, DbConnection, Update, Value};
+use std::collections::HashSet;

+pub type IdList = Vec<i32>;
 pub type ItemListWithMods = Vec<(i32, Option<f64>)>;
+pub type ItemList = Vec<db::Item>;

 #[derive(Serialize, Deserialize, Debug)]
-pub struct SellParams {
+pub struct BuySellParams {
    pub items: ItemListWithMods,
-    players: Option<Vec<i32>>,
+    players: Option<IdList>,
    global_mod: Option<f64>,
 }

-/// Every possible update which can happen during a query
-#[derive(Serialize, Debug)]
-pub enum Update {
-    Wealth(db::Wealth),
-    ItemAdded(db::Item),
-    ItemRemoved(db::Item),
-    ClaimAdded(db::Claim),
-    ClaimRemoved(db::Claim),
+#[derive(Serialize, Deserialize, Debug)]
+pub struct NewGroupLoot {
+    source_name: String,
+    // claims_limit_date: String
+    pub items: ItemList,
 }

-/// Every value which can be queried
-#[derive(Debug)]
-pub enum Value {
-    Player(db::Player),
-    Item(db::Item),
-    Claim(db::Claim),
-    ItemList(Vec<db::Item>),
-    ClaimList(Vec<db::Claim>),
-    PlayerList(Vec<db::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),
-        }
-    }
+#[derive(Serialize, Deserialize, Debug)]
+pub struct NewPlayer {
+    name : String,
+    wealth : f64,
 }

 /// A generic response for all queries
@@ -60,14 +40,18 @@ pub struct ApiResponse {
 }

 impl ApiResponse {
-    fn push_update(&mut self, update: Update) {
+    fn push_updates(&mut self, mut updates: Vec<db::Update>) {
        if let Some(v) = self.updates.as_mut() {
-            v.push(update);
+            v.append(&mut updates);
        } else {
-            self.updates = Some(vec![update]);
+            self.updates = Some(updates);
        }
    }

+    fn push_update(&mut self, update: db::Update) {
+        self.push_updates(vec!(update))
+    }
+
    fn push_error<S: Into<String>>(&mut self, error: S) {
        if let Some(errors) = self.errors.as_mut() {
            *errors = format!("{}\n{}", errors, error.into());
@@ -76,7 +60,7 @@ impl ApiResponse {
        }
    }

-    fn set_value(&mut self, value: Value) {
+    fn set_value(&mut self, value: db::Value) {
        self.value = Some(value);
    }

@@ -90,124 +74,180 @@ pub enum ApiError {
    InvalidAction(String),
 }

-/// Every allowed queries on the database
-pub enum ApiActions {
-    FetchPlayers,
-    FetchInventory,
-    FetchClaims,
-    // Player actions
-    FetchPlayer(i32),
-    FetchNotifications(i32),
-    FetchLoot(i32),
-    UpdateWealth(i32, f64),
-    BuyItems(i32, Vec<(i32, Option<f64>)>),
-    SellItems(i32, Vec<(i32, Option<f64>)>),
-    SellGroupItems(i32, SellParams),
-    ClaimItem(i32, i32),
-    UnclaimItem(i32, i32),
-    // Group actions
-    AddLoot(Vec<db::Item>),
+pub enum ApiEndpoint {
+    InventoryList,
+    InventoryCheck(Vec<String>),
+    InventoryAdd(String, i32), // db::Inventory(conn)::add(new_item)
+
+    ShopList, // db::Shop(conn)::list()
+    BuyItems(i32, BuySellParams), // db::Shop(conn)::buy(params)
+    RefreshShop(ItemList), // db::Shop(conn)::replace_list(items)
+
+    ClaimsList,
+
+    // db::Players::get returns AsPlayer<'q>
+    PlayerList, //db::Players(conn)::list()
+    PlayerAdd(NewPlayer), //db::Players(conn)::add(player)
+    PlayerFetch(i32), // db::Players(conn)::get(id)
+    PlayerClaims(i32), // db::Players(conn)::get(id).claims()
+    PlayerNotifications(i32), // db::Players(conn)::get(id).notifications()
+    PlayerLoot(i32),// db::Players(conn)::get(id).loot()
+    PlayerUpdateWealth(i32, f64), // db::Players(conn)::get(id).update_wealth(f64)
+    SellItems(i32, BuySellParams), // db::Players(conn)::get(id).sell(params)
+    ClaimItems(i32, IdList), // db::Players(conn)::get(id).claim(items)
+    UndoLastAction(i32), // db::Players(conn)::get(id).undo_last()
+    AddLoot(NewGroupLoot), // db::Group(conn)::add_loot(loot)
+    ResolveClaims, // db::Group(conn)::resolve_claims()
 }

-pub enum AdminActions {
-    AddPlayer(String, f64),
-    //AddInventoryItem(pub String, pub i32),
-    ResolveClaims,
-    //SetClaimsTimeout(pub i32),
-}
+static ERROR_MSG : &str = "Une erreur est survenue";

 pub fn execute(
    conn: &DbConnection,
-    query: ApiActions,
+    query: ApiEndpoint,
 ) -> Result<ApiResponse, diesel::result::Error> {
    let mut response = ApiResponse::default();
-    match query {
-        ApiActions::FetchPlayers => {
-            response.set_value(Value::PlayerList(db::Players(conn).all()?));
+    // Return an Option<String> that describes what happened.
+    // If there is some value, store the actions in db so that it can be reversed.
+    let action_text: Option<(i32, &str)> = match query {
+        // Inventory
+        ApiEndpoint::InventoryList => {
+            match db::Inventory(conn).all() {
+                Ok(items) => response.set_value(Value::ItemList(items)),
+                Err(_) => response.push_error(ERROR_MSG),
            }
-        ApiActions::FetchInventory => {
-            response.set_value(Value::ItemList(db::Inventory(conn).all()?));
+            None
        }
-        ApiActions::FetchClaims => {
-            response.set_value(Value::ClaimList(db::fetch_claims(conn)?));
+        ApiEndpoint::InventoryCheck(names) => {
+            match db::Inventory(conn).check_list(names) {
+                Ok((items, errors)) => {
+                    response.set_value(Value::ItemList(items));
+                    response.push_error(errors);
                }
-        ApiActions::FetchPlayer(id) => {
+                Err(_) => response.push_error(ERROR_MSG),
+            }
+            None
+        }
+        ApiEndpoint::InventoryAdd(name, value) => {
+            response.push_error("Not implemented");
+            None
+        }
+        //Shop
+        ApiEndpoint::ShopList => {
+            match db::Shop(conn).all() {
+                Ok(items) => response.set_value(Value::ItemList(items)),
+                Err(_) => response.push_error(ERROR_MSG),
+            }
+            None
+        }
+        ApiEndpoint::BuyItems(buyer, params) => {
+            match db::Shop(conn).buy(params.items, buyer) {
+                Ok(updates) => {
+                    response.notify("Objets achetés !");
+                    response.push_updates(updates);
+                    Some((buyer, "Achat d'objets"))
+                },
+                Err(_) => {
+                    response.push_error(ERROR_MSG);
+                    None
+                }
+            }
+        }
+        // Players
+        ApiEndpoint::PlayerList => {
+            response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?));
+            None
+        }
+        ApiEndpoint::PlayerFetch(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()?));
+        ApiEndpoint::ClaimsList => {
+            response.set_value(Value::ClaimList(db::Claims(conn).all()?));
+            None
        }
-        ApiActions::FetchLoot(id) => {
+        ApiEndpoint::PlayerClaims(id) => {
+            response.set_value(Value::ClaimList(db::Claims(conn).by_player(id)?));
+            None
+        }
+        ApiEndpoint::PlayerNotifications(id) => {
+            response.set_value(Value::Notifications(
+                db::AsPlayer(conn, id).notifications()?,
+            ));
+            None
+        }
+        ApiEndpoint::PlayerLoot(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)?,
-            ));
+        ApiEndpoint::PlayerUpdateWealth(id, amount) => {
+            response.push_updates(db::AsPlayer(conn, id).update_wealth(amount)?);
            response.notify(format!("Mis à jour ({}po)!", amount));
+            Some((id, "Argent mis à jour"))
        }
-        ApiActions::BuyItems(id, params) => {
-            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;
+        // Behavior differs if player is group or regular.
+        // Group sells item like players then split the total amount among players.
+        ApiEndpoint::SellItems(id, params) => {
+            conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
+                let mut updates = db::LootManager(conn, id).sell(params.items)?;
+                        let total_amount: i32 = updates.iter()
+                            .filter_map(|u| match u {
+                            Update::Wealth(diff) => Some(diff.to_gp() as i32),
+                            _ => None
+                        }).sum();
+                match id {
+                    0 => {
+                        let players = params.players.unwrap_or_default();
+                        updates.append(
+                            &mut db::split_and_share(conn, total_amount, players)?
+                        );
+                        response.notify("Les objets ont été vendus");
+                        response.push_updates(updates);
+                    }
+                    _ => {
+                        response.notify("Objets vendus !");
+                        response.push_updates(updates);
+                    }
+                }
+                Ok(Some((id, "Vente d'objets")))
+            })?
+        }
+        ApiEndpoint::ClaimItems(id, items) => {
+            conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
+                let current_claims: HashSet<i32> = db::Claims(conn)
+                    .all()?
+                    .iter()
+                    .filter(|c| c.player_id == id)
+                    .map(|c| c.loot_id)
+                    .collect();
+                let new_claims: HashSet<i32> = items.into_iter().collect();
+                // Claims to delete
+                for item in current_claims.difference(&new_claims) {
+                    response.push_updates(db::Claims(conn).remove(id, *item)?);
+                }
+                // Claims to add
+                for item in new_claims.difference(&current_claims) {
+                    response.push_updates(db::Claims(conn).add(id, *item)?);
+                }
+                Ok(None)
+            })?
+        }
+        ApiEndpoint::UndoLastAction(id) => {
+            if let Ok(event) = db::models::history::get_last_of_player(conn, id) {
+                let name = String::from(event.name());
+                event.undo(conn)?;
+                response.notify(format!("'{}' annulé(e)", name));
            } 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));
-        }
-        ApiActions::SellItems(id, params) => {
-            let mut all_results: Vec<db::Wealth> = Vec::with_capacity(params.len());
-            let mut sold_items: u16 = 0;
-            for (loot_id, price_mod) in params.into_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!("Error selling {}", loot_id));
-                }
-            }
-            let total_amount = all_results
-                    .into_iter()
-                    .fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
-            response.notify(format!("{} objet(s) vendu(s) pour {} po", sold_items, total_amount.to_gp()));
-            response.push_update(Update::Wealth(total_amount));
-        }
-        ApiActions::SellGroupItems(id, params) => {
-            conn.transaction(|| {
-                for i in params.items.into_iter() {
-                   
-                }
-                Err(diesel::result::Error::RollbackTransaction)
-            });
-        }
-        ApiActions::ClaimItem(id, item) => {
-            response.push_update(Update::ClaimAdded(
-                db::Claims(conn).add(id, item)?,
-            ));
-            response.notify(format!("Pour moi !"));
-        }
-        ApiActions::UnclaimItem(id, item) => {
-            response.push_update(Update::ClaimRemoved(
-                db::Claims(conn).remove(id, item)?,
-            ));
-            response.notify(format!("Bof! Finalement non."));
+                response.push_error("Aucune action trouvée")
+            };
+            None
        }
        // Group actions
-        ApiActions::AddLoot(items) => {
+        ApiEndpoint::AddLoot(data) => {
            let mut added_items = 0;
-            for item in items.into_iter() {
+            for item in data.items.into_iter() {
                if let Ok(added) = db::LootManager(conn, 0).add_from(&item) {
-                response.push_update(Update::ItemAdded(added));
+                    response.push_updates(added);
                    added_items += 1;
                } else {
                    response.push_error(format!("Error adding {:?}", item));
@@ -220,7 +260,38 @@ pub fn execute(
            {
                response.push_error(format!("Erreur durant la notification : {:?}", e));
            };
+            Some((0, "Nouveau loot"))
        }
+        ApiEndpoint::ResolveClaims => {
+            response.push_error("Not implemented!");
+            None
        }
+        // Admin actions
+        ApiEndpoint::RefreshShop(items) => {
+            db::Shop(conn).replace_list(items)?;
+            response.notify("Inventaire du marchand renouvelé !");
+            None
+        }
+        ApiEndpoint::PlayerAdd(data) => {
+            db::Players(conn).add(&data.name, data.wealth)?;
+            response.notify("Joueur ajouté !");
+            None
+        }
+    };
+
+    // Store the event if it can be undone.
+    dbg!(&action_text);
+    if let Some((id, text)) = action_text {
+        db::models::history::insert_event(
+            conn,
+            id,
+            text,
+            response
+                .updates
+                .as_ref()
+                .expect("there should be updates in here !"),
+        )?;
+    }
+    // match _action_text -> Save updates in DB
    Ok(response)
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,30 +1,37 @@
 use actix_cors::Cors;
 use actix_files as fs;
-use actix_web::{web, middleware, App, Error, HttpResponse, HttpServer, Either};
-use futures::{Future, IntoFuture};
+use actix_identity::{CookieIdentityPolicy, Identity, IdentityService, RequestIdentity};
+use actix_service::{Service, Transform};
+use actix_web::{
+    dev::{ServiceRequest, ServiceResponse},
+    http::{header, StatusCode},
+    middleware, web, App, Error, HttpResponse, HttpServer,
+};
+use futures::{
+    future::{ok, Either, FutureResult},
+    Future,
+};
+use serde_json;
 use std::env;

-use lootalot_db as db;
 use crate::api;
+use lootalot_db as db;

 type AppPool = web::Data<db::Pool>;
 type PlayerId = web::Path<i32>;
 type ItemId = web::Json<i32>;
+type IdList = web::Json<api::IdList>;
+type BuySellParams = web::Json<api::BuySellParams>;
+type NewGroupLoot = web::Json<api::NewGroupLoot>;

-#[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>;
+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: api::ApiActions,
-) -> impl Future<Item = HttpResponse, Error = Error>
-{
+    query: api::ApiEndpoint,
+) -> impl Future<Item = HttpResponse, Error = Error> {
    let conn = pool.get().unwrap();
    web::block(move || api::execute(&conn, query)).then(|res| match res {
        Ok(r) => HttpResponse::Ok().json(r),
@@ -35,48 +42,102 @@ fn db_call(
    })
 }

-fn forbidden_to_players(id: i32, params: (AppPool, api::ApiActions)) -> MaybeForbidden {
+fn restricted_to_group(id: i32, params: (AppPool, api::ApiEndpoint)) -> MaybeForbidden {
    if id != 0 {
-        Either::B(HttpResponse::Forbidden().finish())
+        actix_web::Either::B(HttpResponse::Forbidden().finish())
    } else {
-        Either::A(Box::new(db_call(params.0, params.1)))
+        actix_web::Either::A(Box::new(db_call(params.0, params.1)))
+    }
 }

+struct RestrictedAccess;
+
+impl<S, B> Transform<S> for RestrictedAccess
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = RestrictedAccessMiddleware<S>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(RestrictedAccessMiddleware { service })
+    }
 }

-fn configure_app(config: &mut web::ServiceConfig) {
-    use api::ApiActions as Q;
+struct RestrictedAccessMiddleware<S> {
+    service: S,
+}
+
+impl<S, B> Service for RestrictedAccessMiddleware<S>
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = Either<S::Future, FutureResult<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
+        self.service.poll_ready()
+    }
+
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+        let is_logged_in = req.get_identity().is_some();
+
+        if is_logged_in {
+            Either::A(self.service.call(req))
+        } else {
+            Either::B(ok(
+                req.into_response(HttpResponse::Forbidden().finish().into_body())
+            ))
+        }
+    }
+}
+
+fn configure_api(config: &mut web::ServiceConfig) {
+    use api::ApiEndpoint as Q;
    config.service(
        web::scope("/api")
+            .wrap(RestrictedAccess)
            .service(
                web::scope("/players")
                    .service(
-                        web::resource("/").route(
-                            web::get().to_async(|pool| db_call(pool, Q::FetchPlayers)),
-                        ), //.route(web::post().to_async(endpoints::new_player))
+                        web::resource("/")
+                            .route(web::get().to_async(|pool| db_call(pool, Q::PlayerList)))
+                            .route(web::post().to_async(
+                                |pool, player: web::Json<api::NewPlayer>| {
+                                    db_call(pool, Q::PlayerAdd(player.into_inner()))
+                                },
+                            )),
                    ) // List of players
                    .service(
                        web::scope("/{player_id}")
-                            .route("/", web::get().to_async(|pool, player: PlayerId| {
+                            /*.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))
-                            }))
+                                }),
+                            )*/
+                            .route(
+                                "/notifications",
+                                web::get().to_async(|pool, player: PlayerId| {
+                                    db_call(pool, Q::PlayerNotifications(*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),
-                                            )
+                                    .route(web::get().to_async(|pool, player: PlayerId| {
+                                        db_call(pool, Q::PlayerClaims(*player))
+                                    }))
+                                    .route(web::post().to_async(
+                                        |pool, (player, data): (PlayerId, IdList)| {
+                                            db_call(pool, Q::ClaimItems(*player, data.into_inner()))
                                        },
                                    )),
                            )
@@ -85,65 +146,179 @@ fn configure_app(config: &mut web::ServiceConfig) {
                                    //.route(web::get().to_async(...))
                                    .route(web::put().to_async(
                                        |pool, (player, data): (PlayerId, web::Json<f64>)| {
-                                            db_call(
-                                                pool,
-                                                Q::UpdateWealth(*player, *data),
-                                            )
+                                            db_call(pool, Q::PlayerUpdateWealth(*player, *data))
                                        },
                                    )),
                            )
                            .service(
                                web::resource("/loot")
                                    .route(web::get().to_async(|pool, player: PlayerId| {
-                                        db_call(pool, Q::FetchLoot(*player))
+                                        db_call(pool, Q::PlayerLoot(*player))
                                    }))
                                    .route(web::put().to_async(
-                                        move |pool, (player, data): (PlayerId, web::Json<api::ItemListWithMods>)| {
+                                        move |pool, (player, data): (PlayerId, BuySellParams)| {
                                            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)))
+                                        move |pool, (player, data): (PlayerId, NewGroupLoot)| {
+                                            restricted_to_group(
+                                                *player,
+                                                (pool, Q::AddLoot(data.into_inner())),
+                                            )
                                        },
                                    ))
                                    .route(web::delete().to_async(
-                                        move |pool, (player, data): (PlayerId, web::Json<api::SellParams>)| {
-                                            match *player {
-                                               0 => db_call(pool, Q::SellItems(*player, data.into_inner().items)),
-                                               _ => db_call(pool, Q::SellGroupItems(*player, data.into_inner())),
-                                            }
+                                        move |pool, (player, data): (PlayerId, BuySellParams)| {
+                                            db_call(pool, Q::SellItems(*player, data.into_inner()))
                                        },
                                    )),
-                            ),
+                            )
+                            .service(web::scope("/events").route(
+                                "/last",
+                                web::delete().to_async(|pool, player: PlayerId| {
+                                    db_call(pool, Q::UndoLastAction(*player))
+                                }),
+                            )),
                    ),
            )
-            .route("/claims", web::get().to_async(|pool| db_call(pool, Q::FetchClaims)))
            .route(
-                "/items",
-                web::get()
-                    .to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)),
+                "/claims",
+                web::get().to_async(|pool| db_call(pool, Q::ClaimsList)),
+            )
+            .service(
+                web::resource("/shop")
+                    .route(web::get().to_async(|pool| db_call(pool, Q::ShopList)))
+                    .route(
+                        web::post().to_async(|pool, items: web::Json<api::ItemList>| {
+                            db_call(pool, Q::RefreshShop(items.into_inner()))
+                        }),
+                    ),
+            )
+            .service(
+                web::resource("/items")
+                    .route(
+                        web::get().to_async(move |pool: AppPool| db_call(pool, Q::InventoryList)),
+                    )
+                    .route(web::post().to_async(
+                        move |pool: AppPool, items: web::Json<Vec<String>>| {
+                            db_call(pool, Q::InventoryCheck(items.into_inner()))
+                        },
+                    )),
            ),
    );
 }

+#[derive(Deserialize)]
+struct AuthRequest {
+    key: String,
+}
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+enum SessionKind {
+    Player(i32),
+    Admin,
+}
+
+use std::collections::HashMap;
+
+fn check_key(key: &str, db: HashMap<&str, SessionKind>) -> Option<SessionKind> {
+    db.get(&key).map(Clone::clone)
+}
+
+fn login(id: Identity, key: web::Query<AuthRequest>) -> HttpResponse {
+    if let Some(session_kind) = check_key(
+        &key.key.to_string(),
+        [
+            ("0", SessionKind::Player(0)),
+            ("1", SessionKind::Player(1)),
+            ("2", SessionKind::Player(2)),
+            ("admin", SessionKind::Admin),
+        ]
+        .iter()
+        .cloned()
+        .collect::<HashMap<&str, SessionKind>>(),
+    ) {
+        id.remember(serde_json::to_string(&session_kind).expect("Serialize SessionKind error"));
+        HttpResponse::build(StatusCode::TEMPORARY_REDIRECT)
+            .header(header::LOCATION, "/")
+            .finish()
+    } else {
+        HttpResponse::Forbidden().finish()
+    }
+}
+
+fn logout(id: Identity) -> HttpResponse {
+    id.forget();
+    HttpResponse::build(StatusCode::TEMPORARY_REDIRECT)
+        .header(header::LOCATION, "/")
+        .finish()
+}
+
+/// This endpoint shall be called by client,
+/// at initialization, to retrieve the current
+/// logging session info.
+///
+/// # Returns
+///
+/// The player data if a player is logged in
+/// The admin data if the admin is logged in
+/// A Forbidden response otherwise
+fn enter_session(id: Identity, pool: AppPool) -> impl Future<Item = HttpResponse, Error = Error> {
+    let conn = pool.get().unwrap();
+    let logged: SessionKind = id
+        .identity()
+        .map(|s| serde_json::from_str(&s).expect("Deserialize SessionKind error"))
+        // This will fail, fastest way to handle
+        // unlogged case with web::block below
+        .unwrap_or(SessionKind::Player(-1));
+
+    web::block(move || {
+        api::execute(
+            &conn,
+            match logged {
+                SessionKind::Player(id) => api::ApiEndpoint::PlayerFetch(id),
+                SessionKind::Admin => api::ApiEndpoint::PlayerList,
+            },
+        )
+    })
+    .then(|res| match res {
+        Ok(r) => HttpResponse::Ok().json(r.value),
+        Err(e) => {
+            dbg!(&e);
+            HttpResponse::Forbidden().finish()
+        }
+    })
+}
+
 pub fn serve() -> std::io::Result<()> {
-    let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
+    let domain: String = env::var("DOMAIN").expect("DOMAIN must be set");
    let pool = db::create_pool();
-    dbg!(&www_root);
+    println!("Serving Loot-a-lot on {}", domain);
+
+    let key = [0; 32]; // TODO: Use a real key

    HttpServer::new(move || {
        App::new()
            .data(pool.clone())
-            .configure(configure_app)
+            .configure(configure_api)
            .wrap(
                Cors::new()
-                    .allowed_origin("http://localhost:8080")
+                    .allowed_origin(&domain)
                    .allowed_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
                    .max_age(3600),
            )
-            .wrap(middleware::Logger::default())
-            .service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
+            .wrap(IdentityService::new(
+                CookieIdentityPolicy::new(&key)
+                    .name("logged-in")
+                    .secure(false),
+            ))
+            //.wrap(middleware::Logger::default())
+            .wrap(middleware::Logger::new("%r -> %s (%{User-Agent}i)"))
+            .route("/session", web::get().to_async(enter_session))
+            .route("/login", web::get().to(login))
+            .route("/logout", web::get().to(logout))
+        //.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
    })
    .bind("127.0.0.1:8088")?
    .run()
Author	SHA1	Message	Date
Artus	d152a999c9	fixes errors	2020-01-09 15:12:51 +01:00
Artus	f9cd09431d	merge shop and looted tables	2020-01-09 13:25:36 +01:00
Artus	6149dfd297	will need to clean up db API	2020-01-05 15:37:40 +01:00
Artus	a47646bd5f	adds AddPlayer endpoint	2019-12-18 15:22:20 +01:00
Artus	2c87713818	deletes old frontend	2019-12-15 16:03:25 +01:00
Artus	b19d56fd9a	updates for prod env	2019-12-15 16:02:00 +01:00
Artus	342a66475d	fixes bugs in group sell	2019-12-08 14:54:45 +01:00
Artus	108470c5d1	adds SessionKind and mocks impl of key checks	2019-12-05 16:17:33 +01:00
Artus	d1a85ed1d0	adds new 'shop' table	2019-11-18 15:07:35 +01:00
Artus	cb8dfa9a2a	works on adding from list	2019-11-14 16:26:03 +01:00
Artus	61a03f1781	adds RestrictedAccess middleware for api scope	2019-11-14 14:23:50 +01:00
Artus	9d84a5ac62	adds logic for magic link authentication	2019-11-14 12:30:57 +01:00
Artus	988cdc97e2	it is useless to keep history of claims updates	2019-11-12 15:56:27 +01:00
Artus	b5010539bb	less verbose logger	2019-11-07 21:05:39 +01:00
Artus	51cc6c4765	fixes small bug (forgot to save sell gains for group)	2019-11-07 16:12:42 +01:00
Artus	1cc9c2eefa	fixes some misbehaviour	2019-11-07 15:55:58 +01:00
Artus	4925afbeb5	some better names	2019-11-06 14:47:47 +01:00
Artus	1afbcff12a	unifies Buy and Sell parameters	2019-11-06 14:31:05 +01:00
Artus	ee0b7b2b7a	adds UpdateResult class of queries	2019-10-29 16:19:00 +01:00
Artus	089aaf9a6d	fixes api	2019-10-29 15:12:56 +01:00
Artus	1f2a940968	adds reactivity when undoing an event	2019-10-28 16:08:05 +01:00
Artus	8d1344e0b6	adds events api	2019-10-28 15:29:17 +01:00
Artus	e9f535ac86	impls undoable events	2019-10-28 15:27:26 +01:00
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