refactor(cli): split tjwater cli modules

cli/src/commands/analysis.ts

@@ -0,0 +1,199 @@
+import { CliError } from "../core/errors.js";
+import { emitApi, requestJson } from "../core/http.js";
+import { assignDatasetKeys, parseBurstFile, parseValveSettingFile } from "../core/files.js";
+import { optionalNumber, optionalString, optionalStringArray, parseOptions, requiredNumber, requiredString, validateChoice } from "../core/options.js";
+import { requireNetwork, requireUsername, resolveScheme } from "../core/runtime.js";
+import { parseTime } from "../core/time.js";
+import { success } from "../core/output.js";
+import type { HandlerMap, RuntimeContext } from "../core/types.js";
+
+function analysisBurst(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { duration: "integer" });
+  const [ids, sizes] = parseBurstFile(requiredString(values, "burst-file"));
+  const schemeName = resolveScheme(ctx, optionalString(values, "scheme"), true)!;
+  return emitApi(ctx, "爆管分析执行成功", {
+    method: "GET",
+    path: "/burst_analysis/",
+    params: {
+      network: requireNetwork(ctx),
+      modify_pattern_start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+      burst_ID: ids,
+      burst_size: sizes,
+      modify_total_duration: requiredNumber(values, "duration"),
+      scheme_name: schemeName,
+    },
+    requireNetworkCtx: true,
+  }, [`tjwater-cli data scheme get --name ${schemeName}`, "tjwater-cli data scheme list"]);
+}
+
+function analysisValve(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { valve: "repeat", element: "repeat", "disabled-valve": "repeat", duration: "integer" });
+  const mode = validateChoice(requiredString(values, "mode"), ["close", "isolation"] as const, "--mode");
+  if (mode === "close") {
+    const valves = optionalStringArray(values, "valve");
+    const startTime = optionalString(values, "start-time");
+    if (!startTime || !valves) throw new CliError("CLI 参数错误", "INVALID_VALVE_CLOSE_ARGS", "close mode requires --start-time and at least one --valve", 2);
+    return emitApi(ctx, "阀门关闭分析执行成功", {
+      method: "GET",
+      path: "/valve_close_analysis/",
+      params: {
+        network: requireNetwork(ctx),
+        start_time: parseTime(startTime, "--start-time"),
+        valves,
+        duration: optionalNumber(values, "duration") || 900,
+        scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+      },
+      requireNetworkCtx: true,
+    });
+  }
+  const elements = optionalStringArray(values, "element");
+  if (!elements) throw new CliError("CLI 参数错误", "INVALID_VALVE_ISOLATION_ARGS", "isolation mode requires at least one --element", 2);
+  return emitApi(ctx, "阀门隔离分析执行成功", {
+    method: "GET",
+    path: "/valve_isolation_analysis/",
+    params: { network: requireNetwork(ctx), accident_element: elements, disabled_valves: optionalStringArray(values, "disabled-valve") },
+    requireNetworkCtx: true,
+  });
+}
+
+function analysisFlushing(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { flow: "number", duration: "integer" });
+  const [valves, openings] = parseValveSettingFile(requiredString(values, "valve-setting-file"));
+  return emitApi(ctx, "冲洗分析执行成功", {
+    method: "GET",
+    path: "/flushing_analysis/",
+    params: {
+      network: requireNetwork(ctx),
+      start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+      valves,
+      valves_k: openings,
+      drainage_node_ID: requiredString(values, "drainage-node"),
+      flush_flow: requiredNumber(values, "flow"),
+      duration: optionalNumber(values, "duration") || 900,
+      scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+    },
+    requireNetworkCtx: true,
+  });
+}
+
+function analysisAge(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { duration: "integer" });
+  return emitApi(ctx, "水龄分析执行成功", {
+    method: "GET",
+    path: "/age_analysis/",
+    params: { network: requireNetwork(ctx), start_time: parseTime(requiredString(values, "start-time"), "--start-time"), duration: requiredNumber(values, "duration") },
+    requireNetworkCtx: true,
+  });
+}
+
+function analysisContaminant(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { duration: "integer", concentration: "number" });
+  const params: Record<string, unknown> = {
+    network: requireNetwork(ctx),
+    start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+    source: requiredString(values, "source-node"),
+    concentration: requiredNumber(values, "concentration"),
+    duration: requiredNumber(values, "duration"),
+    scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+  };
+  const pattern = optionalString(values, "pattern");
+  if (pattern) params.pattern = pattern;
+  return emitApi(ctx, "污染物模拟执行成功", { method: "GET", path: "/contaminant_simulation/", params, requireNetworkCtx: true });
+}
+
+function sensorKmeans(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { count: "integer", "min-diameter": "integer" });
+  return emitApi(ctx, "传感器选址执行成功", {
+    method: "POST",
+    path: "/pressure_sensor_placement_kmeans/",
+    body: {
+      name: requireNetwork(ctx),
+      scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+      sensor_number: requiredNumber(values, "count"),
+      min_diameter: optionalNumber(values, "min-diameter") || 0,
+      username: requireUsername(ctx),
+    },
+    requireNetworkCtx: true,
+    requireUsernameCtx: true,
+  });
+}
+
+function schemeAnalysis(ctx: RuntimeContext, argv: string[], summary: string, path: string, networkKey: string, startKey: string, endKey: string): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, summary, {
+    method: "POST",
+    path,
+    body: {
+      [networkKey]: requireNetwork(ctx),
+      [startKey]: parseTime(requiredString(values, "start-time"), "--start-time"),
+      [endKey]: parseTime(requiredString(values, "end-time"), "--end-time"),
+      scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+    },
+    requireNetworkCtx: true,
+  });
+}
+
+function schemeList(ctx: RuntimeContext, summary: string, path: string): Promise<void> {
+  return emitApi(ctx, summary, { method: "GET", path, params: { network: requireNetwork(ctx) }, requireNetworkCtx: true });
+}
+
+function schemeGet(ctx: RuntimeContext, argv: string[], summary: string, path: string): Promise<void> {
+  const { positionals } = parseOptions(argv);
+  if (!positionals[0]) throw new CliError("CLI 参数错误", "MISSING_ARGUMENT", "Missing argument 'SCHEME_NAME'", 2);
+  return emitApi(ctx, summary, { method: "GET", path: `${path}${positionals[0]}`, params: { network: requireNetwork(ctx) }, requireNetworkCtx: true });
+}
+
+function burstLocation(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { "burst-leakage": "number", "pressure-scada-id": "repeat", "flow-scada-id": "repeat", "use-scada-flow": "boolean" });
+  const body: Record<string, unknown> = {
+    network: requireNetwork(ctx),
+    scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+    data_source: optionalString(values, "data-source") || "monitoring",
+    scada_burst_start: parseTime(requiredString(values, "start-time"), "--start-time"),
+    scada_burst_end: parseTime(requiredString(values, "end-time"), "--end-time"),
+    burst_leakage: requiredNumber(values, "burst-leakage"),
+    use_scada_flow: Boolean(values["use-scada-flow"]),
+  };
+  const pressureIds = optionalStringArray(values, "pressure-scada-id");
+  const flowIds = optionalStringArray(values, "flow-scada-id");
+  if (pressureIds) body.pressure_scada_ids = pressureIds;
+  if (flowIds) body.flow_scada_ids = flowIds;
+  const pressureFile = optionalString(values, "pressure-file");
+  const flowFile = optionalString(values, "flow-file");
+  if (pressureFile) assignDatasetKeys(body, pressureFile, ["burst_pressure", "normal_pressure"], "pressure");
+  if (flowFile) assignDatasetKeys(body, flowFile, ["burst_flow", "normal_flow"], "flow");
+  return emitApi(ctx, "爆管定位执行成功", { method: "POST", path: "/burst-location/locate/", body, requireNetworkCtx: true });
+}
+
+function riskPipe(ctx: RuntimeContext, argv: string[], summary: string, path: string): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, summary, { method: "GET", path, params: { network: requireNetwork(ctx), pipe_id: requiredString(values, "pipe") }, requireNetworkCtx: true });
+}
+
+async function riskNetwork(ctx: RuntimeContext): Promise<void> {
+  const network = requireNetwork(ctx);
+  const [probabilities, a] = await requestJson(ctx, { method: "GET", path: "/getnetworkpiperiskprobabilitynow/", params: { network }, requireNetworkCtx: true });
+  const [geometries, b] = await requestJson(ctx, { method: "GET", path: "/getpiperiskprobabilitygeometries/", params: { network }, requireNetworkCtx: true });
+  success("读取全网风险成功", { probabilities, geometries }, ctx, a + b);
+}
+
+export const analysisHandlers: HandlerMap = {
+  "analysis burst": analysisBurst,
+  "analysis valve": analysisValve,
+  "analysis flushing": analysisFlushing,
+  "analysis age": analysisAge,
+  "analysis contaminant": analysisContaminant,
+  "analysis sensor-placement kmeans": sensorKmeans,
+  "analysis leakage identify": (ctx, argv) => schemeAnalysis(ctx, argv, "漏损识别执行成功", "/leakage/identify/", "network", "scada_start", "scada_end"),
+  "analysis leakage schemes list": (ctx) => schemeList(ctx, "读取漏损方案列表成功", "/leakage/schemes/"),
+  "analysis leakage schemes get": (ctx, argv) => schemeGet(ctx, argv, "读取漏损方案详情成功", "/leakage/schemes/"),
+  "analysis burst-detection detect": (ctx, argv) => schemeAnalysis(ctx, argv, "爆管检测执行成功", "/burst-detection/detect/", "network", "scada_start", "scada_end"),
+  "analysis burst-detection schemes list": (ctx) => schemeList(ctx, "读取爆管检测方案列表成功", "/burst-detection/schemes/"),
+  "analysis burst-detection schemes get": (ctx, argv) => schemeGet(ctx, argv, "读取爆管检测方案详情成功", "/burst-detection/schemes/"),
+  "analysis burst-location locate": burstLocation,
+  "analysis burst-location schemes list": (ctx) => schemeList(ctx, "读取爆管定位方案列表成功", "/burst-location/schemes/"),
+  "analysis burst-location schemes get": (ctx, argv) => schemeGet(ctx, argv, "读取爆管定位方案详情成功", "/burst-location/schemes/"),
+  "analysis risk pipe-now": (ctx, argv) => riskPipe(ctx, argv, "读取当前管道风险成功", "/getpiperiskprobabilitynow/"),
+  "analysis risk pipe-history": (ctx, argv) => riskPipe(ctx, argv, "读取历史管道风险成功", "/getpiperiskprobability/"),
+  "analysis risk network": riskNetwork,
+};

cli/src/commands/component.ts

@@ -0,0 +1,34 @@
+import { CliError } from "../core/errors.js";
+import { emitApi } from "../core/http.js";
+import { optionalString, parseOptions, requiredString, validateChoice } from "../core/options.js";
+import { requireNetwork } from "../core/runtime.js";
+import type { HandlerMap, RuntimeContext } from "../core/types.js";
+
+type ComponentKind = "time" | "energy" | "pump-energy" | "network";
+
+function componentOption(ctx: RuntimeContext, argv: string[], schema: boolean): Promise<void> {
+  const { values } = parseOptions(argv);
+  const kind = validateChoice(requiredString(values, "kind"), ["time", "energy", "pump-energy", "network"] as const, "--kind");
+  const routes: Record<`${ComponentKind}:${boolean}`, string> = {
+    "time:true": "/gettimeschema",
+    "time:false": "/gettimeproperties/",
+    "energy:true": "/getenergyschema/",
+    "energy:false": "/getenergyproperties/",
+    "pump-energy:true": "/getpumpenergyschema/",
+    "pump-energy:false": "/getpumpenergyproperties//",
+    "network:true": "/getoptionschema/",
+    "network:false": "/getoptionproperties/",
+  };
+  const params: Record<string, unknown> = { network: requireNetwork(ctx) };
+  const pump = optionalString(values, "pump");
+  if (kind === "pump-energy") {
+    if (!schema && !pump) throw new CliError("CLI 参数错误", "PUMP_REQUIRED", "--pump is required when --kind pump-energy", 2);
+    if (pump) params.pump = pump;
+  }
+  return emitApi(ctx, schema ? "读取选项 schema 成功" : "读取选项属性成功", { method: "GET", path: routes[`${kind}:${schema}`], params, requireNetworkCtx: true });
+}
+
+export const componentHandlers: HandlerMap = {
+  "component option schema": (ctx, argv) => componentOption(ctx, argv, true),
+  "component option get": (ctx, argv) => componentOption(ctx, argv, false),
+};

cli/src/commands/data.ts

@@ -0,0 +1,167 @@
+import { SCADA_FIELDS, type ElementType } from "../core/constants.js";
+import { CliError } from "../core/errors.js";
+import { emitApi } from "../core/http.js";
+import { fieldsFor, optionalString, parseOptions, requiredString, requiredStringArray, validateChoice } from "../core/options.js";
+import { requireNetwork, resolveScheme } from "../core/runtime.js";
+import { parseTime } from "../core/time.js";
+import type { HandlerMap, RuntimeContext } from "../core/types.js";
+
+function rangeGet(ctx: RuntimeContext, argv: string[], summary: string, path: string): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, summary, {
+    method: "GET",
+    path,
+    params: { start_time: parseTime(requiredString(values, "start-time"), "--start-time"), end_time: parseTime(requiredString(values, "end-time"), "--end-time") },
+    requireProject: true,
+  });
+}
+
+function realtimeByIdTime(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, "读取实时模拟数据成功", {
+    method: "GET",
+    path: "/realtime/query/by-id-time",
+    params: { id: requiredString(values, "id"), type: validateChoice(requiredString(values, "type"), ["pipe", "junction"] as const, "--type"), query_time: parseTime(requiredString(values, "time"), "--time") },
+    requireProject: true,
+  });
+}
+
+function realtimeByTimeProperty(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  const type = validateChoice(requiredString(values, "type"), ["pipe", "junction"] as const, "--type");
+  return emitApi(ctx, "读取实时属性聚合数据成功", {
+    method: "GET",
+    path: "/realtime/query/by-time-property",
+    params: { type, query_time: parseTime(requiredString(values, "time"), "--time"), property: validateChoice(requiredString(values, "property"), fieldsFor(type), "--property") },
+    requireProject: true,
+  });
+}
+
+function schemeLinks(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, "读取方案管道数据成功", {
+    method: "GET",
+    path: "/scheme/links",
+    params: {
+      scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+      scheme_type: optionalString(values, "scheme-type") || "simulation",
+      start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+      end_time: parseTime(requiredString(values, "end-time"), "--end-time"),
+    },
+    requireProject: true,
+  });
+}
+
+function schemeNodeField(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, "读取方案节点字段成功", {
+    method: "GET",
+    path: `/scheme/nodes/${requiredString(values, "node")}/field`,
+    params: {
+      field: validateChoice(requiredString(values, "field"), fieldsFor("junction"), "--field"),
+      scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+      scheme_type: optionalString(values, "scheme-type") || "simulation",
+      start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+      end_time: parseTime(requiredString(values, "end-time"), "--end-time"),
+    },
+    requireProject: true,
+  });
+}
+
+function schemeSimulation(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  const query = validateChoice(requiredString(values, "query"), ["by-id-time", "by-scheme-time-property"] as const, "--query");
+  const type = validateChoice(optionalString(values, "type") || "pipe", ["pipe", "junction"] as const, "--type") as ElementType;
+  const params: Record<string, unknown> = {
+    scheme_name: resolveScheme(ctx, optionalString(values, "scheme"), true),
+    scheme_type: optionalString(values, "scheme-type") || "simulation",
+    query_time: parseTime(requiredString(values, "time"), "--time"),
+    type,
+  };
+  if (query === "by-id-time") {
+    params.id = requiredString(values, "id");
+    return emitApi(ctx, "读取方案单点模拟数据成功", { method: "GET", path: "/scheme/query/by-id-time", params, requireProject: true });
+  }
+  params.property = validateChoice(requiredString(values, "property"), fieldsFor(type), "--property");
+  return emitApi(ctx, "读取方案属性聚合数据成功", { method: "GET", path: "/scheme/query/by-scheme-time-property", params, requireProject: true });
+}
+
+function scadaQuery(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { "device-id": "repeat" });
+  const params: Record<string, unknown> = {
+    device_ids: requiredStringArray(values, "device-id").join(","),
+    start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+    end_time: parseTime(requiredString(values, "end-time"), "--end-time"),
+  };
+  const field = optionalString(values, "field");
+  if (field) params.field = validateChoice(field, SCADA_FIELDS, "--field");
+  return emitApi(ctx, "读取 SCADA 时序成功", { method: "GET", path: field ? "/scada/by-ids-field-time-range" : "/scada/by-ids-time-range", params, requireProject: true });
+}
+
+function composite(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { feature: "repeat", "use-cleaned": "boolean" });
+  const kind = validateChoice(requiredString(values, "kind"), ["scada-simulation", "element-simulation", "element-scada"] as const, "--kind");
+  const params: Record<string, unknown> = {
+    start_time: parseTime(requiredString(values, "start-time"), "--start-time"),
+    end_time: parseTime(requiredString(values, "end-time"), "--end-time"),
+  };
+  const schemeName = resolveScheme(ctx, optionalString(values, "scheme"));
+  if (schemeName) Object.assign(params, { scheme_name: schemeName, scheme_type: optionalString(values, "scheme-type") || "simulation" });
+  if (kind === "scada-simulation") params.device_ids = requiredStringArray(values, "feature").join(",");
+  else if (kind === "element-simulation") params.feature_infos = requiredStringArray(values, "feature").join(",");
+  else {
+    const feature = requiredStringArray(values, "feature");
+    if (feature.length !== 1) throw new CliError("CLI 参数错误", "FEATURE_REQUIRED", "element-scada requires exactly one --feature as element_id", 2);
+    params.element_id = feature[0];
+    params.use_cleaned = Boolean(values["use-cleaned"]);
+  }
+  return emitApi(ctx, kind === "scada-simulation" ? "读取复合 SCADA-模拟数据成功" : kind === "element-simulation" ? "读取复合元素模拟数据成功" : "读取元素关联 SCADA 数据成功", { method: "GET", path: `/composite/${kind}`, params, requireProject: true });
+}
+
+function pipelineHealth(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  requiredString(values, "pipe");
+  requiredString(values, "start-time");
+  return emitApi(ctx, "读取管道健康预测成功", {
+    method: "GET",
+    path: "/composite/pipeline-health-prediction",
+    params: { network_name: requireNetwork(ctx), query_time: parseTime(requiredString(values, "end-time"), "--end-time") },
+    requireProject: true,
+    requireNetworkCtx: true,
+  });
+}
+
+function dataScadaGet(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  validateChoice(requiredString(values, "kind"), ["info"] as const, "--kind");
+  return emitApi(ctx, "读取 SCADA 数据成功", { method: "GET", path: "/getscadainfo/", params: { network: requireNetwork(ctx), id: requiredString(values, "id") }, requireNetworkCtx: true });
+}
+
+function dataScadaList(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  validateChoice(requiredString(values, "kind"), ["info"] as const, "--kind");
+  return emitApi(ctx, "读取 SCADA 列表成功", { method: "GET", path: "/getallscadainfo/", params: { network: requireNetwork(ctx) }, requireNetworkCtx: true });
+}
+
+function dataSchemeGet(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, "读取方案成功", { method: "GET", path: "/getscheme/", params: { network: requireNetwork(ctx), schema_name: requiredString(values, "name") }, requireNetworkCtx: true });
+}
+
+export const dataHandlers: HandlerMap = {
+  "data timeseries realtime links": (ctx, argv) => rangeGet(ctx, argv, "读取实时管道数据成功", "/realtime/links"),
+  "data timeseries realtime nodes": (ctx, argv) => rangeGet(ctx, argv, "读取实时节点数据成功", "/realtime/nodes"),
+  "data timeseries realtime simulation-by-id-time": realtimeByIdTime,
+  "data timeseries realtime simulation-by-time-property": realtimeByTimeProperty,
+  "data timeseries scheme links": schemeLinks,
+  "data timeseries scheme node-field": schemeNodeField,
+  "data timeseries scheme simulation": schemeSimulation,
+  "data timeseries scada query": scadaQuery,
+  "data timeseries composite": composite,
+  "data timeseries composite pipeline-health": pipelineHealth,
+  "data scada get": dataScadaGet,
+  "data scada list": dataScadaList,
+  "data scheme schema": (ctx) => emitApi(ctx, "读取方案 schema 成功", { method: "GET", path: "/getschemeschema/", params: { network: requireNetwork(ctx) }, requireNetworkCtx: true }),
+  "data scheme get": dataSchemeGet,
+  "data scheme list": (ctx) => emitApi(ctx, "读取方案列表成功", { method: "GET", path: "/getallschemes/", params: { network: requireNetwork(ctx) }, requireNetworkCtx: true }),
+};

cli/src/commands/network.ts

@@ -0,0 +1,27 @@
+import { emitApi } from "../core/http.js";
+import { parseOptions, requiredString } from "../core/options.js";
+import { requireNetwork } from "../core/runtime.js";
+import type { HandlerMap, RuntimeContext } from "../core/types.js";
+
+function legacyGet(ctx: RuntimeContext, argv: string[], summary: string, path: string, key: string): Promise<void> {
+  const { values } = parseOptions(argv);
+  return emitApi(ctx, summary, { method: "GET", path, params: { network: requireNetwork(ctx), [key]: requiredString(values, key) }, requireNetworkCtx: true });
+}
+
+function legacyGetAll(ctx: RuntimeContext, summary: string, path: string): Promise<void> {
+  return emitApi(ctx, summary, { method: "GET", path, params: { network: requireNetwork(ctx) }, requireNetworkCtx: true });
+}
+
+export const networkHandlers: HandlerMap = {
+  "network get-junction-properties": (ctx, argv) => legacyGet(ctx, argv, "读取节点属性成功", "/getjunctionproperties/", "junction"),
+  "network get-pipe-properties": (ctx, argv) => legacyGet(ctx, argv, "读取管道属性成功", "/getpipeproperties/", "pipe"),
+  "network get-all-pipes-properties": (ctx) => legacyGetAll(ctx, "读取全部管道属性成功", "/getallpipeproperties/"),
+  "network get-reservoir-properties": (ctx, argv) => legacyGet(ctx, argv, "读取水库属性成功", "/getreservoirproperties/", "reservoir"),
+  "network get-all-reservoirs-properties": (ctx) => legacyGetAll(ctx, "读取全部水库属性成功", "/getallreservoirproperties/"),
+  "network get-tank-properties": (ctx, argv) => legacyGet(ctx, argv, "读取水箱属性成功", "/gettankproperties/", "tank"),
+  "network get-all-tanks-properties": (ctx) => legacyGetAll(ctx, "读取全部水箱属性成功", "/getalltankproperties/"),
+  "network get-pump-properties": (ctx, argv) => legacyGet(ctx, argv, "读取水泵属性成功", "/getpumpproperties/", "pump"),
+  "network get-all-pumps-properties": (ctx) => legacyGetAll(ctx, "读取全部水泵属性成功", "/getallpumpproperties/"),
+  "network get-valve-properties": (ctx, argv) => legacyGet(ctx, argv, "读取阀门属性成功", "/getvalveproperties/", "valve"),
+  "network get-all-valves-properties": (ctx) => legacyGetAll(ctx, "读取全部阀门属性成功", "/getallvalveproperties/"),
+};

cli/src/commands/simulation.ts

@@ -0,0 +1,26 @@
+import { emitApi } from "../core/http.js";
+import { parseOptions, requiredNumber, requiredString } from "../core/options.js";
+import { requireNetwork } from "../core/runtime.js";
+import { addMinutesPreservingOffset, parseTime } from "../core/time.js";
+import type { HandlerMap, RuntimeContext } from "../core/types.js";
+
+function simulationRun(ctx: RuntimeContext, argv: string[]): Promise<void> {
+  const { values } = parseOptions(argv, { duration: "integer" });
+  const start = parseTime(requiredString(values, "start-time"), "--start-time");
+  const duration = requiredNumber(values, "duration");
+  const end = addMinutesPreservingOffset(start, duration);
+  const network = requireNetwork(ctx);
+  return emitApi(
+    ctx,
+    "触发模拟成功",
+    { method: "POST", path: "/runsimulationmanuallybydate/", body: { name: network, start_time: start.replace(/\.\d+/, ""), duration }, requireNetworkCtx: true },
+    [
+      `tjwater-cli data timeseries realtime links --start-time ${start} --end-time ${end}`,
+      `tjwater-cli data timeseries realtime nodes --start-time ${start} --end-time ${end}`,
+    ],
+  );
+}
+
+export const simulationHandlers: HandlerMap = {
+  "simulation run": simulationRun,
+};