Insert boards in the db using correct keys

3 files changed, 38 insertions, 25 deletions

diff --git a/server/src/play.rs b/server/src/play.rs
index f413a74..99f451f 100644
--- a/server/src/play.rs
+++ b/server/src/play.rs
@@ -7,7 +7,7 @@ use protocol::{
         TableState,
     },
     card::Card,
-    core::{Deal, Player},
+    core::Deal,
     simple_bots::{AlwaysPassBiddingBot, RandomPlayingBot},
 };
 use rand::random;
@@ -106,7 +106,7 @@ where
 
 #[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
 pub enum TableUpdate {
-    NewDeal { deal: Deal, dealer: Player },
+    NewDeal { deal: Deal },
     ChangeSettings(TableSettings),
     Bid(Bid),
     Play(Card),
@@ -163,7 +163,6 @@ impl<J: Journal<TableUpdate>> Table<J> {
     async fn init(&mut self) -> Result<(), BridgeError> {
         self.insert_and_apply(TableUpdate::NewDeal {
             deal: random(),
-            dealer: random(),
         })
         .await
     }
@@ -177,14 +176,8 @@ impl<J: Journal<TableUpdate>> Table<J> {
     }
 
     pub async fn new_deal(&mut self) -> Result<(), BridgeError> {
-        let dealer = match &self.state {
-            TableState::Unknown => random(),
-            TableState::Game(g) => g.dealer(),
-            TableState::Result(_) => random(), // TODO: We should know the dealer here.
-        };
         self.insert_and_apply(TableUpdate::NewDeal {
             deal: random(),
-            dealer: dealer.next(),
         })
         .await
     }
@@ -210,8 +203,8 @@ impl<J: Journal<TableUpdate>> Table<J> {
                 self.state = self.game()?.clone().bid(bid)?.into();
                 Ok(())
             }
-            TableUpdate::NewDeal { deal, dealer } => {
-                self.state = GameState::new(deal, dealer).into();
+            TableUpdate::NewDeal { deal } => {
+                self.state = GameState::new(deal).into();
                 Ok(())
             }
             TableUpdate::Play(card) => {
diff --git a/server/src/table.rs b/server/src/table.rs
index 1dc0fb7..370e2e1 100644
--- a/server/src/table.rs
+++ b/server/src/table.rs
@@ -16,7 +16,9 @@ use crate::error::BridgeError;
 
 #[async_trait]
 pub trait Table {
+    fn board_number(&self) -> usize;
     fn state(&self) -> &TableState;
+
     async fn bid(
         self: Box<Self>,
         bid: Bid,
@@ -25,19 +27,23 @@ pub trait Table {
         self: Box<Self>,
         card: Card,
     ) -> Result<Box<Self>, BridgeError>;
-    async fn new_deal(
+    async fn set_board(
         self: Box<Self>,
+        board_number: usize,
+        deal: Deal,
     ) -> Result<Box<Self>, BridgeError>;
 }
 
 pub struct InMemoryTable {
     pub state: TableState,
+    board_number: usize,
 }
 
 impl InMemoryTable {
     pub fn new() -> Self {
         Self {
             state: TableState::Unknown,
+            board_number: 0,
         }
     }
 }
@@ -48,6 +54,10 @@ impl Table for InMemoryTable {
         &self.state
     }
 
+    fn board_number(&self) -> usize {
+        self.board_number
+    }
+
     async fn bid(
         self: Box<Self>,
         bid: Bid,
@@ -59,7 +69,7 @@ impl Table for InMemoryTable {
             }
         };
         let game = game.bid(bid)?;
-        Ok(Box::new(Self { state: game.into() }))
+        Ok(Box::new(Self { state: game.into(), ..*self }))
     }
 
     async fn play(
@@ -73,14 +83,17 @@ impl Table for InMemoryTable {
             }
         };
         let game = game.play(card)?;
-        Ok(Box::new(Self { state: game.into() }))
+        Ok(Box::new(Self { state: game.into(), ..*self }))
     }
 
-    async fn new_deal(
+    async fn set_board(
         self: Box<Self>,
+        board_number: usize,
+        deal: Deal,
     ) -> Result<Box<Self>, BridgeError> {
         Ok(Box::new(Self {
-            state: GameState::new(random(), random()).into(),
+            state: GameState::new(deal).into(),
+            board_number,
         }))
     }
 }
@@ -165,6 +178,10 @@ impl<Inner: Table + Send> Table for DbTable<Inner> {
         self.inner.state()
     }
 
+    fn board_number(&self) -> usize {
+        self.inner.board_number()
+    }
+
     async fn bid(
         self: Box<Self>,
         bid: Bid,
@@ -185,16 +202,18 @@ impl<Inner: Table + Send> Table for DbTable<Inner> {
         }))
     }
 
-    async fn new_deal(
+    async fn set_board(
         self: Box<Self>,
+        board_number: usize,
+        deal: Deal,
     ) -> Result<Box<Self>, BridgeError> {
-        let inner = self.inner.new_deal().await?;
+        let inner = self.inner.set_board(board_number, deal).await?;
 
         let deal: Deal = random();
         sqlx::query!(r#"
             insert into table_boards (table_id, board_number, deal)
             values ($1, $2, $3)
-        "#, self.id, 0, sqlx::types::Json(deal) as _)
+        "#, self.id, board_number as i64, sqlx::types::Json(deal) as _)
         .execute(&self.db).await?;
 
         Ok(Box::new(Self {
diff --git a/server/tests/table_test.rs b/server/tests/table_test.rs
index 1db7aa8..a131768 100644
--- a/server/tests/table_test.rs
+++ b/server/tests/table_test.rs
@@ -1,5 +1,5 @@
 use protocol::bridge_engine::TableState;
-use rand::{thread_rng, Rng};
+use rand::{thread_rng, Rng, random};
 use server::{
     error::BridgeError,
     table::{DbTable, InMemoryTable, Table},
@@ -13,13 +13,13 @@ where
     T: Table + Send,
 {
     assert!(matches!(table.state(), TableState::Unknown));
-    table = table.new_deal().await?;
+    table = table.set_board(0, random()).await?;
     assert!(matches!(table.state(), TableState::Game(_)));
     while matches!(table.state(), TableState::Game(_)) {
         table = server::table::advance_play(table).await?;
     }
     assert!(matches!(table.state(), TableState::Result(_)));
-    table = table.new_deal().await?;
+    table = table.set_board(1, random()).await?;
     assert!(matches!(table.state(), TableState::Game(_)));
 
     Ok(())
@@ -29,10 +29,11 @@ async fn advance_table<T>(table: Box<T>) -> Result<Box<T>, BridgeError>
 where
     T: Table + Send,
 {
+    let board_number = table.board_number() + 1;
     match table.state() {
         TableState::Unknown => panic!("unexpected state"),
         TableState::Game(_) => server::table::advance_play(table).await,
-        TableState::Result(_) => table.new_deal().await,
+        TableState::Result(_) => table.set_board(board_number, random()).await,
     }
 }
 
@@ -83,8 +84,8 @@ async fn db_table_persistence() -> Result<(), anyhow::Error> {
         DbTable::new(db.db().clone(), Uuid::new_v4(), InMemoryTable::new())
             .await?,
     );
-    table = table.new_deal().await?;
-    for i in 0..(thread_rng().gen_range(0..200)) {
+    table = table.set_board(1, random()).await?;
+    for _i in 0..(thread_rng().gen_range(0..200)) {
         table = advance_table(table).await?;
     }
     Ok(())