fuck off, I call that a day.

src/services/_transactions.rs

@@ -1,17 +1,16 @@
-use rusqlite::{Connection, ffi, params, Params, Savepoint, Transaction};
+use rusqlite::{Connection, ffi, params, Savepoint, Transaction};
 
-use crate::db::{accounts, securities};
-use crate::db::accounts::{Account, get_account_by_id};
+use crate::db::accounts;
+use crate::db::accounts::get_account_by_id;
 use crate::db::cheques::Cheque;
 use crate::db::external_id::AccountId;
-use crate::db::securities::get_security_by_id;
 use crate::util::*;
 
 fn _move_securities(tx: &Savepoint,
                     cheque: &Cheque,
                     account_id: &AccountId) -> CustomResult<()> {
     let drawer_receipt = accounts::add_to_account(tx, &cheque.drawer_account_id, -cheque.amount)?;
-    let payee_receipt = accounts::add_to_account(tx, account_id, cheque.amount)?;
+    let _payee_receipt = accounts::add_to_account(tx, account_id, cheque.amount)?;
     if drawer_receipt.amount < 0 {
         let m = format!("Drawer of {:?} does not have sufficient amount in account.", cheque);
         return Err(Error::InvalidAmount(m));
@@ -21,20 +20,27 @@ fn _move_securities(tx: &Savepoint,
 
 fn _add_cheque_to_cashed_cheques_log(tx: &Connection,
                                      cheque: &Cheque,
-                                     account_id: &AccountId) -> Result<(), Error> {
+                                     payee_account_id: &AccountId) -> Result<(), Error> {
     let q = "
         INSERT INTO cashed_cheques(
             drawer_user_id,
+            drawer_account_id,
+            payee_user_id,
+            payee_account_id,
             cheque_number,
             amount,
             underlying_security
         )
-        VALUES(?1, ?2, ?3, ?4)
+        VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7)
     ";
-    let ret = tx.execute(q, params![cheque.drawer_user_id,
+    let params = params![cheque.drawer_user_id,
+                                     cheque.drawer_account_id,
+                                     cheque.payee_user_id,
+                                     payee_account_id,
                                      cheque.cheque_number,
                                      cheque.amount,
-                                     cheque.security_id]).map_err(Error::SqlError);
+                                     cheque.security_id];
+    let ret = tx.execute(q, params).map_err(Error::SqlError);
     match ret {
         Ok(_) => Ok(()),
         Err(Error::SqlError(rusqlite::Error::SqliteFailure(ffi::Error { code: _, extended_code: 2067 }, _))) =>
@@ -81,13 +87,12 @@ fn cash_cheque(tx: &mut Transaction,
 
 #[cfg(test)]
 mod test_caching_cheques {
-    use rusqlite::{Connection, params};
+    use rusqlite::Connection;
 
-    use crate::db::{accounts, test_utils};
     use crate::db::accounts::{create_checking_account, create_security_emitter_account};
     use crate::db::cheques::{Drawer, Payee};
-    use crate::db::external_id::{Id, SecurityId, UserId};
-    use crate::db::users::User;
+    use crate::db::external_id::{Id, UserId};
+    use crate::db::test_utils;
     use crate::migration;
 
     use super::*;
@@ -138,7 +143,7 @@ mod test_caching_cheques {
         let drawer: Drawer = _create_drawer(payee, payee_account);
         let new_payee: Payee = (security_emitter.0, security_emitter.2);
 
-        return (conn, drawer, new_payee, reg_account.id())
+        return (conn, drawer, new_payee, reg_account.id());
     }
 
 
@@ -267,7 +272,7 @@ mod test_caching_cheques {
         test_invalid_drawer(&mut conn, drawer, payee, payee_account)
     }
 
-    fn test_invalid_payee(conn: &mut Connection, security_emitter: Drawer, payee: Payee, payee_account: AccountId) -> CustomResult<()> {
+    fn test_invalid_payee(conn: &mut Connection, security_emitter: Drawer, payee: Payee) -> CustomResult<()> {
         let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
         let mut tx = conn.transaction().unwrap();
         let wrong_payee_account = &security_emitter.1;
@@ -286,12 +291,12 @@ mod test_caching_cheques {
     #[test]
     fn test_invalid_payee_security_emitter_cheque() -> CustomResult<()> {
         let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
-        test_invalid_payee(&mut conn, security_emitter, payee, payee_account)
+        test_invalid_payee(&mut conn, security_emitter, payee)
     }
 
     #[test]
     fn test_invalid_payee_regular_cheque() -> CustomResult<()> {
         let (mut conn, drawer, payee, payee_account) = setup_basic();
-        test_invalid_payee(&mut conn, drawer, payee, payee_account)
+        test_invalid_payee(&mut conn, drawer, payee)
     }
 }