重构项目结构：统一目录层级

- 移除 backend/.git 工作树配置
- 将原根目录文件归入 backend/ 目录
- 新增 app/、frontend/ 等模块
- 保留文件历史（自动识别重命名）

backend/services/user-service/Dockerfile

@@ -0,0 +1,49 @@
+# 构建阶段
+FROM rust:1.94.1-alpine3.23 AS builder
+
+# 安装构建依赖
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static
+
+# 创建工作目录
+WORKDIR /app
+
+# 先复制共享代码和 Cargo 文件以利用缓存
+COPY shared /app/shared
+COPY services/user-service/Cargo.toml services/user-service/Cargo.lock* ./
+
+# 创建虚拟 main.rs 来缓存依赖
+RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
+RUN cargo build --release && rm -rf src
+
+# 复制真实源代码
+COPY services/user-service/src ./src
+
+# 构建（使用 touch 确保重新编译）
+RUN touch src/main.rs && cargo build --release
+
+# 运行阶段
+FROM alpine:3.23 AS runtime
+
+# 安装运行依赖
+RUN apk add --no-cache ca-certificates tzdata
+
+# 创建非 root 用户
+RUN addgroup -g 1000 appuser && adduser -D -u 1000 -G appuser appuser
+
+WORKDIR /app
+
+# 从构建阶段复制二进制文件
+COPY --from=builder /app/target/release/user-service /app/user-service
+
+# 设置权限
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
+
+EXPOSE 8080
+
+CMD ["./user-service"]

backend/services/user-service/docker-compose.yml

@@ -0,0 +1,159 @@
+version: "3.8"
+
+services:
+  user-login-account:
+    build:
+      context: ../..
+      dockerfile: services/user-service/user-login-account/Dockerfile
+    container_name: user-login-account
+    environment:
+      - RUST_LOG=info
+      - DATABASE_URL=postgres://postgres:postgres@user-db:5432/user-db
+      - REDIS_URL=redis://user-redis:6379/0
+      - SERVICE_NAME=user-login-account
+      - SERVICE_PORT=8080
+      - JWT_SECRET=${JWT_SECRET:-dev-secret-key}
+    ports:
+      - "8001:8080"
+    depends_on:
+      user-db:
+        condition: service_healthy
+      user-redis:
+        condition: service_healthy
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  user-register-account:
+    build:
+      context: ../..
+      dockerfile: services/user-service/user-register-account/Dockerfile
+    container_name: user-register-account
+    environment:
+      - RUST_LOG=info
+      - DATABASE_URL=postgres://postgres:postgres@user-db:5432/user-db
+      - REDIS_URL=redis://user-redis:6379/0
+      - SERVICE_NAME=user-register-account
+      - SERVICE_PORT=8080
+    ports:
+      - "8002:8080"
+    depends_on:
+      user-db:
+        condition: service_healthy
+      user-redis:
+        condition: service_healthy
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  user-login-email:
+    build:
+      context: ../..
+      dockerfile: services/user-service/user-login-email/Dockerfile
+    container_name: user-login-email
+    environment:
+      - RUST_LOG=info
+      - DATABASE_URL=postgres://postgres:postgres@user-db:5432/user-db
+      - REDIS_URL=redis://user-redis:6379/0
+      - SERVICE_NAME=user-login-email
+      - SERVICE_PORT=8080
+      - JWT_SECRET=${JWT_SECRET:-dev-secret-key}
+    ports:
+      - "8003:8080"
+    depends_on:
+      user-db:
+        condition: service_healthy
+      user-redis:
+        condition: service_healthy
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  user-register-email:
+    build:
+      context: ../..
+      dockerfile: services/user-service/user-register-email/Dockerfile
+    container_name: user-register-email
+    environment:
+      - RUST_LOG=info
+      - DATABASE_URL=postgres://postgres:postgres@user-db:5432/user-db
+      - REDIS_URL=redis://user-redis:6379/0
+      - SERVICE_NAME=user-register-email
+      - SERVICE_PORT=8080
+    ports:
+      - "8004:8080"
+    depends_on:
+      user-db:
+        condition: service_healthy
+      user-redis:
+        condition: service_healthy
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  user-db:
+    image: postgres:18.3-alpine3.23
+    container_name: user-db
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=user-db
+    volumes:
+      - user-postgres-data:/var/lib/postgresql/data
+      - ./migrations:/docker-entrypoint-initdb.d:ro
+    ports:
+      - "5432:5432"
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d user-db"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  user-redis:
+    image: redis:8.6.2-alpine
+    container_name: user-redis
+    volumes:
+      - user-redis-data:/data
+    ports:
+      - "6379:6379"
+    networks:
+      - user-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+networks:
+  user-network:
+    driver: bridge
+
+volumes:
+  user-postgres-data:
+    name: user-postgres-data
+  user-redis-data:
+    name: user-redis-data

backend/services/user-service/migrations/001_init.sql

@@ -0,0 +1,51 @@
+-- 用户主表
+CREATE TABLE IF NOT EXISTS user_main (
+    id UUID PRIMARY KEY,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    create_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    modify_date TIMESTAMP WITH TIME ZONE NOT NULL
+);
+
+-- 用户登录账号表
+CREATE TABLE IF NOT EXISTS user_login_account (
+    id UUID PRIMARY KEY,
+    user_id UUID NOT NULL,
+    account VARCHAR(100) NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    create_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    modify_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT fk_user_login_account_user_main FOREIGN KEY (user_id) REFERENCES user_main(id)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_user_login_account_active 
+    ON user_login_account(account) 
+    WHERE deleted = FALSE;
+
+-- 用户密码表
+CREATE TABLE IF NOT EXISTS user_login_password (
+    id UUID PRIMARY KEY,
+    user_id UUID NOT NULL,
+    password VARCHAR(255) NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    create_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    modify_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT fk_user_login_password_user_main FOREIGN KEY (user_id) REFERENCES user_main(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_login_password_user_id 
+    ON user_login_password(user_id);
+
+-- 用户登录邮箱表
+CREATE TABLE IF NOT EXISTS user_login_email (
+    id UUID PRIMARY KEY,
+    user_id UUID NOT NULL,
+    email VARCHAR(255) NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    create_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    modify_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT fk_user_login_email_user_main FOREIGN KEY (user_id) REFERENCES user_main(id)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_user_login_email_active 
+    ON user_login_email(email) 
+    WHERE deleted = FALSE;

backend/services/user-service/user-login-account/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "user-login-account"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+# Web 框架
+axum = "0.8"
+tokio = { version = "1", features = ["full"] }
+tower = "0.5"
+
+# 序列化
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# 数据库
+sqlx = { version = "0.8", features = ["runtime-tokio", "tls-rustls", "postgres", "chrono", "uuid"] }
+
+# UUID
+uuid = { version = "1", features = ["v7", "serde"] }
+
+# Redis
+redis = { version = "0.29", features = ["tokio-comp"] }
+
+# 密码哈希（bcrypt）
+bcrypt = "0.17"
+
+# JWT
+jsonwebtoken = "9.3"
+
+# 时间和日志
+chrono = { version = "0.4", features = ["serde"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# 环境变量
+dotenvy = "0.15"
+
+# 错误处理
+thiserror = "2.0"
+
+[profile.release]
+opt-level = 3
+lto = true
+strip = true

backend/services/user-service/user-login-account/Dockerfile

@@ -0,0 +1,39 @@
+# 构建阶段
+FROM rust:1.94.1-alpine3.23 AS builder
+
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static pkgconfig
+
+WORKDIR /app
+
+# 复制 user-login-account 代码
+COPY services/user-service/user-login-account/Cargo.toml services/user-service/user-login-account/Cargo.lock* ./
+
+# 缓存依赖
+RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
+RUN cargo build --release 2>/dev/null || true
+RUN rm -rf src
+
+# 复制真实源码
+COPY services/user-service/user-login-account/src ./src
+
+# 重新构建
+RUN touch src/main.rs && cargo build --release
+
+# 运行阶段
+FROM alpine:3.23 AS runtime
+
+RUN apk add --no-cache ca-certificates
+
+RUN addgroup -g 1000 appuser && adduser -D -u 1000 -G appuser appuser
+
+WORKDIR /app
+
+COPY --from=builder /app/target/release/user-login-account /app/user-login-account
+
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8080
+
+CMD ["./user-login-account"]

backend/services/user-service/user-login-account/src/main.rs

@@ -0,0 +1,196 @@
+use axum::{
+    extract::State,
+    http::StatusCode,
+    response::Json,
+    routing::post,
+    Router,
+};
+use bcrypt::verify;
+use chrono::{Duration, Utc};
+use jsonwebtoken::{encode, EncodingKey, Header};
+use serde::{Deserialize, Serialize};
+use sqlx::{Pool, Postgres};
+use std::env;
+use std::sync::Arc;
+use tracing::{info, warn};
+
+// 应用状态
+#[derive(Clone)]
+struct AppState {
+    db: Pool<Postgres>,
+    jwt_secret: String,
+}
+
+// 登录请求
+#[derive(Deserialize)]
+struct LoginRequest {
+    username: String,
+    password: String,
+}
+
+// 统一响应包装
+#[derive(Serialize)]
+struct ApiResponse<T> {
+    success: bool,
+    message: String,
+    data: Option<T>,
+}
+
+// 登录业务数据
+#[derive(Serialize)]
+struct LoginData {
+    token: String,
+}
+
+// JWT Claims
+#[derive(Serialize, Deserialize)]
+struct Claims {
+    sub: String,
+    exp: usize,
+    iat: usize,
+}
+
+#[tokio::main]
+async fn main() {
+    // 初始化日志
+    tracing_subscriber::fmt::init();
+    
+    info!("Starting user-login-account service...");
+    
+    // 数据库连接
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let pool = sqlx::postgres::PgPool::connect(&database_url)
+        .await
+        .expect("Failed to connect to database");
+    
+    sqlx::query("SET TIME ZONE 'Asia/Shanghai'")
+        .execute(&pool)
+        .await
+        .expect("Failed to set timezone");
+    
+    info!("Database connected");
+    
+    // JWT 密钥
+    let jwt_secret = env::var("JWT_SECRET").unwrap_or_else(|_| "dev-secret".to_string());
+    
+    let state = Arc::new(AppState {
+        db: pool,
+        jwt_secret,
+    });
+    
+    // 路由
+    let app = Router::new()
+        .route("/login", post(login_handler))
+        .route("/health", axum::routing::get(health_handler))
+        .with_state(state);
+    
+    let port = env::var("SERVICE_PORT").unwrap_or_else(|_| "8080".to_string());
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
+        .await
+        .unwrap();
+    
+    info!("User-login service listening on port {}", port);
+    
+    axum::serve(listener, app).await.unwrap();
+}
+
+// 登录处理
+async fn login_handler(
+    State(state): State<Arc<AppState>>,
+    Json(payload): Json<LoginRequest>,
+) -> (StatusCode, Json<ApiResponse<LoginData>>) {
+    info!("Login attempt for user: {}", payload.username);
+    
+    // 查询用户账号与密码
+    let user: Option<(uuid::Uuid, String)> = sqlx::query_as(
+        "SELECT a.user_id, p.password \
+         FROM user_login_account a \
+         JOIN user_login_password p ON a.user_id = p.user_id \
+         WHERE a.account = $1 AND a.deleted = FALSE AND p.deleted = FALSE"
+    )
+    .bind(&payload.username)
+    .fetch_optional(&state.db)
+    .await
+    .unwrap_or(None);
+    
+    match user {
+        Some((user_id, password_hash)) => {
+            // 验证密码
+            tracing::debug!("Verifying password: input_len={}, hash_len={}", payload.password.len(), password_hash.len());
+            match verify(&payload.password, &password_hash) {
+                Ok(true) => {
+                    info!("User {} logged in successfully", payload.username);
+                    
+                    // 生成 JWT
+                    let token = generate_token(&user_id.to_string(), &state.jwt_secret);
+                    
+                    (
+                        StatusCode::OK,
+                        Json(ApiResponse {
+                            success: true,
+                            message: "Login successful".to_string(),
+                            data: Some(LoginData { token }),
+                        }),
+                    )
+                }
+                Ok(false) => {
+                    warn!("Invalid password for user {}", payload.username);
+                    (
+                        StatusCode::UNAUTHORIZED,
+                        Json(ApiResponse {
+                            success: false,
+                            message: "Invalid credentials".to_string(),
+                            data: None,
+                        }),
+                    )
+                }
+                Err(e) => {
+                    warn!("Password verification error: {:?}", e);
+                    (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Json(ApiResponse {
+                            success: false,
+                            message: "Internal error".to_string(),
+                            data: None,
+                        }),
+                    )
+                }
+            }
+        }
+        None => {
+            warn!("User not found: {}", payload.username);
+            (
+                StatusCode::UNAUTHORIZED,
+                Json(LoginResponse {
+                    success: false,
+                    token: None,
+                    message: "Invalid credentials".to_string(),
+                }),
+            )
+        }
+    }
+}
+
+// 健康检查
+async fn health_handler() -> &'static str {
+    "OK"
+}
+
+// 生成 JWT Token
+fn generate_token(sub: &str, secret: &str) -> String {
+    let now = Utc::now();
+    let exp = now + Duration::days(7);
+    
+    let claims = Claims {
+        sub: sub.to_string(),
+        iat: now.timestamp() as usize,
+        exp: exp.timestamp() as usize,
+    };
+    
+    encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(secret.as_bytes()),
+    )
+    .unwrap()
+}

backend/services/user-service/user-login-email/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "user-login-email"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+# Web 框架
+axum = "0.8"
+tokio = { version = "1", features = ["full"] }
+tower = "0.5"
+
+# 序列化
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# 数据库
+sqlx = { version = "0.8", features = ["runtime-tokio", "tls-rustls", "postgres", "chrono", "uuid"] }
+
+# UUID
+uuid = { version = "1", features = ["v7", "serde"] }
+
+# Redis
+redis = { version = "0.29", features = ["tokio-comp"] }
+
+# 密码哈希（bcrypt）
+bcrypt = "0.17"
+
+# JWT
+jsonwebtoken = "9.3"
+
+# 时间和日志
+chrono = { version = "0.4", features = ["serde"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# 环境变量
+dotenvy = "0.15"
+
+# 错误处理
+thiserror = "2.0"
+
+[profile.release]
+opt-level = 3
+lto = true
+strip = true

backend/services/user-service/user-login-email/Dockerfile

@@ -0,0 +1,39 @@
+# 构建阶段
+FROM rust:1.94.1-alpine3.23 AS builder
+
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static pkgconfig
+
+WORKDIR /app
+
+# 复制 user-login-email 代码
+COPY services/user-service/user-login-email/Cargo.toml services/user-service/user-login-email/Cargo.lock* ./
+
+# 缓存依赖
+RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
+RUN cargo build --release 2>/dev/null || true
+RUN rm -rf src
+
+# 复制真实源码
+COPY services/user-service/user-login-email/src ./src
+
+# 重新构建
+RUN touch src/main.rs && cargo build --release
+
+# 运行阶段
+FROM alpine:3.23 AS runtime
+
+RUN apk add --no-cache ca-certificates
+
+RUN addgroup -g 1000 appuser && adduser -D -u 1000 -G appuser appuser
+
+WORKDIR /app
+
+COPY --from=builder /app/target/release/user-login-email /app/user-login-email
+
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8080
+
+CMD ["./user-login-email"]

backend/services/user-service/user-login-email/src/main.rs

@@ -0,0 +1,196 @@
+use axum::{
+    extract::State,
+    http::StatusCode,
+    response::Json,
+    routing::post,
+    Router,
+};
+use bcrypt::verify;
+use chrono::{Duration, Utc};
+use jsonwebtoken::{encode, EncodingKey, Header};
+use serde::{Deserialize, Serialize};
+use sqlx::{Pool, Postgres};
+use std::env;
+use std::sync::Arc;
+use tracing::{info, warn};
+
+// 应用状态
+#[derive(Clone)]
+struct AppState {
+    db: Pool<Postgres>,
+    jwt_secret: String,
+}
+
+// 登录请求
+#[derive(Deserialize)]
+struct LoginRequest {
+    email: String,
+    password: String,
+}
+
+// 统一响应包装
+#[derive(Serialize)]
+struct ApiResponse<T> {
+    success: bool,
+    message: String,
+    data: Option<T>,
+}
+
+// 登录业务数据
+#[derive(Serialize)]
+struct LoginData {
+    token: String,
+}
+
+// JWT Claims
+#[derive(Serialize, Deserialize)]
+struct Claims {
+    sub: String,
+    exp: usize,
+    iat: usize,
+}
+
+#[tokio::main]
+async fn main() {
+    // 初始化日志
+    tracing_subscriber::fmt::init();
+    
+    info!("Starting user-login-email service...");
+    
+    // 数据库连接
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let pool = sqlx::postgres::PgPool::connect(&database_url)
+        .await
+        .expect("Failed to connect to database");
+    
+    sqlx::query("SET TIME ZONE 'Asia/Shanghai'")
+        .execute(&pool)
+        .await
+        .expect("Failed to set timezone");
+    
+    info!("Database connected");
+    
+    // JWT 密钥
+    let jwt_secret = env::var("JWT_SECRET").unwrap_or_else(|_| "dev-secret".to_string());
+    
+    let state = Arc::new(AppState {
+        db: pool,
+        jwt_secret,
+    });
+    
+    // 路由
+    let app = Router::new()
+        .route("/login", post(login_handler))
+        .route("/health", axum::routing::get(health_handler))
+        .with_state(state);
+    
+    let port = env::var("SERVICE_PORT").unwrap_or_else(|_| "8080".to_string());
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
+        .await
+        .unwrap();
+    
+    info!("User-login-email service listening on port {}", port);
+    
+    axum::serve(listener, app).await.unwrap();
+}
+
+// 登录处理
+async fn login_handler(
+    State(state): State<Arc<AppState>>,
+    Json(payload): Json<LoginRequest>,
+) -> (StatusCode, Json<ApiResponse<LoginData>>) {
+    info!("Login attempt for email: {}", payload.email);
+    
+    // 查询用户邮箱与密码
+    let user: Option<(uuid::Uuid, String)> = sqlx::query_as(
+        "SELECT e.user_id, p.password \
+         FROM user_login_email e \
+         JOIN user_login_password p ON e.user_id = p.user_id \
+         WHERE e.email = $1 AND e.deleted = FALSE AND p.deleted = FALSE"
+    )
+    .bind(&payload.email)
+    .fetch_optional(&state.db)
+    .await
+    .unwrap_or(None);
+    
+    match user {
+        Some((user_id, password_hash)) => {
+            // 验证密码
+            tracing::debug!("Verifying password: input_len={}, hash_len={}", payload.password.len(), password_hash.len());
+            match verify(&payload.password, &password_hash) {
+                Ok(true) => {
+                    info!("Email {} logged in successfully", payload.email);
+                    
+                    // 生成 JWT
+                    let token = generate_token(&user_id.to_string(), &state.jwt_secret);
+                    
+                    (
+                        StatusCode::OK,
+                        Json(ApiResponse {
+                            success: true,
+                            message: "Login successful".to_string(),
+                            data: Some(LoginData { token }),
+                        }),
+                    )
+                }
+                Ok(false) => {
+                    warn!("Invalid password for email {}", payload.email);
+                    (
+                        StatusCode::UNAUTHORIZED,
+                        Json(ApiResponse {
+                            success: false,
+                            message: "Invalid credentials".to_string(),
+                            data: None,
+                        }),
+                    )
+                }
+                Err(e) => {
+                    warn!("Password verification error: {:?}", e);
+                    (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Json(ApiResponse {
+                            success: false,
+                            message: "Internal error".to_string(),
+                            data: None,
+                        }),
+                    )
+                }
+            }
+        }
+        None => {
+            warn!("Email not found: {}", payload.email);
+            (
+                StatusCode::UNAUTHORIZED,
+                Json(LoginResponse {
+                    success: false,
+                    token: None,
+                    message: "Invalid credentials".to_string(),
+                }),
+            )
+        }
+    }
+}
+
+// 健康检查
+async fn health_handler() -> &'static str {
+    "OK"
+}
+
+// 生成 JWT Token
+fn generate_token(sub: &str, secret: &str) -> String {
+    let now = Utc::now();
+    let exp = now + Duration::days(7);
+    
+    let claims = Claims {
+        sub: sub.to_string(),
+        iat: now.timestamp() as usize,
+        exp: exp.timestamp() as usize,
+    };
+    
+    encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(secret.as_bytes()),
+    )
+    .unwrap()
+}

backend/services/user-service/user-register-account/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "user-register-account"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+axum = "0.8"
+tokio = { version = "1", features = ["full"] }
+tower = "0.5"
+
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+sqlx = { version = "0.8", features = ["runtime-tokio", "tls-rustls", "postgres", "chrono", "uuid"] }
+
+# UUID
+uuid = { version = "1", features = ["v7", "serde"] }
+redis = { version = "0.29", features = ["tokio-comp"] }
+
+bcrypt = "0.17"
+
+chrono = { version = "0.4", features = ["serde"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+dotenvy = "0.15"
+thiserror = "2.0"
+validator = { version = "0.20", features = ["derive"] }
+
+[profile.release]
+opt-level = 3
+lto = true
+strip = true

backend/services/user-service/user-register-account/Dockerfile

@@ -0,0 +1,33 @@
+FROM rust:1.94.1-alpine3.23 AS builder
+
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static pkgconfig
+
+WORKDIR /app
+
+COPY services/user-service/user-register-account/Cargo.toml services/user-service/user-register-account/Cargo.lock* ./
+
+RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
+RUN cargo build --release 2>/dev/null || true
+RUN rm -rf src
+
+COPY services/user-service/user-register-account/src ./src
+
+RUN touch src/main.rs && cargo build --release
+
+FROM alpine:3.23 AS runtime
+
+RUN apk add --no-cache ca-certificates
+
+RUN addgroup -g 1000 appuser && adduser -D -u 1000 -G appuser appuser
+
+WORKDIR /app
+
+COPY --from=builder /app/target/release/user-register-account /app/user-register-account
+
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8080
+
+CMD ["./user-register-account"]

backend/services/user-service/user-register-account/src/main.rs

@@ -0,0 +1,265 @@
+use axum::{
+    extract::State,
+    http::StatusCode,
+    response::Json,
+    routing::{get, post},
+    Router,
+};
+use bcrypt::hash;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::env;
+use std::sync::Arc;
+use chrono::Utc;
+use tracing::{info, warn};
+use uuid::Uuid;
+use validator::Validate;
+
+#[derive(Clone)]
+struct AppState {
+    db: PgPool,
+}
+
+#[derive(Deserialize, Validate)]
+struct RegisterRequest {
+    #[validate(length(min = 3, max = 50))]
+    username: String,
+    #[validate(length(min = 6))]
+    password: String,
+}
+
+#[derive(Deserialize)]
+struct ApiRequest<T> {
+    device: i32,
+    language: i32,
+    data: T,
+}
+
+#[derive(Serialize)]
+struct ApiResponse<T> {
+    success: bool,
+    message: String,
+    data: Option<T>,
+}
+
+#[derive(Serialize)]
+struct RegisterData {
+    user_id: Uuid,
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+
+    info!("Starting user-register-account service...");
+
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let pool = sqlx::postgres::PgPool::connect(&database_url)
+        .await
+        .expect("Failed to connect to database");
+
+    sqlx::query("SET TIME ZONE 'Asia/Shanghai'")
+        .execute(&pool)
+        .await
+        .expect("Failed to set timezone");
+
+    info!("Database connected");
+
+    let state = Arc::new(AppState { db: pool });
+
+    let app = Router::new()
+        .route("/register", post(register_handler))
+        .route("/health", get(health_handler))
+        .with_state(state);
+
+    let port = env::var("SERVICE_PORT").unwrap_or_else(|_| "8080".to_string());
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
+        .await
+        .unwrap();
+
+    info!("User-register service listening on port {}", port);
+
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn register_handler(
+    State(state): State<Arc<AppState>>,
+    Json(req): Json<ApiRequest<RegisterRequest>>,
+) -> (StatusCode, Json<ApiResponse<RegisterData>>) {
+    info!(
+        "Registration attempt for user: {}, device: {}, language: {}",
+        req.data.username, req.device, req.language
+    );
+
+    // 参数校验
+    if let Err(e) = req.data.validate() {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ApiResponse {
+                success: false,
+                message: format!("Validation error: {}", e),
+                data: None,
+            }),
+        );
+    }
+
+    // 检查账号是否已存在
+    let existing: Option<(Uuid,)> = sqlx::query_as(
+        "SELECT id FROM user_login_account WHERE account = $1 AND deleted = FALSE"
+    )
+        .bind(&req.data.username)
+        .fetch_optional(&state.db)
+        .await
+        .unwrap_or(None);
+
+    if existing.is_some() {
+        return (
+            StatusCode::CONFLICT,
+            Json(ApiResponse {
+                success: false,
+                message: "Username already exists".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    // 密码哈希
+    let password_hash = match hash(&req.data.password, bcrypt::DEFAULT_COST) {
+        Ok(h) => h,
+        Err(e) => {
+            warn!("Password hashing failed: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Internal error".to_string(),
+                    data: None,
+                }),
+            );
+        }
+    };
+
+    // 插入用户（主从表事务）
+    let mut tx = match state.db.begin().await {
+        Ok(t) => t,
+        Err(e) => {
+            warn!("Transaction start failed: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Internal error".to_string(),
+                    data: None,
+                }),
+            );
+        }
+    };
+
+    let now = Utc::now();
+    let user_id = Uuid::now_v7();
+
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_main (id, create_date, modify_date) VALUES ($1, $2, $3)"
+    )
+    .bind(user_id)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_main failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    let account_id = Uuid::now_v7();
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_login_account (id, user_id, account, create_date, modify_date) VALUES ($1, $2, $3, $4, $5)"
+    )
+    .bind(account_id)
+    .bind(user_id)
+    .bind(&req.data.username)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_login_account failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    let password_id = Uuid::now_v7();
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_login_password (id, user_id, password, create_date, modify_date) VALUES ($1, $2, $3, $4, $5)"
+    )
+    .bind(password_id)
+    .bind(user_id)
+    .bind(&password_hash)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_login_password failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    match tx.commit().await {
+        Ok(()) => {
+            info!("User {} registered with id {}", req.data.username, user_id);
+            (
+                StatusCode::CREATED,
+                Json(ApiResponse {
+                    success: true,
+                    message: "User registered successfully".to_string(),
+                    data: Some(RegisterData { user_id }),
+                }),
+            )
+        }
+        Err(e) => {
+            warn!("Registration failed: {}", e);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Registration failed".to_string(),
+                    data: None,
+                }),
+            )
+        }
+    }
+}
+
+async fn health_handler() -> (StatusCode, Json<ApiResponse<()>>) {
+    (
+        StatusCode::OK,
+        Json(ApiResponse {
+            success: true,
+            message: "OK".to_string(),
+            data: None,
+        }),
+    )
+}

backend/services/user-service/user-register-email/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "user-register-email"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+axum = "0.8"
+tokio = { version = "1", features = ["full"] }
+tower = "0.5"
+
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+sqlx = { version = "0.8", features = ["runtime-tokio", "tls-rustls", "postgres", "chrono", "uuid"] }
+
+# UUID
+uuid = { version = "1", features = ["v7", "serde"] }
+redis = { version = "0.29", features = ["tokio-comp"] }
+
+bcrypt = "0.17"
+
+chrono = { version = "0.4", features = ["serde"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+dotenvy = "0.15"
+thiserror = "2.0"
+validator = { version = "0.20", features = ["derive"] }
+
+[profile.release]
+opt-level = 3
+lto = true
+strip = true

backend/services/user-service/user-register-email/Dockerfile

@@ -0,0 +1,33 @@
+FROM rust:1.94.1-alpine3.23 AS builder
+
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static pkgconfig
+
+WORKDIR /app
+
+COPY services/user-service/user-register-email/Cargo.toml services/user-service/user-register-email/Cargo.lock* ./
+
+RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
+RUN cargo build --release 2>/dev/null || true
+RUN rm -rf src
+
+COPY services/user-service/user-register-email/src ./src
+
+RUN touch src/main.rs && cargo build --release
+
+FROM alpine:3.23 AS runtime
+
+RUN apk add --no-cache ca-certificates
+
+RUN addgroup -g 1000 appuser && adduser -D -u 1000 -G appuser appuser
+
+WORKDIR /app
+
+COPY --from=builder /app/target/release/user-register-email /app/user-register-email
+
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8080
+
+CMD ["./user-register-email"]

backend/services/user-service/user-register-email/src/main.rs

@@ -0,0 +1,265 @@
+use axum::{
+    extract::State,
+    http::StatusCode,
+    response::Json,
+    routing::{get, post},
+    Router,
+};
+use bcrypt::hash;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::env;
+use std::sync::Arc;
+use chrono::Utc;
+use tracing::{info, warn};
+use uuid::Uuid;
+use validator::Validate;
+
+#[derive(Clone)]
+struct AppState {
+    db: PgPool,
+}
+
+#[derive(Deserialize, Validate)]
+struct RegisterRequest {
+    #[validate(email)]
+    email: String,
+    #[validate(length(min = 6))]
+    password: String,
+}
+
+#[derive(Deserialize)]
+struct ApiRequest<T> {
+    device: i32,
+    language: i32,
+    data: T,
+}
+
+#[derive(Serialize)]
+struct ApiResponse<T> {
+    success: bool,
+    message: String,
+    data: Option<T>,
+}
+
+#[derive(Serialize)]
+struct RegisterData {
+    user_id: Uuid,
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+
+    info!("Starting user-register-email service...");
+
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let pool = sqlx::postgres::PgPool::connect(&database_url)
+        .await
+        .expect("Failed to connect to database");
+
+    sqlx::query("SET TIME ZONE 'Asia/Shanghai'")
+        .execute(&pool)
+        .await
+        .expect("Failed to set timezone");
+
+    info!("Database connected");
+
+    let state = Arc::new(AppState { db: pool });
+
+    let app = Router::new()
+        .route("/register", post(register_handler))
+        .route("/health", get(health_handler))
+        .with_state(state);
+
+    let port = env::var("SERVICE_PORT").unwrap_or_else(|_| "8080".to_string());
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
+        .await
+        .unwrap();
+
+    info!("User-register-email service listening on port {}", port);
+
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn register_handler(
+    State(state): State<Arc<AppState>>,
+    Json(req): Json<ApiRequest<RegisterRequest>>,
+) -> (StatusCode, Json<ApiResponse<RegisterData>>) {
+    info!(
+        "Email registration attempt for: {}, device: {}, language: {}",
+        req.data.email, req.device, req.language
+    );
+
+    // 参数校验
+    if let Err(e) = req.data.validate() {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ApiResponse {
+                success: false,
+                message: format!("Validation error: {}", e),
+                data: None,
+            }),
+        );
+    }
+
+    // 检查邮箱是否已存在
+    let existing: Option<(Uuid,)> = sqlx::query_as(
+        "SELECT id FROM user_login_email WHERE email = $1 AND deleted = FALSE"
+    )
+        .bind(&req.data.email)
+        .fetch_optional(&state.db)
+        .await
+        .unwrap_or(None);
+
+    if existing.is_some() {
+        return (
+            StatusCode::CONFLICT,
+            Json(ApiResponse {
+                success: false,
+                message: "Email already exists".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    // 密码哈希
+    let password_hash = match hash(&req.data.password, bcrypt::DEFAULT_COST) {
+        Ok(h) => h,
+        Err(e) => {
+            warn!("Password hashing failed: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Internal error".to_string(),
+                    data: None,
+                }),
+            );
+        }
+    };
+
+    // 插入用户（主从表事务）
+    let mut tx = match state.db.begin().await {
+        Ok(t) => t,
+        Err(e) => {
+            warn!("Transaction start failed: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Internal error".to_string(),
+                    data: None,
+                }),
+            );
+        }
+    };
+
+    let now = Utc::now();
+    let user_id = Uuid::now_v7();
+
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_main (id, create_date, modify_date) VALUES ($1, $2, $3)"
+    )
+    .bind(user_id)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_main failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    let email_id = Uuid::now_v7();
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_login_email (id, user_id, email, create_date, modify_date) VALUES ($1, $2, $3, $4, $5)"
+    )
+    .bind(email_id)
+    .bind(user_id)
+    .bind(&req.data.email)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_login_email failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    let password_id = Uuid::now_v7();
+    if let Err(e) = sqlx::query(
+        "INSERT INTO user_login_password (id, user_id, password, create_date, modify_date) VALUES ($1, $2, $3, $4, $5)"
+    )
+    .bind(password_id)
+    .bind(user_id)
+    .bind(&password_hash)
+    .bind(now)
+    .bind(now)
+    .execute(&mut *tx)
+    .await
+    {
+        warn!("Insert user_login_password failed: {}", e);
+        let _ = tx.rollback().await;
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ApiResponse {
+                success: false,
+                message: "Registration failed".to_string(),
+                data: None,
+            }),
+        );
+    }
+
+    match tx.commit().await {
+        Ok(()) => {
+            info!("Email {} registered with id {}", req.data.email, user_id);
+            (
+                StatusCode::CREATED,
+                Json(ApiResponse {
+                    success: true,
+                    message: "User registered successfully".to_string(),
+                    data: Some(RegisterData { user_id }),
+                }),
+            )
+        }
+        Err(e) => {
+            warn!("Registration failed: {}", e);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiResponse {
+                    success: false,
+                    message: "Registration failed".to_string(),
+                    data: None,
+                }),
+            )
+        }
+    }
+}
+
+async fn health_handler() -> (StatusCode, Json<ApiResponse<()>>) {
+    (
+        StatusCode::OK,
+        Json(ApiResponse {
+            success: true,
+            message: "OK".to_string(),
+            data: None,
+        }),
+    )
+}