fixes some misbehaviour

lootalot_db/src/lib.rs

@@ -177,17 +177,26 @@ pub fn resolve_claims(conn: &DbConnection) -> QueryResult<()> {
     })
 }
 
-/// Split up and share group money among selected players
+/// Split up and share an certain amount of group money among selected players
+///
+/// The group first solve players debts,
+/// then give what's left.
+///
+/// # Returns
+///
+/// A Wealth update with the amount of money actually shared
 pub fn split_and_share(
     conn: &DbConnection,
     amount: i32,
     players: &Vec<i32>,
-) -> QueryResult<Wealth> {
+) -> UpdateResult {
     let share = (
         amount / (players.len() + 1) as i32
         // +1 share for the group
     ) as f64;
     conn.transaction(|| {
+        // What we actually give, negative value
+        let mut diff = 0.0;
         for p in players {
             let player = Players(conn).find(*p)?;
             // Take debt into account
@@ -196,13 +205,14 @@ pub fn split_and_share(
                     AsPlayer(conn, *p).update_debt(-player.debt)?;
                     AsPlayer(conn, *p).update_wealth(rest)?;
                     AsPlayer(conn, 0).update_wealth(-rest)?;
+                    diff -= rest;
                 }
                 _ => {
                     AsPlayer(conn, *p).update_debt(-share as i32)?;
                 }
             }
         }
-        Ok(Wealth::from_gp(share))
+        Ok(Update::Wealth(Wealth::from_gp(diff)))
     })
 }
 

lootalot_db/src/models/claim.rs

@@ -1,6 +1,6 @@
-use crate::{DbConnection, QueryResult};
 use diesel::prelude::*;
 
+use crate::{DbConnection, QueryResult, Update, UpdateResult};
 use crate::models::{self, item::Loot};
 use crate::schema::claims;
 
@@ -54,7 +54,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 +68,22 @@ impl<'q> Claims<'q> {
             .values(&claim)
             .execute(self.0)?;
         // Return the created claim
-        claims::table
-            .order(claims::dsl::id.desc())
-            .first::<Claim>(self.0)
+        Ok(
+            Update::ClaimAdded(
+                claims::table
+                    .order(claims::dsl::id.desc())
+                    .first::<Claim>(self.0)?
+            )
+        )
     }
 
     /// Removes a claim from database, returning it
-    pub fn remove(self, player_id: i32, loot_id: i32) -> 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(
+            Update::ClaimRemoved(claim)
+        )
     }
 
     pub fn filtered_by_loot(&self, loot_id: i32) -> QueryResult<Vec<Claim>> {
@@ -86,6 +92,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);

lootalot_db/src/models/item.rs

@@ -3,7 +3,7 @@ use diesel::expression::exists::Exists;
 use diesel::prelude::*;
 
 use crate::schema::{items, looted};
-use crate::{DbConnection, QueryResult, Update, UpdateResult };
+use crate::{DbConnection, QueryResult, Update, UpdateResult, Claims };
 type ItemColumns = (looted::id, looted::name, looted::base_price);
 const ITEM_COLUMNS: ItemColumns = (looted::id, looted::name, looted::base_price);
 type OwnedBy = Select<OwnedLoot, ItemColumns>;
@@ -28,8 +28,15 @@ impl Item {
     }
 
     pub fn remove(self, conn: &DbConnection) -> UpdateResult {
-        diesel::delete(looted::table.find(self.id)).execute(conn)?;
-        Ok(Update::ItemRemoved(self))
+        conn.transaction(
+            || -> UpdateResult
+            {
+                Claims(conn).delete_for_loot(self.id)?;
+                diesel::delete(looted::table.find(self.id)).execute(conn)?;
+
+                Ok(Update::ItemRemoved(self))
+            }
+        )
     }
 
     fn owned_by(player: i32) -> OwnedBy {

lootalot_db/src/models/player/wealth.rs

@@ -140,8 +140,8 @@ mod tests {
     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 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;
@@ -154,8 +154,8 @@ mod tests {
     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 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;