cleans up

lootalot_db/src/lib.rs

@@ -12,25 +12,85 @@ pub use diesel::query_dsl::RunQueryDsl;
 mod models;
 mod schema;
 
-pub use models::Item;
-pub use models::Player;
-
 pub type DbConnection = SqliteConnection;
 pub type Pool = r2d2::Pool<ConnectionManager<DbConnection>>;
 pub type QueryResult<T> = Result<T, diesel::result::Error>;
 pub type ActionResult = QueryResult<bool>;
 
-impl Player {
-    /// Query the list of all players
-    pub fn fetch_list(conn: &SqliteConnection) -> QueryResult<Vec<Self>> {
-        Ok( schema::players::table.load::<Self>(conn)? )
-    }
+/// A wrapper providing an API over the database
+/// It offers a convenient way to deal with connection
+///
+/// # Todo list
+///
+/// struct DbApi<'q>(&'q DbConnection);
+/// ::new() -> DbApi<'q> (Db finds a connection by itself, usefull for cli)
+/// ::with_conn(conn) -> DbApi<'q> (uses a user-defined connection)
+///  v  .fetch_players()
+///  v  .as_player(player_id) -> AsPlayer<'q>
+///  v       .loot() -> List of items owned (Vec<Item>)
+///  x       .claim(item_id) -> Success status (bool)
+///  x       .unclaim(item_id) -> Success status (bool)
+///  x       .sell(item_id) -> Success status (bool, earned)
+///  x       .buy(inventory_item_id) -> Success status (bool, cost)
+///  x       .update_wealth(gold_pieces) -> Success status (bool, new_wealth)
+///  x  .as_admin()
+///  x       .add_loot([inventory_item_ids]) -> Success status
+///  x       .resolve_claims()
+///  x       .sell_loot([players], [excluded_item_ids]) -> Success status (bool, player_share)
+///
+pub struct DbApi<'q>(&'q DbConnection);
 
-    pub fn action_claim_object(player_id: i32, item_id: i32, conn: &DbConnection) -> ActionResult {
-        Ok(false)
+impl<'q> DbApi<'q> {
+    /// Returns a DbApi using the user given connection
+    ///
+    /// # Usage
+    /// ```
+    /// let conn = DbConnection::establish();
+    /// let api = DbApi::with_conn(&conn);
+    /// ```
+    pub fn with_conn(conn: &'q DbConnection) -> Self {
+        Self(conn)
     }
+    /// Fetch the list of all players
+    ///
+    /// This method consumes the DbApi object.
+    pub fn fetch_players(self) -> QueryResult<Vec<models::Player>> {
+        Ok(
+            schema::players::table
+                .load::<models::Player>(self.0)?
+        )
+    }
+    /// Wrapper for acting as a specific player
+    ///
+    /// The DbApi is moved inside a new AsPlayer object.
+    ///
+    /// # Usage
+    /// ```
+    /// let player_id: i32 = 1; // Id that references player in DB
+    /// let player = api.as_player(player_id);
+    /// ```
+    pub fn as_player(self, id: i32) -> AsPlayer<'q> {
+        AsPlayer { id, conn: self.0 }
+    }
+}
 
-    pub fn action_withdraw_claim(player_id: i32, item_id: i32, conn: &DbConnection) -> ActionResult {
+/// A wrapper for interactions of players with the database
+/// Possible actions are exposed as methods
+pub struct AsPlayer<'q> {
+    id: i32,
+    conn: &'q DbConnection,
+}
+
+impl<'q> AsPlayer<'q> {
+    /// Fetch the content of a player's chest
+    pub fn loot(self) -> QueryResult<Vec<models::Item>> {
+        Ok(
+            models::Item::owned_by(self.id)
+                .load(self.conn)?
+        )
+    }
+    /// Put a claim on a specific item
+    pub fn claim(self, item: i32) -> ActionResult {
         Ok(false)
     }
 }

lootalot_db/src/models/player.rs

@@ -12,29 +12,28 @@ pub struct Player {
     pp: i32,
 }
 
-/// The sign of the update
-enum WealthUpdateKind {
-    Income,
-    Expense,
-}
-
-/// Representation of wealth value
-type WealthValues = (i32, i32, i32, i32);
 
+/// Wealth represented as a single fractionnal amount of gold pieces
+struct WealthInGold(f32);
 /// Data used to update wealth
-struct WealthUpdate {
-    kind: WealthUpdateKind,
-    values: WealthValues,
-}
+struct WealthUpdate(WealthInGold);
 
-impl WealthUpdate {
-    /// Create a new update
-    fn new(values: WealthValues, kind: WealthUpdateKind) -> Self {
-        WealthUpdate { kind, values }
+impl WealthInGold {
+    /// Unpack individual pieces counts from gold value
+    fn unpack(self) -> (i32, i32, i32, i32) {
+        // TODO: 0,01 pp = 1 gp = 10 sp = 100 cp
+        (0,0,0,0)
     }
 
+}
+
+
+impl WealthUpdate {
     /// Apply the update to the specified player
-    fn apply_to(self, player_id: i32) {}
+    fn commit(self, player_id: i32) {
+        // Extract (cp, sp, gp, pp) from floating gold piece value
+        // Update record in db
+    }
 }
 
 /// Representation of a new player record
@@ -49,8 +48,8 @@ pub struct NewPlayer<'a> {
 }
 
 impl<'a> NewPlayer<'a> {
-    fn new(name: &'a str, wealth: Option<WealthValues>) -> Self {
-        let (cp, sp, gp, pp) = wealth.unwrap_or((0, 0, 0, 0));
+    fn new(name: &'a str, wealth: Option<WealthInGold>) -> Self {
+        let (cp, sp, gp, pp) = wealth.map(|w| w.unpack()).unwrap_or((0, 0, 0, 0));
         NewPlayer {
             name,
             cp,