feat: add book getter

src/api/book.rs

@@ -1,4 +1,3 @@
-
 use axum::routing::{get, post};
 use axum::{
     extract::{Path, State},
@@ -7,19 +6,25 @@ use axum::{
 };
 use axum_macros::debug_handler;
 
-use sea_orm::ColumnTrait;
+use crate::model::db::book::ActiveModel as BookActiveModel;
-use sea_orm::{entity::*, query::*,};
-use crate::model::db::prelude::Book;
-use crate::model::db::book::Model as BookModel;
 use crate::model::db::book::Column as BookColumn;
+use crate::model::db::book::Model as BookModel;
+use crate::model::db::prelude::Book;
 use crate::model::http_body::book;
+use crate::model::http_body::book::{BookInfo, BookItem};
+use crate::model::http_body::common::SimpleResponse;
 use crate::AppState;
-use crate::model::http_body::book::BookItem;
+use sea_orm::sqlx::types::chrono::Local;
+use sea_orm::{entity::*, query::*};
+use sea_orm::{ColumnTrait, Iden};
 
 pub fn get_nest_handlers() -> Router<crate::AppState> {
     Router::new()
-        .route("/", get(get_all_books_handler))
+        .route(
-        // .route("/{id}", post(update_book).get(get_book))
+            "/{id}",
+            post(update_book_handler).get(get_book_by_id_handler),
+        )
+        .route("/", post(create_book_handler).get(get_all_books_handler))
 }
 
 // handlers
@@ -46,3 +51,122 @@ async fn get_all_books_handler(
     }
     Ok(Json(books))
 }
+
+#[debug_handler]
+async fn get_book_by_id_handler(
+    Path(id):Path<i64>,
+    state:State<AppState>,
+) -> Result<Json<BookItem>,(StatusCode,String)> {
+    // let conn = state.conn.get_postgres_connection_pool();
+    let uid: i64 = 1;
+    let book_query = Book::find()
+        .filter(BookColumn::Uid.eq(uid))
+        .filter(BookColumn::Id.eq(id))
+        .one(&state.conn)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    let book_resp: BookItem;
+    match book_query {
+        Some(b) => {
+            book_resp = BookItem {
+                id: b.id,
+                name: b.name,
+            };
+        }
+        _ => {
+            return Err((StatusCode::NOT_FOUND, "not_found".to_string()));
+        }
+    }
+    Ok(Json(book_resp))
+}
+
+#[debug_handler]
+async fn create_book_handler(
+    state: State<AppState>,
+    Json(payload): Json<BookInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    // let conn = state.conn.get_postgres_connection_pool();
+    let uid: i64 = 1;
+
+    let book = BookActiveModel {
+        name: Set(payload.name.clone().to_owned()),
+        uid: Set(uid.to_owned()),
+        ..Default::default()
+    };
+
+    let res = Book::insert(book).exec(&state.conn).await;
+    let mut err_code: i64 = 0;
+    let mut msg: String;
+    match res {
+        Ok(_) => {
+            err_code = 0;
+            msg = "ok".to_owned();
+        }
+        Err(e) => {
+            err_code = 0;
+            msg = e.to_string();
+        }
+    }
+
+    let resp = SimpleResponse {
+        code: err_code,
+        message: msg,
+    };
+
+    Ok(Json(resp))
+}
+
+#[debug_handler]
+async fn update_book_handler(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    Json(payload): Json<BookInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    // let conn = state.conn.get_postgres_connection_pool();
+    let uid: i64 = 1;
+
+    let exist_book = Book::find()
+        .filter(BookColumn::Uid.eq(uid))
+        .filter(BookColumn::Id.eq(id))
+        .one(&state.conn)
+        .await;
+    let book: BookModel;
+    let mut resp = SimpleResponse {
+        code: 0,
+        message: "ok".to_owned(),
+    };
+    match exist_book {
+        Ok(b) => match b {
+            Some(bk) => {
+                book = bk;
+            }
+            _ => return Err((StatusCode::NOT_FOUND, "not_found".to_string())),
+        },
+        Err(_) => {
+            resp.code = 1;
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "connection_error".to_string(),
+            ));
+        }
+    }
+
+    let mut book_active_model: BookActiveModel = book.into();
+    book_active_model.name = Set(payload.name.clone());
+    book_active_model.updated_at = Set(Local::now().naive_utc());
+    let update_res = book_active_model.update(&state.conn).await;
+    match update_res {
+        Ok(_) => {
+            resp.code = 0;
+            resp.message = "ok".to_owned();
+        }
+        Err(_) => {
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "book_update_fail".to_string(),
+            ));
+        }
+    }
+    Ok(Json(resp))
+}

src/model/http_body/book.rs

@@ -1,7 +1,12 @@
-use serde::Serialize;
+use serde::{Serialize, Deserialize};
 
 #[derive(Serialize)]
 pub struct BookItem {
     pub id: i64,
     pub name: String,
 }
+
+#[derive(Serialize,Deserialize)]
+pub struct BookInfo {
+    pub name: String,
+}

src/model/http_body/common.rs

@@ -0,0 +1,7 @@
+use serde::{Serialize,Deserialize};
+
+#[derive(Serialize)]
+pub struct SimpleResponse {
+    pub code: i64,
+    pub message: String,
+}

src/model/http_body/mod.rs

@@ -1 +1,2 @@
 pub mod book;
+pub mod common;