feat: 1.分析算法提交

jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/ShiroConfig.java

@@ -124,28 +124,14 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/sys/annountCement/show/**", "anon");
 
         //积木报表排除
-//        filterChainDefinitionMap.put("/jmreport/**", "anon");
-//        filterChainDefinitionMap.put("/**/*.js.map", "anon");
-//        filterChainDefinitionMap.put("/**/*.css.map", "anon");
         filterChainDefinitionMap.put("/test/**", "anon");
 
-        //大屏模板例子
-//        filterChainDefinitionMap.put("/test/bigScreen/**", "anon");
-//        filterChainDefinitionMap.put("/bigscreen/template1/**", "anon");
-//        filterChainDefinitionMap.put("/bigscreen/template1/**", "anon");
-        //filterChainDefinitionMap.put("/test/jeecgDemo/rabbitMqClientTest/**", "anon"); //MQ测试
-        //filterChainDefinitionMap.put("/test/jeecgDemo/html", "anon"); //模板页面
-        //filterChainDefinitionMap.put("/test/jeecgDemo/redis/**", "anon"); //redis测试
 
         //websocket排除
         filterChainDefinitionMap.put("/websocket/**", "anon");//系统通知和公告
         filterChainDefinitionMap.put("/newsWebsocket/**", "anon");//CMS模块
         filterChainDefinitionMap.put("/vxeSocket/**", "anon");//JVxeTable无痕刷新示例
 
-        //性能监控——安全隐患泄露TOEKN（durid连接池也有）
-        //filterChainDefinitionMap.put("/actuator/**", "anon");
-        //测试模块排除
-        filterChainDefinitionMap.put("/test/seata/**", "anon");
 
         // update-begin--author:liusq Date:20230522 for：[issues/4829]访问不存在的url时会提示Token失效，请重新登录呢
         //错误路径排除

jeecg-module-system/src/main/java/org/jeecg/codegenerate/CodeGenerate.java

@@ -25,11 +25,11 @@ public class CodeGenerate {
         String outputDir = projectPath + "\\jeecg-module-system\\src\\main\\java\\";
 
         // 模块名
-        String moduleName = "checkData.equipmentCheckData";
+        String moduleName = "dynamicStaticAnalysis";
 
         // 表名
         String[] tables = {
-                "t_djt_movement_tqi_report_unit_device_map",
+                "t_dsa_analysis_batch_unit_device_tqi_score",
         };
 
 

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/algorithm/AnalysisAlgorithm.java

@@ -68,7 +68,7 @@ public class AnalysisAlgorithm {
     private IMovementOverReportUnitDeviceMapService movementOverReportUnitDeviceMapService;
 
     @Resource
-    private IConfigRailVehicleTqlService configRailVehicleTqlService;
+    private IConfigRailVehicleTqiService configRailVehicleTqlService;
 
     @Resource
     private IConfigRailVehicleCheckService configRailVehicleCheckService;
@@ -77,6 +77,9 @@ public class AnalysisAlgorithm {
     private IMovementTqiReportUnitDeviceMapService movementTqiReportUnitDeviceMapService;
 
 
+    @Resource
+    private IAnalysisBatchUnitDeviceTqiScoreService analysisBatchUnitDeviceTqiScoreService;
+
     public void analysis(String analysisBatchId) {
         Map<String, Map<String, Object>> unitDeviceTable = new TreeMap<>();
 
@@ -137,6 +140,10 @@ public class AnalysisAlgorithm {
             analysisBatchUnitDeviceService.lambdaUpdate()
                     .eq(AnalysisBatchUnitDevice::getAnalysisBatchId, analysisBatchId)
                     .remove();
+            // 删除轨检车tqi得分
+            analysisBatchUnitDeviceTqiScoreService.lambdaUpdate()
+                    .eq(AnalysisBatchUnitDeviceTqiScore::getAnalysisBatchId, analysisBatch.getId())
+                    .remove();
 
 
             // 3.1 保存分析批次-单元设备
@@ -149,6 +156,7 @@ public class AnalysisAlgorithm {
             List<AnalysisBatchUnitDevice> analysisBatchUnitDevices = new ArrayList<>();
             List<AnalysisBatchUnitDeviceTransfinite> transfiniteList = new ArrayList<>();
             List<AnalysisBatchUnitDevicePointScore> scoreList = new ArrayList<>();
+            List<AnalysisBatchUnitDeviceTqiScore> tqiScoreList = new ArrayList<>();
             for (Map.Entry<String, Map<String, Object>> entry : unitDeviceTable.entrySet()) {
                 Map<String, Object> unitDevice = entry.getValue();
                 AnalysisBatchUnitDevice analysisBatchUnitDevice = new AnalysisBatchUnitDevice();
@@ -182,10 +190,10 @@ public class AnalysisAlgorithm {
                 BigDecimal railDeviceCheckScore = (BigDecimal) unitDevice.get("railDeviceCheckScore");
                 if (null == railDeviceCheckScore) {
                     analysisBatchUnitDevice.setRailDeviceCheck(0);
-                    analysisBatchUnitDevice.setAddDeviceCheckScore(new BigDecimal("-1"));
+                    analysisBatchUnitDevice.setRailDeviceCheckScore(new BigDecimal("-1"));
                 } else {
                     analysisBatchUnitDevice.setRailDeviceCheck(1);
-                    analysisBatchUnitDevice.setAddDeviceCheckScore(railDeviceCheckScore);
+                    analysisBatchUnitDevice.setRailDeviceCheckScore(railDeviceCheckScore);
                     if (unitScore == null) {
                         unitScore = railDeviceCheckScore;
                     } else {
@@ -193,6 +201,23 @@ public class AnalysisAlgorithm {
                     }
                 }
 
+
+                // 轨检车得分
+                BigDecimal railVehicleCheckScore = (BigDecimal) unitDevice.get("railVehicleCheckScore");
+                if (null == railVehicleCheckScore) {
+                    analysisBatchUnitDevice.setRailVehicleCheck(0);
+                    analysisBatchUnitDevice.setRailVehicleCheckScore(new BigDecimal("-1"));
+                } else {
+                    analysisBatchUnitDevice.setRailVehicleCheck(1);
+                    analysisBatchUnitDevice.setRailVehicleCheckScore(railVehicleCheckScore);
+                    if (unitScore == null) {
+                        unitScore = railVehicleCheckScore;
+                    } else {
+                        unitScore = unitScore.add(railVehicleCheckScore);
+                    }
+                }
+
+
                 // 计算总分
                 Integer unitScoreLevel = null;
                 String unitScoreLevelStr = "结果为空";
@@ -279,7 +304,46 @@ public class AnalysisAlgorithm {
                 }
 
 
+                // 保存轨检车检查数据超限
+                List<AnalysisBatchUnitDeviceTransfinite> railVehicleTransfiniteList = (List<AnalysisBatchUnitDeviceTransfinite>) unitDevice.get("railVehicleTransfiniteList");
+                if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
+                    for (AnalysisBatchUnitDeviceTransfinite railVehicleTransfinite : railVehicleTransfiniteList) {
+                        railVehicleTransfinite.setAnalysisBatchUnitDeviceId(analysisBatchUnitDevice.getId());
+                        railVehicleTransfinite.setAnalysisBatchId(analysisBatchUnitDevice.getAnalysisBatchId());
+                        railVehicleTransfinite.setAnalysisBatchCode(analysisBatchUnitDevice.getAnalysisBatchCode());
+                        railVehicleTransfinite.setUnitId(analysisBatchUnitDevice.getUnitId());
+                        railVehicleTransfinite.setUnitCode(analysisBatchUnitDevice.getUnitCode());
+                        railVehicleTransfinite.setUnitType(analysisBatchUnitDevice.getUnitType());
+                        railVehicleTransfinite.setUnitTypeName(analysisBatchUnitDevice.getUnitTypeName());
+                        transfiniteList.add(railVehicleTransfinite);
+                    }
+                }
+
+                // 保存轨检车检查查数据计算得分
+                List<AnalysisBatchUnitDevicePointScore> railVehicleCheckScoreList = (List<AnalysisBatchUnitDevicePointScore>) unitDevice.get("railVehicleCheckScoreList");
+                if (ObjectUtil.isNotEmpty(railVehicleCheckScoreList)) {
+                    for (AnalysisBatchUnitDevicePointScore score : railVehicleCheckScoreList) {
+                        score.setAnalysisBatchUnitDeviceId(analysisBatchUnitDevice.getId());
+                        score.setAnalysisBatchId(analysisBatchUnitDevice.getAnalysisBatchId());
+                        score.setAnalysisBatchCode(analysisBatchUnitDevice.getAnalysisBatchCode());
+                        score.setUnitId(analysisBatchUnitDevice.getUnitId());
+                        score.setUnitCode(analysisBatchUnitDevice.getUnitCode());
+                        score.setUnitType(analysisBatchUnitDevice.getUnitType());
+                        score.setUnitTypeName(analysisBatchUnitDevice.getUnitTypeName());
+                    }
+                    scoreList.addAll(railVehicleCheckScoreList);
+                }
+
+                // 保存轨检车tqi得分
+                AnalysisBatchUnitDeviceTqiScore railVehicleTqiScore = (AnalysisBatchUnitDeviceTqiScore) unitDevice.get("railVehicleTqiScore");
+                if (ObjectUtil.isNotEmpty(railVehicleTqiScore)) {
+                    railVehicleTqiScore.setAnalysisBatchUnitDeviceId(analysisBatchUnitDevice.getId());
+                    tqiScoreList.add(railVehicleTqiScore);
+                }
+
+
             }
+            analysisBatchUnitDeviceTqiScoreService.saveBatch(tqiScoreList);
             analysisBatchUnitDeviceService.saveBatch(analysisBatchUnitDevices);
             analysisBatchUnitDeviceTransfiniteService.saveBatch(transfiniteList);
             analysisBatchUnitDevicePointScoreService.saveBatch(scoreList);
@@ -456,20 +520,18 @@ public class AnalysisAlgorithm {
 
 
         // 1.5 获取轨检车TQI超限权值
-        ConfigRailVehicleTql configRailVehicleTql = configRailVehicleTqlService.lambdaQuery()
-                .eq(ConfigRailVehicleTql::getSpeedMax, analysisBatch.getSpeedMax())
-                .eq(ConfigRailVehicleTql::getSpeedMin, analysisBatch.getSpeedMin())
-                .eq(ConfigRailVehicleTql::getDelFlag, "0")
+        ConfigRailVehicleTqi configRailVehicleTqi = configRailVehicleTqlService.lambdaQuery()
+                .eq(ConfigRailVehicleTqi::getSpeedMax, analysisBatch.getSpeedMax())
+                .eq(ConfigRailVehicleTqi::getSpeedMin, analysisBatch.getSpeedMin())
+                .eq(ConfigRailVehicleTqi::getDelFlag, "0")
                 .last("limit 1")
                 .one();
 
-        // 1.6
-
         // 1-钢轨,2-曲线,3-竖曲线,4-道岔
-//        JSONObject railWeightValueJsonObject = JSONObject.parseObject(configRailVehicle.getRail());
-//        JSONObject curveWeightValueJsonObject = JSONObject.parseObject(configRailVehicle.getCurve());
-//        JSONObject verticalCurveWeightValueJsonObject = JSONObject.parseObject(configRailVehicle.getVerticalCurve());
-//        JSONObject switchWeightValueJsonObject = JSONObject.parseObject(configRailVehicle.getRailSwitch());
+        JSONObject railTqiJsonObject = JSONObject.parseObject(configRailVehicleTqi.getRail());
+        JSONObject curveTqiJsonObject = JSONObject.parseObject(configRailVehicleTqi.getCurve());
+        JSONObject verticalCurveTqiJsonObject = JSONObject.parseObject(configRailVehicleTqi.getVerticalCurve());
+        JSONObject switchTqiJsonObject = JSONObject.parseObject(configRailVehicleTqi.getRailSwitch());
 
 
         // 2. 根据分析批次的里程查询出映射单元
@@ -478,22 +540,39 @@ public class AnalysisAlgorithm {
         for (Map<String, Object> unitDevice : unitDeviceList) {
             // 1-钢轨,2-曲线,3-竖曲线,4-道岔
             Integer type = Convert.toInt(unitDevice.get("type"));
-            JSONObject jsonObject = null;
+            JSONObject weightValuesjsonObject = null;
             if (type == 1) {
-                jsonObject = railWeightValueJsonObject;
+                weightValuesjsonObject = railWeightValueJsonObject;
             } else if (type == 2) {
-                jsonObject = curveWeightValueJsonObject;
+                weightValuesjsonObject = curveWeightValueJsonObject;
             } else if (type == 3) {
-                jsonObject = verticalCurveWeightValueJsonObject;
+                weightValuesjsonObject = verticalCurveWeightValueJsonObject;
             } else if (type == 4) {
-                jsonObject = switchWeightValueJsonObject;
+                weightValuesjsonObject = switchWeightValueJsonObject;
             }
-            BigDecimal bigTrackGaugeWeightValues = jsonObject.getBigDecimal("bigTrackGauge");
-            BigDecimal smallTrackGaugeWeightValues = jsonObject.getBigDecimal("smallTrackGauge");
-            BigDecimal directionWeightValues = jsonObject.getBigDecimal("direction");
-            BigDecimal triangularPitWeightValues = jsonObject.getBigDecimal("triangularPit");
-            BigDecimal heightWeightValues = jsonObject.getBigDecimal("height");
-            BigDecimal levelWeightValues = jsonObject.getBigDecimal("level");
+            BigDecimal trackGaugeWeightValues = weightValuesjsonObject.getBigDecimal("trackGauge");
+            BigDecimal directionWeightValues = weightValuesjsonObject.getBigDecimal("direction");
+            BigDecimal triangularPitWeightValues = weightValuesjsonObject.getBigDecimal("triangularPit");
+            BigDecimal heightWeightValues = weightValuesjsonObject.getBigDecimal("height");
+            BigDecimal levelWeightValues = weightValuesjsonObject.getBigDecimal("level");
+
+
+            JSONObject tqiJsonObject = null;
+            if (type == 1) {
+                tqiJsonObject = railTqiJsonObject;
+            } else if (type == 2) {
+                tqiJsonObject = curveTqiJsonObject;
+            } else if (type == 3) {
+                tqiJsonObject = verticalCurveTqiJsonObject;
+            } else if (type == 4) {
+                tqiJsonObject = switchTqiJsonObject;
+            }
+            BigDecimal trackGaugeTqi = tqiJsonObject.getBigDecimal("trackGauge");
+            BigDecimal directionTqi = tqiJsonObject.getBigDecimal("direction");
+            BigDecimal triangularPitTqi = tqiJsonObject.getBigDecimal("triangularPit");
+            BigDecimal heightTqi = tqiJsonObject.getBigDecimal("height");
+            BigDecimal levelTqi = tqiJsonObject.getBigDecimal("level");
+            BigDecimal tqiComeUponTqi = tqiJsonObject.getBigDecimal("tqi");
 
 
             List<AnalysisBatchUnitDeviceTransfinite> railVehicleTransfiniteList = new ArrayList<>();
@@ -516,6 +595,15 @@ public class AnalysisAlgorithm {
                     if (1 == transfiniteGrade) {
                         transfinite.setTransfiniteGradeName(reasonLabelRailVehicleOver1);
                         transfinite.setIsWork(isWorkRailVehicleOver1);
+                    } else if (2 == transfiniteGrade) {
+                        transfinite.setTransfiniteGradeName(reasonLabelRailVehicleOver2);
+                        transfinite.setIsWork(isWorkRailVehicleOver2);
+                    } else if (3 == transfiniteGrade) {
+                        transfinite.setTransfiniteGradeName(reasonLabelRailVehicleOver3);
+                        transfinite.setIsWork(isWorkRailVehicleOver3);
+                    } else {
+                        transfinite.setTransfiniteGradeName(reasonLabelRailVehicleOver4);
+                        transfinite.setIsWork(isWorkRailVehicleOver4);
                     }
                     String allowValue = Convert.toBigDecimal(movementOverReport.getPeakValue()).subtract(Convert.toBigDecimal(movementOverReport.getDataDifference())).toString();
                     transfinite.setAllowValue(allowValue);
@@ -553,9 +641,13 @@ public class AnalysisAlgorithm {
             // 2.2 单元设备中心里程落在tqi【开始-结束】这个区间视为这个区间的单元设备
             // 统计单元得分
             // 统计tqi得分
+            BigDecimal sumUnitScore = BigDecimal.ZERO;
+            List<AnalysisBatchUnitDevicePointScore> scoreList = new ArrayList<>();
+            int analysisType = analysisBatch.getAnalysisType();
             for (MovementTqiReport tqiReport : tqiReports) {
                 // 如果命中处理测点映射关系
                 if (tqiReport.getStartMileage().compareTo(centerMileage) <= 0 && tqiReport.getEndMileage().compareTo(centerMileage) > 0) {
+
                     MovementTqiReportUnitDeviceMap movementTqiReportUnitDeviceMap = new MovementTqiReportUnitDeviceMap();
                     movementTqiReportUnitDeviceMap.setId(UUIDGenerator.generate());
                     movementTqiReportUnitDeviceMap.setCheckId(checkDataMap.getEkId());
@@ -587,15 +679,15 @@ public class AnalysisAlgorithm {
 
 
                     // 计算轨距得分
+                    Double finalTrackGauge = Math.abs(Convert.toDouble(tqiReport.getTrackGauge()));
                     if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
-                        Double finalTrackGauge = Convert.toDouble(tqiReport.getTrackGauge());
                         int trackGaugeSize = 1;
-                        double sumTrackGauge = Convert.toDouble(tqiReport.getTrackGauge());
+                        double sumTrackGauge = finalTrackGauge;
                         for (AnalysisBatchUnitDeviceTransfinite record : railVehicleTransfiniteList) {
-                            if ("轨距变化率".equals(record.getTransfiniteType())) {
-                                Double trackGauge = Convert.toDouble(record.getMeasurePointValue());
+                            if ("轨距".equals(record.getTransfiniteType())) {
+                                Double trackGauge = Math.abs(Convert.toDouble(record.getMeasurePointValue()));
 
-                                if (1 == analysisBatch.getAnalysisType()) { // 均值
+                                if (1 == analysisType) { // 均值
                                     sumTrackGauge = sumTrackGauge + trackGauge;
                                     trackGaugeSize++;
                                     finalTrackGauge = sumTrackGauge / trackGaugeSize;
@@ -604,51 +696,303 @@ public class AnalysisAlgorithm {
                                         finalTrackGauge = trackGauge;
                                     }
                                 }
+                            }
+                        }
+                    }
+                    BigDecimal trackGaugeUnitScore = trackGaugeWeightValues.multiply(new BigDecimal(finalTrackGauge));
+                    sumUnitScore = sumUnitScore.add(trackGaugeUnitScore);
 
+                    AnalysisBatchUnitDevicePointScore trackGaugePointScore = new AnalysisBatchUnitDevicePointScore();
+                    trackGaugePointScore.setId(UUIDGenerator.generate());
+                    trackGaugePointScore.setAnalysisType(analysisType);
+                    trackGaugePointScore.setSpeedMax(analysisBatch.getSpeedMax());
+                    trackGaugePointScore.setSpeedMin(analysisBatch.getSpeedMin());
+                    trackGaugePointScore.setAnalysisBatchId(analysisBatch.getId());
+                    trackGaugePointScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    trackGaugePointScore.setPointTypeName("轨距");
+                    trackGaugePointScore.setCheckType(3);
+                    trackGaugePointScore.setPointValue(finalTrackGauge);
+                    trackGaugePointScore.setWeightValues(trackGaugeWeightValues);
+                    trackGaugePointScore.setPointScore(trackGaugeUnitScore);
+                    scoreList.add(trackGaugePointScore);
+
+
+                    // 计算水平得分
+                    Double finalLevel = Convert.toDouble(tqiReport.getLevel());
+                    if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
+                        int levelSize = 1;
+                        double sumLevel = finalLevel;
+                        for (AnalysisBatchUnitDeviceTransfinite record : railVehicleTransfiniteList) {
+                            if (record.getTransfiniteType().contains("水平")) {
+                                Double level = Math.abs(Convert.toDouble(record.getMeasurePointValue()));
+
+                                if (1 == analysisType) { // 均值
+                                    sumLevel = sumLevel + level;
+                                    levelSize++;
+                                    finalLevel = sumLevel / levelSize;
+                                } else {    // 峰值
+                                    if (finalLevel < level) {
+                                        finalLevel = level;
+                                    }
+                                }
                             }
                         }
 
+                    }
+                    BigDecimal levelUnitScore = levelWeightValues.multiply(new BigDecimal(finalLevel));
+                    sumUnitScore = sumUnitScore.add(levelUnitScore);
+
+
+                    AnalysisBatchUnitDevicePointScore levelPointScore = new AnalysisBatchUnitDevicePointScore();
+                    levelPointScore.setId(UUIDGenerator.generate());
+                    levelPointScore.setAnalysisType(analysisType);
+                    levelPointScore.setSpeedMax(analysisBatch.getSpeedMax());
+                    levelPointScore.setSpeedMin(analysisBatch.getSpeedMin());
+                    levelPointScore.setAnalysisBatchId(analysisBatch.getId());
+                    levelPointScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    levelPointScore.setPointTypeName("水平");
+                    levelPointScore.setCheckType(3);
+                    levelPointScore.setPointValue(finalLevel);
+                    levelPointScore.setWeightValues(levelWeightValues);
+                    levelPointScore.setPointScore(levelUnitScore);
+                    scoreList.add(levelPointScore);
 
+
+                    // 计算三角坑得分
+                    Double finalTriangularPit = Math.abs(Convert.toDouble(tqiReport.getLevel()));
+                    if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
+                        int triangularPitSize = 1;
+                        double sumTriangularPit = finalTriangularPit;
+                        for (AnalysisBatchUnitDeviceTransfinite record : railVehicleTransfiniteList) {
+                            if (record.getTransfiniteType().contains("三角坑")) {
+                                Double level = Math.abs(Convert.toDouble(record.getMeasurePointValue()));
+
+                                if (1 == analysisBatch.getAnalysisType()) { // 均值
+                                    sumTriangularPit = sumTriangularPit + level;
+                                    triangularPitSize++;
+                                    finalTriangularPit = sumTriangularPit / triangularPitSize;
+                                } else {    // 峰值
+                                    if (finalTriangularPit < level) {
+                                        finalTriangularPit = level;
+                                    }
                                 }
+                            }
+                        }
+                    }
+                    BigDecimal triangularPitUnitScore = triangularPitWeightValues.multiply(new BigDecimal(finalTriangularPit));
+                    sumUnitScore = sumUnitScore.add(triangularPitUnitScore);
 
 
-                    Double finalLevel = null;
-                    Double finalTriangularPit = null;
+                    AnalysisBatchUnitDevicePointScore triangularPitPointScore = new AnalysisBatchUnitDevicePointScore();
+                    triangularPitPointScore.setId(UUIDGenerator.generate());
+                    triangularPitPointScore.setAnalysisType(analysisType);
+                    triangularPitPointScore.setSpeedMax(analysisBatch.getSpeedMax());
+                    triangularPitPointScore.setSpeedMin(analysisBatch.getSpeedMin());
+                    triangularPitPointScore.setAnalysisBatchId(analysisBatch.getId());
+                    triangularPitPointScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    triangularPitPointScore.setPointTypeName("三角坑");
+                    triangularPitPointScore.setCheckType(3);
+                    triangularPitPointScore.setPointValue(finalTriangularPit);
+                    triangularPitPointScore.setWeightValues(triangularPitWeightValues);
+                    triangularPitPointScore.setPointScore(triangularPitUnitScore);
+                    scoreList.add(triangularPitPointScore);
+
+
+                    // 计算高低得分
                     Double finalHeight = null;
-                    Double finalDirection = null;
+                    if (1 == analysisBatch.getAnalysisType()) {
+                        finalHeight = (Math.abs(Convert.toDouble(tqiReport.getHighLowLeft())) + Math.abs(Convert.toDouble(tqiReport.getHighLowRight()))) / 2;
+                    } else {
+                        if (Convert.toDouble(tqiReport.getHighLowLeft()) > Convert.toDouble(tqiReport.getHighLowRight())) {
+                            finalHeight = Math.abs(Convert.toDouble(tqiReport.getHighLowLeft()));
+                        } else {
+                            finalHeight = Math.abs(Convert.toDouble(tqiReport.getHighLowRight()));
+                        }
+                    }
+                    if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
+                        int heightSize = 1;
+                        double sumHeight = finalHeight;
+                        for (AnalysisBatchUnitDeviceTransfinite record : railVehicleTransfiniteList) {
+                            if (record.getTransfiniteType().contains("高低")) {
+                                Double level = Math.abs(Convert.toDouble(record.getMeasurePointValue()));
 
-                    double sumTrackGauge = 0;
-                    double sumLevel = 0;
-                    double sumTriangularPit = 0;
-                    double sumHeight = 0;
-                    double sumDirection = 0;
+                                if (1 == analysisBatch.getAnalysisType()) { // 均值
+                                    sumHeight = sumHeight + level;
+                                    heightSize++;
+                                    finalHeight = sumHeight / heightSize;
+                                } else {    // 峰值
+                                    if (finalHeight < level) {
+                                        finalHeight = level;
+                                    }
+                                }
+                            }
+                        }
 
-                    double maxTrackGauge = 0;
-                    double maxLevel = 0;
-                    double maxTriangularPit = 0;
-                    double maxHeight = 0;
-                    double maxDirection = 0;
+                    }
+                    BigDecimal heightUnitScore = heightWeightValues.multiply(new BigDecimal(finalHeight));
+                    sumUnitScore = sumUnitScore.add(heightUnitScore);
 
-                    double avgTrackGauge = 0;
-                    double avgLevel = 0;
-                    double avgTriangularPit = 0;
-                    double avgHeight = 0;
-                    double avgDirection = 0;
 
+                    AnalysisBatchUnitDevicePointScore heightPointScore = new AnalysisBatchUnitDevicePointScore();
+                    heightPointScore.setId(UUIDGenerator.generate());
+                    heightPointScore.setAnalysisType(analysisType);
+                    heightPointScore.setSpeedMax(analysisBatch.getSpeedMax());
+                    heightPointScore.setSpeedMin(analysisBatch.getSpeedMin());
+                    heightPointScore.setAnalysisBatchId(analysisBatch.getId());
+                    heightPointScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    heightPointScore.setPointTypeName("高低");
+                    heightPointScore.setCheckType(3);
+                    heightPointScore.setPointValue(finalHeight);
+                    heightPointScore.setWeightValues(heightWeightValues);
+                    heightPointScore.setPointScore(heightUnitScore);
+                    scoreList.add(heightPointScore);
 
-                    double levelSize = 0;
-                    double triangularPitSize = 0;
-                    double heightSize = 0;
-                    double directionSize = 0;
 
+                    // 计算轨向得分
+                    Double finalDirection = null;
+                    if (1 == analysisType) {
+                        finalDirection = (Math.abs(Convert.toDouble(tqiReport.getTrackRight())) + Math.abs(Convert.toDouble(tqiReport.getTrackLeft()))) / 2;
+                    } else {
+                        if (Convert.toDouble(tqiReport.getTrackRight()) > Convert.toDouble(tqiReport.getTrackLeft())) {
+                            finalDirection = Math.abs(Convert.toDouble(tqiReport.getTrackRight()));
+                        } else {
+                            finalDirection = Math.abs(Convert.toDouble(tqiReport.getTrackLeft()));
+                        }
+                    }
+                    if (ObjectUtil.isNotEmpty(railVehicleTransfiniteList)) {
+                        int heightSize = 1;
+                        double sumDirection = finalDirection;
+                        for (AnalysisBatchUnitDeviceTransfinite record : railVehicleTransfiniteList) {
+                            if (record.getTransfiniteType().contains("高低")) {
+                                Double level = Math.abs(Convert.toDouble(record.getMeasurePointValue()));
 
+                                if (1 == analysisType) { // 均值
+                                    sumDirection = sumDirection + level;
+                                    heightSize++;
+                                    finalDirection = sumDirection / heightSize;
+                                } else {    // 峰值
+                                    if (finalDirection < level) {
+                                        finalDirection = level;
+                                    }
                                 }
+                            }
+                        }
+                    }
+                    BigDecimal directionUnitScore = directionWeightValues.multiply(new BigDecimal(finalDirection));
+                    sumUnitScore = sumUnitScore.add(directionUnitScore);
+
+
+                    AnalysisBatchUnitDevicePointScore directionPointScore = new AnalysisBatchUnitDevicePointScore();
+                    directionPointScore.setId(UUIDGenerator.generate());
+                    directionPointScore.setAnalysisType(analysisType);
+                    directionPointScore.setSpeedMax(analysisBatch.getSpeedMax());
+                    directionPointScore.setSpeedMin(analysisBatch.getSpeedMin());
+                    directionPointScore.setAnalysisBatchId(analysisBatch.getId());
+                    directionPointScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    directionPointScore.setPointTypeName("轨向");
+                    directionPointScore.setCheckType(3);
+                    directionPointScore.setPointValue(finalDirection);
+                    directionPointScore.setWeightValues(directionWeightValues);
+                    directionPointScore.setPointScore(directionUnitScore);
+                    scoreList.add(directionPointScore);
+
+
+                    // 计算tqi的分数
+                    // 左高低
+                    BigDecimal highLowLeft = Convert.toBigDecimal(tqiReport.getHighLowLeft());
+                    BigDecimal highLowLeftScore = highLowLeft.multiply(heightTqi);
+
+                    // 右高低
+                    BigDecimal highLowRight = Convert.toBigDecimal(tqiReport.getHighLowRight());
+                    BigDecimal highLowRightScore = highLowRight.multiply(heightTqi);
 
+                    // 轨向左
+                    BigDecimal trackLeft = Convert.toBigDecimal(tqiReport.getTrackLeft());
+                    BigDecimal trackLeftScore = trackLeft.multiply(directionTqi);
+
+
+                    // 轨向右
+                    BigDecimal trackRight = Convert.toBigDecimal(tqiReport.getTrackRight());
+                    BigDecimal trackRightScore = trackRight.multiply(directionTqi);
+
+                    // 水平
+                    BigDecimal level = Convert.toBigDecimal(tqiReport.getLevel());
+                    BigDecimal levelScore = level.multiply(levelTqi);
+
+                    // 轨距
+                    BigDecimal trackGauge = Convert.toBigDecimal(tqiReport.getTrackGauge());
+                    BigDecimal trackGaugeScore = trackGauge.multiply(trackGaugeTqi);
+
+                    // 三角坑
+                    BigDecimal triangularPit = Convert.toBigDecimal(tqiReport.getTriangularPit());
+                    BigDecimal triangularPitScore = triangularPit.multiply(triangularPitTqi);
+
+
+                    // tqi
+                    BigDecimal tqiComeUpon = Convert.toBigDecimal(tqiReport.getTqiComeUpon());
+                    BigDecimal tqiComeUponScore = tqiComeUpon.multiply(tqiComeUponTqi);
+
+                    BigDecimal sumScore = highLowLeftScore.add(highLowRightScore)
+                            .add(trackLeftScore)
+                            .add(trackRightScore)
+                            .add(levelScore)
+                            .add(trackGaugeScore)
+                            .add(triangularPitScore)
+                            .add(tqiComeUponScore);
+
+                    AnalysisBatchUnitDeviceTqiScore tqiScore = new AnalysisBatchUnitDeviceTqiScore();
+                    tqiScore.setId(UUIDGenerator.generate());
+                    tqiScore.setAnalysisType(analysisType);
+                    tqiScore.setAnalysisBatchId(analysisBatch.getId());
+                    tqiScore.setAnalysisBatchCode(analysisBatch.getAnalysisBatchCode());
+                    tqiScore.setUnitId(Convert.toStr(unitDevice.get("id")));
+                    tqiScore.setUnitCode(Convert.toStr(unitDevice.get("unitCode")));
+                    tqiScore.setUnitType(Convert.toInt(unitDevice.get("type")));
+                    tqiScore.setUnitTypeName(Convert.toStr(unitDevice.get("typeName")));
+
+                    tqiScore.setHighLowLeft(highLowLeft);
+                    tqiScore.setHighLowLeftWeightValues(heightTqi);
+                    tqiScore.setHighLowLeftScore(highLowLeftScore);
+
+                    tqiScore.setHighLowRight(highLowRight);
+                    tqiScore.setHighLowRightWeightValues(heightTqi);
+                    tqiScore.setHighLowRightScore(highLowRightScore);
+
+                    tqiScore.setTrackLeft(trackLeft);
+                    tqiScore.setTrackLeftWeightValues(directionTqi);
+                    tqiScore.setTrackLeftScore(trackLeftScore);
+
+                    tqiScore.setTrackRight(trackRight);
+                    tqiScore.setTrackRightWeightValues(directionTqi);
+                    tqiScore.setTrackRightScore(trackRightScore);
+
+                    tqiScore.setLevel(level);
+                    tqiScore.setLevelWeightValues(levelTqi);
+                    tqiScore.setLevelScore(levelScore);
+
+                    tqiScore.setTrackGauge(trackGauge);
+                    tqiScore.setTrackGaugeWeightValues(trackGaugeTqi);
+                    tqiScore.setTrackGaugeScore(trackGaugeScore);
+
+                    tqiScore.setTriangularPit(triangularPit);
+                    tqiScore.setTriangularPitWeightValues(triangularPitTqi);
+                    tqiScore.setTriangularPitScore(triangularPitScore);
+
+                    tqiScore.setTqiComeUpon(tqiComeUpon);
+                    tqiScore.setTqiComeUponWeightValues(tqiComeUponTqi);
+                    tqiScore.setTqiComeUponScore(tqiComeUponScore);
+
+                    tqiScore.setSumScore(sumScore);
+
+                    unitDevice.put("railVehicleTqiScore", tqiScore);
+                    break;
                 }
 
+            }
 
-//            unitDevice.put("railDeviceCheckScore", sumUnitScore);
-//            unitDevice.put("railDeviceCheckScoreList", scoreList);
+            System.out.println(Convert.toStr(unitDevice.get("unitCode")) + "=" + sumUnitScore);
+            unitDevice.put("railVehicleCheckScore", sumUnitScore);
+            unitDevice.put("railVehicleCheckScoreList", scoreList);
 
         }
 

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/controller/ConfigRailVehicleTqlController.java → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/controller/ConfigRailVehicleTqiController.java

@@ -6,8 +6,8 @@ import io.swagger.annotations.ApiOperation;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.aspect.annotation.AutoLog;
 import org.jeecg.common.system.base.controller.JeecgController;
-import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTql;
-import org.jeecg.modules.dynamicStaticAnalysis.service.IConfigRailVehicleTqlService;
+import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTqi;
+import org.jeecg.modules.dynamicStaticAnalysis.service.IConfigRailVehicleTqiService;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -23,20 +23,20 @@ import java.util.List;
 @RestController
 @RequestMapping("/dynamicStaticAnalysis/configRailVehicleTql")
 @Api(tags = "动静态分析-配置参数-轨检车TQI超限权值")
-public class ConfigRailVehicleTqlController extends JeecgController<ConfigRailVehicleTql, IConfigRailVehicleTqlService> {
+public class ConfigRailVehicleTqiController extends JeecgController<ConfigRailVehicleTqi, IConfigRailVehicleTqiService> {
 
     @AutoLog(value = "动静态分析-配置参数-轨检车TQI超限权值-获取记录")
     @ApiOperation(value = "动静态分析-配置参数-轨检车TQI超限权值-获取记录", notes = "动静态分析-配置参数-轨检车TQI超限权值-获取记录")
     @GetMapping(value = "/listRecord")
-    public Result<List<ConfigRailVehicleTql>> listRecord() {
-        List<ConfigRailVehicleTql> records = this.service.listRecord();
+    public Result<List<ConfigRailVehicleTqi>> listRecord() {
+        List<ConfigRailVehicleTqi> records = this.service.listRecord();
         return Result.OK(records);
     }
 
     @AutoLog(value = "动静态分析-配置参数-轨检车TQI超限权值-更新参数")
     @ApiOperation(value = "动静态分析-配置参数-轨检车TQI超限权值-更新参数", notes = "动静态分析-配置参数-轨检车TQI超限权值-更新参数")
     @PostMapping(value = "/updateRecord")
-    public Result<String> updateRecord(@RequestBody ConfigRailVehicleTql record) {
+    public Result<String> updateRecord(@RequestBody ConfigRailVehicleTqi record) {
 
         this.service.updateById(record);
 

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/entity/AnalysisBatchUnitDeviceTqiScore.java

+package org.jeecg.modules.dynamicStaticAnalysis.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * <p>
+ * 动静态分析-分析批次-单元设备测点得分
+ * </p>
+ *
+ * @author hkl
+ * @since 2023-08-28
+ */
+@Getter
+@Setter
+@TableName("t_dsa_analysis_batch_unit_device_tqi_score")
+@ApiModel(value = "AnalysisBatchUnitDeviceTqiScore对象", description = "动静态分析-分析批次-单元设备测点得分")
+public class AnalysisBatchUnitDeviceTqiScore implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty("主键")
+    @TableId("id")
+    private String id;
+
+    @ApiModelProperty("创建人")
+    @TableField("create_by")
+    private String createBy;
+
+    @ApiModelProperty("创建日期")
+    @TableField("create_time")
+    private Date createTime;
+
+    @ApiModelProperty("更新人")
+    @TableField("update_by")
+    private String updateBy;
+
+    @ApiModelProperty("更新时间")
+    @TableField("update_time")
+    private Date updateTime;
+
+    @ApiModelProperty("速度下限")
+    @TableField("speed_min")
+    private Integer speedMin;
+
+    @ApiModelProperty("速度上限")
+    @TableField("speed_max")
+    private Integer speedMax;
+
+    @ApiModelProperty("分析类型 1-均值分析 2-峰值分析")
+    @TableField("analysis_type")
+    private Integer analysisType;
+
+    @ApiModelProperty("分析批次单元设备id")
+    @TableField("analysis_batch_unit_device_id")
+    private String analysisBatchUnitDeviceId;
+
+    @ApiModelProperty("分析批次号")
+    @TableField("analysis_batch_code")
+    private String analysisBatchCode;
+
+    @ApiModelProperty("分析批id")
+    @TableField("analysis_batch_id")
+    private String analysisBatchId;
+
+    @ApiModelProperty("单元设备id")
+    @TableField("unit_id")
+    private String unitId;
+
+    @ApiModelProperty("单元设备code")
+    @TableField("unit_code")
+    private String unitCode;
+
+    @ApiModelProperty("设备单元类型1-钢轨,2-曲线,3-竖曲线,4-道岔")
+    @TableField("unit_type")
+    private Integer unitType;
+
+    @ApiModelProperty("设备单元类型名称")
+    @TableField("unit_type_name")
+    private String unitTypeName;
+
+    @ApiModelProperty("测点类型")
+    @TableField("point_type_name")
+    private String pointTypeName;
+
+    @ApiModelProperty("高低左")
+    @TableField("high_low_left")
+    private BigDecimal highLowLeft;
+
+    @ApiModelProperty("高低左分数")
+    @TableField("high_low_left_score")
+    private BigDecimal highLowLeftScore;
+
+    @ApiModelProperty("高低左权值")
+    @TableField("high_low_left_weight_values")
+    private BigDecimal highLowLeftWeightValues;
+
+    @ApiModelProperty("高低右")
+    @TableField("high_low_right")
+    private BigDecimal highLowRight;
+
+    @ApiModelProperty("高低右分数")
+    @TableField("high_low_right_score")
+    private BigDecimal highLowRightScore;
+
+    @ApiModelProperty("高低右权值")
+    @TableField("high_low_right_weight_values")
+    private BigDecimal highLowRightWeightValues;
+
+    @ApiModelProperty("轨向左")
+    @TableField("track_left")
+    private BigDecimal trackLeft;
+
+    @ApiModelProperty("轨向左分数")
+    @TableField("track_left_score")
+    private BigDecimal trackLeftScore;
+
+    @ApiModelProperty("轨向左权值")
+    @TableField("track_left_weight_values")
+    private BigDecimal trackLeftWeightValues;
+
+    @ApiModelProperty("轨向右")
+    @TableField("track_right")
+    private BigDecimal trackRight;
+
+    @ApiModelProperty("轨向右分数")
+    @TableField("track_right_score")
+    private BigDecimal trackRightScore;
+
+    @ApiModelProperty("轨向右权值")
+    @TableField("track_right_weight_values")
+    private BigDecimal trackRightWeightValues;
+
+    @ApiModelProperty("水平（mm）")
+    @TableField("level")
+    private BigDecimal level;
+
+    @ApiModelProperty("水平（mm）分数")
+    @TableField("level_score")
+    private BigDecimal levelScore;
+
+    @ApiModelProperty("水平（mm）权值")
+    @TableField("level_weight_values")
+    private BigDecimal levelWeightValues;
+
+    @ApiModelProperty("轨距（mm）")
+    @TableField("track_gauge")
+    private BigDecimal trackGauge;
+
+    @ApiModelProperty("轨距（mm）分数")
+    @TableField("track_gauge_score")
+    private BigDecimal trackGaugeScore;
+
+    @ApiModelProperty("轨距（mm）权值")
+    @TableField("track_gauge_weight_values")
+    private BigDecimal trackGaugeWeightValues;
+
+    @ApiModelProperty("三角坑（mm）")
+    @TableField("triangular_pit")
+    private BigDecimal triangularPit;
+
+    @ApiModelProperty("三角坑（mm）分数")
+    @TableField("triangular_pit_score")
+    private BigDecimal triangularPitScore;
+
+    @ApiModelProperty("三角坑（mm）权值")
+    @TableField("triangular_pit_weight_values")
+    private BigDecimal triangularPitWeightValues;
+
+    @ApiModelProperty("TQI数值")
+    @TableField("tqi_come_upon")
+    private BigDecimal tqiComeUpon;
+
+    @ApiModelProperty("TQI数值分数")
+    @TableField("tqi_come_upon_score")
+    private BigDecimal tqiComeUponScore;
+
+    @ApiModelProperty("TQI数值权值")
+    @TableField("tqi_come_upon_weight_values")
+    private BigDecimal tqiComeUponWeightValues;
+
+    @ApiModelProperty("总得分")
+    @TableField("sum_score")
+    private BigDecimal sumScore;
+
+    @ApiModelProperty("备注")
+    @TableField("remark")
+    private String remark;
+
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/entity/ConfigRailVehicleTql.java → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/entity/ConfigRailVehicleTqi.java

@@ -22,9 +22,9 @@ import lombok.Setter;
  */
 @Getter
 @Setter
-@TableName("t_dsa_config_rail_vehicle_tql")
-@ApiModel(value = "ConfigRailVehicleTql对象", description = "动静态分析-配置-轨检车TQI超限权值")
-public class ConfigRailVehicleTql implements Serializable {
+@TableName("t_dsa_config_rail_vehicle_tqi")
+@ApiModel(value = "ConfigRailVehicleTql对象", description = "动静态分析-配置-轨检车TQi超限权值")
+public class ConfigRailVehicleTqi implements Serializable {
 
     private static final long serialVersionUID = 1L;
 

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/AnalysisBatchUnitDeviceTqiScoreMapper.java

+package org.jeecg.modules.dynamicStaticAnalysis.mapper;
+
+import org.jeecg.modules.dynamicStaticAnalysis.entity.AnalysisBatchUnitDeviceTqiScore;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ * 动静态分析-分析批次-单元设备测点得分 Mapper 接口
+ * </p>
+ *
+ * @author hkl
+ * @since 2023-08-28
+ */
+public interface AnalysisBatchUnitDeviceTqiScoreMapper extends BaseMapper<AnalysisBatchUnitDeviceTqiScore> {
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/ConfigRailVehicleTqlMapper.java → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/ConfigRailVehicleTqiMapper.java

 package org.jeecg.modules.dynamicStaticAnalysis.mapper;
 
-import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTql;
+import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTqi;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
 /**
@@ -11,6 +11,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  * @author hkl
  * @since 2023-08-01
  */
-public interface ConfigRailVehicleTqlMapper extends BaseMapper<ConfigRailVehicleTql> {
+public interface ConfigRailVehicleTqiMapper extends BaseMapper<ConfigRailVehicleTqi> {
 
 }

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/xml/AnalysisBatchUnitDeviceTqiScoreMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="org.jeecg.modules.dynamicStaticAnalysis.mapper.AnalysisBatchUnitDeviceTqiScoreMapper">
+
+</mapper>

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/xml/ConfigRailVehicleTqlMapper.xml → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/mapper/xml/ConfigRailVehicleTqiMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="org.jeecg.modules.dynamicStaticAnalysis.mapper.ConfigRailVehicleTqlMapper">
+<mapper namespace="org.jeecg.modules.dynamicStaticAnalysis.mapper.ConfigRailVehicleTqiMapper">
 
 </mapper>

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/other/AnalysisBatchUnitDeviceTqiScoreDTO.java

+package org.jeecg.modules.dynamicStaticAnalysis.entity;
+
+    import com.baomidou.mybatisplus.annotation.TableField;
+    import com.baomidou.mybatisplus.annotation.TableId;
+    import com.baomidou.mybatisplus.annotation.TableName;
+    import java.io.Serializable;
+    import java.math.BigDecimal;
+    import java.util.Date;
+    import io.swagger.annotations.ApiModel;
+    import io.swagger.annotations.ApiModelProperty;
+    import lombok.Getter;
+    import lombok.Setter;
+
+/**
+* <p>
+    * 动静态分析-分析批次-单元设备测点得分
+    * </p>
+*
+* @author hkl
+* @since 2023-08-28
+*/
+    @Getter
+    @Setter
+    @ApiModel(value = "AnalysisBatchUnitDeviceTqiScore对象", description = "动静态分析-分析批次-单元设备测点得分")
+
+public class AnalysisBatchUnitDeviceTqiScoreDTO {
+
+
+    private static final long serialVersionUID = 1L;
+
+            @ApiModelProperty("主键")
+    private String id;
+
+            @ApiModelProperty("创建人")
+    private String createBy;
+
+            @ApiModelProperty("创建日期")
+    private Date createTime;
+
+            @ApiModelProperty("更新人")
+    private String updateBy;
+
+            @ApiModelProperty("更新时间")
+    private Date updateTime;
+
+            @ApiModelProperty("速度下限")
+    private Integer speedMin;
+
+            @ApiModelProperty("速度上限")
+    private Integer speedMax;
+
+            @ApiModelProperty("分析类型 1-均值分析 2-峰值分析")
+    private Integer analysisType;
+
+            @ApiModelProperty("分析批次单元设备id")
+    private String analysisBatchUnitDeviceId;
+
+            @ApiModelProperty("分析批次号")
+    private String analysisBatchCode;
+
+            @ApiModelProperty("分析批id")
+    private String analysisBatchId;
+
+            @ApiModelProperty("单元设备id")
+    private String unitId;
+
+            @ApiModelProperty("单元设备code")
+    private String unitCode;
+
+            @ApiModelProperty("设备单元类型1-钢轨,2-曲线,3-竖曲线,4-道岔")
+    private Integer unitType;
+
+            @ApiModelProperty("设备单元类型名称")
+    private String unitTypeName;
+
+            @ApiModelProperty("测点类型")
+    private String pointTypeName;
+
+            @ApiModelProperty("高低左")
+    private BigDecimal highLowLeft;
+
+            @ApiModelProperty("高低左分数")
+    private BigDecimal highLowLeftScore;
+
+            @ApiModelProperty("高低左权值")
+    private BigDecimal highLowLeftWeightValues;
+
+            @ApiModelProperty("高低右")
+    private BigDecimal highLowRight;
+
+            @ApiModelProperty("高低右分数")
+    private BigDecimal highLowRightScore;
+
+            @ApiModelProperty("高低右权值")
+    private BigDecimal highLowRightWeightValues;
+
+            @ApiModelProperty("轨向左")
+    private BigDecimal trackLeft;
+
+            @ApiModelProperty("轨向左分数")
+    private BigDecimal trackLeftScore;
+
+            @ApiModelProperty("轨向左权值")
+    private BigDecimal trackLeftWeightValues;
+
+            @ApiModelProperty("轨向右")
+    private BigDecimal trackRight;
+
+            @ApiModelProperty("轨向右分数")
+    private BigDecimal trackRightScore;
+
+            @ApiModelProperty("轨向右权值")
+    private BigDecimal trackRightWeightValues;
+
+            @ApiModelProperty("水平（mm）")
+    private BigDecimal level;
+
+            @ApiModelProperty("水平（mm）分数")
+    private BigDecimal levelScore;
+
+            @ApiModelProperty("水平（mm）权值")
+    private BigDecimal levelWeightValues;
+
+            @ApiModelProperty("轨距（mm）")
+    private BigDecimal trackGauge;
+
+            @ApiModelProperty("轨距（mm）分数")
+    private BigDecimal trackGaugeScore;
+
+            @ApiModelProperty("轨距（mm）权值")
+    private BigDecimal trackGaugeWeightValues;
+
+            @ApiModelProperty("三角坑（mm）")
+    private BigDecimal triangularPit;
+
+            @ApiModelProperty("三角坑（mm）分数")
+    private BigDecimal triangularPitScore;
+
+            @ApiModelProperty("三角坑（mm）权值")
+    private BigDecimal triangularPitWeightValues;
+
+            @ApiModelProperty("TQI数值")
+    private BigDecimal tqiComeUpon;
+
+            @ApiModelProperty("TQI数值分数")
+    private BigDecimal tqiComeUponScore;
+
+            @ApiModelProperty("TQI数值权值")
+    private BigDecimal tqiComeUponWeightValues;
+
+            @ApiModelProperty("总得分")
+    private BigDecimal sumScore;
+
+            @ApiModelProperty("备注")
+    private String remark;
+
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/other/AnalysisBatchUnitDeviceTqiScoreVO.java

+package org.jeecg.modules.dynamicStaticAnalysis.entity;
+
+    import com.baomidou.mybatisplus.annotation.TableField;
+    import com.baomidou.mybatisplus.annotation.TableId;
+    import com.baomidou.mybatisplus.annotation.TableName;
+    import java.io.Serializable;
+    import java.math.BigDecimal;
+    import java.util.Date;
+    import io.swagger.annotations.ApiModel;
+    import io.swagger.annotations.ApiModelProperty;
+    import lombok.Getter;
+    import lombok.Setter;
+
+/**
+* <p>
+    * 动静态分析-分析批次-单元设备测点得分
+    * </p>
+*
+* @author hkl
+* @since 2023-08-28
+*/
+    @Getter
+    @Setter
+    @ApiModel(value = "AnalysisBatchUnitDeviceTqiScore对象", description = "动静态分析-分析批次-单元设备测点得分")
+
+public class AnalysisBatchUnitDeviceTqiScoreVO {
+
+
+    private static final long serialVersionUID = 1L;
+
+            @ApiModelProperty("主键")
+            @TableId("id")
+    private String id;
+
+            @ApiModelProperty("创建人")
+        @TableField("create_by")
+    private String createBy;
+
+            @ApiModelProperty("创建日期")
+        @TableField("create_time")
+    private Date createTime;
+
+            @ApiModelProperty("更新人")
+        @TableField("update_by")
+    private String updateBy;
+
+            @ApiModelProperty("更新时间")
+        @TableField("update_time")
+    private Date updateTime;
+
+            @ApiModelProperty("速度下限")
+        @TableField("speed_min")
+    private Integer speedMin;
+
+            @ApiModelProperty("速度上限")
+        @TableField("speed_max")
+    private Integer speedMax;
+
+            @ApiModelProperty("分析类型 1-均值分析 2-峰值分析")
+        @TableField("analysis_type")
+    private Integer analysisType;
+
+            @ApiModelProperty("分析批次单元设备id")
+        @TableField("analysis_batch_unit_device_id")
+    private String analysisBatchUnitDeviceId;
+
+            @ApiModelProperty("分析批次号")
+        @TableField("analysis_batch_code")
+    private String analysisBatchCode;
+
+            @ApiModelProperty("分析批id")
+        @TableField("analysis_batch_id")
+    private String analysisBatchId;
+
+            @ApiModelProperty("单元设备id")
+        @TableField("unit_id")
+    private String unitId;
+
+            @ApiModelProperty("单元设备code")
+        @TableField("unit_code")
+    private String unitCode;
+
+            @ApiModelProperty("设备单元类型1-钢轨,2-曲线,3-竖曲线,4-道岔")
+        @TableField("unit_type")
+    private Integer unitType;
+
+            @ApiModelProperty("设备单元类型名称")
+        @TableField("unit_type_name")
+    private String unitTypeName;
+
+            @ApiModelProperty("测点类型")
+        @TableField("point_type_name")
+    private String pointTypeName;
+
+            @ApiModelProperty("高低左")
+        @TableField("high_low_left")
+    private BigDecimal highLowLeft;
+
+            @ApiModelProperty("高低左分数")
+        @TableField("high_low_left_score")
+    private BigDecimal highLowLeftScore;
+
+            @ApiModelProperty("高低左权值")
+        @TableField("high_low_left_weight_values")
+    private BigDecimal highLowLeftWeightValues;
+
+            @ApiModelProperty("高低右")
+        @TableField("high_low_right")
+    private BigDecimal highLowRight;
+
+            @ApiModelProperty("高低右分数")
+        @TableField("high_low_right_score")
+    private BigDecimal highLowRightScore;
+
+            @ApiModelProperty("高低右权值")
+        @TableField("high_low_right_weight_values")
+    private BigDecimal highLowRightWeightValues;
+
+            @ApiModelProperty("轨向左")
+        @TableField("track_left")
+    private BigDecimal trackLeft;
+
+            @ApiModelProperty("轨向左分数")
+        @TableField("track_left_score")
+    private BigDecimal trackLeftScore;
+
+            @ApiModelProperty("轨向左权值")
+        @TableField("track_left_weight_values")
+    private BigDecimal trackLeftWeightValues;
+
+            @ApiModelProperty("轨向右")
+        @TableField("track_right")
+    private BigDecimal trackRight;
+
+            @ApiModelProperty("轨向右分数")
+        @TableField("track_right_score")
+    private BigDecimal trackRightScore;
+
+            @ApiModelProperty("轨向右权值")
+        @TableField("track_right_weight_values")
+    private BigDecimal trackRightWeightValues;
+
+            @ApiModelProperty("水平（mm）")
+        @TableField("level")
+    private BigDecimal level;
+
+            @ApiModelProperty("水平（mm）分数")
+        @TableField("level_score")
+    private BigDecimal levelScore;
+
+            @ApiModelProperty("水平（mm）权值")
+        @TableField("level_weight_values")
+    private BigDecimal levelWeightValues;
+
+            @ApiModelProperty("轨距（mm）")
+        @TableField("track_gauge")
+    private BigDecimal trackGauge;
+
+            @ApiModelProperty("轨距（mm）分数")
+        @TableField("track_gauge_score")
+    private BigDecimal trackGaugeScore;
+
+            @ApiModelProperty("轨距（mm）权值")
+        @TableField("track_gauge_weight_values")
+    private BigDecimal trackGaugeWeightValues;
+
+            @ApiModelProperty("三角坑（mm）")
+        @TableField("triangular_pit")
+    private BigDecimal triangularPit;
+
+            @ApiModelProperty("三角坑（mm）分数")
+        @TableField("triangular_pit_score")
+    private BigDecimal triangularPitScore;
+
+            @ApiModelProperty("三角坑（mm）权值")
+        @TableField("triangular_pit_weight_values")
+    private BigDecimal triangularPitWeightValues;
+
+            @ApiModelProperty("TQI数值")
+        @TableField("tqi_come_upon")
+    private BigDecimal tqiComeUpon;
+
+            @ApiModelProperty("TQI数值分数")
+        @TableField("tqi_come_upon_score")
+    private BigDecimal tqiComeUponScore;
+
+            @ApiModelProperty("TQI数值权值")
+        @TableField("tqi_come_upon_weight_values")
+    private BigDecimal tqiComeUponWeightValues;
+
+            @ApiModelProperty("总得分")
+        @TableField("sum_score")
+    private BigDecimal sumScore;
+
+            @ApiModelProperty("备注")
+        @TableField("remark")
+    private String remark;
+
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/IAnalysisBatchUnitDeviceTqiScoreService.java

+package org.jeecg.modules.dynamicStaticAnalysis.service;
+
+import org.jeecg.modules.dynamicStaticAnalysis.entity.AnalysisBatchUnitDeviceTqiScore;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 动静态分析-分析批次-单元设备测点得分 服务类
+ * </p>
+ *
+ * @author hkl
+ * @since 2023-08-28
+ */
+public interface IAnalysisBatchUnitDeviceTqiScoreService extends IService<AnalysisBatchUnitDeviceTqiScore> {
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/IConfigRailVehicleTqlService.java → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/IConfigRailVehicleTqiService.java

 package org.jeecg.modules.dynamicStaticAnalysis.service;
 
-import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTql;
+import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTqi;
 import com.baomidou.mybatisplus.extension.service.IService;
 
 import java.util.List;
@@ -13,7 +13,7 @@ import java.util.List;
  * @author hkl
  * @since 2023-08-01
  */
-public interface IConfigRailVehicleTqlService extends IService<ConfigRailVehicleTql> {
+public interface IConfigRailVehicleTqiService extends IService<ConfigRailVehicleTqi> {
 
-    List<ConfigRailVehicleTql> listRecord();
+    List<ConfigRailVehicleTqi> listRecord();
 }

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/impl/AnalysisBatchUnitDeviceTqiScoreServiceImpl.java

+package org.jeecg.modules.dynamicStaticAnalysis.service.impl;
+
+import org.jeecg.modules.dynamicStaticAnalysis.entity.AnalysisBatchUnitDeviceTqiScore;
+import org.jeecg.modules.dynamicStaticAnalysis.mapper.AnalysisBatchUnitDeviceTqiScoreMapper;
+import org.jeecg.modules.dynamicStaticAnalysis.service.IAnalysisBatchUnitDeviceTqiScoreService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 动静态分析-分析批次-单元设备测点得分 服务实现类
+ * </p>
+ *
+ * @author hkl
+ * @since 2023-08-28
+ */
+@Service
+public class AnalysisBatchUnitDeviceTqiScoreServiceImpl extends ServiceImpl<AnalysisBatchUnitDeviceTqiScoreMapper, AnalysisBatchUnitDeviceTqiScore> implements IAnalysisBatchUnitDeviceTqiScoreService {
+
+}

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/impl/ConfigInstrumentCheckServiceImpl.java

 package org.jeecg.modules.dynamicStaticAnalysis.service.impl;
 
 import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigInstrumentCheck;
-import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTql;
 import org.jeecg.modules.dynamicStaticAnalysis.mapper.ConfigInstrumentCheckMapper;
 import org.jeecg.modules.dynamicStaticAnalysis.service.IConfigInstrumentCheckService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/impl/ConfigRailVehicleTqlServiceImpl.java → jeecg-module-system/src/main/java/org/jeecg/modules/dynamicStaticAnalysis/service/impl/ConfigRailVehicleTqiServiceImpl.java

 package org.jeecg.modules.dynamicStaticAnalysis.service.impl;
 
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTql;
-import org.jeecg.modules.dynamicStaticAnalysis.mapper.ConfigRailVehicleTqlMapper;
-import org.jeecg.modules.dynamicStaticAnalysis.service.IConfigRailVehicleTqlService;
+import org.jeecg.modules.dynamicStaticAnalysis.entity.ConfigRailVehicleTqi;
+import org.jeecg.modules.dynamicStaticAnalysis.mapper.ConfigRailVehicleTqiMapper;
+import org.jeecg.modules.dynamicStaticAnalysis.service.IConfigRailVehicleTqiService;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -17,11 +17,11 @@ import java.util.List;
  * @since 2023-08-01
  */
 @Service
-public class ConfigRailVehicleTqlServiceImpl extends ServiceImpl<ConfigRailVehicleTqlMapper, ConfigRailVehicleTql> implements IConfigRailVehicleTqlService {
+public class ConfigRailVehicleTqiServiceImpl extends ServiceImpl<ConfigRailVehicleTqiMapper, ConfigRailVehicleTqi> implements IConfigRailVehicleTqiService {
 
     @Override
-    public List<ConfigRailVehicleTql> listRecord() {
-        List<ConfigRailVehicleTql> records = this.lambdaQuery().eq(ConfigRailVehicleTql::getDelFlag, "0").list();
+    public List<ConfigRailVehicleTqi> listRecord() {
+        List<ConfigRailVehicleTqi> records = this.lambdaQuery().eq(ConfigRailVehicleTqi::getDelFlag, "0").list();
         return records;
     }
 }

jeecg-module-system/src/main/resources/application.yml

@@ -2,4 +2,4 @@ spring:
   application:
     name: jeecg-system
   profiles:
-    active: hkl
+    active: test

subwayOA-app/src/main/resources/application.yml

@@ -2,4 +2,4 @@ spring:
   application:
     name: subwayOA-app
   profiles:
-    active: dev
+    active: test