新增：浙江准确率计算，根据每日上报多个文件的数据，计算多个准确率求平均

pom.xml

@@ -10,8 +10,8 @@
     </parent>
     <groupId>com.syjy</groupId>
     <artifactId>calculation-spring-boot-starter</artifactId>
-    <!--<version>0.0.8</version>-->
-    <version>0.0.8-SNAPSHOT</version>
+    <version>0.0.9</version>
+    <!--<version>0.0.9-SNAPSHOT</version>-->
     <name>calculation</name>
     <description>Demo project for Spring Boot</description>
     <properties>

src/main/java/com/syjy/calculate/entity/CalculateResult.java

@@ -41,6 +41,9 @@ public class CalculateResult extends HashMap<String, Object> {
     /** 冒号 */
     public static final String COLON = ":";
 
+    /** 逗号 */
+    public static final String COMMA = ",";
+
     /** 忽略 */
     public static final String IGNORE = "666";
 
@@ -132,6 +135,8 @@ public class CalculateResult extends HashMap<String, Object> {
 
     public static final String MSG_CALCULATE_DATA_NULL = "无可用数据计算";
     public static final String MSG_CAP_NULL = "容量为空/0，不予考核";
+    public static final String MSG_GEN_TIME_NULL = "数据生成时间为空";
+    public static final String MSG_DATA_SOURCE_TYPE_NULL = "数据文件类型为空";
     public static final String MSG_DATA_CHECK_ERROR = "数据校验错误";
     public static final String MSG_NO_FORMULA = "未匹配到公式:";
     public static final String MSG_CALCULATE_SUCCESS = "计算成功";

src/main/java/com/syjy/calculate/entity/CalculationFormula.java

@@ -68,8 +68,13 @@ public class CalculationFormula extends PageReq {
     /**
      * 状态
      */
-
     private String state;
+
+    /**
+     * 生成预测文件类型
+     */
+    private String dataSourceType;
+
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
     @DateTimeFormat(pattern = "yyyy-MM-dd")
     private Date createTime;

src/main/java/com/syjy/calculate/entity/CalculationInfo.java

@@ -4,6 +4,7 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 import java.io.Serializable;
 import java.math.BigDecimal;
+import java.util.Date;
 
 /**
  * 计算公式的入参
@@ -23,6 +24,17 @@ public class CalculationInfo implements Serializable  {
      */
     private long time;
 
+
+    /**
+     * 预测数据生成时间
+     */
+    private Date genTime;
+
+    /**
+     * 文件数据类型
+     */
+    private String dataSourceType;
+
     // PowerStationStatusData 相关数据
     /**
      * 人工判断是否限电

src/main/java/com/syjy/calculate/service/AccuracyPassRateCalculateService.java

@@ -41,8 +41,10 @@ public class AccuracyPassRateCalculateService {
             // 未匹配到公式
             return CalculateResult.error(CalculateResult.MSG_NO_FORMULA);
         }
+        // 获取数据文件类型
+        String dataSourceType = calculationFormula.getDataSourceType();
         // 对细则进行校验
-        CalculateResult checkedDataResult = checkDataRules(calculateRequest);
+        CalculateResult checkedDataResult = checkDataRules(calculateRequest, dataSourceType);
         // 如果细则校验失败，返回细则结果
         if (!String.valueOf(checkedDataResult.get(CalculateResult.CODE_TAG)).equals(CalculateResult.Type.SUCCESS.value())) {
             return checkedDataResult;
@@ -56,12 +58,18 @@ public class AccuracyPassRateCalculateService {
         // 获取公式
         String formula = calculationFormula.getFormula();
         // 初始化公式并获取缓存的公式
-        String scriptName = common.initFormula(formula,calculateRequest.getProvince(),calculateRequest.getFormulaType(),calculateRequest.getElectricType(),CalculateResult.FORMULA);
-
+        String scriptName = common.initFormula(formula, calculateRequest.getProvince(), calculateRequest.getFormulaType(), calculateRequest.getElectricType(), CalculateResult.FORMULA);
         // 上下文
         Map<String, Object> env = new HashMap<>();
+        // 如果是多日多文件计算准确率，则将数据根据日期和文件类型分组，并放入list中
+        if (calculationFormula.getDataSourceType() != null) {
+            List<List<Map<String, Object>>> groupingList = groupingList(checkedData, calculationFormula.getDataSourceType());
+            env.put(CalculateResult.LIST, groupingList);
+        } else {
+            env.put(CalculateResult.LIST, checkedData);
+        }
+
         // 将需要计算的list数据放入上下文
-        env.put(CalculateResult.LIST, checkedData);
         env.put(CalculateResult.CAPACITY, calculateRequest.getElectricCapacity());
         env.put(CalculateResult.SIGN, calculateRequest.getSign());
 
@@ -83,7 +91,7 @@ public class AccuracyPassRateCalculateService {
             Object executeResult = AviatorEvaluator.getInstance().getCachedExpressionByKey(scriptName).execute(env);
             String result = String.valueOf(executeResult);
             // 过滤计算结果
-            if(calculationFormula.getIsRate().equals(CalculateResult.STR_TRUE)){
+            if (calculationFormula.getIsRate().equals(CalculateResult.STR_TRUE)) {
                 result = filterResult(executeResult);
             }
             log.info("--------------------准确率计算结束--------------------");
@@ -129,9 +137,10 @@ public class AccuracyPassRateCalculateService {
      * 根据细则过滤数据
      *
      * @param calculateRequest
+     * @param calculateRequest
      * @return
      */
-    private CalculateResult checkDataRules(CalculateRequest calculateRequest) {
+    private CalculateResult checkDataRules(CalculateRequest calculateRequest, String dataSourceType) {
         // 对入参进行校验
         if (calculateRequest == null) {
             return CalculateResult.error(CalculateResult.MSG_REQUEST_NULL);
@@ -160,6 +169,7 @@ public class AccuracyPassRateCalculateService {
         }
         // 获取被校验数据
         List<CalculationInfo> calculationInfoList = calculateRequest.getCalculationInfoList();
+
         // 计算数据为空
         if (calculationInfoList == null || calculationInfoList.size() == 0) {
             return CalculateResult.error(CalculateResult.MSG_CALCULATE_DATA_NULL);
@@ -180,12 +190,23 @@ public class AccuracyPassRateCalculateService {
             if (calculationInfoList.get(i).getOpenCapacity() == null || calculationInfoList.get(i).getOpenCapacity().compareTo(BigDecimal.ZERO) == 0) {
                 return CalculateResult.error(CalculateResult.MSG_CAP_NULL);
             }
+
+            // 如果数据文件类型不为空，则判断数据的生成时间和文件类型不可以为空
+            if (dataSourceType != null && !"".equals(dataSourceType)) {
+                if (calculationInfoList.get(i).getGenTime() == null) {
+                    return CalculateResult.error(CalculateResult.MSG_GEN_TIME_NULL);
+                }
+
+                if (calculationInfoList.get(i).getDataSourceType() == null || "".equals(calculationInfoList.get(i).getDataSourceType())) {
+                    return CalculateResult.error(CalculateResult.MSG_DATA_SOURCE_TYPE_NULL);
+                }
+            }
         }
 
         // 将数据转为List Map 格式
         List<Map<String, Object>> calculationInfoListMap = getCalculationInfoList(calculationInfoList, calculateRequest.getElectricCapacity());
         // 获取细则公式
-        CalculationFormula rulesCalculationFormula = calculationFormulaRepository.findByTypeAndProvince(CalculateResult.RULES, formulaType, province, electricType,stationCode);
+        CalculationFormula rulesCalculationFormula = calculationFormulaRepository.findByTypeAndProvince(CalculateResult.RULES, formulaType, province, electricType, stationCode);
         if (rulesCalculationFormula == null || rulesCalculationFormula.getFormula() == null) {
             // 未匹配到细则文件，则不进行细则校验，返回数据
             return CalculateResult.success(calculationInfoListMap);
@@ -193,7 +214,7 @@ public class AccuracyPassRateCalculateService {
 
         String formula = rulesCalculationFormula.getFormula();
         // 初始化公式并获取缓存的公式
-        String scriptName = common.initFormula(formula,calculateRequest.getProvince(),calculateRequest.getFormulaType(),calculateRequest.getElectricType(),CalculateResult.RULES);
+        String scriptName = common.initFormula(formula, calculateRequest.getProvince(), calculateRequest.getFormulaType(), calculateRequest.getElectricType(), CalculateResult.RULES);
         // 通过校验的数据
         List<Map<String, Object>> passList = new ArrayList<>();
         // 循环数据，对数据进行校验
@@ -242,5 +263,59 @@ public class AccuracyPassRateCalculateService {
         }
         return resultList;
     }
+
+    /**
+     * 将多组计算准确率的数据，分组成每个文件类型为一组，并放入list中
+     *
+     * @param list
+     * @param dataSourceType
+     * @return
+     */
+    private List<List<Map<String, Object>>> groupingList(List<Map<String, Object>> list, String dataSourceType) {
+        // 将文件类型转为arr
+        String[] dataSourceTypeArr = dataSourceType.split(CalculateResult.COMMA);
+        // 最终分好组的list
+        List<List<Map<String, Object>>> groupingList = new ArrayList<>();
+        // 同一个生成时间和同一个文件类型的数据，分再一组
+        List<Map<String, Object>> group = new ArrayList<>();
+        // 对比时间
+        Date dataTime = (Date) list.get(0).get("genTime");
+        for (String type : dataSourceTypeArr) {
+            for (Map<String, Object> map : list) {
+                // 获取数据生成时间
+                Date forDataTime = (Date) map.get("genTime");
+                // 如果当前数据的文件类型是当前循环中的
+                if (map.get("dataSourceType").equals(type)) {
+                    // 如果当前数据和上一条数据的 生成时间相同，则放入组中
+                    if (dataTime.equals(forDataTime)) {
+                        group.add(map);
+                    // 如果不是，则将dataTime修改为新时间，并将之前的组数据放入最终list
+                    } else {
+                        dataTime = forDataTime;
+                        if(group.size()!=0){
+                            groupingList.add(group);
+                        }
+                        // 清空之前的组，向组中放入本次内循环的数据
+                        group = new ArrayList<>();
+                        group.add(map);
+                    }
+                    // 如果当前数据的文件类型 不是当前循环中的，将之前的组存入最终list，并清空组
+                } else {
+                    if(group.size()!=0){
+                        groupingList.add(group);
+                    }
+                    group = new ArrayList<>();
+                    continue;
+                }
+            }
+            // 内循环最后一次执行完后，将未保存的组数据存入最终list
+            if(group.size()!=0){
+                groupingList.add(group);
+            }
+        }
+
+        return groupingList;
+    }
+
 }