更新 cli 命令，新增 network 其他元素的属性查询

cli/tests/unit/test_tjwater_cli.py

@@ -71,14 +71,14 @@ def test_auth_stdin_can_be_reused_with_runtime_context_cache(monkeypatch):
     def fake_request_json(ctx, **kwargs):
         observed_runtime_ids.append(id(ctx))
         assert ctx.auth.access_token == "token-1"
-        assert kwargs["params"] == {"network": "tjwater", "node": "11"}
-        return {"node": "11"}, 5
+        assert kwargs["params"] == {"network": "tjwater", "junction": "11"}
+        return {"id": "11"}, 5
 
     monkeypatch.setattr(common, "request_json", fake_request_json)
 
     result = runner.invoke(
         app,
-        ["--auth-stdin", "network", "get-node-properties", "--node", "11"],
+        ["--auth-stdin", "network", "get-junction-properties", "--junction", "11"],
         input=json.dumps(
             {
                 "server": "http://server",
@@ -93,37 +93,70 @@ def test_auth_stdin_can_be_reused_with_runtime_context_cache(monkeypatch):
 
     assert result.exit_code == 0
     assert payload["ok"] is True
-    assert payload["data"] == {"node": "11"}
+    assert payload["data"] == {"id": "11"}
     assert len(observed_runtime_ids) == 1
 
 
-def test_network_get_all_junction_properties_uses_network_context(monkeypatch):
+def test_network_get_junction_properties_uses_network_context(monkeypatch):
     captured = {}
 
     def fake_request_json(ctx, **kwargs):
         captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
         captured["params"] = kwargs["params"]
-        return [{"id": "J1"}], 5
+        return {"id": "J1"}, 5
 
     monkeypatch.setenv("TJWATER_SERVER", "http://server")
     monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
     monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
     monkeypatch.setattr(common, "request_json", fake_request_json)
 
-    result = runner.invoke(app, ["network", "get-all-junction-properties"])
+    result = runner.invoke(app, ["network", "get-junction-properties", "--junction", "J1"])
     payload = json.loads(result.stdout)
 
     assert result.exit_code == 0
     assert payload["ok"] is True
-    assert payload["data"] == [{"id": "J1"}]
-    assert captured == {"access_token": "abc", "params": {"network": "tjwater"}}
+    assert payload["data"] == {"id": "J1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getjunctionproperties/",
+        "params": {"network": "tjwater", "junction": "J1"},
+    }
 
 
-def test_network_get_all_pipe_properties_uses_network_context(monkeypatch):
+def test_network_get_pipe_properties_uses_network_context(monkeypatch):
     captured = {}
 
     def fake_request_json(ctx, **kwargs):
         captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return {"id": "P1"}, 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-pipe-properties", "--pipe", "P1"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == {"id": "P1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getpipeproperties/",
+        "params": {"network": "tjwater", "pipe": "P1"},
+    }
+
+
+def test_network_get_all_pipes_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
         captured["params"] = kwargs["params"]
         return [{"id": "P1"}], 5
 
@@ -132,13 +165,233 @@ def test_network_get_all_pipe_properties_uses_network_context(monkeypatch):
     monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
     monkeypatch.setattr(common, "request_json", fake_request_json)
 
-    result = runner.invoke(app, ["network", "get-all-pipe-properties"])
+    result = runner.invoke(app, ["network", "get-all-pipes-properties"])
     payload = json.loads(result.stdout)
 
     assert result.exit_code == 0
     assert payload["ok"] is True
     assert payload["data"] == [{"id": "P1"}]
-    assert captured == {"access_token": "abc", "params": {"network": "tjwater"}}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getallpipeproperties/",
+        "params": {"network": "tjwater"},
+    }
+
+
+def test_network_get_reservoir_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return {"id": "R1"}, 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-reservoir-properties", "--reservoir", "R1"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == {"id": "R1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getreservoirproperties/",
+        "params": {"network": "tjwater", "reservoir": "R1"},
+    }
+
+
+def test_network_get_all_reservoir_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return [{"id": "R1"}], 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-all-reservoirs-properties"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == [{"id": "R1"}]
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getallreservoirproperties/",
+        "params": {"network": "tjwater"},
+    }
+
+
+def test_network_get_tank_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return {"id": "T1"}, 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-tank-properties", "--tank", "T1"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == {"id": "T1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/gettankproperties/",
+        "params": {"network": "tjwater", "tank": "T1"},
+    }
+
+
+def test_network_get_all_tank_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return [{"id": "T1"}], 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-all-tanks-properties"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == [{"id": "T1"}]
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getalltankproperties/",
+        "params": {"network": "tjwater"},
+    }
+
+
+def test_network_get_pump_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return {"id": "PU1"}, 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-pump-properties", "--pump", "PU1"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == {"id": "PU1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getpumpproperties/",
+        "params": {"network": "tjwater", "pump": "PU1"},
+    }
+
+
+def test_network_get_all_pump_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return [{"id": "PU1"}], 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-all-pumps-properties"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == [{"id": "PU1"}]
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getallpumpproperties/",
+        "params": {"network": "tjwater"},
+    }
+
+
+def test_network_get_valve_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return {"id": "V1"}, 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-valve-properties", "--valve", "V1"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == {"id": "V1"}
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getvalveproperties/",
+        "params": {"network": "tjwater", "valve": "V1"},
+    }
+
+
+def test_network_get_all_valve_properties_uses_network_context(monkeypatch):
+    captured = {}
+
+    def fake_request_json(ctx, **kwargs):
+        captured["access_token"] = ctx.auth.access_token
+        captured["path"] = kwargs["path"]
+        captured["params"] = kwargs["params"]
+        return [{"id": "V1"}], 5
+
+    monkeypatch.setenv("TJWATER_SERVER", "http://server")
+    monkeypatch.setenv("TJWATER_ACCESS_TOKEN", "abc")
+    monkeypatch.setenv("TJWATER_NETWORK", "tjwater")
+    monkeypatch.setattr(common, "request_json", fake_request_json)
+
+    result = runner.invoke(app, ["network", "get-all-valves-properties"])
+    payload = json.loads(result.stdout)
+
+    assert result.exit_code == 0
+    assert payload["ok"] is True
+    assert payload["data"] == [{"id": "V1"}]
+    assert captured == {
+        "access_token": "abc",
+        "path": "/getallvalveproperties/",
+        "params": {"network": "tjwater"},
+    }
 
 
 def test_help_outputs_json_lists_commands():

cli/tjwater_cli/commands_readonly.py

@@ -10,56 +10,42 @@ from .core import CLIError, require_network
 from .option_types import ComponentOptionKind
 
 
-@network_app.command("get-node-properties")
-def network_get_node_properties(
+@network_app.command("get-junction-properties")
+def network_get_junction_properties(
     ctx: typer.Context,
-    node: Annotated[str, typer.Option("--node", help="节点 ID")],
+    junction: Annotated[str, typer.Option("--junction", help="节点 ID")],
 ) -> None:
     runtime = runtime_context(ctx)
     emit_api(
         ctx,
         summary="读取节点属性成功",
         method="GET",
-        path="/getnodeproperties/",
-        params={"network": require_network(runtime), "node": node},
+        path="/getjunctionproperties/",
+        params={"network": require_network(runtime), "junction": junction},
         require_auth=True,
         require_network_ctx=True,
     )
 
 
-@network_app.command("get-link-properties")
-def network_get_link_properties(
+@network_app.command("get-pipe-properties")
+def network_get_pipe_properties(
     ctx: typer.Context,
-    link: Annotated[str, typer.Option("--link", help="管线 ID")],
+    pipe: Annotated[str, typer.Option("--pipe", help="管道 ID")],
 ) -> None:
     runtime = runtime_context(ctx)
     emit_api(
         ctx,
-        summary="读取管线属性成功",
+        summary="读取管道属性成功",
         method="GET",
-        path="/getlinkproperties/",
-        params={"network": require_network(runtime), "link": link},
+        path="/getpipeproperties/",
+        params={"network": require_network(runtime), "pipe": pipe},
         require_auth=True,
         require_network_ctx=True,
     )
 
 
-@network_app.command("get-all-junction-properties")
-def network_get_all_junction_properties(ctx: typer.Context) -> None:
-    runtime = runtime_context(ctx)
-    emit_api(
-        ctx,
-        summary="读取全部节点属性成功",
-        method="GET",
-        path="/getalljunctionproperties/",
-        params={"network": require_network(runtime)},
-        require_auth=True,
-        require_network_ctx=True,
-    )
-
-
-@network_app.command("get-all-pipe-properties")
-def network_get_all_pipe_properties(ctx: typer.Context) -> None:
+@network_app.command("get-all-pipes-properties")
+def network_get_all_pipes_properties(ctx: typer.Context) -> None:
     runtime = runtime_context(ctx)
     emit_api(
         ctx,
@@ -72,6 +58,130 @@ def network_get_all_pipe_properties(ctx: typer.Context) -> None:
     )
 
 
+@network_app.command("get-reservoir-properties")
+def network_get_reservoir_properties(
+    ctx: typer.Context,
+    reservoir: Annotated[str, typer.Option("--reservoir", help="水库 ID")],
+) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取水库属性成功",
+        method="GET",
+        path="/getreservoirproperties/",
+        params={"network": require_network(runtime), "reservoir": reservoir},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-all-reservoirs-properties")
+def network_get_all_reservoir_properties(ctx: typer.Context) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取全部水库属性成功",
+        method="GET",
+        path="/getallreservoirproperties/",
+        params={"network": require_network(runtime)},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-tank-properties")
+def network_get_tank_properties(
+    ctx: typer.Context,
+    tank: Annotated[str, typer.Option("--tank", help="水箱 ID")],
+) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取水箱属性成功",
+        method="GET",
+        path="/gettankproperties/",
+        params={"network": require_network(runtime), "tank": tank},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-all-tanks-properties")
+def network_get_all_tank_properties(ctx: typer.Context) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取全部水箱属性成功",
+        method="GET",
+        path="/getalltankproperties/",
+        params={"network": require_network(runtime)},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-pump-properties")
+def network_get_pump_properties(
+    ctx: typer.Context,
+    pump: Annotated[str, typer.Option("--pump", help="水泵 ID")],
+) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取水泵属性成功",
+        method="GET",
+        path="/getpumpproperties/",
+        params={"network": require_network(runtime), "pump": pump},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-all-pumps-properties")
+def network_get_all_pump_properties(ctx: typer.Context) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取全部水泵属性成功",
+        method="GET",
+        path="/getallpumpproperties/",
+        params={"network": require_network(runtime)},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-valve-properties")
+def network_get_valve_properties(
+    ctx: typer.Context,
+    valve: Annotated[str, typer.Option("--valve", help="阀门 ID")],
+) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取阀门属性成功",
+        method="GET",
+        path="/getvalveproperties/",
+        params={"network": require_network(runtime), "valve": valve},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
+@network_app.command("get-all-valves-properties")
+def network_get_all_valve_properties(ctx: typer.Context) -> None:
+    runtime = runtime_context(ctx)
+    emit_api(
+        ctx,
+        summary="读取全部阀门属性成功",
+        method="GET",
+        path="/getallvalveproperties/",
+        params={"network": require_network(runtime)},
+        require_auth=True,
+        require_network_ctx=True,
+    )
+
+
 @component_option_app.command("schema")
 def component_option_schema(
     ctx: typer.Context,

cli/tjwater_cli/registry.py

@@ -34,31 +34,77 @@ HIDDEN_PATH_PREFIXES: tuple[tuple[str, ...], ...] = (
 )
 
 COMMAND_DOCS: dict[tuple[str, ...], CommandDoc] = {
-    ("network", "get-node-properties"): CommandDoc(
-        path=("network", "get-node-properties"),
+    ("network", "get-junction-properties"): CommandDoc(
+        path=("network", "get-junction-properties"),
         summary="读取节点属性",
-        description="调用 /getnodeproperties/。",
-        options=(CommandOptionDoc("node", "节点 ID", required=True),),
-        examples=("tjwater-cli network get-node-properties --node J1",),
+        description="调用 /getjunctionproperties/。",
+        options=(CommandOptionDoc("junction", "节点 ID", required=True),),
+        examples=("tjwater-cli network get-junction-properties --junction J1",),
     ),
-    ("network", "get-link-properties"): CommandDoc(
-        path=("network", "get-link-properties"),
-        summary="读取管线属性",
-        description="调用 /getlinkproperties/。",
-        options=(CommandOptionDoc("link", "管线 ID", required=True),),
-        examples=("tjwater-cli network get-link-properties --link P1",),
+    ("network", "get-pipe-properties"): CommandDoc(
+        path=("network", "get-pipe-properties"),
+        summary="读取管道属性",
+        description="调用 /getpipeproperties/。",
+        options=(CommandOptionDoc("pipe", "管道 ID", required=True),),
+        examples=("tjwater-cli network get-pipe-properties --pipe P1",),
     ),
-    ("network", "get-all-junction-properties"): CommandDoc(
-        path=("network", "get-all-junction-properties"),
-        summary="读取全部节点属性",
-        description="调用 /getalljunctionproperties/。",
-        examples=("tjwater-cli network get-all-junction-properties",),
-    ),
-    ("network", "get-all-pipe-properties"): CommandDoc(
-        path=("network", "get-all-pipe-properties"),
+    ("network", "get-all-pipes-properties"): CommandDoc(
+        path=("network", "get-all-pipes-properties"),
         summary="读取全部管道属性",
         description="调用 /getallpipeproperties/。",
-        examples=("tjwater-cli network get-all-pipe-properties",),
+        examples=("tjwater-cli network get-all-pipes-properties",),
+    ),
+    ("network", "get-reservoir-properties"): CommandDoc(
+        path=("network", "get-reservoir-properties"),
+        summary="读取水库属性",
+        description="调用 /getreservoirproperties/。",
+        options=(CommandOptionDoc("reservoir", "水库 ID", required=True),),
+        examples=("tjwater-cli network get-reservoir-properties --reservoir R1",),
+    ),
+    ("network", "get-all-reservoirs-properties"): CommandDoc(
+        path=("network", "get-all-reservoirs-properties"),
+        summary="读取全部水库属性",
+        description="调用 /getallreservoirproperties/。",
+        examples=("tjwater-cli network get-all-reservoirs-properties",),
+    ),
+    ("network", "get-tank-properties"): CommandDoc(
+        path=("network", "get-tank-properties"),
+        summary="读取水箱属性",
+        description="调用 /gettankproperties/。",
+        options=(CommandOptionDoc("tank", "水箱 ID", required=True),),
+        examples=("tjwater-cli network get-tank-properties --tank T1",),
+    ),
+    ("network", "get-all-tanks-properties"): CommandDoc(
+        path=("network", "get-all-tanks-properties"),
+        summary="读取全部水箱属性",
+        description="调用 /getalltankproperties/。",
+        examples=("tjwater-cli network get-all-tanks-properties",),
+    ),
+    ("network", "get-pump-properties"): CommandDoc(
+        path=("network", "get-pump-properties"),
+        summary="读取水泵属性",
+        description="调用 /getpumpproperties/。",
+        options=(CommandOptionDoc("pump", "水泵 ID", required=True),),
+        examples=("tjwater-cli network get-pump-properties --pump PU1",),
+    ),
+    ("network", "get-all-pumps-properties"): CommandDoc(
+        path=("network", "get-all-pumps-properties"),
+        summary="读取全部水泵属性",
+        description="调用 /getallpumpproperties/。",
+        examples=("tjwater-cli network get-all-pumps-properties",),
+    ),
+    ("network", "get-valve-properties"): CommandDoc(
+        path=("network", "get-valve-properties"),
+        summary="读取阀门属性",
+        description="调用 /getvalveproperties/。",
+        options=(CommandOptionDoc("valve", "阀门 ID", required=True),),
+        examples=("tjwater-cli network get-valve-properties --valve V1",),
+    ),
+    ("network", "get-all-valves-properties"): CommandDoc(
+        path=("network", "get-all-valves-properties"),
+        summary="读取全部阀门属性",
+        description="调用 /getallvalveproperties/。",
+        examples=("tjwater-cli network get-all-valves-properties",),
     ),
     ("component", "option", "schema"): CommandDoc(
         path=("component", "option", "schema"),