Merge branch 'master' of http://124.70.43.205:3000/GYEE_R.D/gaia

electricity/meter/build.gradle

@@ -49,5 +49,10 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-configuration-processor")
     implementation("org.codehaus.groovy:groovy-all:2.4.1")
 
+    implementation("com.taosdata.jdbc:taos-jdbcdriver:$taosVersion2")
+    implementation("com.baomidou:dynamic-datasource-spring-boot-starter:$mybatisPlusVersion")
+
+
+
 }
 

electricity/meter/src/main/java/com/gyee/gaia/meter/controller/GetTypeController.java

@@ -25,12 +25,12 @@ public class GetTypeController {
 
 
     /**
-     * @return 所有风场的name和nem_code, 已经排序
+     * @return 所有风+光的name和nem_code, 已经排序
      */
     @GetMapping("/infoall")
     public Result<Object> getPowerstation() {
         //查询返回所有风场的name和nem_code,已经排序
-        ArrayList<MeterInfoVo> powerStationsVo = getPowerstationTypeClassName.getPowerstation();
+        ArrayList<MeterInfoVo> powerStationsVo = getPowerstationTypeClassName.getPowerstationAll();
         //构建响应map
         Map<String, Object> response = new HashMap<>();
         response.put("fdc", powerStationsVo);
@@ -55,7 +55,7 @@ public class GetTypeController {
             @RequestParam(required = false) String meterClass
     ) {
 
-        List<MeterInfoVo> meterTypeListVo = getPowerstationTypeClassName.getMeterTypeCalculating(windId, type, meterClass);
+        List<MeterInfoVo> meterTypeListVo = getPowerstationTypeClassName.getMeterTypeCalculatingAll(windId, type, meterClass);
         Map<String, Object> response = new HashMap<>();
         response.put("type", meterTypeListVo);
         return new Result<>(200, "成功", response);
@@ -103,4 +103,27 @@ public class GetTypeController {
         return new Result<>(200, "成功", response);
     }
 
+
+
+    /**
+     * 获取线路
+     *
+     * @param windId     风场nem_code
+     * @return 根据nem_code返回meter_type;
+     * 根据nem_code,meter_type返回meter_class;
+     * 根据nem_code,meter_type,meter_class返回name;
+     */
+    @GetMapping("/getLinename")
+    public Result<Object> getLineName(
+            @RequestParam(required = false) String windId
+
+    ) {
+        List<MeterInfoVo> meterTypeListVo = getPowerstationTypeClassName.getLineName(windId);
+
+        Map<String, Object> response = new HashMap<>();
+        response.put("type", meterTypeListVo);
+        return new Result<>(200, "成功", response);
+
+    }
+
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/controller/MeterController.java

@@ -2,10 +2,8 @@ package com.gyee.gaia.meter.controller;
 
 import com.gyee.gaia.meter.entity.vo.MeterVO;
 import com.gyee.gaia.meter.entity.vo.Result;
-import com.gyee.gaia.meter.service.meter.GetLineInfoById;
-import com.gyee.gaia.meter.service.meter.GetPowerStationInfoById;
-import com.gyee.gaia.meter.service.meter.GetProjectInfoById;
-import com.gyee.gaia.meter.service.meter.GetWindStationInfo;
+import com.gyee.gaia.meter.entity.vo.SisViewVO;
+import com.gyee.gaia.meter.service.meter.*;
 import org.springframework.web.bind.annotation.CrossOrigin;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -31,10 +29,12 @@ public class MeterController {
     GetProjectInfoById getProjectInfoById;
     @Resource
     GetLineInfoById getLineInfoById;
+    @Resource
+    GetView getView;
 
 
     @GetMapping("")
-    public Result<Object> getMeterInfoFDC1(String id) {
+    public Result<Object> getMeterInfoFDC(String id) {
 
         //所有风场,-1
         if ("-1".equals(id)) {
@@ -92,4 +92,11 @@ public class MeterController {
     }
 
 
+    @GetMapping("/sisView")
+    public Result<Object> getView() {
+        SisViewVO view = getView.getView();
+        return new Result<>(200,"获取数据成功!", view);
+    }
+
+
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/controller/MeterInfoController.java

@@ -21,6 +21,47 @@ public class MeterInfoController {
 
     @Resource
     GetMeterInfo getMeterInfo;
+    /**
+     * 获取根据传入不同参数获取线路小时发电量
+     *
+     * @param windId     风场ID
+     * @param meterType  测点一级类型
+     * @param meterClass 测点二级分类
+     * @param name       测点名称
+     * @param startTime  开始时间(时间戳)
+     * @param endTime    结束时间(时间戳)
+     * @param page       第几页
+     * @param perPage    每页几条数据
+     * @return 时间段内的每日底码数据
+     */
+    @GetMapping("/meterinfo/linefdl")
+    public Result<Object> getLineFDL_15Min(
+            @RequestParam(required = false) String windId,
+            @RequestParam(required = false) String meterType,
+            @RequestParam(required = false) String meterClass,
+            @RequestParam(required = false) String name,
+            @RequestParam(required = false) long startTime,
+            @RequestParam(required = false) long endTime,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "25") int perPage
+    ) {
+        ArrayList<MeterInfoVo> meterInfoByWindIdList = getMeterInfo.getLineFDL_hour(windId, meterType, meterClass, name, startTime, endTime);
+        // 进行排序
+        meterInfoByWindIdList.sort(Comparator.comparing(MeterInfoVo::getName));
+        // 进行分页处理
+        int totalItems = meterInfoByWindIdList.size();
+        int startIndex = (page - 1) * perPage;
+        int endIndex = Math.min(startIndex + perPage, totalItems);
+        List<MeterInfoVo> paginatedList = meterInfoByWindIdList.subList(startIndex, endIndex);
+        // 构建响应
+        Map<String, Object> response = new HashMap<>();
+        response.put("lineFDL", paginatedList);
+        response.put("totalItems", totalItems);
+        response.put("page", page);
+        response.put("perPage", perPage);
+        return new Result<>(200, "成功", response);
+
+    }
 
     /**
      * 获取根据传入不同参数获取每日底码信息
@@ -47,6 +88,8 @@ public class MeterInfoController {
             @RequestParam(defaultValue = "25") int perPage
     ) {
         ArrayList<MeterInfoVo> meterInfoByWindIdList = getMeterInfo.getBottomInfoByWindId(windId, meterType, meterClass, name, startTime, endTime);
+        // 进行排序
+        meterInfoByWindIdList.sort(Comparator.comparing(MeterInfoVo::getName));
         // 进行分页处理
         int totalItems = meterInfoByWindIdList.size();
         int startIndex = (page - 1) * perPage;
@@ -59,6 +102,7 @@ public class MeterInfoController {
         response.put("page", page);
         response.put("perPage", perPage);
         return new Result<>(200, "成功", response);
+
     }
 
 
@@ -101,7 +145,7 @@ public class MeterInfoController {
 
 
     /**
-     * 获取根据传入不同参数获取每日场站指标数据(计算点)
+     * 每日场站指标数据(计算点)
      *
      * @param windId     风场ID
      * @param meterType  测点一级类型
@@ -142,7 +186,7 @@ public class MeterInfoController {
     }
 
     /**
-     * 获取根据传入不同参数获取每月场站指标数据(计算点)
+     * 每月场站指标数据(计算点)
      *
      * @param windId     风场ID
      * @param meterType  测点一级类型
@@ -221,7 +265,7 @@ public class MeterInfoController {
 
 
     /**
-     * 获取根据传入不同参数获取每月底码信息
+     * 每月底码信息
      *
      * @param windId     风场ID
      * @param meterType  测点一级类型
@@ -245,6 +289,8 @@ public class MeterInfoController {
             @RequestParam(defaultValue = "25") int perPage
     ) {
         ArrayList<MeterInfoVo> meterInfoByWindIdList = getMeterInfo.getBottomInfoMonthByWindId(windId, meterType, meterClass, name, startTime, endTime);
+        // 进行排序
+        meterInfoByWindIdList.sort(Comparator.comparing(MeterInfoVo::getName));
         // 进行分页处理
         int totalItems = meterInfoByWindIdList.size();
         int startIndex = (page - 1) * perPage;
@@ -323,6 +369,8 @@ public class MeterInfoController {
             @RequestParam(defaultValue = "25") int perPage
     ) {
         ArrayList<MeterInfoVo> meterInfoByWindIdList = getMeterInfo.getBottomInfoYearByWindId(windId, meterType, meterClass, name, startTime, endTime);
+        // 进行排序
+        meterInfoByWindIdList.sort(Comparator.comparing(MeterInfoVo::getName));
         // 进行分页处理
         int totalItems = meterInfoByWindIdList.size();
         int startIndex = (page - 1) * perPage;

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/ProMeterLineFDL15Min.java

@@ -0,0 +1,92 @@
+package com.gyee.gaia.meter.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * <p>
+ * 风机日发电量表
+ * </p>
+ */
+@TableName("pro_meter_lineFDL_15min")
+@Data
+public class ProMeterLineFDL15Min extends Model<ProMeterLineFDL15Min> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键;主键自增
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    /**
+     * 底码字段名称
+     */
+    private String name;
+
+    /**
+     * 开始时间
+     */
+    private LocalDateTime startTime;
+
+    /**
+     * 开始值
+     */
+    private BigDecimal startValue;
+    /**
+     * 截止时间
+     */
+    private LocalDateTime endTime;
+    /**
+     * 截止值
+     */
+    private BigDecimal endValue;
+    /**
+     * 日电量
+     */
+    private BigDecimal dayValue;
+
+    /**
+     * 测点编码
+     */
+    private String code;
+
+    /**
+     * 创建人;创建人
+     */
+    private String createBy;
+
+    /**
+     * 创建时间;创建时间
+     */
+    private LocalDateTime createTime;
+
+    /**
+     * 更新人;更新人
+     */
+    private String updateBy;
+
+    /**
+     * 更新时间;更新时间
+     */
+    private LocalDateTime updateTime;
+
+    /**
+     * 备注;备注
+     */
+    private String remark;
+
+    /**
+     * 场站
+     */
+    private String windpowerstationId;
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/TDLineFDL15Min.java

@@ -0,0 +1,67 @@
+package com.gyee.gaia.meter.entity;
+
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+
+/**
+ * <p>
+ * 风机日发电量表
+ * </p>
+ */
+@TableName("linefdl15min")
+@Data
+@DS("meter")
+public class TDLineFDL15Min extends Model<TDLineFDL15Min> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 子表名
+     */
+    private String tName;
+
+
+
+    /**
+     * 开始时间
+     */
+    private long  ts;
+
+    /**
+     * 开始值
+     */
+    private double startValue;
+
+
+
+
+    /**
+     * 测点编码
+     */
+    private String windpowerstationId;
+
+    /**
+     * 创建人;创建人
+     */
+    private String projectId;
+
+    /**
+     * 底码字段名称
+     */
+    private String name;
+
+
+
+
+
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/vo/MeterInfoVo.java

@@ -15,6 +15,8 @@ public class MeterInfoVo {
     private String name;
     private String nemCode;
     private DateTime date;
+    private DateTime startTime;
+    private DateTime endTime;
     private BigDecimal startCode;
     private BigDecimal endCode;
     private BigDecimal rdl;

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/vo/MeterVO.java

@@ -13,9 +13,6 @@ import java.math.BigDecimal;
 public class MeterVO {
     public DateTime date;
     public String timestr;
-    //    public BigDecimal rfdl;
-//    public BigDecimal rswdl;
-//    public BigDecimal rgwdl;
 
     //日发电量
     public BigDecimal value1;

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/vo/SisViewVO.java

@@ -0,0 +1,92 @@
+package com.gyee.gaia.meter.entity.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 05: 31
+ **/
+//SisView大屏展示数据
+@Data
+public class SisViewVO {
+    //装机容量
+    public BigDecimal fczjrl;
+    //日发电量
+    public BigDecimal fcrfdl;
+    //月发电量
+    public BigDecimal fcyfdl;
+    //年发电量
+    public BigDecimal fcnfdl;
+    //上网电量
+    public BigDecimal fcswdl;
+    //麻黄山发电量
+    public BigDecimal mhsfdl;
+    //牛首山发电量
+    public BigDecimal nssfdl;
+    //青山发电量
+    public BigDecimal qsfdl;
+    //石板泉发电量
+    public BigDecimal sbqfdl;
+    //香山发电量
+    public BigDecimal xsfdl;
+    //月利用小时
+    public BigDecimal fcylyxs;
+    //年利用小时
+    public BigDecimal fcnlyxs;
+
+
+
+
+    //装机容量
+    public BigDecimal gfzjrl;
+    //日发电量
+    public BigDecimal gfrfdl;
+    //月发电量
+    public BigDecimal gfyfdl;
+    //年发电量
+    public BigDecimal gfnfdl;
+    //上网电量
+    public BigDecimal gfswdl;
+    //埃肯发电量
+    public BigDecimal akfdl;
+    //大武口发电量
+    public BigDecimal dwkfdl;
+    //海子井发电量
+    public BigDecimal hzjfdl;
+    //平罗发电量
+    public BigDecimal plfdl;
+    //马场湖发电量
+    public BigDecimal mchfdl;
+    //宣和发电量
+    public BigDecimal xhfdl;
+
+    //月利用小时
+    public BigDecimal gfylyxs;
+    //年利用小时
+    public BigDecimal gfnlyxs;
+
+
+    //总
+    //装机容量
+    public BigDecimal zjrl;
+    //日发电量
+    public BigDecimal rfdl;
+    //月发电量
+    public BigDecimal yfdl;
+    //年发电量
+    public BigDecimal nfdl;
+    //月利用小时
+    public BigDecimal ylyxs;
+    //年利用小时
+    public BigDecimal nlyxs;
+    //日上网电量
+    public BigDecimal swdl;
+
+
+
+
+
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/job/MeterJob.java

@@ -26,10 +26,12 @@ public class MeterJob {
     SaveSWDL_Day_Month_Year saveSWDLDayMonthYear;
     @Resource
     SaveMeterInfoYesterday saveMeterInfoYesterday;
+    @Resource
+    SaveLineFDL_15Min saveLineFDL_15Min;
 
 
-    @XxlJob("MeterJob")
-    void meterJob() {
+    @XxlJob("MeterJob_FD")
+    void meterJob_FD() {
 
         //设备日发电量(407台风机)
         saveEquipmentFDL.saveEquipmentRfdl();
@@ -45,29 +47,108 @@ public class MeterJob {
         saveCalculating.saveCalculating();
         saveCalculating.saveCalculating();
 
+        //风机日月年发电量
+        saveFDLDayMonthYear.sum();
+
+        //风机日月年上网电量
+        saveSWDLDayMonthYear.sum();
+
     }
 
 
-    @XxlJob("MeterJob_FDL_Day_Month_Year")
-    void meterJob2() {
-        saveFDLDayMonthYear.sum();
+    @XxlJob("SaveMeterInfoYesterday_FD")
+    void meterJob_FD_Yesterday() {
+        saveMeterInfoYesterday.saveMeterInfoYesterday_FD();
+    }
+
+
+    @XxlJob("MeterJob_GF")
+    void meterJob_GF() {
+
+        //设备日发电量(407台风机)
+        saveEquipmentFDL.saveEquipmentRfdl_GF();
+        //期次风机发电量(14个期次)
+        saveEquipmentFDL.saveCalculatingNBQFDL();
+
+        //底码表数据,起始底码,截止底码,日电量
+        saveBottomcode.saveBottomCode_GF();
 
+        saveCalculating.saveCalculating_GF();
+
+
+        //风机日月年发电量
+        saveFDLDayMonthYear.sum_GF();
+
+        //风机日月年上网电量
+        saveSWDLDayMonthYear.sum_GF();
 
     }
 
-    @XxlJob("MeterJob_SWDL_Day_Month_Year")
-    void meterJob3() {
-        saveSWDLDayMonthYear.sum();
 
+    @XxlJob("SaveMeterInfoYesterday_GF")
+    void meterJob_GF_Yesterday() {
+        saveMeterInfoYesterday.saveMeterInfoYesterday_GF();
+    }
+
+
+
+    @XxlJob("MeterJob_GF_FD")
+    void meterJob_GF_FD() {
+
+        //设备日发电量(407台风机)
+        saveEquipmentFDL.saveEquipmentRfdl_GF();
+        //期次风机发电量(14个期次)
+        saveEquipmentFDL.saveCalculatingNBQFDL();
+
+        //底码表数据,起始底码,截止底码,日电量
+        saveBottomcode.saveBottomCode_GF();
+
+        saveCalculating.saveCalculating_GF();
+
+
+        //风机日月年发电量
+        saveFDLDayMonthYear.sum_GF();
+
+        //风机日月年上网电量
+        saveSWDLDayMonthYear.sum_GF();
+
+
+        //设备日发电量(407台风机)
+        saveEquipmentFDL.saveEquipmentRfdl();
+        //期次风机发电量(14个期次)
+        saveEquipmentFDL.saveCalculatingFJFDL();
+
+        //底码表数据,起始底码,截止底码,日电量
+        saveBottomcode.saveBottomCode();
+
+        //计算有公式的发电量,场用电量等(由于后面数据需要用前面算出来的数,所以执行3-4次)
+        saveCalculating.saveCalculating();
+        saveCalculating.saveCalculating();
+        saveCalculating.saveCalculating();
+        saveCalculating.saveCalculating();
+
+        //风机日月年发电量
+        saveFDLDayMonthYear.sum();
+
+        //风机日月年上网电量
+        saveSWDLDayMonthYear.sum();
 
     }
 
-    @XxlJob("SaveMeterInfoYesterday")
-    void meterJob4() {
-        saveMeterInfoYesterday.saveMeterInfoYesterday();
+    @XxlJob("SaveMeterInfoYesterday_GF_FD")
+    void meterJob_GF_FD_Yesterday() {
+
+        saveMeterInfoYesterday.saveMeterInfoYesterday_GF();
+        saveMeterInfoYesterday.saveMeterInfoYesterday_FD();
 
     }
 
 
 
+    @XxlJob("saveLineFDL_15Min")
+    void saveLineFDL_15Min(){
+        saveLineFDL_15Min.saveLineFDL_15Min();
+    }
+
+
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/mapper/ProMeterLineFDL15MinMapper.java

@@ -0,0 +1,11 @@
+package com.gyee.gaia.meter.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import org.apache.ibatis.annotations.Mapper;
+
+
+@Mapper
+public interface ProMeterLineFDL15MinMapper extends BaseMapper<ProMeterLineFDL15Min> {
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/mapper/TDLineFDL15MinMapper.java

@@ -0,0 +1,17 @@
+package com.gyee.gaia.meter.mapper;
+
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import com.gyee.gaia.meter.entity.TDLineFDL15Min;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Mapper;
+
+
+@Mapper
+public interface TDLineFDL15MinMapper extends BaseMapper<TDLineFDL15Min> {
+
+    @Insert("insert into ${entity}")
+    int insert(String entity);
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/SaveLineFDL15MinTest.java

@@ -0,0 +1,172 @@
+package com.gyee.gaia.meter.service;
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.date.LocalDateTimeUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.gaia.meter.adapter.Adapter;
+import com.gyee.gaia.meter.entity.*;
+import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
+import com.gyee.gaia.meter.service.impl.PowerStationServiceImpl;
+import com.gyee.gaia.meter.service.impl.ProMeterLineFDL15MinServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 04: 27
+ **/
+@SpringBootTest
+class SaveLineFDL15MinTest {
+
+
+    @Resource
+    Adapter adapter;
+    @Resource
+    PowerStationServiceImpl powerStationService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    ProMeterLineFDL15MinServiceImpl proMeterLineFDL15MinService;
+
+
+    @Value("${start.time}")
+    private String startTimeString;
+    @Value("${end.time}")
+    private String endTimeString;
+
+
+
+    @Test
+    void saveSaveLineFDL15Min() {
+
+        //1,查询所有风电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+            //2,根据场站ID得到场站下所有测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            //3,遍历测点,拿到每个测点的nem_code
+            for (MeterPoint meterPoint : meterPointList) {
+                System.out.println(meterPoint);
+                //获取测点code
+                String pointcode = meterPoint.getNemCode();
+
+                //设置取值开始时间
+                String startString = startTimeString;
+                DateTime startDateTime = DateUtil.parse(startString);
+
+                //设置取值结束时间
+                String endDateString = endTimeString;
+                DateTime endDateTime0 = DateUtil.parse(endDateString);
+                DateTime endDateTime = DateUtil.endOfDay(endDateTime0);
+
+                //指定开始日期到结束日期的天数
+                LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+                LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+                long between0 = ChronoUnit.MINUTES.between(day1, day2);
+                int between = (int) (between0/15);
+
+
+                for (int i = 0; i <= between; i++) {
+
+                    //开始时间00:00:01
+                    DateTime dateTime1 = DateUtil.offsetMinute(startDateTime, (i-1)*15);
+                    DateTime dateTime2 = DateUtil.offsetMinute(startDateTime, i*15);
+                    BigDecimal bigDecimal1 = new BigDecimal(0);
+                    BigDecimal bigDecimal2 = new BigDecimal(0);
+                    BigDecimal rfdl = new BigDecimal(0);
+
+
+                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                    if (historyRaw.size() > 0) {
+                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                        bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                        bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                        if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
+
+                            ArrayList<Double> arrayList = new ArrayList<>();
+                            for (PointData pointData : historyRaw) {
+                                arrayList.add(pointData.getValue());
+                            }
+                            int index = -1;
+                            // 定义增长阈值
+                            double threshold = 50000.0;
+
+                            for (int j = 1; j < arrayList.size(); j++) {
+                                double current = arrayList.get(j);
+                                double previous = arrayList.get(j - 1);
+                                double difference = current - previous;
+                                if (difference > threshold) {
+                                    index = j;
+                                    break;
+                                }
+                            }
+                            if (index != -1) {
+                                double valueGrow2 = arrayList.get(index);
+                                BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                double valueGrow1 = arrayList.get(index - 1);
+                                BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                            }
+                        }
+                    }
+
+                    ProMeterLineFDL15Min meterInfoBottomcode = new ProMeterLineFDL15Min();
+                    meterInfoBottomcode.setName(meterPoint.getDescription());
+                    meterInfoBottomcode.setStartTime(dateTime1.toLocalDateTime());
+                    meterInfoBottomcode.setStartValue(bigDecimal1);
+                    meterInfoBottomcode.setEndTime(dateTime2.toLocalDateTime());
+                    meterInfoBottomcode.setEndValue(bigDecimal2);
+                    meterInfoBottomcode.setDayValue(rfdl);
+                    meterInfoBottomcode.setCode(pointcode);
+                    meterInfoBottomcode.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<ProMeterLineFDL15Min> queryWrapper = new QueryWrapper<>();
+                    queryWrapper
+                            .eq("start_time", dateTime1.toLocalDateTime())
+                            .eq("code", meterPoint.getNemCode());
+                    List<ProMeterLineFDL15Min> list = proMeterLineFDL15MinService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoBottomcode.update(queryWrapper);
+                    } else {
+                        meterInfoBottomcode.insert();
+                    }
+                }
+            }
+        }
+    }
+
+
+
+
+}
+
+
+
+
+
+
+
+
+

electricity/meter/src/main/java/com/gyee/gaia/meter/service/SaveMeterInfoHistoryMonthYearTest.java

@@ -510,7 +510,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
     @Test
     void savePowerstationFdl_Month() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_MONTH"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_MONTH")
+                .like("windpowerstation_id", "FDC")
+        );
 //        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_NFDL"));
 
         //设置取值开始时间
@@ -565,7 +568,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
     @Test
     void savePowerstationFdl_Year() {
 
-        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_YEAR"));
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_YEAR")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = startTimeString;
@@ -645,7 +651,9 @@ public class SaveMeterInfoHistoryMonthYearTest {
             dateTime1 = DateUtil.offsetDay(startDateTime, i);
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
-            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("date", dateTime1.toLocalDateTime()).like("code", "%_JDXLFDL_P0"));
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%_JDXLFDL_P0"));
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculatingDay.size() > 0) {
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
@@ -970,7 +978,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
     @Test
     void savePowerstationSwdl_Month() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_MONTH"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_MONTH")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = startTimeString;
@@ -990,10 +1001,13 @@ public class SaveMeterInfoHistoryMonthYearTest {
             double monthValue = 0.0;
             for (int i = 0; i <= between; i++) {
                 //开始时间00:00:01
-                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
 
                 //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
-                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("windpowerstation_id", meterPoint.getWindpowerstationId()).eq("date", dateTime1.toLocalDateTime()).like("code", "%SWDL_SBS%_MONTH"));
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%SWDL_SBS%_MONTH"));
 
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
                     //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
@@ -1029,7 +1043,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
     @Test
     void savePowerstationSwdl_Year() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_YEAR"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_YEAR")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = startTimeString;
@@ -1049,10 +1066,13 @@ public class SaveMeterInfoHistoryMonthYearTest {
             double monthValue = 0.0;
             for (int i = 0; i <= between; i++) {
                 //开始时间00:00:01
-                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i * 12);
 
                 //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
-                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("windpowerstation_id", meterPoint.getWindpowerstationId()).eq("date", dateTime1.toLocalDateTime()).like("code", "%SWDL_SBS%_YEAR"));
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%SWDL_SBS%_YEAR"));
 
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
                     //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
@@ -1073,7 +1093,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
             meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
 
             QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
-            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            queryWrapper
+                    .eq("code", meterPoint.getNemCode())
+                    .eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0))
+                    .eq("windpowerstation_id", meterPoint.getWindpowerstationId());
             List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
             if (list.size() > 0) {
                 meterInfoCalculating.update(queryWrapper);
@@ -1091,8 +1114,8 @@ public class SaveMeterInfoHistoryMonthYearTest {
         MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCSWDL_DAY"));
         //设置取值开始时间
         String startString = startTimeString;
-        DateTime startDateTime0 = DateUtil.parse(startString);
-        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime startDateTime = DateUtil.parse(startString);
+//        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
 
         //设置取值结束时间
         String endDateString = endTimeString;
@@ -1110,15 +1133,15 @@ public class SaveMeterInfoHistoryMonthYearTest {
         DateTime dateTime1 = DateTime.of(0);
 
 
-
-
         for (int i = 0; i <= between; i++) {
             double monthValue = 0.0;
             //开始时间00:00:00
             dateTime1 = DateUtil.offsetDay(startDateTime, i);
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
-            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("date", dateTime1.toLocalDateTime()).like("code", "%_SWDL_P0"));
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%_SWDL_P0"));
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculatingDay.size() > 0) {
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
@@ -1175,7 +1198,11 @@ public class SaveMeterInfoHistoryMonthYearTest {
             dateTime1 = DateUtil.offsetMonth(startDateTime, i);
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
-            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("date", dateTime1.toLocalDateTime()).like("code", "%_SWDL_MONTH"));
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%_SWDL_MONTH")
+                    .like("windpowerstation_id", "_FDC_")
+            );
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculatingDay.size() > 0) {
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
@@ -1233,7 +1260,10 @@ public class SaveMeterInfoHistoryMonthYearTest {
             dateTime1 = DateUtil.offsetMonth(startDateTime, i);
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路期次)
-            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>().eq("date", dateTime1.toLocalDateTime()).eq("code", "DL.NX_GD_FCSWDL_MONTH"));
+            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .eq("code", "DL.NX_GD_FCSWDL_MONTH")
+            );
 
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculating != null) {
@@ -1261,18 +1291,14 @@ public class SaveMeterInfoHistoryMonthYearTest {
 
     }
 
-
-
-
-
     @Test
     void saveWindStationGwdl_Day() {
 
         MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCGWDL_DAY"));
         //设置取值开始时间
         String startString = startTimeString;
-        DateTime startDateTime0 = DateUtil.parse(startString);
-        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime startDateTime = DateUtil.parse(startString);
+//        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
 
         //设置取值结束时间
         String endDateString = endTimeString;
@@ -1290,7 +1316,6 @@ public class SaveMeterInfoHistoryMonthYearTest {
         DateTime dateTime1 = DateTime.of(0);
 
 
-
         for (int i = 0; i <= between; i++) {
             double monthValue = 0.0;
             //开始时间00:00:00
@@ -1312,7 +1337,7 @@ public class SaveMeterInfoHistoryMonthYearTest {
             meterInfoCalculating.setCode(meterPoint.getNemCode());
             //LocalDateTime只显示年月(实际为每月的1号00:00:00)
             meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
-            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue).divide(BigDecimal.valueOf(10000),4,RoundingMode.HALF_EVEN));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
             meterInfoCalculating.setUpdateTime(LocalDateTime.now());
 
             QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
@@ -1328,37 +1353,740 @@ public class SaveMeterInfoHistoryMonthYearTest {
     }
 
 
+    //光伏
     @Test
-    void sum() {
-        this.saveLineFdl_Month();
-        this.saveLineFdl_Year();
+    void savePowerstationFdl_GF_Month() {
 
-        this.saveProjectFdl_Month();
-        this.saveProjectFdl_Year();
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_MONTH")
+                .like("windpowerstation_id", "_GDC_")
+        );
 
-        this.savePowerstationFdl_Month();
-        this.savePowerstationFdl_Year();
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfMonth(startDateTime0);
 
-        this.saveWindStationFdl_Day();
-        this.saveWindStationFdl_Month();
-        this.saveWindStationFdl_Year();
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
 
-        this.saveSBSSwdl_Month();
-        this.saveSBSSwdl_Year();
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
 
-        this.savePowerstationSwdl_Month();
-        this.savePowerstationSwdl_Year();
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetDay(startDateTime, i);
 
-        this.saveWindStationSwdl_Day();
-        this.saveWindStationSwdl_Month();
-        this.saveWindStationSwdl_Year();
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                MeterInfoCalculating meterInfoCalculatingDay = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "_GFJDXLFDL_PO"));
+
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoCalculatingDay != null) {
+                    monthValue = monthValue + meterInfoCalculatingDay.getValue().doubleValue();
+                }
+            }
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+    }
+
+    @Test
+    void savePowerstationFdl_GF_Year() {
 
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_YEAR")
+                .like("windpowerstation_id", "_GDC_")
+        );
 
-        this.saveWindStationGwdl_Day();
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfYear(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_NFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double yearValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%_POWERSTATIONFDL_MONTH"));
+
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoCalculating != null) {
+                    yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+    }
 
+    @Test
+    void saveWindStationFdl_GF_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFFDL_DAY"));
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime = DateUtil.parse(startString);
+
+        //设置取值结束时间
+        String endDateString = endTimeString;
+        DateTime endDateTime = DateUtil.parse(endDateString);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+        System.out.println("相差天数:" + between);
+
+
+        DateTime dateTime1 = DateTime.of(0);
+
+
+        for (int i = 0; i <= between; i++) {
+            double monthValue = 0.0;
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%_GFJDXLFDL_PO"));
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+
+    }
+
+    @Test
+    void saveWindStationFdl_GF_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFFDL_MONTH"));
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfMonth(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+
+
+        DateTime dateTime1 = DateTime.of(0);
+        double monthValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "_POWERSTATIONFDL_MONTH")
+                    .like("windpowerstation_id", "_GDC_")
+            );
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+        }
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
 
     }
 
+    @Test
+    void saveWindStationFdl_GF_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_GFFDL_YEAR")
+        );
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfYear(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+
+        DateTime dateTime1 = DateTime.of(0);
+        double yearValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:01
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路期次)
+            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .eq("code", "DL.NX_GD_GFFDL_MONTH")
+            );
+
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculating != null) {
+                yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+
+    @Test
+    void savePowerstationSwdl_GF_Month() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_MONTH")
+                .like("windpowerstation_id", "_GDC_")
+        );
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfMonth(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+
+
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "_GFSWDL_PO"));
+
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+
+            }
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper
+                    .eq("code", meterPoint.getNemCode())
+                    .eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0))
+                    .eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+        }
+
+    }
+
+    @Test
+    void savePowerstationSwdl_GF_Year() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_YEAR")
+                .like("windpowerstation_id", "_GDC_"));
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfYear(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "POWERSTATIONSWDL_MONTH"));
+
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+
+            }
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper
+                    .eq("code", meterPoint.getNemCode())
+                    .eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0))
+                    .eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+        }
+
+    }
+
+    @Test
+    void saveGFSwdl_GF_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_GFSWDL_DAY"));
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime = DateUtil.parse(startString);
+//        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+
+        //设置取值结束时间
+        String endDateString = endTimeString;
+        DateTime endDateTime = DateUtil.parse(endDateString);
+//        DateTime endDateTime = DateUtil.endOfMonth(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+
+
+        DateTime dateTime1 = DateTime.of(0);
+
+
+        for (int i = 0; i <= between; i++) {
+            double monthValue = 0.0;
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%_GFSWDL_PO"));
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+
+    }
+
+    @Test
+    void saveGFSwdl_GF_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFSWDL_MONTH"));
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfMonth(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+
+
+        DateTime dateTime1 = DateTime.of(0);
+        double monthValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%POWERSTATIONSWDL_MONTH"));
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+        }
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+    @Test
+    void saveGFSwdl_GF_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFSWDL_YEAR"));
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime0 = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(startDateTime0);
+        DateTime endDateTime = DateUtil.endOfYear(startDateTime0);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+
+        DateTime dateTime1 = DateTime.of(0);
+        double yearValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:01
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路期次)
+            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .eq("code", "DL.NX_GD_GFSWDL_MONTH"));
+
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculating != null) {
+                yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper
+                .eq("code", meterPoint.getNemCode())
+                .eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+
+
+
+
+    //所有风机
+    @Test
+    void sum_FC() {
+        this.saveLineFdl_Month();
+        this.saveLineFdl_Year();
+
+        this.saveProjectFdl_Month();
+        this.saveProjectFdl_Year();
+
+        this.savePowerstationFdl_Month();
+        this.savePowerstationFdl_Year();
+
+        this.saveWindStationFdl_Day();
+        this.saveWindStationFdl_Month();
+        this.saveWindStationFdl_Year();
+
+        this.saveSBSSwdl_Month();
+        this.saveSBSSwdl_Year();
+
+        this.savePowerstationSwdl_Month();
+        this.savePowerstationSwdl_Year();
+
+        this.saveWindStationSwdl_Day();
+        this.saveWindStationSwdl_Month();
+        this.saveWindStationSwdl_Year();
+
+
+        this.saveWindStationGwdl_Day();
+
+
+    }
+
+    //所有光伏
+    @Test
+    void sum_GF() {
+        this.savePowerstationFdl_GF_Month();
+        this.savePowerstationFdl_GF_Year();
+
+        this.saveWindStationFdl_GF_Day();
+        this.saveWindStationFdl_GF_Month();
+        this.saveWindStationFdl_GF_Year();
+
+        this.savePowerstationSwdl_GF_Month();
+        this.savePowerstationSwdl_GF_Year();
+
+        this.saveGFSwdl_GF_Day();
+        this.saveGFSwdl_GF_Month();
+        this.saveGFSwdl_GF_Year();
+
+
+    }
+
+
+    //所有风机+光伏
+    @Test
+    void sumGF_FD() {
+
+        this.savePowerstationFdl_GF_Month();
+        this.savePowerstationFdl_GF_Year();
+
+        this.saveWindStationFdl_GF_Day();
+        this.saveWindStationFdl_GF_Month();
+        this.saveWindStationFdl_GF_Year();
+
+        this.savePowerstationSwdl_GF_Month();
+        this.savePowerstationSwdl_GF_Year();
+
+        this.saveGFSwdl_GF_Day();
+        this.saveGFSwdl_GF_Month();
+        this.saveGFSwdl_GF_Year();
+
+
+
+
+        this.saveLineFdl_Month();
+        this.saveLineFdl_Year();
+
+        this.saveProjectFdl_Month();
+        this.saveProjectFdl_Year();
+
+        this.savePowerstationFdl_Month();
+        this.savePowerstationFdl_Year();
+
+        this.saveWindStationFdl_Day();
+        this.saveWindStationFdl_Month();
+        this.saveWindStationFdl_Year();
+
+        this.saveSBSSwdl_Month();
+        this.saveSBSSwdl_Year();
+
+        this.savePowerstationSwdl_Month();
+        this.savePowerstationSwdl_Year();
+
+        this.saveWindStationSwdl_Day();
+        this.saveWindStationSwdl_Month();
+        this.saveWindStationSwdl_Year();
+
+
+        this.saveWindStationGwdl_Day();
+
+
+
+
+    }
+
+
+
+
 }
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/TDSaveLineFDL15MinTest.java

@@ -0,0 +1,88 @@
+package com.gyee.gaia.meter.service;
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.date.LocalDateTimeUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.gaia.meter.adapter.Adapter;
+import com.gyee.gaia.meter.entity.*;
+import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
+import com.gyee.gaia.meter.service.impl.PowerStationServiceImpl;
+import com.gyee.gaia.meter.service.impl.ProMeterLineFDL15MinServiceImpl;
+import com.gyee.gaia.meter.service.impl.TDLineFDL15MinServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 04: 27
+ **/
+@SpringBootTest
+class TDSaveLineFDL15MinTest {
+    @Resource
+    TDLineFDL15MinServiceImpl tdLineFDL15MinService;
+
+
+    @Resource
+    Adapter adapter;
+    @Resource
+    PowerStationServiceImpl powerStationService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    ProMeterLineFDL15MinServiceImpl proMeterLineFDL15MinService;
+
+
+    @Value("${start.time}")
+    private String startTimeString;
+    @Value("${end.time}")
+    private String endTimeString;
+
+
+
+    @Test
+    void TDSaveSaveLineFDL15Min() {
+
+
+        TDLineFDL15Min tdLineFDL15Min = new TDLineFDL15Min();
+//        tdLineFDL15Min.setTName("MHSDJL.NX_GD_MHSF_DD_P1_L1_001_ZXYG045");
+        tdLineFDL15Min.setTs(new Date().getTime());
+        tdLineFDL15Min.setStartValue(100);
+        tdLineFDL15Min.setWindpowerstationId("NX_GDDL_MHS_FDC_STA");
+        tdLineFDL15Min.setProjectId("NX_GDDL_MHSF02_EG");
+
+
+        tdLineFDL15MinService.saveBatch();
+
+
+
+
+
+
+    }
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IEquipmentService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.Equipment;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/ILineService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.Line;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IMeterInfoBottomcodeService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.MeterInfoBottomcode;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IMeterInfoCalculatingService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.MeterInfoCalculating;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IMeterInfoEquipmentService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.MeterInfoEquipment;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IMeterPointService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.MeterPoint;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IPowerStationService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.PowerStation;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/iService/IProMeterLineFDL15MinService.java

@@ -0,0 +1,16 @@
+package com.gyee.gaia.meter.service.iService;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+
+/**
+ * <p>
+ * 公司日发电量表 服务类
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-04-28
+ */
+public interface IProMeterLineFDL15MinService extends IService<ProMeterLineFDL15Min> {
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/IProjectService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.Project;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/iService/ITDLineFDL15MinService.java

@@ -0,0 +1,17 @@
+package com.gyee.gaia.meter.service.iService;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import com.gyee.gaia.meter.entity.TDLineFDL15Min;
+
+/**
+ * <p>
+ * 公司日发电量表 服务类
+ * </p>
+ *
+ * @author gfhd
+ * @since 2023-04-28
+ */
+public interface ITDLineFDL15MinService extends IService<TDLineFDL15Min> {
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/ITestingPointService.java

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.service;
+package com.gyee.gaia.meter.service.iService;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.gyee.gaia.meter.entity.TestingPoint;

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/EquipmentServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.Equipment;
 import com.gyee.gaia.meter.mapper.EquipmentMapper;
-import com.gyee.gaia.meter.service.IEquipmentService;
+import com.gyee.gaia.meter.service.iService.IEquipmentService;
 import org.springframework.stereotype.Service;
 
 /**

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/LineServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.Line;
 import com.gyee.gaia.meter.mapper.LineMapper;
-import com.gyee.gaia.meter.service.ILineService;
+import com.gyee.gaia.meter.service.iService.ILineService;
 import org.springframework.stereotype.Service;
 
 /**

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/MeterInfoBottomcodeServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.MeterInfoBottomcode;
 import com.gyee.gaia.meter.mapper.MeterInfoBottomcodeMapper;
-import com.gyee.gaia.meter.service.IMeterInfoBottomcodeService;
+import com.gyee.gaia.meter.service.iService.IMeterInfoBottomcodeService;
 import org.springframework.stereotype.Service;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/MeterInfoCalculatingServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.MeterInfoCalculating;
 import com.gyee.gaia.meter.mapper.MeterInfoCalculatingMapper;
-import com.gyee.gaia.meter.service.IMeterInfoCalculatingService;
+import com.gyee.gaia.meter.service.iService.IMeterInfoCalculatingService;
 import org.springframework.stereotype.Service;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/MeterInfoEquipmentServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.MeterInfoEquipment;
 import com.gyee.gaia.meter.mapper.MeterInfoEquipmentMapper;
-import com.gyee.gaia.meter.service.IMeterInfoEquipmentService;
+import com.gyee.gaia.meter.service.iService.IMeterInfoEquipmentService;
 import org.springframework.stereotype.Service;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/MeterPointServiceImpl.java

@@ -4,7 +4,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.MeterPoint;
 import com.gyee.gaia.meter.mapper.MeterPointMapper;
-import com.gyee.gaia.meter.service.IMeterPointService;
+import com.gyee.gaia.meter.service.iService.IMeterPointService;
 import org.springframework.stereotype.Service;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/PowerStationServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.PowerStation;
 import com.gyee.gaia.meter.mapper.PowerStationMapper;
-import com.gyee.gaia.meter.service.IPowerStationService;
+import com.gyee.gaia.meter.service.iService.IPowerStationService;
 import org.springframework.stereotype.Service;
 
 /**

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/ProMeterLineFDL15MinServiceImpl.java

@@ -0,0 +1,13 @@
+package com.gyee.gaia.meter.service.impl;
+
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import com.gyee.gaia.meter.mapper.ProMeterLineFDL15MinMapper;
+import com.gyee.gaia.meter.service.iService.IProMeterLineFDL15MinService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ProMeterLineFDL15MinServiceImpl extends ServiceImpl<ProMeterLineFDL15MinMapper, ProMeterLineFDL15Min> implements IProMeterLineFDL15MinService {
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/ProjectServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.Project;
 import com.gyee.gaia.meter.mapper.ProjectMapper;
-import com.gyee.gaia.meter.service.IProjectService;
+import com.gyee.gaia.meter.service.iService.IProjectService;
 import org.springframework.stereotype.Service;
 
 /**

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/TDLineFDL15MinServiceImpl.java

@@ -0,0 +1,33 @@
+package com.gyee.gaia.meter.service.impl;
+
+
+import cn.hutool.core.collection.ListUtil;
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import com.gyee.gaia.meter.entity.TDLineFDL15Min;
+import com.gyee.gaia.meter.mapper.ProMeterLineFDL15MinMapper;
+import com.gyee.gaia.meter.mapper.TDLineFDL15MinMapper;
+import com.gyee.gaia.meter.service.iService.IProMeterLineFDL15MinService;
+import com.gyee.gaia.meter.service.iService.ITDLineFDL15MinService;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Service
+@DS("meter")
+public class TDLineFDL15MinServiceImpl extends ServiceImpl<TDLineFDL15MinMapper, TDLineFDL15Min> implements ITDLineFDL15MinService {
+
+    @Resource
+    TDLineFDL15MinMapper tdLineFDL15MinMapper;
+
+    public int saveBatch() {
+
+        int count = 0;
+
+            count += tdLineFDL15MinMapper.insert(" MHSDJL_NX_GD_MHSF_DD_P1_L1_001_ZXYG045  VALUES (NOW, 10000);");
+
+        return count;
+    }
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/TestingPointServiceImpl.java

@@ -3,7 +3,7 @@ package com.gyee.gaia.meter.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.gyee.gaia.meter.entity.TestingPoint;
 import com.gyee.gaia.meter.mapper.TestingPointMapper;
-import com.gyee.gaia.meter.service.ITestingPointService;
+import com.gyee.gaia.meter.service.iService.ITestingPointService;
 import org.springframework.stereotype.Service;
 
 /**

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/GetView.java

@@ -0,0 +1,216 @@
+package com.gyee.gaia.meter.service.meter;
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.gaia.meter.entity.MeterInfoCalculating;
+import com.gyee.gaia.meter.entity.vo.SisViewVO;
+import com.gyee.gaia.meter.service.impl.MeterInfoBottomcodeServiceImpl;
+import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 05: 31
+ **/
+@Service
+public class GetView {
+    @Resource
+    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
+    @Resource
+    MeterInfoBottomcodeServiceImpl meterInfoBottomcodeService;
+
+    public SisViewVO getView() {
+
+        //获取当天开始时间
+        DateTime now = DateTime.now();
+        DateTime dateTimeDay = DateUtil.beginOfDay(now);
+        DateTime dateTimeMonth = DateUtil.beginOfMonth(now);
+        DateTime dateTimeYear = DateUtil.beginOfYear(now);
+
+        SisViewVO sisViewVO = new SisViewVO();
+
+        //装机容量
+        sisViewVO.setFczjrl(BigDecimal.valueOf(664));
+
+        //总风场日发电量
+        MeterInfoCalculating oneFCRFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_WINDSTATIONFDL_DAY")
+        );
+        sisViewVO.setFcrfdl(oneFCRFDL.getValue());
+
+        //总风场日上网电量
+        MeterInfoCalculating oneFCSWDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_WINDSTATIONSWDL_DAY")
+        );
+        sisViewVO.setFcswdl(oneFCSWDL.getValue());
+
+        //总风场月发电量
+        MeterInfoCalculating oneFCYFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeMonth.toLocalDateTime())
+                .eq("code", "DL.NX_GD_WINDSTATIONFDL_MONTH")
+        );
+        sisViewVO.setFcyfdl(oneFCYFDL.getValue());
+        //总风场月利用小时
+        sisViewVO.setFcylyxs(oneFCYFDL.getValue().divide(BigDecimal.valueOf(66.4), 2, RoundingMode.HALF_EVEN));
+
+
+        //总风场年发电量
+        MeterInfoCalculating oneFCNFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeYear.toLocalDateTime())
+                .eq("code", "DL.NX_GD_WINDSTATIONFDL_YEAR")
+        );
+        sisViewVO.setFcnfdl(oneFCNFDL.getValue());
+        //总风场年利用小时
+        sisViewVO.setFcnlyxs(oneFCNFDL.getValue().divide(BigDecimal.valueOf(66.4), 2, RoundingMode.HALF_EVEN));
+
+        //麻黄山日发电量
+        MeterInfoCalculating oneMHSFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_MHSF_JDXLFDL_P0")
+        );
+        sisViewVO.setMhsfdl(oneMHSFDL.getValue());
+
+        //牛首山山日发电量
+        MeterInfoCalculating oneNSSFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_NSSF_JDXLFDL_P0")
+        );
+        sisViewVO.setNssfdl(oneNSSFDL.getValue());
+
+        //青山日发电量
+        MeterInfoCalculating oneQSFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_QSF_JDXLFDL_P0")
+        );
+        sisViewVO.setQsfdl(oneQSFDL.getValue());
+
+        //石板泉日发电量
+        MeterInfoCalculating oneSBQFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_SBQF_JDXLFDL_P0")
+        );
+        sisViewVO.setSbqfdl(oneSBQFDL.getValue());
+
+        //香山日发电量
+        MeterInfoCalculating oneXSFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_XSF_JDXLFDL_P0")
+        );
+        sisViewVO.setXsfdl(oneXSFDL.getValue());
+
+
+        //光伏
+        //装机容量
+        sisViewVO.setGfzjrl(BigDecimal.valueOf(122.56));
+
+        //总光伏日发电量
+        MeterInfoCalculating oneGFRFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_GFFDL_DAY")
+        );
+        sisViewVO.setGfrfdl(oneGFRFDL.getValue());
+        ;
+
+        //总光伏日上网电量
+        MeterInfoCalculating oneGFSWDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_GFSWDL_DAY")
+        );
+        sisViewVO.setGfswdl(oneGFSWDL.getValue());
+
+        //总光伏月发电量
+        MeterInfoCalculating oneGFYFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeMonth.toLocalDateTime())
+                .eq("code", "DL.NX_GD_GFFDL_MONTH")
+        );
+        sisViewVO.setGfyfdl(oneGFYFDL.getValue());
+        //总光伏月利用小时
+        sisViewVO.setGfylyxs(oneGFYFDL.getValue().divide(BigDecimal.valueOf(12.256), 2, RoundingMode.HALF_EVEN));
+
+
+        //总光伏年发电量
+        MeterInfoCalculating oneGFNFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeYear.toLocalDateTime())
+                .eq("code", "DL.NX_GD_GFFDL_YEAR")
+        );
+        sisViewVO.setGfnfdl(oneGFNFDL.getValue());
+        //总光伏年利用小时
+        sisViewVO.setGfnlyxs(oneGFNFDL.getValue().divide(BigDecimal.valueOf(12.156), 2, RoundingMode.HALF_EVEN));
+
+        //埃肯日发电量
+        MeterInfoCalculating oneAKFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_AK_GFJDXLFDL_PO")
+        );
+        sisViewVO.setAkfdl(oneAKFDL.getValue());
+
+        //大武口日发电量
+        MeterInfoCalculating oneDKWFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_DWK_GFJDXLFDL_PO")
+        );
+        sisViewVO.setDwkfdl(oneDKWFDL.getValue());
+
+        //海子井日发电量
+        MeterInfoCalculating oneHZJFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_HZJ_GFJDXLFDL_PO")
+        );
+        sisViewVO.setHzjfdl(oneHZJFDL.getValue());
+
+        //马场湖日发电量
+        MeterInfoCalculating oneMCHFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_MCH_GFJDXLFDL_PO")
+        );
+        sisViewVO.setMchfdl(oneMCHFDL.getValue());
+
+        //平罗日发电量
+        MeterInfoCalculating onePLFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_PL_GFJDXLFDL_PO")
+        );
+        sisViewVO.setPlfdl(onePLFDL.getValue());
+
+        //宣和日发电量
+        MeterInfoCalculating oneXHFDL = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", dateTimeDay.toLocalDateTime())
+                .eq("code", "DL.NX_GD_XH_GFJDXLFDL_PO")
+        );
+        sisViewVO.setXhfdl(oneXHFDL.getValue());
+
+
+        //总
+        //装机容量
+        sisViewVO.setZjrl(BigDecimal.valueOf(786.56));
+
+        //日发电量
+        sisViewVO.setRfdl(oneFCRFDL.getValue().add(oneGFRFDL.getValue()));
+
+        //月发电量
+        sisViewVO.setYfdl(oneFCYFDL.getValue().add(oneGFYFDL.getValue()));
+
+        //月利用小时
+        sisViewVO.setYlyxs(oneFCYFDL.getValue().add(oneGFYFDL.getValue()).divide(BigDecimal.valueOf(786.56), 2, RoundingMode.HALF_EVEN));
+
+        //年发电量
+        sisViewVO.setNfdl(oneFCNFDL.getValue().add(oneGFNFDL.getValue()));
+
+        //年利用小时
+        sisViewVO.setNlyxs(oneFCNFDL.getValue().add(oneGFNFDL.getValue()).divide(BigDecimal.valueOf(786.56), 2, RoundingMode.HALF_EVEN));
+
+        //日上网电量
+        sisViewVO.setSwdl(oneFCSWDL.getValue().add(oneGFSWDL.getValue()));
+
+
+        return sisViewVO;
+    }
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveBottomcode.java

@@ -19,6 +19,7 @@ import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Author: malijun
@@ -41,7 +42,8 @@ public class SaveBottomcode {
    public void saveBottomCode() {
 
         //1,查询所有风电场
-        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>().like("nem_code", "_FDC_"));
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
 
         for (PowerStation powerStation : powerStationList) {
 
@@ -60,22 +62,32 @@ public class SaveBottomcode {
 
 
                 //开始时间00:00:01
-                DateTime dateTime1 = startDateTime;
 
-                //结束时间第二天00:00:01
-                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
-
-                //从适配器拿当日数据
-                List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+                //结束时间第
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
+                DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, 1), -1);
+                DateTime dateTime0 = DateUtil.offsetMillisecond(startDateTime, -1);
 
                 //定义开始值,结束值,日发电量值,给0,避免适配器拿不到数
                 BigDecimal bigDecimal1 = new BigDecimal(0);
                 BigDecimal bigDecimal2 = new BigDecimal(0);
                 BigDecimal rfdl = new BigDecimal(0);
 
+                Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                double value0;
+                if (!historySection.isEmpty()) {
+                    value0 = historySection.get(pointcode).getValue();
+                    bigDecimal1 = new BigDecimal(Double.toString(value0));
+                }
+
+                //从适配器拿当日数据
+                List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, startDateTime.getTime(), dateTime2.getTime());
+
+
+
                 //适配器拿到开始值和结束值,除以系数(四舍五入保留4位),乘倍率得到日电量
                 if (historyRaw.size() > 0) {
-                    bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+//                    bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
                     bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
                     bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
                     bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
@@ -120,7 +132,7 @@ public class SaveBottomcode {
 
                 MeterInfoBottomcode meterInfoBottomcode = new MeterInfoBottomcode();
                 meterInfoBottomcode.setName(meterPoint.getName());
-                meterInfoBottomcode.setStartTime(dateTime1.toLocalDateTime());
+                meterInfoBottomcode.setStartTime(startDateTime.toLocalDateTime());
                 meterInfoBottomcode.setStartValue(bigDecimal1);
                 meterInfoBottomcode.setEndTime(nowDateTime.toLocalDateTime());
                 meterInfoBottomcode.setEndValue(bigDecimal2);
@@ -130,7 +142,7 @@ public class SaveBottomcode {
 
                 //判断有无数据,插入或者更新
                 QueryWrapper<MeterInfoBottomcode> queryWrapper = new QueryWrapper<>();
-                queryWrapper.eq("start_time", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                queryWrapper.eq("start_time", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
                 List<MeterInfoBottomcode> list = meterInfoBottomcodeService.list(queryWrapper);
                 if (list.size() > 0) {
                     meterInfoBottomcode.update(queryWrapper);
@@ -146,6 +158,115 @@ public class SaveBottomcode {
     }
 
 
+    //光伏底码数据
+   public void saveBottomCode_GF() {
+
+        //1,查询所有光电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_GDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+
+            //2,根据场站ID得到场站下所有测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+            );
+
+            if (meterPointList.size() > 0) {
+
+                //3,遍历测点,拿到每个测点的nem_code
+                for (MeterPoint meterPoint : meterPointList) {
+                    System.out.println(meterPoint);
+                    //获取测点code
+                    String pointcode = meterPoint.getNemCode();
+
+                    //2,获取当前日期,当日开始时间
+                    DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+                    DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+                    //结束时间第
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
+                    DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, 1), -1);
+                    DateTime dateTime0 = DateUtil.offsetMillisecond(startDateTime, -1);
+
+                        BigDecimal bigDecimal1 = new BigDecimal(0);
+                        BigDecimal bigDecimal2 = new BigDecimal(0);
+                        BigDecimal rfdl = new BigDecimal(0);
+
+                        Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                        double value0 = 0;
+                        if (!historySection.isEmpty()) {
+                            value0 = historySection.get(pointcode).getValue();
+                        }
+                        bigDecimal1 = new BigDecimal(Double.toString(value0));
+
+                        List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, startDateTime.getTime(), dateTime2.getTime());
+
+                        if (historyRaw.size() > 0) {
+//                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                            bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                            bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                            bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                            rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                            if (rfdl.doubleValue() > 1000000 || rfdl.doubleValue() < 0) {
+
+                                ArrayList<Double> arrayList = new ArrayList<>();
+                                for (PointData pointData : historyRaw) {
+                                    arrayList.add(pointData.getValue());
+                                }
+                                int index = -1;
+                                // 定义增长阈值
+                                double threshold = 15000.0;
+
+                                for (int j = 1; j < arrayList.size(); j++) {
+                                    double current = arrayList.get(j);
+                                    double previous = arrayList.get(j - 1);
+                                    double difference = current - previous;
+                                    if (difference > threshold) {
+                                        index = j;
+                                        break;
+                                    }
+                                }
+                                if (index != -1) {
+                                    double valueGrow2 = arrayList.get(index);
+                                    BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                    double valueGrow1 = arrayList.get(index - 1);
+                                    BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                    rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                                }
+                            }
+                        }
+
+                        MeterInfoBottomcode meterInfoBottomcode = new MeterInfoBottomcode();
+                        meterInfoBottomcode.setName(meterPoint.getName());
+                        meterInfoBottomcode.setStartTime(startDateTime.toLocalDateTime());
+                        meterInfoBottomcode.setStartValue(bigDecimal1);
+                        meterInfoBottomcode.setEndTime(dateTime2.toLocalDateTime());
+                        meterInfoBottomcode.setEndValue(bigDecimal2);
+                        meterInfoBottomcode.setDayValue(rfdl);
+                        meterInfoBottomcode.setCode(pointcode);
+                        meterInfoBottomcode.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                        QueryWrapper<MeterInfoBottomcode> queryWrapper = new QueryWrapper<>();
+                        queryWrapper.eq("start_time", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                        List<MeterInfoBottomcode> list = meterInfoBottomcodeService.list(queryWrapper);
+                        if (list.size() > 0) {
+                            meterInfoBottomcode.update(queryWrapper);
+                        } else {
+                            meterInfoBottomcode.insert();
+                        }
+
+                }
+            }
+        }
+    }
+
+
+
+
+
 }
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveCalculating.java

@@ -2,6 +2,7 @@ package com.gyee.gaia.meter.service.meter;
 
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.date.LocalDateTimeUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.gyee.gaia.meter.entity.MeterInfoBottomcode;
 import com.gyee.gaia.meter.entity.MeterInfoCalculating;
@@ -16,7 +17,10 @@ import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -43,7 +47,9 @@ public class SaveCalculating {
         DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
 
         //meterPoint表中,有公式的计算点
-        List<MeterPoint> meterPointJSDList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD").ne("formula", ""));
+        List<MeterPoint> meterPointJSDList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD")
+                .ne("formula", ""));
 
         for (MeterPoint meterPoint : meterPointJSDList) {
 
@@ -63,7 +69,6 @@ public class SaveCalculating {
             //map存公式中测点的数据
             HashMap<String, Object> map = new HashMap<>();
             //开始时间
-            DateTime dateTime1 = startDateTime;
 
             //遍历code数组,拿到每一个code,用code和时间,在meter_info_bottom中拿到dayValue
             for (String meterPointCode : meterPointCodes) {
@@ -73,10 +78,10 @@ public class SaveCalculating {
                 //如果字符串以DL开头,从meter_info_calculating表中取,否则从meter_info_bottom表中取
                 try {
                     if (meterPointCode.startsWith("DL")) {
-                        MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>().eq("code", meterPointCode).eq("date", dateTime1));
+                        MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>().eq("code", meterPointCode).eq("date", startDateTime));
                         map.put(meterPointCode_, meterInfoCalculating.getValue());
                     } else {
-                        MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointCode).eq("start_time", dateTime1));
+                        MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointCode).eq("start_time", startDateTime));
                         map.put(meterPointCode_, meterInfoBottomcode.getDayValue());
                     }
                 } catch (Exception e) {
@@ -92,13 +97,13 @@ public class SaveCalculating {
                 MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
                 meterInfoCalculating.setName(meterPoint.getName());
                 meterInfoCalculating.setCode(meterPoint.getNemCode());
-                meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                meterInfoCalculating.setDate(startDateTime.toLocalDateTime());
                 meterInfoCalculating.setValue(bigDecimal1);
                 meterInfoCalculating.setUpdateTime(nowDateTime.toLocalDateTime());
                 meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
 
                 QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
-                queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                queryWrapper.eq("date", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
                 List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
                 if (list.size() > 0) {
                     meterInfoCalculating.update(queryWrapper);
@@ -110,13 +115,13 @@ public class SaveCalculating {
                 MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
                 meterInfoCalculating.setName(meterPoint.getName());
                 meterInfoCalculating.setCode(meterPoint.getNemCode());
-                meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                meterInfoCalculating.setDate(startDateTime.toLocalDateTime());
                 meterInfoCalculating.setValue(BigDecimal.valueOf(0));
                 meterInfoCalculating.setUpdateTime(LocalDateTime.now());
                 meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
 
                 QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
-                queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                queryWrapper.eq("date", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
                 List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
                 if (list.size() > 0) {
                     meterInfoCalculating.update(queryWrapper);
@@ -132,6 +137,176 @@ public class SaveCalculating {
 
 
     }
+
+
+    //有公式的计算光伏电量
+    public  void saveCalculating_GF() {
+
+        //获取当前日期,当日开始时间
+        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+        DateTime endDateTime = DateUtil.endOfDay(nowDateTime);
+
+        //指定开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+        List<MeterPoint> meterPointJSDList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_GF")
+                .ne("formula", ""));
+
+
+        //时间集合,以便后面批量查询
+        List<DateTime> dateTimes = new ArrayList<>();
+        for (int i = 0; i <= between; i++) {
+            DateTime dateTime4 = DateUtil.offsetDay(startDateTime, i);
+            dateTimes.add(dateTime4);
+        }
+        //code集合,以便后面批量查询
+        List<String> codes = new ArrayList<>();
+        for (MeterPoint meterPoint : meterPointJSDList) {
+            String formula1 = meterPoint.getFormula();
+            System.out.println("转换前的公式:" + formula1);
+            String formula2 = formula1
+                    .replaceAll("DL.NX", "DL_NX")
+                    .replaceAll("DJL.", "DJL_")
+                    .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                    ;
+            System.out.println("转换后的公式字符串:" + formula2);
+
+
+            String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
+            meterPointCodes = Arrays.stream(meterPointCodes)
+                    .filter(meterPointCode -> !(meterPointCode.length() < 8))
+                    .toArray(String[]::new);
+            System.out.println("过滤后公式中的测点数:" + meterPointCodes.length);
+            System.out.println(Arrays.toString(meterPointCodes));
+            codes.addAll(Arrays.asList(meterPointCodes));
+        }
+
+        //批量查询
+        List<MeterInfoCalculating> list1 = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                .in("code", codes)
+                .in("date", dateTimes)
+        );
+        List<MeterInfoBottomcode> list2 = meterInfoBottomcodeService.list(new QueryWrapper<MeterInfoBottomcode>()
+                .in("code", codes)
+                .in("start_time", dateTimes));
+
+
+        for (MeterPoint meterPoint : meterPointJSDList) {
+            String formula1 = meterPoint.getFormula();
+            System.out.println("转换前的公式:" + formula1);
+            String formula2 = formula1
+                    .replaceAll("DL.NX", "DL_NX")
+                    .replaceAll("DJL.", "DJL_")
+                    .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                    ;
+            System.out.println("转换后的公式字符串:" + formula2);
+
+
+            String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
+            meterPointCodes = Arrays.stream(meterPointCodes)
+                    .filter(meterPointCode -> !(meterPointCode.length() < 8))
+                    .toArray(String[]::new);
+            System.out.println("过滤后公式中的测点数:" + meterPointCodes.length);
+            System.out.println(Arrays.toString(meterPointCodes));
+
+
+            for (int i = 0; i <= between; i++) {
+                HashMap<String, Object> map = new HashMap<>();
+                //开始时间
+                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+                //遍历code数据,拿到每一个code,用code和时间,在meter_info_bottom中拿到dayValue
+                for (String meterPointCode : meterPointCodes) {
+//                    String meterPointCode_ = meterPointCode.replaceAll("\\.", "_");
+                    String meterPointCode_ = meterPointCode
+                            .replaceAll("DL.", "DL_")
+                            .replaceAll("DJL.", "DJL_")
+                            .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                            ;
+                    System.out.println("要查询的点code:" + meterPointCode);
+                    System.out.println("替换后的点code:" + meterPointCode_);
+//
+                    try {
+                        if (meterPointCode.startsWith("DL")) {
+                            System.out.println("计算测点DL:" + meterPointCode);
+                            for (MeterInfoCalculating meterInfoCalculating : list1) {
+                                if (meterInfoCalculating.getCode().equals(meterPointCode) && meterInfoCalculating.getDate().equals(dateTime1.toLocalDateTime())) {
+
+                                    System.out.println("DL点数据:" + meterInfoCalculating.getValue());
+                                    map.put(meterPointCode_, meterInfoCalculating.getValue());
+
+                                }
+                            }
+                        } else {
+                            System.out.println("计算测点Bottom:" + meterPointCode);
+
+                            for (MeterInfoBottomcode meterInfoBottomcode : list2) {
+                                if (meterInfoBottomcode.getCode().equals(meterPointCode) && meterInfoBottomcode.getStartTime().equals(dateTime1.toLocalDateTime())) {
+
+                                    System.out.println("Bottom点数据日电量:" + meterInfoBottomcode.getDayValue());
+                                    map.put(meterPointCode_, meterInfoBottomcode.getDayValue());
+                                }
+                            }
+                        }
+
+                    } catch (Exception e) {
+                        System.out.println("获取数据异常:" + e.getMessage());
+
+                    }
+                }
+                System.out.println("map集合:" + map);
+                try {
+                    BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
+                    System.out.println("公式计算后数据:" + bigDecimal1);
+                    MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                    meterInfoCalculating.setName(meterPoint.getName());
+                    meterInfoCalculating.setCode(meterPoint.getNemCode());
+                    meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                    meterInfoCalculating.setValue(bigDecimal1.divide(BigDecimal.valueOf(10000),4, RoundingMode.HALF_EVEN));
+                    meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                    meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                    List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoCalculating.update(queryWrapper);
+                    } else {
+                        meterInfoCalculating.insert();
+                    }
+
+                } catch (ArithmeticException e) {
+
+                    MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                    meterInfoCalculating.setName(meterPoint.getName());
+                    meterInfoCalculating.setCode(meterPoint.getNemCode());
+                    meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                    meterInfoCalculating.setValue(BigDecimal.valueOf(0));
+                    meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                    meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                    List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoCalculating.update(queryWrapper);
+                    } else {
+                        meterInfoCalculating.insert();
+                    }
+
+                } catch (Exception e) {
+                    System.out.println("存入异常  :" + e.getMessage());
+
+
+                }
+
+            }
+        }
+    }
 }
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveEquipmentFDL.java

@@ -11,8 +11,10 @@ import org.springframework.stereotype.Service;
 import javax.annotation.Resource;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Author: malijun
@@ -35,11 +37,13 @@ public class SaveEquipmentFDL {
     @Resource
     MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
 
-
+    //风机日发电量
     public void saveEquipmentRfdl() {
 
         //1,在testingpoint中根据 uniform_code=AI064 和code like "%_FJ_%" 取出所有风机的电量测点code
-        List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>().eq("uniform_code", "AI064").like("code", "%_FJ_%"));
+        List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>()
+                .eq("uniform_code", "AI064")
+                .like("code", "%_FJ_%"));
 
         //2,遍历list,每次取出一个code
         for (TestingPoint testingPoint : testingPointList) {
@@ -53,19 +57,30 @@ public class SaveEquipmentFDL {
             DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
 
 
-            //开始时间00:00:01
-            //结束时间第二天00:00:01
-            DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
+
+            DateTime dateTime0 = DateUtil.offsetMillisecond(startDateTime, -1);
+//            DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
+            DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, 1), -1);
+
+
+            Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+            double value0 = 0;
+            if (!historySection.isEmpty()) {
+                value0 = historySection.get(pointcode).getValue();
+            }
+            BigDecimal bigDecimal1 = new BigDecimal(Double.toString(value0));
 
             //8,通过适配器拿到一天的发电量数据,
             List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, startDateTime.getTime(), dateTime2.getTime());
 
+
+
             //定义日发电量,先给0
             BigDecimal rfdl = new BigDecimal(0);
 
             //如果适配器拿到数据,计算日发电量
             if (historyRaw.size() > 0) {
-                BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+//                BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
                 BigDecimal bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
                 rfdl = bigDecimal2.subtract(bigDecimal1);
 
@@ -106,6 +121,13 @@ public class SaveEquipmentFDL {
                     }
                 }
             }
+
+            //避免出现过大错误数据,异常数据给死值4444.4444
+            if (rfdl.doubleValue() > 100000 || rfdl.doubleValue() < 0){
+                rfdl= BigDecimal.valueOf(4444.4444);
+            }
+
+
             //9,company_nem_code   (powerstation_nem_code project_nem_code line_nem_code equipment_nem_code )都在basic equipment中叫project_id    name date rfdl 存入meterInfo表中
             Equipment thingId1 = equipmentService.getOne(new QueryWrapper<Equipment>().eq("nem_code", thingId));
 
@@ -132,7 +154,6 @@ public class SaveEquipmentFDL {
         }
     }
 
-
     //项目期次风机总发电量
     public void saveCalculatingFJFDL() {
 
@@ -151,7 +172,10 @@ public class SaveEquipmentFDL {
             //开始时间00:00:01
 
             //根据时间和项目期次ID查询设备日发电量表
-            List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("project_nem_code", projectId).eq("date", startDateTime));
+            List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>()
+                    .eq("project_nem_code", projectId)
+                    .eq("date", startDateTime)
+            );
 
             //遍历累加取出的数据
             BigDecimal bigDecimal = BigDecimal.valueOf(0);
@@ -185,4 +209,374 @@ public class SaveEquipmentFDL {
 
     }
 
+    //光伏日发电量
+    public void saveEquipmentRfdl_GF() {
+
+
+        //1,在testingpoint中根据 uniform_code=AI064 和code like "%_G_IN_%" 取出所有光伏的电量测点code
+        List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>()
+                .eq("uniform_code", "AI064")
+                .like("thing_id", "%_G_IN_%")
+        );
+
+        //2,遍历list,每次取出一个code
+        for (TestingPoint testingPoint : testingPointList) {
+            //获取测点code
+            String pointcode = testingPoint.getCode();
+            //获取设备ID
+            String thingId = testingPoint.getThingId();
+
+            //2,获取当前日期,当日开始时间
+            DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+            DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+
+
+            DateTime dateTime0 = DateUtil.offsetMillisecond(startDateTime, -1);
+//            DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
+            DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, 1), -1);
+
+
+                //8,结束点发电量减去开始点发电量得到日发电量(单位Kwh)
+                Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                double value0 = 0;
+                if (!historySection.isEmpty()) {
+                    value0 = historySection.get(pointcode).getValue();
+                }
+                BigDecimal bigDecimal1 = new BigDecimal(Double.toString(value0));
+
+
+                List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, startDateTime.getTime(), dateTime2.getTime());
+
+                BigDecimal rfdl = new BigDecimal(0);
+
+
+                if (historyRaw.size() > 0) {
+//                    BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                    BigDecimal bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                    rfdl = bigDecimal2.subtract(bigDecimal1);
+
+
+                    if (testingPoint.getStationId().equals("NX_GDDL_PL_GDC_STA")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_040_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_042_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_041_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_043_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_045_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_017_AI0021")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_014_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_018_AI0021")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_019_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_015_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_016_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_011_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_012_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_013_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_020_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (testingPoint.getStationId().equals("NX_GDDL_MCH_GDC_STA")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_035_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_038_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_039_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_033_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_034_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_037_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_040_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_041_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_042_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_036_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (rfdl.doubleValue() > 15000 || rfdl.doubleValue() < 0) {
+
+                        ArrayList<Double> arrayList = new ArrayList<>();
+                        for (PointData pointData : historyRaw) {
+                            arrayList.add(pointData.getValue());
+                        }
+
+                        int index = -1;
+                        for (int j = 1; j < arrayList.size(); j++) {
+                            double current = arrayList.get(j);
+                            double previous = arrayList.get(j - 1);
+                            double difference = current - previous;
+                            if (difference > 15000 || difference < -1) {
+                                index = j;
+                                break;
+                            }
+                        }
+                        if (index != -1) {
+                            double valueGrow2 = arrayList.get(index);
+                            BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                            double valueGrow1 = arrayList.get(index - 1);
+                            BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                            rfdl = (bigDecimal2.subtract(bigDecimalGrow2)).add(bigDecimalGrow1.subtract(bigDecimal1));
+                            if (testingPoint.getStationId().equals("NX_GDDL_PL_GDC_STA")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_040_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_042_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_041_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_043_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_045_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+
+                            if (testingPoint.getStationId().equals("NX_GDDL_MCH_GDC_STA")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_014_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_018_AI0021")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_019_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_015_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_017_AI0021")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_016_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_011_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_012_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_013_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_020_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_035_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_038_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_039_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_033_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_034_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_037_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_040_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_041_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_042_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_036_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                        }
+                    }
+                }
+
+
+                //避免出现过大错误数据,异常数据给死值4444.4444
+                if (rfdl.doubleValue() > 15000 || rfdl.doubleValue() < 0){
+                    rfdl= BigDecimal.valueOf(4444.4444);
+                }
+                //9,company_nem_code   (powerstation_nem_code project_nem_code line_nem_code equipment_nem_code )都在basic equipment中叫project_id    name date rfdl 存入meterInfo表中
+                Equipment thingId1 = equipmentService.getOne(new QueryWrapper<Equipment>().eq("nem_code", thingId));
+
+                MeterInfoEquipment meterInfoEquipment = new MeterInfoEquipment();
+                meterInfoEquipment.setPowerstationNemCode(thingId1.getWindpowerstationId());
+                meterInfoEquipment.setProjectNemCode(thingId1.getProjectId());
+                meterInfoEquipment.setLineNemCode(thingId1.getLineId());
+                meterInfoEquipment.setEquipmentNemCode(thingId1.getNemCode());
+                meterInfoEquipment.setName(thingId1.getName());
+                meterInfoEquipment.setDate(startDateTime.toLocalDateTime());
+                meterInfoEquipment.setRfdl(rfdl);
+                meterInfoEquipment.setUpdateTime(LocalDateTime.now());
+                QueryWrapper<MeterInfoEquipment> queryWrapper = new QueryWrapper<>();
+                queryWrapper.eq("equipment_nem_code", thingId1.getNemCode()).eq("date", startDateTime.toLocalDateTime());
+                List<MeterInfoEquipment> list = meterInfoEquipmentService.list(queryWrapper);
+                if (list.size() > 0) {
+                    meterInfoEquipment.update(queryWrapper);
+                } else {
+                    meterInfoEquipment.insert();
+                }
+
+        }
+    }
+
+    //光伏逆变器日发电量(场站)
+    public void saveCalculatingNBQFDL() {
+        //获取当前日期,当日开始时间
+        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+        //1,所有期次发电量测点
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_NBQFDL"));
+
+        //遍历期次发电量测点,拿到场站id,
+        for (MeterPoint meterPoint : meterPointList) {
+            String projectId = meterPoint.getWindpowerstationId();
+
+                List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>()
+                        .eq("powerstation_nem_code", projectId)
+                        .eq("date", startDateTime));
+                BigDecimal bigDecimal = BigDecimal.valueOf(0);
+                for (MeterInfoEquipment meterInfoEquipment : meterInfoEquipments) {
+                    bigDecimal = bigDecimal.add(meterInfoEquipment.getRfdl());
+                }
+
+                MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                meterInfoCalculating.setName(meterPoint.getName());
+                meterInfoCalculating.setDate(startDateTime.toLocalDateTime());
+                meterInfoCalculating.setValue(bigDecimal.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
+                meterInfoCalculating.setCode(meterPoint.getNemCode());
+                meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                queryWrapper.eq("date", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                if (list.size() > 0) {
+                    meterInfoCalculating.update(queryWrapper);
+                } else {
+                    meterInfoCalculating.insert();
+                }
+
+        }
+    }
+
+
+
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveFDL_Day_Month_Year.java

@@ -36,7 +36,8 @@ public class SaveFDL_Day_Month_Year {
 
     void saveLineFdl_Month() {
 
-        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_LINEFDL_MONTH"));
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_LINEFDL_MONTH"));
         for (MeterPoint meterPoint : meterPointList) {
             System.out.println(meterPoint.getName() + ":" + meterPoint);
 
@@ -348,7 +349,10 @@ public class SaveFDL_Day_Month_Year {
 
     void savePowerstationFdl_Month() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_MONTH"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_MONTH")
+                .like("windpowerstation_id", "FDC")
+        );
 //        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_NFDL"));
 
         //设置取值开始时间
@@ -401,7 +405,10 @@ public class SaveFDL_Day_Month_Year {
 
     void savePowerstationFdl_Year() {
 
-        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_YEAR"));
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_YEAR")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = DateUtil.now();
@@ -606,6 +613,290 @@ public class SaveFDL_Day_Month_Year {
     }
 
 
+    //光伏
+    void savePowerstationFdl_GF_Month() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_MONTH")
+                .like("windpowerstation_id", "_GDC_")
+        );
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                MeterInfoCalculating meterInfoCalculatingDay = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "_GFJDXLFDL_PO"));
+
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoCalculatingDay != null) {
+                    monthValue = monthValue + meterInfoCalculatingDay.getValue().doubleValue();
+                }
+            }
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+    }
+
+    void savePowerstationFdl_GF_Year() {
+
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_POWERSTATIONFDL_YEAR")
+                .like("windpowerstation_id", "_GDC_")
+        );
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_NFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double yearValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%_POWERSTATIONFDL_MONTH"));
+
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoCalculating != null) {
+                    yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+        }
+    }
+
+    void saveGFFdl_GF_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFFDL_DAY"));
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+        double monthValue = 0.0;
+        //开始时间00:00:00
+
+        //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+        List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", startDateTime.toLocalDateTime())
+                .like("code", "%_GFJDXLFDL_PO"));
+        //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+        if (meterInfoCalculatingDay.size() > 0) {
+            for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(startDateTime.toLocalDateTime());
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", startDateTime.toLocalDateTime());
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+
+    }
+
+    void saveGFFdl_GF_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFFDL_MONTH"));
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+
+
+        DateTime dateTime1 = DateTime.of(0);
+        double monthValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "_POWERSTATIONFDL_MONTH")
+                    .like("windpowerstation_id", "_GDC_")
+
+            );
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+        }
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+    void saveGFFdl_GF_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFFDL_YEAR"));
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+
+        DateTime dateTime1 = DateTime.of(0);
+        double yearValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:01
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路期次)
+            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .eq("code", "DL.NX_GD_GFFDL_MONTH")
+                    .like("windpowerstation_id", "_GDC_")
+            );
+
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculating != null) {
+                yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+
+
     public void sum() {
         this.saveLineFdl_Month();
         this.saveLineFdl_Year();
@@ -623,5 +914,19 @@ public class SaveFDL_Day_Month_Year {
 
     }
 
+    public void sum_GF() {
+
+
+        this.savePowerstationFdl_GF_Month();
+        this.savePowerstationFdl_GF_Year();
+
+
+        this.saveGFFdl_GF_Day();
+        this.saveGFFdl_GF_Month();
+        this.saveGFFdl_GF_Year();
+
+
+    }
+
 
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveLineFDL_15Min.java

@@ -0,0 +1,245 @@
+package com.gyee.gaia.meter.service.meter;
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.gaia.meter.adapter.Adapter;
+import com.gyee.gaia.meter.entity.MeterPoint;
+import com.gyee.gaia.meter.entity.PointData;
+import com.gyee.gaia.meter.entity.PowerStation;
+import com.gyee.gaia.meter.entity.ProMeterLineFDL15Min;
+import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
+import com.gyee.gaia.meter.service.impl.PowerStationServiceImpl;
+import com.gyee.gaia.meter.service.impl.ProMeterLineFDL15MinServiceImpl;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 05: 09
+ **/
+
+@Component
+public class SaveLineFDL_15Min {
+
+    @Resource
+    PowerStationServiceImpl powerStationService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    ProMeterLineFDL15MinServiceImpl proMeterLineFDL15MinService;
+    @Resource
+    Adapter adapter;
+
+
+
+
+
+    public void saveLineFDL_15Min() {
+
+        //1,查询所有风电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+            //2,根据场站ID得到场站下所有测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            //3,遍历测点,拿到每个测点的nem_code
+            for (MeterPoint meterPoint : meterPointList) {
+                //获取测点code
+                String pointcode = meterPoint.getNemCode();
+
+                DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+
+                //设置取值开始时间
+                DateTime startDateTime = DateUtil.beginOfHour(nowDateTime);
+
+
+                for (int i = 0; i <= 3; i++) {
+
+                    //开始时间00:00:01
+                    DateTime dateTime1 = DateUtil.offsetMinute(startDateTime, (i-1)*15);
+                    DateTime dateTime2 = DateUtil.offsetMinute(startDateTime, i*15);
+                    BigDecimal bigDecimal1 = new BigDecimal(0);
+                    BigDecimal bigDecimal2 = new BigDecimal(0);
+                    BigDecimal rfdl = new BigDecimal(0);
+
+
+                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                    if (historyRaw.size() > 0) {
+                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                        bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                        bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                        if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
+
+                            ArrayList<Double> arrayList = new ArrayList<>();
+                            for (PointData pointData : historyRaw) {
+                                arrayList.add(pointData.getValue());
+                            }
+                            int index = -1;
+                            // 定义增长阈值
+                            double threshold = 50000.0;
+
+                            for (int j = 1; j < arrayList.size(); j++) {
+                                double current = arrayList.get(j);
+                                double previous = arrayList.get(j - 1);
+                                double difference = current - previous;
+                                if (difference > threshold) {
+                                    index = j;
+                                    break;
+                                }
+                            }
+                            if (index != -1) {
+                                double valueGrow2 = arrayList.get(index);
+                                BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                double valueGrow1 = arrayList.get(index - 1);
+                                BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                            }
+                        }
+                    }
+
+                    ProMeterLineFDL15Min meterInfoBottomcode = new ProMeterLineFDL15Min();
+                    meterInfoBottomcode.setName(meterPoint.getDescription());
+                    meterInfoBottomcode.setStartTime(dateTime1.toLocalDateTime());
+                    meterInfoBottomcode.setStartValue(bigDecimal1);
+                    meterInfoBottomcode.setEndTime(dateTime2.toLocalDateTime());
+                    meterInfoBottomcode.setEndValue(bigDecimal2);
+                    meterInfoBottomcode.setDayValue(rfdl);
+                    meterInfoBottomcode.setCode(pointcode);
+                    meterInfoBottomcode.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<ProMeterLineFDL15Min> queryWrapper = new QueryWrapper<>();
+                    queryWrapper
+                            .eq("start_time", dateTime1.toLocalDateTime())
+                            .eq("code", meterPoint.getNemCode());
+                    List<ProMeterLineFDL15Min> list = proMeterLineFDL15MinService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoBottomcode.update(queryWrapper);
+                    } else {
+                        meterInfoBottomcode.insert();
+                    }
+                }
+            }
+        }
+    }
+
+    public void saveLineFDL_15Min0() {
+
+        //1,查询所有风电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+            //2,根据场站ID得到场站下所有测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            //3,遍历测点,拿到每个测点的nem_code
+            for (MeterPoint meterPoint : meterPointList) {
+                //获取测点code
+                String pointcode = meterPoint.getNemCode();
+
+                //2,获取当前日期,当日开始时间
+                DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+
+                //开始时间00:00:01
+                DateTime dateTime1 = DateUtil.offsetMinute(nowDateTime, -15);
+                DateTime dateTime2 = DateUtil.offsetMinute(nowDateTime, 0);
+                BigDecimal bigDecimal1 = new BigDecimal(0);
+                BigDecimal bigDecimal2 = new BigDecimal(0);
+                BigDecimal rfdl = new BigDecimal(0);
+
+
+
+
+                List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                if (historyRaw.size() > 0) {
+                    bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                    bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                    bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                    bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                    rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                    if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
+
+                        ArrayList<Double> arrayList = new ArrayList<>();
+                        for (PointData pointData : historyRaw) {
+                            arrayList.add(pointData.getValue());
+                        }
+                        int index = -1;
+                        // 定义增长阈值
+                        double threshold = 50000.0;
+
+                        for (int j = 1; j < arrayList.size(); j++) {
+                            double current = arrayList.get(j);
+                            double previous = arrayList.get(j - 1);
+                            double difference = current - previous;
+                            if (difference > threshold) {
+                                index = j;
+                                break;
+                            }
+                        }
+                        if (index != -1) {
+                            double valueGrow2 = arrayList.get(index);
+                            BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                            double valueGrow1 = arrayList.get(index - 1);
+                            BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                            rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                        }
+                    }
+                }
+
+                ProMeterLineFDL15Min meterInfoBottomcode = new ProMeterLineFDL15Min();
+                meterInfoBottomcode.setName(meterPoint.getDescription());
+                meterInfoBottomcode.setStartTime(dateTime1.toLocalDateTime());
+                meterInfoBottomcode.setStartValue(bigDecimal1);
+                meterInfoBottomcode.setEndTime(dateTime2.toLocalDateTime());
+                meterInfoBottomcode.setEndValue(bigDecimal2);
+                meterInfoBottomcode.setDayValue(rfdl);
+                meterInfoBottomcode.setCode(pointcode);
+                meterInfoBottomcode.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                QueryWrapper<ProMeterLineFDL15Min> queryWrapper = new QueryWrapper<>();
+                queryWrapper
+                        .eq("start_time", dateTime1.toLocalDateTime())
+                        .eq("code", meterPoint.getNemCode());
+                List<ProMeterLineFDL15Min> list = proMeterLineFDL15MinService.list(queryWrapper);
+                if (list.size() > 0) {
+                    meterInfoBottomcode.update(queryWrapper);
+                } else {
+                    meterInfoBottomcode.insert();
+                }
+
+            }
+        }
+    }
+
+
+
+
+
+}
+
+
+

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveMeterInfoYesterday.java

@@ -16,10 +16,7 @@ import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 
 /**
  * Author: malijun
@@ -49,7 +46,6 @@ class SaveMeterInfoYesterday {
 
 
     //风机日发电量
-
     void saveEquipmentRfdl() {
 
 
@@ -78,8 +74,18 @@ class SaveMeterInfoYesterday {
 
             for (int i = 0; i <= between; i++) {
 
+                DateTime dateTime0 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i), -1);
                 DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
-                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+                DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i+1), -1);
+
+
+                Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                double value0 = 0;
+                if (!historySection.isEmpty()) {
+                    value0 = historySection.get(pointcode).getValue();
+                }
+                BigDecimal bigDecimal1 = new BigDecimal(Double.toString(value0));
 
                 //8,结束点发电量减去开始点发电量得到日发电量(单位Kwh)
                 List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
@@ -87,7 +93,7 @@ class SaveMeterInfoYesterday {
                 BigDecimal rfdl = new BigDecimal(0);
 
                 if (historyRaw.size() > 0) {
-                    BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+//                    BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
                     BigDecimal bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
                     rfdl = bigDecimal2.subtract(bigDecimal1);
 
@@ -117,6 +123,13 @@ class SaveMeterInfoYesterday {
                         }
                     }
                 }
+
+                //避免出现过大错误数据,异常数据给死值4444.4444
+                if (rfdl.doubleValue() > 100000 || rfdl.doubleValue() < 0){
+                    rfdl= BigDecimal.valueOf(4444.4444);
+                }
+
+
                 //9,company_nem_code   (powerstation_nem_code project_nem_code line_nem_code equipment_nem_code )都在basic equipment中叫project_id    name date rfdl 存入meterInfo表中
                 Equipment thingId1 = equipmentService.getOne(new QueryWrapper<Equipment>().eq("nem_code", thingId));
 
@@ -141,8 +154,7 @@ class SaveMeterInfoYesterday {
         }
     }
 
-    //电计量底码表
-
+    //项目期次风机总发电量
     void saveCalculatingProjectFDL() {
 
 
@@ -196,7 +208,7 @@ class SaveMeterInfoYesterday {
         }
     }
 
-
+    //风电电计量底码表
     void saveBottomCode() {
 
         //1,查询所有风电场
@@ -228,18 +240,31 @@ class SaveMeterInfoYesterday {
 
                 for (int i = 0; i <= between; i++) {
 
+                    DateTime dateTime0 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i), -1);
+
                     //开始时间00:00:01
                     DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
                     //结束时间第二天00:00:01
-                    DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+//                    DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+                    DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i+1), -1);
+
 
-                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
                     BigDecimal bigDecimal1 = new BigDecimal(0);
                     BigDecimal bigDecimal2 = new BigDecimal(0);
                     BigDecimal rfdl = new BigDecimal(0);
 
+                    Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                    double value0 = 0;
+                    if (!historySection.isEmpty()) {
+                        value0 = historySection.get(pointcode).getValue();
+                         bigDecimal1 = new BigDecimal(Double.toString(value0));
+                    }
+
+                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+
                     if (historyRaw.size() > 0) {
-                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+//                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
                         bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
                         bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
                         bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
@@ -296,10 +321,8 @@ class SaveMeterInfoYesterday {
             }
         }
     }
-    //项目期次风机总发电量
-
-    //有公式的计算电量
 
+    //风电有公式的计算电量
     void saveCalculating() {
 
         //设置取值开始时间
@@ -399,9 +422,11 @@ class SaveMeterInfoYesterday {
         }
     }
 
-    //调用上面4个,第四个需要3-4次
 
-    public void saveMeterInfoYesterday() {
+
+
+    //调用上面4个,第四个需要3-4次
+    public void saveMeterInfoYesterday_FD() {
         this.saveEquipmentRfdl();
         this.saveBottomCode();
         this.saveCalculatingProjectFDL();
@@ -413,6 +438,706 @@ class SaveMeterInfoYesterday {
     }
 
 
+
+    //光伏日发电量
+    void saveEquipmentRfdl_GF() {
+
+
+        //1,在testingpoint中根据 uniform_code=AI064 和code like "%_G_IN_%" 取出所有光伏的电量测点code
+        List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>()
+                .eq("uniform_code", "AI064")
+                .like("thing_id", "%_G_IN_%")
+        );
+
+        //2,遍历list,每次取出一个code
+        for (TestingPoint testingPoint : testingPointList) {
+            //获取测点code
+            String pointcode = testingPoint.getCode();
+            //获取设备ID
+            String thingId = testingPoint.getThingId();
+
+            //设置取值开始时间
+            DateTime now = DateTime.now();
+            DateTime startDay = DateUtil.offsetDay(now, -1);
+            DateTime startDateTime = DateUtil.beginOfDay(startDay);
+            //设置取值结束时间
+            DateTime endDay = DateUtil.offsetDay(now, -1);
+            DateTime endDateTime = DateUtil.endOfDay(endDay);
+
+            //指定开始日期到结束日期的天数
+            LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+            LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+            long between = ChronoUnit.DAYS.between(day1, day2);
+
+            for (int i = 0; i <= between; i++) {
+
+                DateTime dateTime0 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i), -1);
+                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+                DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i + 1), -1);
+
+                //8,结束点发电量减去开始点发电量得到日发电量(单位Kwh)
+                Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                double value0 = 0;
+                if (!historySection.isEmpty()) {
+                    value0 = historySection.get(pointcode).getValue();
+                }
+                BigDecimal bigDecimal1 = new BigDecimal(Double.toString(value0));
+
+
+                List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                BigDecimal rfdl = new BigDecimal(0);
+
+
+                if (historyRaw.size() > 0) {
+//                    BigDecimal bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                    BigDecimal bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                    rfdl = bigDecimal2.subtract(bigDecimal1);
+
+
+                    if (testingPoint.getStationId().equals("NX_GDDL_PL_GDC_STA")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_040_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_042_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_041_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_043_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_045_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_017_AI0021")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_014_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_018_AI0021")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_019_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_015_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_016_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_011_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_012_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_013_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_020_AI0021")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (testingPoint.getStationId().equals("NX_GDDL_MCH_GDC_STA")) {
+                        rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                    }
+
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_035_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_038_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_039_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_033_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_034_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_037_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_040_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_041_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_042_AI0005")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+                    if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_036_AI0055")) {
+                        rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                    }
+
+
+                    if (rfdl.doubleValue() > 15000 || rfdl.doubleValue() < 0) {
+
+                        ArrayList<Double> arrayList = new ArrayList<>();
+                        for (PointData pointData : historyRaw) {
+                            arrayList.add(pointData.getValue());
+                        }
+
+                        int index = -1;
+                        for (int j = 1; j < arrayList.size(); j++) {
+                            double current = arrayList.get(j);
+                            double previous = arrayList.get(j - 1);
+                            double difference = current - previous;
+                            if (difference > 15000 || difference < -1) {
+                                index = j;
+                                break;
+                            }
+                        }
+                        if (index != -1) {
+                            double valueGrow2 = arrayList.get(index);
+                            BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                            double valueGrow1 = arrayList.get(index - 1);
+                            BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                            rfdl = (bigDecimal2.subtract(bigDecimalGrow2)).add(bigDecimalGrow1.subtract(bigDecimal1));
+                            if (testingPoint.getStationId().equals("NX_GDDL_PL_GDC_STA")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_040_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_042_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_041_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_043_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("PLGF.NX_GD_PLG_GF_P2_L2_045_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_EVEN);
+                            }
+
+
+                            if (testingPoint.getStationId().equals("NX_GDDL_MCH_GDC_STA")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_014_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_018_AI0021")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_019_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_015_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_017_AI0021")) {
+                                rfdl = rfdl.multiply(BigDecimal.valueOf(1000));
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_016_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_011_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_012_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_013_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("DWKGF.NX_GD_DWKG_GF_P1_L2_020_AI0021")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_035_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_038_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_039_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_033_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_034_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_037_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_040_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_041_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_042_AI0005")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                            if (testingPoint.getCode().equals("XHGF.NX_GD_XHG_GF_P1_L4_036_AI0055")) {
+                                rfdl = rfdl.divide(BigDecimal.valueOf(10), 2, RoundingMode.HALF_EVEN);
+                            }
+
+                        }
+                    }
+                }
+
+
+                //避免出现过大错误数据,异常数据给死值4444.4444
+                if (rfdl.doubleValue() > 15000 || rfdl.doubleValue() < 0){
+                    rfdl= BigDecimal.valueOf(4444.4444);
+                }
+                //9,company_nem_code   (powerstation_nem_code project_nem_code line_nem_code equipment_nem_code )都在basic equipment中叫project_id    name date rfdl 存入meterInfo表中
+                Equipment thingId1 = equipmentService.getOne(new QueryWrapper<Equipment>().eq("nem_code", thingId));
+
+                MeterInfoEquipment meterInfoEquipment = new MeterInfoEquipment();
+                meterInfoEquipment.setPowerstationNemCode(thingId1.getWindpowerstationId());
+                meterInfoEquipment.setProjectNemCode(thingId1.getProjectId());
+                meterInfoEquipment.setLineNemCode(thingId1.getLineId());
+                meterInfoEquipment.setEquipmentNemCode(thingId1.getNemCode());
+                meterInfoEquipment.setName(thingId1.getName());
+                meterInfoEquipment.setDate(dateTime1.toLocalDateTime());
+                meterInfoEquipment.setRfdl(rfdl);
+                meterInfoEquipment.setUpdateTime(LocalDateTime.now());
+                QueryWrapper<MeterInfoEquipment> queryWrapper = new QueryWrapper<>();
+                queryWrapper.eq("equipment_nem_code", thingId1.getNemCode()).eq("date", dateTime1.toLocalDateTime());
+                List<MeterInfoEquipment> list = meterInfoEquipmentService.list(queryWrapper);
+                if (list.size() > 0) {
+                    meterInfoEquipment.update(queryWrapper);
+                } else {
+                    meterInfoEquipment.insert();
+                }
+            }
+        }
+    }
+
+    //光伏逆变器日发电量(场站)
+    void saveCalculatingNBQFDL() {
+
+
+        //设置取值开始时间
+        DateTime now = DateTime.now();
+        DateTime startDay = DateUtil.offsetDay(now, -1);
+        DateTime startDateTime = DateUtil.beginOfDay(startDay);
+        //设置取值结束时间
+        DateTime endDay = DateUtil.offsetDay(now, -1);
+        DateTime endDateTime = DateUtil.endOfDay(endDay);
+
+        //指定开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+
+        //1,所有期次发电量测点
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_NBQFDL"));
+
+        //遍历期次发电量测点,拿到场站id,
+        for (MeterPoint meterPoint : meterPointList) {
+            String projectId = meterPoint.getWindpowerstationId();
+
+            for (int i = 0; i <= between; i++) {
+                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("powerstation_nem_code", projectId).eq("date", dateTime1));
+                BigDecimal bigDecimal = BigDecimal.valueOf(0);
+                for (MeterInfoEquipment meterInfoEquipment : meterInfoEquipments) {
+                    bigDecimal = bigDecimal.add(meterInfoEquipment.getRfdl());
+                }
+
+                MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                meterInfoCalculating.setName(meterPoint.getName());
+                meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                meterInfoCalculating.setValue(bigDecimal.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
+                meterInfoCalculating.setCode(meterPoint.getNemCode());
+                meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                if (list.size() > 0) {
+                    meterInfoCalculating.update(queryWrapper);
+                } else {
+                    meterInfoCalculating.insert();
+                }
+            }
+        }
+    }
+
+    //光伏底码数据
+    void saveBottomCode_GF() {
+
+        //1,查询所有光电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_GDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+
+            //2,根据场站ID得到场站下所有测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+            );
+
+            if (meterPointList.size() > 0) {
+
+                //3,遍历测点,拿到每个测点的nem_code
+                for (MeterPoint meterPoint : meterPointList) {
+                    System.out.println(meterPoint);
+                    //获取测点code
+                    String pointcode = meterPoint.getNemCode();
+
+                    //设置取值开始时间
+                    DateTime now = DateTime.now();
+                    DateTime startDay = DateUtil.offsetDay(now, -1);
+                    DateTime startDateTime = DateUtil.beginOfDay(startDay);
+                    //设置取值结束时间
+                    DateTime endDay = DateUtil.offsetDay(now, -1);
+                    DateTime endDateTime = DateUtil.endOfDay(endDay);
+
+                    //指定开始日期到结束日期的天数
+                    LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+                    LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+                    long between = ChronoUnit.DAYS.between(day1, day2);
+
+                    for (int i = 0; i <= between; i++) {
+
+                        //开始时间,前一天最后
+                        DateTime dateTime0 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i), -1);
+
+                        DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+                        //结束时间,当天最后
+                        DateTime dateTime2 = DateUtil.offsetMillisecond(DateUtil.offsetDay(startDateTime, i + 1), -1);
+
+                        BigDecimal bigDecimal1 = new BigDecimal(0);
+                        BigDecimal bigDecimal2 = new BigDecimal(0);
+                        BigDecimal rfdl = new BigDecimal(0);
+
+                        Map<String, PointData> historySection = adapter.getHistorySection(pointcode, dateTime0.getTime());
+                        double value0 = 0;
+                        if (!historySection.isEmpty()) {
+                            value0 = historySection.get(pointcode).getValue();
+                        }
+                        bigDecimal1 = new BigDecimal(Double.toString(value0));
+
+                        List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                        if (historyRaw.size() > 0) {
+//                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                            bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                            bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                            bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                            rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                            if (rfdl.doubleValue() > 1000000 || rfdl.doubleValue() < 0) {
+
+                                ArrayList<Double> arrayList = new ArrayList<>();
+                                for (PointData pointData : historyRaw) {
+                                    arrayList.add(pointData.getValue());
+                                }
+                                int index = -1;
+                                // 定义增长阈值
+                                double threshold = 15000.0;
+
+                                for (int j = 1; j < arrayList.size(); j++) {
+                                    double current = arrayList.get(j);
+                                    double previous = arrayList.get(j - 1);
+                                    double difference = current - previous;
+                                    if (difference > threshold) {
+                                        index = j;
+                                        break;
+                                    }
+                                }
+                                if (index != -1) {
+                                    double valueGrow2 = arrayList.get(index);
+                                    BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                    double valueGrow1 = arrayList.get(index - 1);
+                                    BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                    rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                                }
+                            }
+                        }
+
+                        MeterInfoBottomcode meterInfoBottomcode = new MeterInfoBottomcode();
+                        meterInfoBottomcode.setName(meterPoint.getName());
+                        meterInfoBottomcode.setStartTime(dateTime1.toLocalDateTime());
+                        meterInfoBottomcode.setStartValue(bigDecimal1);
+                        meterInfoBottomcode.setEndTime(dateTime2.toLocalDateTime());
+                        meterInfoBottomcode.setEndValue(bigDecimal2);
+                        meterInfoBottomcode.setDayValue(rfdl);
+                        meterInfoBottomcode.setCode(pointcode);
+                        meterInfoBottomcode.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                        QueryWrapper<MeterInfoBottomcode> queryWrapper = new QueryWrapper<>();
+                        queryWrapper.eq("start_time", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                        List<MeterInfoBottomcode> list = meterInfoBottomcodeService.list(queryWrapper);
+                        if (list.size() > 0) {
+                            meterInfoBottomcode.update(queryWrapper);
+                        } else {
+                            meterInfoBottomcode.insert();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    //有公式的计算光伏电量
+    void saveCalculating_GF() {
+
+        //设置取值开始时间
+        DateTime now = DateTime.now();
+        DateTime startDay = DateUtil.offsetDay(now, -1);
+        DateTime startDateTime = DateUtil.beginOfDay(startDay);
+        //设置取值结束时间
+        DateTime endDay = DateUtil.offsetDay(now, -1);
+        DateTime endDateTime = DateUtil.endOfDay(endDay);
+
+        //指定开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between = ChronoUnit.DAYS.between(day1, day2);
+
+        List<MeterPoint> meterPointJSDList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_GF")
+                .ne("formula", ""));
+
+
+        //时间集合,以便后面批量查询
+        List<DateTime> dateTimes = new ArrayList<>();
+        for (int i = 0; i <= between; i++) {
+            DateTime dateTime4 = DateUtil.offsetDay(startDateTime, i);
+            dateTimes.add(dateTime4);
+        }
+        //code集合,以便后面批量查询
+        List<String> codes = new ArrayList<>();
+        for (MeterPoint meterPoint : meterPointJSDList) {
+            String formula1 = meterPoint.getFormula();
+            System.out.println("转换前的公式:" + formula1);
+            String formula2 = formula1
+                    .replaceAll("DL.NX", "DL_NX")
+                    .replaceAll("DJL.", "DJL_")
+                    .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                    ;
+            System.out.println("转换后的公式字符串:" + formula2);
+
+
+            String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
+            meterPointCodes = Arrays.stream(meterPointCodes)
+                    .filter(meterPointCode -> !(meterPointCode.length() < 8))
+                    .toArray(String[]::new);
+            System.out.println("过滤后公式中的测点数:" + meterPointCodes.length);
+            System.out.println(Arrays.toString(meterPointCodes));
+            codes.addAll(Arrays.asList(meterPointCodes));
+        }
+
+        //批量查询
+        List<MeterInfoCalculating> list1 = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                .in("code", codes)
+                .in("date", dateTimes)
+        );
+        List<MeterInfoBottomcode> list2 = meterInfoBottomcodeService.list(new QueryWrapper<MeterInfoBottomcode>()
+                .in("code", codes)
+                .in("start_time", dateTimes));
+
+
+        for (MeterPoint meterPoint : meterPointJSDList) {
+            String formula1 = meterPoint.getFormula();
+            System.out.println("转换前的公式:" + formula1);
+            String formula2 = formula1
+                    .replaceAll("DL.NX", "DL_NX")
+                    .replaceAll("DJL.", "DJL_")
+                    .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                    ;
+            System.out.println("转换后的公式字符串:" + formula2);
+
+
+            String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
+            meterPointCodes = Arrays.stream(meterPointCodes)
+                    .filter(meterPointCode -> !(meterPointCode.length() < 8))
+                    .toArray(String[]::new);
+            System.out.println("过滤后公式中的测点数:" + meterPointCodes.length);
+            System.out.println(Arrays.toString(meterPointCodes));
+
+
+            for (int i = 0; i <= between; i++) {
+                HashMap<String, Object> map = new HashMap<>();
+                //开始时间
+                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+//                DateTime dateTime2 = DateUtil.offsetDay(startDateTime, i + 1);
+                //遍历code数据,拿到每一个code,用code和时间,在meter_info_bottom中拿到dayValue
+                for (String meterPointCode : meterPointCodes) {
+//                    String meterPointCode_ = meterPointCode.replaceAll("\\.", "_");
+                    String meterPointCode_ = meterPointCode
+                            .replaceAll("DL.", "DL_")
+                            .replaceAll("DJL.", "DJL_")
+                            .replaceAll("PLSJ1.NX", "PLSJ1_NX")
+                            ;
+                    System.out.println("要查询的点code:" + meterPointCode);
+                    System.out.println("替换后的点code:" + meterPointCode_);
+//
+                    try {
+                        if (meterPointCode.startsWith("DL")) {
+                            System.out.println("计算测点DL:" + meterPointCode);
+                            for (MeterInfoCalculating meterInfoCalculating : list1) {
+                                if (meterInfoCalculating.getCode().equals(meterPointCode) && meterInfoCalculating.getDate().equals(dateTime1.toLocalDateTime())) {
+
+                                    System.out.println("DL点数据:" + meterInfoCalculating.getValue());
+                                    map.put(meterPointCode_, meterInfoCalculating.getValue());
+
+                                }
+                            }
+                        } else {
+                            System.out.println("计算测点Bottom:" + meterPointCode);
+
+                            for (MeterInfoBottomcode meterInfoBottomcode : list2) {
+                                if (meterInfoBottomcode.getCode().equals(meterPointCode) && meterInfoBottomcode.getStartTime().equals(dateTime1.toLocalDateTime())) {
+
+                                    System.out.println("Bottom点数据日电量:" + meterInfoBottomcode.getDayValue());
+                                    map.put(meterPointCode_, meterInfoBottomcode.getDayValue());
+                                }
+                            }
+                        }
+
+                    } catch (Exception e) {
+                        System.out.println("获取数据异常:" + e.getMessage());
+
+                    }
+                }
+                System.out.println("map集合:" + map);
+                try {
+                    BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
+                    System.out.println("公式计算后数据:" + bigDecimal1);
+                    MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                    meterInfoCalculating.setName(meterPoint.getName());
+                    meterInfoCalculating.setCode(meterPoint.getNemCode());
+                    meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                    meterInfoCalculating.setValue(bigDecimal1.divide(BigDecimal.valueOf(10000),4,RoundingMode.HALF_EVEN));
+                    meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                    meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                    List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoCalculating.update(queryWrapper);
+                    } else {
+                        meterInfoCalculating.insert();
+                    }
+
+                } catch (ArithmeticException e) {
+
+                    MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                    meterInfoCalculating.setName(meterPoint.getName());
+                    meterInfoCalculating.setCode(meterPoint.getNemCode());
+                    meterInfoCalculating.setDate(dateTime1.toLocalDateTime());
+                    meterInfoCalculating.setValue(BigDecimal.valueOf(0));
+                    meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+                    meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+                    QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+                    List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+                    if (list.size() > 0) {
+                        meterInfoCalculating.update(queryWrapper);
+                    } else {
+                        meterInfoCalculating.insert();
+                    }
+
+                } catch (Exception e) {
+                    System.out.println("存入异常  :" + e.getMessage());
+
+
+                }
+
+            }
+        }
+    }
+
+
+    //调用上面4个,第四个需要3-4次
+    public void saveMeterInfoYesterday_GF() {
+        this.saveEquipmentRfdl_GF();
+        this.saveCalculatingNBQFDL();
+        this.saveBottomCode_GF();
+        this.saveCalculating_GF();
+    }
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meter/SaveSWDL_Day_Month_Year.java

@@ -210,7 +210,10 @@ public class SaveSWDL_Day_Month_Year {
 
     void savePowerstationSwdl_Month() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_MONTH"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_MONTH")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = DateUtil.now();
@@ -229,7 +232,7 @@ public class SaveSWDL_Day_Month_Year {
             double monthValue = 0.0;
             for (int i = 0; i <= between; i++) {
                 //开始时间00:00:01
-                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
 
                 //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
                 List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("windpowerstation_id", meterPoint.getWindpowerstationId()).eq("date", dateTime1.toLocalDateTime()).like("code", "%SWDL_SBS%_MONTH"));
@@ -267,7 +270,10 @@ public class SaveSWDL_Day_Month_Year {
 
     void savePowerstationSwdl_Year() {
 
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_YEAR"));
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_YEAR")
+                .like("windpowerstation_id", "FDC")
+        );
 
         //设置取值开始时间
         String startString = DateUtil.now();
@@ -286,7 +292,7 @@ public class SaveSWDL_Day_Month_Year {
             double monthValue = 0.0;
             for (int i = 0; i <= between; i++) {
                 //开始时间00:00:01
-                dateTime1 = DateUtil.offsetDay(startDateTime, i);
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i*12);
 
                 //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
                 List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("windpowerstation_id", meterPoint.getWindpowerstationId()).eq("date", dateTime1.toLocalDateTime()).like("code", "%SWDL_SBS%_YEAR"));
@@ -326,7 +332,6 @@ public class SaveSWDL_Day_Month_Year {
 
         MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCSWDL_DAY"));
         //设置取值开始时间
-        //设置取值开始时间
         String startString = DateUtil.now();
         DateTime nowDateTime = DateUtil.parse(startString);
         DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
@@ -337,7 +342,9 @@ public class SaveSWDL_Day_Month_Year {
             //开始时间00:00:00
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
-            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("date", startDateTime.toLocalDateTime()).like("code", "%_SWDL_P0"));
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", startDateTime.toLocalDateTime())
+                    .like("code", "%_SWDL_P0"));
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculatingDay.size() > 0) {
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
@@ -393,7 +400,10 @@ public class SaveSWDL_Day_Month_Year {
             dateTime1 = DateUtil.offsetMonth(startDateTime, i);
 
             //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
-            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>().eq("date", dateTime1.toLocalDateTime()).like("code", "%_SWDL_MONTH"));
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("windpowerstation_id", "_FDC_")
+                    .like("code", "%_SWDL_MONTH"));
             //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
             if (meterInfoCalculatingDay.size() > 0) {
                 for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
@@ -478,6 +488,301 @@ public class SaveSWDL_Day_Month_Year {
     }
 
 
+
+
+    //光伏
+    void savePowerstationSwdl_GF_Month() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_MONTH")
+                .like("windpowerstation_id", "_GDC_")
+        );
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(DateUtil.parse(startString));
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%_GFSWDL_PO"));
+
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+
+            }
+
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+        }
+
+    }
+
+    void savePowerstationSwdl_GF_Year() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("property", "JSD_SWDL_YEAR")
+                .like("windpowerstation_id", "_GDC_")
+        );
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.YEARS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_YFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+            for (int i = 0; i <= between; i++) {
+                //开始时间00:00:01
+                dateTime1 = DateUtil.offsetMonth(startDateTime, i*12);
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路总发电量)
+                List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                        .eq("windpowerstation_id", meterPoint.getWindpowerstationId())
+                        .eq("date", dateTime1.toLocalDateTime())
+                        .like("code", "%POWERSTATIONSWDL_MONTH"));
+
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+
+            }
+
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPoint.getName());
+            meterInfoCalculating.setCode(meterPoint.getNemCode());
+            //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+            meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+            meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPoint.getNemCode())
+                    .eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0))
+                    .eq("windpowerstation_id", meterPoint.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+        }
+
+    }
+
+    void saveGFStationSwdl_GF_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFSWDL_DAY"));
+        //设置取值开始时间
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+        double monthValue = 0.0;
+
+
+        //开始时间00:00:00
+
+        //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+        List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                .eq("date", startDateTime.toLocalDateTime())
+                .like("code", "%_GFSWDL_PO"));
+        //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+        if (meterInfoCalculatingDay.size() > 0) {
+            for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(startDateTime.toLocalDateTime());
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", startDateTime.toLocalDateTime());
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+    void saveGFStationSwdl_GF_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFSWDL_MONTH"));
+        //设置取值开始时间
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfMonth(DateUtil.parse(startString));
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+
+
+        DateTime dateTime1 = DateTime.of(0);
+        double monthValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:00
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            List<MeterInfoCalculating> meterInfoCalculatingDay = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .like("code", "%POWERSTATIONSWDL_MONTH"));
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculatingDay.size() > 0) {
+                for (MeterInfoCalculating meterInfoCalculating : meterInfoCalculatingDay) {
+                    monthValue = monthValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+        }
+
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(monthValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("code", meterPoint.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+    void saveGFStationSwdl_GF_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_GFSWDL_YEAR"));
+
+        //设置取值开始时间
+        String startString = DateUtil.now();
+        DateTime nowDateTime = DateUtil.parse(startString);
+        DateTime startDateTime = DateUtil.beginOfYear(nowDateTime);
+
+        //开始日期到结束日期的天数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        System.out.println(between);
+
+        //2,meterPointJSD_YFDLList
+
+        DateTime dateTime1 = DateTime.of(0);
+        double yearValue = 0.0;
+
+
+        for (int i = 0; i <= between; i++) {
+            //开始时间00:00:01
+            dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路期次)
+            MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>()
+                    .eq("date", dateTime1.toLocalDateTime())
+                    .eq("code", "DL.NX_GD_GFSWDL_MONTH"));
+
+            //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+            if (meterInfoCalculating != null) {
+                yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+            }
+        }
+
+        // 将每个场站的每个月的value值存入到MeterInfoCalculating
+        MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+        meterInfoCalculating.setName(meterPoint.getName());
+        meterInfoCalculating.setCode(meterPoint.getNemCode());
+        //LocalDateTime只显示年月(实际为每月的1号00:00:00)
+        meterInfoCalculating.setDate(dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        meterInfoCalculating.setValue(BigDecimal.valueOf(yearValue));
+        meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+
+        QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+        queryWrapper
+                .eq("code", meterPoint.getNemCode())
+                .eq("date", dateTime1.toLocalDateTime().withDayOfYear(1).withNano(0).withSecond(0).withMinute(0).withHour(0));
+        List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+        if (list.size() > 0) {
+            meterInfoCalculating.update(queryWrapper);
+        } else {
+            meterInfoCalculating.insert();
+        }
+
+    }
+
+
     public void sum() {
 
         this.saveSBSSwdl_Month();
@@ -493,5 +798,17 @@ public class SaveSWDL_Day_Month_Year {
 
     }
 
+    public void sum_GF() {
+
+        this.savePowerstationSwdl_GF_Month();
+        this.savePowerstationSwdl_GF_Year();
+
+        this.saveGFStationSwdl_GF_Day();
+        this.saveGFStationSwdl_GF_Month();
+        this.saveGFStationSwdl_GF_Year();
+
+
+    }
+
 
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meterInfo/GetMeterInfo.java

@@ -8,6 +8,8 @@ import com.gyee.gaia.common.utils.StringUtil;
 import com.gyee.gaia.meter.entity.*;
 import com.gyee.gaia.meter.entity.vo.MeterInfoVo;
 import com.gyee.gaia.meter.service.impl.*;
+import com.gyee.gaia.meter.util.ScriptShell;
+import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.springframework.stereotype.Service;
@@ -18,9 +20,7 @@ import java.math.RoundingMode;
 import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 import java.util.function.Function;
 
 /**
@@ -40,6 +40,8 @@ public class GetMeterInfo {
     MeterPointServiceImpl meterPointService;
     @Resource
     EquipmentServiceImpl equipmentService;
+    @Resource
+    ProMeterLineFDL15MinServiceImpl proMeterLineFDL15MinService;
 
     //获取风机发电量,每日
     public ArrayList<MeterInfoVo> getEquipmentInfoById(String windId, String id, long startTime, long endTime) {
@@ -121,34 +123,36 @@ public class GetMeterInfo {
                 .eq(StringUtil.isNotBlank(name), "name", name)
         );
 
-        //所有测点的code加入meterPointNemCodes集合,以便后面根据code批量查询
-        List<String> meterPointNemCodes = new ArrayList<>();
-        for (MeterPoint meterPoint : meterPoints) {
-            meterPointNemCodes.add(meterPoint.getNemCode());
-        }
+        if (meterPoints.size() > 0) {
+            //所有测点的code加入meterPointNemCodes集合,以便后面根据code批量查询
+            List<String> meterPointNemCodes = new ArrayList<>();
+            for (MeterPoint meterPoint : meterPoints) {
+                meterPointNemCodes.add(meterPoint.getNemCode());
+            }
 
-        //所有查询日期加入dateTimes 集合,以便后面根据时间批量查询
-        List<DateTime> dateTimes = new ArrayList<>();
-        for (int i = 0; i <= betweenDays; i++) {
-            DateTime dateTime4 = DateUtil.offsetDay(startDateTime, i);
-            dateTimes.add(dateTime4);
-        }
+            //所有查询日期加入dateTimes 集合,以便后面根据时间批量查询
+            List<DateTime> dateTimes = new ArrayList<>();
+            for (int i = 0; i <= betweenDays; i++) {
+                DateTime dateTime4 = DateUtil.offsetDay(startDateTime, i);
+                dateTimes.add(dateTime4);
+            }
 
-        //条件构造器,根据时间集合和code集合批量查询
-        List<MeterInfoBottomcode> meterInfoBottomcodes = meterInfoBottomcodeService.list(new QueryWrapper<MeterInfoBottomcode>()
-                .in("start_time", dateTimes)
-                .in("code", meterPointNemCodes)
-        );
+            //条件构造器,根据时间集合和code集合批量查询
+            List<MeterInfoBottomcode> meterInfoBottomcodes = meterInfoBottomcodeService.list(new QueryWrapper<MeterInfoBottomcode>()
+                    .in("start_time", dateTimes)
+                    .in("code", meterPointNemCodes)
+            );
 
-        //遍历查询到的数据,赋值VO对象,添加入VO对象集合,返回
-        for (MeterInfoBottomcode meterInfoBottomcode : meterInfoBottomcodes) {
-            MeterInfoVo meterInfoVo = new MeterInfoVo();
-            meterInfoVo.setDate(new DateTime(meterInfoBottomcode.getStartTime()));
-            meterInfoVo.setName(meterInfoBottomcode.getName());
-            meterInfoVo.setStartCode(meterInfoBottomcode.getStartValue());
-            meterInfoVo.setEndCode(meterInfoBottomcode.getEndValue());
-            meterInfoVo.setRdl(meterInfoBottomcode.getDayValue());
-            meterInfoVos.add(meterInfoVo);
+            //遍历查询到的数据,赋值VO对象,添加入VO对象集合,返回
+            for (MeterInfoBottomcode meterInfoBottomcode : meterInfoBottomcodes) {
+                MeterInfoVo meterInfoVo = new MeterInfoVo();
+                meterInfoVo.setDate(new DateTime(meterInfoBottomcode.getStartTime()));
+                meterInfoVo.setName(meterInfoBottomcode.getName());
+                meterInfoVo.setStartCode(meterInfoBottomcode.getStartValue());
+                meterInfoVo.setEndCode(meterInfoBottomcode.getEndValue());
+                meterInfoVo.setRdl(meterInfoBottomcode.getDayValue());
+                meterInfoVos.add(meterInfoVo);
+            }
         }
         return meterInfoVos;
     }
@@ -175,11 +179,12 @@ public class GetMeterInfo {
 
         //条件构造器查询
         List<MeterPoint> meterPoints = meterPointService.list(new QueryWrapper<MeterPoint>()
-                .eq("windpowerstation_id", windId)
-                .eq("property", "JSD")
-                .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
-                .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
-                .eq(StringUtil.isNotBlank(name), "name", name)
+                        .eq("windpowerstation_id", windId)
+//                .eq("property", "JSD")
+                        .in("property", "JSD", "JSD_GF", "JSD_NBQFDL")
+                        .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
+                        .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
+                        .eq(StringUtil.isNotBlank(name), "name", name)
         );
 
         //code集合,以便批量查询
@@ -249,7 +254,7 @@ public class GetMeterInfo {
         List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>()
                 .in("date", dateTimes)
                 .eq(StringUtil.isNotBlank(windId), "powerstation_nem_code", windId)
-                .eq(StringUtil.isNotBlank(id),"equipment_nem_code", id)
+                .eq(StringUtil.isNotBlank(id), "equipment_nem_code", id)
         );
         //遍历每月
         for (int i = 0; i <= between; i++) {
@@ -278,7 +283,7 @@ public class GetMeterInfo {
                     }
                 }
                 //VO对象赋值月发电量,添加入VO对象集合
-                meterInfoVo.setRdl(ydl.divide(BigDecimal.valueOf(10000),2,RoundingMode.HALF_EVEN));
+                meterInfoVo.setRdl(ydl.divide(BigDecimal.valueOf(10000), 2, RoundingMode.HALF_EVEN));
                 meterInfoVos.add(meterInfoVo);
             }
         }
@@ -358,7 +363,7 @@ public class GetMeterInfo {
                         meterInfoVo.setEndCode(meterInfoBottomcode.getEndValue());
                     }
                 }
-                meterInfoVo.setRdl(ydl);
+                meterInfoVo.setRdl(ydl.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
                 meterInfoVos.add(meterInfoVo);
             }
         }
@@ -366,7 +371,7 @@ public class GetMeterInfo {
     }
 
     //获取计算场站指标,每月
-    public ArrayList<MeterInfoVo> getCalculatingInfoMonthByWindId(String windId, String meterType, String meterClass, String name, long startTime, long endTime) {
+    public ArrayList<MeterInfoVo> getCalculatingInfoMonthByWindId1(String windId, String meterType, String meterClass, String name, long startTime, long endTime) {
         //时间戳转为字符串
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         String format1 = simpleDateFormat.format(new Date(startTime));
@@ -389,7 +394,7 @@ public class GetMeterInfo {
         //条件构造器查询计算点
         List<MeterPoint> meterPoints = meterPointService.list(new QueryWrapper<MeterPoint>()
                 .eq("windpowerstation_id", windId)
-                .like("property", "JSD%")
+                .in("property", "JSD", "JSD_QCFDL")
                 .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
                 .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
                 .eq(StringUtil.isNotBlank(name), "name", name)
@@ -438,6 +443,132 @@ public class GetMeterInfo {
         return meterInfoVos;
     }
 
+    public ArrayList<MeterInfoVo> getCalculatingInfoMonthByWindId(String windId, String meterType, String meterClass, String name, long startTime, long endTime) {
+        //时间戳转为字符串
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String format1 = simpleDateFormat.format(new Date(startTime));
+        String format2 = simpleDateFormat.format(new Date(endTime));
+        //字符串转为DateTime类型
+        DateTime startDateTime1 = DateUtil.parse(format1);
+        DateTime endDateTime1 = DateUtil.parse(format2);
+        //开始时间月的第一天,结束时间月的最后一天
+        DateTime startDateTime = DateUtil.beginOfMonth(startDateTime1);
+        DateTime endDateTime = DateUtil.endOfMonth(endDateTime1);
+        //转为LocalDateTime计算间隔数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        //相隔月数
+        long between = ChronoUnit.MONTHS.between(day1, day2);
+        //相隔天数
+        long betweenDays = ChronoUnit.DAYS.between(day1, day2);
+        //VO对象集合
+        ArrayList<MeterInfoVo> meterInfoVos = new ArrayList<>();
+        //条件构造器查询计算点
+        List<MeterPoint> meterPoints = meterPointService.list(new QueryWrapper<MeterPoint>()
+                        .eq("windpowerstation_id", windId)
+                        .in("property", "JSD", "JSD_QCFDL", "JSD_NBQFDL", "JSD_GF")
+//                .in("property", "JSD", "JSD_QCFDL")
+                        .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
+                        .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
+                        .eq(StringUtil.isNotBlank(name), "name", name)
+
+        );
+
+        //时间集合,以便后面批量查询
+        List<DateTime> dateTimes = new ArrayList<>();
+        for (int i = 0; i <= betweenDays; i++) {
+            DateTime dateTime4 = DateUtil.offsetDay(startDateTime, i);
+            dateTimes.add(dateTime4);
+        }
+        //批量查询拿到计算点数据
+        List<MeterInfoCalculating> meterInfoCalculatings = meterInfoCalculatingService.list(new QueryWrapper<MeterInfoCalculating>()
+                .in("date", dateTimes));
+
+        //遍历每月
+        for (int i = 0; i <= between; i++) {
+            //每月开始时间和结束时间
+            DateTime dateTime1 = DateUtil.offsetMonth(startDateTime, i);
+            DateTime dateTime2 = DateUtil.endOfMonth(dateTime1);
+            //转为LocalDateTime类型计算间隔数
+            LocalDateTime day3 = LocalDateTimeUtil.of(dateTime1);
+            LocalDateTime day4 = LocalDateTimeUtil.of(dateTime2);
+            //当月天数
+            long betweenDay = ChronoUnit.DAYS.between(day3, day4);
+            //循环遍历每个测点
+            for (MeterPoint meterPoint : meterPoints) {
+                MeterInfoVo meterInfoVo = new MeterInfoVo();
+                meterInfoVo.setDate(dateTime1);
+                meterInfoVo.setName(meterPoint.getName());
+                meterInfoVo.setNemCode(meterPoint.getNemCode());
+                BigDecimal ydl = BigDecimal.valueOf(0);
+                for (int j = 0; j <= betweenDay; j++) {
+                    DateTime dateTime3 = DateUtil.offsetDay(dateTime1, j);
+//                    meterInfoCalculating = findMeterInfoCalculating(meterInfoCalculatings, meterPoint.getNemCode(), dateTime3);
+                    MeterInfoCalculating meterInfoCalculating = findObjectByCodeAndDate(meterInfoCalculatings, meterPoint.getNemCode(), dateTime3.toLocalDateTime(), MeterInfoCalculating::getCode, MeterInfoCalculating::getDate);
+                    if (meterInfoCalculating != null) {
+                        ydl = ydl.add(meterInfoCalculating.getValue());
+                    }
+                }
+                meterInfoVo.setRdl(ydl);
+                meterInfoVos.add(meterInfoVo);
+            }
+        }
+
+        //遍历计算点集合,如果meter_type中包含率,则取这个测点的nem_code和公式formula,解析公式中的nem_code
+        for (MeterPoint meterPoint : meterPoints) {
+            if (meterPoint.getMeterType().endsWith("率")) {
+
+                String nemCode = meterPoint.getNemCode();
+
+                String formula1 = meterPoint.getFormula();
+                String formula2 = formula1.replaceAll("DL.NX", "DL_NX").replaceAll("DJL.", "DJL_");
+
+                //分割公式字符串,得到code数组
+                String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
+                meterPointCodes = Arrays.stream(meterPointCodes)
+                        .filter(meterPointCode -> !(meterPointCode.length() < 8))
+                        .toArray(String[]::new);
+
+                HashMap<String, Object> map = new HashMap<>();
+
+                //遍历code数组,拿到每一个code
+                for (String meterPointCode : meterPointCodes) {
+                    String meterPointCode_ = meterPointCode.replaceAll("DL.", "DL_").replaceAll("DJL.", "DJL_");
+                    System.out.println("要查询的点code:" + meterPointCode);
+                    System.out.println("替换后的点code:" + meterPointCode_);
+
+                    //拿公式中的nem_code在meterInfoVos集合中取出VO数据点
+                    for (MeterInfoVo meterInfoVo : meterInfoVos) {
+                        if (meterInfoVo.getNemCode().equals(meterPointCode)) {
+                            map.put(meterPointCode_, meterInfoVo.getRdl());
+                        }
+                    }
+                }
+
+                //公式重新计算率
+                BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
+
+                for (MeterInfoVo meterInfoVo : meterInfoVos) {
+                    if (meterInfoVo.getNemCode().equals(nemCode)) {
+                        meterInfoVo.setRdl(bigDecimal1);
+                        break;
+                    }
+                }
+                // 新建一个集合存重新计算后的VO对象和原来的VO对象
+                ArrayList<MeterInfoVo> updatedMeterInfoVos = new ArrayList<>();
+                for (MeterInfoVo meterInfoVo : meterInfoVos) {
+                    if (meterInfoVo.getNemCode().equals(nemCode)) {
+                        updatedMeterInfoVos.add(meterInfoVo); // 添加修改后的对象
+                    } else {
+                        updatedMeterInfoVos.add(meterInfoVo); // 添加原来不匹配的对象
+                    }
+                }
+                meterInfoVos = updatedMeterInfoVos;
+            }
+        }
+        return meterInfoVos;
+    }
+
 
     //获取风机发电量,每年
     public ArrayList<MeterInfoVo> getEquipmentInfoYearByWindId(String windId, String id, long startTime, long endTime) {
@@ -476,8 +607,8 @@ public class GetMeterInfo {
         //条件构造器批量查询
         List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>()
                 .in("date", dateTimes)
-                .eq(StringUtil.isNotBlank(windId),"powerstation_nem_code", windId)
-                .eq(StringUtil.isNotBlank(id),"equipment_nem_code", id)
+                .eq(StringUtil.isNotBlank(windId), "powerstation_nem_code", windId)
+                .eq(StringUtil.isNotBlank(id), "equipment_nem_code", id)
         );
         //遍历每年
         for (int i = 0; i <= between; i++) {
@@ -506,7 +637,7 @@ public class GetMeterInfo {
                     }
                 }
                 //VO对象赋值月发电量,添加入VO对象集合
-                meterInfoVo.setRdl(ndl.divide(BigDecimal.valueOf(10000),2,RoundingMode.HALF_EVEN));
+                meterInfoVo.setRdl(ndl.divide(BigDecimal.valueOf(10000), 2, RoundingMode.HALF_EVEN));
                 meterInfoVos.add(meterInfoVo);
             }
         }
@@ -586,7 +717,7 @@ public class GetMeterInfo {
                         meterInfoVo.setEndCode(meterInfoBottomcode.getEndValue());
                     }
                 }
-                meterInfoVo.setRdl(ndl);
+                meterInfoVo.setRdl(ndl.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
                 meterInfoVos.add(meterInfoVo);
             }
         }
@@ -616,11 +747,12 @@ public class GetMeterInfo {
         ArrayList<MeterInfoVo> meterInfoVos = new ArrayList<>();
         //条件构造器查询计算点
         List<MeterPoint> meterPoints = meterPointService.list(new QueryWrapper<MeterPoint>()
-                .eq("windpowerstation_id", windId)
-                .like("property", "JSD%")
-                .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
-                .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
-                .eq(StringUtil.isNotBlank(name), "name", name)
+                        .eq("windpowerstation_id", windId)
+//                .in("property", "JSD", "JSD_QCFDL")
+                        .in("property", "JSD", "JSD_QCFDL", "JSD_NBQFDL", "JSD_GF")
+                        .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
+                        .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
+                        .eq(StringUtil.isNotBlank(name), "name", name)
 
         );
 
@@ -667,7 +799,7 @@ public class GetMeterInfo {
     }
 
 
-    //三个辅助方法合并成一个通用方法
+    //三个辅助方法合并成一个通用方法(时间为判断是否不包括时分秒)
     @Nullable
     private <T> T findObjectByCodeAndDate(@NotNull List<T> objects, String code, LocalDateTime date, Function<T, String> getCodeFunction, Function<T, LocalDateTime> getDateFunction) {
         for (T object : objects) {
@@ -678,6 +810,17 @@ public class GetMeterInfo {
         return null;
     }
 
+    //辅助方法,线路发电量(时间为判断是否相同包括时分秒)
+    @Nullable
+    private <T> T findObjectByCodeAndDateLine(@NotNull List<T> objects, String code, LocalDateTime date, Function<T, String> getCodeFunction, Function<T, LocalDateTime> getDateFunction) {
+        for (T object : objects) {
+            if (getCodeFunction.apply(object).equals(code) && getDateFunction.apply(object).isEqual(date)) {
+                return object;
+            }
+        }
+        return null;
+    }
+
     // 辅助方法，根据日期和NemCode查找对象
     @Nullable
     private MeterInfoCalculating findMeterInfoCalculating(@NotNull List<MeterInfoCalculating> meterInfoCalculatings, String nemCode, DateTime date) {
@@ -713,4 +856,89 @@ public class GetMeterInfo {
     }
 
 
+
+    //获取底码数据,每月
+    public ArrayList<MeterInfoVo> getLineFDL_hour(String windId, String meterType, String meterClass, String name, long startTime, long endTime) {
+        //时间戳转为字符串
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String format1 = simpleDateFormat.format(new Date(startTime));
+        String format2 = simpleDateFormat.format(new Date(endTime));
+        //字符串转为DateTime类型
+        DateTime startDateTime0 = DateUtil.parse(format1);
+        DateTime startDateTime = DateUtil.beginOfHour(startDateTime0);
+        DateTime endDateTime0 = DateUtil.parse(format2);
+        DateTime endDateTime = DateUtil.beginOfHour(endDateTime0);
+
+        //转为LocalDateTime类型,计算间隔数
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+
+        long betweenMin = ChronoUnit.MINUTES.between(day1, day2);
+        int between= (int) (betweenMin/15);
+
+        long betweenHour = ChronoUnit.HOURS.between(day1, day2);
+
+        //VO对象集合
+        ArrayList<MeterInfoVo> meterInfoVos = new ArrayList<>();
+        //条件构造器查询
+        List<MeterPoint> meterPoints = meterPointService.list(new QueryWrapper<MeterPoint>()
+                .eq("windpowerstation_id", windId)
+                .like("property", "CD")
+                .eq(StringUtil.isBlank(meterType), "meter_type", "线路")
+                .like(StringUtil.isBlank(meterClass),"meter_class", "集电线路")
+                .eq(StringUtil.isNotBlank(meterType), "meter_type", meterType)
+                .eq(StringUtil.isNotBlank(meterClass), "meter_class", meterClass)
+                .eq(StringUtil.isNotBlank(name), "description", name)
+
+        );
+        //时间集合,以便后面批量查询
+        List<DateTime> dateTimes = new ArrayList<>();
+        for (int i = 0; i < between; i++) {
+            DateTime dateTime4 = DateUtil.offsetMinute(startDateTime, (i+1)*15);
+            dateTimes.add(dateTime4);
+        }
+        //条件构造器批量查询
+        List<ProMeterLineFDL15Min> meterInfoBottomcodes = proMeterLineFDL15MinService.list(new QueryWrapper<ProMeterLineFDL15Min>()
+                .in("end_time", dateTimes));
+
+        //遍历每小时
+        for (int i = 0; i < betweenHour; i++) {
+            //每小时开始和结束
+            DateTime dateTime0 = DateUtil.offsetHour(startDateTime, i);
+            DateTime dateTime1 = DateUtil.beginOfHour(dateTime0);
+            DateTime dateTime2 = DateUtil.offsetHour(dateTime1,1);
+
+            //遍历测点,累加每15分钟到每小时
+            for (MeterPoint meterPoint : meterPoints) {
+                //每台风机VO对象,先赋值时间,名称
+                MeterInfoVo meterInfoVo = new MeterInfoVo();
+                meterInfoVo.setStartTime(dateTime1);
+                meterInfoVo.setEndTime(dateTime2);
+                meterInfoVo.setName(meterPoint.getDescription());
+                //初始化月发电量
+                BigDecimal ydl = BigDecimal.valueOf(0);
+                //循环遍历每15分钟
+                for (int j = 1; j <= 4; j++) {
+                    DateTime dateTime3 = DateUtil.offsetMinute(dateTime1, j*15);
+                    ProMeterLineFDL15Min meterInfoBottomcode = findObjectByCodeAndDateLine(meterInfoBottomcodes, meterPoint.getNemCode(), dateTime3.toLocalDateTime(), ProMeterLineFDL15Min::getCode, ProMeterLineFDL15Min::getEndTime);
+                    if (meterInfoBottomcode != null) {
+                        //当月第一天底码,起码
+                        if (j == 1) {
+                            meterInfoVo.setStartCode(meterInfoBottomcode.getStartValue());
+                        }
+                        ydl = ydl.add(meterInfoBottomcode.getDayValue());
+                        //每天赋值一次止码,最后一天的止码为当月止码
+                        if (j == 4) {
+                            meterInfoVo.setEndCode(meterInfoBottomcode.getEndValue());
+                        }
+                    }
+                }
+                meterInfoVo.setRdl(ydl.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
+                meterInfoVos.add(meterInfoVo);
+            }
+
+        }
+        return meterInfoVos;
+    }
+
 }

electricity/meter/src/main/java/com/gyee/gaia/meter/service/meterInfo/GetPowerstation_Type_Class_Name.java

@@ -35,7 +35,26 @@ public class GetPowerstation_Type_Class_Name {
     /*获取所有风场排序后的VO对象*/
     public ArrayList<MeterInfoVo> getPowerstation() {
         //获取所有风场,并排序
-        List<PowerStation> powerStations = powerStationService.list(new QueryWrapper<PowerStation>().eq("wind_type", "-1").orderBy(true, true, "order_num"));
+        List<PowerStation> powerStations = powerStationService.list(new QueryWrapper<PowerStation>()
+                .eq("wind_type", "-1")
+                .orderBy(true, true, "order_num"));
+        //创建VO对象,遍历每个风场,赋值name和nem_code,并返回
+        ArrayList<MeterInfoVo> powerStationsVo = new ArrayList<>();
+        for (PowerStation powerStation : powerStations) {
+            MeterInfoVo meterInfoVo = new MeterInfoVo();
+            meterInfoVo.setName(powerStation.getName());
+            meterInfoVo.setNemCode(powerStation.getNemCode());
+            powerStationsVo.add(meterInfoVo);
+        }
+        return powerStationsVo;
+    }
+
+    /*获取所有风场排序后的VO对象*/
+    public ArrayList<MeterInfoVo> getPowerstationAll() {
+        //获取所有风场,并排序
+        List<PowerStation> powerStations = powerStationService.list(new QueryWrapper<PowerStation>()
+//                .eq("wind_type", "-1")
+                .orderBy(true, true, "order_num"));
         //创建VO对象,遍历每个风场,赋值name和nem_code,并返回
         ArrayList<MeterInfoVo> powerStationsVo = new ArrayList<>();
         for (PowerStation powerStation : powerStations) {
@@ -53,7 +72,45 @@ public class GetPowerstation_Type_Class_Name {
         //判断传入参数是否为空,并根据传入参数在meterPoint查询计算点
         if (windId != null) {
             List<MeterPoint> meterTypeList = meterPointService.list(new QueryWrapper<MeterPoint>()
-                    .eq("property", "JSD")
+                    .in("property", "JSD", "JSD_QCFDL")
+                    .eq("windpowerstation_id", windId)
+                    .eq(StringUtils.isNotBlank(type), "meter_type", type)
+                    .eq(StringUtils.isNotBlank(meterClass), "meter_class", meterClass)
+            );
+
+            //encounteredMeterTypes存不重复的测点类型
+            Set<String> encounteredMeterTypes = new HashSet<>();
+            //返回的VO对象
+            List<MeterInfoVo> meterTypeListVo = new ArrayList<>();
+            //遍历测点集合,判断传入参数是否为空,分别返回一级类型,二级分类,name
+            for (MeterPoint meterPoint : meterTypeList) {
+                String meterType;
+                if (StringUtils.isNotBlank(meterClass) && StringUtils.isNotBlank(type)) {
+                    meterType = meterPoint.getName();
+                } else if (StringUtils.isNotBlank(type)) {
+                    meterType = meterPoint.getMeterClass();
+                } else {
+                    meterType = meterPoint.getMeterType();
+                }
+
+                if (!encounteredMeterTypes.contains(meterType)) {
+                    MeterInfoVo meterInfoVo = new MeterInfoVo();
+                    meterInfoVo.setName(meterType);
+                    meterTypeListVo.add(meterInfoVo);
+                    encounteredMeterTypes.add(meterType);
+                }
+            }
+            return meterTypeListVo;
+        }
+        return null;
+    }
+
+    /*获取计算点的的一级类型,二级分类,具体名称*/
+    public List<MeterInfoVo> getMeterTypeCalculatingAll(String windId, String type, String meterClass) {
+        //判断传入参数是否为空,并根据传入参数在meterPoint查询计算点
+        if (windId != null) {
+            List<MeterPoint> meterTypeList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .in("property", "JSD", "JSD_QCFDL", "JSD_GF", "JSD_NBQFDL")
                     .eq("windpowerstation_id", windId)
                     .eq(StringUtils.isNotBlank(type), "meter_type", type)
                     .eq(StringUtils.isNotBlank(meterClass), "meter_class", meterClass)
@@ -124,6 +181,38 @@ public class GetPowerstation_Type_Class_Name {
 
     }
 
+
+    /*获取LINE的一级类型,二级分类,具体名称*/
+    public List<MeterInfoVo> getLineName(String windId) {
+
+        if (windId != null) {
+            List<MeterPoint> meterTypeList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("property", "CD")
+                    .eq("windpowerstation_id", windId)
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            Set<String> encounteredMeterTypes = new HashSet<>();
+            List<MeterInfoVo> meterTypeListVo = new ArrayList<>();
+
+            for (MeterPoint meterPoint : meterTypeList) {
+                String meterType;
+                meterType = meterPoint.getDescription();
+                if (!encounteredMeterTypes.contains(meterType)) {
+                    MeterInfoVo meterInfoVo = new MeterInfoVo();
+                    meterInfoVo.setName(meterType);
+                    meterTypeListVo.add(meterInfoVo);
+                    encounteredMeterTypes.add(meterType);
+                }
+            }
+            return meterTypeListVo;
+        }
+        return null;
+
+    }
+
+
     /*获取场站下风机编号*/
     public List<MeterInfoVo> getEquipmentId(String windId) {
         //设备表中根据场站ID查询风机编号

electricity/meter/src/main/resources/application.yml

@@ -0,0 +1,106 @@
+#server:
+#  port: 8022
+#
+#start:
+#  time: 2023-06-02
+#
+#end:
+#  time: 2023-06-08
+#test:
+#  abcd: asdf
+#adapter:
+#  url: http://192.168.1.67:8011/ts
+#
+#
+#meter:
+#  stations: MHS_FDC,NSS_FDC
+#
+#spring:
+#  cache:
+#    type: SIMPLE
+#  datasource:
+#    dynamic:
+#      primary: master #设置默认的数据源或者数据源组,默认值即为master
+#      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
+#      datasource:
+#        master:
+#          url: jdbc:postgresql://192.168.10.18:5432/nx_dev
+#          username: gdprod
+#          password: gyee123
+#          driver-class-name: org.postgresql.Driver
+#          type: com.alibaba.druid.pool.DruidDataSource
+#        meter:
+#          url: jdbc:TAOS-RS://192.168.1.67:6041/meter?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
+#          username: root
+#          password: taosdata
+#          driver-class-name: com.taosdata.jdbc.rs.RestfulDriver
+#    # datasource:
+#    #   driver-class-name: org.postgresql.Driver
+#    #   url: jdbc:postgresql://192.168.10.18:5432/nx_dev
+#    #   username: gdprod
+#    #   password: gyee123
+#    #   # url: jdbc:postgresql://192.168.1.67:5432/gyee
+#    #   # username: gyee
+#    #   # password: Gyee@2023!@#
+#    #   type: com.alibaba.druid.pool.DruidDataSource
+#    druid:
+#      max-active: 20
+#      initial-size: 1
+#      min-idle: 3
+#      max-wait: 60000
+#      time-between-eviction-runs-millis: 60000
+#      min-evictable-idle-time-millis: 300000
+#      test-while-idle: true
+#      test-on-borrow: false
+#      test-on-return: false
+#  jackson:
+#    date-format: yyyy-MM-dd HH:mm:ss
+#    time-zone: GMT+8
+#    default-property-inclusion: always
+#
+#
+#mybatis-plus:
+#  typeAliasesPackage: com.gyee.gaia.meter.entity
+#  mapper-locations: classpath:mappers-postgresql/*.xml
+#  global-config:
+#    #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
+#    id-type: 3
+#    #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
+#    field-strategy: 2
+#    #驼峰下划线转换
+#    db-column-underline: true
+#    #mp2.3+ 全局表前缀 mp_
+#    #table-prefix: mp_
+#    #刷新mapper 调试神器
+#    #refresh-mapper: true
+#    #数据库大写下划线转换
+#    #capital-mode: true
+#    # Sequence序列接口实现类配置
+#    key-generator: com.baomidou.mybatisplus.incrementer.OracleKeyGenerator
+#    #逻辑删除配置（下面3个配置）
+#    logic-delete-value: 1
+#    logic-not-delete-value: 0
+#    #sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
+#    #自定义填充策略接口实现
+#    #meta-object-handler: com.baomidou.springboot.MyMetaObjectHandler
+#  configuration:
+#    #配置返回数据库(column下划线命名&&返回java实体是驼峰命名)，自动匹配无需as（没开启这个，SQL需要写as： select user_id as userId）
+#    map-underscore-to-camel-case: true
+#    cache-enabled: false
+#    #配置JdbcTypeForNull, oracle数据库必须配置
+#    jdbc-type-for-null: 'null'
+#    callSettersOnNulls: true
+#
+#xxl:
+#  job:
+#    admin:
+#      addresses: http://192.168.10.18:8080/xxl-job-admin
+#    accessToken:
+#    executor:
+#      appname: meter
+#      address:
+#      ip:
+#      port: 9999
+#      logpath: c:/xxl-job/meter/logs
+#      logretentiondays: 30
+#

electricity/meter/src/main/resources/mappers-postgresql/ProMeterLineFDL15MinMapper.xml

@@ -0,0 +1,5 @@
+<?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.gyee.gaia.meter.mapper.ProMeterLineFDL15MinMapper">
+
+</mapper>

electricity/meter/src/main/resources/mappers-postgresql/TDLineFDL15MinMapper.xml

@@ -0,0 +1,5 @@
+<?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.gyee.gaia.meter.mapper.TDLineFDL15MinMapper">
+
+</mapper>