Linted code.

src/services/_transactions.rs

@@ -1,4 +1,4 @@
-use rusqlite::{Connection, ffi, params, Savepoint, Transaction};
+use rusqlite::{ffi, params, Connection, Savepoint, Transaction};
 
 use crate::db::accounts;
 use crate::db::accounts::get_account_by_id;
@@ -6,22 +6,32 @@ use crate::db::cheques::Cheque;
 use crate::db::external_id::AccountId;
 use crate::util::*;
 
-fn _move_securities(tx: &Savepoint,
-                    cheque: &Cheque,
-                    account_id: &AccountId) -> CustomResult<(accounts::AccountChangeReceipt, accounts::AccountChangeReceipt)> {
+fn _move_securities(
+    tx: &Savepoint,
+    cheque: &Cheque,
+    account_id: &AccountId,
+) -> CustomResult<(
+    accounts::AccountChangeReceipt,
+    accounts::AccountChangeReceipt,
+)> {
     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)?;
     if drawer_receipt.amount < 0 {
-        let m = format!("Drawer of {:?} does not have sufficient amount in account.", cheque);
+        let m = format!(
+            "Drawer of {:?} does not have sufficient amount in account.",
+            cheque
+        );
         return Err(Error::InvalidAmount(m));
     }
     Ok((drawer_receipt, payee_receipt))
 }
 
-fn _add_cheque_to_cashed_cheques_log(tx: &Connection,
-                                     cheque: &Cheque,
-                                     drawer_receipt: &accounts::AccountChangeReceipt,
-                                     payee_receipt: &accounts::AccountChangeReceipt) -> Result<(), Error> {
+fn _add_cheque_to_cashed_cheques_log(
+    tx: &Connection,
+    cheque: &Cheque,
+    drawer_receipt: &accounts::AccountChangeReceipt,
+    payee_receipt: &accounts::AccountChangeReceipt,
+) -> Result<(), Error> {
     let q = "
         INSERT INTO cashed_cheques(
             drawer_user_id,
@@ -36,49 +46,69 @@ fn _add_cheque_to_cashed_cheques_log(tx: &Connection,
         )
         VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
     ";
-    let params = params![cheque.drawer_user_id,
-                                     cheque.drawer_account_id,
-                                     drawer_receipt.version,
-                                     cheque.payee_user_id,
-                                     payee_receipt.account_id,
-                                     payee_receipt.version,
-                                     cheque.cheque_number,
-                                     cheque.amount,
-                                     cheque.security_id];
+    let params = params![
+        cheque.drawer_user_id,
+        cheque.drawer_account_id,
+        drawer_receipt.version,
+        cheque.payee_user_id,
+        payee_receipt.account_id,
+        payee_receipt.version,
+        cheque.cheque_number,
+        cheque.amount,
+        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 }, _))) =>
-            Err(Error::DoubleSpendingError(format!("Cheque number {} from user {} has already been cached.", cheque.cheque_number, cheque.drawer_user_id))),
-        Err(a) => Err(a)
+        Err(Error::SqlError(rusqlite::Error::SqliteFailure(
+            ffi::Error {
+                code: _,
+                extended_code: 2067,
+            },
+            _,
+        ))) => Err(Error::DoubleSpendingError(format!(
+            "Cheque number {} from user {} has already been cached.",
+            cheque.cheque_number, cheque.drawer_user_id
+        ))),
+        Err(a) => Err(a),
     }
 }
 
-fn cash_cheque_unsafe(savepoint: &Savepoint,
-                      cheque: &Cheque,
-                      account_id: &AccountId) -> CustomResult<()> {
+fn cash_cheque_unsafe(
+    savepoint: &Savepoint,
+    cheque: &Cheque,
+    account_id: &AccountId,
+) -> CustomResult<()> {
     if cheque.amount < 0 {
-        return Err(Error::InvalidAmount(format!("The cheque {:?} has a negative amount.", cheque)));
+        return Err(Error::InvalidAmount(format!(
+            "The cheque {:?} has a negative amount.",
+            cheque
+        )));
     }
-    if !accounts::is_owner(&savepoint, &cheque.drawer_account_id, &cheque.drawer_user_id)? {
-        return Err(Error::InvalidDrawer(format!("The drawer is the security owner: {:?}", cheque)));
+    if !accounts::is_owner(
+        &savepoint,
+        &cheque.drawer_account_id,
+        &cheque.drawer_user_id,
+    )? {
+        return Err(Error::InvalidDrawer(format!(
+            "The drawer is the security owner: {:?}",
+            cheque
+        )));
     }
 
     if !accounts::is_owner(&savepoint, account_id, &cheque.payee_user_id)? {
-        return Err(Error::InvalidPayee(format!("Trying to cash the cheque {:?} in \
-        an account {:?} that is not owned by the payee.", cheque, account_id)));
+        return Err(Error::InvalidPayee(format!(
+            "Trying to cash the cheque {:?} in \
+        an account {:?} that is not owned by the payee.",
+            cheque, account_id
+        )));
     }
     let (drawer_receipt, payee_receipt) = _move_securities(&savepoint, cheque, account_id)?;
-    _add_cheque_to_cashed_cheques_log(&savepoint,
-                                      cheque,
-                                      &drawer_receipt,
-                                      &payee_receipt)?;
+    _add_cheque_to_cashed_cheques_log(&savepoint, cheque, &drawer_receipt, &payee_receipt)?;
     Ok(())
 }
 
-fn cash_cheque(tx: &mut Transaction,
-               cheque: &Cheque,
-               account_id: &AccountId) -> CustomResult<()> {
+fn cash_cheque(tx: &mut Transaction, cheque: &Cheque, account_id: &AccountId) -> CustomResult<()> {
     let mut savepoint = tx.savepoint().map_err(Error::SqlError)?;
     let ret = cash_cheque_unsafe(&savepoint, cheque, account_id);
     match ret {
@@ -86,13 +116,10 @@ fn cash_cheque(tx: &mut Transaction,
             savepoint.rollback().map_err(Error::SqlError)?;
             ret
         }
-        Ok(_) => {
-            savepoint.commit().map_err(Error::SqlError)
-        }
+        Ok(_) => savepoint.commit().map_err(Error::SqlError),
     }
 }
 
-
 #[cfg(test)]
 mod test_caching_cheques {
     use rusqlite::Connection;
@@ -118,7 +145,8 @@ mod test_caching_cheques {
         let sec = securities.get(0).unwrap();
         let drawer = users.get(0).unwrap();
         let payee = users.get(1).unwrap();
-        let security_emitter_account = create_security_emitter_account(&tx, &sec.id(), &drawer.id()).unwrap();
+        let security_emitter_account =
+            create_security_emitter_account(&tx, &sec.id(), &drawer.id()).unwrap();
         let payee_account = create_checking_account(&tx, &sec.id(), &payee.id()).unwrap();
 
         tx.commit().unwrap();
@@ -127,9 +155,13 @@ mod test_caching_cheques {
         (conn, security_emitter, payee, payee_account.id())
     }
 
-    fn _create_100_secs_in_payee_account(tx: &mut Transaction, security_emitter: &Drawer, payee: &Payee, payee_account: &AccountId) {
-        let cheque = Cheque::new(
-            security_emitter.clone(), payee.clone(), 100, 99);
+    fn _create_100_secs_in_payee_account(
+        tx: &mut Transaction,
+        security_emitter: &Drawer,
+        payee: &Payee,
+        payee_account: &AccountId,
+    ) {
+        let cheque = Cheque::new(security_emitter.clone(), payee.clone(), 100, 99);
 
         cash_cheque(tx, &cheque, &payee_account).unwrap();
     }
@@ -144,7 +176,8 @@ mod test_caching_cheques {
         let mut tx = conn.transaction().unwrap();
 
         _create_100_secs_in_payee_account(&mut tx, &security_emitter, &payee, &payee_account);
-        let reg_account = create_checking_account(&tx, &security_emitter.2, &security_emitter.0).unwrap();
+        let reg_account =
+            create_checking_account(&tx, &security_emitter.2, &security_emitter.0).unwrap();
 
         tx.commit().unwrap();
 
@@ -154,14 +187,12 @@ mod test_caching_cheques {
         return (conn, drawer, new_payee, reg_account.id());
     }
 
-
     #[test]
     fn test_happy_path_currency_emitter() -> CustomResult<()> {
         let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
         let mut tx = conn.transaction().unwrap();
 
-        let cheque = Cheque::new(
-            security_emitter, payee, 1000, 99);
+        let cheque = Cheque::new(security_emitter, payee, 1000, 99);
 
         cash_cheque(&mut tx, &cheque, &payee_account)?;
         tx.commit().unwrap();
@@ -178,8 +209,7 @@ mod test_caching_cheques {
         let (mut conn, drawer, payee, payee_account) = setup_basic();
         let mut tx = conn.transaction().unwrap();
 
-        let cheque = Cheque::new(
-            drawer.clone(), payee, 25, 10001);
+        let cheque = Cheque::new(drawer.clone(), payee, 25, 10001);
 
         cash_cheque(&mut tx, &cheque, &payee_account)?;
 
@@ -192,16 +222,22 @@ mod test_caching_cheques {
         Ok(())
     }
 
-    fn test_negative_cheque(conn: &mut Connection, drawer: Drawer, payee: Payee, payee_account: AccountId) -> CustomResult<()> {
+    fn test_negative_cheque(
+        conn: &mut Connection,
+        drawer: Drawer,
+        payee: Payee,
+        payee_account: AccountId,
+    ) -> CustomResult<()> {
         let mut tx = conn.transaction().unwrap();
 
-        let cheque = Cheque::new(
-            drawer, payee, -1, 99);
+        let cheque = Cheque::new(drawer, payee, -1, 99);
 
         let ret = cash_cheque(&mut tx, &cheque, &payee_account);
         match ret {
             Err(Error::InvalidAmount(_)) => Ok(()),
-            _ => Err(Error::Testing("Expected invalid amount error here.".to_string()))
+            _ => Err(Error::Testing(
+                "Expected invalid amount error here.".to_string(),
+            )),
         }
     }
 
@@ -217,15 +253,15 @@ mod test_caching_cheques {
         test_negative_cheque(&mut conn, drawer, payee, payee_account)
     }
 
-    fn test_double_spend(conn: &mut Connection, drawer: Drawer, payee: Payee, payee_account: AccountId) -> CustomResult<()> {
+    fn test_double_spend(
+        conn: &mut Connection,
+        drawer: Drawer,
+        payee: Payee,
+        payee_account: AccountId,
+    ) -> CustomResult<()> {
         let mut tx = conn.transaction().unwrap();
 
-        let cheque = Cheque::new(
-            drawer,
-            payee,
-            10,
-            99,
-        );
+        let cheque = Cheque::new(drawer, payee, 10, 99);
 
         cash_cheque(&mut tx, &cheque, &payee_account)?;
         tx.commit().unwrap();
@@ -234,7 +270,9 @@ mod test_caching_cheques {
         let ret = cash_cheque(&mut tx, &cheque, &payee_account);
         match ret {
             Err(Error::DoubleSpendingError(_)) => Ok(()),
-            _ => Err(Error::Testing("Expected double spending error here.".to_string()))
+            _ => Err(Error::Testing(
+                "Expected double spending error here.".to_string(),
+            )),
         }
     }
 
@@ -250,21 +288,21 @@ mod test_caching_cheques {
         test_double_spend(&mut conn, drawer, payee, payee_account)
     }
 
-    fn test_invalid_drawer(conn: &mut Connection, drawer: Drawer, payee: Payee, payee_account: AccountId) -> CustomResult<()> {
+    fn test_invalid_drawer(
+        conn: &mut Connection,
+        drawer: Drawer,
+        payee: Payee,
+        payee_account: AccountId,
+    ) -> CustomResult<()> {
         let mut tx = conn.transaction().unwrap();
         let not_currency_owner_user_id = UserId::from_id(drawer.0.get_id() + 72623);
         let not_currency_owner: Drawer = (not_currency_owner_user_id, drawer.1, drawer.2);
-        let cheque = Cheque::new(
-            not_currency_owner,
-            payee,
-            100,
-            99,
-        );
+        let cheque = Cheque::new(not_currency_owner, payee, 100, 99);
 
         let ret = cash_cheque(&mut tx, &cheque, &payee_account);
         match ret {
             Err(Error::InvalidDrawer(_)) => Ok(()),
-            _ => Err(Error::Testing("Expected invalid drawer here.".to_string()))
+            _ => Err(Error::Testing("Expected invalid drawer here.".to_string())),
         }
     }
 
@@ -280,22 +318,24 @@ 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) -> 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;
 
-        let cheque = Cheque::new(
-            security_emitter.clone(), payee.clone(), 1000, 99);
+        let cheque = Cheque::new(security_emitter.clone(), payee.clone(), 1000, 99);
 
         let ret = cash_cheque(&mut tx, &cheque, wrong_payee_account);
         match ret {
             Err(Error::InvalidPayee(_)) => Ok(()),
-            _ => Err(Error::Testing("Expected invalid payee here.".to_string()))
+            _ => Err(Error::Testing("Expected invalid payee here.".to_string())),
         }
     }
 
-
     #[test]
     fn test_invalid_payee_security_emitter_cheque() -> CustomResult<()> {
         let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
@@ -307,4 +347,4 @@ mod test_caching_cheques {
         let (mut conn, drawer, payee, payee_account) = setup_basic();
         test_invalid_payee(&mut conn, drawer, payee)
     }
-}
+}