I should be working...

src/db/_accounts.rs

@@ -0,0 +1,129 @@
+use rusqlite::{Connection, params, Result, Row, Transaction};
+
+use crate::db::_securities::Security;
+use crate::db::_users::User;
+
+pub struct Account {
+    pub id: i64,
+    pub amount: i64,
+    pub timestamp: i64,
+    pub security: Security,
+}
+
+impl Account {
+    pub fn from_row(row: &Row) -> Result<Account>{
+        return Ok(Account{
+            id: row.get("acc_id")?,
+            amount: row.get("acc_amount")?,
+            timestamp: row.get("acc_timestamp")?,
+            security: Security::from_row(row)?,
+        });
+    }
+}
+
+pub fn list_accounts<'a>(conn: &Connection) -> Result<Vec<Account>> {
+    let q = "SELECT acc.id AS acc_id,
+                          acc.amount AS acc_amount,
+                          UNIXEPOCH(acc.timestamp) AS acc_timestamp,
+
+                          sec.id AS sec_id,
+                          sec.symbol AS sec_symbol,
+                          sec.security_type AS sec_security_type
+                   FROM accounts acc
+                   JOIN securities sec ON acc.security = sec.id
+                   ORDER BY acc.id ASC";
+    let mut stmt = conn.prepare(q)?;
+    let ret: Vec<Account> = stmt
+        .query_map([], &Account::from_row)?
+        .filter(Result::is_ok)
+        .map(Result::unwrap)
+        .collect();
+    return Ok(ret);
+}
+
+pub fn get_account_by_id(tx: &Transaction, id: u32) -> Result<Account>{
+    let q = "SELECT acc.id AS acc_id,
+                          acc.amount AS acc_amount,
+                          UNIXEPOCH(acc.timestamp) AS acc_timestamp,
+
+                          sec.id AS sec_id,
+                          sec.symbol AS sec_symbol,
+                          sec.security_type AS sec_security_type
+                  FROM accounts acc
+                  JOIN securities sec ON acc.security = sec.id
+                  WHERE acc.id = ?1";
+    return tx.query_row(q, params![id], Account::from_row);
+}
+
+pub fn create_account(tx: &Transaction, sec: &Security, user: &User) -> Result<Account>{
+    let q = "INSERT INTO accounts(security, owner, amount, timestamp)
+                   VALUES (?1, ?2, 0, CURRENT_TIMESTAMP)";
+    tx.execute(q, (sec.id, user.id))?;
+    return get_account_by_id(tx, tx.last_insert_rowid() as u32);
+}
+
+#[cfg(test)]
+mod test {
+    use rusqlite::{Connection};
+    use crate::db::_users;
+    use crate::db::_securities;
+    use crate::migration;
+
+    use super::*;
+
+    fn setup_users(tx: &Transaction) -> Result<Vec<User>> {
+        let user_1 = _users::create_user(tx, &"bernard".to_string(), &"123".to_string())?;
+        let user_2 = _users::create_user(tx, &"sam".to_string(), &"abc".to_string())?;
+        return Ok(vec![user_1, user_2]);
+    }
+
+    fn setup_securities(tx: &Transaction) -> Result<Vec<Security>> {
+        let sec_1 = _securities::create_security(tx, &_securities::test_util::mock_currency_1())?;
+        let sec_2 = _securities::create_security(tx, &_securities::test_util::mock_currency_2())?;
+        return Ok(vec![sec_1, sec_2]);
+    }
+
+    fn setup() -> (Connection, Vec<User>, Vec<Security>) {
+        let mut conn = Connection::open_in_memory().unwrap();
+        migration::apply_migrations(&mut conn).unwrap();
+
+        let tx = conn.transaction().unwrap();
+        let users = setup_users(&tx).unwrap();
+        let securities = setup_securities(&tx).unwrap();
+
+        tx.commit().unwrap();
+        return (conn, users, securities);
+    }
+
+    fn create_all_accounts(tx: & Transaction, users: & Vec<User>, secs: & Vec<Security>) -> Result<()>{
+        for sec in secs.iter() {
+            for user in users.iter() {
+                create_account(&tx, sec, user)?;
+            }
+        }
+        return Ok(());
+    }
+
+    #[test]
+    fn test_happy_path() -> Result<()>{
+        let (mut conn, users, secs) = setup();
+        let tx = conn.transaction()?;
+        create_all_accounts(& tx, &users, &secs)?;
+        tx.commit()?;
+        let accs = list_accounts(& conn)?;
+        assert_eq!(4, accs.len());
+        assert_eq!(1, accs.get(0).unwrap().id);
+        assert_eq!(4, accs.get(3).unwrap().id);
+        return Ok(());
+    }
+
+    #[test]
+    fn test_happy_path_no_commit() -> Result<()>{
+        let (mut conn, users, secs) = setup();
+        create_all_accounts(& conn.transaction()?, &users, &secs)?;
+        let accs = list_accounts(& conn)?;
+        assert_eq!(0, accs.len());
+        return Ok(());
+    }
+}
+