完善监测点管理

pipe-network-service/zksy-system/src/main/java/com/zksy/base/service/impl/MonitorPointServiceImpl.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.zksy.base.domain.EquipmentBase;
 import com.zksy.base.domain.EquipmentPointRel;
+import com.zksy.base.domain.EquipmentType;
 import com.zksy.base.domain.MonitorPoint;
 import com.zksy.base.enums.MonitorPointTypeEnum;
 import com.zksy.base.mapper.EquipmentBaseMapper;
@@ -105,10 +106,15 @@ public class MonitorPointServiceImpl extends ServiceImpl<MonitorPointMapper, Mon
     @Transactional
     public boolean updateWithCheck(MonitorPoint entity) {
         String pointId = entity.getPointId();
-        if (this.getById(pointId) == null) {
+        MonitorPoint existingPoint = this.getById(pointId);
+        if (existingPoint == null) {
             throw new ServiceException("监测点不存在，无法修改：" + pointId);
         }
         validatePointType(entity.getPointType());
+        if (!Objects.equals(existingPoint.getPointType(), entity.getPointType())
+                && equipmentCount(pointId) > 0) {
+            throw new ServiceException("监测点已关联设备，不能修改监测点类型，请先解除全部设备关联");
+        }
 
         String newCode = entity.getPointCode();
         if (newCode != null) {
@@ -182,12 +188,16 @@ public class MonitorPointServiceImpl extends ServiceImpl<MonitorPointMapper, Mon
             throw new ServiceException("设备ID列表不能为空");
         }
         equipmentIds = new ArrayList<>(new LinkedHashSet<>(equipmentIds));
+        Map<Integer, EquipmentType> equipmentTypeMap = loadEquipmentTypeMap();
 
         for (String equipmentId : equipmentIds) {
             EquipmentBase equipment = equipmentBaseMapper.selectById(equipmentId);
             if (equipment == null) {
                 throw new ServiceException("设备不存在：" + equipmentId);
             }
+            if (!belongsToPointType(equipment.getEquipmentTypeId(), point.getPointType(), equipmentTypeMap)) {
+                throw new ServiceException("设备[" + equipment.getEquipmentCode() + "]类型与监测点类型不匹配");
+            }
             LambdaQueryWrapper<EquipmentPointRel> checkWrapper = new LambdaQueryWrapper<>();
             checkWrapper.eq(EquipmentPointRel::getEquipmentId, equipmentId);
             List<EquipmentPointRel> existing = equipmentPointRelMapper.selectList(checkWrapper);
@@ -271,11 +281,18 @@ public class MonitorPointServiceImpl extends ServiceImpl<MonitorPointMapper, Mon
 
     @Override
     public List<Map<String, Object>> listEquipmentForAssociation(String pointId) {
+        MonitorPoint point = this.getById(pointId);
+        if (point == null) {
+            throw new ServiceException("监测点不存在：" + pointId);
+        }
         Map<String, String> ownerByEquipment = equipmentPointRelMapper.selectList(new LambdaQueryWrapper<>()).stream()
                 .filter(rel -> rel.getEquipmentId() != null)
                 .collect(Collectors.toMap(EquipmentPointRel::getEquipmentId, EquipmentPointRel::getPointId, (left, right) -> left));
-        List<EquipmentBase> devices = equipmentBaseMapper.selectList(null);
-        fillEquipmentTypeNames(devices);
+        Map<Integer, EquipmentType> equipmentTypeMap = loadEquipmentTypeMap();
+        List<EquipmentBase> devices = equipmentBaseMapper.selectList(null).stream()
+                .filter(device -> belongsToPointType(device.getEquipmentTypeId(), point.getPointType(), equipmentTypeMap))
+                .collect(Collectors.toList());
+        fillEquipmentTypeNames(devices, equipmentTypeMap);
         return devices.stream().map(device -> {
             Map<String, Object> row = new LinkedHashMap<>();
             row.put("equipmentId", device.getEquipmentId());
@@ -291,14 +308,35 @@ public class MonitorPointServiceImpl extends ServiceImpl<MonitorPointMapper, Mon
 
     private void fillEquipmentTypeNames(List<EquipmentBase> devices) {
         if (devices == null || devices.isEmpty()) return;
-        Set<Integer> typeIds = devices.stream()
-                .map(EquipmentBase::getEquipmentTypeId)
-                .filter(Objects::nonNull)
-                .collect(Collectors.toSet());
-        if (typeIds.isEmpty()) return;
-        equipmentTypeMapper.selectBatchIds(typeIds).forEach(type -> devices.stream()
-                .filter(device -> Objects.equals(device.getEquipmentTypeId(), type.getId()))
-                .forEach(device -> device.setEquipmentTypeName(type.getTypeName())));
+        fillEquipmentTypeNames(devices, loadEquipmentTypeMap());
+    }
+
+    private void fillEquipmentTypeNames(List<EquipmentBase> devices, Map<Integer, EquipmentType> equipmentTypeMap) {
+        if (devices == null || devices.isEmpty()) return;
+        devices.forEach(device -> {
+            EquipmentType type = equipmentTypeMap.get(device.getEquipmentTypeId());
+            device.setEquipmentTypeName(type == null ? null : type.getTypeName());
+        });
+    }
+
+    private Map<Integer, EquipmentType> loadEquipmentTypeMap() {
+        return equipmentTypeMapper.selectList(null).stream()
+                .collect(Collectors.toMap(EquipmentType::getId, type -> type, (left, right) -> left));
+    }
+
+    private boolean belongsToPointType(Integer equipmentTypeId, Integer pointType,
+                                       Map<Integer, EquipmentType> equipmentTypeMap) {
+        if (pointType == null) return true;
+        if (equipmentTypeId == null) return false;
+        Integer currentTypeId = equipmentTypeId;
+        Set<Integer> visited = new HashSet<>();
+        while (currentTypeId != null && currentTypeId != 0 && visited.add(currentTypeId)) {
+            if (Objects.equals(currentTypeId, pointType)) return true;
+            EquipmentType currentType = equipmentTypeMap.get(currentTypeId);
+            if (currentType == null) return false;
+            currentTypeId = currentType.getParentId();
+        }
+        return false;
     }
 
     private long equipmentCount(String pointId) {

pipe-network-service/zksy-system/src/main/java/com/zksy/drainage/service/impl/DrainageEquipmentPointRelServiceImpl.java

@@ -5,9 +5,11 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.zksy.base.domain.EquipmentBase;
 import com.zksy.base.domain.EquipmentPointRel;
+import com.zksy.base.domain.EquipmentType;
 import com.zksy.base.domain.MonitorPoint;
 import com.zksy.base.mapper.EquipmentBaseMapper;
 import com.zksy.base.mapper.EquipmentPointRelMapper;
+import com.zksy.base.mapper.EquipmentTypeMapper;
 import com.zksy.base.mapper.MonitorPointMapper;
 import com.zksy.common.exception.ServiceException;
 import com.zksy.drainage.service.DrainageEquipmentPointRelService;
@@ -19,6 +21,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -33,6 +36,9 @@ public class DrainageEquipmentPointRelServiceImpl extends ServiceImpl<EquipmentP
     @Autowired
     private MonitorPointMapper monitorPointMapper;
 
+    @Autowired
+    private EquipmentTypeMapper equipmentTypeMapper;
+
     @Override
     public Page<EquipmentPointRel> findByPage(long pageNum, long pageSize,
                                               String equipmentId, String pointId) {
@@ -65,6 +71,7 @@ public class DrainageEquipmentPointRelServiceImpl extends ServiceImpl<EquipmentP
         if (monitorPointMapper.selectById(pointId) == null) {
             throw new ServiceException("关联的监测点不存在：" + pointId);
         }
+        validateEquipmentType(entity);
         // 校验是否已存在相同关联
         LambdaQueryWrapper<EquipmentPointRel> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(EquipmentPointRel::getEquipmentId, equipmentId)
@@ -112,6 +119,17 @@ public class DrainageEquipmentPointRelServiceImpl extends ServiceImpl<EquipmentP
         if (!invalidPointIds.isEmpty()) {
             throw new ServiceException("存在无效的监测点ID：" + invalidPointIds);
         }
+        Map<Integer, EquipmentType> typeMap = equipmentTypeMapper.selectList(null).stream()
+                .collect(Collectors.toMap(EquipmentType::getId, type -> type, (left, right) -> left));
+        Map<String, MonitorPoint> pointMap = monitorPointMapper.selectBatchIds(pointIds).stream()
+                .collect(Collectors.toMap(MonitorPoint::getPointId, point -> point));
+        Map<String, EquipmentBase> equipmentMap = equipmentBaseMapper.selectBatchIds(equipmentIds).stream()
+                .collect(Collectors.toMap(EquipmentBase::getEquipmentId, equipment -> equipment));
+        for (EquipmentPointRel relation : entityList) {
+            if (!belongsToPointType(equipmentMap.get(relation.getEquipmentId()), pointMap.get(relation.getPointId()), typeMap)) {
+                throw new ServiceException("设备与监测点类型不匹配：" + relation.getEquipmentId());
+            }
+        }
         Set<String> duplicateEquipmentIds = equipmentIds.stream()
                 .filter(equipmentId -> this.count(new LambdaQueryWrapper<EquipmentPointRel>()
                         .eq(EquipmentPointRel::getEquipmentId, equipmentId)) > 0)
@@ -152,4 +170,30 @@ public class DrainageEquipmentPointRelServiceImpl extends ServiceImpl<EquipmentP
         wrapper.eq(EquipmentPointRel::getPointId, pointId);
         return this.list(wrapper);
     }
+
+    private void validateEquipmentType(EquipmentPointRel relation) {
+        MonitorPoint point = monitorPointMapper.selectById(relation.getPointId());
+        EquipmentBase equipment = equipmentBaseMapper.selectById(relation.getEquipmentId());
+        Map<Integer, EquipmentType> typeMap = equipmentTypeMapper.selectList(null).stream()
+                .collect(Collectors.toMap(EquipmentType::getId, type -> type, (left, right) -> left));
+        if (!belongsToPointType(equipment, point, typeMap)) {
+            throw new ServiceException("设备与监测点类型不匹配：" + relation.getEquipmentId());
+        }
+    }
+
+    private boolean belongsToPointType(EquipmentBase equipment, MonitorPoint point,
+                                       Map<Integer, EquipmentType> typeMap) {
+        if (point == null) return false;
+        if (point.getPointType() == null) return true;
+        if (equipment == null || equipment.getEquipmentTypeId() == null) return false;
+        Integer currentId = equipment.getEquipmentTypeId();
+        Set<Integer> visited = new java.util.HashSet<>();
+        while (currentId != null && currentId != 0 && visited.add(currentId)) {
+            if (point.getPointType().equals(currentId)) return true;
+            EquipmentType type = typeMap.get(currentId);
+            if (type == null) return false;
+            currentId = type.getParentId();
+        }
+        return false;
+    }
 }