feat: pass since and limit to transaction list

Author: DewaldV

src/accounts.rs

@@ -73,7 +73,7 @@ pub async fn list(token: &str) -> Result<()> {
     for (account_type, account) in supported_accounts {
         let created = account.created.format("%Y-%m-%d").to_string();
         let balance = client.balance(&account.id).await?;
-        let balance_value = Amount::try_from(balance.balance)?;
+        let balance_value = Amount::from(balance.balance);
         print_balance_row(
             &account_type.value(),
             &account.account_number,

src/batch.rs

@@ -23,7 +23,7 @@ impl Display for Row {
     }
 }
 
-pub async fn run(token: String, file: String) -> Result<()> {
+pub async fn run(_token: String, file: String) -> Result<()> {
     let path = Path::new(&file);
     println!("starting batch run for file: {}", path.display());
 

src/currency.rs

@@ -9,11 +9,11 @@ use serde::Deserialize;
 #[derive(Clone, Debug, Deserialize)]
 #[serde(try_from = "&str")]
 pub struct Amount {
-    pub pence: u32,
+    pub pence: i64,
 }
 
-impl From<u32> for Amount {
-    fn from(pence: u32) -> Self {
+impl From<i64> for Amount {
+    fn from(pence: i64) -> Self {
         Amount { pence }
     }
 }
@@ -36,12 +36,11 @@ impl TryFrom<&str> for Amount {
     }
 }
 
-impl TryFrom<i64> for Amount {
+impl TryInto<u32> for Amount {
     type Error = TryFromIntError;
 
-    fn try_from(value: i64) -> Result<Self, Self::Error> {
-        let pence = u32::try_from(value)?;
-        Ok(Amount { pence })
+    fn try_into(self) -> Result<u32, Self::Error> {
+        self.pence.try_into()
     }
 }
 
@@ -69,13 +68,14 @@ impl Display for Amount {
 
 #[cfg(test)]
 mod test {
+
     use super::*;
 
     #[test]
     fn format_currency_decimals() {
         let pence = 890;
 
-        let value = Amount::from(pence).to_string();
+        let value = Amount { pence }.to_string();
 
         assert_eq!(value, "8.90")
     }
@@ -89,7 +89,7 @@ mod test {
         ];
 
         for (pence, expected) in cases {
-            let value = Amount::from(pence).to_string();
+            let value = Amount { pence }.to_string();
 
             assert_eq!(value, expected);
         }
@@ -99,7 +99,7 @@ mod test {
     fn parse_currency_decimals() {
         let pence = "10.05";
 
-        let value = Amount::from_str(pence)
+        let value = Amount::try_from(pence)
             .expect("must parse fixed value")
             .pence;
 
@@ -110,19 +110,28 @@ mod test {
     fn parse_currency_separators() {
         let pence = "1,010.05";
 
-        let value = Amount::from_str(pence)
+        let value = Amount::try_from(pence)
             .expect("must parse fixed value")
             .pence;
 
         assert_eq!(value, 101005);
     }
 
     #[test]
-    fn try_from_i64() {
+    fn from_i64() {
         let pence: i64 = 953578513525;
 
-        let value = Amount::try_from(pence);
+        let value = Amount::from(pence);
+
+        assert_eq!(value.pence, pence);
+    }
+
+    #[test]
+    fn try_into_u32() {
+        let pence = 1024;
+
+        let res: Result<u32, _> = Amount { pence }.try_into();
 
-        assert_eq!(value.is_err(), true);
+        assert_eq!(res.is_ok(), true);
     }
 }

src/main.rs

@@ -1,3 +1,4 @@
+use chrono::{DateTime, Utc};
 use clap::{Parser, Subcommand};
 use currency::Amount;
 
@@ -69,6 +70,12 @@ enum PotsCommands {
 enum TransactionCommands {
     List {
         account_type: accounts::AccountType,
+
+        #[arg(short, long)]
+        since: Option<DateTime<Utc>>,
+
+        #[arg(short, long, default_value = "10")]
+        limit: u16,
     },
     UpdateNote {
         transaction_id: String,
@@ -104,8 +111,12 @@ async fn main() -> Result<()> {
             }
         },
         Commands::Transactions { tx_cmd } => match tx_cmd {
-            TransactionCommands::List { account_type } => {
-                transactions::list(&args.monzo_access_token, account_type).await?;
+            TransactionCommands::List {
+                account_type,
+                since,
+                limit,
+            } => {
+                transactions::list(&args.monzo_access_token, account_type, since, limit).await?;
             }
             TransactionCommands::UpdateNote {
                 transaction_id,

src/pots.rs

@@ -22,7 +22,7 @@ pub async fn list(token: &str) -> Result<()> {
         let pots = client.pots(&account.id).await?;
 
         for pot in pots.iter().filter(|pot| !pot.deleted) {
-            let balance_value = Amount::try_from(pot.balance)?;
+            let balance_value = Amount::from(pot.balance);
             print_pot_balance_row(
                 &account_type.value(),
                 &account.account_number,
@@ -52,16 +52,18 @@ pub async fn deposit(
         }
 
         Some(pot) => {
-            let balance = Amount::try_from(pot.balance)?;
+            let balance = Amount::from(pot.balance);
             println!("Found pot. Name: {}, Balance: {}", pot.name, balance,);
+
+            let amount_i: u32 = amount.pence.try_into()?;
             client
-                .deposit_into_pot(&pot.id, &pot.current_account_id, amount.pence)
+                .deposit_into_pot(&pot.id, &pot.current_account_id, amount_i)
                 .await?;
             println!("Completed deposit. Name: {}, Amount: {}", pot.name, amount);
         }
     }
 
-    if let Some(description) = description {
+    if let Some(_description) = description {
         // find transaction
         // annotate transaction
     }

src/transactions.rs

@@ -7,7 +7,12 @@ use crate::accounts;
 use crate::currency::Amount;
 use crate::Result;
 
-pub async fn list(token: &str, account_type: accounts::AccountType) -> Result<()> {
+pub async fn list(
+    token: &str,
+    account_type: accounts::AccountType,
+    since: Option<DateTime<Utc>>,
+    limit: u16,
+) -> Result<()> {
     let client = Client::new(token);
 
     let accounts = client.accounts().await?;
@@ -27,16 +32,18 @@ pub async fn list(token: &str, account_type: accounts::AccountType) -> Result<()
             print_transaction_row("Created", "Category", "Description", "Amount");
             println!("-----------------------------------------------------------------------------------------------------------");
 
+            let since = since.unwrap_or(Utc::now() - Duration::days(1));
+
             let transactions = client
                 .transactions(&acc.id)
-                .since(Utc::now() - Duration::days(5))
-                .limit(10)
+                .since(since)
+                .limit(limit)
                 .send()
                 .await?;
 
             for tx in transactions.iter() {
                 let created = &tx.created.format("%Y-%m-%d").to_string();
-                let amount = Amount::try_from(tx.amount)?;
+                let amount = Amount::from(tx.amount);
                 print_transaction_row(created, &tx.category, &tx.id, &amount.to_string());
             }
         }
@@ -57,7 +64,7 @@ pub async fn annotate(token: &str, transaction_id: &str, note: String) -> Result
     println!("Note added.");
     println!("");
     let created = &tx.created.format("%Y-%m-%d").to_string();
-    let amount = Amount::try_from(tx.amount)?;
+    let amount = Amount::from(tx.amount);
     print_transaction_row("Created", "Category", "Note", "Amount");
     println!("-----------------------------------------------------------------------------------------------------------");
     print_transaction_row(created, &tx.category, &tx.notes, &amount.to_string());