feat: cleanup, API for statement works correctly now

saskenuba · saskenuba · commit 0cc0ce5fdee4 · 2024-03-01T16:31:22.000-03:00
Signed-off-by: Martin &lt;martin@hotmail.com.br&gt;
diff --git a/src/api/mod.rs b/src/api/mod.rs
@@ -1,19 +1,16 @@
 use crate::application::adapters::{StatementDTO, TransactionDTO};
+use crate::application::cache::AccountCache;
+use crate::application::repositories::TransactionRepository;
 use crate::application::ServerData;
+use crate::domain::account::Account;
 use crate::domain::transaction::Transaction;
-use crate::infrastructure::redis_lock::RedisLock;
 use crate::infrastructure::server_impl::request::Request;
 use crate::infrastructure::server_impl::response::{JsonResponse, Response, StatusCode};
 use crate::infrastructure::server_impl::server::Method;
-use crate::{AnyResult, Statement};
-use compact_str::CompactString;
+use crate::AnyResult;
 use eyre::bail;
-use redis::streams::StreamRangeReply;
-use redis::{AsyncCommands, Client, Value};
-use serde::{Deserialize, Serialize};
-use std::mem;
-use std::sync::Arc;
-use time::OffsetDateTime;
+use fnv::FnvHashMap;
+use std::sync::{Arc, Mutex};
 
 pub mod input_types;
 
@@ -28,13 +25,16 @@ pub async fn statement_route(
         bail!("Only GET available.")
     }
 
-    let my = Statement {
-        balance: 0,
-        time_of_statement: OffsetDateTime::now_utc(),
-        credit_limit: 0,
+    let service = BankAccountService {
+        re_conn: server_data.re_conn.clone(),
+        pg_conn: server_data.pg_pool.clone(),
     };
 
-    let a = JsonResponse::from::<StatementDTO>(my.into());
+    let res = service
+        .query(AccountQueries::Statement { account: client_id })
+        .await;
+
+    let a = JsonResponse::from::<StatementDTO>(StatementDTO::from_other(res));
     Ok(a.0)
 }
 
@@ -54,7 +54,7 @@ pub async fn transaction_route(
         .unwrap();
 
     let mapping = serde_json::from_slice::<TransactionDTO>(body)
-        .map_err(|e| ())
+        .map_err(|_| ())
         .and_then(|c| c.try_into());
 
     let transaction: Transaction = match mapping {
@@ -83,69 +83,78 @@ pub async fn transaction_route(
     //              -> insert transaction and balance on redis
     //              -> remove lock
 
-    let command = AccountCommands::WithdrawMoney {
+    let command = AccountCommands::HandleMoney {
         account: client_id,
-        transaction: &transaction,
+        transaction,
     };
 
-    let res = BankAccountService {
+    let bank_service = BankAccountService {
         re_conn: server_data.re_conn.clone(),
         pg_conn: server_data.pg_pool.clone(),
-    }
-    .handler(command)
-    .await;
+    };
+    let res = bank_service.handler(command).await;
+
+    // if res.is_err() {
+    //     return Ok(Response::from_status_code(
+    //         StatusCode::UnprocessableEntity,
+    //         None,
+    //     ));
+    // }
 
-    let a = JsonResponse::from::<TransactionDTO>(transaction.into());
+    let a =
+        JsonResponse::from::<TransactionDTO>(TransactionDTO::from(Transaction::generate(1, None)));
     Ok(a.0)
 }
 
+pub type AccountMapStorage = Arc<FnvHashMap<i32, (u32, Mutex<Account>)>>;
+
 struct BankAccountService {
     re_conn: redis::aio::ConnectionManager,
     pg_conn: deadpool_postgres::Pool,
+    // storage: AccountMapStorage,
 }
 
-enum AccountCommands<'a> {
-    DepositMoney {
-        user: i32,
-        amount: &'a Transaction,
-    },
-    WithdrawMoney {
+#[derive(Debug)]
+enum AccountCommands {
+    HandleMoney {
         account: i32,
-        transaction: &'a Transaction,
+        transaction: Transaction,
     },
 }
 
+#[derive(Debug)]
 enum AccountQueries {
-    Statement,
+    Statement { account: i32 },
 }
 
 impl BankAccountService {
-    async fn handler(&self, command: AccountCommands<'_>) {
+    async fn query(&self, command: AccountQueries) -> (Account, impl Iterator<Item = Transaction>) {
         match command {
-            AccountCommands::DepositMoney { .. } => unimplemented!(),
-            AccountCommands::WithdrawMoney {
+            AccountQueries::Statement { account: user } => {
+                let trans_cache = AccountCache {
+                    re_conn: self.re_conn.clone(),
+                };
+
+                let res = trans_cache.get_account(user, true).await;
+                (res.0, res.1.unwrap())
+            }
+        }
+    }
+    async fn handler(&self, command: AccountCommands) -> AnyResult<()> {
+        match command {
+            AccountCommands::HandleMoney {
                 account: user,
                 transaction,
             } => {
                 let trans_repo = TransactionRepository {
                     conn: self.pg_conn.clone(),
                 };
 
-                let trans_cache = TransactionCache {
+                let trans_cache = AccountCache {
                     re_conn: self.re_conn.clone(),
                 };
 
-                let redis_lock = RedisLock::new(self.re_conn.clone(), user, 100);
-                {
-                    let guard = redis_lock.acquire().await.unwrap();
-                    trans_repo.save_transaction(user, transaction).await;
-                    trans_cache.append(user, transaction).await;
-                    guard.release().await;
-                }
-            }
-        }
-    }
-}
+                // let redis_lock = RedisLock::new(self.re_conn.clone(), user, 100);
 
                 let (acc, _) = trans_cache.get_account(user, false).await;
                 let acc = acc
diff --git a/src/application/adapters/mod.rs b/src/application/adapters/mod.rs
@@ -1,5 +1,5 @@
+use crate::domain::account::Account;
 use crate::domain::transaction::{Transaction, TransactionDescription, TransactionKind};
-use crate::Statement;
 use compact_str::{CompactString, ToCompactString};
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
@@ -10,26 +10,41 @@ use time::OffsetDateTime;
 #[allow(non_camel_case_types)]
 #[derive(Debug, Serialize)]
 pub struct StatementDTO {
+    #[serde(rename = "saldo")]
+    saldo: SaldoDTO,
+    #[serde(rename = "ultimas_transacoes")]
+    transactions: Vec<TransactionDTO<'static>>,
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Serialize)]
+pub struct SaldoDTO {
     #[serde(rename = "total")]
     total_balance: i32,
     #[serde(rename = "data_extrato")]
     data_extrato: CompactString,
     #[serde(rename = "limite")]
     credit_limit: u32,
 }
-
-impl From<Statement> for StatementDTO {
-    fn from(value: Statement) -> Self {
-        let formatted = value
-            .time_of_statement
+impl StatementDTO {
+    pub fn from_other(value: (Account, impl Iterator<Item = Transaction>)) -> Self {
+        let formatted = OffsetDateTime::now_utc()
             .format(&Iso8601::DEFAULT)
             .unwrap()
             .to_compact_string();
 
+        let acc = value.0;
+        let transactions = value.1;
         Self {
-            total_balance: value.balance,
-            data_extrato: formatted,
-            credit_limit: value.credit_limit,
+            saldo: SaldoDTO {
+                total_balance: acc.balance,
+                data_extrato: formatted,
+                credit_limit: acc.credit_limit,
+            },
+            transactions: transactions
+                .into_iter()
+                .map(TransactionDTO::from)
+                .collect::<Vec<_>>(),
         }
     }
 }
@@ -59,11 +74,15 @@ impl TryFrom<TransactionDTO<'_>> for Transaction {
             _ => return Err(()),
         };
 
-        let description = TransactionDescription::new(&value.description).map_err(|e| {
+        let description = TransactionDescription::new(&value.description).map_err(|_| {
             eprintln!("desc error");
-            ()
         })?;
-        let amount = NonZeroI32::new(value.amount).ok_or(())?;
+
+        let amount = if matches!(kind, TransactionKind::Debit) {
+            NonZeroI32::new(-value.amount).ok_or(())?
+        } else {
+            NonZeroI32::new(value.amount).ok_or(())?
+        };
 
         Ok(Self {
             valor: amount,
@@ -82,7 +101,7 @@ impl From<Transaction> for TransactionDTO<'_> {
         };
 
         let description = value.descricao.0.into();
-        let amount = i32::from(value.valor);
+        let amount = i32::from(value.valor.abs());
         let created_on = Some(value.realizada_em.format(&Iso8601::DEFAULT).unwrap().into());
 
         Self {
diff --git a/src/application/mod.rs b/src/application/mod.rs
@@ -1,18 +1,8 @@
 pub mod adapters;
+pub mod cache;
+pub mod repositories;
 
 use deadpool_postgres::Pool;
-use std::sync::Arc;
-
-#[derive(Copy, Clone, Debug)]
-pub struct AccountService {}
-
-impl AccountService {
-    fn get_balance() {
-
-        // get user from database
-        // and store transactions on redis so we can get to the balance faster
-    }
-}
 
 #[derive(Clone)]
 pub struct ServerData {
