日月年发电量,上网电量

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

@@ -1,5 +1,6 @@
 package com.gyee.gaia.meter.job;
 
+import com.gyee.gaia.meter.service.meterinfo.*;
 import com.xxl.job.core.handler.annotation.XxlJob;
 import org.springframework.stereotype.Component;
 
@@ -12,32 +13,49 @@ import javax.annotation.Resource;
 @Component
 public class MeterJob {
 
-
-    @Resource
-    SaveCalculatingFJFDL saveCalculatingFJFDL;
     @Resource
-    SaveCalculating saveCalculating;
-    @Resource
-    SaveEquipmentRfdl saveEquipmentRfdl;
+    SaveEquipmentFDL saveEquipmentFDL;
     @Resource
     SaveBottomcode saveBottomcode;
     @Resource
-    SavaMonthFdl savaMonthFdl;
+    SaveCalculating saveCalculating;
+    @Resource
+    SaveFDL_Day_Month_Year saveFDLDayMonthYear;
     @Resource
-    SavaYearFdl savaYearFdl;
-
+    SaveSWDL_Day_Month_Year saveSWDLDayMonthYear;
 
 
     @XxlJob("MeterJob")
-    void meterJob(){
-        saveEquipmentRfdl.saveEquipmentRfdl();
+    void meterJob() {
+
+        //设备日发电量(407台风机)
+        saveEquipmentFDL.saveEquipmentRfdl();
+        //期次风机发电量(14个期次)
+        saveEquipmentFDL.saveEquipmentRfdl();
+
+        //底码表数据,起始底码,截止底码,日电量
         saveBottomcode.saveBottomCode();
-        saveCalculatingFJFDL.saveCalculatingFJFDL();
+
+        //计算有公式的发电量,场用电量等(由于后面数据需要用前面算出来的数,所以执行3-4次)
         saveCalculating.saveCalculating();
         saveCalculating.saveCalculating();
         saveCalculating.saveCalculating();
-        savaMonthFdl.savaMonthFdl();
-        savaYearFdl.savaYearFdl();
+        saveCalculating.saveCalculating();
+
+
+    }
+
+
+    @XxlJob("MeterJob_FDL_Day_Month_Year")
+    void meterJob2() {
+        saveFDLDayMonthYear.sum();
+
+
+    }
+
+    @XxlJob("MeterJob_SWDL_Day_Month_Year")
+    void meterJob3() {
+        saveSWDLDayMonthYear.sum();
 
 
     }

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

@@ -1,84 +0,0 @@
-package com.gyee.gaia.meter.job;
-
-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.MeterInfoCalculating;
-import com.gyee.gaia.meter.entity.MeterPoint;
-import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
-import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
-import com.xxl.job.core.handler.annotation.XxlJob;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.time.temporal.ChronoUnit;
-import java.util.List;
-
-/**
- * Author: malijun
- * Data  : 2023: 05: 17
- **/
-@Component
-public class SavaMonthFdl {
-
-    @Resource
-    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
-    @Resource
-    MeterPointServiceImpl meterPointService;
-
-    @XxlJob("saveMonthFdl")
-    void savaMonthFdl() {
-
-        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_MONTH"));
-
-        //设置取值开始时间
-        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
-        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", "%_JDXLFDL_P0"));
-
-                //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();
-            }
-        }
-    }
-}

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

@@ -1,83 +0,0 @@
-package com.gyee.gaia.meter.job;
-
-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.MeterInfoCalculating;
-import com.gyee.gaia.meter.entity.MeterPoint;
-import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
-import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
-import com.xxl.job.core.handler.annotation.XxlJob;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.time.temporal.ChronoUnit;
-import java.util.List;
-
-/**
- * Author: malijun
- * Data  : 2023: 05: 17
- **/
-@Component
-public class SavaYearFdl {
-
-    @Resource
-    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
-    @Resource
-    MeterPointServiceImpl meterPointService;
-
-@XxlJob("saveYearFdl")
-    void savaYearFdl() {
-
-        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_YEAR"));
-
-        //设置取值开始时间
-        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
-        DateTime startDateTime = DateUtil.beginOfYear(nowDateTime);
-
-        //开始日期到结束日期的天数
-        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
-        LocalDateTime day2 = LocalDateTimeUtil.of(nowDateTime);
-        long between = ChronoUnit.MONTHS.between(day1, day2);
-
-        //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", "%_JDXLFDL_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();
-            }
-        }
-    }
-}

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

@@ -1,98 +0,0 @@
-package com.gyee.gaia.meter.job;
-
-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.MeterInfoEquipment;
-import com.gyee.gaia.meter.entity.MeterPoint;
-import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
-import com.gyee.gaia.meter.service.impl.MeterInfoEquipmentServiceImpl;
-import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
-import com.xxl.job.core.handler.annotation.XxlJob;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.util.List;
-
-/**
- * Author: malijun
- * Data  : 2023: 05: 09
- **/
-
-@Component
-public class SaveCalculatingFJFDL {
-
-    @Resource
-    MeterPointServiceImpl meterPointService;
-    @Resource
-    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
-    @Resource
-    MeterInfoEquipmentServiceImpl meterInfoEquipmentService;
-
-    //项目期次风机总发电量
-    @XxlJob("SaveCalculatingFJFDL")
-    void saveCalculatingFJFDL() {
-
-        //获取当前日期,当日开始时间
-        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
-        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
-
-        //1,所有期次发电量测点
-        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_QCFDL"));
-        System.out.println(meterPointList.size());
-
-        //遍历期次发电量测点,拿到项目期次ID
-        for (MeterPoint meterPoint : meterPointList) {
-            String projectId = meterPoint.getProjectId();
-
-            //开始时间00:00:01
-            DateTime dateTime1 = startDateTime;
-
-            //根据时间和项目期次ID查询设备日发电量表
-            List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("project_nem_code", projectId).eq("date", dateTime1));
-
-            //遍历累加取出的数据
-            BigDecimal bigDecimal = BigDecimal.valueOf(0);
-            for (MeterInfoEquipment meterInfoEquipment : meterInfoEquipments) {
-                bigDecimal = bigDecimal.add(meterInfoEquipment.getRfdl());
-            }
-
-            //存入MeterInfoCalculating表中,单位:万千瓦时
-            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(nowDateTime.toLocalDateTime());
-            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
-
-
-            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
-            queryWrapper.eq("date", dateTime1.toLocalDateTime()).eq("code", meterPoint.getNemCode());
-            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
-            System.out.println(list.size());
-            if (list.size() > 0) {
-                meterInfoCalculating.update(queryWrapper);
-            } else {
-                meterInfoCalculating.insert();
-            }
-
-
-        }
-
-
-    }
-
-
-}
-
-
-
-
-
-
-
-

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

@@ -51,7 +51,7 @@ class SaveMeterInfoHistoryDayTest {
     @Value("${end.time}")
     private String endTimeString;
 
-    //读取时间段内设备发电量计算肉发电量写入pg数据库
+    //风机日发电量
     @Test
     void saveEquipmentRfdl() {
 
@@ -143,6 +143,61 @@ class SaveMeterInfoHistoryDayTest {
         }
     }
 
+    //电计量底码表
+    @Test
+    void saveCalculatingProjectFDL() {
+
+
+        //设置取值开始时间
+        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);
+
+
+        //1,所有期次发电量测点
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_QCFDL"));
+
+        //遍历期次发电量测点,拿到场站id,
+        for (MeterPoint meterPoint : meterPointList) {
+            String projectId = meterPoint.getProjectId();
+
+            for (int i = 0; i <= between; i++) {
+                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("project_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();
+                }
+            }
+        }
+    }
+
     @Test
     void saveBottomCode() {
 
@@ -243,63 +298,9 @@ class SaveMeterInfoHistoryDayTest {
             }
         }
     }
+    //项目期次风机总发电量
 
-    //项目期期风机总发电量
-    @Test
-    void saveCalculatingProjectFDL() {
-
-
-        //设置取值开始时间
-        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);
-
-
-        //1,所有期次发电量测点
-        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_QCFDL"));
-
-        //遍历期次发电量测点,拿到场站id,
-        for (MeterPoint meterPoint : meterPointList) {
-            String projectId = meterPoint.getProjectId();
-
-            for (int i = 0; i <= between; i++) {
-                DateTime dateTime1 = DateUtil.offsetDay(startDateTime, i);
-
-                List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("project_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();
-                }
-            }
-        }
-    }
-
-    //用公式计算
+    //有公式的计算电量
     @Test
     void saveCalculating() {
 
@@ -321,15 +322,12 @@ class SaveMeterInfoHistoryDayTest {
         for (MeterPoint meterPoint : meterPointJSDList) {
             String formula1 = meterPoint.getFormula();
             System.out.println("转换前的公式:" + formula1);
-            String formula3 = formula1.replaceAll("DL\\.", "DL_");
-            String formula2 = formula3.replaceAll("DJL\\.", "DJL_");
-
-            //得到公式字符串(DL.已经替换为DL_)
-//            String formula2 = meterPoint.getFormula2();
+            String formula2 = formula1.replaceAll("DL.NX", "DL_NX").replaceAll("DJL.", "DJL_");
             System.out.println("转换后的公式字符串:" + formula2);
 
-            //分割公式字符串,得到每一的个ode
-            String[] meterPointCodes = StringUtils.split(formula1, "[+\\-*/()]");
+            //分割公式字符串,得到每一的个code
+//            String[] meterPointCodes = StringUtils.split(formula1, "[+\\-*/()]");
+            String[] meterPointCodes = StringUtils.split(formula1, "[+-*/()]");
             meterPointCodes = Arrays.stream(meterPointCodes)
                     .filter(meterPointCode -> !(meterPointCode.length() < 8))
                     .toArray(String[]::new);
@@ -345,8 +343,7 @@ class SaveMeterInfoHistoryDayTest {
                 //遍历code数据,拿到每一个code,用code和时间,在meter_info_bottom中拿到dayValue
                 for (String meterPointCode : meterPointCodes) {
 //                    String meterPointCode_ = meterPointCode.replaceAll("\\.", "_");
-                    String meterPointCode_1 = meterPointCode.replaceAll("DL\\.", "DL_");
-                    String meterPointCode_ = meterPointCode_1.replaceAll("DJL\\.", "DJL_");
+                    String meterPointCode_ = meterPointCode.replaceAll("DL.", "DL_").replaceAll("DJL.", "DJL_");
                     System.out.println("要查询的点code:" + meterPointCode);
                     System.out.println("替换后的点code:" + meterPointCode_);
 //
@@ -354,12 +351,12 @@ class SaveMeterInfoHistoryDayTest {
                         if (meterPointCode.startsWith("DL")) {
                             System.out.println("计算测点DL:" + meterPointCode);
                             MeterInfoCalculating meterInfoCalculating = meterInfoCalculatingService.getOne(new QueryWrapper<MeterInfoCalculating>().eq("code", meterPointCode).eq("date", dateTime1));
-                            System.out.println("测点数据:" + meterInfoCalculating.getValue());
+                            System.out.println("DL点数据:" + meterInfoCalculating.getValue());
                             map.put(meterPointCode_, meterInfoCalculating.getValue());
                         } else {
                             System.out.println("计算测点Bottom:" + meterPointCode);
                             MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointCode).eq("start_time", dateTime1));
-                            System.out.println("测点数据日电量:" + meterInfoBottomcode.getDayValue());
+                            System.out.println("Bottom点数据日电量:" + meterInfoBottomcode.getDayValue());
                             map.put(meterPointCode_, meterInfoBottomcode.getDayValue());
                         }
 
@@ -367,9 +364,11 @@ class SaveMeterInfoHistoryDayTest {
                         System.out.println("获取数据异常:" + e.getMessage());
 
                     }
+                }
+                    System.out.println("map集合:"+map);
                     try {
                         BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
-                        System.out.println(bigDecimal1);
+                        System.out.println("公式计算后数据:"+bigDecimal1);
                         MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
                         meterInfoCalculating.setName(meterPoint.getName());
                         meterInfoCalculating.setCode(meterPoint.getNemCode());
@@ -386,20 +385,42 @@ class SaveMeterInfoHistoryDayTest {
                         } 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个,第四个需要3-4次
     @Test
     void saveCalculating3() {
         this.saveEquipmentRfdl();
-        this.saveBottomCode();
         this.saveCalculatingProjectFDL();
+        this.saveBottomCode();
         this.saveCalculating();
         this.saveCalculating();
         this.saveCalculating();

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

@@ -4,7 +4,9 @@ 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.*;
+import com.gyee.gaia.meter.entity.MeterInfoBottomcode;
+import com.gyee.gaia.meter.entity.MeterInfoCalculating;
+import com.gyee.gaia.meter.entity.MeterPoint;
 import com.gyee.gaia.meter.service.impl.*;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Value;
@@ -40,6 +42,8 @@ public class SaveMeterInfoHistoryMonthYearTest {
 
     @Value("${start.time}")
     private String startTimeString;
+    @Value("${end.time}")
+    private String endTimeString;
 
     @Test
     void saveLineFdl_Month() {
@@ -619,6 +623,64 @@ public class SaveMeterInfoHistoryMonthYearTest {
     }
 
     @Test
+    void saveWindStationFdl_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCFDL_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", "%_JDXLFDL_P0"));
+            //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_Month() {
 
         MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCFDL_MONTH"));
@@ -732,7 +794,6 @@ public class SaveMeterInfoHistoryMonthYearTest {
     }
 
 
-
     @Test
     void saveSBSSwdl_Month() {
 
@@ -808,7 +869,7 @@ public class SaveMeterInfoHistoryMonthYearTest {
             meterInfoCalculating.setCode(meterPointJSD_SBSSWDL.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).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());
             meterInfoCalculating.setWindpowerstationId(meterPointJSD_SBSSWDL.getWindpowerstationId());
 
@@ -1030,6 +1091,67 @@ public class SaveMeterInfoHistoryMonthYearTest {
     }
 
     @Test
+    void saveWindStationSwdl_Day() {
+
+        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);
+
+        //设置取值结束时间
+        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);
+        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", "%_SWDL_P0"));
+            //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 saveWindStationSwdl_Month() {
 
         MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCSWDL_MONTH"));
@@ -1143,27 +1265,32 @@ public class SaveMeterInfoHistoryMonthYearTest {
     }
 
 
-
     @Test
-    void sum(){
+    void sum() {
         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();
 
 
-
-
     }
 }
 

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

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.job;
+package com.gyee.gaia.meter.service.meterinfo;
 
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
@@ -38,7 +38,7 @@ public class SaveBottomcode {
     Adapter adapter;
 
     @XxlJob("SaveBottomcode")
-    void saveBottomCode() {
+   public void saveBottomCode() {
 
         //1,查询所有风电场
         List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>().like("nem_code", "_FDC_"));
@@ -61,6 +61,7 @@ public class SaveBottomcode {
 
                 //开始时间00:00:01
                 DateTime dateTime1 = startDateTime;
+
                 //结束时间第二天00:00:01
                 DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
 

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

@@ -1,4 +1,4 @@
-package com.gyee.gaia.meter.job;
+package com.gyee.gaia.meter.service.meterinfo;
 
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
@@ -16,6 +16,7 @@ import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -35,7 +36,7 @@ public class SaveCalculating {
     MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
 
     @XxlJob("SaveCalculating")
-    void saveCalculating() {
+    public void saveCalculating() {
 
         //获取当前日期,当日开始时间
         DateTime nowDateTime = DateUtil.parse(DateUtil.now());
@@ -49,7 +50,7 @@ public class SaveCalculating {
             //原始公式
             String formula1 = meterPoint.getFormula();
             //.转换为_后的公式
-            String formula2 = formula1.replaceAll("DL\\.", "DL_").replaceAll("DJL\\.", "DJL_");
+            String formula2 = formula1.replaceAll("DL.", "DL_").replaceAll("DJL.", "DJL_");
 
             //分割原始公式字符串,得到每一的个code
             String[] meterPointCodes = StringUtils.split(formula1, "[+\\-*/()]");
@@ -67,9 +68,9 @@ public class SaveCalculating {
             //遍历code数组,拿到每一个code,用code和时间,在meter_info_bottom中拿到dayValue
             for (String meterPointCode : meterPointCodes) {
 
-                String meterPointCode_ = meterPointCode.replaceAll("DL\\.", "DL_").replaceAll("DJL\\.", "DJL_");
+                String meterPointCode_ = meterPointCode.replaceAll("DL.", "DL_").replaceAll("DJL.", "DJL_");
 
-                //如果字符串以DL开头,从meter_info_calclating表中取,否则从meter_info_bottom表中取
+                //如果字符串以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));
@@ -81,32 +82,49 @@ public class SaveCalculating {
                 } catch (Exception e) {
                     System.out.println("获取数据异常  :" + e.getMessage());
                 }
+            }
 
-                try {
-                    //公式计算
-                    BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
-
-                    //存入数据
-                    MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
-                    meterInfoCalculating.setName(meterPoint.getName());
-                    meterInfoCalculating.setCode(meterPoint.getNemCode());
-                    meterInfoCalculating.setDate(dateTime1.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());
-                    List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
-                    if (list.size() > 0) {
-                        meterInfoCalculating.update(queryWrapper);
-                    } else {
-                        meterInfoCalculating.insert();
-                    }
-                } catch (Exception e) {
-                    System.out.println(e.getMessage());
+            try {
+                //公式计算
+                BigDecimal bigDecimal1 = (BigDecimal) ScriptShell.parseExpr(formula2, map);
+
+                //存入数据
+                MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+                meterInfoCalculating.setName(meterPoint.getName());
+                meterInfoCalculating.setCode(meterPoint.getNemCode());
+                meterInfoCalculating.setDate(dateTime1.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());
+                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/job/SaveEquipmentRfdl.java

@@ -1,31 +1,26 @@
-package com.gyee.gaia.meter.job;
+package com.gyee.gaia.meter.service.meterinfo;
 
 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.Equipment;
-import com.gyee.gaia.meter.entity.MeterInfoEquipment;
-import com.gyee.gaia.meter.entity.PointData;
-import com.gyee.gaia.meter.entity.TestingPoint;
-import com.gyee.gaia.meter.service.impl.EquipmentServiceImpl;
-import com.gyee.gaia.meter.service.impl.MeterInfoEquipmentServiceImpl;
-import com.gyee.gaia.meter.service.impl.TestingPointServiceImpl;
-import com.xxl.job.core.handler.annotation.XxlJob;
-import org.springframework.stereotype.Component;
+import com.gyee.gaia.meter.entity.*;
+import com.gyee.gaia.meter.service.impl.*;
+import org.springframework.stereotype.Service;
 
 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
+ * Data  : 2023: 05: 19
  **/
 
-@Component
-public class SaveEquipmentRfdl {
+@Service
+public class SaveEquipmentFDL {
 
     @Resource
     Adapter adapter;
@@ -35,9 +30,13 @@ public class SaveEquipmentRfdl {
     EquipmentServiceImpl equipmentService;
     @Resource
     MeterInfoEquipmentServiceImpl meterInfoEquipmentService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
+
 
-    @XxlJob("SaveEquipmentRfdl")
-    void saveEquipmentRfdl() {
+    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_%"));
@@ -55,12 +54,11 @@ public class SaveEquipmentRfdl {
 
 
             //开始时间00:00:01
-            DateTime dateTime1 = startDateTime;
             //结束时间第二天00:00:01
             DateTime dateTime2 = DateUtil.offsetDay(startDateTime, 1);
 
             //8,通过适配器拿到一天的发电量数据,
-            List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+            List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, startDateTime.getTime(), dateTime2.getTime());
 
             //定义日发电量,先给0
             BigDecimal rfdl = new BigDecimal(0);
@@ -117,13 +115,13 @@ public class SaveEquipmentRfdl {
             meterInfoEquipment.setLineNemCode(thingId1.getLineId());
             meterInfoEquipment.setEquipmentNemCode(thingId1.getNemCode());
             meterInfoEquipment.setName(thingId1.getName());
-            meterInfoEquipment.setDate(dateTime1.toLocalDateTime());
+            meterInfoEquipment.setDate(startDateTime.toLocalDateTime());
             meterInfoEquipment.setUpdateTime(nowDateTime.toLocalDateTime());
             meterInfoEquipment.setRfdl(rfdl);
 
             //判断当前数据是否存在,更新或者插入
             QueryWrapper<MeterInfoEquipment> queryWrapper = new QueryWrapper<>();
-            queryWrapper.eq("equipment_nem_code", thingId1.getNemCode()).eq("date", dateTime1.toLocalDateTime());
+            queryWrapper.eq("equipment_nem_code", thingId1.getNemCode()).eq("date", startDateTime.toLocalDateTime());
             List<MeterInfoEquipment> list = meterInfoEquipmentService.list(queryWrapper);
             if (list.size() > 0) {
                 meterInfoEquipment.update(queryWrapper);
@@ -135,7 +133,56 @@ public class SaveEquipmentRfdl {
     }
 
 
-}
+    //项目期次风机总发电量
+    public void saveCalculatingFJFDL() {
+
+        //获取当前日期,当日开始时间
+        DateTime nowDateTime = DateUtil.parse(DateUtil.now());
+        DateTime startDateTime = DateUtil.beginOfDay(nowDateTime);
+
+        //1,所有期次发电量测点
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_QCFDL"));
+        System.out.println(meterPointList.size());
+
+        //遍历期次发电量测点,拿到项目期次ID
+        for (MeterPoint meterPoint : meterPointList) {
+            String projectId = meterPoint.getProjectId();
+
+            //开始时间00:00:01
+
+            //根据时间和项目期次ID查询设备日发电量表
+            List<MeterInfoEquipment> meterInfoEquipments = meterInfoEquipmentService.list(new QueryWrapper<MeterInfoEquipment>().eq("project_nem_code", projectId).eq("date", startDateTime));
+
+            //遍历累加取出的数据
+            BigDecimal bigDecimal = BigDecimal.valueOf(0);
+            for (MeterInfoEquipment meterInfoEquipment : meterInfoEquipments) {
+                bigDecimal = bigDecimal.add(meterInfoEquipment.getRfdl());
+            }
 
+            //存入MeterInfoCalculating表中,单位:万千瓦时
+            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(nowDateTime.toLocalDateTime());
+            meterInfoCalculating.setWindpowerstationId(meterPoint.getWindpowerstationId());
 
 
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("date", startDateTime.toLocalDateTime()).eq("code", meterPoint.getNemCode());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            System.out.println(list.size());
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+
+        }
+
+
+    }
+
+}

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

@@ -0,0 +1,775 @@
+package com.gyee.gaia.meter.service.meterinfo;
+
+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;
+import com.gyee.gaia.meter.entity.MeterPoint;
+import com.gyee.gaia.meter.service.impl.MeterInfoBottomcodeServiceImpl;
+import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
+import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 05: 19
+ **/
+@Service
+public class SaveFDL_Day_Month_Year {
+
+    @Resource
+    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    MeterInfoBottomcodeServiceImpl meterInfoBottomcodeService;
+
+
+    void saveLineFdl_Month() {
+
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_LINEFDL_MONTH"));
+        for (MeterPoint meterPoint : meterPointList) {
+            System.out.println(meterPoint.getName() + ":" + meterPoint);
+
+
+            //设置取值开始时间
+            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.DAYS.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.offsetDay(startDateTime, i);
+
+                MeterPoint meterPointLine = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("line_id", meterPoint.getLineId()).eq("uniform_code", "ZXYG"));
+                System.out.println(meterPointLine.getLineId());
+
+                //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+                MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("start_time", dateTime1.toLocalDateTime()).eq("code", meterPointLine.getNemCode()));
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoBottomcode != null) {
+                    monthValue = monthValue + meterInfoBottomcode.getDayValue().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).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
+            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 saveLineFdl_Year() {
+
+        List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_LINEFDL_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);
+
+        for (MeterPoint meterPoint : meterPointList) {
+            double yearValue = 0.0;
+
+            MeterPoint meterPointLine = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_LINEFDL_MONTH").eq("line_id", meterPoint.getLineId()));
+
+            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()).like("code", meterPointLine.getNemCode()));
+
+                //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                if (meterInfoCalculating != null) {
+                    yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                }
+            }
+
+
+//            if (meterPoint.getNemCode().endsWith("_L1_YEAR")) {
+//                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()).like("code", "%_LINEFDL_L1_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L2_YEAR")) {
+//                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", "%_LINEFDL_l2_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L3_YEAR")) {
+//                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", "%_LINEFDL_l3_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L4_YEAR")) {
+//                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", "%_LINEFDL_l4_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L5_YEAR")) {
+//                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", "%_LINEFDL_l5_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L6_YEAR")) {
+//                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", "%_LINEFDL_l6_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L7_YEAR")) {
+//                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", "%_LINEFDL_l7_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L8_YEAR")) {
+//                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", "%_LINEFDL_l8_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L9_YEAR")) {
+//                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", "%_LINEFDL_l9_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L10_YEAR")) {
+//                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", "%_LINEFDL_l10_MONTH"));
+//
+//                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+//                    if (meterInfoCalculating != null) {
+//                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+//                    }
+//                }
+//            } else if (meterPoint.getNemCode().endsWith("_L11_YEAR")) {
+//                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", "%_LINEFDL_l11_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();
+            }
+        }
+    }
+
+    void saveProjectFdl_Month() {
+
+        List<MeterPoint> meterPointJSD_ProjectFDL_MonthList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_PROJECTFDL_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.DAYS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPoint : meterPointJSD_ProjectFDL_MonthList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double monthValue = 0.0;
+
+            if (meterPoint.getNemCode().endsWith("_P1_MONTH")) {
+                for (int i = 0; i <= between; i++) {
+
+                    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", "%_JDXLFDL_P1"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculatingDay != null) {
+                        monthValue = monthValue + meterInfoCalculatingDay.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_P2_MONTH")) {
+
+                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", "%_JDXLFDL_P2"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculatingDay != null) {
+                        monthValue = monthValue + meterInfoCalculatingDay.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_P3_MONTH")) {
+                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", "%_JDXLFDL_P3"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculatingDay != null) {
+                        monthValue = monthValue + meterInfoCalculatingDay.getValue().doubleValue();
+                    }
+                }
+
+            } else if (meterPoint.getNemCode().endsWith("_P4_MONTH")) {
+                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", "%_JDXLFDL_P4"));
+
+                    //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 saveProjectFdl_Year() {
+
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_PROJECTFDL_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
+        for (MeterPoint meterPoint : meterPointJSD_NFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double yearValue = 0.0;
+
+            if (meterPoint.getNemCode().endsWith("_P1_YEAR")) {
+                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", "%_PROJECTFDL_P1_MONTH"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculating != null) {
+                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_P2_YEAR")) {
+                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", "%_PROJECTFDL_P2_MONTH"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculating != null) {
+                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_P3_YEAR")) {
+                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", "%_PROJECTFDL_P3_MONTH"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculating != null) {
+                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_P4_YEAR")) {
+                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", "%_PROJECTFDL_P4_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 savePowerstationFdl_Month() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_MONTH"));
+//        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_NFDL"));
+
+        //设置取值开始时间
+        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", "%_JDXLFDL_P0"));
+
+                //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_Year() {
+
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_POWERSTATIONFDL_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
+        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 saveWindStationFdl_Day() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCFDL_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", "%_JDXLFDL_P0"));
+            //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 saveWindStationFdl_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCFDL_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"));
+            //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 saveWindStationFdl_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCFDL_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_WINDSTATIONFDL_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.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();
+
+
+    }
+
+
+}

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

@@ -0,0 +1,497 @@
+package com.gyee.gaia.meter.service.meterinfo;
+
+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;
+import com.gyee.gaia.meter.entity.MeterPoint;
+import com.gyee.gaia.meter.service.impl.MeterInfoBottomcodeServiceImpl;
+import com.gyee.gaia.meter.service.impl.MeterInfoCalculatingServiceImpl;
+import com.gyee.gaia.meter.service.impl.MeterPointServiceImpl;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 05: 19
+ **/
+@Service
+public class SaveSWDL_Day_Month_Year {
+
+    @Resource
+    MeterInfoCalculatingServiceImpl meterInfoCalculatingService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    MeterInfoBottomcodeServiceImpl meterInfoBottomcodeService;
+
+
+    void saveSBSSwdl_Month() {
+
+        List<MeterPoint> meterPointJSD_ProjectFDL_MonthList = meterPointService.list(new QueryWrapper<MeterPoint>().like("property", "JSD_SBSSWDL_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.DAYS.between(day1, day2);
+
+        //2,meterPointJSD_YFDLList
+        for (MeterPoint meterPointJSD_SBSSWDL : meterPointJSD_ProjectFDL_MonthList) {
+
+
+            double monthValue = 0.0;
+            DateTime dateTime1 = DateTime.of(0);
+
+            if (meterPointJSD_SBSSWDL.getNemCode().endsWith("SWDL_SBS1_MONTH")) {
+
+                MeterPoint meterPointSBS = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("windpowerstation_id", meterPointJSD_SBSSWDL.getWindpowerstationId()).eq("uniform_code", "ZXYG").eq("meter_code", "111"));
+                for (int i = 0; i <= between; i++) {
+                    //开始时间00:00:01
+                    dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                    //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+                    MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointSBS.getNemCode()).eq("start_time", dateTime1.toLocalDateTime()));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoBottomcode != null) {
+                        monthValue = monthValue + meterInfoBottomcode.getDayValue().doubleValue();
+                    }
+                }
+            } else if (meterPointJSD_SBSSWDL.getNemCode().endsWith("SWDL_SBS2_MONTH")) {
+                MeterPoint meterPointSBS = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("windpowerstation_id", meterPointJSD_SBSSWDL.getWindpowerstationId()).eq("uniform_code", "ZXYG").eq("meter_code", "121"));
+                for (int i = 0; i <= between; i++) {
+                    //开始时间00:00:01
+                    dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                    //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+                    MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointSBS.getNemCode()).eq("start_time", dateTime1.toLocalDateTime()));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoBottomcode != null) {
+                        monthValue = monthValue + meterInfoBottomcode.getDayValue().doubleValue();
+                    }
+                }
+            } else if (meterPointJSD_SBSSWDL.getNemCode().endsWith("SWDL_SBS3_MONTH")) {
+                MeterPoint meterPointSBS = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("windpowerstation_id", meterPointJSD_SBSSWDL.getWindpowerstationId()).eq("uniform_code", "ZXYG").eq("meter_code", "151"));
+                for (int i = 0; i <= between; i++) {
+                    //开始时间00:00:01
+                    dateTime1 = DateUtil.offsetDay(startDateTime, i);
+
+                    //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+                    MeterInfoBottomcode meterInfoBottomcode = meterInfoBottomcodeService.getOne(new QueryWrapper<MeterInfoBottomcode>().eq("code", meterPointSBS.getNemCode()).eq("start_time", dateTime1.toLocalDateTime()));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoBottomcode != null) {
+                        monthValue = monthValue + meterInfoBottomcode.getDayValue().doubleValue();
+                    }
+                }
+            }
+
+
+            // 将每个场站的每个月的value值存入到MeterInfoCalculating
+            MeterInfoCalculating meterInfoCalculating = new MeterInfoCalculating();
+            meterInfoCalculating.setName(meterPointJSD_SBSSWDL.getName());
+            meterInfoCalculating.setCode(meterPointJSD_SBSSWDL.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).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_EVEN));
+            meterInfoCalculating.setUpdateTime(LocalDateTime.now());
+            meterInfoCalculating.setWindpowerstationId(meterPointJSD_SBSSWDL.getWindpowerstationId());
+
+            QueryWrapper<MeterInfoCalculating> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("code", meterPointJSD_SBSSWDL.getNemCode()).eq("date", dateTime1.toLocalDateTime().withDayOfMonth(1).withNano(0).withSecond(0).withMinute(0).withHour(0)).eq("windpowerstation_id", meterPointJSD_SBSSWDL.getWindpowerstationId());
+            List<MeterInfoCalculating> list = meterInfoCalculatingService.list(queryWrapper);
+            if (list.size() > 0) {
+                meterInfoCalculating.update(queryWrapper);
+            } else {
+                meterInfoCalculating.insert();
+            }
+
+
+        }
+    }
+
+    void saveSBSSwdl_Year() {
+
+        List<MeterPoint> meterPointJSD_NFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SBSSWDL_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
+        for (MeterPoint meterPoint : meterPointJSD_NFDLList) {
+
+            DateTime dateTime1 = DateTime.of(0);
+            double yearValue = 0.0;
+
+            if (meterPoint.getNemCode().endsWith("_SBS1_YEAR")) {
+                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", "%_SWDL_SBS1_MONTH"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculating != null) {
+                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_SBS2_YEAR")) {
+                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", "%_SWDL_SBS2_MONTH"));
+
+                    //MeterInfoCalculating,拿到每个记录的value值并累加到monthValue
+                    if (meterInfoCalculating != null) {
+                        yearValue = yearValue + meterInfoCalculating.getValue().doubleValue();
+                    }
+                }
+            } else if (meterPoint.getNemCode().endsWith("_SBS3_YEAR")) {
+                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", "%_SWDL_SBS3_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 savePowerstationSwdl_Month() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_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
+        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", "%SWDL_SBS%_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().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_Year() {
+
+        List<MeterPoint> meterPointJSD_YFDLList = meterPointService.list(new QueryWrapper<MeterPoint>().eq("property", "JSD_SWDL_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.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.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", "%SWDL_SBS%_YEAR"));
+
+                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 saveWindStationSwdl_Day() {
+
+        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);
+
+        double monthValue = 0.0;
+
+
+            //开始时间00:00:00
+
+            //根据每个场站的id,dateTime1,和集电线路总发电量的code拿到产站日发电量(集电线路项目期次侧)
+            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) {
+                    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().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", startDateTime.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 saveWindStationSwdl_Month() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCSWDL_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", "%_SWDL_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 saveWindStationSwdl_Year() {
+
+        MeterPoint meterPoint = meterPointService.getOne(new QueryWrapper<MeterPoint>().eq("property", "JSD_FCSWDL_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_FCSWDL_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();
+        this.saveSBSSwdl_Year();
+
+        this.savePowerstationSwdl_Month();
+        this.savePowerstationSwdl_Year();
+
+        this.saveWindStationSwdl_Day();
+        this.saveWindStationSwdl_Month();
+        this.saveWindStationSwdl_Year();
+
+
+    }
+
+
+}

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

@@ -6,9 +6,9 @@
 adapter.url=http://192.168.1.67:8011/ts
 
 #动态配置开始日期
-start.time=2023-04-01
+start.time=2023-05-01
 #动态配置结束日期
-end.time=2023-05-18
+end.time=2023-05-01
 
 meter.stations=MHS_FDC,NSS_FDC