优化API文档，添加参数描述和示例

app/api/v1/endpoints/simulation.py

@@ -4,8 +4,7 @@ import json
 import os
 import shutil
 import threading
-import pandas as pd
-from fastapi import APIRouter, HTTPException, File, UploadFile, Query
+from fastapi import APIRouter, HTTPException, File, UploadFile, Query, Path, Body
 from fastapi.responses import PlainTextResponse
 import app.infra.db.influxdb.api as influxdb_api
 import app.services.simulation as simulation
@@ -39,77 +38,77 @@ from app.services.simulation_ops import (
     daily_scheduling_simulation,
 )
 from app.services.valve_isolation import analyze_valve_isolation
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 router = APIRouter()
 
 
 class RunSimulationManuallyByDate(BaseModel):
-    name: str
-    simulation_date: str
-    start_time: str
-    duration: int
+    name: str = Field(..., description="管网名称（或数据库名称）")
+    simulation_date: str = Field(..., description="模拟基准日期 (YYYY-MM-DD)")
+    start_time: str = Field(..., description="开始时间 (HH:MM 或 HH:MM:SS)")
+    duration: int = Field(..., description="持续时间 (分钟)")
 
 
 class BurstAnalysis(BaseModel):
-    name: str
-    modify_pattern_start_time: str
-    burst_ID: List[str] | str | None = None
-    burst_size: List[float] | float | int | None = None
-    modify_total_duration: int = 900
-    modify_fixed_pump_pattern: Optional[dict[str, list]] = None
-    modify_variable_pump_pattern: Optional[dict[str, list]] = None
-    modify_valve_opening: Optional[dict[str, float]] = None
-    scheme_name: Optional[str] = None
+    name: str = Field(..., description="管网名称（或数据库名称）")
+    modify_pattern_start_time: str = Field(..., description="模式修改开始时间 (ISO 8601)")
+    burst_ID: List[str] | str | None = Field(None, description="爆管节点/管段ID列表")
+    burst_size: List[float] | float | int | None = Field(None, description="爆管流量大小")
+    modify_total_duration: int = Field(900, description="模拟总时长 (秒)")
+    modify_fixed_pump_pattern: Optional[dict[str, list]] = Field(None, description="定速泵模式修改")
+    modify_variable_pump_pattern: Optional[dict[str, list]] = Field(None, description="变速泵模式修改")
+    modify_valve_opening: Optional[dict[str, float]] = Field(None, description="阀门开度修改")
+    scheme_name: Optional[str] = Field(None, description="方案名称")
 
 
 class SchedulingAnalysis(BaseModel):
-    network: str
-    start_time: str
-    pump_control: dict
-    tank_id: str
-    water_plant_output_id: str
-    time_delta: Optional[int] = 300
+    network: str = Field(..., description="管网名称（或数据库名称）")
+    start_time: str = Field(..., description="开始时间")
+    pump_control: dict = Field(..., description="泵控制策略")
+    tank_id: str = Field(..., description="水箱ID")
+    water_plant_output_id: str = Field(..., description="水厂出水ID")
+    time_delta: Optional[int] = Field(300, description="时间步长 (秒)")
 
 
 class PressureRegulation(BaseModel):
-    network: str
-    start_time: str
-    pump_control: dict
-    tank_init_level: Optional[dict] = None
-    duration: Optional[int] = 900
-    scheme_name: Optional[str] = None
+    network: str = Field(..., description="管网名称（或数据库名称）")
+    start_time: str = Field(..., description="开始时间")
+    pump_control: dict = Field(..., description="泵控制策略")
+    tank_init_level: Optional[dict] = Field(None, description="水箱初始水位")
+    duration: Optional[int] = Field(900, description="持续时间 (秒)")
+    scheme_name: Optional[str] = Field(None, description="方案名称")
 
 
 class ProjectManagement(BaseModel):
-    network: str
-    start_time: str
-    pump_control: dict
-    tank_init_level: Optional[dict] = None
-    region_demand: Optional[dict] = None
+    network: str = Field(..., description="管网名称（或数据库名称）")
+    start_time: str = Field(..., description="开始时间")
+    pump_control: dict = Field(..., description="泵控制策略")
+    tank_init_level: Optional[dict] = Field(None, description="水箱初始水位")
+    region_demand: Optional[dict] = Field(None, description="区域需水量控制")
 
 
 class DailySchedulingAnalysis(BaseModel):
-    network: str
-    start_time: str
-    pump_control: dict
-    reservoir_id: str
-    tank_id: str
-    water_plant_output_id: str
-    time_delta: Optional[int] = 300
+    network: str = Field(..., description="管网名称（或数据库名称）")
+    start_time: str = Field(..., description="开始时间")
+    pump_control: dict = Field(..., description="泵控制策略")
+    reservoir_id: str = Field(..., description="水库ID")
+    tank_id: str = Field(..., description="水箱ID")
+    water_plant_output_id: str = Field(..., description="水厂出水ID")
+    time_delta: Optional[int] = Field(300, description="时间步长 (秒)")
 
 
 class PumpFailureState(BaseModel):
-    time: str
-    pump_status: dict
+    time: str = Field(..., description="故障发生时间")
+    pump_status: dict = Field(..., description="泵状态字典")
 
 
 class PressureSensorPlacement(BaseModel):
-    name: str
-    scheme_name: str
-    sensor_number: int
-    min_diameter: int = 0
-    username: str
+    name: str = Field(..., description="管网名称（或数据库名称）")
+    scheme_name: str = Field(..., description="方案名称")
+    sensor_number: int = Field(..., description="传感器数量")
+    min_diameter: int = Field(0, description="最小管径限制")
+    username: str = Field(..., description="用户名")
 
 
 def run_simulation_manually_by_date(
@@ -140,8 +139,15 @@ def run_simulation_manually_by_date(
 
 
 # 必须用这个PlainTextResponse，不然每个key都有引号
-@router.get("/runproject/", response_class=PlainTextResponse)
-async def run_project_endpoint(network: str) -> str:
+@router.get("/runproject/", response_class=PlainTextResponse, summary="运行项目模拟", description="基于指定的管网项目运行标准水力模拟，返回纯文本格式的模拟报告。使用分布式锁机制确保同时只有一个模拟任务运行。")
+async def run_project_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> str:
+    """
+    运行项目模拟
+    
+    - **network**: 管网名称（或数据库名称）
+    
+    使用分布式锁机制确保同一时间只有一个模拟任务在运行。如果已有任务在运行，返回409状态码。
+    """
     lock_key = "exclusive_api_lock"
     timeout = 120  # 锁自动过期时间（秒）
 
@@ -162,8 +168,19 @@ async def run_project_endpoint(network: str) -> str:
 # output 和 report
 # output 是 json
 # report 是 text
-@router.get("/runprojectreturndict/")
-async def run_project_return_dict_endpoint(network: str) -> dict[str, Any]:
+@router.get("/runprojectreturndict/", summary="运行项目模拟（返回字典）", description="基于指定的管网项目运行标准水力模拟，返回JSON格式的字典，包含输出数据和报告文本。使用分布式锁机制确保同时只有一个模拟任务运行。")
+async def run_project_return_dict_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
+    """
+    运行项目模拟（返回字典）
+    
+    - **network**: 管网名称（或数据库名称）
+    
+    返回字典包含：
+    - output: JSON格式的模拟输出数据
+    - report: 文本格式的模拟报告
+    
+    使用分布式锁机制确保同一时间只有一个模拟任务在运行。
+    """
     lock_key = "exclusive_api_lock"
     timeout = 120  # 锁自动过期时间（秒）
 
@@ -181,34 +198,73 @@ async def run_project_return_dict_endpoint(network: str) -> dict[str, Any]:
 
 
 # put in inp folder, name without extension
-@router.get("/runinp/")
-async def run_inp_endpoint(network: str) -> str:
+@router.get("/runinp/", summary="运行INP文件", description="运行指定INP文件格式的管网模型进行水力模拟。INP文件应该放在inp文件夹中，参数为文件名不含扩展名。")
+async def run_inp_endpoint(network: str = Query(..., description="inp文件名（不含扩展名）")) -> str:
+    """
+    运行INP文件
+    
+    - **network**: inp文件名（不含扩展名）
+    
+    从inp文件夹中读取指定的INP文件并运行模拟。
+    """
     return run_inp(network)
 
 
 # path is absolute path
-@router.get("/dumpoutput/")
-async def dump_output_endpoint(output: str) -> str:
+@router.get("/dumpoutput/", summary="导出模拟输出", description="导出指定路径的模拟输出文件内容。参数应为绝对路径。")
+async def dump_output_endpoint(output: str = Query(..., description="模拟输出文件的绝对路径")) -> str:
+    """
+    导出模拟输出
+    
+    - **output**: 模拟输出文件的绝对路径
+    
+    读取并返回指定路径的模拟输出内容。
+    """
     return dump_output(output)
 
 
 # Analysis Endpoints
-@router.get("/burstanalysis/")
+@router.get("/burstanalysis/", summary="爆管分析（基础）", description="对管网中的爆管事件进行分析，包括爆管对管网压力和流量的影响。此为基础版本，接收简化的查询参数。")
 async def burst_analysis_endpoint(
-    network: str, pipe_id: str, start_time: str, end_time: str, burst_flow: float
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    pipe_id: str = Query(..., description="管段ID"),
+    start_time: str = Query(..., description="分析开始时间（ISO 8601格式）"),
+    end_time: str = Query(..., description="分析结束时间（ISO 8601格式）"),
+    burst_flow: float = Query(..., description="爆管流量大小（L/s）"),
 ):
+    """
+    爆管分析（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **pipe_id**: 管段ID
+    - **start_time**: 分析开始时间
+    - **end_time**: 分析结束时间
+    - **burst_flow**: 爆管流量大小
+    """
     return burst_analysis(network, pipe_id, start_time, end_time, burst_flow)
 
 
-@router.get("/burst_analysis/")
+@router.get("/burst_analysis/", summary="爆管分析（高级）", description="高级版本的爆管分析，支持在指定时间点修改泵控制模式和阀门开度，以分析这些改变对爆管影响的作用。支持固定泵和变速泵的独立控制。")
 async def fastapi_burst_analysis(
-    network: str = Query(...),
-    modify_pattern_start_time: str = Query(...),
-    burst_ID: list[str] = Query(...),
-    burst_size: list[float] = Query(...),
-    modify_total_duration: int = Query(...),
-    scheme_name: str = Query(...),
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    modify_pattern_start_time: str = Query(..., description="模式修改开始时间（ISO 8601格式）"),
+    burst_ID: list[str] = Query(..., description="爆管节点/管段ID列表"),
+    burst_size: list[float] = Query(..., description="对应各爆管点的爆管流量大小列表（L/s）"),
+    modify_total_duration: int = Query(..., description="模拟总时长（秒）"),
+    scheme_name: str = Query(..., description="分析方案名称"),
 ) -> str:
+    """
+    爆管分析（高级版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **modify_pattern_start_time**: 模式修改开始时间
+    - **burst_ID**: 爆管节点/管段ID列表
+    - **burst_size**: 爆管流量大小列表（与burst_ID对应）
+    - **modify_total_duration**: 模拟总时长（秒）
+    - **scheme_name**: 分析方案名称
+    
+    支持在指定时间修改泵控制模式和阀门开度。
+    """
     burst_analysis(
         name=network,
         modify_pattern_start_time=modify_pattern_start_time,
@@ -220,20 +276,41 @@ async def fastapi_burst_analysis(
     return "success"
 
 
-@router.get("/valvecloseanalysis/")
+@router.get("/valvecloseanalysis/", summary="阀门关闭分析（基础）", description="对管网中的阀门关闭事件进行分析，评估关闭阀门对管网的影响。此为基础版本。")
 async def valve_close_analysis_endpoint(
-    network: str, valve_id: str, start_time: str, end_time: str
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    valve_id: str = Query(..., description="阀门ID"),
+    start_time: str = Query(..., description="分析开始时间（ISO 8601格式）"),
+    end_time: str = Query(..., description="分析结束时间（ISO 8601格式）"),
 ):
+    """
+    阀门关闭分析（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **valve_id**: 阀门ID
+    - **start_time**: 分析开始时间
+    - **end_time**: 分析结束时间
+    """
     return valve_close_analysis(network, valve_id, start_time, end_time)
 
 
-@router.get("/valve_close_analysis/", response_class=PlainTextResponse)
+@router.get("/valve_close_analysis/", response_class=PlainTextResponse, summary="阀门关闭分析（高级）", description="高级版本的阀门关闭分析，支持同时关闭多个阀门，并在指定持续时间内进行模拟。返回纯文本格式的分析结果。")
 async def fastapi_valve_close_analysis(
-    network: str,
-    start_time: str,
-    valves: List[str] = Query(...),
-    duration: int | None = None,
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    start_time: str = Query(..., description="阀门关闭开始时间（ISO 8601格式）"),
+    valves: List[str] = Query(..., description="要关闭的阀门ID列表"),
+    duration: int | None = Query(None, description="模拟持续时间（秒），默认900秒"),
 ) -> str:
+    """
+    阀门关闭分析（高级版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 阀门关闭开始时间
+    - **valves**: 要关闭的阀门ID列表
+    - **duration**: 模拟持续时间（秒，可选，默认900）
+    
+    支持同时关闭多个阀门进行分析。
+    """
     result = valve_close_analysis(
         name=network,
         modify_pattern_start_time=start_time,
@@ -243,12 +320,25 @@ async def fastapi_valve_close_analysis(
     return result or "success"
 
 
-@router.get("/valve_isolation_analysis/")
+@router.get("/valve_isolation_analysis/", summary="阀门隔离分析", description="分析当发生突发事件时，通过关闭指定阀门进行隔离，确定哪些阀门必须关闭、哪些可选关闭，以及隔离的可行性。")
 async def valve_isolation_endpoint(
-    network: str,
-    accident_element: List[str] = Query(...),
-    disabled_valves: List[str] = Query(None),
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    accident_element: List[str] = Query(..., description="发生事故的管段/节点ID列表"),
+    disabled_valves: List[str] = Query(None, description="已故障的阀门ID列表（可选）"),
 ):
+    """
+    阀门隔离分析
+    
+    - **network**: 管网名称（或数据库名称）
+    - **accident_element**: 发生事故的管段/节点ID列表
+    - **disabled_valves**: 已故障的阀门ID列表（可选）
+    
+    返回隔离方案，包括：
+    - must_close_valves: 必须关闭的阀门列表
+    - optional_valves: 可选关闭的阀门列表
+    - affected_nodes: 受影响的节点列表
+    - isolatable: 是否可以有效隔离
+    """
     result = {
         "accident_element": "P461309",
         "accident_elements": ["P461309"],
@@ -270,24 +360,51 @@ async def valve_isolation_endpoint(
     return result
 
 
-@router.get("/flushinganalysis/")
+@router.get("/flushinganalysis/", summary="冲洗分析（基础）", description="对管网的冲洗操作进行分析，评估冲洗流量和持续时间对管网的影响。此为基础版本。")
 async def flushing_analysis_endpoint(
-    network: str, pipe_id: str, start_time: str, duration: float, flow: float
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    pipe_id: str = Query(..., description="要冲洗的管段ID"),
+    start_time: str = Query(..., description="冲洗开始时间（ISO 8601格式）"),
+    duration: float = Query(..., description="冲洗持续时间（分钟）"),
+    flow: float = Query(..., description="冲洗流量（L/s）"),
 ):
+    """
+    冲洗分析（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **pipe_id**: 要冲洗的管段ID
+    - **start_time**: 冲洗开始时间
+    - **duration**: 冲洗持续时间（分钟）
+    - **flow**: 冲洗流量（L/s）
+    """
     return flushing_analysis(network, pipe_id, start_time, duration, flow)
 
 
-@router.get("/flushing_analysis/", response_class=PlainTextResponse)
+@router.get("/flushing_analysis/", response_class=PlainTextResponse, summary="冲洗分析（高级）", description="高级版本的冲洗分析，支持同时开启多个阀门进行冲洗，指定排污节点，并设置固定的冲洗流量。返回纯文本格式的分析结果。")
 async def fastapi_flushing_analysis(
-    network: str,
-    start_time: str,
-    valves: List[str] = Query(...),
-    valves_k: List[float] = Query(...),
-    drainage_node_ID: str = Query(...),
-    flush_flow: float = 0,
-    duration: int | None = None,
-    scheme_name: str | None = None,
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    start_time: str = Query(..., description="冲洗开始时间（ISO 8601格式）"),
+    valves: List[str] = Query(..., description="要开启的阀门ID列表"),
+    valves_k: List[float] = Query(..., description="对应各阀门的开度列表（0-1）"),
+    drainage_node_ID: str = Query(..., description="排污节点ID"),
+    flush_flow: float = Query(0, description="冲洗流量（L/s），0表示自动计算"),
+    duration: int | None = Query(None, description="模拟持续时间（秒），默认900秒"),
+    scheme_name: str | None = Query(None, description="冲洗方案名称（可选）"),
 ) -> str:
+    """
+    冲洗分析（高级版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 冲洗开始时间
+    - **valves**: 要开启的阀门ID列表
+    - **valves_k**: 各阀门的开度列表（0-1，与valves对应）
+    - **drainage_node_ID**: 排污节点ID
+    - **flush_flow**: 冲洗流量（L/s）
+    - **duration**: 模拟持续时间（秒，可选，默认900）
+    - **scheme_name**: 冲洗方案名称（可选）
+    
+    支持多阀联合冲洗操作。
+    """
     valve_opening = {
         valve_id: float(valves_k[idx]) for idx, valve_id in enumerate(valves)
     }
@@ -303,16 +420,29 @@ async def fastapi_flushing_analysis(
     return result or "success"
 
 
-@router.get("/contaminant_simulation/", response_class=PlainTextResponse)
+@router.get("/contaminant_simulation/", response_class=PlainTextResponse, summary="污染物模拟", description="对管网中的污染物扩散进行模拟，评估污染源对管网的影响范围和浓度分布。支持指定污染源位置、污染浓度和扩散模式。")
 async def fastapi_contaminant_simulation(
-    network: str,
-    start_time: str,
-    source: str,
-    concentration: float,
-    duration: int,
-    scheme_name: str | None = None,
-    pattern: str | None = None,
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    start_time: str = Query(..., description="污染开始时间（ISO 8601格式）"),
+    source: str = Query(..., description="污染源节点ID"),
+    concentration: float = Query(..., description="污染浓度（mg/L）"),
+    duration: int = Query(..., description="模拟持续时间（秒）"),
+    scheme_name: str | None = Query(None, description="模拟方案名称（可选）"),
+    pattern: str | None = Query(None, description="污染源模式ID（可选）"),
 ) -> str:
+    """
+    污染物模拟
+    
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 污染开始时间
+    - **source**: 污染源节点ID
+    - **concentration**: 污染浓度（mg/L）
+    - **duration**: 模拟持续时间（秒）
+    - **scheme_name**: 模拟方案名称（可选）
+    - **pattern**: 污染源模式ID（可选）
+    
+    用于评估管网中污染物的传播和影响范围。
+    """
     result = contaminant_simulation(
         name=network,
         modify_pattern_start_time=start_time,
@@ -325,15 +455,35 @@ async def fastapi_contaminant_simulation(
     return result or "success"
 
 
-@router.get("/ageanalysis/")
-async def age_analysis_endpoint(network: str):
+@router.get("/ageanalysis/", summary="水龄分析（基础）", description="对管网中的水体停留时间（水龄）进行分析。此为基础版本。")
+async def age_analysis_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")):
+    """
+    水龄分析（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    
+    分析管网中各节点的水体停留时间。
+    """
     return age_analysis(network)
 
 
-@router.get("/age_analysis/", response_class=PlainTextResponse)
+@router.get("/age_analysis/", response_class=PlainTextResponse, summary="水龄分析（高级）", description="高级版本的水龄分析，在指定时间点进行分析，支持自定义模拟持续时间。返回纯文本格式的分析结果。")
 async def fastapi_age_analysis(
-    network: str, start_time: str, end_time: str, duration: int
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    start_time: str = Query(..., description="分析开始时间（ISO 8601格式）"),
+    end_time: str = Query(..., description="分析结束时间（ISO 8601格式）"),
+    duration: int = Query(..., description="模拟持续时间（秒）"),
 ) -> str:
+    """
+    水龄分析（高级版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 分析开始时间
+    - **end_time**: 分析结束时间（可选）
+    - **duration**: 模拟持续时间（秒）
+    
+    分析指定时间段内管网中各节点的水体停留时间。
+    """
     result = age_analysis(network, start_time, duration)
     return result or "success"
 
@@ -343,15 +493,39 @@ async def fastapi_age_analysis(
 #     return scheduling_analysis(network)
 
 
-@router.get("/pressureregulation/")
+@router.get("/pressureregulation/", summary="压力调节（基础）", description="对管网的压力进行调节分析，通过控制泵的运行来维持目标节点的目标压力。此为基础版本。")
 async def pressure_regulation_endpoint(
-    network: str, target_node: str, target_pressure: float
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    target_node: str = Query(..., description="目标节点ID"),
+    target_pressure: float = Query(..., description="目标压力值（kPa）"),
 ):
+    """
+    压力调节（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    - **target_node**: 目标节点ID
+    - **target_pressure**: 目标压力值（kPa）
+    
+    通过泵控制维持目标节点的压力。
+    """
     return pressure_regulation(network, target_node, target_pressure)
 
 
-@router.post("/pressure_regulation/")
-async def fastapi_pressure_regulation(data: PressureRegulation) -> str:
+@router.post("/pressure_regulation/", summary="压力调节（高级）", description="高级版本的压力调节分析，通过JSON请求体提供详细的控制参数，包括固定泵和变速泵的独立控制、水箱初始水位等。")
+async def fastapi_pressure_regulation(data: PressureRegulation = Body(..., description="压力调节控制参数")) -> str:
+    """
+    压力调节（高级版本）
+    
+    请求体参数：
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 控制开始时间
+    - **pump_control**: 泵控制策略字典
+    - **tank_init_level**: 水箱初始水位字典（可选）
+    - **duration**: 模拟持续时间（秒，可选，默认900）
+    - **scheme_name**: 控制方案名称（可选）
+    
+    支持固定泵和变速泵的独立控制。
+    """
     item = data.dict()
     simulation.query_corresponding_element_id_and_query_id(item["network"])
     fixed_pumps = set(globals.fixed_pumps_id.keys())
@@ -375,13 +549,32 @@ async def fastapi_pressure_regulation(data: PressureRegulation) -> str:
     return "success"
 
 
-@router.get("/projectmanagement/")
-async def project_management_endpoint(network: str):
+@router.get("/projectmanagement/", summary="项目管理（基础）", description="对管网项目进行基础的管理操作。此为基础版本。")
+async def project_management_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")):
+    """
+    项目管理（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    
+    进行基础的项目管理操作。
+    """
     return project_management(network)
 
 
-@router.post("/project_management/")
-async def fastapi_project_management(data: ProjectManagement) -> str:
+@router.post("/project_management/", summary="项目管理（高级）", description="高级版本的项目管理，通过JSON请求体提供详细的控制参数，包括泵控制策略、水箱初始水位和区域需水量控制。")
+async def fastapi_project_management(data: ProjectManagement = Body(..., description="项目管理控制参数")) -> str:
+    """
+    项目管理（高级版本）
+    
+    请求体参数：
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 管理开始时间
+    - **pump_control**: 泵控制策略字典
+    - **tank_init_level**: 水箱初始水位字典（可选）
+    - **region_demand**: 区域需水量控制字典（可选）
+    
+    支持多维度的项目管理。
+    """
     item = data.dict()
     return project_management(
         prj_name=item["network"],
@@ -397,8 +590,21 @@ async def fastapi_project_management(data: ProjectManagement) -> str:
 #     return daily_scheduling_analysis(network)
 
 
-@router.post("/scheduling_analysis/")
-async def fastapi_scheduling_analysis(data: SchedulingAnalysis) -> str:
+@router.post("/scheduling_analysis/", summary="排程分析", description="对管网的供水排程进行分析，优化泵的运行时间和出水流量，平衡水厂出水、水箱进出水，满足用户需求。")
+async def fastapi_scheduling_analysis(data: SchedulingAnalysis = Body(..., description="排程分析参数")) -> str:
+    """
+    排程分析
+    
+    请求体参数：
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 分析开始时间
+    - **pump_control**: 泵控制策略字典
+    - **tank_id**: 水箱ID
+    - **water_plant_output_id**: 水厂出水ID
+    - **time_delta**: 时间步长（秒，可选，默认300）
+    
+    用于优化供水排程。
+    """
     item = data.dict()
     return scheduling_simulation(
         item["network"],
@@ -410,8 +616,22 @@ async def fastapi_scheduling_analysis(data: SchedulingAnalysis) -> str:
     )
 
 
-@router.post("/daily_scheduling_analysis/")
-async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis) -> str:
+@router.post("/daily_scheduling_analysis/", summary="日排程分析", description="对管网的每日供水排程进行分析，优化水库、水厂、水箱和用户需求的协调，制定合理的每日排程方案。")
+async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis = Body(..., description="日排程分析参数")) -> str:
+    """
+    日排程分析
+    
+    请求体参数：
+    - **network**: 管网名称（或数据库名称）
+    - **start_time**: 分析开始时间
+    - **pump_control**: 泵控制策略字典
+    - **reservoir_id**: 水库ID
+    - **tank_id**: 水箱ID
+    - **water_plant_output_id**: 水厂出水ID
+    - **time_delta**: 时间步长（秒，可选，默认300）
+    
+    用于制定每日供水排程方案。
+    """
     item = data.dict()
     return daily_scheduling_simulation(
         item["network"],
@@ -423,8 +643,15 @@ async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis) -> st
     )
 
 
-@router.post("/network_project/")
-async def fastapi_network_project(file: UploadFile = File()) -> str:
+@router.post("/network_project/", summary="导入网络项目", description="通过上传INP格式的管网文件导入新的网络项目。系统将自动处理文件并执行模拟。")
+async def fastapi_network_project(file: UploadFile = File(..., description="INP格式的管网文件")) -> str:
+    """
+    导入网络项目
+    
+    - **file**: 上传的INP格式管网文件
+    
+    系统将上传的文件保存到inp文件夹并执行模拟。
+    """
     temp_file_dir = "./inp/"
     if not os.path.exists(temp_file_dir):
         os.mkdir(temp_file_dir)
@@ -435,13 +662,27 @@ async def fastapi_network_project(file: UploadFile = File()) -> str:
     return run_inp(temp_file_name)
 
 
-@router.get("/networkupdate/")
-async def network_update_endpoint(network: str):
+@router.get("/networkupdate/", summary="管网更新（基础）", description="对指定管网项目进行基础的更新操作。此为基础版本。")
+async def network_update_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")):
+    """
+    管网更新（基础版本）
+    
+    - **network**: 管网名称（或数据库名称）
+    
+    进行管网的基础更新操作。
+    """
     return network_update(network)
 
 
-@router.post("/network_update/")
-async def fastapi_network_update(file: UploadFile = File()) -> str:
+@router.post("/network_update/", summary="管网更新（高级）", description="通过上传更新文件对管网进行高级的更新操作。系统将处理更新文件并应用到数据库。")
+async def fastapi_network_update(file: UploadFile = File(..., description="包含管网更新信息的文件")) -> str:
+    """
+    管网更新（高级版本）
+    
+    - **file**: 包含管网更新信息的文件
+    
+    系统将处理上传的文件并应用管网更新。
+    """
     default_folder = "./"
     temp_file_name = f'network_update_{datetime.now().strftime("%Y%m%d")}'
     temp_file_path = os.path.join(default_folder, temp_file_name)
@@ -459,8 +700,17 @@ async def fastapi_network_update(file: UploadFile = File()) -> str:
 #     return pump_failure(network, pump_id, time)
 
 
-@router.post("/pump_failure/")
-async def fastapi_pump_failure(data: PumpFailureState) -> str:
+@router.post("/pump_failure/", summary="泵故障管理", description="记录和管理泵的故障状态，包括故障发生时间和受影响的泵列表。系统将记录故障日志并更新泵状态。")
+async def fastapi_pump_failure(data: PumpFailureState = Body(..., description="泵故障状态信息")) -> str:
+    """
+    泵故障管理
+    
+    请求体参数：
+    - **time**: 故障发生时间
+    - **pump_status**: 泵状态字典，包含第一阶段和第二阶段泵的故障状态
+    
+    系统将验证泵信息的有效性并更新故障状态文件。
+    """
     item = data.dict()
     with open("./pump_failure_message.txt", "a", encoding="utf-8-sig") as f1:
         f1.write("[{}] {}\n".format(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), item))
@@ -494,19 +744,46 @@ async def fastapi_pump_failure(data: PumpFailureState) -> str:
     return json.dumps("SUCCESS")
 
 
-@router.get("/pressuresensorplacementsensitivity/")
+@router.get("/pressuresensorplacementsensitivity/", summary="压力传感器放置-灵敏度分析（基础）", description="基于灵敏度分析方法，为指定管网项目确定最优的压力传感器放置位置。此为基础版本。")
 async def pressure_sensor_placement_sensitivity_endpoint(
-    name: str, scheme_name: str, sensor_number: int, min_diameter: int, username: str
+    name: str = Query(..., description="管网名称（或数据库名称）"),
+    scheme_name: str = Query(..., description="放置方案名称"),
+    sensor_number: int = Query(..., description="传感器数量"),
+    min_diameter: int = Query(..., description="最小管径限制（毫米）"),
+    username: str = Query(..., description="用户名"),
 ):
+    """
+    压力传感器放置-灵敏度分析（基础版本）
+    
+    - **name**: 管网名称（或数据库名称）
+    - **scheme_name**: 放置方案名称
+    - **sensor_number**: 传感器数量
+    - **min_diameter**: 最小管径限制（毫米）
+    - **username**: 用户名
+    
+    基于灵敏度分析方法确定传感器放置位置。
+    """
     return pressure_sensor_placement_sensitivity(
         name, scheme_name, sensor_number, min_diameter, username
     )
 
 
-@router.post("/pressure_sensor_placement_sensitivity/")
+@router.post("/pressure_sensor_placement_sensitivity/", summary="压力传感器放置-灵敏度分析（高级）", description="高级版本的压力传感器放置分析，通过JSON请求体提供详细参数。基于灵敏度分析方法确定最优放置位置。")
 async def fastapi_pressure_sensor_placement_sensitivity(
-    data: PressureSensorPlacement,
+    data: PressureSensorPlacement = Body(..., description="传感器放置分析参数"),
 ) -> None:
+    """
+    压力传感器放置-灵敏度分析（高级版本）
+    
+    请求体参数：
+    - **name**: 管网名称（或数据库名称）
+    - **scheme_name**: 放置方案名称
+    - **sensor_number**: 传感器数量
+    - **min_diameter**: 最小管径限制（毫米）
+    - **username**: 用户名
+    
+    基于灵敏度分析方法确定压力传感器的最优放置位置。
+    """
     item = data.dict()
     pressure_sensor_placement_sensitivity(
         name=item["name"],
@@ -517,19 +794,46 @@ async def fastapi_pressure_sensor_placement_sensitivity(
     )
 
 
-@router.get("/pressuresensorplacementkmeans/")
+@router.get("/pressuresensorplacementkmeans/", summary="压力传感器放置-KMeans聚类分析（基础）", description="基于KMeans聚类算法，为指定管网项目确定压力传感器的最优放置位置。此为基础版本。")
 async def pressure_sensor_placement_kmeans_endpoint(
-    name: str, scheme_name: str, sensor_number: int, min_diameter: int, username: str
+    name: str = Query(..., description="管网名称（或数据库名称）"),
+    scheme_name: str = Query(..., description="放置方案名称"),
+    sensor_number: int = Query(..., description="传感器数量"),
+    min_diameter: int = Query(..., description="最小管径限制（毫米）"),
+    username: str = Query(..., description="用户名"),
 ):
+    """
+    压力传感器放置-KMeans聚类分析（基础版本）
+    
+    - **name**: 管网名称（或数据库名称）
+    - **scheme_name**: 放置方案名称
+    - **sensor_number**: 传感器数量
+    - **min_diameter**: 最小管径限制（毫米）
+    - **username**: 用户名
+    
+    基于KMeans聚类算法确定传感器放置位置。
+    """
     return pressure_sensor_placement_kmeans(
         name, scheme_name, sensor_number, min_diameter, username
     )
 
 
-@router.post("/pressure_sensor_placement_kmeans/")
+@router.post("/pressure_sensor_placement_kmeans/", summary="压力传感器放置-KMeans聚类分析（高级）", description="高级版本的压力传感器放置分析，通过JSON请求体提供详细参数。基于KMeans聚类算法确定最优放置位置。")
 async def fastapi_pressure_sensor_placement_kmeans(
-    data: PressureSensorPlacement,
+    data: PressureSensorPlacement = Body(..., description="传感器放置分析参数"),
 ) -> None:
+    """
+    压力传感器放置-KMeans聚类分析（高级版本）
+    
+    请求体参数：
+    - **name**: 管网名称（或数据库名称）
+    - **scheme_name**: 放置方案名称
+    - **sensor_number**: 传感器数量
+    - **min_diameter**: 最小管径限制（毫米）
+    - **username**: 用户名
+    
+    基于KMeans聚类算法确定压力传感器的最优放置位置。
+    """
     item = data.dict()
     pressure_sensor_placement_kmeans(
         name=item["name"],
@@ -540,16 +844,31 @@ async def fastapi_pressure_sensor_placement_kmeans(
     )
 
 
-@router.post("/sensorplacementscheme/create")
+@router.post("/sensorplacementscheme/create", summary="传感器放置方案创建", description="创建新的传感器放置方案，支持灵敏度分析和KMeans聚类两种方法。根据指定的方法自动计算最优的传感器放置位置。")
 async def fastapi_pressure_sensor_placement(
-    network: str = Query(...),
-    scheme_name: str = Query(...),
-    sensor_type: str = Query(...),
-    method: str = Query(...),
-    sensor_count: int = Query(...),
-    min_diameter: int = Query(0),
-    user_name: str = Query(...),
+    network: str = Query(..., description="管网名称（或数据库名称）"),
+    scheme_name: str = Query(..., description="放置方案名称"),
+    sensor_type: str = Query(..., description="传感器类型"),
+    method: str = Query(..., description="放置方法（'sensitivity'或'kmeans'）"),
+    sensor_count: int = Query(..., description="传感器数量"),
+    min_diameter: int = Query(0, description="最小管径限制（毫米），默认0"),
+    user_name: str = Query(..., description="用户名"),
 ) -> str:
+    """
+    传感器放置方案创建
+    
+    - **network**: 管网名称（或数据库名称）
+    - **scheme_name**: 放置方案名称
+    - **sensor_type**: 传感器类型
+    - **method**: 放置方法（'sensitivity'或'kmeans'）
+    - **sensor_count**: 传感器数量
+    - **min_diameter**: 最小管径限制（毫米，默认0）
+    - **user_name**: 用户名
+    
+    支持两种放置方法：
+    - sensitivity: 基于灵敏度分析
+    - kmeans: 基于KMeans聚类
+    """
     if method not in ["sensitivity", "kmeans"]:
         raise HTTPException(
             status_code=400, detail="Invalid method. Must be 'sensitivity' or 'kmeans'"
@@ -573,67 +892,22 @@ async def fastapi_pressure_sensor_placement(
     return "success"
 
 
-@router.post("/scadadevicedatacleaning/")
-async def fastapi_scada_device_data_cleaning(
-    network: str = Query(...),
-    ids_list: List[str] = Query(...),
-    start_time: str = Query(...),
-    end_time: str = Query(...),
-    user_name: str = Query(...),
-) -> str:
-    item = {
-        "network": network,
-        "ids": ids_list,
-        "start_time": start_time,
-        "end_time": end_time,
-        "user_name": user_name,
-    }
-    query_ids_list = item["ids"][0].split(",")
-    scada_data = influxdb_api.query_SCADA_data_by_device_ID_and_timerange(
-        query_ids_list=query_ids_list,
-        start_time=item["start_time"],
-        end_time=item["end_time"],
-    )
-    scada_device_info = influxdb_api.query_pg_scada_info(item["network"])
-    scada_device_info_dict = {info["id"]: info for info in scada_device_info}
-    type_groups: dict[str, list[str]] = {}
-    for device_id in query_ids_list:
-        device_info = scada_device_info_dict.get(device_id, {})
-        device_type = device_info.get("type", "unknown")
-        type_groups.setdefault(device_type, []).append(device_id)
-    for device_type, device_ids in type_groups.items():
-        if device_type not in ["pressure", "pipe_flow"]:
-            continue
-        type_scada_data = {
-            device_id: scada_data[device_id]
-            for device_id in device_ids
-            if device_id in scada_data
-        }
-        if not type_scada_data:
-            continue
-        time_list = [record["time"] for record in next(iter(type_scada_data.values()))]
-        df = pd.DataFrame({"time": time_list})
-        for device_id in device_ids:
-            if device_id in type_scada_data:
-                values = [record["value"] for record in type_scada_data[device_id]]
-                df[device_id] = values
-        if device_type == "pressure":
-            cleaned_value_df = pressure_data_clean.clean_pressure_data_df_km(df)
-        elif device_type == "pipe_flow":
-            cleaned_value_df = flow_data_clean.clean_flow_data_df_kf(df)
-        cleaned_value_df = pd.DataFrame(cleaned_value_df)
-        cleaned_df = pd.concat([df["time"], cleaned_value_df], axis=1)
-        influxdb_api.import_multicolumn_data_from_dict(
-            data_dict=cleaned_df.to_dict("list"),
-            raw=False,
-        )
-    return "success"
-
-
-@router.post("/runsimulationmanuallybydate/")
+@router.post("/runsimulationmanuallybydate/", summary="手动运行日期指定模拟", description="根据指定的日期、开始时间和持续时间，手动运行水力模拟。系统将自动查询管网参数并执行模拟。")
 async def fastapi_run_simulation_manually_by_date(
-    data: RunSimulationManuallyByDate,
+    data: RunSimulationManuallyByDate = Body(..., description="模拟运行参数"),
 ) -> dict[str, str]:
+    """
+    手动运行日期指定模拟
+    
+    请求体参数：
+    - **name**: 管网名称（或数据库名称）
+    - **simulation_date**: 模拟基准日期（YYYY-MM-DD格式）
+    - **start_time**: 开始时间（HH:MM或HH:MM:SS格式）
+    - **duration**: 模拟持续时间（分钟）
+    
+    系统将从指定日期和时间开始，按15分钟间隔多次运行模拟。
+    每次模拟间隔15分钟，直至达到指定的总持续时间。
+    """
     item = data.dict()
     try:
         simulation.query_corresponding_element_id_and_query_id(item["name"])