city-life-line/tests/waterHomeModel.test.mjs

import test from 'node:test'
import assert from 'node:assert/strict'

import {
  HOME_QUICK_ENTRIES,
  buildHomeWorkOrderQuery,
  normalizeFacilityTotal,
  normalizeHomeKpis,
  normalizeDeviceStatistics,
  normalizeWorkOrderStatusStat,
  normalizeAlarmOverviewCards,
  normalizeAlarmTrend,
  normalizePieRatio,
  normalizeRealtimeAlarmRows,
  realtimeAlarmJumpTarget,
  normalizeAbnormalTodoRows,
  normalizeDeviceSummary,
  normalizeWorkOrderRows,
  buildHomeGisOverview
} from '../src/utils/waterHomeModel.js'

test('home work order scope is constrained to the water-supply type tree', () => {
  assert.deepEqual(buildHomeWorkOrderQuery(), {
    deviceTypeParentId: '1',
    pageNum: 1,
    pageSize: 5
  })
  assert.deepEqual(buildHomeWorkOrderQuery({ pageSize: 8 }), {
    deviceTypeParentId: '1',
    pageNum: 1,
    pageSize: 8
  })
})

test('facility total excludes the aggregated total row', () => {
  const rows = [
    { facilityType: 'source', totalCount: 3 },
    { facilityType: 'plant', totalCount: 2 },
    { facilityType: 'pipe', totalCount: 996 },
    { facilityType: 'total', totalCount: 1000 }
  ]
  assert.equal(normalizeFacilityTotal(rows), 1001)
  assert.equal(normalizeFacilityTotal(null), 0)
  assert.equal(normalizeFacilityTotal([]), 0)
})

test('home KPIs map api payloads to workbench cards', () => {
  const kpis = normalizeHomeKpis({
    facilityRows: [{ facilityType: 'pipe', totalCount: 996 }, { facilityType: 'total', totalCount: 1000 }],
    ledgerStats: { total: 15, online: 13 },
    alarmStats: { realtimeAlarmCount: 3 }
  })
  assert.deepEqual(kpis, [
    { key: 'facility', label: '设施总数', value: 996, unit: '处', tone: 'primary' },
    { key: 'device', label: '监测设备', value: 15, unit: '台', tone: 'primary' },
    { key: 'online', label: '在线设备', value: 13, unit: '台', tone: 'primary' },
    { key: 'alarm', label: '实时报警', value: 3, unit: '条', tone: 'danger' }
  ])
})

test('home KPIs keep realtime alarm card neutral when no alarm is active', () => {
  const alarm = normalizeHomeKpis({ alarmStats: { realtimeAlarmCount: 0 } }).find(item => item.key === 'alarm')
  assert.equal(alarm.tone, 'primary')
})

test('work order status statistic groups by authoritative status contract', () => {
  const stat = normalizeWorkOrderStatusStat({
    total: 10,
    counts: [
      { status: 0, count: 2 },
      { status: 1, count: 1 },
      { status: 3, count: 2 },
      { status: 4, count: 2 },
      { status: 5, count: 2 },
      { status: 7, count: 1 }
    ]
  })
  assert.equal(stat.total, 10)
  assert.equal(stat.pendingCount, 3)
  assert.equal(stat.processingCount, 2)
  assert.equal(stat.verifyingCount, 2)
  assert.equal(stat.finishedCount, 3)
  assert.equal(stat.byStatus.find(item => item.status === 6).count, 0)
})

test('alarm overview cards derive online rate and verifying orders', () => {
  const cards = normalizeAlarmOverviewCards({
    dashboard: { totalCount: 16, alarmingDeviceCount: 4 },
    deviceStats: { onlineRate: 86.666666 },
    workOrderStat: {
      counts: [{ status: 4, count: 3 }]
    }
  })
  assert.deepEqual(cards, [
    { key: 'alarmTotal', label: '报警总数', value: 16, unit: '条', tone: 'primary' },
    { key: 'alarmingDevice', label: '报警中设备', value: 4, unit: '台', tone: 'danger' },
    { key: 'verifyingOrder', label: '待验收工单', value: 3, unit: '单', tone: 'warning' },
    { key: 'onlineRate', label: '在线率', value: 86.7, unit: '%', tone: 'primary' }
  ])
})

test('alarm trend returns four level series with zero-filled missing days', () => {
  const trend = normalizeAlarmTrend([
    { date: '2026-09-15', level1Count: 1, level2Count: 2 },
    { date: '2026-09-16' }
  ])
  assert.deepEqual(trend.dates, ['2026-09-15', '2026-09-16'])
  assert.equal(trend.levels.length, 4)
  const level2 = trend.levels.find(item => item.name === '级2')
  assert.deepEqual(level2.data, [2, 0])
  assert.equal(normalizeAlarmTrend(null).levels.length, 4)
})

test('ratio pie drops empty values and caps the number of segments', () => {
  const items = [
    { name: ' ' },
    { name: '压力', count: '8' },
    { name: '流量', count: '5' },
    { name: '离线', count: '3' },
    { name: '低', count: 0 }
  ]
  assert.deepEqual(normalizePieRatio(items, '未分类', 3), [
    { name: '压力', count: 8 },
    { name: '流量', count: 5 },
    { name: '离线', count: 3 }
  ])
  assert.deepEqual(normalizePieRatio(undefined, '未分类'), [])
})

test('realtime alarm rows expose chinese friendly display fields', () => {
  const rows = normalizeRealtimeAlarmRows([
    {
      id: 'a1',
      deviceCode: 'CN-GS-202609020001',
      deviceName: '一号压力点',
      warningType: '压力过低',
      alarmLevel: 1,
      alarmTime: '2026-09-15 10:00:00',
      equipmentLocation: '城南',
      displayStatus: 1
    }
  ])
  assert.equal(rows.length, 1)
  assert.equal(rows[0].deviceName, '一号压力点')
  assert.equal(rows[0].alarmLevelText, '一级报警')
  assert.equal(rows[0].location, '城南')
  assert.equal(rows[0].displayStatusText, '待审核')
  assert.equal(rows[0].displayStatusType, 'warning')
  assert.equal(normalizeRealtimeAlarmRows([], 5).length, 0)
})

test('realtime alarm rows drop released alarms and keep status for routing', () => {
  const rows = normalizeRealtimeAlarmRows([
    { id: 'a-pending', deviceCode: 'CN-GS-202609020001', displayStatus: 1, alarmTime: '2026-09-15 10:00:00' },
    { id: 'a-order', deviceCode: 'CN-GS-202609020002', displayStatus: 2, orderNo: 'WO202609151100001', alarmTime: '2026-09-15 09:00:00' },
    { id: 'a-released', deviceCode: 'CN-GS-202609020003', displayStatus: 3, alarmTime: '2026-09-15 08:00:00' }
  ], 5)

  assert.deepEqual(rows.map(item => item.id), ['a-pending', 'a-order'])
  assert.equal(rows.find(item => item.id === 'a-order').displayStatusText, '已转工单')
  assert.equal(rows.find(item => item.id === 'a-order').orderNo, 'WO202609151100001')
  assert.equal(rows.find(item => item.id === 'a-pending').displayStatusType, 'warning')
})

test('realtime alarm rows derive transferred status from a live order number when displayStatus is missing', () => {
  const rows = normalizeRealtimeAlarmRows([
    { id: 'legacy-order', deviceCode: 'CN-GS-202609020004', orderNo: 'WO202609151100009', orderStatus: 3, alarmTime: '2026-09-15 11:00:00' },
    { id: 'legacy-pending', deviceCode: 'CN-GS-202609020005', alarmTime: '2026-09-15 10:30:00' }
  ], 5)

  const transferred = rows.find(item => item.id === 'legacy-order')
  assert.equal(transferred.displayStatus, 2)
  assert.equal(transferred.displayStatusText, '已转工单')
  assert.equal(transferred.displayStatusType, 'primary')
  const pending = rows.find(item => item.id === 'legacy-pending')
  assert.equal(pending.displayStatus, 1)
  assert.equal(pending.displayStatusText, '待审核')
})

test('realtime alarm rows never treat a cancelled order as transferred', () => {
  const rows = normalizeRealtimeAlarmRows([
    { id: 'legacy-cancelled', deviceCode: 'CN-GS-202609020006', orderNo: 'WO202609151100010', orderStatus: 7, alarmTime: '2026-09-15 11:30:00' }
  ], 5)

  assert.equal(rows[0].displayStatus, 1)
  assert.equal(rows[0].displayStatusText, '待审核')
})

test('realtime alarm fallback keeps a live order as transferred even when the alarm row is already handled', () => {
  // 与后端 resolveDisplayStatus 同序：在办工单优先于报警是否已处理。
  const rows = normalizeRealtimeAlarmRows([
    {
      id: 'legacy-handled-with-order',
      deviceCode: 'CN-GS-202609020007',
      alarmStatus: 1,
      orderNo: 'WO202609151100011',
      orderStatus: 3,
      alarmTime: '2026-09-15 12:00:00'
    }
  ], 5)

  assert.equal(rows.length, 1)
  assert.equal(rows[0].displayStatus, 2)
  assert.equal(rows[0].displayStatusText, '已转工单')
})

test('realtime alarm jumps split between audit and work order by display status', () => {
  assert.deepEqual(realtimeAlarmJumpTarget({
    id: 'alarm-1',
    deviceCode: 'CN-GS-202609020001',
    displayStatus: 1
  }), {
    path: '/monitorAlarm/audit',
    query: { rootTypeId: 1, alarmId: 'alarm-1', deviceCode: 'CN-GS-202609020001' }
  })
  assert.deepEqual(realtimeAlarmJumpTarget({
    id: 'alarm-2',
    deviceCode: 'CN-GS-202609020002',
    displayStatus: 2,
    orderNo: 'WO202609151100001'
  }), {
    path: '/device/maintain',
    query: { keyword: 'WO202609151100001' }
  })
  // 已转工单但缺少工单号时回落到报警审核，避免无效跳转
  const fallback = realtimeAlarmJumpTarget({ id: 'alarm-3', displayStatus: 2 })
  assert.equal(fallback.path, '/monitorAlarm/audit')
  assert.equal(fallback.query.rootTypeId, 1)
})

test('abnormal todo rows reuse the shared device normalization contract', () => {
  const rows = normalizeAbnormalTodoRows([{
    equipmentId: 'eq-1',
    equipmentCode: 'CN-GS-202609020002',
    equipmentName: '二号流量点',
    alarmStatus: 1,
    onlineStatus: 1,
    currentStatus: 1,
    alertLevel: 2,
    relatedWorkOrderNo: 'WO202609150001',
    relatedWorkOrderStatus: 3
  }], 1)
  assert.equal(rows.length, 1)
  assert.equal(rows[0].alarmStatusText, '报警')
  assert.equal(rows[0].onlineStatusText, '在线')
  assert.equal(rows[0].alarmLevelText, '二级报警')
  assert.equal(rows[0].relatedOrderNo, 'WO202609150001')
  assert.equal(rows[0].workOrderStatusText, '处理中')
})

test('device summary keeps key text fields for the workbench detail panel', () => {
  const summary = normalizeDeviceSummary({
    equipmentId: 'eq-9',
    equipmentCode: 'CB-GS-202609020003',
    equipmentName: '三号漏失点',
    equipmentLocation: '城北',
    district: '城北',
    alarmStatus: 0,
    onlineStatus: 0,
    currentStatus: 3,
    equipmentTypeName: '漏失在线监测仪'
  })
  assert.equal(summary.name, '三号漏失点')
  assert.equal(summary.alarmStatusText, '正常')
  assert.equal(summary.onlineStatusText, '离线')
  assert.equal(summary.currentStatusText, '维修')
  assert.equal(summary.abnormalReasonText, '设备维修中')
  assert.equal(summary.typeName, '漏失在线监测仪')
})

test('work order rows translate status and level codes to chinese', () => {
  const rows = normalizeWorkOrderRows([
    { orderId: 5, orderNo: 'WO202609150001', orderStatus: 4, orderLevel: 0, deviceCode: 'CN-GS-202609020001', createTime: '2026-09-15 10:00:00' }
  ], 5)
  assert.equal(rows[0].orderStatusText, '待验收')
  assert.equal(rows[0].orderStatusType, 'primary')
  assert.equal(rows[0].orderLevelText, '紧急')
  assert.equal(rows[0].orderLevelType, 'danger')
})

test('home GIS overview aggregates facilities, devices and alarms with alarm priority', () => {
  const overview = buildHomeGisOverview({
    facilityPoints: [
      { id: 'f-1', type: 'source', name: '一水源地', code: 'S-001', lng: 110.08, lat: 28.05 }
    ],
    facilityLines: [
      { id: 'pipe-1', name: '城南主管', type: 'pipe', points: [{ lng: 110.1, lat: 28.1 }, { lng: 110.2, lat: 28.2 }] }
    ],
    devicePoints: [
      { equipmentId: 'eq-1', equipmentCode: 'CN-GS-202609020001', equipmentName: '一号压力点', longitude: 110.1, latitude: 28.1, alarmStatus: 0, onlineStatus: 1, currentStatus: 0, equipmentTypeName: '压力计' }
    ],
    alarmPoints: [
      { alarmId: 'alarm-1', deviceCode: 'CN-GS-202609020001', deviceName: '一号压力点', longitude: 110.1, latitude: 28.1, warningType: '压力过低', alarmLevel: 1 }
    ]
  })

  assert.equal(overview.lines.length, 1)
  assert.equal(overview.lines[0].color, '#f1c40f')
  assert.equal(overview.lines[0].points.length, 2)
  assert.ok(overview.points.some(point => point.id === 'f-1' && point.statusKey === 'normal'))
  const device = overview.points.find(point => point.code === 'CN-GS-202609020001')
  assert.ok(device)
  assert.equal(device.statusKey, 'alarm')
  assert.equal(device.meta, '压力过低')
  assert.ok(overview.points.every(point =>
    Number.isFinite(point.lng) && Number.isFinite(point.lat) && point.name && point.iconUrl))
  const empty = buildHomeGisOverview({})
  assert.deepEqual(empty, { points: [], lines: [] })
})

test('home GIS facility points share device status color semantics by facility status', () => {
  const overview = buildHomeGisOverview({
    facilityPoints: [
      { id: 'src-abnormal', type: 'source', name: '一水源地', lng: 110.08, lat: 28.05, status: 1 },
      { id: 'src-normal', type: 'source', name: '二水源地', lng: 110.09, lat: 28.06, status: 0 },
      { id: 'src-unknown', type: 'source', name: '三水源地', lng: 110.15, lat: 28.12 },
      { id: 'plant-stopped', type: 'plant', name: '一水厂', lng: 110.1, lat: 28.07, status: 1 },
      { id: 'pump-maintaining', type: 'pumpStation', name: '城南泵站', lng: 110.11, lat: 28.08, status: 2 },
      { id: 'pump-fault', type: 'pumpStation', name: '城北泵站', lng: 110.12, lat: 28.09, status: 1 },
      { id: 'user-arrears', type: 'user', name: '用水户A', lng: 110.13, lat: 28.1, status: 1 },
      { id: 'user-stopped', type: 'user', name: '用水户B', lng: 110.14, lat: 28.11, status: 2 },
      { id: 'pipe-point', type: 'pipe', name: '管网占位点', lng: 110.16, lat: 28.13 }
    ]
  })

  const byId = id => overview.points.find(point => point.id === id)

  assert.equal(byId('src-abnormal').statusKey, 'alarm')
  assert.equal(byId('src-abnormal').statusText, '异常')
  assert.match(byId('src-abnormal').iconUrl, /T_MarkPoint_Red\.png/u)
  assert.equal(byId('src-normal').statusKey, 'normal')
  assert.equal(byId('src-normal').statusText, '正常')
  assert.match(byId('src-normal').iconUrl, /T_MarkPoint_Green\.png/u)
  assert.equal(byId('src-unknown').statusKey, 'normal')
  assert.equal(byId('src-unknown').statusText, '正常')

  assert.equal(byId('plant-stopped').statusKey, 'alarm')
  assert.equal(byId('plant-stopped').statusText, '停产')

  assert.equal(byId('pump-maintaining').statusKey, 'workOrder')
  assert.equal(byId('pump-maintaining').statusText, '检修中')
  assert.match(byId('pump-maintaining').iconUrl, /T_MarkPoint_Blue\.png/u)
  assert.equal(byId('pump-fault').statusKey, 'alarm')
  assert.equal(byId('pump-fault').statusText, '故障停运')

  assert.equal(byId('user-arrears').statusKey, 'warning')
  assert.equal(byId('user-arrears').statusText, '欠费')
  assert.match(byId('user-arrears').iconUrl, /T_MarkPoint_Yellow\.png/u)
  assert.equal(byId('user-stopped').statusKey, 'alarm')
  assert.equal(byId('user-stopped').statusText, '停用')

  assert.equal(byId('pipe-point'), undefined)
})

test('home quick entries cover the four workbench jumps', () => {
  assert.deepEqual(HOME_QUICK_ENTRIES.map(item => item.label), ['设备异常管理', '报警管理', '报警审核', '监测报警一张图'])
  assert.ok(HOME_QUICK_ENTRIES.every(item => item.suffix.startsWith('/')))
  assert.equal(HOME_QUICK_ENTRIES.find(item => item.key === 'audit').query.rootTypeId, 1)
})

test('home device statistics derive online rate from the unified equipment endpoint', () => {
  assert.deepEqual(normalizeDeviceStatistics({ total: 15, online: 12, offline: 3, alarm: 5 }), {
    total: 15,
    online: 12,
    offline: 3,
    alarm: 5,
    onlineRate: 80
  })

  // 后端未回填 offline 时按总数推导；无设备时不产生除零
  assert.equal(normalizeDeviceStatistics({ total: 15, online: 12 }).offline, 3)
  assert.equal(normalizeDeviceStatistics({ total: 0, online: 0 }).onlineRate, 0)
  assert.equal(normalizeDeviceStatistics({}).onlineRate, 0)
})