/** * 基础设施模式四个二级面板的**领域与视图层**(票 17)。 * * 四块面板:基础档案 `archive` / 运行信息 `operation` / 管理信息 `management` / 应急保障 `emergency`。 * 本模块做两件事,两件都是纯函数(不 import service、不碰 DOM、不自己发请求): * 1. **契约适配**:后端四个面板级聚合读模型的载荷 → 领域对象(字段改名、缺失记账、码翻人话); * 2. **视图计划**:领域对象 → 组件可以直接画的块(KPI / 分布 / 键值行 / 条目列表 / 可定位对象)。 * * 票 18 起,**「块长什么样」与「码怎么翻」搬到 `domain/panelBlocks.js`**(票 17 判定四块共用一层 * 视图计划,票 18/19/20 沿用同一形状 —— 于是"构造一个块"只有一份实现,各票只写"放哪些块")。 * 本文件保留票 17 的全部对外导出名(含从 `panelBlocks.js` 转出的那几个), * 所以票 17 的 `verify/t17-infrastructure-panels.mjs` 一行都不用改。 * * 后端形状依据(`E:\pipe-ner-server`,逐类读过响应类与演示载荷): * `CockpitInfrastructureBaseArchivesResponse` / `...OperatingInformationResponse` / * `...ManagementInformationResponse` / `...EmergencySupportResponse`, * 演示载荷 `docs/cockpit/infrastructure-*-demo.html`。 * 注意四个切片的 BigDecimal 在演示载荷里是**字符串**(`"0.32"`),所以本层用 `numberish` * 宽进严出:数字与数字串都认,真 0 是有效值,认不出的回 null(占位符)。 */ import { fieldReader } from './fields.js' import { DETAIL_PLACEHOLDER } from './detailFlow.js' import { facilityStatusText, facilityStatusTone } from './entityDetail.js' import { FACILITY_DETAIL_CATEGORIES } from './facilityPoints.js' import { collectMissing, valueText } from './equipmentDetailView.js' import { industryLabel, normalizeDistrict, districtLabel } from './filterOptions.js' import { barsBlock, CARD_ACTION, childHasContent, codeText, dimensionBarsBlock, donutBlock, donutGridBlock, kpiBlock, listBlock, locateEntries, numberish, numberText, panelLocateEntries, panelMissingNote, ratioText, regionText, rowsBlock, sortByCountDesc, stackedBlock, trendBlock, sectionHasContent, sectionPlaceholder, sectionPending, supplementalBlock, } from './panelBlocks.js' // 票 67:运行信息三项能力的唯一口径来源(category 合计、行业范围与降级说明)。 import { OPERATING_SOURCE_NOTE, operatingCategoryCards, operatingScope } from './operatingMetricCaliber.js' // 票 100:台账行的派生字段惰性物化(6771 条指标 / 每页 10 条,没必要全算)。 import { lazyFields } from './lazyFields.js' // 票 100:`missing` 只按**领域对象的自有形状**收,不做全树深扫(见 `panelMissingFromSections`)。 import { collectDeclaredMissing, panelMissingFromSections } from './panelBlocks.js' // 票 18:这些工具已搬到 `panelBlocks.js`,这里**原样转出**,票 17 的既有导入点不受影响。 export { codeText, numberish, numberText, panelLocateEntries, ratioText, regionText, sectionHasContent, sectionPlaceholder, sectionPending, } /** 基础设施模式的四个 panelId(与 `domain/panelCatalog.js` 的目录一致,顺序即界面顺序)。 */ export const INFRASTRUCTURE_PANEL_IDS = ['archive', 'operation', 'management', 'emergency'] /** * 建成年限分桶 → 中文(时间轴语义,**不排序**:<5 → 5–10 → 10–20 → 20+ → 未知 是业务顺序)。 * 后端给的是码(UNDER_5_YEARS 等),码翻人话在这里做,渲染层不认识任何码。 */ const AGE_LABELS = Object.freeze({ UNDER_5_YEARS: '5 年以内', '5_TO_10_YEARS': '5–10 年', '10_TO_20_YEARS': '10–20 年', '20_YEARS_OR_OVER': '20 年以上', UNKNOWN: '未知', }) /** 码 → 色键(负荷状态用语义色,让"超载"在扫一眼时就能看见;认不出的回中性)。 */ function loadTone(loadState) { if (loadState === 'OVERLOAD') return 'lv1' if (loadState === 'WATCH') return 'lv2' if (loadState === 'NORMAL') return 'lv4' return 'neutral' } // ================================================================ 契约适配 /** * 分布行 → 视图行。 * * 注意 `Distribution` 是**三类维度共用**的一个结构(`category` / `industry` / `area` 三选一有值), * 所以取键的字段名必须按维度给,不能一律读 `code` —— 后端 `industryDistribution` 的行里 * `code` 是 null、值在 `industry` 上(见 `CockpitInfrastructureEmergencySupportService` * 的三个构造函数)。 * @param {Array} list 后端分布数组 * @param {string} keyField 该维度取值的字段名(`code` / `industry` / `area`) * @param {(value: string) => string} [toLabel] 取值 → 展示名 */ function distributionRows(list, keyField, toLabel) { return (Array.isArray(list) ? list : []).map((item) => { const reader = fieldReader(item, 'distribution') const value = reader.optionalStr(keyField) || reader.optionalStr('code') return { code: value, label: toLabel ? toLabel(value) : codeText(value), count: numberish(reader.raw.count) || 0 } }) } /** * 基础档案(`/infrastructure/base-archives`)→ 领域对象。 * 票 17 的四项:设施规模、行业分类、区域分布、档案摘要。 */ export function toBaseArchives(raw) { const reader = fieldReader(raw, 'baseArchives') const totals = fieldReader(reader.raw.totals, 'baseArchives.totals') const ageReference = fieldReader(reader.raw.ageReference, 'baseArchives.ageReference') return { updatedAt: reader.optionalStr('updatedAt'), rangeType: (reader.optionalObj('range') || {}).type || '', // 设施底数与里程(票 38:`totals.scale` 不再解析——真实后端恒 null,「规模」读数已删除) facilityCount: numberish(totals.raw.facilityCount), lengthKm: numberish(totals.raw.lengthKm), // 行业分类 / 区域分布 / 档案摘要(这三个分布的行都取值在 `code` 上) industries: distributionRows(reader.raw.industryDistribution, 'code', industryLabel), regions: reader.optionalList('districtDistribution').map((row) => ({ code: normalizeDistrict(row.district), label: districtLabel(row.district), count: numberish(row.count) })), ages: distributionRows(reader.raw.ageDistribution, 'code'), facilityTypes: (reader.raw.facilityTypeDistribution || []).map((item) => { const type = fieldReader(item, 'facilityType') return { code: type.optionalStr('code'), name: type.optionalStr('name') || type.optionalStr('code'), count: numberish(type.raw.count) || 0 } }), ageReference: { asOfDate: ageReference.optionalStr('asOfDate'), commissionedCount: numberish(ageReference.raw.commissionedCount), builtCount: numberish(ageReference.raw.builtCount), unknownCount: numberish(ageReference.raw.unknownCount), }, // 口径剔除:后端把"为什么没算进来"如实给出,界面照实说明(票 17 的"档案摘要"要能解释口径)。 excluded: { unknownTypeCount: numberish((reader.raw.excluded || {}).unknownTypeCount), typeKindMismatchCount: numberish((reader.raw.excluded || {}).typeKindMismatchCount), }, selectedIndustry: reader.optionalObj('selectedFilters') ? reader.raw.selectedFilters.industry || '' : '', missing: reader.missing, } } /** 单个运行指标 → 领域对象。 */ function toOperatingMetric(raw) { const reader = fieldReader(raw, 'operatingMetric') const freshness = fieldReader(reader.raw.freshness, 'operatingMetric.freshness') return { code: reader.optionalStr('metricCode'), name: reader.optionalStr('metricName') || reader.optionalStr('metricCode'), category: reader.optionalStr('category'), unit: reader.optionalStr('unit'), value: numberish(reader.raw.value), capacityValue: numberish(reader.raw.capacityValue), loadRatio: numberish(reader.raw.loadRatio), loadState: reader.optionalStr('loadState'), sampledAt: reader.optionalStr('sampledAt'), freshness: freshness.optionalStr('status'), ageSeconds: numberish(freshness.raw.ageSeconds), abnormal: reader.bool('abnormal', false), // 票 49 裁定:这里装的是**源设施编码**(水厂 plantCode / 泵站 stationCode / 管网 networkCode / // 排水设施 id),与一张图的监测点/设备编码空间结构性不重叠(后端将改名 `facilityCodes`)。 // 字段照契约透传(实测恒单元素),但**不再喂定位**——票 50 起运行信息面板不产定位入口。 pointCodes: reader.optionalList('pointCodes').map((item) => String(item)).filter(Boolean), facilityId: reader.optionalStr('facilityId'), facilityKind: reader.optionalStr('facilityKind'), // 维护者 2026-10-29:卡片状态必须与详情同步 —— 后端随指标下发设施状态码(0/1/2)。 facilityStatus: reader.optionalStr('facilityStatus'), missing: reader.missing, } } /** * 运行信息(`/infrastructure/operating-information`)→ 领域对象。 * 票 17 要求「供应、输送、承载能力和运行指标」—— 三类能力对应后端的 * `SUPPLY` / `FLOW` / `CAPACITY` 三个 `category`。(票 64:原措辞「指标占位」已按真实内容纠正。) */ export function toOperatingInformation(raw) { const reader = fieldReader(raw, 'operatingInformation') return { updatedAt: reader.optionalStr('updatedAt'), rangeType: (reader.optionalObj('range') || {}).type || '', rangeStart: (reader.optionalObj('range') || {}).start || '', rangeEnd: (reader.optionalObj('range') || {}).end || '', // 票 51:回显只留**码**(`{code,key,label}` 里 code 是稳定锚)—— 块选择用它定位对应块; // 未筛行业时后端回 null,这里如实回空串。 selectedIndustry: (reader.optionalObj('selectedIndustry') || {}).code || '', // 按行业分组:后端本来就是按行业聚合的(一个行业一块指标),这里保持后端顺序,不重排。 industries: reader .optionalList('industries') .map((item) => { const block = fieldReader(item, 'industryBlock') const industry = fieldReader(block.raw.industry, 'industryBlock.industry') const code = industry.optionalStr('code') // 实测后端对 MANHOLE 的 label 直接回英文码,所以先过前端行业词表; // 认不出的码才用后端 label,最后才回码 —— 接口词汇不上大屏(票 05/11 纪律)。 const label = industryLabel(code) || industry.optionalStr('label') || code || '' // 票 67:指标带上所属行业 —— 全部行业时清单逐行说明身份,卡片也能按行业解释来源。 const metrics = (block.raw.metrics || []).map((metric) => ({ ...toOperatingMetric(metric), industryCode: code, industryLabel: label, })) // 票 100:指标级的 `missing` 账本在**适配期**上收到行业块(逐条指标的缺失路径 // 去重后并进 `blockMissing`)。这样面板出口不必再对整棵载荷做深扫 // (6771 条 × 递归实测 ≈ 100 ms),而界面读到的仍是同一份去重清单。 const blockMissing = reader.missing.concat(collectDeclaredMissing(metrics)) return { code, label, state: block.optionalStr('state'), // 认不出的原因码回空串(接口词汇不上大屏,票 05/11 的教训)。 stateText: '', abnormalMetricCount: numberish(block.raw.abnormalMetricCount), metrics, missing: blockMissing, } }), excluded: { unknownIndustryCount: numberish((reader.raw.excluded || {}).unknownIndustryCount), nonFormalIndustryCount: numberish((reader.raw.excluded || {}).nonFormalIndustryCount), }, missing: reader.missing, } } /** * 排水行的雨污二级分项(维护者 2026-11-02):`networkLevelCounts[]` 只挂在 `industry=DRAINAGE` * 的行上,每项 `{ networkLevel, facilityCount }`。码位语义归前端的排水字典解释 * (0-污水 1-雨水,与 `entityDetail.js` 的 NETWORK_LEVEL_TEXT、`pipeVisual.js` 的管线配色同源)—— * 后端**不给名字**:`pipe_network_base.network_level` 存的是共享字典 `pipe_network_level`, * 对燃气是压力等级、对排水才是雨污,同一列跨行业语义不同,名字只能按行业给。 * * 「有没有」分得开:旧后端没有该字段 → 回 `null`(未知,画占位符); * 新后端给了空数组 → 真实 0(该行确实没有可解释等级的设施)。 */ function toNetworkLevelCounts(raw) { if (!Array.isArray(raw)) return null return raw .filter((item) => item && typeof item === 'object') .map((item) => ({ networkLevel: item.networkLevel == null ? '' : String(item.networkLevel).trim(), facilityCount: numberish(item.facilityCount) || 0, })) .filter((row) => row.networkLevel !== '') } /** 管理信息读模型:片区编码与行业计数,不消费已退役的机构/权属维度。 */ export function toManagementInformation(raw) { const reader = fieldReader(raw, 'managementInformation') const totals = fieldReader(reader.raw.totals, 'managementInformation.totals') return { updatedAt: reader.optionalStr('updatedAt'), facilityCount: numberish(totals.raw.facilityCount), equipmentCount: numberish(totals.raw.equipmentCount), districtIndustry: reader.optionalList('districtIndustry').map((item) => ({ district: normalizeDistrict(item.district), industry: typeof item.industry === 'string' ? item.industry : '', facilityCount: numberish(item.facilityCount), equipmentCount: numberish(item.equipmentCount), networkLevelCounts: toNetworkLevelCounts(item.networkLevelCounts), })), missing: reader.missing, } } /** 应急保障的一个条目 → 领域对象。 */ function toEmergencyItem(raw) { const reader = fieldReader(raw, 'emergencyItem') const associations = fieldReader(reader.raw.eventAssociations, 'emergencyItem.eventAssociations') return { code: reader.optionalStr('objectCode'), name: reader.optionalStr('objectName') || reader.optionalStr('objectCode'), category: reader.optionalStr('category'), industry: reader.optionalStr('industry'), area: reader.optionalStr('area'), pointCodes: reader.optionalList('pointCodes').map((item) => String(item)).filter(Boolean), warningCount: numberish(associations.raw.warningCount), alarmCount: numberish(associations.raw.alarmCount), workOrderCount: numberish(associations.raw.workOrderCount), missing: reader.missing, } } /** 应急保障的一个子分区(危险源 / 防护目标 / 应急资源各一块)。 */ function toEmergencySection(raw) { const reader = fieldReader(raw, 'emergencySection') return { state: reader.optionalStr('state'), stateReason: reader.optionalStr('stateReason'), items: (reader.raw.items || []).map(toEmergencyItem), } } /** * 应急保障(`/infrastructure/emergency-support`)→ 领域对象。 * 票 17 要求「危险源、防护目标和应急资源」—— 正好是后端的三个 section。 * **过期与不可用分得开**:后端 `UNAVAILABLE`(该段没取到)与 `EMPTY`(确实没有)是两回事。 */ export function toEmergencySupport(raw) { const reader = fieldReader(raw, 'emergencySupport') const totals = fieldReader(reader.raw.totals, 'emergencySupport.totals') const sections = fieldReader(reader.raw.sections, 'emergencySupport.sections') return { updatedAt: reader.optionalStr('updatedAt'), totals: { emergencyResourceCount: numberish(totals.raw.emergencyResourceCount), hazardSourceCount: numberish(totals.raw.hazardSourceCount), protectionTargetCount: numberish(totals.raw.protectionTargetCount), totalObjectCount: numberish(totals.raw.totalObjectCount), }, sections: { hazardSources: toEmergencySection(sections.raw.hazardSources), protectionTargets: toEmergencySection(sections.raw.protectionTargets), emergencyResources: toEmergencySection(sections.raw.emergencyResources), }, eventSummary: { warningCount: numberish((reader.raw.eventSummary || {}).warningCount), alarmCount: numberish((reader.raw.eventSummary || {}).alarmCount), workOrderCount: numberish((reader.raw.eventSummary || {}).workOrderCount), }, // 分布行按维度取键:行业族值在 `industry` 上,区域族值在 `area` 上(`code` 为 null)。 industries: distributionRows(reader.raw.industryDistribution, 'industry', industryLabel), areas: distributionRows(reader.raw.areaDistribution, 'area', regionText), selectedCategory: (reader.raw.selectedFilters || {}).category || '', missing: reader.missing, } } // ================================================================ 视图计划 /** * 片区固定四项(维护者第 16 轮):城南 / 城北 / 太常 / 未分区,**顺序与字典固定**。 * * 后端 `regions[]` 只回实际出现的片区(且顺序随数据),读者在不同时刻看到同一指标换位置。 * 片区是**固定字典**(码 0/1/2,其余归未分区),固定字典下缺项就是真实的 0 —— * 所以这里补齐四项并照实画 0(这不是「把没给的数据画成 0」:码位是确定的)。 */ function fixedDistrictRows(regions) { const list = Array.isArray(regions) ? regions : [] const buckets = [ { code: 0, label: '城南', count: 0 }, { code: 1, label: '城北', count: 0 }, { code: 2, label: '太常', count: 0 }, { code: null, label: '未分区', count: 0 }, ] for (const row of list) { const code = normalizeDistrict(row && row.code) const bucket = buckets.find((item) => item.code === code) || buckets[3] bucket.count += Number(row && row.count) || 0 } return buckets } /** * 基础档案面板视图。 * 验收四项:设施规模 / 行业分类 / 区域分布 / 档案摘要。 */ export function archivePanel(data, section) { const current = data || {} // 维护者 2026-10-29 视觉统一:类型分布用环/堆叠,对比分析用柱,时间维度用面积/折线; // 不再用一排同色横条把八类设施铺满(观感差、还占高度)。 const typeRows = sortByCountDesc( (current.facilityTypes || []).map((row) => ({ code: row.code, label: row.name, count: row.count })), (row) => row.count, ) const industryRows = sortByCountDesc(current.industries || [], (row) => row.count) // 维护者第 16 轮:片区分布改**固定四项**(城南 / 城北 / 太常 / 未分区)—— // 片区是固定字典(后端码 0/1/2,其余归未分区),随数据出现的顺序会让同行指标在 // 不同时刻换位置(读者对不上「上次那条」)。固定字典下 0 是**真实值**(确实没有), // 与「后端没给」分得开,所以照实画 0。 const regionRows = fixedDistrictRows(current.regions || []) const ageRows = current.ages || [] const blocks = [ // 票 38(第 2、4 条):删除「规模」KPI(真实后端 totals.scale 恒 null,是空读数); // 设施总数与管线里程回到**同一行**呈现 —— 渲染层不再有 lengthKm 独占整行的特判, // KPI 网格 auto-fit 让两项并排,不改变其它读数。 kpiBlock([ { key: 'facilityCount', label: '设施总数', value: valueText(current.facilityCount), unit: '处' }, { key: 'lengthKm', label: '管线里程', value: valueText(current.lengthKm), unit: 'km' }, ]), // 维护者第 15 轮补充:还原为上下两块(并排在窄面板里把图压得太小)。 // 另:原「设施类型分布」环与「设施类型构成」堆叠条表达同一份八类构成(重复)—— // 已删掉那张环,只留堆叠条(这条修改保留)。 donutBlock('行业分类', industryRows, { layout: 'compact' }), // 维护者第 16 轮:八类设施要「对不同颜色做出更明显的区分」—— 声明 `distinct`, // 按行序取八个互不相近的色相(默认语义色里排水/供水/燃气之外都落进同一族蓝)。 stackedBlock('设施类型构成', typeRows, { distinct: true }), // 维护者第 16 轮:片区分布改**饼图**(四个固定片区的构成比),图例带横置柱状条 // 给直观对比(`legendBar`);环心合计=本面板片区口径的设施总数。 donutBlock('片区分布', regionRows, { legendBar: true }), // 时间维度 → 面积折线(年限是固定分桶,靠顺序读"新老结构",不排序)。 trendBlock('建成年限结构', ageRows.map((row) => ({ key: row.code, label: AGE_LABELS[row.code] || codeText(row.code), count: row.count, })), { chart: 'line' }), ] return { name: 'archive', label: '基础档案', section, hasContent: sectionHasContent(section), blocks, // 基础档案端点**不给逐设施的编码与坐标**(只有聚合分布),所以本面板没有可定位对象。 locate: [], locateNote: '基础档案是聚合分布口径(后端不返回逐设施坐标),本面板没有可定位对象', missing: panelMissingNote(current), placeholder: sectionPlaceholder(section), } } /** * 票 64:运行指标列表**页码归属的筛选条件标识**(翻页复位判据的输入,不是页码本身)。 * * 为什么要有这个串:规范条文 5/6 要求「条件变化 → 页码回第 1 页;定时刷新不复位」, * 而视图计划在这两种情况下**都会**重算出新块对象——按对象身份判条件变没变, * 会把每次刷新都读成换筛选(票 43 第四轮记过的同一条教训:别拿对象当键)。 * 所以由 domain 给一个跨刷新稳定的标量:当前行业块 + 全局片区键。 * 换行业/换片区 ⇒ 串变 ⇒ 渲染层清掉该块页码(回第 1 页);周期刷新(同一筛选)⇒ 串不变 ⇒ 页码保持。 * **切走再切回也算一次条件变化**(同样回第 1 页)——所以这个串只当**判据**用, * 不编进页码归属键:编进键会让切回时读到上次留下的旧槽位(条文 6 不许)。 * * `extra.scope` 由外壳传入(与台账徽标、饼图选中态同一个 extra 通道); * 缺失或不是字符串时回空串——不拿脏值造出一个会漂移的假作用域。 */ function operationPageScope(scope, extra) { const district = extra && typeof extra.scope === 'string' ? extra.scope : '' // 票 67:全部行业的键是 'ALL'(不是空串),所以「全部 ↔ 单行业」切换一定换槽位、回第 1 页。 return `${scope.key || scope.code || ''}|${district}` } /** * 票 73(维护者 2026-10-23 裁定 A):指标行标题带设施编码。 * * 为什么必须带:同页 10 行 `metricName` 全同(燃气首屏第 2–10 行连读数都是 1.00 m、 * `loadState`/`freshness` 也全同),行上唯一能分开它们的身份就是设施编码 * (票 49 裁定的 `pointCodes`,实测 6362 条恒单元素)。标题仍是**单源**:只在本函数拼, * 渲染层不拼第二份。缺编码时退回指标名——不留「 · 」悬空分隔符。 * * **编码在前、指标名在后**(维护者 2026-10-23 追加裁定):`.panel-item__title` 是单行 * nowrap + 共用省略,省略号切的是**文本尾部**——把 16 字符编码放在指标名后面, * 恰好把唯一可辨识的尾号切掉(票 73 首次实施实测反馈「最后几位隐藏,显示不直观」)。 * 编码放最前则无论栏多窄都先保住身份,指标名放后面(同页同名时它本就重复,被省略不损失信息)。 */ function metricTitle(metric) { const facilityCode = (metric.pointCodes || [])[0] || '' return facilityCode ? `${facilityCode} · ${metric.name}` : metric.name } /** 设施详情类别必须由摘要显式给出;未知类别不猜、不下钻错误表。 */ function facilityDetailCategory(metric) { const explicit = String(metric.facilityKind || metric.facilityType || '').trim().toUpperCase() return FACILITY_DETAIL_CATEGORIES.includes(explicit) ? explicit : '' } const EMERGENCY_DETAIL_CATEGORY = Object.freeze({ hazardSources: 'HAZARD', protectionTargets: 'PROTECTION_TARGET', emergencyResources: 'EMERGENCY_RESOURCE', }) /** * 运行信息面板视图。 * 验收四项:供应 / 输送 / 承载能力 + **运行指标**(票 64:原措辞「指标占位」是占位期遗留词, * 实际内容是真实指标清单;真实数据 6772 条/2.3 MB 已证伪「契约有界」,本块接入统一分页)。 * * **票 67 重做三项能力**:旧实现从每个 category 里取"第一条指标"当读数,而每条指标其实 * 对应**一个设施**(管网按段逐条)—— 于是"承载能力"显示的是某一段管道的 1.03 m; * 未筛行业时又直接取 `industries[0]`(燃气),所以「全部行业」看起来只有燃气数据。 * 现在范围判定与合计口径都收在 `domain/operatingMetricCaliber.js`: * · 单行业 → 只统计该行业块; * · 全部行业 → 跨所有有指标的行业块合计,并列出实际参与的行业; * · 后端只回一个块(忽略"全部")→ 如实说"仅统计××",不假称全部(降级路径)。 */ /** * 运行信息「设施数量」读数(维护者 2026-10-29)。 * * 口径:运行信息端点每条指标对应**一个设施**(管网按段逐条),所以按 `facilityKind` 计数 * 就是设施数量,不需要第二套聚合。四项是维护者点名的:管段 / 水厂 / 水源地 / 用水户 / 泵站。 * * 诚实边界:本端点当前只产出 PIPE_NETWORK / WATER_PLANT / PUMP_STATION / ENGINEERING_FACILITY; * 水源地(WATER_SOURCE)与用水户(WATER_USER)在这里**没有数据**,卡片按占位符 + 说明呈现, * 不拿别的类型凑数(缺口写进面板的 gap)。 * * @param {Array} metrics `operatingScope()` 交出的指标行(带 `facilityKind`) * @returns {Array} 五张 KPI 卡(管段独占一行) */ /** * 运行信息「设施台账」的**一行**(票 100 惰性化)。 * * 为什么要惰性:本端点一次回 6771 条指标,而清单块每页只画 10 条(`PAGE_SIZE`)。 * 旧实现把每一条都整套物化(含 `identityPayload: { ...metric }` 深拷贝、meta 数组、 * tone 文案),真机实测整体 ≈ 92–100 ms,其中深拷贝占 ≈ 65 ms —— 面板视图 miss 一次 * (切模式 / 换筛选 / 30s 刷新)就是单帧 350–400 ms 的卡顿(维护者报的"特别卡"残余)。 * 派生字段只在**被画出来**时才需要,所以这里只固化标量/身份字段, * 其余交给 `lazyFields`:第一次读才算,未渲染的行零成本。 * * 字段语义一字不改(惰性只改"什么时候算",不改"算什么")—— t67b 的 rows 断言照常成立。 * * @param {object} metric `toOperatingMetric()` 交出的指标 * @param {number} index 该行业块内序号(只用于保证块内行键唯一) * @param {object} scope `operatingScope()` 的判定结果(`allView` / `code`) * @returns {object} 面板清单行 */ function operatingLedgerRow(metric, index, scope) { const category = facilityDetailCategory(metric) // 身份字段是**点击分派**的判据(`cardActionFor` 直接读),必须现在就定下来: // 它是标量/布尔,成本可忽略,而且不物化会造成"卡片能不能点"随渲染时机变化。 const row = { // 票 64:键必须块内唯一(真实载荷里同一 metricCode 整块碰撞,cardAction 是 keyed v-for)。 // 票 67:全部行业时同一 metricCode 跨行业重复,行业也编进键。 key: `${metric.industryCode || scope.code || ''}|${metric.code || ''}|${index}`, identityKind: CARD_ACTION.FACILITY, facilityLocate: Boolean(metric.facilityId && category), identityCode: category ? metric.facilityId || '' : '', identityCategory: category, identityReason: category ? (metric.facilityId ? '' : '缺少设施主键,无法展开') : '设施类别未发布,无法展开详情', // 票 50:指标行**不产出定位点**(`points` 恒空)。`pointCodes` 实为源设施编码(票 49 裁定), // 不进一张图对象序列,画按钮就是「不可达做成常态」+ 撞名假阳性(PS001/PS002 会飞向 // 不相干的排水监测点)。「没有可定位对象就不画按钮」由这里的构造保证。 points: [], } // 下面这些都是纯派生(只由这一条 metric 决定),所以可以安全惰性化。 return lazyFields(row, { // 票 73 裁定 A:标题带设施编码且**编码在前**(同页十行同名;编码放后面会被省略号切掉尾号)。 title: () => metricTitle(metric), // 维护者 2026-10-29:卡片状态与详情**同一份**设施状态(正常/异常), // 不再各显示各的。后端没给状态时退回负荷态标签(不编造设施状态)。 tone: () => (metric.facilityStatus ? facilityStatusTone(metric.facilityStatus) : loadTone(metric.loadState)), toneLabel: () => (metric.facilityStatus ? facilityStatusText(metric.facilityStatus) || codeText(metric.loadState) : codeText(metric.loadState)), meta: () => [ // 票 67:全部行业时逐行补行业名,否则清单看不出这一行属于哪个行业。 scope.allView ? metric.industryLabel || '' : '', `当前 ${numberText(metric.value, metric.unit)}`, `能力 ${numberText(metric.capacityValue, metric.unit)}`, `负荷 ${ratioText(metric.loadRatio)}`, codeText(metric.loadState), codeText(metric.freshness), metric.abnormal ? '异常' : '', ].filter(Boolean), // 详情预填:只有**点开**这张卡时才被 `cardActionFor` 之后的 handler 取走, // 没点过的行永远不构造。`entityDetailStore.show()` 自己会再浅拷一份,所以这里 // 不必担心共享引用被下游改写。 identityPayload: () => ({ ...metric, category, industry: metric.industryCode || scope.code, status: metric.facilityStatus }), }) } /** * 运行信息「设施数量」读数的来源与口径(维护者 2026-10-29 改版后的话术)。 * * 与 OPERATING_SOURCE_NOTE(三项能力合计的口径)并存但**不混用**:那一段描述的是 * 「同类设施读数合计」,本段描述的是「按设施实体逐条计数」——两者口径不同, * 界面现在只展示后者,所以摘要读这一段。 */ export const OPERATING_FACILITY_SOURCE_NOTE = '设施数量由后端按设施实体逐条下发(水厂、泵站、管网、排水设施各一条),前端只做按类别计数,不做第二套聚合。' + '「管段数量」数的是管网类设施条数(一段管网一条记录),与「基础档案」的设施类型分布同源;' + '「水厂」「泵站」按设施类别计数。' + '水源地与用水户当前不在本端点的下发范围内,读数按占位符呈现,不拿别的类别凑数。' export function operatingFacilityCards(metrics, extra = {}) { const list = Array.isArray(metrics) ? metrics : [] // 设施类别优先取后端的 facilityKind;老载荷/测试样例没有这个字段时按 metricCode 后缀兜底 // (口径模块已登记四类后缀,这里是同一套词,不新造第二份映射)。 const kindOf = (row) => { const explicit = String((row && row.facilityKind) || '').toUpperCase() if (explicit) return explicit const code = String((row && row.code) || '') if (code.endsWith('pipe_network_length')) return 'PIPE_NETWORK' if (code.endsWith('water_plant_current_supply')) return 'WATER_PLANT' if (code.endsWith('pump_station_design_flow')) return 'PUMP_STATION' if (code.endsWith('point_count')) return 'ENGINEERING_FACILITY' return '' } const countOf = (kinds) => list.filter((row) => kinds.includes(kindOf(row))).length const hasKind = (kinds) => list.some((row) => kinds.includes(kindOf(row))) const pipes = countOf(['PIPE_NETWORK']) const plants = countOf(['WATER_PLANT']) const pumps = countOf(['PUMP_STATION', 'DRAINAGE_PUMP_STATION']) const sources = hasKind(['WATER_SOURCE']) ? countOf(['WATER_SOURCE']) : null const users = hasKind(['WATER_USER']) ? countOf(['WATER_USER']) : null // 窨井数量(维护者 2026-10-29):本端点**没有**窨井指标(MANHOLE 块实测 state=EMPTY、0 条), // 所以不在这里硬造一个 0;由外壳从**基础设施档案目录**(与「基础档案」同一份目录)搬进来, // 与「设施数量与基础档案同源」这条口径一致。拿不到(档案分区空/失败)就回 null → 占位符。 const manholeCount = typeof extra.manholeCount === 'number' && Number.isFinite(extra.manholeCount) ? extra.manholeCount : null return [ { key: 'pipeSegmentCount', label: '管段数量', value: valueText(pipes), unit: '段', caption: '管网按段逐条统计', accent: 'info' }, { key: 'manholeCount', label: '窨井数量', value: valueText(manholeCount), unit: '座', caption: '取自基础设施档案目录', hint: manholeCount === null ? '基础设施档案目录未取到,窨井数量暂不可用' : '', }, { key: 'waterPlantCount', label: '水厂', value: valueText(plants), unit: '座' }, { key: 'waterSourceCount', label: '水源地', value: valueText(sources), unit: '处', hint: sources === null ? '本端点不提供水源地指标,数量见基础档案的设施类型分布' : '' }, { key: 'waterUserCount', label: '用水户', value: valueText(users), unit: '户', hint: users === null ? '后端尚未提供用水户台账,读数留空' : '' }, { key: 'pumpStationCount', label: '泵站', value: valueText(pumps), unit: '座' }, ] } export function operationPanel(data, section, extra) { const current = data || {} const scope = operatingScope(current.industries || [], current.selectedIndustry) const metrics = scope.metrics const blocks = [ // 维护者 2026-10-29:指标改为「管段数量 + 窨井数量(并排一行)+ 水厂/水源地/用水户/泵站(1×2×2)」; // 「承载能力=管网长度合计」删除 —— 与基础档案重复,且不是运行读数。 kpiBlock(operatingFacilityCards(metrics, extra), { layout: 'two-by-two' }), listBlock( // 维护者 2026-10-29:标题由「运行指标」改为「设施台账」—— // 这本来就是**按设施逐条**的清单(一条指标对应一个设施),叫台账比叫指标准确, // 也与上方「管段/水厂/水源地/用水户/泵站」那组设施读数同一套词。 '设施台账', // 票 100:行**惰性物化**。真实载荷 6771 条、每页只画 10 条(`PAGE_SIZE`), // 旧实现把每条的派生字段(identityPayload 深拷贝 / meta / tone 文案)全算一遍 // ⇒ 单次视图构建 ≈ 92–100 ms,面板 miss 一次就是单帧 350–400 ms 的卡顿。 // 现在只固化标量身份字段,派生字段第一次被读才计算(见 `operatingLedgerRow`)。 metrics.map((metric, index) => operatingLedgerRow(metric, index, scope)), '当前行业没有设施台账', // 票 64:本块接入统一分页(规范条文 1/2/4 + 跳页节)。**为什么这里必须声明**: // 同一个 list 渲染分支服务多处清单,其中应急保障三段另有专票(63); // 票 66 起管理信息已没有清单块(多环统计取代了它)。只有 domain 逐块声明, // 渲染层才知道该不该切窗口。 // 行序不改(票 10/11 立场:前端不重排),分页只切展示窗口。 // `pageScope`=页码归属的筛选条件标识:换行业/换片区时它变,页码自然回第 1 页; // 定时刷新时它不变,页码保持(条文 6)。翻页算术与控件都在单源 // (`domain/pagination.js` + `PagerNav.vue`),本层只声明「这一块要分页、按什么条件归页」。 { paginate: true, pageScope: operationPageScope(scope, extra) }, ), ] return { name: 'operation', label: '运行信息', section, hasContent: sectionHasContent(section), blocks, // 窨井数量取自**基础档案目录**(本端点没有窨井指标,见上面 operatingFacilityCards 的注释): // 本分区为空时它仍可能是真值,不能被空态一起抹成占位符(维护者 2026-11-12 实测: // 同一屏基础档案显示「窨井 3」,这里却显示「—」)。 retainedKeys: ['manholeCount'], // 票 67 要求 4:说清"当前统计的是哪个行业范围"——全部时列出实际参与的行业, // 后端只回一个块时如实降级为"仅统计××"。 industryNote: scope.note, // 维护者 2026-10-29:读数已从「三项能力」改成设施数量 —— 来源说明同步改口 // (旧那段描述的是供应/输送/承载合计,它说的读数现在已经不在屏上了)。 sourceNote: OPERATING_FACILITY_SOURCE_NOTE, // 票 50:定位入口整体撤下(locate 恒空)。该面板的关联编码是**设施**编码、不进一张图对象序列, // 对它跑 `locateEntries` 就是「不可达做成常态 + 撞名假阳性」;正确的对象交互**在图上**—— // 管段/设施构件拾取走既有「重点对象局部增强」(pipeEnhancement,票 32),本票不动那条链路。 locate: [], locateNote: '指标关联的是设施编码(水厂/泵站/管网/排水设施),不在一张图的点位序列里,本面板没有可定位对象;管段与设施构件请在图上拾取(地下管线详情视图)', // 票 100:只读领域对象自己的 `missing` 账本(分区 + 各行业块,指标级已在适配期上收), // 不再对整棵载荷做深扫 —— 6771 条指标深扫实测 ≈ 100 ms,扫的仍是同一份清单。 missing: panelMissingFromSections([current, ...(current.industries || [])]), placeholder: sectionPlaceholder(section), } } /** 片区统计的展示次序:片区字典序固定(未分区永远是最后一档)。 */ const DISTRICT_SUMMARY_ORDER = [0, 1, 2, null] /** 行业在环上的固定次序:后端四个正式行业;认不出的行业排在最后。 */ const INDUSTRY_SUMMARY_ORDER = ['GAS', 'WATER_SUPPLY', 'DRAINAGE', 'MANHOLE'] /** 统计投影里「未分区」与「未知行业」的稳定键(键进断言、名进界面,两不混)。 */ const UNASSIGNED_KEY = 'UNASSIGNED' const UNKNOWN_INDUSTRY_KEY = 'UNKNOWN' /** 片区排序位:未分区排在三个正式片区之后。 */ function districtRank(key) { if (key === UNASSIGNED_KEY) return DISTRICT_SUMMARY_ORDER.length const index = DISTRICT_SUMMARY_ORDER.findIndex((value) => value !== null && String(value) === key) return index === -1 ? DISTRICT_SUMMARY_ORDER.length : index } /** 行业排序位:认不出的行业排在四个正式行业之后。 */ function industryRank(code) { const index = INDUSTRY_SUMMARY_ORDER.indexOf(code) return index === -1 ? INDUSTRY_SUMMARY_ORDER.length : index } /** 按给定排序位稳定排序(并列时保持插入次序,不靠引擎的排序稳定性)。 */ function orderByRank(entries, rankOf) { return entries .map((entry, index) => ({ entry, index })) .sort((a, b) => rankOf(a.entry) - rankOf(b.entry) || a.index - b.index) .map((item) => item.entry) } /** * 「片区 × 行业」计数的统计投影(票 66)。 * * 为什么单独成纯函数:多环分片与指标卡都从这**一份**聚合里出,图与读数就不可能各算一套; * 而且这一段要能被脱浏览器断言 —— 乱序、缺字段、全 0、只有设备没有设施、只有设施没有设备 * 五种形状都是票面的验收输入。 * * 三条口径: * · **宽容输入**:非数组、空行、字段缺失一律跳过或按 0 计,不抛错;认不出的行业码不丢 * (归到「未知」一档,不猜成四类之一); * · **次序固定**:片区按 城南/城北/太常/未分区,行业按 燃气/供水/排水/窨井 —— 次序进断言, * 也让跨行业各环的扇区色能按同一份图例稳定下来; * · **环只画设施**:设施与设备单位不同,不混进同一个环;设备进各环/图例的悬停明细与读数。 * * 「覆盖片区」与「覆盖行业」数的是**至少有一处设施或一台设备**的正式片区/行业; * 未分区是数据质量桶,单独出一个读数,不算「覆盖到的片区」。 * * @param {Array} rows 管理信息的 districtIndustry 行(每行一个片区×行业组合) * 两条**轴是固定的**(与数据无关):图例=四个片区档(含未分区),环的骨架=四个正式行业。 * 轴固定的理由见下面 `districtRows` 与 `industryAxis` 的注释 —— 筛选态下轴跟着数据走, * 会让「未分区」「城北」凭空消失;空态下则连结构都不剩(票 72 不许)。 * * @returns {{facilityTotal: number, equipmentTotal: number, districtCount: number, industryCount: number, unassignedFacility: number, unassignedEquipment: number, districtRows: Array, industryRings: Array, industryAxis: Array}} */ export function districtIndustrySummary(rows) { const list = Array.isArray(rows) ? rows : [] const districts = new Map() const industries = new Map() let facilityTotal = 0 let equipmentTotal = 0 for (const row of list) { if (!row || typeof row !== 'object') continue const district = normalizeDistrict(row.district) const districtKey = district === null ? UNASSIGNED_KEY : String(district) const industry = typeof row.industry === 'string' ? row.industry.trim() : '' const industryKey = industry || UNKNOWN_INDUSTRY_KEY const facility = numberish(row.facilityCount) || 0 const equipment = numberish(row.equipmentCount) || 0 facilityTotal += facility equipmentTotal += equipment let districtEntry = districts.get(districtKey) if (!districtEntry) { districtEntry = { key: districtKey, label: districtLabel(district), facilityCount: 0, equipmentCount: 0 } districts.set(districtKey, districtEntry) } districtEntry.facilityCount += facility districtEntry.equipmentCount += equipment let industryEntry = industries.get(industryKey) if (!industryEntry) { industryEntry = { key: industryKey, code: industry, label: industryLabel(industry) || codeText(industry), facilityCount: 0, equipmentCount: 0, byDistrict: new Map(), } industries.set(industryKey, industryEntry) } industryEntry.facilityCount += facility industryEntry.equipmentCount += equipment industryEntry.byDistrict.set(districtKey, (industryEntry.byDistrict.get(districtKey) || 0) + facility) } const orderedDistricts = orderByRank([...districts.values()], (entry) => districtRank(entry.key)) const orderedIndustries = orderByRank([...industries.values()], (entry) => industryRank(entry.code)) const coversAny = (entry) => entry.facilityCount + entry.equipmentCount > 0 const unassigned = districts.get(UNASSIGNED_KEY) return { facilityTotal, equipmentTotal, // 覆盖数只数正式片区/行业:未分区单列,不冒充「覆盖到的片区」。 districtCount: orderedDistricts.filter((entry) => entry.key !== UNASSIGNED_KEY && coversAny(entry)).length, industryCount: orderedIndustries.filter(coversAny).length, unassignedFacility: unassigned ? unassigned.facilityCount : 0, unassignedEquipment: unassigned ? unassigned.equipmentCount : 0, // 共用图例:**固定四档片区轴**(城南/城北/太常/未分区),行上的计数是 // **该片区全部行业的设施合计**(与环内扇区不同层,块标题小字已写明)。 // 为什么是固定轴而不是「有数据才出」:票 66 第 4 条要求「未分区」如实展示、不隐藏; // 而接口按行业/片区筛选后只会回**部分行**(实测 `industry=GAS` 只回城南与太常两行), // 若图例跟着行走,未分区与城北会在筛选态凭空消失,看起来像数据丢了。固定轴把它们 // 如实画成 0(内置环形图的老规矩:0 计数保留图例、不占扇区)。 districtRows: DISTRICT_SUMMARY_ORDER.map((district) => { const entry = districts.get(district === null ? UNASSIGNED_KEY : String(district)) const facilityCount = entry ? entry.facilityCount : 0 const equipmentCount = entry ? entry.equipmentCount : 0 return { key: district === null ? UNASSIGNED_KEY : String(district), label: districtLabel(district), count: facilityCount, tone: district === null ? 'neutral' : '', hint: '设施 ' + facilityCount + ' 处 · 设备 ' + equipmentCount + ' 台', } }), // 环:一个行业一个环。票 66 第 4 条 —— 该行业设施计数全 0 时整块不出(不画空环)。 industryRings: orderedIndustries .filter((entry) => entry.facilityCount > 0) .map((entry) => ({ key: entry.key, label: entry.label, unit: '处', hint: '设施 ' + entry.facilityCount + ' 处 · 设备 ' + entry.equipmentCount + ' 台', // 每个环都按**同一份**固定片区轴出扇区:0 计数的片区不画扇区,但图例里仍在(见上)。 slices: DISTRICT_SUMMARY_ORDER.map((district) => ({ key: district === null ? UNASSIGNED_KEY : String(district), label: districtLabel(district), count: entry.byDistrict.get(district === null ? UNASSIGNED_KEY : String(district)) || 0, })), })), // 环的固定轴(四个正式行业):只在**没有任何数据**时用来保设计骨架(票 72: // 失败/空态也画结构,只把数值位换成占位符)。有数据时环集合由真实行业决定。 industryAxis: INDUSTRY_SUMMARY_ORDER.map((code) => ({ key: code, label: industryLabel(code) || codeText(code) })), } } /** * 管理信息面板(票 38 第 6 条;票 66 改统计形态)。 * * 三块: * 1. KPI 读数 —— 总设施 / 总设备 / 覆盖片区 / 覆盖行业 / 未分区设施; * 2. 主图 —— 可切换维度的分类柱状图(按片区 / 按行业两维,domain 各聚合一遍,切换纯展示、不回后端); * 3. **多环形统计** —— 一个行业一个环,环内扇区是该行业在**各片区**的设施占比、环心是该行业合计, * 块底一份共用图例(各片区设施合计)。它取代了旧版「片区 × 行业明细」的卡片清单: * 管理信息要回答的是「这个行业主要落在哪个片区」,不是逐行列数。 * * 为什么环形按**行业**分片(票 66 要求二选一并说明理由): * · 读者是片区管理方,一个环回答一个问题(这个行业在各片区的分布),环心直接给该行业总量; * · 反过来按片区分片会**少一个环**:城北当前没有设施(0 处),按片区分片时城北整块不出, * 看起来像「城北不存在」;按行业分片时城北只是没有扇区,固定片区轴上仍如实列出 0(不隐藏); * · 扇区色因此与全站同一套行业语义色对齐(燃气/供水/排水/窨井);换到片区维度就只剩图表色序。 * * 口径不变(票 66 第 5 条):设施计数与「基础档案」同源;设备计数只含能归入四类的监测设备。 * 设施与设备**单位不同、不混进同一个环**:环只画设施,设备在读数、柱状图悬停说明与环/图例的 * 悬停明细里给(实测 12 台设备对 6776 处设施,混画会让环完全被设施支配)。 * 只消费 `districtIndustry[]`;已退役的 `organizations`/`ownershipDistribution`/`unmaintained` 不再读取。 * 「责任区域」=片区别名(决策 06),不新增独立维度。 */ /** * 排水行的雨污拆分读数(维护者 2026-11-02)。 * * 「有没有」与「是多少」分得开,沿用面板取数的老纪律(不把「后端没给」画成 0): * · 范围里**没有排水行**(行业筛到别处)→ 真实 0,与燃气/供水的 `sumOf` 同一语义; * · 有排水行但**任一行缺二级分项**(旧后端没下发该字段)→ 回 `null`=未知, * 卡片画占位符、面板 gap 照旧交代缺口; * · 全部排水行都带分项 → 按码位求和(0-污水 1-雨水,语义归前端排水字典)。 * * @param {Array} rows `districtIndustry[]`(领域行,`networkLevelCounts` 已归一为数组或 null) * @returns {{available: boolean, sewage: number, rainwater: number}|null} null=分项不可得 */ export function drainageLevelSplit(rows) { // 输入不是数组(分区还没就绪 / 脏输入)=未知,与「空范围」分得开。 if (!Array.isArray(rows)) return null const drainageRows = rows .filter((row) => String((row && row.industry) || '') === 'DRAINAGE') if (!drainageRows.length) return { available: true, sewage: 0, rainwater: 0 } if (!drainageRows.every((row) => Array.isArray(row.networkLevelCounts))) return null const sumOf = (level) => drainageRows.reduce((total, row) => { const hit = row.networkLevelCounts.find((item) => item.networkLevel === level) return total + (hit ? hit.facilityCount || 0 : 0) }, 0) return { available: true, sewage: sumOf('0'), rainwater: sumOf('1') } } /** * 管理信息「设施」读数(维护者 2026-10-29):只统计设施,不再出现设备口径。 * * 四类管段来自 `districtIndustry[]` 的行业分项 —— 燃气/供水/排水/窨井各自的设施数。 * 维护者要的四项是「燃气管段 / 供水管段 / 污水管段 / 雨水管段」(维护者 2026-11-02 起四项全真值): * · 燃气管段、供水管段 ← GAS / WATER_SUPPLY 两个行业的设施数(与基础档案同源); * · 污水/雨水管段 ← 排水行自带的雨污二级分项(`networkLevelCounts`,见 `drainageLevelSplit`); * 分项只覆盖能认出等级的排水管线,与「排水设施合计」的差值(泵站等非管线设施)在 * 雨水卡说明里如实交代,不强行补齐。 * * @param {Array} rows `districtIndustry[]` * @returns {Array} 四张 KPI 卡(2×2) */ export function managementFacilityCards(rows) { const list = Array.isArray(rows) ? rows : [] const sumOf = (code) => (list.length ? list.filter((row) => String(row.industry || '') === code).reduce((sum, row) => sum + (numberish(row.facilityCount) || 0), 0) : null) const gas = sumOf('GAS') const water = sumOf('WATER_SUPPLY') const drainage = sumOf('DRAINAGE') const split = drainageLevelSplit(list) return [ { key: 'gasFacilityCount', label: '燃气管段', value: valueText(gas), unit: '处' }, { key: 'waterFacilityCount', label: '供水管段', value: valueText(water), unit: '处' }, { key: 'sewageFacilityCount', label: '污水管段', value: valueText(split ? split.sewage : null), unit: '处', hint: split ? '按排水管线的雨污二级分类计数' : '本端点暂未提供雨污分项' }, { key: 'rainwaterFacilityCount', label: '雨水管段', value: valueText(split ? split.rainwater : null), unit: '处', hint: split ? '按排水管线的雨污二级分类计数;排水设施合计 ' + valueText(drainage) + ' 处(含泵站等非管线设施)' : '本端点暂未提供雨污分项;排水设施合计 ' + valueText(drainage) + ' 处' }, ] } export function managementPanel(data, section) { const current = data || {} const rows = current.districtIndustry || [] const summary = districtIndustrySummary(rows) // 雨污分项可用性决定 gap 措辞:拿得到就不再喊「后端没有拆分」(那是撒谎), // 拿不到(旧后端)才如实交代缺口 —— 措辞纪律:只说业务含义,不出现接口字段名。 const split = drainageLevelSplit(rows) const blocks = [ // 维护者 2026-10-29:管理信息**只统计设施**(设备口径归监测模式), // 「设施总数」与基础档案重复也已删除;改为四类管段的设施数,2×2 排列。 kpiBlock(managementFacilityCards(rows), { layout: 'two-by-two' }), // 主图:按片区 / 按行业切换的分类柱状图(主计数=设施数;悬停也只看设施)。 dimensionBarsBlock('片区 × 行业', rows, { countOf: (row) => row.facilityCount, hintOf: (row) => `设施 ${valueText(row.facilityCount)} 处`, unit: '处', emptyText: '当前范围没有片区与行业计数', dimensions: [ { key: 'district', label: '按片区', field: 'district', emptyLabel: '未分区', labelOf: (value) => districtLabel(value) }, { key: 'industry', label: '按行业', field: 'industry', emptyLabel: '行业未知', labelOf: (value) => industryLabel(value) || codeText(value) }, ], }), // 多环形统计(票 66):取代旧版「片区 × 行业明细」卡片清单。 // 边界(复核提出,如实写在这里):筛到「只有设备、没有设施」的片区时(如 district=1), // 环集合为空、也没有可比的扇区比例,块走 emptyText 而不是硬画四档 0 图例 —— // 固定片区轴只在**确有设施计数**时承载「同一颜色 = 同一片区」的比较语义。 // 另:主图柱状图的轴仍按数据行聚合(0 的片区不出柱),与本图例的固定档位是两种语义 // —— 柱状图是排名(没数据不占位),环形图例是图例(档位固定才读得出一致颜色)。 donutGridBlock('片区 × 行业 · 按行业分片', summary.industryRings, { legend: summary.districtRows, axis: summary.industryAxis, unit: '处', emptyText: '当前范围没有设施计数', }), ] return { name: 'management', label: '管理信息', section, hasContent: sectionHasContent(section), blocks, // 票 68(维护者 2026-10-19 反馈第 3 条):公开「这些数从哪来、覆盖什么范围、与别处为何对得上」。 // 票 66 随形态一并改写:旧的「一行一个组合」清单说明随清单一起去掉,不留旧措辞。 // 措辞纪律:只说业务含义与范围,**不出现接口字段名** —— 读者是值班人员,不是接口调用方。 sourceNote: '设施计数取自基础设施档案目录(与「基础档案」是同一份目录、同一批设施实体);片区取档案里登记的片区,没有登记的落「未分区」,如实列出、不隐藏。污水/雨水管段按排水管线的雨污二级分类计,泵站等非管线排水设施不参与拆分。', // 维护者 2026-11-02:雨污分项已由端点下发 —— 只有旧后端(没下发)才保留缺口句。 gap: split ? '' : '当前服务端未提供排水的雨污分项,因此「污水管段 / 雨水管段」暂不给出单项读数;排水设施合计可在「片区 × 行业」块按行业维度读到。', locate: [], locateNote: '片区与行业计数为聚合口径,本面板没有可定位对象', missing: panelMissingNote(current), placeholder: sectionPlaceholder(section), } } /** * 应急保障三段 → 条目列表块(每段的 state 决定它是内容、空还是不可用)。 * * **票 63(批次五)**:三段接入统一分页(规范条文 1/2/4 的前端集合形态)。 * 真实数据已证明这不是空转——实测 `protectionTargets` **20 条**(两页)、 * `emergencyResources` 9 条、`hazardSources` 0 条;20 条那一段此前是一屏 20 张卡。 * * 三条纪律落在这里: * 1. **三段各自独立页码**:`pageScope` 带上段标识(`hazardSources`/`protectionTargets`/ * `emergencyResources`),翻危险源的页不会动到防护目标 —— 渲染层的页码槽按 * 「面板名 + 块标题」寻址,标题本来就不同,但把段码写进 `pageScope` 才是 * 真正按段复位的依据(换筛选时三段一起回第 1 页)。 * 2. **段内行次序不动**:`pagedRows` 只切窗口,不排序(票 10/11 立场)。 * 3. **定位按钮不受影响**:`points` 挂在被窗口化之后的行上,翻到第 2 页看到的是 * 第 11–20 条的定位按钮,行为与翻页前完全一致。 * * `stateText` 语义不变(`UNAVAILABLE`/`EMPTY` 分得开,且**优先于**空列表提示渲染)。 * @param {string} label 段标题(也是渲染层页码槽的键之一) * @param {object} child 该段的后端分区 * @param {string} emptyText 空态文案 * @param {string} sectionKey 段码(`sections` 上的键;用于 `pageScope` 与断言面) */ function emergencySectionBlock(label, child, emptyText, sectionKey) { const items = (child && child.items) || [] const rows = items.map((item) => ({ key: item.code, title: item.name, identityKind: CARD_ACTION.EMERGENCY, identityCode: item.code, identityCategory: EMERGENCY_DETAIL_CATEGORY[sectionKey] || '', identityPayload: { ...item, category: EMERGENCY_DETAIL_CATEGORY[sectionKey] || item.category }, identityReason: item.code ? '' : '缺少对象编码,无法展开', meta: [ codeText(item.category), industryLabel(item.industry) || codeText(item.industry), regionText(item.area), item.alarmCount ? `报警 ${item.alarmCount}` : '', item.warningCount ? `预警 ${item.warningCount}` : '', item.workOrderCount ? `工单 ${item.workOrderCount}` : '', ].filter(Boolean), points: item.pointCodes.map((pointCode) => ({ key: `${item.code}|${pointCode}`, label: item.name, pointCode, objectCode: item.code, objectName: item.name, })), })) return { ...listBlock(label, childHasContent(child && child.state) ? rows : [], emptyText, { // 前端集合分页:数据已一次装齐,pager 只切窗口、零请求。 paginate: true, // 页码归属键=段码 + 全局条件:换行业/片区/类别时三段一起回第 1 页, // 定时刷新(条件不变)页码保持(条文 5/6)。标量键,不接受对象身份(票 43 教训)。 pageScope: emergencySectionScope(sectionKey, child), }), // 该段自己的成败(后端 `UNAVAILABLE` 与 `EMPTY` 分得开,界面也说得出区别)。 state: (child && child.state) || '', stateText: child && child.state === 'UNAVAILABLE' ? '该段数据未取到' : child && child.state === 'EMPTY' ? '该段当前没有对象' : '', // 断层面:段码 + 该段真实条数(走查与闸门按段取数,不靠标题字符串猜)。 sectionKey, total: rows.length, } } /** * 应急保障某一段的**页码归属键**(票 63)。 * * 只用**标量**:段码 + 该段收到的条数 + 筛选回显(类别/行业/片区)。 * 不把行内容/对象身份编进来——视图计划每次重算都是新对象,按对象记会让每次刷新 * 都读成"换了筛选"(票 43 第四轮记过的教训,票 64 又踩过一次)。 * 条数也进键:同一段的数据**变短**时(例如换类别后从 20 条降到 3 条), * 页码槽跟着换,越界自然回到第 1 页,不用另外写一条夹回逻辑。 * @param {string} sectionKey 段码 * @param {object} child 该段分区(提供条数与 state) */ function emergencySectionScope(sectionKey, child) { const count = ((child && child.items) || []).length return `${sectionKey || ''}|${count}|${(child && child.state) || ''}` } /** * 应急保障面板视图。 * 验收三项:危险源 / 防护目标 / 应急资源 —— 后端的三个 section 正好对应。 */ export function emergencyPanel(data, section) { const current = data || {} const sections = current.sections || {} const blocks = [ kpiBlock([ { key: 'hazardSourceCount', label: '危险源', value: valueText(current.totals && current.totals.hazardSourceCount), unit: '处' }, { key: 'protectionTargetCount', label: '防护目标', value: valueText(current.totals && current.totals.protectionTargetCount), unit: '处' }, { key: 'emergencyResourceCount', label: '应急资源', value: valueText(current.totals && current.totals.emergencyResourceCount), unit: '项' }, ]), emergencySectionBlock('危险源', sections.hazardSources, '没有危险源对象', 'hazardSources'), emergencySectionBlock('防护目标', sections.protectionTargets, '没有防护目标', 'protectionTargets'), emergencySectionBlock('应急资源', sections.emergencyResources, '没有应急资源', 'emergencyResources'), barsBlock('区域分布', sortByCountDesc(current.areas || [], (row) => row.count)), ] const allItems = ['hazardSources', 'protectionTargets', 'emergencyResources'].flatMap((key) => ((sections[key] || {}).items || []).map((item) => ({ item, key })), ) // 票 68(维护者 2026-10-19 反馈第 3 条):应急保障也要说清「这些对象从哪来」。 // 关联编码的说明是**条件句**(不只写当前实测):真实接口的三类对象目前一律不带编码 // (后端适配器对三类对象都下发空列表,票 49 已记),所以界面此刻没有可定位对象—— // 但这句话不能写成恒真的「没有编码」,否则后端日后真给出编码时文案就开始撒谎。 const anyPointCode = allItems.some(({ item }) => (item.pointCodes || []).length > 0) const pointCodeNote = anyPointCode ? '对象带的关联编码是设施编码(不是一张图的监测点编码),可据此在图上查找对应设施。' : '对象带的关联编码是设施编码(不是一张图的监测点编码);当前三类对象都没有带编码,所以本面板没有可定位对象。' return { name: 'emergency', label: '应急保障', section, hasContent: sectionHasContent(section), blocks, locate: allItems.flatMap(({ item }) => locateEntries(item.code, item.name, { code: item.code, name: item.name }, item.pointCodes), ), // 票 68 更正:原文案「关联点位可定位」在两处站不住——① 真实数据没有可定位对象(点了没东西); // ② 这些编码是**设施**编码(票 49 裁定),叫「点位」会把设施说成监测点。改为按实测条件如实说。 locateNote: anyPointCode ? '三类对象带的关联编码是设施编码(不是一张图的监测点编码),定位按该编码在图上查找对应设施' : '三类对象当前都没有关联设施编码,本面板没有可定位对象', // 票 68:三段各自的业务来源 + 关联编码语义 + 关联事件口径(三段各一句,逐句可核)。 // 措辞纪律:只说业务含义与范围,**不出现接口字段名**(读者是值班人员,不是接口调用方)。 sourceNote: [ '三类对象来自各自的业务台账、不合并:应急资源=设备台账里的监测设备;防护目标=燃气风险评估里登记的防护目标;危险源=隐患台账里能关联到设备的隐患(关联不到设备的不计入,所以这一段为空不等于隐患库为空)。', pointCodeNote, '关联事件=对象所在设备上尚未解除的预警、尚未关闭的报警与未结束的工单,按对象逐条加总(同一台设备的事件可能同时计在设备对象与它关联的危险源上),不是全城去重后的事件总数;只有能回联到设备的对象才有这类计数,防护目标不挂设备,它的关联事件恒为 0。', ].join(''), // 关联事件总量是后端给的口径,界面照实带出(不自己加总)。 eventNote: current.eventSummary ? `关联事件:预警 ${valueText(current.eventSummary.warningCount)} · 报警 ${valueText(current.eventSummary.alarmCount)} · 工单 ${valueText(current.eventSummary.workOrderCount)}` : '', missing: panelMissingNote(current), placeholder: sectionPlaceholder(section), } } /** panelId → 视图构造函数(本模式自己的四块)。 */ export const INFRASTRUCTURE_PANEL_BUILDERS = { archive: archivePanel, operation: operationPanel, management: managementPanel, emergency: emergencyPanel, } /** * 一个面板的视图。`data` 为 null(失败/空)时仍返回结构完整的视图(块为空), * 组件据此画占位说明 —— 「失败」不该让整块面板消失,那会连面板标题都没了。 */ export function infrastructurePanelView(panelId, data, section) { const build = INFRASTRUCTURE_PANEL_BUILDERS[panelId] if (!build) return null return build(data, section) } /** 收集一个面板视图里真实的字段缺失(含嵌套层,票 05 的 `missing` 清单口径)。 */ export function panelMissingFields(data) { return collectMissing(data) }