feat(health): Handler 接线 + Doctor Service + DTO 统一
Some checks failed
CI / rust-check (push) Has been cancelled
CI / rust-test (push) Has been cancelled
CI / frontend-build (push) Has been cancelled
CI / security-audit (push) Has been cancelled

- 重写全部 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>
This commit is contained in:
iven
2026-04-23 21:31:42 +08:00
parent 1824f84467
commit d6678d001e
14 changed files with 929 additions and 915 deletions

View File

@@ -1,142 +1,142 @@
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::consultation_dto::*;
use crate::service::consultation_service;
use crate::state::HealthState;
// ---------------------------------------------------------------------------
// DTO — 咨询管理
// ---------------------------------------------------------------------------
/// 会话列表查询参数
#[derive(Debug, Deserialize, IntoParams)]
pub struct SessionListParams {
pub page: Option<u64>,
pub page_size: Option<u64>,
pub status: Option<String>,
pub patient_id: Option<Uuid>,
pub doctor_id: Option<Uuid>,
pub status: Option<String>,
}
/// 会话响应
#[derive(Debug, Serialize, ToSchema)]
pub struct ConsultationSessionResp {
pub id: Uuid,
pub patient_id: Uuid,
pub doctor_id: Uuid,
pub subject: String,
pub status: String,
pub created_at: String,
pub updated_at: String,
}
/// 消息列表查询参数
#[derive(Debug, Deserialize, IntoParams)]
pub struct MessageListParams {
pub page: Option<u64>,
pub page_size: Option<u64>,
}
/// 创建消息请求
#[derive(Debug, Deserialize, ToSchema)]
pub struct CreateConsultationMessageReq {
pub content: String,
pub message_type: Option<String>,
#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
pub struct CloseSessionReq {
pub version: i32,
}
/// 消息响应
#[derive(Debug, Serialize, ToSchema)]
pub struct ConsultationMessageResp {
pub id: Uuid,
#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
pub struct CreateConsultationMessageReq {
pub session_id: Uuid,
pub sender_id: Uuid,
pub sender_type: String,
pub sender_role: String,
pub content_type: Option<String>,
pub content: String,
pub message_type: String,
pub created_at: String,
}
/// 导出会话请求
#[derive(Debug, Deserialize, IntoParams)]
pub struct ExportSessionsParams {
pub status: Option<String>,
pub patient_id: Option<Uuid>,
pub doctor_id: Option<Uuid>,
pub start_date: Option<String>,
pub end_date: Option<String>,
}
// ---------------------------------------------------------------------------
// Handler — 咨询管理 (5 个端点)
// ---------------------------------------------------------------------------
/// GET /api/v1/health/consultations/sessions — 会话列表
pub async fn list_sessions<S>(
State(_state): State<HealthState>,
Extension(_ctx): Extension<TenantContext>,
Query(_params): Query<SessionListParams>,
) -> Result<Json<ApiResponse<PaginatedResponse<ConsultationSessionResp>>>, AppError>
State(state): State<HealthState>,
Extension(ctx): Extension<TenantContext>,
Query(params): Query<SessionListParams>,
) -> Result<Json<ApiResponse<PaginatedResponse<SessionResp>>>, 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 = consultation_service::list_sessions(
&state, ctx.tenant_id, page, page_size, params.status, params.patient_id,
params.doctor_id,
)
.await?;
Ok(Json(ApiResponse::ok(result)))
}
/// GET /api/v1/health/consultations/sessions/{id}/messages — 消息列表
pub async fn list_messages<S>(
State(_state): State<HealthState>,
Extension(_ctx): Extension<TenantContext>,
Path(_session_id): Path<Uuid>,
Query(_params): Query<MessageListParams>,
) -> Result<Json<ApiResponse<PaginatedResponse<ConsultationMessageResp>>>, AppError>
State(state): State<HealthState>,
Extension(ctx): Extension<TenantContext>,
Path(session_id): Path<Uuid>,
Query(params): Query<MessageListParams>,
) -> Result<Json<ApiResponse<PaginatedResponse<MessageResp>>>, 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 = consultation_service::list_messages(
&state, ctx.tenant_id, session_id, page, page_size,
)
.await?;
Ok(Json(ApiResponse::ok(result)))
}
/// PUT /api/v1/health/consultations/sessions/{id}/close — 关闭会话
pub async fn close_session<S>(
State(_state): State<HealthState>,
Extension(_ctx): Extension<TenantContext>,
Path(_id): Path<Uuid>,
) -> Result<Json<ApiResponse<ConsultationSessionResp>>, AppError>
State(state): State<HealthState>,
Extension(ctx): Extension<TenantContext>,
Path(id): Path<Uuid>,
Json(req): Json<CloseSessionReq>,
) -> Result<Json<ApiResponse<SessionResp>>, AppError>
where
HealthState: FromRef<S>,
S: Clone + Send + Sync + 'static,
{
Err(AppError::Internal("Not implemented yet".into()))
let result = consultation_service::close_session(
&state, ctx.tenant_id, id, Some(ctx.user_id), req.version,
)
.await?;
Ok(Json(ApiResponse::ok(result)))
}
/// POST /api/v1/health/consultations/sessions/{id}/messages — 创建消息
pub async fn create_message<S>(
State(_state): State<HealthState>,
Extension(_ctx): Extension<TenantContext>,
Path(_session_id): Path<Uuid>,
Json(_req): Json<CreateConsultationMessageReq>,
) -> Result<Json<ApiResponse<ConsultationMessageResp>>, AppError>
State(state): State<HealthState>,
Extension(ctx): Extension<TenantContext>,
Json(req): Json<CreateConsultationMessageReq>,
) -> Result<Json<ApiResponse<MessageResp>>, AppError>
where
HealthState: FromRef<S>,
S: Clone + Send + Sync + 'static,
{
Err(AppError::Internal("Not implemented yet".into()))
let msg_req = CreateMessageReq {
session_id: req.session_id,
sender_id: req.sender_id,
sender_role: req.sender_role,
content_type: req.content_type,
content: req.content,
};
let result = consultation_service::create_message(
&state, ctx.tenant_id, Some(ctx.user_id), msg_req,
)
.await?;
Ok(Json(ApiResponse::ok(result)))
}
/// GET /api/v1/health/consultations/export — 导出会话
pub async fn export_sessions<S>(
State(_state): State<HealthState>,
Extension(_ctx): Extension<TenantContext>,
Query(_params): Query<ExportSessionsParams>,
) -> Result<Json<ApiResponse<Vec<ConsultationSessionResp>>>, AppError>
State(state): State<HealthState>,
Extension(ctx): Extension<TenantContext>,
Query(params): Query<ExportSessionsParams>,
) -> Result<Json<ApiResponse<Vec<SessionResp>>>, AppError>
where
HealthState: FromRef<S>,
S: Clone + Send + Sync + 'static,
{
Err(AppError::Internal("Not implemented yet".into()))
let result = consultation_service::export_sessions(
&state, ctx.tenant_id, params.status, params.patient_id, params.doctor_id,
)
.await?;
Ok(Json(ApiResponse::ok(result)))
}