feat: category apis

Cargo.lock

@@ -23,7 +23,7 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
  "once_cell",
  "version_check",
 ]
@@ -354,6 +354,33 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum-extra"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45bf463831f5131b7d3c756525b305d40f1185b688565648a92e1392ca35713d"
+dependencies = [
+ "axum",
+ "axum-core",
+ "axum-macros",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "headers",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_html_form",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "axum-macros"
 version = "0.5.0"
@@ -380,6 +407,12 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -755,13 +788,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "entity"
-version = "0.1.0"
-dependencies = [
- "sea-orm",
-]
-
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -976,8 +1002,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
 ]
 
 [[package]]
@@ -1033,6 +1073,30 @@ dependencies = [
  "hashbrown 0.15.3",
 ]
 
+[[package]]
+name = "headers"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322106e6bd0cba2d5ead589ddb8150a13d7c4217cf80d7c4f682ca994ccc6aa9"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "headers-core",
+ "http",
+ "httpdate",
+ "mime",
+ "sha1",
+]
+
+[[package]]
+name = "headers-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54b4a22553d4242c49fddb9ba998a99962b5cc6f22cb5a3482bec22522403ce4"
+dependencies = [
+ "http",
+]
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -1050,13 +1114,21 @@ name = "helios-server-rs"
 version = "0.1.0"
 dependencies = [
  "axum",
+ "axum-extra",
  "axum-macros",
  "clap",
  "dotenvy",
+ "jsonwebtoken",
+ "once_cell",
+ "pbkdf2",
+ "rand_core 0.9.3",
  "sea-orm",
  "serde",
+ "serde_json",
  "tokio",
  "toml",
+ "tower",
+ "tower-http",
  "tracing",
  "tracing-subscriber",
 ]
@@ -1361,6 +1433,21 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "jsonwebtoken"
+version = "9.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
+dependencies = [
+ "base64 0.22.1",
+ "js-sys",
+ "pem",
+ "ring",
+ "serde",
+ "serde_json",
+ "simple_asn1",
+]
+
 [[package]]
 name = "kv-log-macro"
 version = "1.0.7"
@@ -1493,7 +1580,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
 dependencies = [
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
 ]
 
@@ -1659,6 +1746,39 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+ "password-hash",
+ "sha2",
+]
+
+[[package]]
+name = "pem"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38af38e8470ac9dee3ce1bae1af9c1671fffc44ddfd8bd1d0a3445bf349a8ef3"
+dependencies = [
+ "base64 0.22.1",
+ "serde",
+]
+
 [[package]]
 name = "pem-rfc7468"
 version = "0.7.0"
@@ -1854,6 +1974,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -1868,7 +1994,7 @@ checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
  "rand_chacha",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -1878,7 +2004,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -1887,7 +2013,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.3",
 ]
 
 [[package]]
@@ -1960,7 +2095,7 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.16",
  "libc",
  "untrusted",
  "windows-sys 0.52.0",
@@ -2008,7 +2143,7 @@ dependencies = [
  "num-traits",
  "pkcs1",
  "pkcs8",
- "rand_core",
+ "rand_core 0.6.4",
  "signature",
  "spki",
  "subtle",
@@ -2290,6 +2425,19 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "serde_html_form"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d2de91cf02bbc07cde38891769ccd5d4f073d22a40683aa4bc7a95781aaa2c4"
+dependencies = [
+ "form_urlencoded",
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "serde_json"
 version = "1.0.140"
@@ -2386,7 +2534,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
  "digest",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -2395,6 +2543,18 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
+[[package]]
+name = "simple_asn1"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "297f631f50729c8c99b84667867963997ec0b50f32b2a7dbcab828ef0541e8bb"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "thiserror",
+ "time",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -2461,7 +2621,7 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bigdecimal",
  "bytes",
  "chrono",
@@ -2541,7 +2701,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
  "atoi",
- "base64",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags",
  "byteorder",
@@ -2588,7 +2748,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
  "atoi",
- "base64",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags",
  "byteorder",
@@ -2920,6 +3080,22 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "http",
+ "http-body",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.3"
@@ -3097,6 +3273,15 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
 [[package]]
 name = "wasite"
 version = "0.1.0"
@@ -3450,6 +3635,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.1"

Cargo.toml

@@ -5,10 +5,11 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [workspace]
-members = [".", "entity", "migration"]
+members = [".", "migration"]
 
 [dependencies]
 axum = { version = "0.8" }
+axum-extra = {version = "0.10", features = ["typed-header", "typed-routing"] }
 axum-macros = "0.5"
 sea-orm = { version = "1.1.12", features = [
     "sqlx-postgres",
@@ -17,9 +18,16 @@ sea-orm = { version = "1.1.12", features = [
     "chrono",
 ] }
 serde = { version = "1", features = ["derive"] }
+serde_json = "1.0.140"
 tokio = { version = "1.0", features = ["full"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 dotenvy = "0.15.7"
 toml = "0.8.22"
 clap = { version = "4.0", features = ["derive"] }
+pbkdf2 = { version = "0.12", features = ["simple"] }
+rand_core = { version = "0.9.3", features = ["std"] }
+jsonwebtoken = "9"
+once_cell = "1.21.3"
+tower-http = {version= "0.6", features = ["trace", "cors"] }
+tower = "0.5.2"

src/api/book.rs

@@ -1,4 +1,3 @@
-
 use axum::routing::{get, post};
 use axum::{
     extract::{Path, State},
@@ -7,42 +6,166 @@ use axum::{
 };
 use axum_macros::debug_handler;
 
-use sea_orm::ColumnTrait;
+use crate::middleware::auth::Claims;
-use sea_orm::{entity::*, query::*,};
+use crate::model::db::book::ActiveModel as BookActiveModel;
-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};
 
 pub fn get_nest_handlers() -> Router<crate::AppState> {
     Router::new()
-        .route("/", get(get_all_books_handler))
+        .route("/{id}/update",post(update_book_handler))
-        // .route("/{id}", post(update_book).get(get_book))
+        .route("/{id}",get(get_book_by_id_handler))
+        .route("/", post(create_book_handler).get(get_all_books_handler))
 }
 
 // handlers
 //
 #[debug_handler]
 async fn get_all_books_handler(
-    state: State<AppState>
+    state: State<AppState>,
-) -> Result<Json<Vec<book::BookItem>>,(StatusCode,String)> {
+    claims: Claims,
-    // let conn = state.conn.get_postgres_connection_pool();
+) -> Result<Json<Vec<book::BookItem>>, (StatusCode, String)> {
-    let uid :i64 = 1;
+    let uid: i64 = claims.uid.clone();
-    let all_books  = Book::find()
+    let all_books = Book::find()
         .filter(BookColumn::Uid.eq(uid))
         .all(&state.conn)
         .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR,e.to_string()))?;
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
 
     let mut books: Vec<BookItem> = Vec::new();
     for b in all_books {
-        let book_resp = BookItem{
+        let book_resp = BookItem {
-            id: b.id,
+            id: b.id.into(),
             name: b.name,
         };
         books.push(book_resp);
     }
     Ok(Json(books))
 }
+
+#[debug_handler]
+async fn get_book_by_id_handler(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<BookItem>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+    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.into(),
+                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>,
+    claims: Claims,
+    Json(payload): Json<BookInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+
+    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>,
+    claims: Claims,
+    Json(payload): Json<BookInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+
+    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/api/category.rs

@@ -0,0 +1,217 @@
+use crate::api::category;
+use crate::middleware::auth::Claims;
+use crate::model::db::prelude::Category;
+use crate::model::db::{
+    category::ActiveModel as CategoryActiveModel, category::Column as CategoryColumn,
+    category::Model as CategoryModel,
+};
+use crate::model::http_body::category::CategoryInfo;
+use crate::model::http_body::common::{OptionalI64, SimpleResponse};
+use crate::AppState;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+use axum::routing::{get, post};
+use axum::{Json, Router};
+use axum_macros::debug_handler;
+
+use sea_orm::sqlx::types::chrono::Local;
+use sea_orm::QueryFilter;
+use sea_orm::{entity::*, query::*};
+use tokio::join;
+
+pub fn get_nested_handlers() -> Router<crate::AppState> {
+    Router::new()
+        .route("/{id}/update", post(update_category_by_id))
+        .route("/{id}", get(get_category_by_id))
+        .route("/", post(create_category).get(get_all_categories))
+}
+
+#[debug_handler]
+async fn get_all_categories(
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<Vec<CategoryInfo>>, (StatusCode, String)> {
+    let uid = claims.uid.clone();
+    let categories_query = Category::find()
+        .filter(CategoryColumn::Uid.eq(uid))
+        .all(&state.conn)
+        .await;
+    let category_models = match categories_query {
+        Ok(categories) => categories,
+        Err(e) => return Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
+    };
+    let mut category_resp: Vec<CategoryInfo> = Vec::new();
+    for category in category_models {
+        let category_info = CategoryInfo {
+            id: category.id.into(),
+            name: category.name,
+            parent_id: category.parent_id.into(),
+        };
+        category_resp.push(category_info);
+    }
+    Ok(Json(category_resp))
+}
+
+#[debug_handler]
+async fn create_category(
+    state: State<AppState>,
+    claims: Claims,
+    payload: Json<CategoryInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid = claims.uid.clone();
+    let parent_id: i64 = match payload.parent_id {
+        OptionalI64(pid_opt) => pid_opt.unwrap_or_else(|| 0),
+    };
+    let category_active_model = CategoryActiveModel {
+        name: Set(payload.name.clone()),
+        uid: Set(uid),
+        parent_id: Set(parent_id),
+        ..Default::default()
+    };
+    let insert_res = Category::insert(category_active_model)
+        .exec(&state.conn)
+        .await;
+    match insert_res {
+        Ok(_) => Ok(Json(SimpleResponse {
+            code: 0,
+            message: "success".to_string(),
+        })),
+        Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
+    }
+}
+
+#[debug_handler]
+async fn get_category_by_id(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<CategoryInfo>, (StatusCode, String)> {
+    let uid = claims.uid.clone();
+    let category_query_res = Category::find()
+        .filter(CategoryColumn::Uid.eq(uid))
+        .filter(CategoryColumn::Id.eq(id))
+        .one(&state.conn)
+        .await;
+    let category_query: CategoryModel = match category_query_res {
+        Ok(r) => match r {
+            Some(res) => res,
+            None => return Err((StatusCode::NOT_FOUND, "not found".to_string())),
+        },
+        Err(e) => return Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
+    };
+    let category_resp = CategoryInfo {
+        id: category_query.id.into(),
+        name: category_query.name.clone(),
+        parent_id: category_query.parent_id.into(),
+    };
+    Ok(Json(category_resp))
+}
+
+#[debug_handler]
+async fn update_category_by_id(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+    payload: Json<CategoryInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid = claims.uid.clone();
+    let mut parent_category_required = false;
+    let mut parent_id: i64 = 0;
+    let category_query = Category::find()
+        .filter(CategoryColumn::Uid.eq(uid))
+        .filter(CategoryColumn::Id.eq(id))
+        .one(&state.conn);
+    let parent_query = match payload.parent_id {
+        OptionalI64(Some(cid)) => {
+            if cid > 0 {
+                parent_category_required = true;
+                parent_id = cid;
+                Some(
+                    Category::find()
+                        .filter(CategoryColumn::Uid.eq(uid))
+                        .filter(CategoryColumn::ParentId.eq(cid))
+                        .one(&state.conn),
+                )
+            } else {
+                None
+            }
+        }
+        OptionalI64(None) => None,
+    };
+
+    let (category_result, parent_result) = if let Some(parent_query) = parent_query {
+        // 并发执行两个查询
+        let (category, parent) = join!(category_query, parent_query);
+        // 处理查询结果
+        (
+            category.map_err(|e| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    format!("Database error: {}", e),
+                )
+            })?,
+            parent.map_err(|e| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    format!("Database error: {}", e),
+                )
+            })?,
+        )
+    } else {
+        // 只查询 category
+        (
+            category_query.await.map_err(|e| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    format!("Database error: {}", e),
+                )
+            })?,
+            None,
+        )
+    };
+
+    let category = match category_result {
+        Some(category) => {
+            category
+        }
+        None => {
+            return Err((StatusCode::NOT_FOUND, "Category not found".to_string()));
+        }
+    };
+    let parent_category_valid = match parent_result {
+        Some(_) => { true }
+        None => { false }
+    };
+
+    let mut resp = SimpleResponse {
+        code: 0,
+        message: "success".to_string(),
+    };
+    let mut category_active_model : CategoryActiveModel = category.into();
+    category_active_model.name = Set(payload.name.clone());
+    category_active_model.updated_at = Set(Local::now().naive_utc());
+    if parent_category_required && parent_id > 0 {
+        category_active_model.parent_id = Set(parent_id.into());
+    }
+
+    let update_res = category_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,
+                "category update failed".to_string(),
+            ));
+        }
+    }
+
+    if parent_category_required && !parent_category_valid {
+        resp.code = 1;
+        resp.message = "Parent category not found".to_string();
+        return Err((StatusCode::NOT_FOUND, "Parent category not found".to_string()));
+    }
+    Ok(Json(resp))
+}

src/api/mod.rs

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

src/main.rs

@@ -1,17 +1,28 @@
-use axum::Router;
+use crate::middleware::auth;
+use axum::{http::Method, Router};
 use clap::Parser;
 use sea_orm::{Database, DatabaseConnection};
 use serde::Deserialize;
+use tower::ServiceBuilder;
+use tower_http::cors::{Any, CorsLayer};
+use tower_http::trace::TraceLayer;
+use tracing::info;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 // Project modules
 mod api;
+mod middleware;
 mod model;
+mod util;
+mod query;
 
 #[tokio::main]
 async fn main() {
     dotenvy::dotenv().unwrap();
     // initialize tracing
-    tracing_subscriber::fmt::init();
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::fmt::layer())
+        .init();
     let cli = Cli::parse();
     match cli.command {
         Command::Serve { config_path } => {
@@ -76,24 +87,33 @@ async fn load_config(path: &str) -> Result<Config, Box<dyn std::error::Error>> {
 
 // ====== Commands ======
 
-
 // start http server
-async fn start_server(config: &Config){
+async fn start_server(config: &Config) {
-    // Define the router
-    // let app = Router.new()
-    //     .nest();
     let conn = Database::connect(&config.database.connection)
-    .await
+        .await
         .expect("Database connection failed.");
 
-    let state = AppState{conn };
+    auth::initialize_jwt_key(config.keys.jwt.clone());
+
+    let state = AppState { conn };
+    // Build router
+    let cors_layer = CorsLayer::new()
+        .allow_methods([Method::GET, Method::POST])
+        .allow_origin(Any);
+    let global_layer = ServiceBuilder::new()
+        .layer(TraceLayer::new_for_http())
+        .layer(cors_layer);
+
     let app = Router::new()
         .nest("/api/v1/book", api::book::get_nest_handlers())
-        .with_state(state);
+        .nest("/api/v1/category", api::category::get_nested_handlers())
+        .with_state(state)
+        .layer(global_layer);
     let host = config.service.host.clone();
     let port = config.service.port;
     let server_url = format!("{host}:{port}");
     let listener = tokio::net::TcpListener::bind(&server_url).await.unwrap();
-    axum::serve(listener, app).await.expect("Service panic happened");
+    axum::serve(listener, app)
-
+        .await
+        .expect("Service panic happened");
 }

src/middleware/auth.rs

@@ -0,0 +1,120 @@
+use axum::{
+    extract::FromRequestParts,
+    http::{request::Parts, StatusCode},
+    response::{IntoResponse, Response},
+    Json, RequestPartsExt,
+};
+use axum_extra::{
+    headers::{authorization::Bearer, Authorization},
+    TypedHeader,
+};
+use jsonwebtoken::{decode, encode, DecodingKey, EncodingKey, Header, Validation};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::fmt::Display;
+use std::sync::OnceLock;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Claims {
+    sub: String,
+    // company: String,
+    exp: usize,
+    pub uid: i64,
+}
+
+#[derive(Debug, Serialize)]
+struct AuthBody {
+    access_token: String,
+    token_type: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct AuthPayload {
+    client_id: String,
+    client_secret: String,
+}
+
+#[derive(Debug)]
+pub enum AuthError {
+    WrongCredentials,
+    MissingCredentials,
+    TokenCreation,
+    InvalidToken,
+}
+
+static KEYS: OnceLock<Keys> = OnceLock::new();
+
+pub fn initialize_jwt_key(key_str: String) {
+    let res = KEYS.set(Keys::new(key_str.as_bytes()));
+    match res {
+        Ok(_) => {}
+        Err(_) => panic!("jwt key initialize failed"),
+    }
+}
+
+struct Keys {
+    encoding: EncodingKey,
+    decoding: DecodingKey,
+}
+
+impl Keys {
+    fn new(secret: &[u8]) -> Self {
+        Self {
+            encoding: EncodingKey::from_secret(secret),
+            decoding: DecodingKey::from_secret(secret),
+        }
+    }
+}
+
+impl Display for Claims {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Email: {}", self.sub)
+    }
+}
+
+impl AuthBody {
+    fn new(access_token: String) -> Self {
+        Self {
+            access_token,
+            token_type: "Bearer".to_string(),
+        }
+    }
+}
+
+impl<S> FromRequestParts<S> for Claims
+where
+    S: Send + Sync,
+{
+    type Rejection = AuthError;
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        // Extract the token from the authorization header
+        let TypedHeader(Authorization(bearer)) = parts
+            .extract::<TypedHeader<Authorization<Bearer>>>()
+            .await
+            .map_err(|_| AuthError::InvalidToken)?;
+        // Decode the user data
+        let token_data = decode::<Claims>(
+            bearer.token(),
+            &KEYS.get().unwrap().decoding,
+            &Validation::default(),
+        )
+        .map_err(|_| AuthError::InvalidToken)?;
+
+        Ok(token_data.claims)
+    }
+}
+impl IntoResponse for AuthError {
+    fn into_response(self) -> Response {
+        let (status, error_message) = match self {
+            AuthError::WrongCredentials => (StatusCode::UNAUTHORIZED, "Wrong credentials"),
+            AuthError::MissingCredentials => (StatusCode::BAD_REQUEST, "Missing credentials"),
+            AuthError::TokenCreation => (StatusCode::INTERNAL_SERVER_ERROR, "Token creation error"),
+            AuthError::InvalidToken => (StatusCode::BAD_REQUEST, "Invalid token"),
+        };
+        let body = Json(json!({
+            "error": error_message,
+        }));
+        (status, body).into_response()
+    }
+}

src/middleware/mod.rs

@@ -0,0 +1 @@
+pub mod auth;

src/model/http_body/book.rs

@@ -1,7 +1,14 @@
-use serde::Serialize;
+use serde::{Serialize, Deserialize};
+use super::common::{number_stringify, OptionalI64};
 
 #[derive(Serialize)]
 pub struct BookItem {
-    pub id: i64,
+    #[serde(with="number_stringify")]
+    pub id: OptionalI64,
+    pub name: String,
+}
+
+#[derive(Serialize,Deserialize)]
+pub struct BookInfo {
     pub name: String,
 }

src/model/http_body/category.rs

@@ -0,0 +1,10 @@
+use serde::{Deserialize, Serialize};
+use super::common::{number_stringify, OptionalI64};
+#[derive(Serialize, Deserialize)]
+pub struct CategoryInfo {
+    #[serde(with="number_stringify")]
+    pub id: OptionalI64,
+    pub name: String,
+    #[serde(with="number_stringify")]
+    pub parent_id: OptionalI64,
+}

src/model/http_body/common.rs

@@ -0,0 +1,88 @@
+use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter, Result as FmtResult};
+use std::num::ParseIntError;
+use std::str::FromStr;
+
+#[derive(Serialize)]
+pub struct SimpleResponse {
+    pub code: i64,
+    pub message: String,
+}
+
+#[derive(Debug)]
+pub struct OptionalI64(pub Option<i64>);
+
+impl OptionalI64 {
+    // 构造函数：从 i64 创建 Some
+    pub fn new(value: i64) -> Self {
+        OptionalI64(Some(value))
+    }
+
+    // 构造函数：直接创建 None
+    pub fn none() -> Self {
+        OptionalI64(None)
+    }
+
+    // 从 Option<i64> 转换
+    pub fn from_option(value: Option<i64>) -> Self {
+        OptionalI64(value)
+    }
+}
+
+impl From<i64> for OptionalI64 {
+    fn from(value: i64) -> Self {
+        OptionalI64(Some(value))
+    }
+}
+impl From<Option<i64>> for OptionalI64 {
+    fn from(value: Option<i64>) -> Self {
+        OptionalI64(value)
+    }
+}
+
+impl FromStr for OptionalI64 {
+    type Err = std::num::ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.is_empty() || s.eq_ignore_ascii_case("null") {
+            Ok(OptionalI64(None))
+        } else {
+            s.parse::<i64>().map(|n| OptionalI64(Some(n)))
+        }
+    }
+}
+
+impl Display for OptionalI64 {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self.0 {
+            Some(num) => write!(f, "{}", num), // 有值时输出数字
+            None => write!(f, ""),             // None 时输出空字符串
+        }
+    }
+}
+
+pub mod number_stringify {
+    use std::fmt::Display;
+    use std::str::FromStr;
+
+    use serde::{de, Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: Display,
+        S: Serializer,
+    {
+        serializer.collect_str(value)
+    }
+
+    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+    where
+        T: FromStr,
+        T::Err: Display,
+        D: Deserializer<'de>,
+    {
+        String::deserialize(deserializer)?
+            .parse()
+            .map_err(de::Error::custom)
+    }
+}

src/model/http_body/mod.rs

@@ -1 +1,3 @@
 pub mod book;
+pub mod common;
+pub mod category;

src/query/book.rs

@@ -0,0 +1,4 @@
+// use crate::model::db::prelude::Book;
+// pub fn get_book_by_id(id:i64, uid:i64)->Option<Book> {
+// 
+// }

src/query/mod.rs

@@ -0,0 +1 @@
+mod book;

src/util/mod.rs

@@ -0,0 +1 @@
+pub mod pass;

src/util/pass.rs

@@ -0,0 +1,16 @@
+use std::error::Error;
+use pbkdf2::{
+    password_hash::{
+        rand_core::OsRng,
+        PasswordHash,SaltString,
+    },
+    Pbkdf2,
+};
+use pbkdf2::password_hash::PasswordHasher;
+
+pub fn get_pbkdf2_from_psw(password:String) -> Result<String, pbkdf2::password_hash::Error> {
+    let salt = SaltString::generate(&mut OsRng);
+    let password_hash = Pbkdf2.hash_password(password.as_bytes(), &salt)?.to_string();
+    println!("{}",password_hash);
+    return Ok(password_hash)
+}