|
|
@@ -20,18 +20,27 @@ import com.zksy.base.radar.mapper.RadarDataMapper;
|
|
|
import com.zksy.base.service.MonitoringService;
|
|
|
import com.zksy.base.telemetry.domain.TelemetryData;
|
|
|
import com.zksy.base.telemetry.mapper.TelemetryDataMapper;
|
|
|
-import lombok.extern.slf4j.Slf4j;
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
|
|
|
import java.time.LocalDateTime;
|
|
|
import java.util.*;
|
|
|
+import java.util.function.Function;
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
-@Slf4j
|
|
|
@Service
|
|
|
public class MonitoringServiceImpl implements MonitoringService {
|
|
|
|
|
|
+ private static final String RADAR_SOURCE = "雷达流量计";
|
|
|
+ private static final String TELEMETRY_SOURCE = "遥测终端";
|
|
|
+
|
|
|
+ private static final String WATER_SUPPLY_ROOT_ID = "1";
|
|
|
+ private static final String WATER_SUPPLY_ROOT_TYPE_ID = "water_supply";
|
|
|
+ private static final String WATER_SUPPLY_ROOT_PARENT_ID = "0";
|
|
|
+ private static final String FLOW_TYPE_ID = "ws_flow";
|
|
|
+ private static final String PRESSURE_TYPE_ID = "ws_pressure";
|
|
|
+ private static final String LEAKAGE_TYPE_ID = "ws_leak";
|
|
|
+
|
|
|
@Autowired
|
|
|
private EquipmentBaseMapper equipmentBaseMapper;
|
|
|
|
|
|
@@ -52,438 +61,491 @@ public class MonitoringServiceImpl implements MonitoringService {
|
|
|
|
|
|
@Override
|
|
|
public Page<FlowMonitoringVO> getFlowMonitorPage(long pageNum, long pageSize,
|
|
|
- String equipmentName, String equipmentCode,
|
|
|
- String equipmentLocation,
|
|
|
- LocalDateTime startTime, LocalDateTime endTime,
|
|
|
- Double flowMin, Double flowMax) {
|
|
|
- LambdaQueryWrapper<EquipmentBase> baseWrapper = new LambdaQueryWrapper<>();
|
|
|
- baseWrapper.like(StrUtil.isNotBlank(equipmentName), EquipmentBase::getEquipmentName, equipmentName)
|
|
|
- .like(StrUtil.isNotBlank(equipmentCode), EquipmentBase::getEquipmentCode, equipmentCode)
|
|
|
- .like(StrUtil.isNotBlank(equipmentLocation), EquipmentBase::getEquipmentLocation, equipmentLocation)
|
|
|
- .orderByDesc(EquipmentBase::getCreateTime);
|
|
|
- constrainToMonitoringTypes(baseWrapper, "flow");
|
|
|
-
|
|
|
- Page<EquipmentBase> basePage = equipmentBaseMapper.selectPage(new Page<>(pageNum, pageSize), baseWrapper);
|
|
|
- Page<FlowMonitoringVO> resultPage = new Page<>(pageNum, pageSize, basePage.getTotal());
|
|
|
-
|
|
|
- if (CollUtil.isEmpty(basePage.getRecords())) {
|
|
|
- resultPage.setRecords(new ArrayList<>());
|
|
|
- return resultPage;
|
|
|
- }
|
|
|
-
|
|
|
- List<EquipmentBase> devices = basePage.getRecords();
|
|
|
- List<String> deviceCodes = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentCode).filter(StrUtil::isNotBlank).collect(Collectors.toList());
|
|
|
- List<String> typeIds = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentTypeId).filter(StrUtil::isNotBlank).distinct().collect(Collectors.toList());
|
|
|
-
|
|
|
- Map<String, EquipmentType> typeMap = new HashMap<>();
|
|
|
- if (CollUtil.isNotEmpty(typeIds)) {
|
|
|
- List<EquipmentType> types = equipmentTypeMapper.selectBatchIds(typeIds);
|
|
|
- typeMap = types.stream().collect(Collectors.toMap(EquipmentType::getTypeId, t -> t, (a, b) -> a));
|
|
|
- }
|
|
|
-
|
|
|
- Map<String, RadarData> radarLatestMap = new HashMap<>();
|
|
|
- Map<String, TelemetryData> telemetryLatestMap = new HashMap<>();
|
|
|
-
|
|
|
- if (CollUtil.isNotEmpty(deviceCodes)) {
|
|
|
- List<RadarData> radarDataList = radarDataMapper.selectList(
|
|
|
- new LambdaQueryWrapper<RadarData>().in(RadarData::getDeviceCode, deviceCodes)
|
|
|
- .ge(startTime != null, RadarData::getCreateTime, startTime)
|
|
|
- .le(endTime != null, RadarData::getCreateTime, endTime)
|
|
|
- .orderByDesc(RadarData::getCreateTime)
|
|
|
- );
|
|
|
- if (CollUtil.isNotEmpty(radarDataList)) {
|
|
|
- Set<String> seen = new HashSet<>();
|
|
|
- for (RadarData d : radarDataList) {
|
|
|
- if (seen.add(d.getDeviceCode())) {
|
|
|
- radarLatestMap.put(d.getDeviceCode(), d);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- List<TelemetryData> telemetryDataList = telemetryDataMapper.selectList(
|
|
|
- new LambdaQueryWrapper<TelemetryData>().in(TelemetryData::getDeviceCode, deviceCodes)
|
|
|
- .ge(startTime != null, TelemetryData::getCreateTime, startTime)
|
|
|
- .le(endTime != null, TelemetryData::getCreateTime, endTime)
|
|
|
- .orderByDesc(TelemetryData::getCreateTime)
|
|
|
- );
|
|
|
- if (CollUtil.isNotEmpty(telemetryDataList)) {
|
|
|
- Set<String> seen = new HashSet<>();
|
|
|
- for (TelemetryData d : telemetryDataList) {
|
|
|
- if (seen.add(d.getDeviceCode())) {
|
|
|
- telemetryLatestMap.put(d.getDeviceCode(), d);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
+ String equipmentName, String equipmentCode,
|
|
|
+ String equipmentLocation,
|
|
|
+ LocalDateTime startTime, LocalDateTime endTime,
|
|
|
+ Double flowMin, Double flowMax) {
|
|
|
+ List<EquipmentBase> devices = selectMonitoringDevices(equipmentName, equipmentCode, equipmentLocation, "flow");
|
|
|
+ if (CollUtil.isEmpty(devices)) {
|
|
|
+ return emptyPage(pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
- List<FlowMonitoringVO> voList = new ArrayList<>();
|
|
|
- for (EquipmentBase device : devices) {
|
|
|
- FlowMonitoringVO vo = new FlowMonitoringVO();
|
|
|
- vo.setEquipmentId(device.getEquipmentId());
|
|
|
- vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
- vo.setEquipmentName(device.getEquipmentName());
|
|
|
- vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
- vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
- EquipmentType type = typeMap.get(device.getEquipmentTypeId());
|
|
|
- if (type != null) {
|
|
|
- vo.setEquipmentTypeName(type.getTypeName());
|
|
|
- }
|
|
|
- vo.setLongitude(device.getLongitude());
|
|
|
- vo.setLatitude(device.getLatitude());
|
|
|
- if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
- vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
- }
|
|
|
+ Map<String, EquipmentType> typeMap = selectTypeMap(devices);
|
|
|
+ Map<String, RadarData> radarMap = selectLatestRadar(devices, startTime, endTime, flowMin, flowMax);
|
|
|
+ Map<String, TelemetryData> telemetryMap = selectLatestTelemetry(devices, startTime, endTime, flowMin, flowMax);
|
|
|
|
|
|
+ List<FlowMonitoringVO> allRows = new ArrayList<>();
|
|
|
+ for (EquipmentBase device : devices) {
|
|
|
String code = device.getEquipmentCode();
|
|
|
- boolean matched = false;
|
|
|
+ RadarData radar = radarMap.get(code);
|
|
|
+ TelemetryData telemetry = telemetryMap.get(code);
|
|
|
+ if (radar == null && telemetry == null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
|
|
|
- RadarData radar = radarLatestMap.get(code);
|
|
|
- if (radar != null && isFlowInRange(radar.getMeter1InstantFlow(), flowMin, flowMax)) {
|
|
|
- vo.setDataSource("雷达流量计");
|
|
|
+ FlowMonitoringVO vo = new FlowMonitoringVO();
|
|
|
+ fillBaseFields(vo, device, typeMap.get(device.getEquipmentTypeId()));
|
|
|
+ if (radar != null && (telemetry == null
|
|
|
+ || compareTime(radar.getCreateTime(), telemetry.getCreateTime()) >= 0)) {
|
|
|
+ vo.setDataSource(RADAR_SOURCE);
|
|
|
vo.setInstantFlow(radar.getMeter1InstantFlow());
|
|
|
vo.setFlowSpeed(radar.getFlowSpeed());
|
|
|
vo.setMonitorTime(radar.getCreateTime());
|
|
|
- matched = true;
|
|
|
- }
|
|
|
-
|
|
|
- if (!matched) {
|
|
|
- TelemetryData telemetry = telemetryLatestMap.get(code);
|
|
|
- if (telemetry != null && isFlowInRange(telemetry.getMeter1PositiveTotal(), flowMin, flowMax)) {
|
|
|
- vo.setDataSource("遥测终端");
|
|
|
- vo.setPositiveTotal(telemetry.getMeter1PositiveTotal());
|
|
|
- vo.setTemperature(telemetry.getTemperature());
|
|
|
- vo.setFlowSpeed(telemetry.getFlowSpeed());
|
|
|
- vo.setMonitorTime(telemetry.getCreateTime());
|
|
|
- matched = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (matched || (flowMin == null && flowMax == null)) {
|
|
|
- voList.add(vo);
|
|
|
+ } else {
|
|
|
+ vo.setDataSource(TELEMETRY_SOURCE);
|
|
|
+ vo.setInstantFlow(telemetry.getMeter1InstantFlow());
|
|
|
+ vo.setPositiveTotal(telemetry.getMeter1PositiveTotal());
|
|
|
+ vo.setTemperature(telemetry.getTemperature());
|
|
|
+ vo.setFlowSpeed(telemetry.getFlowSpeed());
|
|
|
+ vo.setMonitorTime(telemetry.getCreateTime());
|
|
|
}
|
|
|
+ allRows.add(vo);
|
|
|
}
|
|
|
-
|
|
|
- resultPage.setRecords(voList);
|
|
|
- return resultPage;
|
|
|
- }
|
|
|
-
|
|
|
- private boolean isFlowInRange(String flowStr, Double min, Double max) {
|
|
|
- if (min == null && max == null) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (StrUtil.isBlank(flowStr)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- try {
|
|
|
- double val = Double.parseDouble(flowStr);
|
|
|
- if (min != null && val < min) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (max != null && val > max) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- } catch (NumberFormatException e) {
|
|
|
- return false;
|
|
|
- }
|
|
|
+ return pageOf(allRows, pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public Page<PressureMonitoringVO> getPressureMonitorPage(long pageNum, long pageSize,
|
|
|
- String equipmentName, String equipmentCode,
|
|
|
- String equipmentLocation,
|
|
|
- LocalDateTime startTime, LocalDateTime endTime,
|
|
|
- Double pressureMin, Double pressureMax) {
|
|
|
- LambdaQueryWrapper<EquipmentBase> baseWrapper = new LambdaQueryWrapper<>();
|
|
|
- baseWrapper.like(StrUtil.isNotBlank(equipmentName), EquipmentBase::getEquipmentName, equipmentName)
|
|
|
- .like(StrUtil.isNotBlank(equipmentCode), EquipmentBase::getEquipmentCode, equipmentCode)
|
|
|
- .like(StrUtil.isNotBlank(equipmentLocation), EquipmentBase::getEquipmentLocation, equipmentLocation)
|
|
|
- .orderByDesc(EquipmentBase::getCreateTime);
|
|
|
- constrainToMonitoringTypes(baseWrapper, "pressure");
|
|
|
-
|
|
|
- Page<EquipmentBase> basePage = equipmentBaseMapper.selectPage(new Page<>(pageNum, pageSize), baseWrapper);
|
|
|
- Page<PressureMonitoringVO> resultPage = new Page<>(pageNum, pageSize, basePage.getTotal());
|
|
|
-
|
|
|
- if (CollUtil.isEmpty(basePage.getRecords())) {
|
|
|
- resultPage.setRecords(new ArrayList<>());
|
|
|
- return resultPage;
|
|
|
- }
|
|
|
-
|
|
|
- List<EquipmentBase> devices = basePage.getRecords();
|
|
|
- List<String> deviceCodes = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentCode).filter(StrUtil::isNotBlank).collect(Collectors.toList());
|
|
|
- List<String> typeIds = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentTypeId).filter(StrUtil::isNotBlank).distinct().collect(Collectors.toList());
|
|
|
-
|
|
|
- Map<String, EquipmentType> typeMap = new HashMap<>();
|
|
|
- if (CollUtil.isNotEmpty(typeIds)) {
|
|
|
- List<EquipmentType> types = equipmentTypeMapper.selectBatchIds(typeIds);
|
|
|
- typeMap = types.stream().collect(Collectors.toMap(EquipmentType::getTypeId, t -> t, (a, b) -> a));
|
|
|
+ String equipmentName, String equipmentCode,
|
|
|
+ String equipmentLocation,
|
|
|
+ LocalDateTime startTime, LocalDateTime endTime,
|
|
|
+ Double pressureMin, Double pressureMax) {
|
|
|
+ List<EquipmentBase> devices = selectMonitoringDevices(equipmentName, equipmentCode, equipmentLocation, "pressure");
|
|
|
+ if (CollUtil.isEmpty(devices)) {
|
|
|
+ return emptyPage(pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
- Map<String, FirefightingPressure> pressureLatestMap = new HashMap<>();
|
|
|
- if (CollUtil.isNotEmpty(deviceCodes)) {
|
|
|
- List<FirefightingPressure> pressureList = firefightingPressureMapper.selectList(
|
|
|
- new LambdaQueryWrapper<FirefightingPressure>().in(FirefightingPressure::getTelemeteringStation, deviceCodes)
|
|
|
+ Map<String, EquipmentType> typeMap = selectTypeMap(devices);
|
|
|
+ Map<String, FirefightingPressure> pressureMap = new HashMap<>();
|
|
|
+ List<String> deviceCodes = deviceCodes(devices);
|
|
|
+ if (!deviceCodes.isEmpty()) {
|
|
|
+ List<FirefightingPressure> records = firefightingPressureMapper.selectList(
|
|
|
+ new LambdaQueryWrapper<FirefightingPressure>()
|
|
|
+ .in(FirefightingPressure::getTelemeteringStation, deviceCodes)
|
|
|
.ge(startTime != null, FirefightingPressure::getCreateTime, startTime)
|
|
|
.le(endTime != null, FirefightingPressure::getCreateTime, endTime)
|
|
|
- .ge(pressureMin != null, FirefightingPressure::getPressureValue, pressureMin)
|
|
|
- .le(pressureMax != null, FirefightingPressure::getPressureValue, pressureMax)
|
|
|
- .orderByDesc(FirefightingPressure::getCreateTime)
|
|
|
- );
|
|
|
- if (CollUtil.isNotEmpty(pressureList)) {
|
|
|
- Set<String> seen = new HashSet<>();
|
|
|
- for (FirefightingPressure p : pressureList) {
|
|
|
- if (seen.add(p.getTelemeteringStation())) {
|
|
|
- pressureLatestMap.put(p.getTelemeteringStation(), p);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
+ .orderByDesc(FirefightingPressure::getCreateTime));
|
|
|
+ pressureMap = latestBy(records, FirefightingPressure::getTelemeteringStation,
|
|
|
+ record -> inRange(record.getPressureValue(), pressureMin, pressureMax, startTime, endTime, record.getCreateTime()));
|
|
|
}
|
|
|
|
|
|
- List<PressureMonitoringVO> voList = new ArrayList<>();
|
|
|
+ List<PressureMonitoringVO> allRows = new ArrayList<>();
|
|
|
for (EquipmentBase device : devices) {
|
|
|
- PressureMonitoringVO vo = new PressureMonitoringVO();
|
|
|
- vo.setEquipmentId(device.getEquipmentId());
|
|
|
- vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
- vo.setEquipmentName(device.getEquipmentName());
|
|
|
- vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
- vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
- EquipmentType type = typeMap.get(device.getEquipmentTypeId());
|
|
|
- if (type != null) {
|
|
|
- vo.setEquipmentTypeName(type.getTypeName());
|
|
|
- }
|
|
|
- vo.setLongitude(device.getLongitude());
|
|
|
- vo.setLatitude(device.getLatitude());
|
|
|
- if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
- vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
- }
|
|
|
-
|
|
|
- FirefightingPressure pressure = pressureLatestMap.get(device.getEquipmentCode());
|
|
|
- if (pressure != null) {
|
|
|
- vo.setPressureValue(pressure.getPressureValue());
|
|
|
- vo.setMonitorTime(pressure.getCreateTime());
|
|
|
+ FirefightingPressure pressure = pressureMap.get(device.getEquipmentCode());
|
|
|
+ if (pressure == null) {
|
|
|
+ continue;
|
|
|
}
|
|
|
- voList.add(vo);
|
|
|
+ PressureMonitoringVO vo = new PressureMonitoringVO();
|
|
|
+ fillBaseFields(vo, device, typeMap.get(device.getEquipmentTypeId()));
|
|
|
+ vo.setPressureValue(pressure.getPressureValue());
|
|
|
+ vo.setMonitorTime(pressure.getCreateTime());
|
|
|
+ allRows.add(vo);
|
|
|
}
|
|
|
-
|
|
|
- resultPage.setRecords(voList);
|
|
|
- return resultPage;
|
|
|
+ return pageOf(allRows, pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public Page<LeakageMonitoringVO> getLeakageMonitorPage(long pageNum, long pageSize,
|
|
|
- String equipmentName, String equipmentCode,
|
|
|
- String equipmentLocation,
|
|
|
- LocalDateTime startTime, LocalDateTime endTime,
|
|
|
- Double powerMin, Double powerMax) {
|
|
|
- LambdaQueryWrapper<EquipmentBase> baseWrapper = new LambdaQueryWrapper<>();
|
|
|
- baseWrapper.like(StrUtil.isNotBlank(equipmentName), EquipmentBase::getEquipmentName, equipmentName)
|
|
|
- .like(StrUtil.isNotBlank(equipmentCode), EquipmentBase::getEquipmentCode, equipmentCode)
|
|
|
- .like(StrUtil.isNotBlank(equipmentLocation), EquipmentBase::getEquipmentLocation, equipmentLocation)
|
|
|
- .orderByDesc(EquipmentBase::getCreateTime);
|
|
|
- constrainToMonitoringTypes(baseWrapper, "leakage");
|
|
|
-
|
|
|
- Page<EquipmentBase> basePage = equipmentBaseMapper.selectPage(new Page<>(pageNum, pageSize), baseWrapper);
|
|
|
- Page<LeakageMonitoringVO> resultPage = new Page<>(pageNum, pageSize, basePage.getTotal());
|
|
|
-
|
|
|
- if (CollUtil.isEmpty(basePage.getRecords())) {
|
|
|
- resultPage.setRecords(new ArrayList<>());
|
|
|
- return resultPage;
|
|
|
- }
|
|
|
-
|
|
|
- List<EquipmentBase> devices = basePage.getRecords();
|
|
|
- List<String> deviceCodes = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentCode).filter(StrUtil::isNotBlank).collect(Collectors.toList());
|
|
|
- List<String> typeIds = devices.stream()
|
|
|
- .map(EquipmentBase::getEquipmentTypeId).filter(StrUtil::isNotBlank).distinct().collect(Collectors.toList());
|
|
|
-
|
|
|
- Map<String, EquipmentType> typeMap = new HashMap<>();
|
|
|
- if (CollUtil.isNotEmpty(typeIds)) {
|
|
|
- List<EquipmentType> types = equipmentTypeMapper.selectBatchIds(typeIds);
|
|
|
- typeMap = types.stream().collect(Collectors.toMap(EquipmentType::getTypeId, t -> t, (a, b) -> a));
|
|
|
+ String equipmentName, String equipmentCode,
|
|
|
+ String equipmentLocation,
|
|
|
+ LocalDateTime startTime, LocalDateTime endTime,
|
|
|
+ Double powerMin, Double powerMax) {
|
|
|
+ List<EquipmentBase> devices = selectMonitoringDevices(equipmentName, equipmentCode, equipmentLocation, "leakage");
|
|
|
+ if (CollUtil.isEmpty(devices)) {
|
|
|
+ return emptyPage(pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
- Map<String, NoiseInfo> noiseLatestMap = new HashMap<>();
|
|
|
- if (CollUtil.isNotEmpty(deviceCodes)) {
|
|
|
- List<NoiseInfo> noiseList = noiseInfoMapper.selectList(
|
|
|
- new LambdaQueryWrapper<NoiseInfo>().in(NoiseInfo::getEncode, deviceCodes)
|
|
|
+ Map<String, EquipmentType> typeMap = selectTypeMap(devices);
|
|
|
+ Map<String, NoiseInfo> noiseMap = new HashMap<>();
|
|
|
+ List<String> deviceCodes = deviceCodes(devices);
|
|
|
+ if (!deviceCodes.isEmpty()) {
|
|
|
+ List<NoiseInfo> records = noiseInfoMapper.selectList(
|
|
|
+ new LambdaQueryWrapper<NoiseInfo>()
|
|
|
+ .in(NoiseInfo::getEncode, deviceCodes)
|
|
|
.ge(startTime != null, NoiseInfo::getCreateTime, startTime)
|
|
|
.le(endTime != null, NoiseInfo::getCreateTime, endTime)
|
|
|
- .ge(powerMin != null, NoiseInfo::getPower, powerMin)
|
|
|
- .le(powerMax != null, NoiseInfo::getPower, powerMax)
|
|
|
- .orderByDesc(NoiseInfo::getCreateTime)
|
|
|
- );
|
|
|
- if (CollUtil.isNotEmpty(noiseList)) {
|
|
|
- Set<String> seen = new HashSet<>();
|
|
|
- for (NoiseInfo n : noiseList) {
|
|
|
- if (seen.add(n.getEncode())) {
|
|
|
- noiseLatestMap.put(n.getEncode(), n);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
+ .orderByDesc(NoiseInfo::getCreateTime));
|
|
|
+ noiseMap = latestBy(records, NoiseInfo::getEncode,
|
|
|
+ record -> inRange(record.getPower(), powerMin, powerMax, startTime, endTime, record.getCreateTime()));
|
|
|
}
|
|
|
|
|
|
- List<LeakageMonitoringVO> voList = new ArrayList<>();
|
|
|
+ List<LeakageMonitoringVO> allRows = new ArrayList<>();
|
|
|
for (EquipmentBase device : devices) {
|
|
|
- LeakageMonitoringVO vo = new LeakageMonitoringVO();
|
|
|
- vo.setEquipmentId(device.getEquipmentId());
|
|
|
- vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
- vo.setEquipmentName(device.getEquipmentName());
|
|
|
- vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
- vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
- EquipmentType type = typeMap.get(device.getEquipmentTypeId());
|
|
|
- if (type != null) {
|
|
|
- vo.setEquipmentTypeName(type.getTypeName());
|
|
|
- }
|
|
|
- vo.setLongitude(device.getLongitude());
|
|
|
- vo.setLatitude(device.getLatitude());
|
|
|
- if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
- vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
- }
|
|
|
-
|
|
|
- NoiseInfo noise = noiseLatestMap.get(device.getEquipmentCode());
|
|
|
- if (noise != null) {
|
|
|
- vo.setPower(noise.getPower());
|
|
|
- vo.setGain(noise.getGain());
|
|
|
- vo.setRms(noise.getRms());
|
|
|
- vo.setCenterFrequency(noise.getCenterFrequency());
|
|
|
- vo.setMonitorTime(noise.getCreateTime());
|
|
|
+ NoiseInfo noise = noiseMap.get(device.getEquipmentCode());
|
|
|
+ if (noise == null) {
|
|
|
+ continue;
|
|
|
}
|
|
|
- voList.add(vo);
|
|
|
+ LeakageMonitoringVO vo = new LeakageMonitoringVO();
|
|
|
+ fillBaseFields(vo, device, typeMap.get(device.getEquipmentTypeId()));
|
|
|
+ vo.setPower(noise.getPower());
|
|
|
+ vo.setGain(noise.getGain());
|
|
|
+ vo.setRms(noise.getRms());
|
|
|
+ vo.setCenterFrequency(noise.getCenterFrequency());
|
|
|
+ vo.setMonitorTime(noise.getCreateTime());
|
|
|
+ allRows.add(vo);
|
|
|
}
|
|
|
-
|
|
|
- resultPage.setRecords(voList);
|
|
|
- return resultPage;
|
|
|
+ return pageOf(allRows, pageNum, pageSize);
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
- public List<Map<String, Object>> getFlowTrend24h(String equipmentId) {
|
|
|
- EquipmentBase device = equipmentBaseMapper.selectById(equipmentId);
|
|
|
+ public List<Map<String, Object>> getFlowTrend(String equipmentId, LocalDateTime startTime, LocalDateTime endTime) {
|
|
|
+ EquipmentBase device = selectMonitoringDevice(equipmentId, "flow");
|
|
|
if (device == null || StrUtil.isBlank(device.getEquipmentCode())) {
|
|
|
return new ArrayList<>();
|
|
|
}
|
|
|
|
|
|
- LocalDateTime now = LocalDateTime.now();
|
|
|
- LocalDateTime before24h = now.minusHours(24);
|
|
|
+ LocalDateTime start = normalizeTrendStart(startTime, endTime);
|
|
|
String code = device.getEquipmentCode();
|
|
|
-
|
|
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
|
|
|
|
List<RadarData> radarList = radarDataMapper.selectList(
|
|
|
- new LambdaQueryWrapper<RadarData>().eq(RadarData::getDeviceCode, code)
|
|
|
- .ge(RadarData::getCreateTime, before24h)
|
|
|
- .orderByAsc(RadarData::getCreateTime)
|
|
|
- );
|
|
|
+ new LambdaQueryWrapper<RadarData>()
|
|
|
+ .eq(RadarData::getDeviceCode, code)
|
|
|
+ .ge(start != null, RadarData::getCreateTime, start)
|
|
|
+ .le(endTime != null, RadarData::getCreateTime, endTime)
|
|
|
+ .orderByAsc(RadarData::getCreateTime));
|
|
|
if (CollUtil.isNotEmpty(radarList)) {
|
|
|
- for (RadarData d : radarList) {
|
|
|
- Map<String, Object> point = new LinkedHashMap<>();
|
|
|
- point.put("time", d.getCreateTime());
|
|
|
- point.put("instantFlow", d.getMeter1InstantFlow());
|
|
|
- point.put("flowSpeed", d.getFlowSpeed());
|
|
|
- result.add(point);
|
|
|
+ for (RadarData data : radarList) {
|
|
|
+ if (!inTimeRange(data.getCreateTime(), start, endTime)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ result.add(flowTrendPoint(device, data.getCreateTime(), data.getMeter1InstantFlow(),
|
|
|
+ data.getFlowSpeed(), null, null));
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
List<TelemetryData> telemetryList = telemetryDataMapper.selectList(
|
|
|
- new LambdaQueryWrapper<TelemetryData>().eq(TelemetryData::getDeviceCode, code)
|
|
|
- .ge(TelemetryData::getCreateTime, before24h)
|
|
|
- .orderByAsc(TelemetryData::getCreateTime)
|
|
|
- );
|
|
|
- for (TelemetryData d : telemetryList) {
|
|
|
- Map<String, Object> point = new LinkedHashMap<>();
|
|
|
- point.put("time", d.getCreateTime());
|
|
|
- point.put("positiveTotal", d.getMeter1PositiveTotal());
|
|
|
- point.put("temperature", d.getTemperature());
|
|
|
- point.put("flowSpeed", d.getFlowSpeed());
|
|
|
- result.add(point);
|
|
|
+ new LambdaQueryWrapper<TelemetryData>()
|
|
|
+ .eq(TelemetryData::getDeviceCode, code)
|
|
|
+ .ge(start != null, TelemetryData::getCreateTime, start)
|
|
|
+ .le(endTime != null, TelemetryData::getCreateTime, endTime)
|
|
|
+ .orderByAsc(TelemetryData::getCreateTime));
|
|
|
+ for (TelemetryData data : telemetryList) {
|
|
|
+ if (!inTimeRange(data.getCreateTime(), start, endTime)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ result.add(flowTrendPoint(device, data.getCreateTime(), data.getMeter1InstantFlow(),
|
|
|
+ data.getFlowSpeed(), data.getMeter1PositiveTotal(), data.getTemperature()));
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
- public List<Map<String, Object>> getPressureTrend24h(String equipmentId) {
|
|
|
- EquipmentBase device = equipmentBaseMapper.selectById(equipmentId);
|
|
|
+ public List<Map<String, Object>> getPressureTrend(String equipmentId, LocalDateTime startTime, LocalDateTime endTime) {
|
|
|
+ EquipmentBase device = selectMonitoringDevice(equipmentId, "pressure");
|
|
|
if (device == null || StrUtil.isBlank(device.getEquipmentCode())) {
|
|
|
return new ArrayList<>();
|
|
|
}
|
|
|
|
|
|
- LocalDateTime now = LocalDateTime.now();
|
|
|
- LocalDateTime before24h = now.minusHours(24);
|
|
|
-
|
|
|
+ LocalDateTime start = normalizeTrendStart(startTime, endTime);
|
|
|
List<FirefightingPressure> list = firefightingPressureMapper.selectList(
|
|
|
- new LambdaQueryWrapper<FirefightingPressure>().eq(FirefightingPressure::getTelemeteringStation, device.getEquipmentCode())
|
|
|
- .ge(FirefightingPressure::getCreateTime, before24h)
|
|
|
- .orderByAsc(FirefightingPressure::getCreateTime)
|
|
|
- );
|
|
|
+ new LambdaQueryWrapper<FirefightingPressure>()
|
|
|
+ .eq(FirefightingPressure::getTelemeteringStation, device.getEquipmentCode())
|
|
|
+ .ge(start != null, FirefightingPressure::getCreateTime, start)
|
|
|
+ .le(endTime != null, FirefightingPressure::getCreateTime, endTime)
|
|
|
+ .orderByAsc(FirefightingPressure::getCreateTime));
|
|
|
|
|
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
|
- for (FirefightingPressure p : list) {
|
|
|
- Map<String, Object> point = new LinkedHashMap<>();
|
|
|
- point.put("time", p.getCreateTime());
|
|
|
- point.put("pressureValue", p.getPressureValue());
|
|
|
+ for (FirefightingPressure pressure : list) {
|
|
|
+ if (!inTimeRange(pressure.getCreateTime(), start, endTime)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ Map<String, Object> point = trendPoint(device, pressure.getCreateTime());
|
|
|
+ point.put("pressureValue", pressure.getPressureValue());
|
|
|
result.add(point);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
- public List<Map<String, Object>> getLeakageTrend24h(String equipmentId) {
|
|
|
- EquipmentBase device = equipmentBaseMapper.selectById(equipmentId);
|
|
|
+ public List<Map<String, Object>> getLeakageTrend(String equipmentId, LocalDateTime startTime, LocalDateTime endTime) {
|
|
|
+ EquipmentBase device = selectMonitoringDevice(equipmentId, "leakage");
|
|
|
if (device == null || StrUtil.isBlank(device.getEquipmentCode())) {
|
|
|
return new ArrayList<>();
|
|
|
}
|
|
|
|
|
|
- LocalDateTime now = LocalDateTime.now();
|
|
|
- LocalDateTime before24h = now.minusHours(24);
|
|
|
-
|
|
|
+ LocalDateTime start = normalizeTrendStart(startTime, endTime);
|
|
|
List<NoiseInfo> list = noiseInfoMapper.selectList(
|
|
|
- new LambdaQueryWrapper<NoiseInfo>().eq(NoiseInfo::getEncode, device.getEquipmentCode())
|
|
|
- .ge(NoiseInfo::getCreateTime, before24h)
|
|
|
- .orderByAsc(NoiseInfo::getCreateTime)
|
|
|
- );
|
|
|
+ new LambdaQueryWrapper<NoiseInfo>()
|
|
|
+ .eq(NoiseInfo::getEncode, device.getEquipmentCode())
|
|
|
+ .ge(start != null, NoiseInfo::getCreateTime, start)
|
|
|
+ .le(endTime != null, NoiseInfo::getCreateTime, endTime)
|
|
|
+ .orderByAsc(NoiseInfo::getCreateTime));
|
|
|
|
|
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
|
- for (NoiseInfo n : list) {
|
|
|
- Map<String, Object> point = new LinkedHashMap<>();
|
|
|
- point.put("time", n.getCreateTime());
|
|
|
- point.put("power", n.getPower());
|
|
|
- point.put("gain", n.getGain());
|
|
|
- point.put("rms", n.getRms());
|
|
|
+ for (NoiseInfo noise : list) {
|
|
|
+ if (!inTimeRange(noise.getCreateTime(), start, endTime)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ Map<String, Object> point = trendPoint(device, noise.getCreateTime());
|
|
|
+ point.put("power", noise.getPower());
|
|
|
+ point.put("gain", noise.getGain());
|
|
|
+ point.put("rms", noise.getRms());
|
|
|
+ point.put("centerFrequency", noise.getCenterFrequency());
|
|
|
result.add(point);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
- /** Restrict the equipment query before pagination so each monitoring page only contains its sub-devices. */
|
|
|
- private void constrainToMonitoringTypes(LambdaQueryWrapper<EquipmentBase> wrapper, String monitorKind) {
|
|
|
- String[] keywords;
|
|
|
+ private List<EquipmentBase> selectMonitoringDevices(String equipmentName, String equipmentCode,
|
|
|
+ String equipmentLocation, String monitorKind) {
|
|
|
+ LambdaQueryWrapper<EquipmentBase> wrapper = new LambdaQueryWrapper<>();
|
|
|
+ wrapper.like(StrUtil.isNotBlank(equipmentName), EquipmentBase::getEquipmentName, equipmentName)
|
|
|
+ .like(StrUtil.isNotBlank(equipmentCode), EquipmentBase::getEquipmentCode, equipmentCode)
|
|
|
+ .like(StrUtil.isNotBlank(equipmentLocation), EquipmentBase::getEquipmentLocation, equipmentLocation)
|
|
|
+ .orderByDesc(EquipmentBase::getCreateTime);
|
|
|
+ Set<String> monitoringTypeIds = selectMonitoringTypeIds(monitorKind);
|
|
|
+ wrapper.in(EquipmentBase::getEquipmentTypeId,
|
|
|
+ monitoringTypeIds.isEmpty() ? Collections.singleton("__NO_WATER_MONITORING_TYPE__") : monitoringTypeIds);
|
|
|
+ return equipmentBaseMapper.selectList(wrapper);
|
|
|
+ }
|
|
|
+
|
|
|
+ private EquipmentBase selectMonitoringDevice(String equipmentId, String monitorKind) {
|
|
|
+ EquipmentBase device = equipmentBaseMapper.selectById(equipmentId);
|
|
|
+ if (device == null || StrUtil.isBlank(device.getEquipmentCode())) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ Set<String> monitoringTypeIds = selectMonitoringTypeIds(monitorKind);
|
|
|
+ return monitoringTypeIds.contains(device.getEquipmentTypeId()) ? device : null;
|
|
|
+ }
|
|
|
+
|
|
|
+ private Map<String, EquipmentType> selectTypeMap(List<EquipmentBase> devices) {
|
|
|
+ boolean anyTypePresent = devices.stream()
|
|
|
+ .map(EquipmentBase::getEquipmentTypeId)
|
|
|
+ .anyMatch(StrUtil::isNotBlank);
|
|
|
+ if (!anyTypePresent) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+ return equipmentTypeMapper.selectList(new LambdaQueryWrapper<>()).stream()
|
|
|
+ .collect(Collectors.toMap(EquipmentType::getId, Function.identity(), (left, right) -> left));
|
|
|
+ }
|
|
|
+
|
|
|
+ private Map<String, RadarData> selectLatestRadar(List<EquipmentBase> devices,
|
|
|
+ LocalDateTime startTime, LocalDateTime endTime,
|
|
|
+ Double flowMin, Double flowMax) {
|
|
|
+ List<String> deviceCodes = deviceCodes(devices);
|
|
|
+ if (deviceCodes.isEmpty()) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+ List<RadarData> records = radarDataMapper.selectList(
|
|
|
+ new LambdaQueryWrapper<RadarData>()
|
|
|
+ .in(RadarData::getDeviceCode, deviceCodes)
|
|
|
+ .ge(startTime != null, RadarData::getCreateTime, startTime)
|
|
|
+ .le(endTime != null, RadarData::getCreateTime, endTime)
|
|
|
+ .orderByDesc(RadarData::getCreateTime));
|
|
|
+ return latestBy(records, RadarData::getDeviceCode,
|
|
|
+ record -> flowInRange(record.getMeter1InstantFlow(), flowMin, flowMax)
|
|
|
+ && inTimeRange(record.getCreateTime(), startTime, endTime));
|
|
|
+ }
|
|
|
+
|
|
|
+ private Map<String, TelemetryData> selectLatestTelemetry(List<EquipmentBase> devices,
|
|
|
+ LocalDateTime startTime, LocalDateTime endTime,
|
|
|
+ Double flowMin, Double flowMax) {
|
|
|
+ List<String> deviceCodes = deviceCodes(devices);
|
|
|
+ if (deviceCodes.isEmpty()) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+ List<TelemetryData> records = telemetryDataMapper.selectList(
|
|
|
+ new LambdaQueryWrapper<TelemetryData>()
|
|
|
+ .in(TelemetryData::getDeviceCode, deviceCodes)
|
|
|
+ .ge(startTime != null, TelemetryData::getCreateTime, startTime)
|
|
|
+ .le(endTime != null, TelemetryData::getCreateTime, endTime)
|
|
|
+ .orderByDesc(TelemetryData::getCreateTime));
|
|
|
+ return latestBy(records, TelemetryData::getDeviceCode,
|
|
|
+ record -> flowInRange(record.getMeter1InstantFlow(), flowMin, flowMax)
|
|
|
+ && inTimeRange(record.getCreateTime(), startTime, endTime));
|
|
|
+ }
|
|
|
+
|
|
|
+ private <T> Map<String, T> latestBy(List<T> records, Function<T, String> codeGetter, Function<T, Boolean> qualifier) {
|
|
|
+ Map<String, T> result = new HashMap<>();
|
|
|
+ for (T record : records) {
|
|
|
+ String code = codeGetter.apply(record);
|
|
|
+ if (StrUtil.isBlank(code) || !Boolean.TRUE.equals(qualifier.apply(record))) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ T current = result.get(code);
|
|
|
+ if (current == null || getTime(record).compareTo(getTime(current)) > 0) {
|
|
|
+ result.put(code, record);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ private int compareTime(LocalDateTime left, LocalDateTime right) {
|
|
|
+ if (left == null && right == null) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (left == null) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ if (right == null) {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return left.compareTo(right);
|
|
|
+ }
|
|
|
+
|
|
|
+ private LocalDateTime getTime(Object value) {
|
|
|
+ if (value instanceof RadarData) return ((RadarData) value).getCreateTime();
|
|
|
+ if (value instanceof TelemetryData) return ((TelemetryData) value).getCreateTime();
|
|
|
+ if (value instanceof FirefightingPressure) return ((FirefightingPressure) value).getCreateTime();
|
|
|
+ if (value instanceof NoiseInfo) return ((NoiseInfo) value).getCreateTime();
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean flowInRange(String value, Double min, Double max) {
|
|
|
+ if (min == null && max == null) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ if (StrUtil.isBlank(value)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ return inRange(Double.parseDouble(value), min, max, null, null, null);
|
|
|
+ } catch (NumberFormatException e) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean inRange(Double value, Double min, Double max, LocalDateTime startTime,
|
|
|
+ LocalDateTime endTime, LocalDateTime actualTime) {
|
|
|
+ boolean timeFilterRequired = startTime != null || endTime != null;
|
|
|
+ if (timeFilterRequired && !inTimeRange(actualTime, startTime, endTime)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (min == null && max == null) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ if (value == null) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return (min == null || value >= min) && (max == null || value <= max);
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean inTimeRange(LocalDateTime value, LocalDateTime startTime, LocalDateTime endTime) {
|
|
|
+ return value != null
|
|
|
+ && (startTime == null || !value.isBefore(startTime))
|
|
|
+ && (endTime == null || !value.isAfter(endTime));
|
|
|
+ }
|
|
|
+
|
|
|
+ private <T> Page<T> emptyPage(long pageNum, long pageSize) {
|
|
|
+ return pageOf(Collections.emptyList(), pageNum, pageSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ private <T> Page<T> pageOf(List<T> records, long pageNum, long pageSize) {
|
|
|
+ long safePageNum = Math.max(pageNum, 1);
|
|
|
+ long safePageSize = Math.max(pageSize, 1);
|
|
|
+ Page<T> page = new Page<>(safePageNum, safePageSize, records.size());
|
|
|
+ int fromIndex = (int) Math.min((safePageNum - 1) * safePageSize, records.size());
|
|
|
+ int toIndex = (int) Math.min(fromIndex + safePageSize, records.size());
|
|
|
+ page.setRecords(new ArrayList<>(records.subList(fromIndex, toIndex)));
|
|
|
+ return page;
|
|
|
+ }
|
|
|
+
|
|
|
+ private List<String> deviceCodes(List<EquipmentBase> devices) {
|
|
|
+ return devices.stream()
|
|
|
+ .map(EquipmentBase::getEquipmentCode)
|
|
|
+ .filter(StrUtil::isNotBlank)
|
|
|
+ .collect(Collectors.toList());
|
|
|
+ }
|
|
|
+
|
|
|
+ private void fillBaseFields(FlowMonitoringVO vo, EquipmentBase device, EquipmentType type) {
|
|
|
+ vo.setEquipmentId(device.getEquipmentId());
|
|
|
+ vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
+ vo.setEquipmentName(device.getEquipmentName());
|
|
|
+ vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
+ vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
+ if (type != null) vo.setEquipmentTypeName(type.getTypeName());
|
|
|
+ vo.setLongitude(device.getLongitude());
|
|
|
+ vo.setLatitude(device.getLatitude());
|
|
|
+ if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
+ vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void fillBaseFields(PressureMonitoringVO vo, EquipmentBase device, EquipmentType type) {
|
|
|
+ vo.setEquipmentId(device.getEquipmentId());
|
|
|
+ vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
+ vo.setEquipmentName(device.getEquipmentName());
|
|
|
+ vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
+ vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
+ if (type != null) vo.setEquipmentTypeName(type.getTypeName());
|
|
|
+ vo.setLongitude(device.getLongitude());
|
|
|
+ vo.setLatitude(device.getLatitude());
|
|
|
+ if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
+ vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void fillBaseFields(LeakageMonitoringVO vo, EquipmentBase device, EquipmentType type) {
|
|
|
+ vo.setEquipmentId(device.getEquipmentId());
|
|
|
+ vo.setEquipmentCode(device.getEquipmentCode());
|
|
|
+ vo.setEquipmentName(device.getEquipmentName());
|
|
|
+ vo.setEquipmentLocation(device.getEquipmentLocation());
|
|
|
+ vo.setEquipmentTypeId(device.getEquipmentTypeId());
|
|
|
+ if (type != null) vo.setEquipmentTypeName(type.getTypeName());
|
|
|
+ vo.setLongitude(device.getLongitude());
|
|
|
+ vo.setLatitude(device.getLatitude());
|
|
|
+ if (device.getLongitude() != null && device.getLatitude() != null) {
|
|
|
+ vo.setGps(device.getLongitude() + "," + device.getLatitude());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private Map<String, Object> trendPoint(EquipmentBase device, LocalDateTime time) {
|
|
|
+ Map<String, Object> point = new LinkedHashMap<>();
|
|
|
+ point.put("equipmentId", device.getEquipmentId());
|
|
|
+ point.put("equipmentCode", device.getEquipmentCode());
|
|
|
+ point.put("equipmentName", device.getEquipmentName());
|
|
|
+ point.put("time", time);
|
|
|
+ return point;
|
|
|
+ }
|
|
|
+
|
|
|
+ private Map<String, Object> flowTrendPoint(EquipmentBase device, LocalDateTime time, String instantFlow,
|
|
|
+ String flowSpeed, String positiveTotal, String temperature) {
|
|
|
+ Map<String, Object> point = trendPoint(device, time);
|
|
|
+ point.put("instantFlow", instantFlow);
|
|
|
+ point.put("flowSpeed", flowSpeed);
|
|
|
+ point.put("positiveTotal", positiveTotal);
|
|
|
+ point.put("temperature", temperature);
|
|
|
+ return point;
|
|
|
+ }
|
|
|
+
|
|
|
+ private LocalDateTime normalizeTrendStart(LocalDateTime startTime, LocalDateTime endTime) {
|
|
|
+ if (startTime != null) {
|
|
|
+ return startTime;
|
|
|
+ }
|
|
|
+ return endTime != null ? null : LocalDateTime.now().minusHours(24);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Restrict monitoring pages and trends to the canonical water-supply monitoring types. */
|
|
|
+ private Set<String> selectMonitoringTypeIds(String monitorKind) {
|
|
|
+ String typeId;
|
|
|
switch (monitorKind) {
|
|
|
case "pressure":
|
|
|
- keywords = new String[]{"压力", "pressure", "消防"};
|
|
|
+ typeId = PRESSURE_TYPE_ID;
|
|
|
break;
|
|
|
case "leakage":
|
|
|
- keywords = new String[]{"漏失", "漏损", "泄漏", "噪声", "音频", "noise"};
|
|
|
+ typeId = LEAKAGE_TYPE_ID;
|
|
|
break;
|
|
|
- default:
|
|
|
- keywords = new String[]{"流量", "flow", "雷达", "遥测", "telemetry"};
|
|
|
+ case "flow":
|
|
|
+ typeId = FLOW_TYPE_ID;
|
|
|
break;
|
|
|
+ default:
|
|
|
+ return Collections.emptySet();
|
|
|
}
|
|
|
- List<EquipmentType> types = equipmentTypeMapper.selectList(new LambdaQueryWrapper<EquipmentType>());
|
|
|
- Set<String> ids = types.stream()
|
|
|
- .filter(type -> {
|
|
|
- String value = ((type.getTypeId() == null ? "" : type.getTypeId()) + " "
|
|
|
- + (type.getTypeName() == null ? "" : type.getTypeName())).toLowerCase(Locale.ROOT);
|
|
|
- return Arrays.stream(keywords).anyMatch(keyword -> value.contains(keyword.toLowerCase(Locale.ROOT)));
|
|
|
- })
|
|
|
+ List<EquipmentType> types = equipmentTypeMapper.selectList(new LambdaQueryWrapper<>());
|
|
|
+ boolean hasCanonicalWaterSupplyRoot = types.stream()
|
|
|
+ .anyMatch(type -> WATER_SUPPLY_ROOT_ID.equals(type.getId())
|
|
|
+ && WATER_SUPPLY_ROOT_TYPE_ID.equals(type.getTypeId())
|
|
|
+ && WATER_SUPPLY_ROOT_PARENT_ID.equals(type.getParentTypeId()));
|
|
|
+ if (!hasCanonicalWaterSupplyRoot) {
|
|
|
+ return Collections.emptySet();
|
|
|
+ }
|
|
|
+ return types.stream()
|
|
|
+ .filter(type -> typeId.equals(type.getTypeId()))
|
|
|
+ .filter(type -> WATER_SUPPLY_ROOT_ID.equals(type.getParentTypeId()))
|
|
|
.map(EquipmentType::getId)
|
|
|
.filter(StrUtil::isNotBlank)
|
|
|
.collect(Collectors.toSet());
|
|
|
- // Keep an empty result portable across database drivers that reject IN ().
|
|
|
- wrapper.in(EquipmentBase::getEquipmentTypeId,
|
|
|
- ids.isEmpty() ? Collections.singleton("__NO_MONITORING_TYPE__") : ids);
|
|
|
}
|
|
|
}
|
Kazerin