1、维修金额设置上限：

2、维修金额不收取同类型现象多次人工费

watero-rst-service/src/main/java/com/iamberry/rst/service/fm/ComplaintDetectInfoServiceImpl.java

@@ -41,10 +41,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.text.MessageFormat;
 import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
 
 @Service
 public class ComplaintDetectInfoServiceImpl implements ComplaintDetectInfoService {
@@ -81,6 +78,8 @@ public class ComplaintDetectInfoServiceImpl implements ComplaintDetectInfoServic
     @Autowired
     private DetectTransportMapper detectTransportMapper;
 
+    private static final int MAX_MAINTAIN_PRICE = 500_00;
+
     @Override
     public ComplaintDetectInfo getDetectByMachine(String machine) {
         return complaintDetectInfoMapper.getDetectByMachine(machine);
@@ -451,13 +450,34 @@ public class ComplaintDetectInfoServiceImpl implements ComplaintDetectInfoServic
                                 record.setDetectState(34);
                                 record.setDetectOffer(0);
                             } else {
+                                // 系统检测，若维修类型为同一个时，再次递增同类型的问题现象，不收取维修费用
+                                Map<Integer, Integer> maintainType = new HashMap<>(5);
                                 for (Integer id : record.getDetectPhenomenonIds()) {
+                                    // 计算维修费用
+                                    MaintainPhenomenon phenomenon = null;
                                     if (record.getDetectOffer() == null) {
-                                        record.setDetectOffer(phenomenonMapper.get(id).getPhenomenonMaintainPrice());
+                                        phenomenon = phenomenonMapper.get(id);
+                                        record.setDetectOffer(phenomenon.getPhenomenonMaintainPrice());
+                                    } else {
+                                        phenomenon = phenomenonMapper.get(id);
+                                        record.setDetectOffer(record.getDetectOffer() + phenomenon.getPhenomenonMaintainPrice());
+                                    }
+                                    // 保存问题类型出现的次数
+                                    Integer val = maintainType.get(phenomenon.getTypeId());
+                                    if (val == null) {
+                                        maintainType.put(phenomenon.getTypeId(), 0);
                                     } else {
-                                        record.setDetectOffer(record.getDetectOffer() + phenomenonMapper.get(id).getPhenomenonMaintainPrice());
+                                        maintainType.put(phenomenon.getTypeId(), val++);
                                     }
                                 }
+                                // 减去同类型问题现象的拆机费用
+                                maintainType.forEach((k, v) -> {
+                                    record.setDetectOffer(record.getDetectOffer()-v*50_00);
+                                });
+                                // 系统设置最高的维修价格上限，当超过最高的维修上限时，使用最高的维修价格
+                                if (record.getDetectOffer() > MAX_MAINTAIN_PRICE) {
+                                    record.setDetectOffer(MAX_MAINTAIN_PRICE);
+                                }
                                 record.setDetectState(30);
                             }
                         }else if(record.getIsMaintenance() == 2){
@@ -467,12 +487,33 @@ public class ComplaintDetectInfoServiceImpl implements ComplaintDetectInfoServic
                         }
                     } else {
                         // 质保期外(付费维修) , 并且机器非检测待定的
+                        // 系统检测，若维修类型为同一个时，再次递增同类型的问题现象，不收取维修费用
+                        Map<Integer, Integer> maintainType = new HashMap<>(5);
                         for (Integer id : record.getDetectPhenomenonIds()) {
+                            // 计算维修费用
+                            MaintainPhenomenon phenomenon = null;
                             if (record.getDetectOffer() == null) {
-                                record.setDetectOffer(phenomenonMapper.get(id).getPhenomenonMaintainPrice());
+                                phenomenon = phenomenonMapper.get(id);
+                                record.setDetectOffer(phenomenon.getPhenomenonMaintainPrice());
                             } else {
-                                record.setDetectOffer(record.getDetectOffer() + phenomenonMapper.get(id).getPhenomenonMaintainPrice());
+                                phenomenon = phenomenonMapper.get(id);
+                                record.setDetectOffer(record.getDetectOffer() + phenomenon.getPhenomenonMaintainPrice());
                             }
+                            // 保存问题类型出现的次数
+                            Integer val = maintainType.get(phenomenon.getTypeId());
+                            if (val == null) {
+                                maintainType.put(phenomenon.getTypeId(), 0);
+                            } else {
+                                maintainType.put(phenomenon.getTypeId(), val++);
+                            }
+                        }
+                        // 减去同类型问题现象的拆机费用
+                        maintainType.forEach((k, v) -> {
+                            record.setDetectOffer(record.getDetectOffer()-v*50_00);
+                        });
+                        // 系统设置最高的维修价格上限，当超过最高的维修上限时，使用最高的维修价格
+                        if (record.getDetectOffer() > MAX_MAINTAIN_PRICE) {
+                            record.setDetectOffer(MAX_MAINTAIN_PRICE);
                         }
                         record.setDetectState(30);
                     }