Merge pull request #25 from suba327777/main

feat/update account

Author: suba327777

src/domain/repository/account.rs

@@ -1,9 +1,10 @@
 use super::super::object::account::{Account, AccountId};
-use anyhow::Result;
+use anyhow;
 
 pub trait AccountRepository {
-    fn insert(&self, account: &Account) -> Result<()>;
-    fn list(&self) -> Result<Vec<Account>>;
-    fn find_by_id(&self, account_id: &AccountId) -> Result<Account>;
-    fn delete(&self, account: &Account) -> Result<()>;
+    fn insert(&self, account: &Account) -> anyhow::Result<()>;
+    fn list(&self) -> anyhow::Result<Vec<Account>>;
+    fn find_by_id(&self, account_id: &AccountId) -> anyhow::Result<Account>;
+    fn update(&self, account: &Account) -> anyhow::Result<()>;
+    fn delete(&self, account: &Account) -> anyhow::Result<()>;
 }

src/infrastructures/repository/account.rs

@@ -1,7 +1,7 @@
 use super::super::database::models::{AccountEntity, NewAccountEntity};
 use crate::domain::object::account::{Account, AccountId};
 use crate::domain::repository::account::AccountRepository;
-use anyhow::Result;
+use anyhow;
 use chrono::NaiveDateTime;
 use diesel::prelude::*;
 use diesel::r2d2::{ConnectionManager, Pool};
@@ -57,7 +57,7 @@ pub struct AccountRepositoryImpl {
 }
 
 impl AccountRepository for AccountRepositoryImpl {
-    fn insert(&self, account: &Account) -> Result<()> {
+    fn insert(&self, account: &Account) -> anyhow::Result<()> {
         use super::super::database::schema::account::dsl;
 
         let entity = NewAccountEntity::from(account);
@@ -69,7 +69,7 @@ impl AccountRepository for AccountRepositoryImpl {
         Ok(())
     }
 
-    fn list(&self) -> Result<Vec<Account>> {
+    fn list(&self) -> anyhow::Result<Vec<Account>> {
         use super::super::database::schema::account::dsl;
 
         let query = dsl::account.into_boxed();
@@ -79,7 +79,7 @@ impl AccountRepository for AccountRepositoryImpl {
         Ok(results.into_iter().map(|e| e.of()).collect())
     }
 
-    fn find_by_id(&self, account_id: &AccountId) -> Result<Account> {
+    fn find_by_id(&self, account_id: &AccountId) -> anyhow::Result<Account> {
         use super::super::database::schema::account::dsl;
         use super::super::database::schema::account::id;
 
@@ -91,7 +91,19 @@ impl AccountRepository for AccountRepositoryImpl {
         Ok(entity.of())
     }
 
-    fn delete(&self, account: &Account) -> Result<()> {
+    fn update(&self, account: &Account) -> anyhow::Result<()> {
+        use super::super::database::schema::account::dsl;
+
+        let mut conn = self.pool.get()?;
+        let entity = AccountEntity::from(account);
+        diesel::update(dsl::account.filter(dsl::id.eq(account.id.get())))
+            .set(&entity)
+            .execute(&mut conn)?;
+
+        Ok(())
+    }
+
+    fn delete(&self, account: &Account) -> anyhow::Result<()> {
         let entity = AccountEntity::from(account);
         let mut conn = self.pool.get()?;
         diesel::delete(&entity).execute(&mut conn)?;

src/server/handler/account.rs

@@ -3,7 +3,7 @@ use super::super::response::account::{AccountDto, AccountListResopnse};
 use crate::domain::object::account::AccountId;
 use crate::server::connection::RequestContext;
 use crate::usecase;
-use actix_web::{delete, get, post, web, web::Json, HttpResponse, Responder};
+use actix_web::{delete, get, post, put, web, web::Json, HttpResponse, Responder};
 
 #[post("/accounts")]
 async fn post_account(
@@ -42,6 +42,21 @@ async fn get_account(
     }
 }
 
+#[put("/accounts/{id}")]
+async fn put_account(
+    data: web::Data<RequestContext>,
+    request: Json<AccountRequest>,
+    path_params: web::Path<(i64,)>,
+) -> impl Responder {
+    let account_id = AccountId::new(path_params.into_inner().0);
+    match usecase::account::put_account(&mut data.account_repository(), &request, &account_id) {
+        Ok(_) => HttpResponse::Ok().finish(),
+        Err(err) => {
+            HttpResponse::InternalServerError().json(format!("Internal Server Error {}", err))
+        }
+    }
+}
+
 #[delete("/accounts/{id}")]
 async fn delete_account(
     data: web::Data<RequestContext>,

src/server/mod.rs

@@ -1,5 +1,5 @@
 mod connection;
 mod handler;
-mod request;
+pub mod request;
 mod response;
 pub mod router;

src/server/request/account.rs

@@ -1,12 +1,12 @@
-use crate::domain::object::account::Account;
+use crate::domain::object::account::{Account, AccountId};
 use chrono::NaiveDateTime;
 use serde::Deserialize;
 
 #[derive(Debug, Default, Deserialize)]
 pub struct AccountRequest {
-    username: String,
-    grade: i32,
-    expiration_date: NaiveDateTime,
+    pub username: String,
+    pub grade: i32,
+    pub expiration_date: NaiveDateTime,
 }
 
 #[derive(Debug, Default, Deserialize)]
@@ -22,4 +22,13 @@ impl AccountRequest {
             self.expiration_date.to_owned(),
         )
     }
+    pub fn model(&self, account_id: AccountId, created_at: NaiveDateTime) -> Account {
+        Account {
+            id: account_id,
+            username: self.username.to_owned(),
+            grade: self.grade.to_owned(),
+            expiration_date: self.expiration_date.to_owned(),
+            created_at,
+        }
+    }
 }

src/server/router.rs

@@ -11,6 +11,7 @@ pub async fn run() -> std::io::Result<()> {
             .service(handler::account::post_account)
             .service(handler::account::get_accounts)
             .service(handler::account::get_account)
+            .service(handler::account::put_account)
             .service(handler::account::delete_account)
             .service(handler::card::post_card)
             .service(handler::card::get_cards)

src/tests/mock_account_repository.rs

@@ -29,6 +29,17 @@ impl AccountRepository for MockAccountRepository {
             None => Err(anyhow::anyhow!("Account not found")),
         }
     }
+
+    fn update(&self, account: &Account) -> anyhow::Result<()> {
+        let _ = &self
+            .pool
+            .borrow_mut()
+            .entry(account.id.get())
+            .or_insert_with(|| account.clone());
+
+        Ok(())
+    }
+
     fn delete(&self, account: &Account) -> anyhow::Result<()> {
         let _ = &self.pool.borrow_mut().remove(&account.id.get());
         Ok(())

src/usecase/account.rs

@@ -1,26 +1,41 @@
 use crate::domain::object::account::{Account, AccountId};
 use crate::domain::repository::account::AccountRepository;
-use anyhow::Result;
+use crate::server::request::account::AccountRequest;
+use actix_web::web::Json;
+use anyhow;
 
-pub fn post_account(repository: &mut impl AccountRepository, account: &Account) -> Result<()> {
+pub fn post_account(
+    repository: &mut impl AccountRepository,
+    account: &Account,
+) -> anyhow::Result<()> {
     repository.insert(account)
 }
 
-pub fn get_account_list(repository: &mut impl AccountRepository) -> Result<Vec<Account>> {
+pub fn get_account_list(repository: &mut impl AccountRepository) -> anyhow::Result<Vec<Account>> {
     repository.list()
 }
 
 pub fn get_account(
     repository: &mut impl AccountRepository,
     account_id: &AccountId,
-) -> Result<Account> {
+) -> anyhow::Result<Account> {
     repository.find_by_id(account_id)
 }
 
+pub fn put_account(
+    repository: &mut impl AccountRepository,
+    request: &Json<AccountRequest>,
+    account_id: &AccountId,
+) -> anyhow::Result<()> {
+    let account = repository.find_by_id(account_id)?;
+    let updated_account = request.model(account.id, account.created_at);
+    repository.update(&updated_account)
+}
+
 pub fn delete_account(
     repository: &mut impl AccountRepository,
     account_id: &AccountId,
-) -> Result<()> {
+) -> anyhow::Result<()> {
     let account = repository.find_by_id(account_id)?;
     repository.delete(&account)
 }
@@ -136,6 +151,31 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn success_put_account() {
+        let mut repository = MockAccountRepository {
+            pool: RefCell::new(HashMap::new()),
+        };
+
+        let test_account = Account {
+            id: AccountId::new(1),
+            username: "test_user".to_string(),
+            grade: 4,
+            expiration_date: Local::now().naive_local() + Duration::hours(1),
+            created_at: Local::now().naive_local(),
+        };
+
+        let update_account = AccountRequest {
+            username: "update_user".to_string(),
+            grade: 3,
+            expiration_date: Local::now().naive_local() + Duration::hours(2),
+        };
+
+        let _ = repository.insert(&test_account);
+        let result = put_account(&mut repository, &Json(update_account), &test_account.id);
+        assert!(result.is_ok());
+    }
+
     #[test]
     fn success_delete_account() {
         let mut repository = MockAccountRepository {