going somewhere.

src/db/_securities.rs

@@ -1,5 +1,6 @@
-use rusqlite::{Connection, params, Result, Row, ToSql, Transaction};
+use rusqlite::{Connection, OptionalExtension, params, Result, Row, ToSql, Transaction};
 use serde::Serialize;
+use crate::db::users::User;
 
 
 #[derive(Debug, Serialize, PartialEq)]
@@ -48,31 +49,51 @@ impl Security {
 }
 
 pub struct NewSecurity {
-    security_type: SecurityType,
-    symbol: String,
-    name: String,
+    pub security_type: SecurityType,
+    pub symbol: String,
+    pub name: String,
 }
 
-pub fn create_security(tx: &Transaction, sec: &NewSecurity) -> Result<Security> {
+pub fn create_security(tx: &Transaction,
+                       sec: &NewSecurity,
+                       owner: &User) -> Result<Security> {
     let q = "INSERT INTO
                      securities(name, symbol, security_type)
                    VALUES(?1, ?2, ?3)";
     let params = (&sec.name, &sec.symbol, &sec.security_type);
     tx.execute(q, params)?;
-    return get_security_by_id(tx, tx.last_insert_rowid() as i32);
+    let new_sec_id = tx.last_insert_rowid() as i32;
+
+    let q = "INSERT INTO
+                      security_permissions(security_id, user_id)
+                      VALUES(?1, ?2)";
+    tx.execute(q, params![new_sec_id, owner.id])?;
+
+    return get_security_by_id(tx, new_sec_id);
+}
+
+pub fn is_owner(tx: &Transaction, sec: &Security, user: &User) -> Result<bool> {
+    let q = "SELECT id
+                  FROM security_permissions
+                  WHERE security_id = ?1 AND user_id = ?2
+                  LIMIT 1";
+    let ret: Option<u32> = tx.query_row(q,
+                                        params![sec.id, user.id],
+                                        |r| r.get(0)).optional()?;
+    return Ok(ret.is_some());
 }
 
 pub fn get_security_by_id(tx: &Transaction, id: i32) -> Result<Security> {
     let q = "SELECT id AS sec_id, security_type AS sec_security_type, symbol AS sec_symbol
-                   FROM securities
-                   WHERE id = ?1";
+                  FROM securities
+                  WHERE id = ?1";
     tx.query_row(q, params![id], Security::from_row)
 }
 
 pub fn list_securities(conn: &Connection) -> Result<Vec<Security>> {
     let q = "SELECT id AS sec_id, security_type AS sec_security_type, symbol AS sec_symbol
-                   FROM securities
-                   ORDER BY id ASC";
+                  FROM securities
+                  ORDER BY id ASC";
     let mut stmt = conn.prepare(q)?;
 
     let ret: Vec<Security> = stmt
@@ -83,41 +104,27 @@ pub fn list_securities(conn: &Connection) -> Result<Vec<Security>> {
     return Ok(ret);
 }
 
-pub mod test_util {
-    use super::*;
-    pub fn mock_currency_1() -> NewSecurity {
-        return NewSecurity {
-            security_type: SecurityType::Currency,
-            symbol: "P".to_string(),
-            name: "piastre".to_string(),
-        };
-    }
-
-    pub fn mock_currency_2() -> NewSecurity {
-        return NewSecurity {
-            security_type: SecurityType::Bond,
-            symbol: "B".to_string(),
-            name: "bong".to_string(),
-        };
-    }
-}
 
 #[cfg(test)]
 mod test {
     use rusqlite::{Connection, params};
     use super::*;
-    use super::test_util::*;
+    use crate::db::_test_utils::*;
     use crate::migration;
 
-    fn setup() -> Connection {
+    fn setup() -> (Connection, Vec<User>) {
         let mut conn = Connection::open_in_memory().unwrap();
         migration::apply_migrations(&mut conn).unwrap();
-        return conn;
+        let tx = conn.transaction().unwrap();
+        let users = setup_users(&tx).unwrap();
+        tx.commit().unwrap();
+
+        return (conn, users);
     }
 
     #[test]
     fn test_security_types() -> Result<(), rusqlite::Error> {
-        let conn = setup();
+        let (mut conn, users) = setup();
         let q = "CREATE TABLE test_security_types(
             name TEXT,
             FOREIGN KEY (name) REFERENCES security_types (name)
@@ -133,21 +140,28 @@ mod test {
 
     #[test]
     fn test_create_security() -> Result<(), rusqlite::Error> {
-        let mut conn = setup();
+        let (mut conn, users) = setup();
+        let owner = users.get(0).unwrap();
+        let not_owner = users.get(1).unwrap();
         let sec = mock_currency_1();
         let tx = conn.transaction()?;
-        create_security(&tx, &sec)?;
-        return tx.commit();
+        let sec = create_security(&tx, &sec, &owner)?;
+
+        assert!(is_owner(&tx, &sec, &owner)?);
+        assert!(!is_owner(&tx, &sec, &not_owner)?);
+
+        tx.commit()
     }
 
     #[test]
     fn test_list_security() -> Result<(), rusqlite::Error> {
-        let mut conn = setup();
+        let (mut conn, users) = setup();
+        let user = users.get(0).unwrap();
         assert_eq!(0, list_securities(&conn)?.len());
 
         let sec = mock_currency_1();
         let tx = conn.transaction()?;
-        create_security(&tx, &sec)?;
+        create_security(&tx, &sec, &user)?;
         tx.commit()?;
         let ret = list_securities(&conn)?;
         let expt = Security {
@@ -166,7 +180,7 @@ mod test {
             symbol: "B".to_string(),
         };
         let tx = conn.transaction()?;
-        create_security(&tx, &sec)?;
+        create_security(&tx, &sec, &user)?;
         tx.commit()?;
         let ret = list_securities(&conn)?;
         assert_eq!(2, ret.len());