going somewhere.

src/db/_accounts.rs

@@ -1,16 +1,23 @@
-use rusqlite::{Connection, params, Result, Row, Transaction};
+use rusqlite::{Connection, OptionalExtension, params, Result, Row, Transaction};
+use sha2::digest::typenum::op;
+use crate::db::_external_id::{Id, AccountId, UserId};
 
 use crate::db::_securities::Security;
 use crate::db::_users::User;
+use crate::db::external_id::SecurityId;
 
 pub struct Account {
-    pub id: i64,
-    pub amount: i64,
-    pub timestamp: i64,
-    pub security: Security,
+    id: u32,
+    amount: u32,
+    timestamp: i32,
+    security: Security,
 }
 
 impl Account {
+    pub fn id(&self) -> AccountId {
+        AccountId::from_id(self.id)
+    }
+
     pub fn from_row(row: &Row) -> Result<Account> {
         return Ok(Account {
             id: row.get("acc_id")?,
@@ -55,13 +62,21 @@ pub fn get_account_by_id(tx: &Transaction, id: u32) -> Result<Account> {
     return tx.query_row(q, params![id], Account::from_row);
 }
 
-pub fn create_account(tx: &Transaction, sec: &Security, user: &User) -> Result<Account> {
+pub fn create_account(tx: &Transaction, sec: &SecurityId, user: &UserId) -> Result<Account> {
     let q = "INSERT INTO accounts(security, owner, amount, timestamp)
                    VALUES (?1, ?2, 0, CURRENT_TIMESTAMP)";
-    tx.execute(q, (sec.id, user.id))?;
+    tx.execute(q, (sec, user))?;
     return get_account_by_id(tx, tx.last_insert_rowid() as u32);
 }
 
+pub fn is_owner(tx: &Transaction, account_id: &AccountId, user_id: &UserId) -> Result<bool> {
+    let q = "SELECT id FROM accounts WHERE id = ?1 AND owner = ?2";
+    let params = params![account_id, user_id];
+    let ite = |row: &Row| row.get::<usize, u32>(0);
+    let option = tx.query_row(q, params, ite).optional()?;
+    Ok(option.is_some())
+}
+
 #[cfg(test)]
 mod test {
     use rusqlite::Connection;
@@ -84,13 +99,14 @@ mod test {
         return (conn, users, securities);
     }
 
-    fn create_all_accounts(tx: &Transaction, users: &Vec<User>, secs: &Vec<Security>) -> Result<()> {
+    fn create_all_accounts(tx: &Transaction, users: &Vec<User>, secs: &Vec<Security>) -> Result<Vec<Account>> {
+        let mut ret: Vec<Account> = Vec::new();
         for sec in secs.iter() {
             for user in users.iter() {
-                create_account(&tx, sec, user)?;
+                ret.push(create_account(&tx, &sec.id(), &user.id())?);
             }
         }
-        return Ok(());
+        return Ok(ret);
     }
 
     #[test]
@@ -114,5 +130,22 @@ mod test {
         assert_eq!(0, accs.len());
         return Ok(());
     }
+
+    #[test]
+    fn test_is_owner() -> Result<()> {
+        let (mut conn, users, secs) = setup();
+        let tx = &conn.transaction()?;
+        let accounts = create_all_accounts(tx, &users, &secs)?;
+        let user_1 = users.get(0).unwrap();
+        let user_2 = users.get(1).unwrap();
+        let sec = secs.get(0).unwrap();
+
+        let acc = create_account(&tx, &sec.id(), &user_1.id())?;
+
+        assert!(is_owner(tx, &acc.id(), &user_1.id())?);
+        assert!(!is_owner(tx, &acc.id(), &user_2.id())?);
+
+        Ok(())
+    }
 }