海南版本提交

pqs-advance/advance-api/pom.xml

@@ -60,5 +60,10 @@
             <artifactId>harmonic-api</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>cglib</groupId>
+            <artifactId>cglib</artifactId>
+            <version>3.3.0</version>
+        </dependency>
     </dependencies>
 </project>

pqs-advance/advance-api/src/main/java/com/njcn/advance/enums/AdvanceResponseEnum.java

@@ -36,7 +36,8 @@ public enum AdvanceResponseEnum {
     DATA_UNDERRUN("A0104","数据量不足，请根据模版上传充足近两周数据"),
     DOCUMENT_FORMAT_ERROR("A0105","数据缺失，导入失败！请检查导入文档的格式是否正确"),
     USER_LOST("A0106","干扰源用户缺失"),
-
+    UNCOMPLETE_STRATEGY("A0106","配置安全，III级预警,II级预警,I级预警4条完整策略"),
+    EXISTENCE_EVALUATION_RESULT("A0104","存在评结果结果，如要评估，请删除后评估"),
     SG_USER_NAME_REPEAT("A0102","业务用户名重复"),
 
     SG_USER_ID_MISS("A0102","业务用户id缺失"),

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/excel/CarryCapcityDataEexcel.java

@@ -0,0 +1,286 @@
+package com.njcn.advance.pojo.carrycapacity.excel;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.converters.localdatetime.LocalDateTimeStringConverter;
+import com.njcn.advance.utils.EasyExcelUtil;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 类的介绍：
+ *
+ * @author xuyang
+ * @version 1.0.0
+ * @createTime 2022/5/12 9:13
+ */
+@Data
+public class CarryCapcityDataEexcel {
+
+    @ExcelProperty(index = 0,value = "时间",converter = LocalDateTimeStringConverter.class)
+    private LocalDateTime time;
+
+    @ExcelProperty(index =1,value = {"电压","A"})
+    private Double u_a;
+
+    @ExcelProperty(index =2,value = {"电压","B"})
+    private Double u_b;
+
+    @ExcelProperty(index =3,value = {"电压","C"})
+    private Double u_c;
+
+
+    @ExcelProperty(index =4,value = {"有功功率","A"})
+    private Double p_a;
+
+    @ExcelProperty(index =5,value = {"有功功率","B"})
+    private Double p_b;
+
+    @ExcelProperty(index =6,value = {"有功功率","C"})
+    private Double p_c;
+
+    @ExcelProperty(index =7,value = {"无功功率","A"})
+    private Double q_a;
+
+    @ExcelProperty(index =8,value = {"无功功率","B"})
+    private Double q_b;
+
+    @ExcelProperty(index =9,value = {"无功功率","C"})
+    private Double q_c;
+
+    @ExcelProperty(index =10,value = {"电流","2次","A"})
+    private Double i2_a;
+
+    @ExcelProperty(index =11,value = {"电流","2次","B"})
+    private Double i2_b;
+
+    @ExcelProperty(index =12,value = {"电流","2次","C"})
+    private Double i2_c;
+
+    @ExcelProperty(index =13,value = {"电流","3次","A"})
+    private Double i3_a;
+
+    @ExcelProperty(index =14,value = {"电流","3次","B"})
+    private Double i3_b;
+
+    @ExcelProperty(index =15,value = {"电流","3次","C"})
+    private Double i3_c;
+
+    @ExcelProperty(index =16,value = {"电流","4次","A"})
+    private Double i4_a;
+
+    @ExcelProperty(index =17,value = {"电流","4次","B"})
+    private Double i4_b;
+
+    @ExcelProperty(index =18,value = {"电流","4次","C"})
+    private Double i4_c;
+
+    @ExcelProperty(index =19,value = {"电流","5次","A"})
+    private Double i5_a;
+
+    @ExcelProperty(index =20,value = {"电流","5次","B"})
+    private Double i5_b;
+
+    @ExcelProperty(index =21,value = {"电流","5次","C"})
+    private Double i5_c;
+
+    @ExcelProperty(index =22,value = {"电流","6次","A"})
+    private Double i6_a;
+
+    @ExcelProperty(index =23,value = {"电流","6次","B"})
+    private Double i6_b;
+
+    @ExcelProperty(index =24,value = {"电流","6次","C"})
+    private Double i6_c;
+
+    @ExcelProperty(index =25,value = {"电流","7次","A"})
+    private Double i7_a;
+
+    @ExcelProperty(index =26,value = {"电流","7次","B"})
+    private Double i7_b;
+
+    @ExcelProperty(index =27,value = {"电流","7次","C"})
+    private Double i7_c;
+
+    @ExcelProperty(index =28,value = {"电流","8次","A"})
+    private Double i8_a;
+
+    @ExcelProperty(index =29,value = {"电流","8次","B"})
+    private Double i8_b;
+
+    @ExcelProperty(index =30,value = {"电流","8次","C"})
+    private Double i8_c;
+
+    @ExcelProperty(index =31,value = {"电流","9次","A"})
+    private Double i9_a;
+
+    @ExcelProperty(index =32,value = {"电流","9次","B"})
+    private Double i9_b;
+
+    @ExcelProperty(index =33,value = {"电流","9次","C"})
+    private Double i9_c;
+
+    @ExcelProperty(index =34,value = {"电流","10次","A"})
+    private Double i10_a;
+
+    @ExcelProperty(index =35,value = {"电流","10次","B"})
+    private Double i10_b;
+
+    @ExcelProperty(index =36,value = {"电流","10次","C"})
+    private Double i10_c;
+
+    @ExcelProperty(index =37,value = {"电流","11次","A"})
+    private Double i11_a;
+
+    @ExcelProperty(index =38,value = {"电流","11次","B"})
+    private Double i11_b;
+
+    @ExcelProperty(index =39,value = {"电流","11次","C"})
+    private Double i11_c;
+
+    @ExcelProperty(index =40,value = {"电流","12次","A"})
+    private Double i12_a;
+
+    @ExcelProperty(index =41,value = {"电流","12次","B"})
+    private Double i12_b;
+
+    @ExcelProperty(index =42,value = {"电流","12次","C"})
+    private Double i12_c;
+
+    @ExcelProperty(index =43,value = {"电流","13次","A"})
+    private Double i13_a;
+
+    @ExcelProperty(index =44,value = {"电流","13次","B"})
+    private Double i13_b;
+
+    @ExcelProperty(index =45,value = {"电流","13次","C"})
+    private Double i13_c;
+
+    @ExcelProperty(index =46,value = {"电流","14次","A"})
+    private Double i14_a;
+
+    @ExcelProperty(index =47,value = {"电流","14次","B"})
+    private Double i14_b;
+
+    @ExcelProperty(index =48,value = {"电流","14次","C"})
+    private Double i14_c;
+
+    @ExcelProperty(index =49,value = {"电流","15次","A"})
+    private Double i15_a;
+
+    @ExcelProperty(index =50,value = {"电流","15次","B"})
+    private Double i15_b;
+
+    @ExcelProperty(index =51,value = {"电流","15次","C"})
+    private Double i15_c;
+
+    @ExcelProperty(index =52,value = {"电流","16次","A"})
+    private Double i16_a;
+
+    @ExcelProperty(index =53,value = {"电流","16次","B"})
+    private Double i16_b;
+
+    @ExcelProperty(index =54,value = {"电流","16次","C"})
+    private Double i16_c;
+
+    @ExcelProperty(index =55,value = {"电流","17次","A"})
+    private Double i17_a;
+
+    @ExcelProperty(index =56,value = {"电流","17次","B"})
+    private Double i17_b;
+
+    @ExcelProperty(index =57,value = {"电流","17次","C"})
+    private Double i17_c;
+
+    @ExcelProperty(index =58,value = {"电流","18次","A"})
+    private Double i18_a;
+
+    @ExcelProperty(index =59,value = {"电流","18次","B"})
+    private Double i18_b;
+
+    @ExcelProperty(index =60,value = {"电流","18次","C"})
+    private Double i18_c;
+
+    @ExcelProperty(index =61,value = {"电流","19次","A"})
+    private Double i19_a;
+
+    @ExcelProperty(index =62,value = {"电流","19次","B"})
+    private Double i19_b;
+
+    @ExcelProperty(index =63,value = {"电流","19次","C"})
+    private Double i19_c;
+
+    @ExcelProperty(index =64,value = {"电流","20次","A"})
+    private Double i20_a;
+
+    @ExcelProperty(index =65,value = {"电流","20次","B"})
+    private Double i20_b;
+
+    @ExcelProperty(index =66,value = {"电流","20次","C"})
+    private Double i20_c;
+
+    @ExcelProperty(index =67,value = {"电流","21次","A"})
+    private Double i21_a;
+
+    @ExcelProperty(index =68,value = {"电流","21次","B"})
+    private Double i21_b;
+
+    @ExcelProperty(index =69,value = {"电流","21次","C"})
+    private Double i21_c;
+
+    @ExcelProperty(index =70,value = {"电流","22次","A"})
+    private Double i22_a;
+
+    @ExcelProperty(index =71,value = {"电流","22次","B"})
+    private Double i22_b;
+
+    @ExcelProperty(index =72,value = {"电流","22次","C"})
+    private Double i22_c;
+
+    @ExcelProperty(index =73,value = {"电流","23次","A"})
+    private Double i23_a;
+
+    @ExcelProperty(index =74,value = {"电流","23次","B"})
+    private Double i23_b;
+
+    @ExcelProperty(index =75,value = {"电流","23次","C"})
+    private Double i23_c;
+
+    @ExcelProperty(index =76,value = {"电流","24次","A"})
+    private Double i24_a;
+
+    @ExcelProperty(index =77,value = {"电流","24次","B"})
+    private Double i24_b;
+
+    @ExcelProperty(index =78,value = {"电流","24次","C"})
+    private Double i24_c;
+
+    @ExcelProperty(index =79,value = {"电流","25次","A"})
+    private Double i25_a;
+
+    @ExcelProperty(index =80,value = {"电流","25次","B"})
+    private Double i25_b;
+
+    @ExcelProperty(index =81,value = {"电流","25次","C"})
+    private Double i25_c;
+
+    public static void main(String[] args) {
+        List<CarryCapcityDataEexcel> objects = EasyExcelUtil.syncReadModel("C:\\Users\\无名\\Desktop\\11.xlsx", CarryCapcityDataEexcel.class, 0,3);
+        System.out.println(objects);
+
+//        String sheetName = "sheetName";
+//        List<CarryCapcityDataEexcel> excels = new ArrayList<>();
+//        CarryCapcityDataEexcel exportHeadersExcel = new CarryCapcityDataEexcel();
+//        excels.add(exportHeadersExcel);
+//
+//        EasyExcel.write("C:\\\\Users\\\\无名\\\\Desktop\\\\22.xlsx", CarryCapcityDataEexcel.class)
+//                .sheet(sheetName)
+//                .doWrite(excels);
+
+    }
+
+
+
+
+}

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/param/CarryCapacityEvaluateParam.java

@@ -6,6 +6,8 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
 import java.util.List;
 
 /**
@@ -21,17 +23,21 @@ import java.util.List;
 @AllArgsConstructor
 public class CarryCapacityEvaluateParam {
     @ApiModelProperty(value = "接线类型不可为空\"星型接法_0\", \"三角型接法_1\", \"开口三角型接法_2\"")
+    @NotBlank(message = "接线类型不能为空")
     private String ptType;
     @ApiModelProperty(value = "变压器连接方式")
     private String connectionMode;
     @ApiModelProperty(value = "功率因数（0.95-1之间）")
+    @NotNull(message = "功率因数不能为空")
     private Double k;
 
     @ApiModelProperty(value = "专变用户,公变用户")
+    @NotBlank(message = "用户类型不能为空")
     private String userMode;
 
 
     @ApiModelProperty(name = "scale",value = "电压等级")
+    @NotBlank(message = "电压等级不能为空")
     private String scale;
 
     @ApiModelProperty(name = "shortCapacity",value = "短路容量")

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/param/CarryCapacityStrategyParam.java

@@ -19,6 +19,8 @@ import javax.validation.constraints.NotNull;
 @AllArgsConstructor
 @NoArgsConstructor
 public class CarryCapacityStrategyParam {
+
+    private  String id;
     /**
      * 总承载能力评估结果（1-安全，2-III级预警，3-II级预警，4-I 级预警）
      */

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/param/CarryCapacityUserParam.java

@@ -89,7 +89,7 @@ public class CarryCapacityUserParam {
         @NotNull(message="显示条数不能为空！")
         @ApiModelProperty(value = "显示条数",name = "pageSize",dataType ="Integer",required = true)
         private Integer pageSize;
-
+        private String voltage;
         @ApiModelProperty(value="起始时间")
         private String startTime;
 

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/po/CarryCapacityResultPO.java

@@ -78,7 +78,7 @@ public class CarryCapacityResultPO extends BaseEntity {
     private Integer iLevel;
 
     /**
-     * 总结果等级（1-安全，2-III级预警，3-II级预警，4-I 级预警）
+     * 总结果等级（1-安全，2-III级预警，3-II级预警，4-I 级预警,5-禁止接入，6-允许接入）
      */
     @TableField(value = "reslut_level")
     private Integer reslutLevel;
@@ -100,9 +100,30 @@ public class CarryCapacityResultPO extends BaseEntity {
 
 
     @TableField(value = "first_result")
-    private Double firstResult;
+    private double firstResult;
 
     @TableField(value = "i_result_list")
     private String iResultList;
 
+    @TableField(value = "pt_type")
+    private String ptType;
+    @TableField(value = "connection_mode")
+    private String connectionMode;
+    @TableField(value = "k")
+    private Double k;
+
+    @TableField(value = "user_mode")
+    private String userMode;
+
+
+    @TableField(value = "scale")
+    private String scale;
+
+    @TableField(value = "short_capacity")
+    private Float shortCapacity;
+
+
+    @TableField(value = "device_capacity")
+    private Float deviceCapacity;
+
 }

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/po/CarryCapacityStrategyDhlPO.java

@@ -0,0 +1,98 @@
+package com.njcn.advance.pojo.carrycapacity.po;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.db.bo.BaseEntity;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 
+ * Description:
+ * Date: 2024/3/15  10:45【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "carry_capacity_strategy_dhl")
+public class CarryCapacityStrategyDhlPO extends BaseEntity {
+    /**
+     * id
+     */
+    @TableId(value = "id", type = IdType.ASSIGN_ID)
+    private String id;
+
+    /**
+     * 充电桩，电弧炉，电气化铁路
+     */
+    @TableField(value = "`type`")
+    private String type;
+
+    /**
+     * 一级评估比较符
+     */
+    @TableField(value = "comparison_operators_1")
+    private String comparisonOperators1;
+
+    /**
+     * 一级评估数量
+     */
+    @TableField(value = "count_1")
+    private Integer count1;
+
+    /**
+     * 二级级评估（2~20次谐波合格个数）比较符
+     */
+    @TableField(value = "comparison_operators_2")
+    private String comparisonOperators2;
+
+    /**
+     * 二级评估（2~20次谐波合格）个数数量
+     */
+    @TableField(value = "count_2")
+    private Integer count2;
+
+    /**
+     * 二级级评估（奇数谐波合格个数）比较符
+     */
+    @TableField(value = "comparison_operators_3")
+    private String comparisonOperators3;
+
+    /**
+     * 二级评估（奇数次谐波合格）个数数量
+     */
+    @TableField(value = "count_3")
+    private Integer count3;
+
+    /**
+     * 初始配置1，客户配置2
+     */
+    @TableField(value = "proto_flag")
+    private Integer protoFlag;
+
+    /**
+     * 二级级评估（偶数谐波合格个数）比较符
+     */
+    @TableField(value = "comparison_operators_4")
+    private String comparisonOperators4;
+
+    /**
+     * 二级评估（偶数次谐波合格）个数数量
+     */
+    @TableField(value = "count_4")
+    private Integer count4;
+
+    /**
+     * 启用配置1，不启用配置2
+     */
+    @TableField(value = "user_flag")
+    private Integer userFlag;
+
+
+}

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/po/CarryCapacityStrategyPO.java

@@ -55,4 +55,7 @@ public class CarryCapacityStrategyPO  extends BaseEntity {
     @TableField(value = "user_flag")
     private Integer userFlag;
 
+    @TableField(value = "id")
+    private String id;
+
 }

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/vo/CarryCapacityDResultVO.java

@@ -1,5 +1,6 @@
 package com.njcn.advance.pojo.carrycapacity.vo;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
@@ -79,6 +80,21 @@ public class CarryCapacityDResultVO {
     private List<CarryCapacityDResultVO.CarryCapacityIResult> iResultList;
 
 
+    @TableField(value = "pt_type")
+    private String connectionMode;
+    private Double k;
+
+    private String userMode;
+
+
+    private String scale;
+
+    private Float shortCapacity;
+
+
+    private Float deviceCapacity;
+
+
     @Data
     public static class CarryCapacityIResult {
 

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/vo/CarryCapacityStrategyDhlVO.java

@@ -0,0 +1,76 @@
+package com.njcn.advance.pojo.carrycapacity.vo;
+
+import lombok.Data;
+
+/**
+ * 
+ * Description:
+ * Date: 2024/3/15  10:45【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Data
+public class CarryCapacityStrategyDhlVO {
+    /**
+     * id
+     */
+    private String id;
+
+    /**
+     * 充电桩，电弧炉，电气化铁路
+     */
+    private String type;
+
+    /**
+     * 一级评估比较符
+     */
+    private String comparisonOperators1;
+
+    /**
+     * 一级评估数量
+     */
+    private Integer count1;
+
+    /**
+     * 二级级评估（2~20次谐波合格个数）比较符
+     */
+    private String comparisonOperators2;
+
+    /**
+     * 二级评估（2~20次谐波合格）个数数量
+     */
+    private Integer count2;
+
+    /**
+     * 二级级评估（奇数谐波合格个数）比较符
+     */
+    private String comparisonOperators3;
+
+    /**
+     * 二级评估（奇数次谐波合格）个数数量
+     */
+    private Integer count3;
+
+    /**
+     * 初始配置1，客户配置2
+     */
+    private Integer protoFlag;
+
+    /**
+     * 二级级评估（偶数谐波合格个数）比较符
+     */
+    private String comparisonOperators4;
+
+    /**
+     * 二级评估（偶数次谐波合格）个数数量
+     */
+    private Integer count4;
+
+    /**
+     * 启用配置1，不启用配置2
+     */
+    private Integer userFlag;
+
+
+}

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/carrycapacity/vo/CarryCapacityStrategyVO.java

@@ -3,6 +3,8 @@ package com.njcn.advance.pojo.carrycapacity.vo;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
+import java.util.List;
+
 /**
  * Description:
  * Date: 2024/3/5  10:47【需求编号】
@@ -12,12 +14,25 @@ import lombok.Data;
  */
 @Data
 public class CarryCapacityStrategyVO {
+
     /**
      * 总承载能力评估结果（1-安全，2-III级预警，3-II级预警，4-I 级预警）
      */
+
     @ApiModelProperty(value = "总承载能力评估结果（1-安全，2-III级预警，3-II级预警，4-I 级预警）")
     private Integer result;
 
+
+
+    private List<CarryCapacityStrategysingleVO> capacityStrategysingleVOList;
+    @Data
+    public static class CarryCapacityStrategysingleVO  {
+
+        private  String id;
+        private List<CarryCapacityStrategyIndexVO> carryCapacityStrategyIndexVOList;
+        @Data
+        public static class CarryCapacityStrategyIndexVO  {
+
             /**
              * 指标评估结果（1-安全，2-III级预警，3-II级预警，4-I 级预警）
              */
@@ -36,5 +51,9 @@ public class CarryCapacityStrategyVO {
             @ApiModelProperty(value = "数量")
             private Integer count;
 
+        }
+
+
 
+    }
 }

pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelDefaultListener.java

@@ -0,0 +1,88 @@
+package com.njcn.advance.utils;
+
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.event.AnalysisEventListener;
+import com.alibaba.excel.exception.ExcelDataConvertException;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Description:
+ * Date: 2024/3/15  16:02【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Slf4j
+public abstract class EasyExcelDefaultListener<T> extends AnalysisEventListener<T> {
+
+    /**
+     * 批处理阈值
+     */
+    private static final int BATCH_COUNT = 20;
+
+    /**
+     * 用来存放待处理的数据
+     */
+    @Getter
+    private List<T> list = new ArrayList<>(BATCH_COUNT);
+
+    /**
+     * 读取excel数据前操作 <br>
+     *
+     * 只有不读取表头数据时才会触发此方法)
+     */
+    @Override
+    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+        log.info("======================================================");
+        log.info("======================================================");
+    }
+
+    /**
+     * 读取excel数据操作
+     * @param obj
+     * @param context
+     */
+    @Override
+    public void invoke(T obj, AnalysisContext context) {
+        list.add(obj);
+
+        if (list.size() >= BATCH_COUNT) {
+            //将数据保存到数据库中
+            fun(list);
+            list.clear();
+        }
+    }
+
+    /**
+     * 具体业务
+     */
+    protected abstract void fun(List<T> list);
+
+    /**
+     * 读取完excel数据后的操作
+     */
+    @Override
+    public void doAfterAllAnalysed(AnalysisContext context) {
+        if (list.size() > 0) {
+            fun(list);
+        }
+    }
+
+    /**
+     * 在读取excel异常 获取其他异常下会调用本接口。抛出异常则停止读取。如果这里不抛出异常则 继续读取下一行。
+     */
+    @Override
+    public void onException(Exception exception, AnalysisContext context) {
+        log.error("解析失败，但是继续解析下一行:{}", exception.getMessage());
+        if (exception instanceof ExcelDataConvertException) {
+            ExcelDataConvertException ex = (ExcelDataConvertException) exception;
+            log.error("第{}行，第{}列解析异常，数据为:{}", ex.getRowIndex(), ex.getColumnIndex(), ex.getCellData());
+        }
+    }
+}
+

pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelUtil.java

@@ -0,0 +1,379 @@
+package com.njcn.advance.utils;
+
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.EasyExcelFactory;
+import com.alibaba.excel.event.AnalysisEventListener;
+import com.alibaba.excel.write.handler.WriteHandler;
+import lombok.SneakyThrows;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URLEncoder;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Description:
+ * Date: 2024/3/15  15:58【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class EasyExcelUtil {
+
+    //====================================================无JAVA模型读取excel数据===============================================================
+
+    /**
+     * 同步无模型读（默认读取sheet0,从第2行开始读）
+     * @param file excel文件的绝对路径
+     */
+    public static List<Map<Integer, String>> syncRead(String file) {
+        return EasyExcelFactory.read(file).sheet().doReadSync();
+    }
+
+    /**
+     * 同步无模型读（自定义读取sheetX，从第2行开始读）
+     * @param file excel文件的绝对路径
+     * @param sheetNum sheet页号，从0开始
+     */
+    public static List<Map<Integer, String>> syncRead(String file, Integer sheetNum) {
+        return EasyExcelFactory.read(file).sheet(sheetNum).doReadSync();
+    }
+
+    /**
+     * 同步无模型读（指定sheet和表头占的行数）
+     * @param file
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static List<Map<Integer, String>> syncRead(String file, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(file).sheet(sheetNum).headRowNumber(headNum).doReadSync();
+    }
+
+    /**
+     * 同步无模型读（指定sheet和表头占的行数）
+     * @param inputStream
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static List<Map<Integer, String>> syncRead(InputStream inputStream, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(inputStream).sheet(sheetNum).headRowNumber(headNum).doReadSync();
+    }
+
+    /**
+     * 同步无模型读（指定sheet和表头占的行数）
+     * @param file
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static List<Map<Integer, String>> syncRead(File file, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(file).sheet(sheetNum).headRowNumber(headNum).doReadSync();
+    }
+    //====================================================无JAVA模型读取excel数据===============================================================
+
+    //====================================================将excel数据同步到JAVA模型属性里===============================================================
+
+    /**
+     * 同步按模型读（默认读取sheet0,不读取表头，从第2行开始读）
+     * @param file
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     */
+    public static <T> List<T> syncReadModel(String file, Class clazz) {
+        return EasyExcelFactory.read(file).sheet().head(clazz).doReadSync();
+    }
+
+    /**
+     * 同步按模型读（默认表头占一行，不读取表头，从第2行开始读）
+     * @param file
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum sheet页号，从0开始
+     */
+    public static <T> List<T> syncReadModel(String file, Class clazz, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(file).sheet(sheetNum).headRowNumber(headNum).head(clazz).doReadSync();
+    }
+
+    /**
+     * 同步按模型读（指定sheet,不读取表头）
+     * @param inputStream
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum sheet页号，从0开始
+     */
+    public static <T> List<T> syncReadModel(InputStream inputStream, Class clazz, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(inputStream).sheet(sheetNum).headRowNumber(headNum).head(clazz).doReadSync();
+    }
+
+    /**
+     * 同步按模型读（指定sheet,不读取表头）
+     * @param file
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum sheet页号，从0开始
+     */
+    public static <T> List<T> syncReadModel(File file, Class clazz, Integer sheetNum, Integer headNum) {
+        return EasyExcelFactory.read(file).sheet(sheetNum).headRowNumber(headNum).head(clazz).doReadSync();
+    }
+    //====================================================将excel数据同步到JAVA模型属性里===============================================================
+
+    //====================================================异步读取excel数据===============================================================
+
+    /**
+     * 异步无模型读（默认读取sheet0,不读取表头,从第2行开始读）
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param file 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static <T> void asyncRead(String file, AnalysisEventListener<T> listener) {
+        EasyExcelFactory.read(file, listener).sheet().doRead();
+    }
+
+    /**
+     * 异步无模型读（默认表头占一行，不读取表头,从第2行开始读）
+     * @param file 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param sheetNum sheet页号，从0开始
+     */
+    public static <T> void asyncRead(String file, AnalysisEventListener<T> listener, Integer sheetNum) {
+        EasyExcelFactory.read(file, listener).sheet(sheetNum).doRead();
+    }
+
+    /**
+     * 异步无模型读（指定sheet和表头占的行数）
+     * @param inputStream
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static <T> void asyncRead(InputStream inputStream, AnalysisEventListener<T> listener, Integer sheetNum, Integer headNum) {
+        EasyExcelFactory.read(inputStream, listener).sheet(sheetNum).headRowNumber(headNum).doRead();
+    }
+
+    /**
+     * 异步无模型读（指定sheet和表头占的行数）
+     * @param file
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     */
+    public static <T> void asyncRead(File file, AnalysisEventListener<T> listener, Integer sheetNum, Integer headNum) {
+        EasyExcelFactory.read(file, listener).sheet(sheetNum).headRowNumber(headNum).doRead();
+    }
+
+    /**
+     * 异步无模型读（指定sheet和表头占的行数）
+     * @param file
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param sheetNum sheet页号，从0开始
+     * @param headNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
+     * @return
+     */
+    public static <T> void asyncRead(String file, AnalysisEventListener<T> listener, Integer sheetNum, Integer headNum) {
+        EasyExcelFactory.read(file, listener).sheet(sheetNum).headRowNumber(headNum).doRead();
+    }
+    //====================================================异步读取excel数据===============================================================
+
+    //====================================================将excel数据异步到JAVA模型属性里===============================================================
+    /**
+     * 异步按模型读取（默认读取sheet0,不读取表头,从第2行开始读）
+     * @param file
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     */
+    public static <T> void asyncReadModel(String file, AnalysisEventListener<T> listener, Class clazz) {
+        EasyExcelFactory.read(file, clazz, listener).sheet().doRead();
+    }
+
+    /**
+     * 异步按模型读取（默认表头占一行，不读取表头,从第2行开始读）
+     * @param file
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum  sheet页号，从0开始
+     */
+    public static <T> void asyncReadModel(String file, AnalysisEventListener<T> listener, Class clazz, Integer sheetNum) {
+        EasyExcelFactory.read(file, clazz, listener).sheet(sheetNum).doRead();
+    }
+
+    /**
+     * 异步按模型读取
+     * @param file
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum  sheet页号，从0开始
+     */
+    public static <T> void asyncReadModel(File file, AnalysisEventListener<T> listener, Class clazz, Integer sheetNum) {
+        EasyExcelFactory.read(file, clazz, listener).sheet(sheetNum).doRead();
+    }
+
+    /**
+     * 异步按模型读取
+     * @param inputStream
+     * @param listener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
+     * @param clazz 模型的类类型（excel数据会按该类型转换成对象）
+     * @param sheetNum  sheet页号，从0开始
+     */
+    public static <T> void asyncReadModel(InputStream inputStream, AnalysisEventListener<T> listener, Class clazz, Integer sheetNum) {
+        EasyExcelFactory.read(inputStream, clazz, listener).sheet(sheetNum).doRead();
+    }
+    //====================================================将excel数据异步到JAVA模型属性里===============================================================
+
+
+    //====================================================无JAVA模型写文件===============================================================
+    /**
+     * 无模板写文件
+     * @param file
+     * @param head 表头数据
+     * @param data 表内容数据
+     */
+    public static void write(String file, List<List<String>> head, List<List<Object>> data) {
+        EasyExcel.write(file).head(head).sheet().doWrite(data);
+    }
+
+    /**
+     * 无模板写文件
+     * @param file
+     * @param head 表头数据
+     * @param data 表内容数据
+     * @param sheetNum sheet页号，从0开始
+     * @param sheetName sheet名称
+     */
+    public static void write(String file, List<List<String>> head, List<List<Object>> data, Integer sheetNum, String sheetName) {
+        EasyExcel.write(file).head(head).sheet(sheetNum, sheetName).doWrite(data);
+    }
+    //====================================================无JAVA模型写文件===============================================================
+
+    //====================================================有Excel模板写文件===============================================================
+    /**
+     * 根据excel模板文件写入文件，可以实现向已有文件中添加数据的功能
+     * @param file
+     * @param template
+     * @param data
+     */
+    public static <T> void writeTemplate(String file, String template, List<T> data) {
+        EasyExcel.write(file).withTemplate(template).sheet().doWrite(data);
+    }
+
+    /**
+     * 根据excel模板文件写入文件
+     * @param file
+     * @param template
+     * @param clazz
+     * @param data
+     */
+    public static <T> void writeTemplate(String file, String template, Class clazz, List<T> data) {
+        EasyExcel.write(file, clazz).withTemplate(template).sheet().doWrite(data);
+    }
+
+
+
+    //====================================================无模板写文件===============================================================
+
+    //====================================================有模板写文件===============================================================
+    /**
+     * 按模板写文件
+     * @param file
+     * @param clazz 表头模板
+     * @param data 数据
+     */
+    public static <T> void write(String file, Class clazz, List<T> data) {
+        EasyExcel.write(file, clazz).sheet().doWrite(data);
+    }
+
+    /**
+     * 按模板写文件
+     * @param file
+     * @param clazz 表头模板
+     * @param data 数据
+     * @param sheetNum sheet页号，从0开始
+     * @param sheetName sheet名称
+     */
+    public static <T> void write(String file, Class clazz, List<T> data, Integer sheetNum, String sheetName) {
+        EasyExcel.write(file, clazz).sheet(sheetNum, sheetName).doWrite(data);
+    }
+
+    /**
+     * 按模板写文件
+     * @param file
+     * @param clazz 表头模板
+     * @param data 数据
+     * @param writeHandler 自定义的处理器，比如设置table样式，设置超链接、单元格下拉框等等功能都可以通过这个实现（需要注册多个则自己通过链式去调用）
+     * @param sheetNum sheet页号，从0开始
+     * @param sheetName sheet名称
+     */
+    public static <T> void write(String file, Class clazz, List<T> data, WriteHandler writeHandler, Integer sheetNum, String sheetName) {
+        EasyExcel.write(file, clazz).registerWriteHandler(writeHandler).sheet(sheetNum, sheetName).doWrite(data);
+    }
+
+    /**
+     * 按模板写文件（包含某些字段）
+     * @param file
+     * @param clazz 表头模板
+     * @param data 数据
+     * @param includeCols 包含字段集合，根据字段名称显示
+     * @param sheetNum sheet页号，从0开始
+     * @param sheetName sheet名称
+     */
+    public static <T> void writeInclude(String file, Class clazz, List<T> data, Set<String> includeCols, Integer sheetNum, String sheetName) {
+        EasyExcel.write(file, clazz).includeColumnFiledNames(includeCols).sheet(sheetNum, sheetName).doWrite(data);
+    }
+
+    /**
+     * 按模板写文件（排除某些字段）
+     * @param file
+     * @param clazz 表头模板
+     * @param data 数据
+     * @param excludeCols 过滤排除的字段，根据字段名称过滤
+     * @param sheetNum sheet页号，从0开始
+     * @param sheetName sheet名称
+     */
+    public static <T> void writeExclude(String file, Class clazz, List<T> data, Set<String> excludeCols, Integer sheetNum, String sheetName) {
+        EasyExcel.write(file, clazz).excludeColumnFiledNames(excludeCols).sheet(sheetNum, sheetName).doWrite(data);
+    }
+
+    //------------------------------------------------------------------------------------------------
+    /**
+     * 多个sheet页的数据链式写入
+     *
+     * @param file
+     */
+    public static EasyExcelWriteTool writeWithSheets(String file) {
+        return new EasyExcelWriteTool(file);
+    }
+
+    /**
+     * 多个sheet页的数据链式写入
+     *
+     * @param file
+     */
+    public static EasyExcelWriteTool writeWithSheets(File file) {
+        return new EasyExcelWriteTool(file);
+    }
+
+    /**
+     * 多个sheet页的数据链式写入
+     *
+     * @param outputStream
+     */
+    public static EasyExcelWriteTool writeWithSheets(OutputStream outputStream) {
+        return new EasyExcelWriteTool(outputStream);
+    }
+
+    /**
+     * 多个sheet页的数据链式写入（失败了会返回一个有部分数据的Excel）
+     *
+     * @param response
+     * @param exportFileName 导出的文件名称
+     */
+    @SneakyThrows
+    public static EasyExcelWriteTool writeWithSheetsWeb(HttpServletResponse response, String exportFileName) throws IOException {
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+        response.setCharacterEncoding("utf-8");
+
+        // 这里URLEncoder.encode可以防止中文乱码
+        String fileName = URLEncoder.encode(exportFileName, "UTF-8");
+        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
+
+        return new EasyExcelWriteTool(response.getOutputStream());
+    }
+}

pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelWriteTool.java

@@ -0,0 +1,68 @@
+package com.njcn.advance.utils;
+
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.ExcelWriter;
+import com.alibaba.excel.write.metadata.WriteSheet;
+import org.apache.poi.ss.formula.functions.T;
+
+import java.io.File;
+import java.io.OutputStream;
+import java.util.List;
+
+/**
+ * Description:
+ * Date: 2024/3/15  16:00【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class EasyExcelWriteTool {
+
+    private int sheetNum;
+    private ExcelWriter excelWriter;
+
+    public EasyExcelWriteTool(OutputStream outputStream) {
+        excelWriter = EasyExcel.write(outputStream).build();
+    }
+
+    public EasyExcelWriteTool(File file) {
+        excelWriter = EasyExcel.write(file).build();
+    }
+
+    public EasyExcelWriteTool(String filePath) {
+        excelWriter = EasyExcel.write(filePath).build();
+    }
+
+    /**
+     * 链式模板表头写入
+     * @param clazz 表头格式
+     * @param data 数据 List<ExcelModel> 或者List<List<Object>>
+     * @return
+     */
+    public <T> EasyExcelWriteTool writeModel(Class clazz, List<T> data, String sheetName) {
+        final WriteSheet writeSheet = EasyExcel.writerSheet(this.sheetNum++, sheetName).head(clazz).build();
+        excelWriter.write(data, writeSheet);
+        return this;
+    }
+
+    /**
+     * 链式自定义表头写入
+     * @param head
+     * @param data 数据 List<ExcelModel> 或者List<List<Object>>
+     * @param sheetName
+     * @return
+     */
+    public EasyExcelWriteTool write(List<List<String>> head, List<T> data, String sheetName) {
+        final WriteSheet writeSheet = EasyExcel.writerSheet(this.sheetNum++, sheetName).head(head).build();
+        excelWriter.write(data, writeSheet);
+        return this;
+    }
+
+    /**
+     * 使用此类结束后，一定要关闭流
+     */
+    public void finish() {
+        excelWriter.finish();
+    }
+
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/carrycapacity/CarryCapacityController.java

@@ -1,40 +1,35 @@
 package com.njcn.advance.controller.carrycapacity;
 
-import cn.afterturn.easypoi.excel.ExcelExportUtil;
+import com.alibaba.excel.EasyExcel;
-import cn.afterturn.easypoi.excel.entity.ExportParams;
+import com.njcn.advance.pojo.carrycapacity.excel.CarryCapcityDataEexcel;
-import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
-import com.alibaba.nacos.shaded.com.google.common.collect.Maps;
-import com.njcn.advance.pojo.carrycapacity.excel.CarryCapcityDataIEexcel;
-import com.njcn.advance.pojo.carrycapacity.excel.CarryCapcityDataPEexcel;
-import com.njcn.advance.pojo.carrycapacity.excel.CarryCapcityDataQEexcel;
-import com.njcn.advance.pojo.carrycapacity.excel.CarryCapcityDataVEexcel;
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityCalParam;
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityEvaluateParam;
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityQueryDataParam;
 import com.njcn.advance.pojo.carrycapacity.param.ExcelDataParam;
-import com.njcn.advance.pojo.carrycapacity.vo.*;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDResultVO;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDataIVO;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDataQVO;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDataVO;
 import com.njcn.advance.service.carrycapacity.CarryCapcityService;
+import com.njcn.advance.utils.EasyExcelUtil;
 import com.njcn.common.pojo.annotation.OperateInfo;
 import com.njcn.common.pojo.enums.common.LogEnum;
 import com.njcn.common.pojo.enums.response.CommonResponseEnum;
 import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.common.utils.HttpResultUtil;
 import com.njcn.device.pq.pojo.vo.TerminalTree;
-import com.njcn.poi.util.PoiUtil;
 import com.njcn.web.controller.BaseController;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiImplicitParam;
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
-import org.apache.commons.compress.utils.Lists;
-import org.apache.poi.ss.usermodel.Workbook;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 
 /**
@@ -113,49 +108,19 @@ public class CarryCapacityController extends BaseController {
     @ResponseBody
     @ApiOperation("导出数据集模板")
     @GetMapping(value = "getExcelTemplate")
-    public HttpResult<String> getExcelTemplate(HttpServletResponse response) {
+    public HttpResult<String> getExcelTemplate(HttpServletResponse response) throws IOException {
-        final List<Map<String, Object>> sheetsList = Lists.newArrayList();
-        Map<String, Object> exportMap = Maps.newHashMap();
-        final ExportParams exportParams = new ExportParams(null, "电流幅值", ExcelType.HSSF);
-        // 以下3个参数为API中写死的参数名 分别是sheet配置/导出类（注解定义）/数据集
-        exportMap.put("title", exportParams);
-        exportMap.put("entity", CarryCapcityDataIEexcel.class);
-        exportMap.put("data", new ArrayList<>());
-        // 加入多sheet配置列表
-        sheetsList.add(exportMap);
-
-        Map<String, Object> exportMap2 = Maps.newHashMap();
-        final ExportParams exportParams2 = new ExportParams(null, "电压", ExcelType.XSSF);
-        // 以下3个参数为API中写死的参数名 分别是sheet配置/导出类（注解定义）/数据集
-        exportMap2.put("title", exportParams2);
-        exportMap2.put("entity", CarryCapcityDataVEexcel.class);
-        exportMap2.put("data", new ArrayList<>());
-        // 加入多sheet配置列表
-        sheetsList.add(exportMap2);
-
-        Map<String, Object> exportMap3 = Maps.newHashMap();
-        final ExportParams exportParams3 = new ExportParams(null, "有功功率", ExcelType.XSSF);
-        // 以下3个参数为API中写死的参数名 分别是sheet配置/导出类（注解定义）/数据集
-        exportMap3.put("title", exportParams3);
-        exportMap3.put("entity", CarryCapcityDataPEexcel.class);
-        exportMap3.put("data", new ArrayList<>());
-        // 加入多sheet配置列表
-        sheetsList.add(exportMap3);
-
-        Map<String, Object> exportMap4 = Maps.newHashMap();
-        final ExportParams exportParams4 = new ExportParams(null, "无功功率", ExcelType.XSSF);
-        // 以下3个参数为API中写死的参数名 分别是sheet配置/导出类（注解定义）/数据集
-        exportMap4.put("title", exportParams4);
-        exportMap4.put("entity", CarryCapcityDataQEexcel.class);
-        exportMap4.put("data", new ArrayList<>());
-        // 加入多sheet配置列表
-        sheetsList.add(exportMap4);
-        Workbook workbook = ExcelExportUtil.exportExcel(sheetsList, ExcelType.XSSF);
 
 
-        String fileName = "数据集.xlsx";
+
-        ExportParams exportExcel = new ExportParams("数据集", "数据集");
+        String sheetName = "数据集模版.xlsx";
-        PoiUtil.exportFileByWorkbook(workbook, fileName, response);
+        List<CarryCapcityDataEexcel> excels = new ArrayList<>();
+        CarryCapcityDataEexcel exportHeadersExcel = new CarryCapcityDataEexcel();
+        excels.add(exportHeadersExcel);
+        EasyExcel.write(response.getOutputStream(), CarryCapcityDataEexcel.class)
+                .sheet(sheetName)
+                .doWrite(excels);
+        EasyExcelUtil.writeWithSheetsWeb(response,  "数据集模版");
+
 
 
 

pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/carrycapacity/CarryCapacityResultController.java

@@ -2,6 +2,7 @@ package com.njcn.advance.controller.carrycapacity;
 
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityResultParam;
+import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityResultPO;
 import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDResultVO;
 import com.njcn.advance.service.carrycapacity.CarryCapacityResultPOService;
 import com.njcn.common.pojo.annotation.OperateInfo;
@@ -15,10 +16,9 @@ import io.swagger.annotations.ApiImplicitParam;
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.*;
-import org.springframework.web.bind.annotation.RequestBody;
+
-import org.springframework.web.bind.annotation.RequestMapping;
+import java.util.List;
-import org.springframework.web.bind.annotation.RestController;
 
 
 /**
@@ -45,7 +45,14 @@ public class CarryCapacityResultController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, vo, methodDescribe);
     }
 
-
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/remove")
+    @ApiOperation("承载能力评估用户批量删除")
+    public HttpResult<Boolean> remove(@RequestParam("ids") List<String> ids) {
+        String methodDescribe = getMethodDescribe("remove");
+        Boolean flag = carryCapacityResultPOService.lambdaUpdate().in(CarryCapacityResultPO::getId, ids).set(CarryCapacityResultPO::getStatus, 0).update();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, flag, methodDescribe);
+    }
 
 
 }

pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/carrycapacity/CarryCapacityStrategyController.java

@@ -1,7 +1,9 @@
 package com.njcn.advance.controller.carrycapacity;
 
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityStrategyParam;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyDhlVO;
 import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyVO;
+import com.njcn.advance.service.carrycapacity.CarryCapacityStrategyDhlPOService;
 import com.njcn.advance.service.carrycapacity.CarryCapacityStrategyPOService;
 import com.njcn.common.pojo.annotation.OperateInfo;
 import com.njcn.common.pojo.enums.common.LogEnum;
@@ -36,10 +38,12 @@ public class CarryCapacityStrategyController extends BaseController {
 
 
     private final CarryCapacityStrategyPOService carryCapacityStrategyPOService;
+    private final CarryCapacityStrategyDhlPOService carryCapacityStrategyDhlPOService;
+
 
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
     @PostMapping("/add")
-    @ApiOperation("用户新增承载能力评估策略")
+    @ApiOperation("用户新增承载能力评估策略（光伏）")
     @ApiImplicitParam(name = "carryCapacityStrategyParam", value = "新增参数", required = true)
     public HttpResult<Boolean> add(@RequestBody @Validated CarryCapacityStrategyParam carryCapacityStrategyParam) {
         String methodDescribe = getMethodDescribe("add");
@@ -47,8 +51,17 @@ public class CarryCapacityStrategyController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, flag, methodDescribe);
     }
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/addList")
+    @ApiOperation("用户新增承载能力评估策略组（光伏）")
+    @ApiImplicitParam(name = "carryCapacityStrategyParamList", value = "新增参数", required = true)
+    public HttpResult<Boolean> addList(@RequestBody @Validated List<CarryCapacityStrategyParam> carryCapacityStrategyParamList) {
+        String methodDescribe = getMethodDescribe("addList");
+        Boolean flag = carryCapacityStrategyPOService.addList(carryCapacityStrategyParamList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, flag, methodDescribe);
+    }
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
     @PostMapping("/queyDetail")
-    @ApiOperation("承载能力评估策略初始化查询")
+    @ApiOperation("承载能力评估策略初始化查询（光伏）")
     public HttpResult<List<CarryCapacityStrategyVO>> queyDetail() {
         String methodDescribe = getMethodDescribe("queyDetail");
         List<CarryCapacityStrategyVO> carryCapacityStrategyVOList = carryCapacityStrategyPOService.queyDetail();
@@ -64,4 +77,23 @@ public class CarryCapacityStrategyController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, flag, methodDescribe);
     }
 
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/adddhl")
+    @ApiOperation("用户新增承载能力评估策略（电弧炉）")
+    @ApiImplicitParam(name = "capacityStrategyDhlVO", value = "新增参数", required = true)
+    public HttpResult<Boolean> adddhl(@RequestBody @Validated CarryCapacityStrategyDhlVO capacityStrategyDhlVO) {
+        String methodDescribe = getMethodDescribe("adddhl");
+        Boolean flag = carryCapacityStrategyDhlPOService.adddhl(capacityStrategyDhlVO);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, flag, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/queyDetailDhl")
+    @ApiOperation("承载能力评估策略初始化查询（电弧炉）")
+    public HttpResult<List<CarryCapacityStrategyDhlVO>> queyDetailDhl() {
+        String methodDescribe = getMethodDescribe("queyDetailDhl");
+        List<CarryCapacityStrategyDhlVO> car = carryCapacityStrategyDhlPOService.queyDetailDhl();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, car, methodDescribe);
+    }
+
 }

pqs-advance/advance-boot/src/main/java/com/njcn/advance/mapper/carrycapacity/CarryCapacityStrategyDhlPOMapper.java

@@ -0,0 +1,15 @@
+package com.njcn.advance.mapper.carrycapacity;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyDhlPO;
+
+/**
+ * 
+ * Description:
+ * Date: 2024/3/15  10:45【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public interface CarryCapacityStrategyDhlPOMapper extends BaseMapper<CarryCapacityStrategyDhlPO> {
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/mapper/carrycapacity/mapping/CarryCapacityStrategyDhlPOMapper.xml

@@ -0,0 +1,30 @@
+<?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="com.njcn.advance.mapper.carrycapacity.CarryCapacityStrategyDhlPOMapper">
+  <resultMap id="BaseResultMap" type="com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyDhlPO">
+    <!--@mbg.generated-->
+    <!--@Table carry_capacity_strategy_dhl-->
+    <result column="id" jdbcType="INTEGER" property="id" />
+    <result column="type" jdbcType="VARCHAR" property="type" />
+    <result column="comparison_operators_1" jdbcType="VARCHAR" property="comparisonOperators1" />
+    <result column="count_1" jdbcType="INTEGER" property="count1" />
+    <result column="comparison_operators_2" jdbcType="VARCHAR" property="comparisonOperators2" />
+    <result column="count_2" jdbcType="INTEGER" property="count2" />
+    <result column="comparison_operators_3" jdbcType="VARCHAR" property="comparisonOperators3" />
+    <result column="count_3" jdbcType="INTEGER" property="count3" />
+    <result column="proto_flag" jdbcType="INTEGER" property="protoFlag" />
+    <result column="comparison_operators_4" jdbcType="VARCHAR" property="comparisonOperators4" />
+    <result column="count_4" jdbcType="INTEGER" property="count4" />
+    <result column="user_flag" jdbcType="INTEGER" property="userFlag" />
+    <result column="create_by" jdbcType="VARCHAR" property="createBy" />
+    <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
+    <result column="update_by" jdbcType="VARCHAR" property="updateBy" />
+    <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
+  </resultMap>
+  <sql id="Base_Column_List">
+    <!--@mbg.generated-->
+    id, `type`, comparison_operators_1, count_1, comparison_operators_2, count_2, comparison_operators_3, 
+    count_3, proto_flag, comparison_operators_4, count_4, user_flag, create_by, create_time, 
+    update_by, update_time
+  </sql>
+</mapper>

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/CarryCapacityStrategyDhlPOService.java

@@ -0,0 +1,23 @@
+package com.njcn.advance.service.carrycapacity;
+
+import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyDhlPO;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyDhlVO;
+
+import java.util.List;
+
+/**
+ * 
+ * Description:
+ * Date: 2024/3/15  10:45【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public interface CarryCapacityStrategyDhlPOService extends IService<CarryCapacityStrategyDhlPO>{
+
+
+        List<CarryCapacityStrategyDhlVO> queyDetailDhl();
+
+    Boolean adddhl(CarryCapacityStrategyDhlVO capacityStrategyDhlVO);
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/CarryCapacityStrategyPOService.java

@@ -23,4 +23,6 @@ public interface CarryCapacityStrategyPOService extends IService<CarryCapacitySt
         List<CarryCapacityStrategyVO> queyDetail();
 
         Boolean restore();
+
+        Boolean addList(List<CarryCapacityStrategyParam> carryCapacityStrategyParamList);
 }

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/impl/CarryCapacityResultPOServiceImpl.java

@@ -1,5 +1,6 @@
 package com.njcn.advance.service.carrycapacity.impl;
 
+import cn.hutool.json.JSONUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -13,6 +14,7 @@ import com.njcn.advance.service.carrycapacity.CarryCapacityResultPOService;
 import com.njcn.advance.service.carrycapacity.CarryCapacityUserPOService;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.ObjectUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
@@ -54,6 +56,11 @@ public class CarryCapacityResultPOServiceImpl extends ServiceImpl<CarryCapacityR
                 return carryCapacityUserPO.getUserName();
             }).collect(Collectors.toList());
             vo.setUserName(collect1.stream().collect(Collectors.joining(",")));
+            if (ObjectUtils.isNotEmpty(temp.getIResultList()) ){
+                String iResultList = temp.getIResultList();
+                List<CarryCapacityDResultVO.CarryCapacityIResult> list = JSONUtil.toList(JSONUtil.toJsonStr(iResultList), CarryCapacityDResultVO.CarryCapacityIResult.class);
+                vo.setIResultList(list);
+            }
             return vo;
         }).collect(Collectors.toList());
         returnpage.setRecords(collect);

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/impl/CarryCapacityStrategyDhlPOServiceImpl.java

@@ -0,0 +1,57 @@
+package com.njcn.advance.service.carrycapacity.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.advance.mapper.carrycapacity.CarryCapacityStrategyDhlPOMapper;
+import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyDhlPO;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyDhlVO;
+import com.njcn.advance.service.carrycapacity.CarryCapacityStrategyDhlPOService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 
+ * Description:
+ * Date: 2024/3/15  10:45【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Service
+public class CarryCapacityStrategyDhlPOServiceImpl extends ServiceImpl<CarryCapacityStrategyDhlPOMapper, CarryCapacityStrategyDhlPO> implements CarryCapacityStrategyDhlPOService{
+
+
+    @Override
+    public List<CarryCapacityStrategyDhlVO> queyDetailDhl() {
+        List<CarryCapacityStrategyDhlPO> list = this.lambdaQuery().eq(CarryCapacityStrategyDhlPO::getUserFlag, 1).list();
+        List<CarryCapacityStrategyDhlVO> collect = list.stream().map(t -> {
+            CarryCapacityStrategyDhlVO vo = new CarryCapacityStrategyDhlVO();
+            vo.setCount1(t.getCount1());
+            vo.setCount2(t.getCount2());
+            vo.setCount3(t.getCount3());
+            vo.setComparisonOperators1(t.getComparisonOperators1());
+            vo.setComparisonOperators2(t.getComparisonOperators2());
+            vo.setComparisonOperators3(t.getComparisonOperators3());
+            vo.setId(t.getId());
+            vo.setProtoFlag(t.getProtoFlag());
+            vo.setType(t.getType());
+            return vo;
+        }).collect(Collectors.toList());
+        return collect;
+    }
+
+    @Override
+    public Boolean adddhl(CarryCapacityStrategyDhlVO capacityStrategyDhlVO) {
+        this.lambdaUpdate().eq(CarryCapacityStrategyDhlPO::getId, capacityStrategyDhlVO.getId()).
+                set(CarryCapacityStrategyDhlPO::getUserFlag, 2).update();
+        CarryCapacityStrategyDhlPO carryCapacityStrategyDhlPO = new CarryCapacityStrategyDhlPO();
+        BeanUtils.copyProperties(capacityStrategyDhlVO,carryCapacityStrategyDhlPO);
+        carryCapacityStrategyDhlPO.setId(null);
+        carryCapacityStrategyDhlPO.setProtoFlag(2);
+        boolean save = this.save(carryCapacityStrategyDhlPO);
+        return save;
+    }
+
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/impl/CarryCapacityStrategyPOServiceImpl.java

@@ -1,17 +1,26 @@
 package com.njcn.advance.service.carrycapacity.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.advance.enums.AdvanceResponseEnum;
+import com.njcn.advance.mapper.carrycapacity.CarryCapacityStrategyDhlPOMapper;
 import com.njcn.advance.mapper.carrycapacity.CarryCapacityStrategyPOMapper;
 import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityStrategyParam;
+import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyDhlPO;
 import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityStrategyPO;
 import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyVO;
 import com.njcn.advance.service.carrycapacity.CarryCapacityStrategyPOService;
+import com.njcn.common.pojo.exception.BusinessException;
+import lombok.RequiredArgsConstructor;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 /**
@@ -23,8 +32,9 @@ import java.util.stream.Collectors;
  * @version V1.0.0
  */
 @Service
+@RequiredArgsConstructor
 public class CarryCapacityStrategyPOServiceImpl extends ServiceImpl<CarryCapacityStrategyPOMapper, CarryCapacityStrategyPO> implements CarryCapacityStrategyPOService{
-
+        private final CarryCapacityStrategyDhlPOMapper carryCapacityStrategyDhlPOMapper;
     @Override
     @Transactional(rollbackFor = {Exception.class})
     public Boolean add(CarryCapacityStrategyParam carryCapacityStrategyParam) {
@@ -32,6 +42,7 @@ public class CarryCapacityStrategyPOServiceImpl extends ServiceImpl<CarryCapacit
         BeanUtils.copyProperties(carryCapacityStrategyParam, carryCapacityStrategyPO);
         //将原始策略处理为不启用
         this.lambdaUpdate().eq(CarryCapacityStrategyPO::getResult, carryCapacityStrategyParam.getResult())
+                .eq(CarryCapacityStrategyPO::getId, carryCapacityStrategyParam.getId())
                 .eq(CarryCapacityStrategyPO::getIndexResult, carryCapacityStrategyParam.getIndexResult())
                 .eq(CarryCapacityStrategyPO::getProtoFlag, 1)
                 .set(CarryCapacityStrategyPO::getUserFlag,2)
@@ -39,6 +50,7 @@ public class CarryCapacityStrategyPOServiceImpl extends ServiceImpl<CarryCapacit
         QueryWrapper<CarryCapacityStrategyPO> lambdaQuery = new QueryWrapper<>();
         lambdaQuery.lambda()
                 .eq(CarryCapacityStrategyPO::getResult, carryCapacityStrategyParam.getResult())
+                .eq(CarryCapacityStrategyPO::getId, carryCapacityStrategyParam.getId())
                 .eq(CarryCapacityStrategyPO::getIndexResult, carryCapacityStrategyParam.getIndexResult())
                 .eq(CarryCapacityStrategyPO::getProtoFlag, 2);
         //将客户对应策略删除
@@ -52,13 +64,29 @@ public class CarryCapacityStrategyPOServiceImpl extends ServiceImpl<CarryCapacit
 
     @Override
     public List<CarryCapacityStrategyVO> queyDetail() {
+        List<CarryCapacityStrategyVO> result = new ArrayList<>();
         List<CarryCapacityStrategyPO> list = this.lambdaQuery().eq(CarryCapacityStrategyPO::getUserFlag, 1).list();
-        List<CarryCapacityStrategyVO> collect = list.stream().map(temp -> {
+        Map<Integer, Map<String, List<CarryCapacityStrategyPO>>> collect = list.stream().collect(Collectors.groupingBy(CarryCapacityStrategyPO::getResult,
+                Collectors.groupingBy(CarryCapacityStrategyPO::getId)));
+        collect.forEach((key, value) -> {
             CarryCapacityStrategyVO vo = new CarryCapacityStrategyVO();
-            BeanUtils.copyProperties(temp, vo);
+            vo.setResult(key);
-            return vo;
+            List<CarryCapacityStrategyVO.CarryCapacityStrategysingleVO> capacityStrategysingleVOList =new ArrayList<>();
-        }).collect(Collectors.toList());
+            value.forEach((k, v) -> {
-        return collect;
+                CarryCapacityStrategyVO.CarryCapacityStrategysingleVO vo1 = new CarryCapacityStrategyVO.CarryCapacityStrategysingleVO();
+                vo1.setId(k);
+                vo1.setCarryCapacityStrategyIndexVOList(v.stream().map(temp -> {
+                    CarryCapacityStrategyVO.CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO vo2 = new CarryCapacityStrategyVO.CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO();
+                    BeanUtils.copyProperties(temp, vo2);
+                    return vo2;
+                }).collect(Collectors.toList()));
+                capacityStrategysingleVOList.add(vo1);
+            });
+            vo.setCapacityStrategysingleVOList(capacityStrategysingleVOList);
+            result.add(vo);
+        });
+
+        return result;
     }
 
     @Override
@@ -67,12 +95,45 @@ public class CarryCapacityStrategyPOServiceImpl extends ServiceImpl<CarryCapacit
         QueryWrapper<CarryCapacityStrategyPO> lambdaQuery = new QueryWrapper<>();
         lambdaQuery.lambda()
                 .eq(CarryCapacityStrategyPO::getProtoFlag, 2);
-        this.remove(lambdaQuery
+        this.remove(lambdaQuery);
-        );
+
         //将原始策略处理为启用
         boolean update = this.lambdaUpdate().eq(CarryCapacityStrategyPO::getProtoFlag, 1)
                 .set(CarryCapacityStrategyPO::getUserFlag, 1)
                 .update();
+
+        //电弧炉初始化
+        QueryWrapper<CarryCapacityStrategyDhlPO> lambdaQuery2 = new QueryWrapper<>();
+        lambdaQuery2.lambda()
+                .eq(CarryCapacityStrategyDhlPO::getProtoFlag, 2);
+        carryCapacityStrategyDhlPOMapper.delete(lambdaQuery2);
+        UpdateWrapper<CarryCapacityStrategyDhlPO> lambdaQuery3 = new UpdateWrapper<>();
+        lambdaQuery3.lambda()
+                .eq(CarryCapacityStrategyDhlPO::getProtoFlag, 1)
+                .set(CarryCapacityStrategyDhlPO::getUserFlag, 1);
+
+        carryCapacityStrategyDhlPOMapper.update(null,lambdaQuery3);
+
         return update;
     }
+
+    @Override
+    public Boolean addList(List<CarryCapacityStrategyParam> carryCapacityStrategyParamList) {
+        UUID uuid = UUID.randomUUID();
+        if(4!=carryCapacityStrategyParamList.size()){
+            throw new BusinessException(AdvanceResponseEnum.UNCOMPLETE_STRATEGY);
+
+        }
+        List<CarryCapacityStrategyPO> collect = carryCapacityStrategyParamList.stream().map(temp -> {
+            CarryCapacityStrategyPO po = new CarryCapacityStrategyPO();
+            BeanUtils.copyProperties(temp, po);
+            po.setId(uuid.toString());
+            //新增客户策略;
+            po.setProtoFlag(2);
+            po.setUserFlag(1);
+            return po;
+        }).collect(Collectors.toList());
+        boolean b = this.saveBatch(collect);
+        return b;
+    }
 }

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/impl/CarryCapacityUserPOServiceImpl.java

@@ -60,6 +60,7 @@ public class CarryCapacityUserPOServiceImpl extends ServiceImpl<CarryCapacityUse
         Page<CarryCapacityUserPO> returnpage = new Page<> (pageParm.getPageNum ( ), pageParm.getPageSize ( ));
         QueryWrapper<CarryCapacityUserPO> queryWrapper = new QueryWrapper<>();
         queryWrapper.lambda().eq(StringUtils.isNotBlank(pageParm.getUserId()) ,CarryCapacityUserPO::getUserId,pageParm.getUserId())
+                .eq(StringUtils.isNotBlank(pageParm.getVoltage()) ,CarryCapacityUserPO::getVoltage,pageParm.getVoltage())
                 .eq(StringUtils.isNotBlank(pageParm.getUserType()) ,CarryCapacityUserPO::getUserType,pageParm.getUserType())
                 .between(StringUtils.isNotBlank(pageParm.getStartTime()) && StringUtils.isNotBlank(pageParm.getEndTime()) ,CarryCapacityUserPO::getCreateTime,pageParm.getStartTime(),pageParm.getEndTime()).
                 orderByDesc(CarryCapacityUserPO::getCreateTime);

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/carrycapacity/impl/CarryCapcityServiceImpl.java

@@ -1,8 +1,5 @@
 package com.njcn.advance.service.carrycapacity.impl;
 
-import cn.afterturn.easypoi.excel.ExcelImportUtil;
-import cn.afterturn.easypoi.excel.entity.ImportParams;
-import cn.afterturn.easypoi.excel.entity.result.ExcelImportResult;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.LocalDateTimeUtil;
 import cn.hutool.json.JSONUtil;
@@ -19,6 +16,7 @@ import com.njcn.advance.pojo.carrycapacity.po.CarryCapacityUserPO;
 import com.njcn.advance.pojo.carrycapacity.vo.*;
 import com.njcn.advance.service.carrycapacity.*;
 import com.njcn.advance.utils.CZNLPG;
+import com.njcn.advance.utils.EasyExcelUtil;
 import com.njcn.advance.utils.Utils;
 import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.common.utils.PubUtils;
@@ -43,20 +41,22 @@ import com.njcn.system.enums.DicDataEnum;
 import com.njcn.system.pojo.po.DictData;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
-import org.apache.poi.ss.usermodel.Workbook;
-import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.multipart.MultipartFile;
 
+import java.io.InputStream;
 import java.time.LocalDate;
 import java.time.LocalTime;
+import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityStrategyVO.CarryCapacityStrategysingleVO;
+
 /**
  * Description:
  * Date: 2024/1/31  14:42【需求编号】
@@ -80,7 +80,7 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
     private final RedisUtil redisUtil;
     private final CarryCapacityResultPOService carryCapacityResultPOService;
     private final CarryCapacityUserPOService carryCapacityUserPOService;
-    private static final double DEFAULTVALUE=3.1415926;
+    private static final double DEFAULTVALUE=31415.926;
 
     private final FileStorageUtil fileStorageUtil;
 
@@ -260,12 +260,8 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
                 if(CollectionUtil.isEmpty(dataHarmPowerPList)){
                     throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
                 }else {
-                //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-                List<Double> listP = dataHarmPowerPList.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+                    if (!checkData(dataHarmPowerPList,startDate,endDate,timeInterval)){
-                        .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
-                        .map(CarryCapcityData::getValue)
-                        .collect(Collectors.toList());
-                    if (listP.size()<minDataNum){
 
                         throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
                     }
@@ -280,55 +276,45 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
                         "'  and  time >= '" + startTime + "'and time <= '" +endTime + "'"+"group by time("+timeInterval+"m) ,* fill(3.1415926)"+InfluxDBPublicParam.TIME_ZONE;
                 dataHarmPowerQList = dataHarmPowerQMapper.getSqlResult(SqlQ1);
                 //数据缺失填补
-
                 //数据校验
-                linearInterpolation(dataHarmPowerQList);
+                if(CollectionUtil.isEmpty(dataHarmPowerQList)){
-                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate, formatter)+"#"+LocalDateTimeUtil.format(endDate, formatter)+"#"+"Q",
+                    throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                        dataHarmPowerQList);
+                }else {
+
+                    if (!checkData(dataHarmPowerQList,startDate,endDate,timeInterval)){
+
+                        throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                    }
+                }
+
+                linearInterpolation(dataHarmPowerQList);
+//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate, formatter)+"#"+LocalDateTimeUtil.format(endDate, formatter)+"#"+"Q",
+//                        dataHarmPowerQList);
+
 
-                //电流
-//                StringBuilder stringBuilder1 = new StringBuilder();
-//                StringBuilder stringBuilder2 = new StringBuilder();
-//                for (int i = 2; i <=25 ; i++) {
-//                    if (i==25){
-//                        stringBuilder1.append("mean(i_").append(i).append(") AS i_").append(i);
-//                    } else {
-//                        stringBuilder1.append("mean(i_").append(i).append(") AS i_").append(i).append(",");
-//                    }
-//                }
-//                stringBuilder2.append ("line_id='").append (lineId).append ("' and ").append(InfluxDBPublicParam.TIME + " >= '").append(startTime).append("' and ").append(InfluxDBPublicParam.TIME).append(" <= '").append(endTime).append("'  group by time(").append(timeInterval).append("m),* fill(3.1415926) ").append(InfluxDBPublicParam.TIME_ZONE);
-//                String sqlI1 = "select "+stringBuilder1+" from "+ InfluxDBPublicParam.DATA_I+" where value_type='CP95' and phasic_type!='T' and  "+stringBuilder2;
-//                dataIList = dataIMapper.getSqlResult(sqlI1);
-//                //数据校验
-//                //数据缺失填补
-//                linearInterpolationI(dataIList);
-//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate, formatter)+"#"+LocalDateTimeUtil.format(endDate, formatter)+"#"+"I",
-//                        dataIList);
 
                 //前2周的数据用于计算首端电流模型参数
                 String forwardStartTime = LocalDateTimeUtil.format(queryParam.getStartTime()
-//                .plusWeeks(-1)
+                .plusWeeks(-1)
                         , formatter) + " 00:00:00";
                 String forwardEndTime = LocalDateTimeUtil.format(queryParam.getEndTime()
-//                .plusWeeks(-1)
+                .plusWeeks(-1)
                         , formatter) + " 23:59:00";
 
                 String SqlP2 = "select mean(p)*1000 as value from data_harmpower_p where  value_type='CP95' and phasic_type!='T' and line_id='"+lineId+
                         "'  and  time >= '" + forwardStartTime + "'and time <= '" +forwardEndTime + "'"+"group by time("+timeInterval+"m) ,* fill(3.1415926)"+InfluxDBPublicParam.TIME_ZONE;
                 dataHarmPowerP2List = dataHarmPowerPMapper.getSqlResult(SqlP2);
                 //数据校验
-        //        if(CollectionUtil.isEmpty(dataHarmPowerPList2)){
+                if(CollectionUtil.isEmpty(dataHarmPowerP2List)){
-        //            throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                    throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-        //        }else {
+                }else {
-        //        //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-        //        List<Double> listP = dataHarmPowerPList2.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+                    if (!checkData(dataHarmPowerP2List,startDate2,endDate2,timeInterval)){
-        //                .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-        //                .map(CarryCapcityData::getValue)
+                        throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-        //                .collect(Collectors.toList());
+                    }
-        //            if (listP.size()<minDataNum){
+                }
-        //                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+
-        //            }
-        //        }
                 //数据缺失填补
                 linearInterpolation(dataHarmPowerP2List);
 
@@ -338,6 +324,17 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
                         "'  and  time >= '" + forwardStartTime + "'and time <= '" +forwardEndTime + "'"+"group by time("+timeInterval+"m) ,* fill(3.1415926)"+InfluxDBPublicParam.TIME_ZONE;
                 dataHarmPowerQ2List = dataHarmPowerQMapper.getSqlResult(SqlQ2);
                 //数据校验
+                //数据校验
+                if(CollectionUtil.isEmpty(dataHarmPowerQ2List)){
+                    throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                }else {
+
+                    if (!checkData(dataHarmPowerQ2List,startDate2,endDate2,timeInterval)){
+
+                        throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                    }
+                }
+
                 //数据缺失填补
                 linearInterpolation(dataHarmPowerQ2List);
 
@@ -347,17 +344,26 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
                         "'  and  time >= '" + forwardStartTime + "'and time <= '" +forwardEndTime + "'"+"group by time("+timeInterval+"m) ,* fill(3.1415926)"+InfluxDBPublicParam.TIME_ZONE;
                 dataHarmPowerU2List = dataVMapper.getSqlResult(SqlU2);
                 //数据校验
+                //数据校验
+                if(CollectionUtil.isEmpty(dataHarmPowerU2List)){
+                    throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                }else {
 
+                    if (!checkData(dataHarmPowerU2List,startDate2,endDate2,timeInterval)){
+
+                        throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+                    }
+                }
                 //数据缺失填补
                 linearInterpolation(dataHarmPowerU2List);
-                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"P",
+//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"P",
-                        dataHarmPowerP2List);
+//                        dataHarmPowerP2List);
-                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"Q",
+//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"Q",
-                        dataHarmPowerQ2List);
+//                        dataHarmPowerQ2List);
-                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"U",
+//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate2, formatter)+"#"+LocalDateTimeUtil.format(endDate2, formatter)+"#"+"U",
-                        dataHarmPowerU2List);
+//                        dataHarmPowerU2List);
-                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate, formatter)+"#"+LocalDateTimeUtil.format(endDate, formatter)+"#"+"I",
+//                redisUtil.saveByKey(lineId+"#"+LocalDateTimeUtil.format(startDate, formatter)+"#"+LocalDateTimeUtil.format(endDate, formatter)+"#"+"I",
-                        dataIList);
+//                        dataIList);
 
 
             }
@@ -406,7 +412,12 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         Integer timeInterval = data.getTimeInterval();
 //        Integer timeInterval =10;
 
+        //根据时间间隔算出最低数据量 7天*6小时*60分钟*3项*90%/时间间隔
+        int minDataNum = 7*6*60*3*90/(100*timeInterval);
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        LocalDate startDate = queryParam.getStartTime();
+        LocalDate endDate = queryParam.getEndTime();
+
         String startTime = LocalDateTimeUtil.format(queryParam.getStartTime(), formatter) + " 00:00:00";
         String endTime = LocalDateTimeUtil.format(queryParam.getEndTime(), formatter) + " 23:59:00";
 
@@ -415,6 +426,15 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         String SqlQ1 = "select mean(q)*1000 as value from data_harmpower_q where  value_type='CP95' and phasic_type!='T' and line_id='"+lineId+
                 "'  and  time >= '" + startTime + "'and time <= '" +endTime + "'"+"group by time("+timeInterval+"m) ,* fill(3.1415926)"+InfluxDBPublicParam.TIME_ZONE;
         List<CarryCapcityData> dataHarmPowerList = dataHarmPowerQMapper.getSqlResult(SqlQ1);
+        if(CollectionUtil.isEmpty(dataHarmPowerList)){
+            throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+        }else {
+
+            if (!checkData(dataHarmPowerList,startDate,endDate,timeInterval)){
+
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+            }
+        }
         //数据缺失填补
         linearInterpolation(dataHarmPowerList);
         carryCapacityDataQVO.setData(dataHarmPowerList);
@@ -448,6 +468,8 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         //时间间隔
         Integer timeInterval = data.getTimeInterval();
 //        Integer timeInterval =10;
+        //根据时间间隔算出最低数据量 7天*6小时*60分钟*3项*90%/时间间隔
+        int minDataNum = 7*6*60*3*90/(100*timeInterval);
         LocalDate startDate = queryParam.getStartTime();
         LocalDate endDate = queryParam.getEndTime();
 
@@ -468,6 +490,20 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         stringBuilder2.append ("line_id='").append (lineId).append ("' and ").append(InfluxDBPublicParam.TIME + " >= '").append(startTime).append("' and ").append(InfluxDBPublicParam.TIME).append(" <= '").append(endTime).append("'  group by time(").append(timeInterval).append("m),* fill(3.1415926) ").append(InfluxDBPublicParam.TIME_ZONE);
         String sqlI1 = "select "+stringBuilder1+" from "+ InfluxDBPublicParam.DATA_I+" where value_type='CP95' and phasic_type!='T' and  "+stringBuilder2;
         List<DataI> dataI = dataIMapper.getSqlResult(sqlI1);
+        if(CollectionUtil.isEmpty(dataI)){
+            throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+        }else {
+            List<CarryCapcityData> i_list = dataI.stream().map(temp -> {
+                CarryCapcityData carryCapcityData = new CarryCapcityData();
+                BeanUtils.copyProperties(temp, carryCapcityData);
+                carryCapcityData.setValue(temp.getI2());
+                return carryCapcityData;
+            }).collect(Collectors.toList());
+            if (!checkData(i_list,startDate,endDate,timeInterval)){
+
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
+            }
+        }
         //数据缺失填补
         linearInterpolationI(dataI);
         List<CarryCapcityData> i_list = dataI.stream().map(temp -> {
@@ -604,16 +640,23 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         //1-安全，2-III级预警，3-II级预警，4-I 级预警,依次执行策略看是否符合
         for (int i = 1; i < 5; i++) {
             int finalI = i;
-            boolean b = StrategyReslut(carryCapacityStrategyVOList, i, 1, safe_count);
+            boolean b = StrategyReslut(carryCapacityStrategyVOList, i,safe_count, warn_count1, warn_count2, warn_count3 );
-            boolean b1 = StrategyReslut(carryCapacityStrategyVOList, i, 2, warn_count3);
+
-            boolean b2 = StrategyReslut(carryCapacityStrategyVOList, i, 3, warn_count2);
+            if(b){
-            boolean b3 = StrategyReslut(carryCapacityStrategyVOList, i, 4, warn_count1);
-            if(b&&b1&&b2&&b3){
                 carryCapacityDResultVO.setReslutLevel(i);
                 break;
             }
         }
         CarryCapacityResultPO carryCapacityResultPO = new CarryCapacityResultPO();
+        List<CarryCapacityResultPO> list1 = carryCapacityResultPOService.lambdaQuery().eq(CarryCapacityResultPO::getLineId, calParam.getLineId())
+                .eq(CarryCapacityResultPO::getUserId, calParam.getUserId())
+                .eq(CarryCapacityResultPO::getStartTime, calParam.getStartTime())
+                .eq(CarryCapacityResultPO::getEndTime, calParam.getEndTime())
+                .eq(CarryCapacityResultPO::getStatus, 1).list();
+        if (CollectionUtil.isNotEmpty(list1)) {
+            throw new BusinessException(AdvanceResponseEnum.EXISTENCE_EVALUATION_RESULT);
+
+        }
 
         carryCapacityResultPO.setLineId(calParam.getLineId());
         carryCapacityResultPO.setUserId(calParam.getUserId());
@@ -681,7 +724,7 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
 
 
         //前一周的数据
-        ExcelDataDTO excelDataDTO = ParsingFile(startDate, endDate, excelDataParam.getFile());
+        ExcelDataDTO excelDataDTO = ParsingFile(startDate, endDate, excelDataParam.getFile().getInputStream());
         List<CarryCapcityData> dataHarmPowerPList =excelDataDTO.getDataHarmPowerPList();
         List<CarryCapcityData> dataHarmPowerQList =excelDataDTO.getDataHarmPowerQList();
         List<DataI>  dataIList =excelDataDTO.getDataIList();
@@ -690,74 +733,62 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         List<CarryCapcityData> dataHarmPowerQ2List =excelDataDTO.getDataHarmPowerQ2List();
         List<CarryCapcityData> dataHarmPowerUList =excelDataDTO.getDataHarmPowerU2List();
 
-        //数据校验
         //数据校验
         if(CollectionUtil.isEmpty(dataHarmPowerPList)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-        //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-        List<Double> tempList = dataHarmPowerPList.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+            if (!checkData(dataHarmPowerPList,startDate,endDate,timeInterval)){
-                .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-                .map(CarryCapcityData::getValue)
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                .collect(Collectors.toList());
-            if (tempList.size()<minDataNum){
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
             }
         }
         linearInterpolation(dataHarmPowerPList);
 
+        //数据校验
         if(CollectionUtil.isEmpty(dataHarmPowerP2List)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-            //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-            List<Double> tempList = dataHarmPowerP2List.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+            if (!checkData(dataHarmPowerP2List,startDate2,endDate2,timeInterval)){
-                    .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-                    .map(CarryCapcityData::getValue)
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                    .collect(Collectors.toList());
-            if (tempList.size()<minDataNum){
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
             }
         }
         linearInterpolation(dataHarmPowerP2List);
 
+        //数据校验
         if(CollectionUtil.isEmpty(dataHarmPowerQList)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-            //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-            List<Double> tempList = dataHarmPowerQList.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+            if (!checkData(dataHarmPowerQList,startDate,endDate,timeInterval)){
-                    .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-                    .map(CarryCapcityData::getValue)
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                    .collect(Collectors.toList());
-            if (tempList.size()<minDataNum){
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
             }
         }
         linearInterpolation(dataHarmPowerQList);
 
+        //数据校验
         if(CollectionUtil.isEmpty(dataHarmPowerQ2List)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-            //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-            List<Double> tempList = dataHarmPowerQ2List.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+            if (!checkData(dataHarmPowerQ2List,startDate2,endDate2,timeInterval)){
-                    .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-                    .map(CarryCapcityData::getValue)
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                    .collect(Collectors.toList());
-            if (tempList.size()<minDataNum){
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
             }
         }
         linearInterpolation(dataHarmPowerQ2List);
 
+        //数据校验
         if(CollectionUtil.isEmpty(dataHarmPowerUList)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-            //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+
-            List<Double> tempList = dataHarmPowerUList.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+            if (!checkData(dataHarmPowerUList,startDate2,endDate2,timeInterval)){
-                    .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+
-                    .map(CarryCapcityData::getValue)
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
-                    .collect(Collectors.toList());
-            if (tempList.size()<minDataNum){
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
             }
         }
         linearInterpolation(dataHarmPowerUList);
@@ -765,13 +796,15 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         if(CollectionUtil.isEmpty(dataIList)){
             throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
         }else {
-            //数据清洗取近一周的配变每日9时~15时段的负载率数据中概率95%小值所对应时刻的有功功率和无功功率值
+            List<CarryCapcityData> i_list = dataIList.stream().map(temp -> {
-            List<Double> tempList = dataIList.stream().filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+                CarryCapcityData carryCapcityData = new CarryCapcityData();
-                    .filter(temp -> temp.getI2()!=DEFAULTVALUE&&Objects.nonNull(temp.getI2()))
+                BeanUtils.copyProperties(temp, carryCapcityData);
-                    .map(DataI::getI2)
+                carryCapcityData.setValue(temp.getI2());
-                    .collect(Collectors.toList());
+                return carryCapcityData;
-            if (tempList.size()<minDataNum){
+            }).collect(Collectors.toList());
-                throw new BusinessException(AdvanceResponseEnum.DATA_UNDERRUN);
+            if (!checkData(i_list,startDate,endDate,timeInterval)){
+
+                throw new BusinessException(AdvanceResponseEnum.DATA_NOT_FOUND);
             }
         }
         linearInterpolationI(dataIList);
@@ -895,6 +928,10 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
     @Override
     public CarryCapacityDResultVO carryCapacityEvaluate(CarryCapacityEvaluateParam calParam) {
         CarryCapacityDResultVO vo = new CarryCapacityDResultVO();
+        List<CarryCapacityDResultVO.CarryCapacityIResult> carryCapacityIResultList = new ArrayList<>();
+
+        String userType = calParam.getUserList().get(0).getUserType();
+        String code = dicDataFeignClient.getDicDataById(userType).getData().getCode();
         //用户协议容量
         double sumCapacity = 0.00;
         if (CollectionUtil.isEmpty(calParam.getUserList())){
@@ -907,7 +944,26 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         }
         double rate = sumCapacity / calParam.getShortCapacity();
         vo.setFirstResult(rate*100);
-        if(rate>0.001){
+
+        CarryCapacityResultPO carryCapacityResultPO = new CarryCapacityResultPO();
+        carryCapacityResultPO.setFirstResult(rate*100);
+        carryCapacityResultPO.setUserId( String.join(",", calParam.getUserList().stream().map(CarryCapacityUserVO::getUserId).collect(Collectors.toList())));
+        carryCapacityResultPO.setEvaluateDate(LocalDate.now());
+        carryCapacityResultPO.setEvaluateType(userType);
+        carryCapacityResultPO.setStatus(1);
+        carryCapacityResultPO.setPtType(calParam.getPtType());
+        carryCapacityResultPO.setConnectionMode(calParam.getConnectionMode());
+        carryCapacityResultPO.setK(calParam.getK());
+        carryCapacityResultPO.setUserMode(calParam.getUserMode());
+        carryCapacityResultPO.setScale(calParam.getScale());
+        carryCapacityResultPO.setShortCapacity(calParam.getShortCapacity());
+        carryCapacityResultPO.setDeviceCapacity(calParam.getDeviceCapacity());
+
+
+        carryCapacityResultPO.setStatus(1);
+        if(rate<0.001){
+            carryCapacityResultPO.setReslutLevel(6);
+            carryCapacityResultPOService.save(carryCapacityResultPO);
             return vo;
         }
 
@@ -934,9 +990,7 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         Overlimit overlimit = new Overlimit();
         COverlimitUtil.iHarm(overlimit,Float.valueOf(sacaleValue),(float) sumCapacity,calParam.getDeviceCapacity(),calParam.getShortCapacity());
 
-        String userType = calParam.getUserList().get(0).getUserType();
+
-        String code = dicDataFeignClient.getDicDataById(userType).getData().getCode();
-        List<CarryCapacityDResultVO.CarryCapacityIResult> carryCapacityIResultList = new ArrayList<>();
         if(DicDataEnum.Charging_Station_Users.getCode().equals(code)){
 
             integerList.stream().forEach(temp->{
@@ -1004,22 +1058,16 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
             });
         }
         vo.setIResultList(carryCapacityIResultList);
-
-        CarryCapacityResultPO carryCapacityResultPO = new CarryCapacityResultPO();
-        carryCapacityResultPO.setFirstResult(rate*100);
         carryCapacityResultPO.setIResultList(JSONUtil.toJsonStr(carryCapacityIResultList));
-        carryCapacityResultPO.setEvaluateDate(LocalDate.now());
-        carryCapacityResultPO.setEvaluateType(userType);
-        List<CarryCapacityDResultVO.CarryCapacityIResult> list = JSONUtil.toList(JSONUtil.toJsonStr(carryCapacityIResultList), CarryCapacityDResultVO.CarryCapacityIResult.class);
 
-        carryCapacityResultPO.setStatus(1);
+
         carryCapacityResultPOService.save(carryCapacityResultPO);
 
         return vo;
     }
 
 
-    public static ExcelDataDTO ParsingFile(LocalDate startDate, LocalDate endDate, MultipartFile file) throws Exception{
+    public static ExcelDataDTO ParsingFile(LocalDate startDate, LocalDate endDate, InputStream is) throws Exception{
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
         List<CarryCapcityData> dataHarmPowerPList = new ArrayList<>();
         List<CarryCapcityData> dataHarmPowerQList= new ArrayList<>();
@@ -1035,76 +1083,80 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
         List<CarryCapcityData> dataHarmPowerU2List= new ArrayList<>();
 
         try {
-            // 根据file得到Workbook,主要是要根据这个对象获取,传过来的excel有几个sheet页
+            List<CarryCapcityDataEexcel> objects = EasyExcelUtil.syncReadModel( is, CarryCapcityDataEexcel.class, 0,3);
-            Workbook workbook = new XSSFWorkbook(file.getInputStream());
+            List<CarryCapcityDataIEexcel > iEexcelList = new ArrayList<>();
-            StringBuilder sb=new StringBuilder();
+            List<CarryCapcityDataVEexcel> vEexcelList = new ArrayList<>();
-            ImportParams params = new ImportParams();
+            List<CarryCapcityDataPEexcel> pEexcelList = new ArrayList<>();
-            // 循环工作表Sheet
+            List<CarryCapcityDataQEexcel> qEexcelList = new ArrayList<>();
-            for (int numSheet = 0; numSheet < workbook.getNumberOfSheets(); numSheet++) {
+            objects.stream().forEach(temp->{
-                // 表头在第几行
+                CarryCapcityDataIEexcel carryCapcityDataIEexcel = new CarryCapcityDataIEexcel();
-                params.setTitleRows(0);
+                CarryCapcityDataVEexcel carryCapcityDataVEexcel = new CarryCapcityDataVEexcel();
-                // 距离表头中间有几行不要的数据
+                CarryCapcityDataPEexcel carryCapcityDataPEexcel = new CarryCapcityDataPEexcel();
-                params.setStartRows(0);
+                CarryCapcityDataQEexcel carryCapcityDataQEexcel = new CarryCapcityDataQEexcel();
-                // 第几个sheet页
-                params.setStartSheetIndex(numSheet);
-                // 验证数据
-                params.setNeedVerify(true);
-                if(numSheet==0){
-                    ExcelImportResult<CarryCapcityDataIEexcel> result =ExcelImportUtil.importExcelMore(file.getInputStream(),
-                            CarryCapcityDataIEexcel.class, params);
 
-                    List<CarryCapcityDataIEexcel > successList = result.getList();
+                BeanUtils.copyProperties(temp,carryCapcityDataIEexcel);
-                    List<DataI> collect = successList.stream().map(CarryCapcityDataIEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
+                carryCapcityDataIEexcel.setTime(temp.getTime().atZone(ZoneId.systemDefault()).toInstant());
+                carryCapcityDataIEexcel.setValueType("CP95");
+
+                carryCapcityDataVEexcel.setTime(temp.getTime().atZone(ZoneId.systemDefault()).toInstant());
+                carryCapcityDataVEexcel.setValueType("CP95");
+                carryCapcityDataVEexcel.setValue_a(Double.valueOf(temp.getU_a()));
+                carryCapcityDataVEexcel.setValue_b(Double.valueOf(temp.getU_b()));
+                carryCapcityDataVEexcel.setValue_c(Double.valueOf(temp.getU_c()));
+
+
+                carryCapcityDataPEexcel.setTime(temp.getTime().atZone(ZoneId.systemDefault()).toInstant());
+                carryCapcityDataPEexcel.setValueType("CP95");
+                carryCapcityDataPEexcel.setValue_a(Double.valueOf(temp.getP_a()));
+                carryCapcityDataPEexcel.setValue_b(Double.valueOf(temp.getP_b()));
+                carryCapcityDataPEexcel.setValue_c(Double.valueOf(temp.getP_c()));
+
+                carryCapcityDataQEexcel.setTime(temp.getTime().atZone(ZoneId.systemDefault()).toInstant());
+                carryCapcityDataQEexcel.setValueType("CP95");
+                carryCapcityDataQEexcel.setValue_a(Double.valueOf(temp.getQ_a()));
+                carryCapcityDataQEexcel.setValue_b(Double.valueOf(temp.getQ_b()));
+                carryCapcityDataQEexcel.setValue_c(Double.valueOf(temp.getQ_c()));
+                iEexcelList.add(carryCapcityDataIEexcel);
+                vEexcelList.add(carryCapcityDataVEexcel);
+                pEexcelList.add(carryCapcityDataPEexcel);
+                qEexcelList.add(carryCapcityDataQEexcel);
+
+            });
+
+
+
+            List<DataI> collect = iEexcelList.stream().map(CarryCapcityDataIEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
             dataIList = collect.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate, endDate)
             ).collect(Collectors.toList());
 
 
-                }else if(numSheet==1){
-                    ExcelImportResult<CarryCapcityDataVEexcel> result = ExcelImportUtil.importExcelMore(file.getInputStream(),
-                            CarryCapcityDataVEexcel.class, params);
-
             // 校验合格的数据
-                    List<CarryCapcityDataVEexcel> successList = result.getList();
+            List<CarryCapcityData> collect2 = vEexcelList.stream().map(CarryCapcityDataVEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
-                    List<CarryCapcityData> collect = successList.stream().map(CarryCapcityDataVEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
             // 业务逻辑
-                    dataHarmPowerU2List = collect.stream().filter(
+            dataHarmPowerU2List = collect2.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate2, endDate2)
             ).collect(Collectors.toList());
-                }
+
-                else if(numSheet==2){
-                    ExcelImportResult<CarryCapcityDataPEexcel> result = ExcelImportUtil.importExcelMore(file.getInputStream(),
-                            CarryCapcityDataPEexcel.class, params);
 
             // 校验合格的数据
-                    List<CarryCapcityDataPEexcel> successList = result.getList();
+            List<CarryCapcityData> collect3 = pEexcelList.stream().map(CarryCapcityDataPEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
-                    List<CarryCapcityData> collect = successList.stream().map(CarryCapcityDataPEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
+            dataHarmPowerPList = collect3.stream().filter(
-                    dataHarmPowerPList = collect.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate, endDate)
             ).collect(Collectors.toList());
-                    dataHarmPowerP2List = collect.stream().filter(
+            dataHarmPowerP2List = collect3.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate2, endDate2)
             ).collect(Collectors.toList());
 
-                    // 业务逻辑
-                }
-                else if(numSheet==3){
-                    ExcelImportResult<CarryCapcityDataQEexcel> result = ExcelImportUtil.importExcelMore(file.getInputStream(),
-                            CarryCapcityDataQEexcel.class, params);
 
-                    // 校验合格的数据
+            List<CarryCapcityData> collect4 = qEexcelList.stream().map(CarryCapcityDataQEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
-                    List<CarryCapcityDataQEexcel> successList = result.getList();
+            dataHarmPowerQList = collect4.stream().filter(
-                    List<CarryCapcityData> collect = successList.stream().map(CarryCapcityDataQEexcel::excelToPO).flatMap(Collection::stream).collect(Collectors.toList());
-                    dataHarmPowerQList = collect.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate, endDate)
             ).collect(Collectors.toList());
-                    dataHarmPowerQ2List = collect.stream().filter(
+            dataHarmPowerQ2List = collect4.stream().filter(
                     item -> Utils.isTimeInRange(item.getTime(), startDate2, endDate2)
             ).collect(Collectors.toList());
-                    // 业务逻辑
-                }
 
-            }
         } catch (Exception e) {
             throw new BusinessException(AdvanceResponseEnum.DOCUMENT_FORMAT_ERROR);
         }
@@ -1285,14 +1337,67 @@ public class CarryCapcityServiceImpl implements CarryCapcityService {
             throw new IllegalArgumentException("无效的操作符");
         }
     }
-    private static boolean StrategyReslut(List<CarryCapacityStrategyVO> carryCapacityStrategyVOList, int result_level, int index_result_level,int result_count) {
+    private static boolean StrategyReslut(List<CarryCapacityStrategyVO> carryCapacityStrategyVOList, int result_level, int safe_count,int warn_count1,int warn_count2,int warn_count3) {
+
         CarryCapacityStrategyVO carryCapacityStrategyVO = carryCapacityStrategyVOList.stream()
                 .filter(temp -> temp.getResult() == result_level)
-                .filter(temp -> temp.getIndexResult() == index_result_level)
                 .collect(Collectors.toList()).get(0);
-        boolean b1 = compareNumbers(result_count, carryCapacityStrategyVO.getCount(), carryCapacityStrategyVO.getComparisonOperators());
+        //每个策略组结果
-        return b1;
+        List<Boolean> list = new ArrayList<>();
+        List<CarryCapacityStrategysingleVO> capacityStrategysingleVOList = carryCapacityStrategyVO.getCapacityStrategysingleVOList();
+        capacityStrategysingleVOList.forEach(temp -> {
+            CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO carryCapacityStrategyIndexVO = temp.getCarryCapacityStrategyIndexVOList().stream()
+                    .filter(temp1 -> temp1.getIndexResult() == 1)
+                    .collect(Collectors.toList()).get(0);
+            boolean b1 = compareNumbers(safe_count, carryCapacityStrategyIndexVO.getCount(), carryCapacityStrategyIndexVO.getComparisonOperators());
+            CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO carryCapacityStrategyIndexVO2 = temp.getCarryCapacityStrategyIndexVOList().stream()
+                    .filter(temp1 -> temp1.getIndexResult() == 2)
+                    .collect(Collectors.toList()).get(0);
+            boolean b2 = compareNumbers(warn_count3, carryCapacityStrategyIndexVO2.getCount(), carryCapacityStrategyIndexVO2.getComparisonOperators());
+
+            CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO carryCapacityStrategyIndexVO3 = temp.getCarryCapacityStrategyIndexVOList().stream()
+                    .filter(temp1 -> temp1.getIndexResult() == 3)
+                    .collect(Collectors.toList()).get(0);
+            boolean b3 = compareNumbers(warn_count2, carryCapacityStrategyIndexVO3.getCount(), carryCapacityStrategyIndexVO3.getComparisonOperators());
+
+
+            CarryCapacityStrategysingleVO.CarryCapacityStrategyIndexVO carryCapacityStrategyIndexVO4 = temp.getCarryCapacityStrategyIndexVOList().stream()
+                    .filter(temp1 -> temp1.getIndexResult() == 4)
+                    .collect(Collectors.toList()).get(0);
+            boolean b4 = compareNumbers(warn_count1, carryCapacityStrategyIndexVO4.getCount(), carryCapacityStrategyIndexVO4.getComparisonOperators());
+            Boolean flag =b1&&b2&&b3&&b4;
+            list.add(flag);
+        });
+        long count = list.stream().filter(temp -> temp == true).count();
+        return count>0;
+    }
+
+    private static boolean checkData(List<CarryCapcityData> list,LocalDate startTime,LocalDate endTime,int timeInterval){
+        boolean flag = false;
+        long daysBetween = ChronoUnit.DAYS.between(startTime, endTime);
+        //根据时间间隔算出最低数据量 1天*6小时*60分钟*90%/时间间隔算出一天一个的数据
+        int minDataNum = 1*6*60*3*80/(100*timeInterval);
+        //合格天数》=3通过
+        int days =0;
+
+        for (long i = 0; i <= daysBetween; i++) {
+            LocalDate currentDay = startTime.plusDays(i);
+            long count = list.stream()
+                    .filter(temp -> Utils.isTimeInRange(temp.getTime(), LocalTime.of(9, 0), LocalTime.of(15, 0)))
+                    .filter(temp -> temp.getValue()!=DEFAULTVALUE&&Objects.nonNull(temp.getValue()))
+                    .filter(temp -> temp.getTime().atZone(ZoneId.systemDefault()).toLocalDate().equals(currentDay)).count();
+            if(count>=minDataNum){
+                days++;
+            }
+
+        }
+        if(days>=3) {
+            flag = true;
+        }
+
+        return flag;
     }
 
 
+
 }