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

import test from 'node:test'
import assert from 'node:assert/strict'
import {
  buildAlarmGisPoints,
  deriveAlarmGisStatus,
  filterAlarmGisPoints,
  summarizeAlarmGisPoints
} from '../src/utils/waterAlarmGisModel.js'
import { isActiveWorkOrderStatus } from '../src/utils/waterSupplyUiModel.js'

test('alarm gis points take the highest-risk status by documented priority', () => {
  assert.equal(deriveAlarmGisStatus({}), 'normal')
  assert.equal(deriveAlarmGisStatus({ onlineStatus: 0 }), 'offline')
  assert.equal(deriveAlarmGisStatus({ currentStatus: 3 }), 'warning')
  assert.equal(deriveAlarmGisStatus({ deviceAlarmStatus: 1 }), 'alarm')
  assert.equal(deriveAlarmGisStatus({ orderNo: 'WO-1', orderStatus: 3 }), 'workOrder')

  assert.equal(deriveAlarmGisStatus({ orderNo: 'WO-1', orderStatus: 3, deviceAlarmStatus: 1, currentStatus: 3, onlineStatus: 0 }), 'workOrder')
  assert.equal(deriveAlarmGisStatus({ deviceAlarmStatus: 1, currentStatus: 3, onlineStatus: 0 }), 'alarm')
  assert.equal(deriveAlarmGisStatus({ currentStatus: 3, onlineStatus: 0 }), 'warning')
  assert.equal(deriveAlarmGisStatus({ onlineStatus: 0, deviceAlarmStatus: 0 }), 'offline')
})

test('a closed or cancelled work order no longer counts as an active related order', () => {
  assert.equal(isActiveWorkOrderStatus(0), true)
  assert.equal(isActiveWorkOrderStatus('2'), true)
  assert.equal(isActiveWorkOrderStatus(6), true)
  assert.equal(isActiveWorkOrderStatus(5), false)
  assert.equal(isActiveWorkOrderStatus('7'), false)
  assert.equal(isActiveWorkOrderStatus(undefined), false)

  assert.equal(deriveAlarmGisStatus({ orderNo: 'WO-5', orderStatus: 5, deviceAlarmStatus: 1 }), 'alarm')
  assert.equal(deriveAlarmGisStatus({ orderNo: 'WO-7', orderStatus: 7, onlineStatus: 0 }), 'offline')
})

test('renders every valid alarm point and drops points without coordinates', () => {
  const points = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-1', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 2 },
      { alarmId: 'A-2', deviceCode: 'D-2', longitude: '110.2', latitude: '28.2', alarmLevel: 3 },
      { alarmId: 'A-3', deviceCode: 'D-3', longitude: '', latitude: '28.3', alarmLevel: 1 }
    ]
  })

  assert.deepEqual(points.map(point => point.alarmId), ['A-1', 'A-2'])
  assert.deepEqual(points.map(point => point.lng), [110.1, 110.2])
  assert.deepEqual(points.map(point => point.lat), [28.1, 28.2])
})

test('merges the alarms of one device into a single highest-risk point', () => {
  const points = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-LOW', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 4, alarmTime: '2026-09-16 08:00:00' },
      { alarmId: 'A-HIGH', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 1, alarmTime: '2026-09-16 09:00:00' }
    ]
  })

  assert.equal(points.length, 1)
  assert.equal(points[0].alarmId, 'A-HIGH')
  assert.equal(points[0].alarmCount, 2)
})

test('enriches alarm points with independent device, record and work-order state', () => {
  const points = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-1', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 1, warningType: '压力预警' }
    ],
    ledgerRows: [
      {
        id: 'A-1',
        deviceCode: 'D-1',
        alarmStatus: 1,
        alarmStatusText: '已处理',
        deviceAlarmStatus: 1,
        deviceAlarmStatusText: '报警中',
        displayStatus: 2,
        displayStatusText: '已转工单',
        orderNo: 'WO-2026-1',
        orderStatus: 3
      }
    ],
    devicePoints: [
      { equipmentCode: 'D-1', onlineStatus: 1, currentStatus: 3, onlineStatusText: '在线', currentStatusText: '维修' }
    ]
  })

  assert.equal(points.length, 1)
  assert.equal(points[0].recordStatus, 1)
  assert.equal(points[0].deviceAlarmStatus, 1)
  assert.equal(points[0].displayStatus, 2)
  assert.equal(points[0].orderNo, 'WO-2026-1')
  assert.equal(points[0].orderStatus, 3)
  assert.equal(points[0].onlineStatus, 1)
  assert.equal(points[0].currentStatus, 3)
  assert.equal(points[0].onlineStatusText, '在线')
  assert.equal(points[0].currentStatusText, '维修')
  // 关联工单进行中时点位取最高风险语义；设备报警状态与记录状态仍各自保留
  assert.equal(points[0].statusKey, 'workOrder')
})

test('marks unavailable device and record state as unknown without substituting either one', () => {
  const [pending] = buildAlarmGisPoints({
    alarmPoints: [{ alarmId: 'A-1', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 1 }]
  })
  assert.equal(pending.deviceAlarmStatus, undefined)
  assert.equal(pending.deviceAlarmStatusText, '未获取')
  assert.equal(pending.recordStatus, undefined)
  assert.equal(pending.recordStatusText, '未获取')
  assert.equal(pending.statusKey, 'alarm')

  const [handled] = buildAlarmGisPoints({
    alarmPoints: [{ alarmId: 'A-2', deviceCode: 'D-2', longitude: '110.1', latitude: '28.1', alarmLevel: 4 }],
    ledgerRows: [{ id: 'A-2', deviceCode: 'D-2', alarmStatus: 1, alarmStatusText: '已处理' }]
  })
  assert.equal(handled.deviceAlarmStatus, undefined)
  assert.equal(handled.deviceAlarmStatusText, '未获取')
  assert.equal(handled.recordStatus, 1)
  assert.equal(handled.statusKey, 'normal')
})

test('keeps an offline or repairing device out of the alarm colour even when its order is closed', () => {
  const [offline, warning] = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-1', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1' },
      { alarmId: 'A-2', deviceCode: 'D-2', longitude: '110.2', latitude: '28.2' }
    ],
    ledgerRows: [
      { id: 'A-1', deviceCode: 'D-1', deviceAlarmStatus: 0, orderNo: 'WO-1', orderStatus: 5 },
      { id: 'A-2', deviceCode: 'D-2', deviceAlarmStatus: 0 }
    ],
    devicePoints: [
      { equipmentCode: 'D-1', onlineStatus: 0, currentStatus: 1 },
      { equipmentCode: 'D-2', onlineStatus: 1, currentStatus: 3 }
    ]
  })

  assert.equal(offline.statusKey, 'offline')
  assert.equal(warning.statusKey, 'warning')
})

test('searches alarm points by device, alarm type and location', () => {
  const points = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-1', deviceCode: 'CN-GS-001', deviceName: '一号压力计', warningType: '压力预警', equipmentLocation: '迎宾路', longitude: '110.1', latitude: '28.1', alarmLevel: 1 },
      { alarmId: 'A-2', deviceCode: 'CN-GS-002', deviceName: '二号流量计', warningType: '流量预警', equipmentLocation: '沅水大道', longitude: '110.2', latitude: '28.2', alarmLevel: 3 }
    ]
  })

  assert.deepEqual(filterAlarmGisPoints(points, '').map(point => point.alarmId), ['A-1', 'A-2'])
  assert.deepEqual(filterAlarmGisPoints(points, '压力').map(point => point.alarmId), ['A-1'])
  assert.deepEqual(filterAlarmGisPoints(points, 'cn-gs-002').map(point => point.alarmId), ['A-2'])
  assert.deepEqual(filterAlarmGisPoints(points, '沅水').map(point => point.alarmId), ['A-2'])
  assert.deepEqual(filterAlarmGisPoints(points, '不存在的关键字'), [])
})

test('summarizes alarm points by the five documented map states', () => {
  const points = buildAlarmGisPoints({
    alarmPoints: [
      { alarmId: 'A-1', deviceCode: 'D-1', longitude: '110.1', latitude: '28.1', alarmLevel: 1 },
      { alarmId: 'A-2', deviceCode: 'D-2', longitude: '110.2', latitude: '28.2', alarmLevel: 4 },
      { alarmId: 'A-3', deviceCode: 'D-3', longitude: '110.3', latitude: '28.3', alarmLevel: 2 },
      { alarmId: 'A-4', deviceCode: 'D-4', longitude: '110.4', latitude: '28.4', alarmLevel: 3 }
    ],
    ledgerRows: [
      { id: 'A-1', deviceCode: 'D-1', deviceAlarmStatus: 1 },
      { id: 'A-2', deviceCode: 'D-2', deviceAlarmStatus: 0 },
      { id: 'A-3', deviceCode: 'D-3', deviceAlarmStatus: 0, orderNo: 'WO-1', orderStatus: 2 },
      { id: 'A-4', deviceCode: 'D-4', deviceAlarmStatus: 0 }
    ],
    devicePoints: [
      { equipmentCode: 'D-1', onlineStatus: 1, currentStatus: 1 },
      { equipmentCode: 'D-2', onlineStatus: 0, currentStatus: 1 },
      { equipmentCode: 'D-3', onlineStatus: 1, currentStatus: 1 },
      { equipmentCode: 'D-4', onlineStatus: 1, currentStatus: 3 }
    ]
  })

  const summary = summarizeAlarmGisPoints(points)
  assert.equal(summary.total, 4)
  assert.equal(summary.highLevel, 2)
  assert.deepEqual(summary.byStatus, { normal: 0, alarm: 1, warning: 1, workOrder: 1, offline: 1 })

  assert.deepEqual(summarizeAlarmGisPoints([]).byStatus, { normal: 0, alarm: 0, warning: 0, workOrder: 0, offline: 0 })
})