temp

.gitignore

@@ -4,3 +4,5 @@
 .DS_Store
 .env
 conf.toml
+config.toml
+.fleet\

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,22 @@ name = "helios-server-rs"
 version = "0.1.0"
 dependencies = [
  "axum",
+ "axum-extra",
  "axum-macros",
  "clap",
  "dotenvy",
+ "jsonwebtoken",
+ "once_cell",
+ "pbkdf2",
+ "rand 0.9.2",
+ "rand_core 0.9.3",
  "sea-orm",
  "serde",
+ "serde_json",
  "tokio",
  "toml",
+ "tower",
+ "tower-http",
  "tracing",
  "tracing-subscriber",
 ]
@@ -1320,9 +1393,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.3",
@@ -1361,6 +1434,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 +1581,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",
 ]
 
@@ -1529,7 +1617,7 @@ dependencies = [
  "num-integer",
  "num-iter",
  "num-traits",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "zeroize",
 ]
@@ -1659,6 +1747,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 +1975,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"
@@ -1867,8 +1994,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
+ "rand_chacha 0.3.1",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -1878,7 +2015,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -1887,7 +2034,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 +2116,7 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.16",
  "libc",
  "untrusted",
  "windows-sys 0.52.0",
@@ -2008,7 +2164,7 @@ dependencies = [
  "num-traits",
  "pkcs1",
  "pkcs8",
- "rand_core",
+ "rand_core 0.6.4",
  "signature",
  "spki",
  "subtle",
@@ -2025,7 +2181,7 @@ dependencies = [
  "borsh",
  "bytes",
  "num-traits",
- "rand",
+ "rand 0.8.5",
  "rkyv",
  "serde",
  "serde_json",
@@ -2117,9 +2273,9 @@ dependencies = [
 
 [[package]]
 name = "sea-orm"
-version = "1.1.12"
+version = "1.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18b7272b88bd608cd846de24f41b74a0315a135fe761b0aed4ec1ce6a6327a93"
+checksum = "335d87ec8e5c6eb4b2afb866dc53ed57a5cba314af63ce288db83047aa0fed4d"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -2164,9 +2320,9 @@ dependencies = [
 
 [[package]]
 name = "sea-orm-macros"
-version = "1.1.12"
+version = "1.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c38255a6b2e6d1ae2d5df35696507a345f03c036ae32caeb0a3b922dbab610d"
+checksum = "68de7a2258410fd5e6ba319a4fe6c4af7811507fc714bbd76534ae6caa60f95f"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -2272,24 +2428,47 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.226"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "0dca6411025b24b60bfa7ec1fe1f8e710ac09782dca409ee8237ba74b51295fd"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.226"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba2ba63999edb9dac981fb34b3e5c0d111a69b0924e253ed29d83f7c99e966a4"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.226"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "8db53ae22f34573731bafa1db20f04027b2d25e02d8205921b569171699cdb33"
 dependencies = [
  "proc-macro2",
  "quote",
  "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"
@@ -2314,11 +2493,11 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.8"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2386,7 +2565,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 +2574,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 +2652,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 +2732,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
  "atoi",
- "base64",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags",
  "byteorder",
@@ -2565,7 +2756,7 @@ dependencies = [
  "memchr",
  "once_cell",
  "percent-encoding",
- "rand",
+ "rand 0.8.5",
  "rsa",
  "rust_decimal",
  "serde",
@@ -2588,7 +2779,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
  "atoi",
- "base64",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags",
  "byteorder",
@@ -2609,7 +2800,7 @@ dependencies = [
  "memchr",
  "num-bigint",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "rust_decimal",
  "serde",
  "serde_json",
@@ -2865,14 +3056,17 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.22"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
+checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0"
 dependencies = [
- "serde",
+ "indexmap",
+ "serde_core",
  "serde_spanned",
- "toml_datetime",
+ "toml_datetime 0.7.2",
- "toml_edit",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
 ]
 
 [[package]]
@@ -2880,8 +3074,14 @@ name = "toml_datetime"
 version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2891,18 +3091,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
 dependencies = [
  "indexmap",
- "serde",
+ "toml_datetime 0.6.9",
- "serde_spanned",
- "toml_datetime",
- "toml_write",
  "winnow",
 ]
 
 [[package]]
-name = "toml_write"
+name = "toml_parser"
-version = "0.1.1"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
+checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109"
 
 [[package]]
 name = "tower"
@@ -2920,6 +3126,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 +3319,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"
@@ -3443,13 +3674,22 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.7.10"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 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,21 +5,30 @@ 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 = [
+sea-orm = { version = "1.1.16", features = [
     "sqlx-postgres",
     "runtime-tokio-rustls",
     "macros",
     "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"
+toml = "0.9.7"
 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"
+rand = "0.9.2"

migration/src/lib.rs

@@ -5,6 +5,7 @@ mod m20250525_000002_create_ledger_table_book;
 mod m20250525_000003_create_ledger_table_tag;
 mod m20250525_000004_create_ledger_table_account;
 mod m20250525_000005_create_ledger_table_transaction;
+mod m20250921_000001_create_ledger_table_transaction_tag_rel;
 
 pub struct Migrator;
 
@@ -17,6 +18,7 @@ impl MigratorTrait for Migrator {
             Box::new(m20250525_000003_create_ledger_table_tag::Migration),
             Box::new(m20250525_000004_create_ledger_table_account::Migration),
             Box::new(m20250525_000005_create_ledger_table_transaction::Migration),
+            Box::new(m20250921_000001_create_ledger_table_transaction_tag_rel::Migration),
         ]
     }
 }

migration/src/m20250921_000001_create_ledger_table_transaction_tag_rel.rs

@@ -0,0 +1,71 @@
+use crate::sea_query;
+use sea_orm_migration::{MigrationName, MigrationTrait, SchemaManager};
+use crate::{async_trait, ColumnDef, DbErr, Expr, Iden, Table};
+
+pub struct Migration;
+
+impl MigrationName for crate::m20250921_000001_create_ledger_table_transaction_tag_rel::Migration {
+    fn name(&self) -> &str {
+        "m20250921_000001_create_ledger_table_transaction_tag_rel" // Make sure this matches with the file name
+    }
+}
+
+#[async_trait::async_trait]
+impl MigrationTrait for crate::m20250921_000001_create_ledger_table_transaction_tag_rel::Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::Table)
+                    .col(
+                        ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::Id)
+                            .big_integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::Uid).big_integer().not_null())
+                    .col(ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::TransactionId).big_integer().not_null())
+                    .col(ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::TagId).big_integer().not_null())
+                    .col(
+                        ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::IsDeleted)
+                            .boolean()
+                            .default(false)
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::CreatedAt)
+                            .date_time()
+                            .default(Expr::current_timestamp())
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::UpdatedAt)
+                            .date_time()
+                            .default(Expr::current_timestamp())
+                            .not_null(),
+                    )
+                    .to_owned(),
+            )
+            .await
+    }
+
+    // Define how to rollback this migration: Drop the Bakery table.
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(crate::m20250921_000001_create_ledger_table_transaction_tag_rel::TransactionTagRel::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(Iden)]
+pub enum TransactionTagRel {
+    Table,
+    Id,
+    Uid,
+    TransactionId,
+    TagId,
+    IsDeleted,
+    CreatedAt,
+    UpdatedAt,
+}

src/api/account.rs

@@ -0,0 +1,62 @@
+use crate::middleware::auth::Claims;
+use crate::model::db::account::{
+    ActiveModel as AccountActiveModel, Column as AccountColumn, Model as AccountModel,
+};
+use crate::model::db::prelude::Account as AccountPrelude;
+use crate::model::http_body::account::{AccountReq, AccountResp};
+use crate::model::http_body::common::SimpleResponse;
+use crate::AppState;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+use axum::routing::{get, post};
+use axum::{Json, Router};
+use sea_orm::sqlx::types::chrono::Local;
+use sea_orm::{ActiveModelTrait, DbErr, Iden, Set};
+
+pub fn get_nest_handlers() -> Router<crate::AppState> {
+    Router::new()
+        .route("/{id}/update", post(update_account_handler))
+        .route("/{id}", get(get_account_by_id_handler))
+        .route(
+            "/",
+            post(create_account_handler).get(get_all_accounts_handler),
+        )
+}
+
+async fn update_account_handler(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+    Json(payload): Json<AccountReq>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+    let mut active_model: AccountActiveModel = AccountPrelude::find_by_id(id)
+        .filter(AccountColumn::Uid.eq(uid))
+        .filter(AccountColumn::IsDeleted.eq(false))
+        .one(&state.conn)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+    match payload.name {
+        Some(n) => {
+            active_model.name = Set(n);
+        }
+        _ => {}
+    }
+
+    active_model.updated_at = Set(Local::now().naive_utc());
+
+    active_model.update(&state.conn).await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    let resp = SimpleResponse{
+        code: 0,
+        message: "".to_string()
+    };
+    Ok(Json(resp))
+}
+
+async fn get_account_by_id_handler() {}
+
+async fn create_account_handler() {}
+
+async fn get_all_accounts_handler() {}

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, BookResp};
+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::BookResp>>, (StatusCode, String)> {
-    let uid :i64 = 1;
+    let uid: i64 = claims.uid.clone();
     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();
+    let mut books: Vec<BookResp> = Vec::new();
     for b in all_books {
-        let book_resp = BookItem{
+        let book_resp = BookResp {
-            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<BookResp>, (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: BookResp;
+    match book_query {
+        Some(b) => {
+            book_resp = BookResp {
+                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/book_test.rs

@@ -0,0 +1,198 @@
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//     use axum::{
+//         http::{Request, StatusCode},
+//         Router,
+//         routing::{get, put},
+//         body::Body,
+//     };
+//     use sea_orm::{
+//         MockDatabase, MockExecResult, DatabaseConnection, DatabaseTransaction,
+//         entity::prelude::*,
+//         QueryFilter, Condition, DbErr, EntityTrait,
+//     };
+//     use serde_json::{json, Value};
+//     use tower::ServiceExt;
+//     use std::sync::Arc;
+//
+//     // 模拟 Book 实体
+//     #[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+//     #[sea_orm(table_name = "books")]
+//     pub struct Model {
+//         #[sea_orm(primary_key)]
+//         pub id: i32,
+//         pub title: String,
+//         pub author: String,
+//     }
+//
+//     #[derive(Copy, Clone, Debug, EnumIter)]
+//     pub enum Relation {}
+//
+//     impl Related<super::book::Entity> for Entity {
+//         fn to() -> RelationDef {
+//             panic!("No relations defined")
+//         }
+//     }
+//
+//     // 创建测试用的 Router
+//     async fn setup_router(db: DatabaseConnection) -> Router {
+//         Router::new()
+//             .route("/books/:id", get(get_book_by_id).put(update_book_by_id))
+//             .route("/books", get(get_all_book))
+//             .with_state(Arc::new(db))
+//     }
+//
+//     // 测试 get_book_by_id
+//     #[tokio::test]
+//     async fn test_get_book_by_id() {
+//         // 设置模拟数据库
+//         let db = MockDatabase::new(DatabaseBackend::Postgres)
+//             .append_query_results(vec![vec![Model {
+//                 id: 1,
+//                 title: "Test Book".to_string(),
+//                 author: "Test Author".to_string(),
+//             }]])
+//             .into_connection();
+//
+//         let app = setup_router(db).await;
+//
+//         // 构造请求
+//         let request = Request::builder()
+//             .uri("/books/1")
+//             .method("GET")
+//             .body(Body::empty())
+//             .unwrap();
+//
+//         // 发送请求
+//         let response = app.oneshot(request).await.unwrap();
+//         assert_eq!(response.status(), StatusCode::OK);
+//
+//         // 解析响应
+//         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+//         let body: Value = serde_json::from_slice(&body).unwrap();
+//         assert_eq!(
+//             body,
+//             json!({
+//                 "id": 1,
+//                 "title": "Test Book",
+//                 "author": "Test Author"
+//             })
+//         );
+//     }
+//
+//     // 测试 get_book_by_id 未找到
+//     #[tokio::test]
+//     async fn test_get_book_by_id_not_found() {
+//         let db = MockDatabase::new(DatabaseBackend::Postgres)
+//             .append_query_results(vec![vec![] as Vec<Model>])
+//             .into_connection();
+//
+//         let app = setup_router(db).await;
+//
+//         let request = Request::builder()
+//             .uri("/books/999")
+//             .method("GET")
+//             .body(Body::empty())
+//             .unwrap();
+//
+//         let response = app.oneshot(request).await.unwrap();
+//         assert_eq!(response.status(), StatusCode::NOT_FOUND);
+//     }
+//
+//     // 测试 update_book_by_id
+//     #[tokio::test]
+//     async fn test_update_book_by_id() {
+//         let db = MockDatabase::new(DatabaseBackend::Postgres)
+//             .append_query_results(vec![vec![Model {
+//                 id: 1,
+//                 title: "Updated Book".to_string(),
+//                 author: "Updated Author".to_string(),
+//             }]])
+//             .append_exec_results(vec![MockExecResult {
+//                 last_insert_id: 1,
+//                 rows_affected: 1,
+//             }])
+//             .into_connection();
+//
+//         let app = setup_router(db).await;
+//
+//         // 构造请求
+//         let request = Request::builder()
+//             .uri("/books/1")
+//             .method("PUT")
+//             .header("Content-Type", "application/json")
+//             .body(Body::from(
+//                 json!({
+//                     "title": "Updated Book",
+//                     "author": "Updated Author"
+//                 })
+//                     .to_string(),
+//             ))
+//             .unwrap();
+//
+//         // 发送请求
+//         let response = app.oneshot(request).await.unwrap();
+//         assert_eq!(response.status(), StatusCode::OK);
+//
+//         // 解析响应
+//         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+//         let body: Value = serde_json::from_slice(&body).unwrap();
+//         assert_eq!(
+//             body,
+//             json!({
+//                 "id": 1,
+//                 "title": "Updated Book",
+//                 "author": "Updated Author"
+//             })
+//         );
+//     }
+//
+//     // 测试 get_all_book
+//     #[tokio::test]
+//     async fn test_get_all_book() {
+//         let db = MockDatabase::new(DatabaseBackend::Postgres)
+//             .append_query_results(vec![vec![
+//                 Model {
+//                     id: 1,
+//                     title: "Book 1".to_string(),
+//                     author: "Author 1".to_string(),
+//                 },
+//                 Model {
+//                     id: 2,
+//                     title: "Book 2".to_string(),
+//                     author: "Author 2".to_string(),
+//                 },
+//             ]])
+//             .into_connection();
+//
+//         let app = setup_router(db).await;
+//
+//         let request = Request::builder()
+//             .uri("/books")
+//             .method("GET")
+//             .body(Body::empty())
+//             .unwrap();
+//
+//         let response = app.oneshot(request).await.unwrap();
+//         assert_eq!(response.status(), StatusCode::OK);
+//
+//         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+//         let body: Value = serde_json::from_slice(&body).unwrap();
+//         assert_eq!(
+//             body,
+//             json!([
+//                 {
+//                     "id": 1,
+//                     "title": "Book 1",
+//                     "author": "Author 1"
+//                 },
+//                 {
+//                     "id": 2,
+//                     "title": "Book 2",
+//                     "author": "Author 2"
+//                 }
+//             ])
+//         );
+//     }
+// }

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,5 @@
 pub mod book;
+pub mod category;
+pub mod tag;
+pub mod transaction;
+pub mod account;

src/api/tag.rs

@@ -0,0 +1,170 @@
+use axum::routing::{get, post};
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    Json, Router,
+};
+use axum_macros::debug_handler;
+
+use crate::middleware::auth::Claims;
+use crate::model::db::tag::ActiveModel as TagActiveModel;
+use crate::model::db::tag::Column as TagColumn;
+use crate::model::db::tag::Model as TagModel;
+use crate::model::db::prelude::Tag;
+use crate::model::http_body::tag::{TagInfo, TagResp};
+use crate::model::http_body::common::SimpleResponse;
+use crate::AppState;
+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("/{id}/update",post(update_tag))
+        .route("/{id}",get(get_tag_by_id))
+        .route("/", post(create_tag).get(get_all_tags))
+}
+
+// handlers
+//
+#[debug_handler]
+async fn get_all_tags(
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<Vec<TagResp>>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+    let all_tags = Tag::find()
+        .filter(TagColumn::Uid.eq(uid))
+        .all(&state.conn)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    let mut tags: Vec<TagResp> = Vec::new();
+    for b in all_tags {
+        let tag_resp = TagResp {
+            id: b.id.into(),
+            name: b.name,
+        };
+        tags.push(tag_resp);
+    }
+    Ok(Json(tags))
+}
+
+#[debug_handler]
+async fn get_tag_by_id(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<TagResp>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+    let tag_query = Tag::find()
+        .filter(TagColumn::Uid.eq(uid))
+        .filter(TagColumn::Id.eq(id))
+        .one(&state.conn)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    let tag_resp: TagResp;
+    match tag_query {
+        Some(b) => {
+            tag_resp = TagResp {
+                id: b.id.into(),
+                name: b.name,
+            };
+        }
+        _ => {
+            return Err((StatusCode::NOT_FOUND, "not_found".to_string()));
+        }
+    }
+    Ok(Json(tag_resp))
+}
+
+#[debug_handler]
+async fn create_tag(
+    state: State<AppState>,
+    claims: Claims,
+    Json(payload): Json<TagInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+
+    let tag = TagActiveModel {
+        name: Set(payload.name.clone().to_owned()),
+        uid: Set(uid.to_owned()),
+        ..Default::default()
+    };
+
+    let res = Tag::insert(tag).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_tag(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+    Json(payload): Json<TagInfo>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+
+    let exist_tag = Tag::find()
+        .filter(TagColumn::Uid.eq(uid))
+        .filter(TagColumn::Id.eq(id))
+        .one(&state.conn)
+        .await;
+    let tag: TagModel;
+    let mut resp = SimpleResponse {
+        code: 0,
+        message: "ok".to_owned(),
+    };
+    match exist_tag {
+        Ok(b) => match b {
+            Some(bk) => {
+                tag = 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 tag_active_model: TagActiveModel = tag.into();
+    tag_active_model.name = Set(payload.name.clone());
+    tag_active_model.updated_at = Set(Local::now().naive_utc());
+    let update_res = tag_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,
+                "tag_update_fail".to_string(),
+            ));
+        }
+    }
+    Ok(Json(resp))
+}

src/api/transaction.rs

@@ -0,0 +1,217 @@
+use crate::middleware::auth::Claims;
+use crate::model::db::category::Column as CategoryColumn;
+use crate::model::db::prelude::Category as CategoryPrelude;
+use crate::model::db::prelude::Transaction;
+use crate::model::db::transaction::{
+    ActiveModel as TransactionActiveModel, Column as TransactionColumn, Model as TransactionModel,
+};
+use crate::model::http_body;
+use crate::model::http_body::book::BookInfo;
+use std::collections::HashMap;
+
+use crate::model::db::prelude::Tag as TagPrelude;
+use crate::model::db::tag::{
+    ActiveModel as TagActiveModel, Column as TagColumn, Model as TagModel,
+};
+use crate::model::http_body::category::CategoryResp;
+use crate::model::http_body::common::SimpleResponse;
+use crate::model::http_body::transaction::{TransactionReq, TransactionResp};
+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::{ColumnTrait, DatabaseConnection};
+use sea_orm::QueryFilter;
+use sea_orm::{entity::*, query::*};
+use serde_json::error::Category;
+use std::ptr::null;
+
+pub fn get_nest_handlers() -> Router<crate::AppState> {
+    Router::new()
+        .route("/{id}/update", post(update_transaction_handler))
+        .route("/{id}", get(get_transaction_by_id_handler))
+        .route(
+            "/",
+            post(create_transaction_handler).get(get_all_transactions_handler),
+        )
+}
+
+async fn update_transaction_handler(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+    Json(payload): Json<TransactionReq>,
+) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
+    let uid: i64 = claims.uid;
+    let exist_transaction = Transaction::find()
+        .filter(TransactionColumn::Id.eq(id))
+        .filter(TransactionColumn::Uid.eq(uid))
+        .one(&state.conn)
+        .await;
+    let mut resp = SimpleResponse {
+        code: 0,
+        message: "".to_string(),
+    };
+    let transaction: TransactionModel;
+    match exist_transaction {
+        Err(_) => {
+            resp.code = 1;
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "connection_error".to_string(),
+            ));
+        }
+        Ok(tra) => match tra {
+            Some(tr) => {
+                transaction = tr;
+            }
+            _ => return Err((StatusCode::NOT_FOUND, "Transaction not found".to_string())),
+        },
+    }
+    let mut tr_active: TransactionActiveModel = transaction.into();
+    match payload.description {
+        None => {}
+        Some(input_desc) => {
+            tr_active.description = Set(input_desc);
+        }
+    }
+    // TODO category
+    let new_category_id: i64 = match payload.category_id {
+        None => {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                "category_id is not valid".to_string(),
+            ))
+        }
+        Some(cid_string) => match cid_string.parse::<i64>() {
+            Ok(cid) => cid,
+            Err(_) => {
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    "category_id is not valid".to_string(),
+                ))
+            }
+        },
+    };
+    let new_category_id_exist = CategoryPrelude::find()
+        .filter(CategoryColumn::Id.eq(new_category_id))
+        .filter(CategoryColumn::Uid.eq(uid))
+        .all(&state.conn)
+        .await;
+    match new_category_id_exist {
+        Ok(_) => {}
+        Err(_) => {
+            return Err((StatusCode::NOT_FOUND, "category_id not found".to_string()));
+        }
+    }
+
+    // TODO tags
+    let tag_exist = check_tags_exist(&state.conn, payload.tags).await;
+    let all_tag_exist: bool;
+    match tag_exist {
+        Ok(tag_res) => {
+            all_tag_exist = tag_res.values().all(|&exists| exists);
+        }
+        Err(_) => {
+            return Err((StatusCode::NOT_FOUND, "tag not found".to_string()));
+        }
+    }
+    if !all_tag_exist {
+        return Err((StatusCode::NOT_FOUND, "tag not found".to_string()));
+    }
+
+    // TODO amounts
+
+    // Update
+    tr_active.updated_at = Set(Local::now().naive_utc());
+    let update_res = tr_active.update(&state.conn).await;
+    match update_res {
+        Ok(_) => {
+            resp.code = 0;
+        }
+        Err(_) => {
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "transaction_update_failed".to_string(),
+            ));
+        }
+    }
+
+    Ok(Json(resp))
+}
+
+async fn create_transaction_handler() {}
+
+async fn get_transaction_by_id_handler(
+    Path(id): Path<i64>,
+    state: State<AppState>,
+    claims: Claims,
+) -> Result<Json<TransactionResp>, (StatusCode, String)> {
+    let uid: i64 = claims.uid.clone();
+    let transaction_query = Transaction::find()
+        .filter(TransactionColumn::Uid.eq(id))
+        .filter(TransactionColumn::Id.eq(id))
+        .one(&state.conn)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    let response: TransactionResp;
+    match transaction_query {
+        None => {
+            return Err((StatusCode::NOT_FOUND, "Transaction not found".to_string()));
+        }
+        Some(x) => {
+            response = TransactionResp {
+                id: x.id,
+                description: x.description,
+                category: CategoryResp {
+                    id: 0,
+                    name: "".to_string(),
+                    parent_id: 0,
+                },
+                tags: vec![],
+            }
+        }
+    };
+
+    Ok(Json(response))
+}
+
+async fn get_all_transactions_handler() {}
+
+// 批量检查 TagModel 是否存在
+async fn check_tags_exist(
+    connection: &DatabaseConnection,
+    ids: Vec<String>,
+) -> Result<HashMap<i64, bool>, String> {
+    // 将 Vec<String> 转换为 Vec<i64>，并处理可能的转换错误
+    let ids_i64: Vec<i64> = ids
+        .into_iter()
+        .filter_map(|id| id.parse::<i64>().ok())
+        .collect();
+
+    if ids_i64.is_empty() {
+        return Ok(HashMap::new());
+    }
+
+    // 构建 IN 查询条件
+    let condition = Condition::any().add(TagColumn::Id.is_in(ids_i64.clone()));
+
+    // 执行批量查询，获取存在的 TagModel
+    let found_tags = TagPrelude::find()
+        .filter(condition)
+        .all(connection)
+        .await
+        .map_err(|e| format!("Database error: {}", e))?;
+
+    // 创建 HashMap 记录每个 ID 是否存在
+    let mut result = HashMap::new();
+    for id in ids_i64 {
+        result.insert(id, found_tags.iter().any(|tag| tag.id == id));
+    }
+
+    Ok(result)
+}

src/dal/mod.rs

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

src/dao/mod.rs

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

src/dao/transaction_tag_rel.rs

@@ -0,0 +1,130 @@
+use sea_orm::{DatabaseConnection, EntityTrait, ActiveModelTrait, Set, QueryFilter, ColumnTrait, DbErr};
+use sea_orm::sqlx::types::chrono::{Local};
+use crate::model::db::prelude::TransactionTagRel as TransactionTagRelPrelude;
+use crate::model::db::transaction_tag_rel::{
+    ActiveModel as TransactionTagRelActiveModel,
+    Model as TransactionTagRelModel,
+    Column as TransactionTagRelColumn,
+};
+
+// DAO struct for TransactionTagRel
+pub struct TransactionTagRelDAO {
+    db: DatabaseConnection,
+} 
+
+impl TransactionTagRelDAO {
+    // Constructor
+    pub fn new(db: DatabaseConnection) -> Self {
+        Self { db }
+    }
+
+    // Create a new TransactionTagRel
+    pub async fn create(
+        &self,
+        uid: i64,
+        transaction_id: i64,
+        tag_id: i64,
+    ) -> Result<TransactionTagRelModel, DbErr> {
+        let active_model = TransactionTagRelActiveModel {
+            uid: Set(uid),
+            transaction_id: Set(transaction_id),
+            tag_id: Set(tag_id),
+            is_deleted: Set(false),
+            // created_at: Set(Utc::now()),
+            // updated_at: Set(Utc::now()),
+            ..Default::default() // id is auto-incremented
+        };
+
+        active_model.insert(&self.db).await
+    }
+
+    // Find by ID
+    pub async fn find_by_id(&self, id: i64, uid:i64) -> Result<Option<TransactionTagRelModel>, DbErr> {
+        TransactionTagRelPrelude::find_by_id(id)
+            .filter(TransactionTagRelColumn::Uid.eq(uid))
+            .filter(TransactionTagRelColumn::IsDeleted.eq(false))
+            .one(&self.db)
+            .await
+    }
+
+    // Find all by transaction_id
+    pub async fn find_by_transaction_id(
+        &self,
+        transaction_id: i64,
+        uid: i64,
+    ) -> Result<Vec<TransactionTagRelModel>, DbErr> {
+        TransactionTagRelPrelude::find()
+            .filter(TransactionTagRelColumn::Uid.eq(uid))
+            .filter(TransactionTagRelColumn::TransactionId.eq(transaction_id))
+            .filter(TransactionTagRelColumn::IsDeleted.eq(false))
+            .all(&self.db)
+            .await
+    }
+
+    // Find all by tag_id
+    pub async fn find_by_tag_id(
+        &self,
+        tag_id: i64,
+        uid: i64,
+    ) -> Result<Vec<TransactionTagRelModel>, DbErr> {
+        TransactionTagRelPrelude::find()
+            .filter(TransactionTagRelColumn::Uid.eq(uid))
+            .filter(TransactionTagRelColumn::TagId.eq(tag_id))
+            .filter(TransactionTagRelColumn::IsDeleted.eq(false))
+            .all(&self.db)
+            .await
+    }
+
+    // Update a TransactionTagRel
+    pub async fn update(
+        &self,
+        id: i64,
+        uid: Option<i64>,
+        transaction_id: Option<i64>,
+        tag_id: Option<i64>,
+    ) -> Result<TransactionTagRelModel, DbErr> {
+        let mut active_model: TransactionTagRelActiveModel = TransactionTagRelPrelude::find_by_id(id)
+            .filter(TransactionTagRelColumn::Uid.eq(uid))
+            .filter(TransactionTagRelColumn::IsDeleted.eq(false))
+            .one(&self.db)
+            .await?
+            .ok_or(DbErr::RecordNotFound("TransactionTagRel not found".into()))?
+            .into();
+
+        if let Some(uid) = uid {
+            active_model.uid = Set(uid);
+        }
+        if let Some(transaction_id) = transaction_id {
+            active_model.transaction_id = Set(transaction_id);
+        }
+        if let Some(tag_id) = tag_id {
+            active_model.tag_id = Set(tag_id);
+        }
+        active_model.updated_at = Set(Local::now().naive_utc());
+
+        active_model.update(&self.db).await
+    }
+
+    // Soft delete (set is_deleted = true)
+    pub async fn soft_delete(&self, id: i64, uid: i64) -> Result<(), DbErr> {
+        let mut active_model: TransactionTagRelActiveModel = TransactionTagRelPrelude::find_by_id(id)
+            .filter(TransactionTagRelColumn::Uid.eq(uid))
+            .filter(TransactionTagRelColumn::IsDeleted.eq(false))
+            .one(&self.db)
+            .await?
+            .ok_or(DbErr::RecordNotFound("TransactionTagRel not found".into()))?
+            .into();
+
+        active_model.is_deleted = Set(true);
+        active_model.updated_at = Set(Local::now().naive_utc());
+        active_model.update(&self.db).await?;
+        Ok(())
+    }
+
+    // Hard delete (optional, use with caution)
+    pub async fn hard_delete(&self, id: i64, uid: i64) -> Result<(), DbErr> {
+        TransactionTagRelPrelude::delete_by_id(id)
+            .exec(&self.db).await?;
+        Ok(())
+    }
+}

src/main.rs

@@ -1,17 +1,30 @@
-use axum::Router;
+use crate::middleware::auth;
+use axum::{http::Method, Router};
 use clap::Parser;
-use sea_orm::{Database, DatabaseConnection};
+use sea_orm::{Database, DatabaseConnection, Iden};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+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;
+mod dao;
+mod dal;
 
 #[tokio::main]
 async fn main() {
-    dotenvy::dotenv().unwrap();
+    // 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 } => {
@@ -24,6 +37,9 @@ async fn main() {
                 eprintln!("Failed to load config from {}", config_path);
             }
         }
+        Command::PrintExampleConfig {}=>{
+            print_default_config().await;
+        }
     }
 }
 
@@ -32,23 +48,23 @@ struct AppState {
     conn: DatabaseConnection,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize,Serialize)]
 struct Key {
     jwt: String,
     user: String,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize,Serialize)]
 struct DatabaseConf {
     connection: String,
 }
-#[derive(Deserialize)]
+#[derive(Deserialize,Serialize)]
 struct ServiceConf {
     host: String,
     port: u32,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize,Serialize)]
 struct Config {
     service: ServiceConf,
     database: DatabaseConf,
@@ -67,6 +83,7 @@ enum Command {
         #[arg(long = "conf")]
         config_path: String,
     },
+    PrintExampleConfig {},
 }
 async fn load_config(path: &str) -> Result<Config, Box<dyn std::error::Error>> {
     let content = tokio::fs::read_to_string(path).await?;
@@ -76,24 +93,54 @@ 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
         .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())
+        .nest("/api/v1/tag", api::tag::get_nest_handlers())
+        .nest("/api/v1/transaction", api::transaction::get_nest_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");
+}
+
+async fn print_default_config() {
+    let example_conf = Config{
+        service: ServiceConf {
+            host: "localhost".to_string(),
+            port: 8080,
+        },
+        database: DatabaseConf {
+            connection: "postgres://postgres:postgres@localhost/test_db".to_string(),
+        },
+        keys: Key {
+            jwt: "THIS_IS_TEST_CONFIG".to_string(),
+            user: "test_user".to_string(),
+        },
+    };
+    // 序列化为 TOML 字符串
+    let toml_string = toml::to_string(&example_conf);
+    println!("#This is an example config.\n{}", toml_string.unwrap());
 }

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/db/account.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -9,7 +9,7 @@ pub struct Model {
     #[sea_orm(primary_key)]
     pub id: i64,
     pub name: String,
-    pub r#type: i32,
+    pub account_type: i32,
     pub uid: i64,
     pub is_deleted: bool,
     pub created_at: DateTime,

src/model/db/book.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};

src/model/db/category.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};

src/model/db/mod.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 pub mod prelude;
 
@@ -7,3 +7,4 @@ pub mod book;
 pub mod category;
 pub mod tag;
 pub mod transaction;
+pub mod transaction_tag_rel;

src/model/db/prelude.rs

@@ -1,7 +1,8 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 pub use super::account::Entity as Account;
 pub use super::book::Entity as Book;
 pub use super::category::Entity as Category;
 pub use super::tag::Entity as Tag;
 pub use super::transaction::Entity as Transaction;
+pub use super::transaction_tag_rel::Entity as TransactionTagRel;

src/model/db/tag.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};

src/model/db/transaction.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.11
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
 
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -9,7 +9,7 @@ pub struct Model {
     #[sea_orm(primary_key)]
     pub id: i64,
     pub uid: i64,
-    pub r#type: i32,
+    pub transaction_type: i32,
     pub book_id: i64,
     pub category_id: i64,
     pub description: String,

src/model/db/transaction_tag_rel.rs

@@ -0,0 +1,22 @@
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.16
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "transaction_tag_rel")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i64,
+    pub uid: i64,
+    pub transaction_id: i64,
+    pub tag_id: i64,
+    pub is_deleted: bool,
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}

src/model/http_body/account.rs

@@ -0,0 +1,14 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize)]
+pub struct AccountResp {
+    pub id: String,
+    pub name: String,
+    pub account_type: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AccountReq {
+    pub name: Option<String>,
+    pub account_type: Option<String>,
+}

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 struct BookResp {
-    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,17 @@
+use serde::{Deserialize, Serialize};
+use super::common::{number_stringify, OptionalI64};
+#[derive(Serialize, Deserialize)]
+pub struct CategoryResp {
+    pub id: i64,
+    pub name: String,
+    pub parent_id: i64,
+}
+
+#[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,6 @@
 pub mod book;
+pub mod common;
+pub mod category;
+pub mod tag;
+pub mod transaction;
+pub mod account;

src/model/http_body/tag.rs

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

src/model/http_body/transaction.rs

@@ -0,0 +1,25 @@
+ use serde::{Serialize, Deserialize};
+ use crate::model::http_body::tag::TagInfo;
+ use crate::model::http_body::category::CategoryResp;
+ use crate::model::http_body::common::OptionalI64;
+
+ #[derive(Serialize,Deserialize)]
+ pub struct TransactionResp {
+     pub id: i64,
+     pub description: String,
+     pub category: CategoryResp,
+     pub tags: Vec<TagInfo>,
+ }
+
+ #[derive(Serialize,Deserialize)]
+ pub struct TransactionReq {
+     pub id: Option<String>,
+     pub description: Option<String>,
+     pub category_id: Option<String>,
+     pub tags: Vec<String>,
+ }
+ 
+ pub struct TransactionAmountReq {
+     pub id: Option<String>,
+     pub account_id: Option<String>,
+ }

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)
+}