feat(health): Handler 接线 + Doctor Service + DTO 统一

- 重写全部 6 个 handler 文件，从占位错误改为调用 service 层
- 删除 handler 内联 DTO，统一使用 dto/ 模块类型
- 新增 dto/doctor_dto.rs 和 dto/follow_up_dto.rs
- 新增 service/doctor_service.rs 实现医护档案 CRUD
- 将 follow_up_service 内联 DTO 迁移到 dto/follow_up_dto.rs
- 修复 consultation_session 列名 type→consultation_type（数据库+entity+迁移同步）
- 全部 51 个 API 端点已验证可用

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/erp-health/src/handler/patient_handler.rs

@@ -1,311 +1,281 @@
 use axum::Extension;
 use axum::extract::{FromRef, Json, Path, Query, State};
-use serde::{Deserialize, Serialize};
-use utoipa::{IntoParams, ToSchema};
+use serde::Deserialize;
+use utoipa::IntoParams;
 use uuid::Uuid;
 
 use erp_core::error::AppError;
 use erp_core::types::{ApiResponse, PaginatedResponse, TenantContext};
 
+use crate::dto::patient_dto::{
+    CreatePatientReq, FamilyMemberReq, FamilyMemberResp, ManageTagsReq, PatientResp,
+    UpdatePatientReq,
+};
+use crate::service::patient_service;
 use crate::state::HealthState;
 
-// ---------------------------------------------------------------------------
-// DTO — 患者管理
-// ---------------------------------------------------------------------------
-
-/// 患者列表查询参数
 #[derive(Debug, Deserialize, IntoParams)]
 pub struct PatientListParams {
     pub page: Option<u64>,
     pub page_size: Option<u64>,
-    /// 按姓名/身份证号模糊搜索
     pub search: Option<String>,
-    /// 按标签筛选
     pub tag_id: Option<Uuid>,
-    /// 按负责医生筛选
-    pub doctor_id: Option<Uuid>,
-}
-
-/// 创建患者请求
-#[derive(Debug, Deserialize, ToSchema)]
-pub struct CreatePatientReq {
-    pub name: String,
-    pub id_card: Option<String>,
-    pub phone: Option<String>,
-    pub gender: Option<String>,
-    pub birth_date: Option<String>,
-    pub address: Option<String>,
-    pub emergency_contact: Option<String>,
-    pub emergency_phone: Option<String>,
-    pub medical_notes: Option<String>,
-}
-
-/// 更新患者请求
-#[derive(Debug, Deserialize, ToSchema)]
-pub struct UpdatePatientReq {
-    pub name: Option<String>,
-    pub id_card: Option<String>,
-    pub phone: Option<String>,
-    pub gender: Option<String>,
-    pub birth_date: Option<String>,
-    pub address: Option<String>,
-    pub emergency_contact: Option<String>,
-    pub emergency_phone: Option<String>,
-    pub medical_notes: Option<String>,
-    pub version: i32,
-}
-
-/// 患者标签管理请求
-#[derive(Debug, Deserialize, ToSchema)]
-pub struct ManagePatientTagsReq {
-    pub tag_ids: Vec<Uuid>,
-}
-
-/// 患者响应
-#[derive(Debug, Serialize, ToSchema)]
-pub struct PatientResp {
-    pub id: Uuid,
-    pub name: String,
-    pub id_card: Option<String>,
-    pub phone: Option<String>,
-    pub gender: Option<String>,
-    pub birth_date: Option<String>,
-    pub address: Option<String>,
-    pub emergency_contact: Option<String>,
-    pub emergency_phone: Option<String>,
-    pub medical_notes: Option<String>,
-    pub tags: Vec<PatientTagResp>,
-    pub created_at: String,
-    pub updated_at: String,
-}
-
-/// 患者标签响应
-#[derive(Debug, Serialize, ToSchema)]
-pub struct PatientTagResp {
-    pub id: Uuid,
-    pub name: String,
-    pub color: Option<String>,
-}
-
-/// 健康摘要响应
-#[derive(Debug, Serialize, ToSchema)]
-pub struct HealthSummaryResp {
-    pub patient_id: Uuid,
-    pub latest_vital_signs: Option<serde_json::Value>,
-    pub latest_lab_report: Option<serde_json::Value>,
-    pub upcoming_appointments: u64,
-    pub pending_follow_ups: u64,
-}
-
-/// 家庭成员请求
-#[derive(Debug, Deserialize, ToSchema)]
-pub struct CreateFamilyMemberReq {
-    pub name: String,
-    pub relationship: String,
-    pub phone: Option<String>,
-    pub id_card: Option<String>,
-}
-
-/// 更新家庭成员请求
-#[derive(Debug, Deserialize, ToSchema)]
-pub struct UpdateFamilyMemberReq {
-    pub name: Option<String>,
-    pub relationship: Option<String>,
-    pub phone: Option<String>,
-    pub id_card: Option<String>,
-}
-
-/// 家庭成员响应
-#[derive(Debug, Serialize, ToSchema)]
-pub struct FamilyMemberResp {
-    pub id: Uuid,
-    pub patient_id: Uuid,
-    pub name: String,
-    pub relationship: String,
-    pub phone: Option<String>,
-    pub id_card: Option<String>,
 }
 
 /// 分配医生请求
-#[derive(Debug, Deserialize, ToSchema)]
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
 pub struct AssignDoctorReq {
     pub doctor_id: Uuid,
+    pub relationship_type: Option<String>,
 }
 
-// ---------------------------------------------------------------------------
-// Handler — 患者管理 (13 个端点)
-// ---------------------------------------------------------------------------
-
-/// GET /api/v1/health/patients — 患者列表
 pub async fn list_patients<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Query(_params): Query<PatientListParams>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Query(params): Query<PatientListParams>,
 ) -> Result<Json<ApiResponse<PaginatedResponse<PatientResp>>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let page = params.page.unwrap_or(1);
+    let page_size = params.page_size.unwrap_or(20);
+    let result = patient_service::list_patients(
+        &state, ctx.tenant_id, page, page_size, params.search, params.tag_id,
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// POST /api/v1/health/patients — 创建患者
 pub async fn create_patient<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Json(_req): Json<CreatePatientReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Json(req): Json<CreatePatientReq>,
 ) -> Result<Json<ApiResponse<PatientResp>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let result = patient_service::create_patient(
+        &state, ctx.tenant_id, Some(ctx.user_id), req,
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// GET /api/v1/health/patients/{id} — 获取患者详情
 pub async fn get_patient<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
 ) -> Result<Json<ApiResponse<PatientResp>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let result = patient_service::get_patient(&state, ctx.tenant_id, id).await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// PUT /api/v1/health/patients/{id} — 更新患者
 pub async fn update_patient<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
-    Json(_req): Json<UpdatePatientReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
+    Json(req): Json<UpdatePatientWithVersion>,
 ) -> Result<Json<ApiResponse<PatientResp>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let version = req.version;
+    let update = UpdatePatientReq {
+        name: req.name,
+        gender: req.gender,
+        birth_date: req.birth_date,
+        blood_type: req.blood_type,
+        id_number: req.id_number,
+        allergy_history: req.allergy_history,
+        medical_history_summary: req.medical_history_summary,
+        emergency_contact_name: req.emergency_contact_name,
+        emergency_contact_phone: req.emergency_contact_phone,
+        source: req.source,
+        notes: req.notes,
+    };
+    let result = patient_service::update_patient(
+        &state, ctx.tenant_id, id, Some(ctx.user_id), update, version,
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// DELETE /api/v1/health/patients/{id} — 删除患者（软删除）
 pub async fn delete_patient<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
 ) -> Result<Json<ApiResponse<()>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    patient_service::delete_patient(&state, ctx.tenant_id, id, Some(ctx.user_id)).await?;
+    Ok(Json(ApiResponse::ok(())))
 }
 
-/// POST /api/v1/health/patients/{id}/tags — 管理患者标签
 pub async fn manage_patient_tags<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
-    Json(_req): Json<ManagePatientTagsReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
+    Json(req): Json<ManageTagsReq>,
 ) -> Result<Json<ApiResponse<()>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    patient_service::manage_patient_tags(&state, ctx.tenant_id, id, req, Some(ctx.user_id)).await?;
+    Ok(Json(ApiResponse::ok(())))
 }
 
-/// GET /api/v1/health/patients/{id}/health-summary — 获取患者健康摘要
 pub async fn get_health_summary<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
-) -> Result<Json<ApiResponse<HealthSummaryResp>>, AppError>
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
+) -> Result<Json<ApiResponse<serde_json::Value>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let result = patient_service::get_health_summary(&state, ctx.tenant_id, id).await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// GET /api/v1/health/patients/{id}/family-members — 家庭成员列表
 pub async fn list_family_members<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
 ) -> Result<Json<ApiResponse<Vec<FamilyMemberResp>>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let result = patient_service::list_family_members(&state, ctx.tenant_id, id).await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// POST /api/v1/health/patients/{id}/family-members — 创建家庭成员
 pub async fn create_family_member<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
-    Json(_req): Json<CreateFamilyMemberReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
+    Json(req): Json<FamilyMemberReq>,
 ) -> Result<Json<ApiResponse<FamilyMemberResp>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let result = patient_service::create_family_member(
+        &state, ctx.tenant_id, id, Some(ctx.user_id), req,
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// PUT /api/v1/health/patients/{patient_id}/family-members/{member_id} — 更新家庭成员
 pub async fn update_family_member<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path((_patient_id, _member_id)): Path<(Uuid, Uuid)>,
-    Json(_req): Json<UpdateFamilyMemberReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path((_patient_id, member_id)): Path<(Uuid, Uuid)>,
+    Json(req): Json<FamilyMemberUpdateWithVersion>,
 ) -> Result<Json<ApiResponse<FamilyMemberResp>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    let version = req.version;
+    let update = FamilyMemberReq {
+        name: req.name,
+        relationship: req.relationship,
+        phone: req.phone,
+        birth_date: req.birth_date,
+        notes: req.notes,
+    };
+    let result = patient_service::update_family_member(
+        &state, ctx.tenant_id, _patient_id, member_id, Some(ctx.user_id), update, version,
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(result)))
 }
 
-/// DELETE /api/v1/health/patients/{patient_id}/family-members/{member_id} — 删除家庭成员
 pub async fn delete_family_member<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path((_patient_id, _member_id)): Path<(Uuid, Uuid)>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path((patient_id, member_id)): Path<(Uuid, Uuid)>,
 ) -> Result<Json<ApiResponse<()>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    patient_service::delete_family_member(
+        &state, ctx.tenant_id, patient_id, member_id, Some(ctx.user_id),
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(())))
 }
 
-/// POST /api/v1/health/patients/{id}/doctors — 分配负责医生
 pub async fn assign_doctor<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path(_id): Path<Uuid>,
-    Json(_req): Json<AssignDoctorReq>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path(id): Path<Uuid>,
+    Json(req): Json<AssignDoctorReq>,
 ) -> Result<Json<ApiResponse<()>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    patient_service::assign_doctor(
+        &state,
+        ctx.tenant_id,
+        id,
+        req.doctor_id,
+        req.relationship_type.unwrap_or_else(|| "primary".to_string()),
+        Some(ctx.user_id),
+    )
+    .await?;
+    Ok(Json(ApiResponse::ok(())))
 }
 
-/// DELETE /api/v1/health/patients/{patient_id}/doctors/{doctor_id} — 移除负责医生
 pub async fn remove_doctor<S>(
-    State(_state): State<HealthState>,
-    Extension(_ctx): Extension<TenantContext>,
-    Path((_patient_id, _doctor_id)): Path<(Uuid, Uuid)>,
+    State(state): State<HealthState>,
+    Extension(ctx): Extension<TenantContext>,
+    Path((patient_id, doctor_id)): Path<(Uuid, Uuid)>,
 ) -> Result<Json<ApiResponse<()>>, AppError>
 where
     HealthState: FromRef<S>,
     S: Clone + Send + Sync + 'static,
 {
-    Err(AppError::Internal("Not implemented yet".into()))
+    patient_service::remove_doctor(&state, ctx.tenant_id, patient_id, doctor_id).await?;
+    Ok(Json(ApiResponse::ok(())))
+}
+
+// 带版本号的更新请求包装
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+pub struct UpdatePatientWithVersion {
+    pub name: Option<String>,
+    pub gender: Option<String>,
+    pub birth_date: Option<chrono::NaiveDate>,
+    pub blood_type: Option<String>,
+    pub id_number: Option<String>,
+    pub allergy_history: Option<String>,
+    pub medical_history_summary: Option<String>,
+    pub emergency_contact_name: Option<String>,
+    pub emergency_contact_phone: Option<String>,
+    pub source: Option<String>,
+    pub notes: Option<String>,
+    pub version: i32,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+pub struct FamilyMemberUpdateWithVersion {
+    pub name: String,
+    pub relationship: String,
+    pub phone: Option<String>,
+    pub birth_date: Option<chrono::NaiveDate>,
+    pub notes: Option<String>,
+    pub version: i32,
 }