Merge remote-tracking branch 'origin/master' into oracle_T001_202411121430

C00-common/pps-common/src/main/java/pps/core/common/constant/BusinessConstant.java

@@ -220,6 +220,11 @@ public class BusinessConstant {
      */
     public static final BigDecimal BIG_DECIMAL_0_6 = BigDecimal.valueOf(0.6);
 
+    /**
+     * 0.5
+     */
+    public static final BigDecimal BIG_DECIMAL_0_5 = BigDecimal.valueOf(0.5);
+
     /**
      * 0.4
      */

C10-task/pps-core-task/src/main/java/pps/core/task/job/SpaceYesterdayGreenRateJob.java

+package pps.core.task.job;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import pps.cloud.space.service.ISpaceYesterdayGreenRateCloudService;
+import pps.core.common.cache.TaskLockCache;
+import pps.core.task.constant.TaskConstant;
+import pps.core.task.utils.ServiceUtil;
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.base.exception.XServiceException;
+import xstartup.data.XServiceResult;
+import xstartup.service.job.XJob;
+import xstartup.service.job.annotation.XCronTrigger;
+
+/**
+ * 昨日绿电占比定时任务
+ *
+ * @author ZWT
+ * @date 2024/11/27 15:12
+ */
+@XText("长期间开优化定时任务")
+@XService
+public class SpaceYesterdayGreenRateJob implements XJob {
+
+    /**
+     * 每天00:30执行
+     *
+     * @param xContext x上下文
+     * @return {@link XServiceResult}
+     */
+    @XCronTrigger(value = TaskConstant.EVERY_DAY_30)
+    @Override
+    public XServiceResult execute(XContext xContext) {
+        xContext.getLogger().info("------ SpaceYesterdayGreenRateJob start:{}", DateUtil.date());
+        String key = TaskConstant.TASK_LOCK_KEY + "SpaceYesterdayGreenRateJob";
+        TaskLockCache exist = TaskLockCache.exist(xContext, key);
+        if (ObjectUtil.isNull(exist)) {
+            ServiceUtil.setCache(xContext, key);
+            try {
+                xContext.getBean(ISpaceYesterdayGreenRateCloudService.class)
+                        .yesterdayGreenRateJob(xContext)
+                        .throwIfFail();
+            } catch (XServiceException e) {
+                xContext.getLogger().error("------ SpaceYesterdayGreenRateJob XServiceException: ", e);
+            } finally {
+                xContext.getLogger().info("------ SpaceYesterdayGreenRateJob end:{}", DateUtil.date());
+                TaskLockCache.delete(xContext, key);
+            }
+        }
+        return XServiceResult.OK;
+    }
+}

C11-space/pps-cloud-space/src/main/java/pps/cloud/space/service/ISpaceYesterdayGreenRateCloudService.java

+package pps.cloud.space.service;
+
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+
+/**
+ * 昨日绿电占比Cloud模块
+ *
+ * @author ZWT
+ * @date 2024/11/27 15:13
+ */
+@XService
+@XText("昨日绿电占比Cloud模块")
+public interface ISpaceYesterdayGreenRateCloudService {
+
+    /**
+     * 昨日绿电占比定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @XText("昨日绿电占比定时任务")
+    XServiceResult yesterdayGreenRateJob(XContext context);
+}

C11-space/pps-core-space/src/main/java/pps/core/space/entity/SpaceYesterdayGreenRateEnt.java

+package pps.core.space.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import pps.core.common.entity.BaseModel;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 昨日绿电占比
+ *
+ * @author ZWT
+ * @date 2024/11/27
+ */
+@Data
+@TableName("space_yesterday_green_rate")
+public class SpaceYesterdayGreenRateEnt extends BaseModel implements Serializable {
+
+    @XText("井口ID")
+    @TableField
+    private String wellheadId;
+
+    @XText("井号")
+    @TableField
+    private String wellNumber;
+
+    @XText("记录日期")
+    @TableField
+    private Date recordDate;
+
+    @XText("启动顺序")
+    @TableField
+    private Integer startSeq;
+
+    @XText("井口每日用电量(优化前)")
+    @TableField
+    private BigDecimal wellTotalPowerActual;
+
+    @XText("井口每日用电量(优化后)")
+    @TableField
+    private BigDecimal wellTotalPowerOptimize;
+
+    @XText("井口每日光伏用电量(优化前)")
+    @TableField
+    private BigDecimal wellGreenPowerActual;
+
+    @XText("井口每日光伏用电量(优化后)")
+    @TableField
+    private BigDecimal wellGreenPowerOptimize;
+
+    @XText("绿电占比(优化前)")
+    @TableField
+    private BigDecimal greenPowerRateActual;
+
+    @XText("绿电占比(优化后)")
+    @TableField
+    private BigDecimal greenPowerRateOptimize;
+
+    @XText("线路名")
+    @TableField
+    private String lineName;
+
+    @XText("电费(优化前)")
+    @TableField
+    private BigDecimal powerCostActual;
+
+    @XText("电费(优化后)")
+    @TableField
+    private BigDecimal powerCostOptimize;
+
+    @XText("绿电市电电费(优化前)")
+    @TableField
+    private BigDecimal cityCostActual;
+
+    @XText("绿电市电电费(优化后)")
+    @TableField
+    private BigDecimal cityCostOptimize;
+}

C11-space/pps-core-space/src/main/java/pps/core/space/entity/SpaceYesterdayGreenRateView.java

+package pps.core.space.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import pps.core.common.entity.BaseModel;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 昨日绿电占比
+ *
+ * @author ZWT
+ * @date 2024/11/27
+ */
+@Data
+public class SpaceYesterdayGreenRateView extends BaseModel implements Serializable {
+
+    @XText("井口ID")
+    @TableField
+    private String wellheadId;
+
+    @XText("井号")
+    @TableField
+    private String wellNumber;
+
+    @XText("记录日期")
+    @TableField
+    private Date recordDate;
+
+    @XText("启动顺序")
+    @TableField
+    private Integer startSeq;
+
+    @XText("井口每日用电量(优化前)")
+    @TableField
+    private BigDecimal wellTotalPowerActual;
+
+    @XText("井口每日用电量(优化后)")
+    @TableField
+    private BigDecimal wellTotalPowerOptimize;
+
+    @XText("井口每日光伏用电量(优化前)")
+    @TableField
+    private BigDecimal wellGreenPowerActual;
+
+    @XText("井口每日光伏用电量(优化后)")
+    @TableField
+    private BigDecimal wellGreenPowerOptimize;
+
+    @XText("绿电占比(优化前)")
+    @TableField
+    private BigDecimal greenPowerRateActual;
+
+    @XText("绿电占比(优化后)")
+    @TableField
+    private BigDecimal greenPowerRateOptimize;
+
+    @XText("线路名")
+    @TableField
+    private String lineName;
+
+    @XText("电费(优化前)")
+    @TableField
+    private BigDecimal powerCostActual;
+
+    @XText("电费(优化后)")
+    @TableField
+    private BigDecimal powerCostOptimize;
+
+    @XText("绿电市电电费(优化前)")
+    @TableField
+    private BigDecimal cityCostActual;
+
+    @XText("绿电市电电费(优化后)")
+    @TableField
+    private BigDecimal cityCostOptimize;
+}

C11-space/pps-core-space/src/main/java/pps/core/space/mapper/SpaceOptimizeShortDurationViewMapper.java

@@ -38,4 +38,12 @@ public interface SpaceOptimizeShortDurationViewMapper {
      * @return {@link List }<{@link SpaceOptimizeShortDurationView }>
      */
     List<SpaceOptimizeShortDurationView> selectOptimizationResultList(SpaceOptimizeShortDurationView record);
+
+    /**
+     * 结果列表
+     *
+     * @param record 记录
+     * @return {@link List }<{@link SpaceOptimizeShortDurationView }>
+     */
+    List<SpaceOptimizeShortDurationView> selectResultList(SpaceOptimizeShortDurationView record);
 }

C11-space/pps-core-space/src/main/java/pps/core/space/mapper/SpaceYesterdayGreenRateMapper.java

+package pps.core.space.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+import pps.core.space.entity.SpaceYesterdayGreenRateEnt;
+
+/**
+ * 昨日绿电占比
+ *
+ * @author ZWT
+ * @date 2024/11/27
+ */
+@Repository(value = "pps.core.space.mapper.SpaceYesterdayGreenRateMapper")
+public interface SpaceYesterdayGreenRateMapper extends BaseMapper<SpaceYesterdayGreenRateEnt> {
+}

C11-space/pps-core-space/src/main/java/pps/core/space/mapper/SpaceYesterdayGreenRateViewMapper.java

+package pps.core.space.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+import pps.core.space.entity.SpaceYesterdayGreenRateView;
+
+import java.util.List;
+
+/**
+ * 昨日绿电占比
+ *
+ * @author ZWT
+ * @date 2024/11/27
+ */
+@Repository(value = "pps.core.space.mapper.SpaceYesterdayGreenRateViewMapper")
+public interface SpaceYesterdayGreenRateViewMapper {
+
+    SpaceYesterdayGreenRateView selectOne(SpaceYesterdayGreenRateView record);
+
+    List<SpaceYesterdayGreenRateView> selectList(SpaceYesterdayGreenRateView record);
+
+    /**
+     * 批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int batchInsert(@Param(value = "list") List<SpaceYesterdayGreenRateView> list);
+}

C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceInstitutionDetailService.java

@@ -14,6 +14,7 @@ import pps.cloud.base.service.data.base_power_line.GetBasePowerLineInput;
 import pps.cloud.base.service.data.base_power_line.GetBasePowerLineViewOutput;
 import pps.cloud.base.service.data.base_power_line_wellhead.DynamicQueryBasePowerLineWellheadInput;
 import pps.cloud.base.service.data.base_power_line_wellhead.DynamicQueryBasePowerLineWellheadViewOutput;
+import pps.cloud.space.service.ISpaceYesterdayGreenRateCloudService;
 import pps.core.common.constant.BusinessConstant;
 import pps.core.common.entity.BaseModel;
 import pps.core.common.session.PpsUserSession;
@@ -66,6 +67,8 @@ public class SpaceInstitutionDetailService extends SpaceOptimizeBaseService {
             bean1.optimizeMidJob(context);
             SpaceOptimizeShortCloudServiceImpl bean2 = context.getBean(SpaceOptimizeShortCloudServiceImpl.class);
             bean2.optimizeShortJob(context);
+            ISpaceYesterdayGreenRateCloudService yesterdayGreenRateCloudService = context.getBean(ISpaceYesterdayGreenRateCloudService.class);
+            yesterdayGreenRateCloudService.yesterdayGreenRateJob(context);
             context.getLogger().info("------------- optimize space end -------------");
         });
         return XServiceResult.OK;

C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeBaseService.java

@@ -270,7 +270,7 @@ public class SpaceOptimizeBaseService {
                     //计算权重
                     electricityCostList = this.electricityCostList(rangeToList, monthStrategyList);
                     Map<String, Object> objectObjectMap = this.setParams(powerGenerationList, electricityCostList, detail.getOptimizeType(), wellheadList);
-                    String post = HttpUtil.post("http://120.46.208.168:10060/api/gaponoff/plan?secretKey=fZ1kC1aV8bO7rH3bL8oE5zI0mY3vW1sG", objectObjectMap);
+                    String post = HttpUtil.post("http://127.0.0.1:10060/api/gaponoff/plan?secretKey=fZ1kC1aV8bO7rH3bL8oE5zI0mY3vW1sG", objectObjectMap);
                     List<OptimizeWellResult> resultList;
                     if (JSONUtil.isTypeJSON(post)) {
                         BaseResult result = JSONUtil.toBean(post, BaseResult.class);
@@ -1091,8 +1091,8 @@ public class SpaceOptimizeBaseService {
                     //查光伏预测
                     powerList = this.getAveragePower(context, DynamicQueryPlantPredictedPowerInput.builder()
                             .plantIds(plantIds)
-                            .startTime(DateUtil.offsetDay(begin, -1).toString(BusinessConstant.DATE_FORMAT_DAY))
-                            .endTime(begin.toString(BusinessConstant.DATE_FORMAT_DAY))
+                            .startTime(begin.toString(BusinessConstant.DATE_FORMAT_DAY))
+                            .endTime(DateUtil.offsetDay(begin, 1).toString(BusinessConstant.DATE_FORMAT_DAY))
                             .dateType(dateType)
                             .formatType(0)
                             .build());
@@ -2073,14 +2073,14 @@ public class SpaceOptimizeBaseService {
                     //封装能耗分析
                     if (effectMap.containsKey(w.getWellheadId())) {
                         effect = effectMap.get(w.getWellheadId());
-                        costDown = effect.getCostDown();
-                        //降低成本大于等于0才优化(1天/3天间开不处理结果)
-                        isOptimal = BusinessConstant.FOUR.equals(flag) || BusinessConstant.THREE.equals(flag) || costDown.compareTo(BigDecimal.ZERO) >= 0;
+                        greenPowerUpgrade = effect.getGreenPowerUpgrade();
+                        //绿电占比大于等于0才优化
+                        isOptimal = greenPowerUpgrade.compareTo(BigDecimal.ZERO) >= 0;
                         if (isOptimal) {
                             optimalResult = effect.getOptimalResult();
                             optimalGreenPowerRate = effect.getOptimalGreenPowerRate();
                             optimalPowerCost = effect.getOptimalPowerCost();
-                            greenPowerUpgrade = effect.getGreenPowerUpgrade();
+                            costDown = effect.getCostDown();
                         } else {
                             optimalResult = effect.getInstitutionResult();
                             optimalGreenPowerRate = effect.getGreenPowerRate();
@@ -2873,7 +2873,7 @@ public class SpaceOptimizeBaseService {
      * @param periodTypeKey 周期类型键
      * @return int
      */
-    private int getWeightByPeriodTypeKey(String periodTypeKey) {
+    public int getWeightByPeriodTypeKey(String periodTypeKey) {
         switch (periodTypeKey) {
             case BusinessConstant.PERIOD_TYPE_LOW:
                 return 5;

C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceYesterdayGreenRateCloudServiceImpl.java

+package pps.core.space.service;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateField;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
+import pps.cloud.base.service.data.base_price_strategy_detail.GetBasePriceStrategyDetailInput;
+import pps.cloud.base.service.data.base_price_strategy_detail.GetBasePriceStrategyDetailOutput;
+import pps.cloud.prediction.service.IPlantPredictedPowerCloudService;
+import pps.cloud.prediction.service.IThirdPowerCloudService;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewInput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewOutput;
+import pps.cloud.prediction.service.data.third_active_power.GetThirdActivePowerInput;
+import pps.cloud.prediction.service.data.third_active_power.GetThirdActivePowerOutput;
+import pps.cloud.space.service.ISpaceYesterdayGreenRateCloudService;
+import pps.core.common.constant.BusinessConstant;
+import pps.core.common.utils.BaseUtils;
+import pps.core.space.entity.SpaceOptimizeShortDurationView;
+import pps.core.space.entity.SpaceYesterdayGreenRateView;
+import pps.core.space.mapper.SpaceOptimizeShortDurationViewMapper;
+import pps.core.space.mapper.SpaceYesterdayGreenRateViewMapper;
+import pps.core.space.service.data.SpaceOptimizeWeight;
+import pps.core.space.utils.ServiceUtil;
+import xstartup.annotation.XService;
+import xstartup.base.XContext;
+import xstartup.data.XListResult;
+import xstartup.data.XServiceResult;
+import xstartup.helper.XTransactionHelper;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 昨日绿电占比Cloud模块
+ *
+ * @author ZWT
+ * @date 2024/11/27 15:17
+ */
+@XService
+public class SpaceYesterdayGreenRateCloudServiceImpl extends SpaceOptimizeBaseService implements ISpaceYesterdayGreenRateCloudService {
+
+    /**
+     * 昨日绿电占比
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult }
+     */
+    @Override
+    public XServiceResult yesterdayGreenRateJob(XContext context) {
+        //取昨日
+        DateTime beginOfYesterday = DateUtil.beginOfDay(DateUtil.yesterday());
+        //取昨日间开优化井
+        SpaceOptimizeShortDurationViewMapper spaceMapper = context.getBean(SpaceOptimizeShortDurationViewMapper.class);
+        List<SpaceOptimizeShortDurationView> durationViewList = spaceMapper.selectResultList(SpaceOptimizeShortDurationView.builder()
+                .optimizeDate(beginOfYesterday)
+                .build());
+        Map<String, Map<Integer, Map<Integer, List<SpaceOptimizeShortDurationView>>>> durationCollect;
+        Map<String, Map<Date, BigDecimal>> activeMap;
+        Map<String, Map<Date, BigDecimal>> predictionMap;
+        if (CollUtil.isEmpty(durationViewList)) {
+            durationCollect = Collections.emptyMap();
+            activeMap = Collections.emptyMap();
+            predictionMap = Collections.emptyMap();
+        } else {
+            //间开区间Map
+            durationCollect = durationViewList.stream()
+                    .collect(Collectors.groupingBy(SpaceOptimizeShortDurationView::getLineName,
+                                    Collectors.groupingBy(SpaceOptimizeShortDurationView::getStartSeq,
+                                            Collectors.groupingBy(SpaceOptimizeShortDurationView::getIsOptimize))
+                            )
+                    );
+            //取昨日实际发电功率
+            IThirdPowerCloudService cloudService = context.getBean(IThirdPowerCloudService.class);
+            XListResult<GetThirdActivePowerOutput> result = cloudService.queryPhotovoltaicPower30(context, GetThirdActivePowerInput.builder()
+                    .stationNames(durationCollect.keySet())
+                    .createDate(beginOfYesterday)
+                    .build());
+            result.throwIfFail();
+            List<GetThirdActivePowerOutput> powerList = result.getResult();
+            if (CollUtil.isEmpty(powerList)) {
+                activeMap = Collections.emptyMap();
+            } else {
+                activeMap = powerList.stream()
+                        .collect(Collectors.groupingBy(GetThirdActivePowerOutput::getStationName,
+                                Collectors.toMap(GetThirdActivePowerOutput::getCreateDate, GetThirdActivePowerOutput::getPhotovoltaicPower)));
+            }
+            //昨日预测发电功率
+            IPlantPredictedPowerCloudService service = context.getBean(IPlantPredictedPowerCloudService.class);
+            XListResult<GetPredictedPowerViewOutput> predictionResult = service.queryPredictionPower30(context, GetPredictedPowerViewInput.builder()
+                    .stationNames(durationCollect.keySet())
+                    .dataDate(beginOfYesterday)
+                    .build());
+            predictionResult.throwIfFail();
+            List<GetPredictedPowerViewOutput> predictionList = predictionResult.getResult();
+            if (CollUtil.isEmpty(predictionList)) {
+                predictionMap = Collections.emptyMap();
+            } else {
+                predictionMap = predictionList.stream()
+                        .collect(Collectors.groupingBy(GetPredictedPowerViewOutput::getStationName,
+                                Collectors.toMap(GetPredictedPowerViewOutput::getCreateTime, GetPredictedPowerViewOutput::getPredictPower)));
+            }
+        }
+        //查市电峰谷
+        List<GetBasePriceStrategyDetailOutput> strategyList = ServiceUtil.getStrategyDetailList(context, GetBasePriceStrategyDetailInput.builder()
+                .strategyMonth(String.valueOf(beginOfYesterday.monthBaseOne()))
+                .build());
+        //初始化时间轴
+        List<DateTime> rangeToList = DateUtil.rangeToList(DateUtil.offsetDay(BusinessConstant.DATE_FLAG, -1), BusinessConstant.DATE_FLAG, DateField.MINUTE, 30);
+        List<SpaceOptimizeShortDurationView> unOptimizeList;
+        List<SpaceOptimizeShortDurationView> optimizeList;
+        TreeMap<Integer, Map<Integer, List<SpaceOptimizeShortDurationView>>> wellSortMap;
+        SpaceOptimizeShortDurationView durationTemp;
+        List<SpaceYesterdayGreenRateView> batchList = new ArrayList<>(durationCollect.size() * 2);
+        SpaceOptimizeShortDurationView unOptimizeDuration;
+        SpaceOptimizeShortDurationView optimizeDuration;
+        DateTime openWellTime;
+        DateTime closeWellTime;
+        for (Map.Entry<String, Map<Integer, Map<Integer, List<SpaceOptimizeShortDurationView>>>> lineEntry : durationCollect.entrySet()) {
+            String lineName = lineEntry.getKey();
+            //初始化轴
+            Map<DateTime, SpaceOptimizeWeight> activeWeightMap = this.obtainTimeline(strategyList, rangeToList, activeMap.getOrDefault(lineName, Collections.emptyMap()));
+            Map<DateTime, SpaceOptimizeWeight> predictionWeightMap = this.obtainTimeline(strategyList, rangeToList, predictionMap.getOrDefault(lineName, Collections.emptyMap()));
+            //按顺序排
+            wellSortMap = new TreeMap<>(lineEntry.getValue());
+            BigDecimal sumServiceRating = BigDecimal.ZERO;
+            //计算结果
+            for (Map.Entry<Integer, Map<Integer, List<SpaceOptimizeShortDurationView>>> sortEntry : wellSortMap.entrySet()) {
+                //未优化间开
+                unOptimizeList = sortEntry.getValue().get(1);
+                if (CollUtil.isEmpty(unOptimizeList)) {
+                    continue;
+                }
+                BigDecimal wellGreenPowerActual = BigDecimal.ZERO;
+                BigDecimal wellGreenPowerOptimize = BigDecimal.ZERO;
+                BigDecimal runHourActual = BigDecimal.ZERO;
+                BigDecimal runHourOptimize = BigDecimal.ZERO;
+                BigDecimal powerCostActual = BigDecimal.ZERO;
+                BigDecimal powerCostOptimize = BigDecimal.ZERO;
+                BigDecimal cityCostActual = BigDecimal.ZERO;
+                BigDecimal cityCostOptimize = BigDecimal.ZERO;
+                durationTemp = unOptimizeList.get(0);
+                //累加运行功率
+                BigDecimal serviceRating = ObjectUtil.defaultIfNull(durationTemp.getServiceRating(), BigDecimal.ZERO);
+                sumServiceRating = sumServiceRating.add(serviceRating);
+                //优化后间开
+                optimizeList = sortEntry.getValue().get(0);
+                boolean optimizeListFlag = CollUtil.isNotEmpty(optimizeList);
+                int unOptimizeIndex = 0;
+                int optimizeIndex = 0;
+                boolean greenFlag = false;
+                //计算优化前后功率
+                for (DateTime dateTime : rangeToList) {
+                    BigDecimal greenPowerActual = BigDecimal.ZERO;
+                    BigDecimal greenPowerPrediction = BigDecimal.ZERO;
+                    //计算实际
+                    SpaceOptimizeWeight optimizeWeight = activeWeightMap.get(dateTime);
+                    BigDecimal activePower = optimizeWeight.getPower();
+                    unOptimizeDuration = unOptimizeList.get(unOptimizeIndex);
+                    //时间转换
+                    openWellTime = this.parseDateTime(unOptimizeDuration.getOpenWellTime());
+                    closeWellTime = this.parseDateTime(unOptimizeDuration.getCloseWellTime());
+                    if (DateUtil.compare(dateTime, openWellTime) >= 0 && DateUtil.compare(dateTime, closeWellTime) < 0) {
+                        //计算发电功率
+                        if (activePower.compareTo(BigDecimal.ZERO) <= 0) {
+                            //不管
+                        } else if (activePower.compareTo(serviceRating) >= 0) {
+                            greenFlag = true;
+                            //光伏发电功率大于运行负荷: 该时段光伏用电量量=运行负荷*0.5
+                            greenPowerActual = serviceRating.multiply(BusinessConstant.BIG_DECIMAL_0_5);
+                            wellGreenPowerActual = wellGreenPowerActual.add(greenPowerActual);
+                            activeWeightMap.get(dateTime).setPower(activePower.subtract(serviceRating));
+                        } else {
+                            greenFlag = true;
+                            //光伏发电功率-井口累计发电功率 : 小于等于0不管
+                            BigDecimal subtract = activePower.subtract(serviceRating);
+                            if (subtract.compareTo(BigDecimal.ZERO) > 0) {
+                                greenPowerActual = subtract;
+                                //光伏发电功率小于井的运行负荷: 该时段光伏用电量=光伏发电功率*0.5
+                                wellGreenPowerActual = wellGreenPowerActual.add(subtract.multiply(BusinessConstant.BIG_DECIMAL_0_5));
+                            }
+                            activeWeightMap.get(dateTime).setPower(BigDecimal.ZERO);
+                        }
+                        //累加开井时长
+                        runHourActual = runHourActual.add(BusinessConstant.BIG_DECIMAL_0_5);
+                        //计算电费(绿电没电费)
+                        if (greenFlag) {
+                            //绿电市电电费
+                            cityCostActual = cityCostActual.add(optimizeWeight.getElectricityPrice().multiply(greenPowerActual));
+                        } else {
+                            //市电峰谷电费
+                            powerCostActual = powerCostActual.add(optimizeWeight.getElectricityPrice().multiply(BusinessConstant.BIG_DECIMAL_0_5));
+                        }
+                    } else if (DateUtil.compare(dateTime, closeWellTime) >= 0) {
+                        unOptimizeIndex++;
+                    }
+                    if (unOptimizeIndex == unOptimizeList.size()) {
+                        unOptimizeIndex = unOptimizeList.size() - 1;
+                    }
+                    /*--------------------------------------------------*/
+                    greenFlag = false;
+                    if (optimizeListFlag) {
+                        SpaceOptimizeWeight predictionWeight = predictionWeightMap.get(dateTime);
+                        BigDecimal predictionPower = predictionWeight.getPower();
+                        optimizeDuration = optimizeList.get(optimizeIndex);
+                        //时间转换
+                        openWellTime = this.parseDateTime(optimizeDuration.getOpenWellTime());
+                        closeWellTime = this.parseDateTime(optimizeDuration.getCloseWellTime());
+                        if (DateUtil.compare(dateTime, openWellTime) >= 0 && DateUtil.compare(dateTime, closeWellTime) < 0) {
+                            //计算发电功率
+                            if (predictionPower.compareTo(BigDecimal.ZERO) <= 0) {
+                                //不管
+                            } else if (predictionPower.compareTo(sumServiceRating) >= 0) {
+                                greenFlag = true;
+                                //光伏发电功率大于运行负荷: 该时段光伏用电量量=运行负荷*0.5
+                                greenPowerPrediction = serviceRating.multiply(BusinessConstant.BIG_DECIMAL_0_5);
+                                wellGreenPowerOptimize = wellGreenPowerOptimize.add(greenPowerPrediction);
+                                predictionWeightMap.get(dateTime).setPower(predictionPower.subtract(serviceRating));
+                            } else {
+                                greenFlag = true;
+                                //光伏发电功率-井口累计发电功率 : 小于等于0不管
+                                BigDecimal subtract = predictionPower.subtract(serviceRating);
+                                if (subtract.compareTo(BigDecimal.ZERO) > 0) {
+                                    greenPowerPrediction = subtract;
+                                    //光伏发电功率小于井的运行负荷: 该时段光伏用电量=(光伏发电功率-井口累计发电功率+当前井口运行功率)*0.5
+                                    wellGreenPowerOptimize = wellGreenPowerOptimize.add(subtract.multiply(BusinessConstant.BIG_DECIMAL_0_5));
+                                }
+                                predictionWeightMap.get(dateTime).setPower(BigDecimal.ZERO);
+                            }
+                            //累加开井时长
+                            runHourOptimize = runHourOptimize.add(BusinessConstant.BIG_DECIMAL_0_5);
+                            //计算电费(绿电没电费)
+                            if (greenFlag) {
+                                //绿电市电电费
+                                cityCostOptimize = cityCostOptimize.add(optimizeWeight.getElectricityPrice().multiply(greenPowerPrediction));
+                            } else {
+                                //市电峰谷电费
+                                powerCostOptimize = powerCostOptimize.add(optimizeWeight.getElectricityPrice().multiply(BusinessConstant.BIG_DECIMAL_0_5));
+                            }
+                        } else if (DateUtil.compare(dateTime, closeWellTime) >= 0) {
+                            optimizeIndex++;
+                        }
+                        if (optimizeIndex == optimizeList.size()) {
+                            optimizeIndex = optimizeList.size() - 1;
+                        }
+                    }
+                }
+                //添加计算结果
+                BigDecimal wellTotalPowerActual = runHourActual.multiply(serviceRating);
+                BigDecimal wellTotalPowerOptimize = runHourOptimize.multiply(serviceRating);
+                SpaceYesterdayGreenRateView yesterdayGreenRateView = new SpaceYesterdayGreenRateView();
+                BaseUtils.setBaseModelDefaultForJob(yesterdayGreenRateView);
+                yesterdayGreenRateView.setRecordDate(beginOfYesterday);
+                yesterdayGreenRateView.setWellheadId(durationTemp.getWellheadId());
+                yesterdayGreenRateView.setWellNumber(durationTemp.getWellNumber());
+                yesterdayGreenRateView.setStartSeq(sortEntry.getKey());
+                yesterdayGreenRateView.setWellTotalPowerActual(wellTotalPowerActual);
+                yesterdayGreenRateView.setWellTotalPowerOptimize(wellTotalPowerOptimize);
+                yesterdayGreenRateView.setWellGreenPowerActual(wellGreenPowerActual);
+                yesterdayGreenRateView.setWellGreenPowerOptimize(wellGreenPowerOptimize);
+                yesterdayGreenRateView.setGreenPowerRateActual(BaseUtils.getRate(wellGreenPowerActual, wellTotalPowerActual));
+                yesterdayGreenRateView.setGreenPowerRateOptimize(BaseUtils.getRate(wellGreenPowerOptimize, wellTotalPowerOptimize));
+                yesterdayGreenRateView.setLineName(lineName);
+                yesterdayGreenRateView.setPowerCostActual(powerCostActual);
+                yesterdayGreenRateView.setPowerCostOptimize(powerCostOptimize);
+                yesterdayGreenRateView.setCityCostActual(cityCostActual);
+                yesterdayGreenRateView.setCityCostOptimize(cityCostOptimize);
+                batchList.add(yesterdayGreenRateView);
+            }
+        }
+        return XTransactionHelper.begin(context, () -> {
+            SpaceYesterdayGreenRateViewMapper mapper = context.getBean(SpaceYesterdayGreenRateViewMapper.class);
+            if (CollUtil.isNotEmpty(batchList)) {
+                if (batchList.size() > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceYesterdayGreenRateView>> subList = BaseUtils.getSubList(batchList);
+                    subList.forEach(mapper::batchInsert);
+                } else {
+                    mapper.batchInsert(batchList);
+                }
+            }
+            return XServiceResult.OK;
+        });
+    }
+
+
+    /**
+     * 获取时间线
+     *
+     * @param strategyList   战略列表
+     * @param rangeToList    要列出范围
+     * @param activePowerMap 有功功率图
+     * @return {@link Map }<{@link DateTime }, {@link SpaceOptimizeWeight }>
+     */
+    private Map<DateTime, SpaceOptimizeWeight> obtainTimeline(List<GetBasePriceStrategyDetailOutput> strategyList, List<DateTime> rangeToList, Map<Date, BigDecimal> activePowerMap) {
+        Map<DateTime, SpaceOptimizeWeight> weightMap = new HashMap<>(strategyList.size());
+        GetBasePriceStrategyDetailOutput strategy;
+        int strategyIndex = 0;
+        Date openTime;
+        Date closeTime;
+        SpaceOptimizeWeight weight;
+        DateTime dateTime;
+        for (int i = 0; i < rangeToList.size(); i++) {
+            dateTime = rangeToList.get(i);
+            weight = new SpaceOptimizeWeight();
+            weight.setPower(activePowerMap.getOrDefault(dateTime, BigDecimal.ZERO));
+            weight.setTimestamp(dateTime);
+            weight.setSort(i);
+            strategy = strategyList.get(strategyIndex);
+            openTime = strategy.getOpenTime();
+            closeTime = strategy.getCloseTime();
+            if (ObjectUtil.isNull(strategy.getCloseTime()) && CharSequenceUtil.equals(strategy.getEndTime(), BusinessConstant.END_OF_DAY_TIME)) {
+                closeTime = BusinessConstant.DATE_FLAG;
+            }
+            if (DateUtil.isIn(dateTime, openTime, closeTime)) {
+                weight.setWeight(super.getWeightByPeriodTypeKey(strategy.getPeriodTypeKey()));
+                weight.setElectricityPrice(strategy.getElectrovalence());
+                if (DateUtil.compare(dateTime, closeTime) == 0) {
+                    strategyIndex++;
+                }
+            } else {
+                strategyIndex++;
+            }
+            if (strategyIndex == strategyList.size()) {
+                strategyIndex = strategyList.size() - 1;
+            }
+            weightMap.put(dateTime, weight);
+        }
+        return weightMap;
+    }
+
+    /**
+     * 转换时间
+     *
+     * @param timeString 时间字符串
+     * @return {@link DateTime }
+     */
+    private DateTime parseDateTime(String timeString) {
+        DateTime wellTime;
+        if (CharSequenceUtil.equals(timeString, BusinessConstant.END_OF_DAY_TIME)) {
+            wellTime = BusinessConstant.DATE_FLAG;
+        } else {
+            wellTime = DateUtil.parse(timeString + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT);
+        }
+        return wellTime;
+    }
+}
\ No newline at end of file

C11-space/pps-core-space/src/main/java/pps/core/space/service/data/SpaceOptimizeWeight.java

@@ -59,4 +59,9 @@ public class SpaceOptimizeWeight {
      * 发电类型key
      */
     private String generationTypeKey;
+
+    /**
+     * 电价
+     */
+    private BigDecimal electricityPrice;
 }

C11-space/pps-core-space/src/main/resources/mybatis/mapper/pps/core/space/SpaceOptimizeShortDurationViewMapper.xml

@@ -159,4 +159,28 @@
                  S.START_SEQ,
                  D.OPEN_WELL_TIME
     </select>
+
+    <select id="selectResultList" resultMap="ExtendsResultMap"
+            parameterType="pps.core.space.entity.SpaceOptimizeShortDurationView">
+        SELECT p.line_id,
+               l.line_name,
+               w.well_number,
+               w.wellhead_id,
+               w.start_seq,
+               b.service_rating,
+               d.is_optimize,
+               d.open_well_time,
+               d.close_well_time
+        FROM space_optimize_short_period p
+                 JOIN base_power_line l ON p.line_id = l.id
+                 JOIN space_optimize_short_wellhead w ON p.id = w.short_period_id
+                 JOIN base_wellhead b ON w.wellhead_id = b.id
+                 JOIN space_optimize_short_duration d ON w.id = d.record_id
+        WHERE p.optimize_date = #{optimizeDate}
+        ORDER BY p.line_id,
+                 w.well_number,
+                 w.start_seq,
+                 d.is_optimize,
+                 d.open_well_time
+    </select>
 </mapper>
\ No newline at end of file

C11-space/pps-core-space/src/main/resources/mybatis/mapper/pps/core/space/SpaceYesterdayGreenRateViewMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="pps.core.space.mapper.SpaceYesterdayGreenRateViewMapper">
+    <resultMap id="BaseResultMap" type="pps.core.space.entity.SpaceYesterdayGreenRateView">
+        <id column="id" property="id" jdbcType="VARCHAR"/>
+        <result column="is_deleted" property="isDeleted" jdbcType="INTEGER"/>
+        <result column="create_by_id" property="createById" jdbcType="VARCHAR"/>
+        <result column="create_by_name" property="createByName" jdbcType="VARCHAR"/>
+        <result column="create_time" property="createTime" jdbcType="DATE"/>
+        <result column="modify_by_id" property="modifyById" jdbcType="VARCHAR"/>
+        <result column="modify_by_name" property="modifyByName" jdbcType="VARCHAR"/>
+        <result column="modify_time" property="modifyTime" jdbcType="DATE"/>
+        <result column="wellhead_id" property="wellheadId" jdbcType="VARCHAR"/>
+        <result column="well_number" property="wellNumber" jdbcType="VARCHAR"/>
+        <result column="record_date" property="recordDate" jdbcType="DATE"/>
+        <result column="start_seq" property="startSeq" jdbcType="INTEGER"/>
+        <result column="well_total_power_actual" property="wellTotalPowerActual" jdbcType="DECIMAL"/>
+        <result column="well_total_power_optimize" property="wellTotalPowerOptimize" jdbcType="DECIMAL"/>
+        <result column="well_green_power_actual" property="wellGreenPowerActual" jdbcType="DECIMAL"/>
+        <result column="well_green_power_optimize" property="wellGreenPowerOptimize" jdbcType="DECIMAL"/>
+        <result column="green_power_rate_actual" property="greenPowerRateActual" jdbcType="DECIMAL"/>
+        <result column="green_power_rate_optimize" property="greenPowerRateOptimize" jdbcType="DECIMAL"/>
+        <result column="line_name" property="lineName" jdbcType="VARCHAR"/>
+        <result column="power_cost_actual" property="powerCostActual" jdbcType="DECIMAL"/>
+        <result column="power_cost_optimize" property="powerCostOptimize" jdbcType="DECIMAL"/>
+        <result column="city_cost_optimize" property="cityCostOptimize" jdbcType="DECIMAL"/>
+        <result column="city_cost_optimize" property="cityCostOptimize" jdbcType="DECIMAL"/>
+    </resultMap>
+    <sql id="Base_Column_List">
+        id
+        ,
+    is_deleted,
+    create_by_id,
+    create_by_name,
+    create_time,
+    modify_by_id,
+    modify_by_name,
+    modify_time,
+    wellhead_id,
+    well_number,
+    record_date,
+    start_seq,
+    well_total_power_actual,
+    well_total_power_optimize,
+    well_green_power_actual,
+    well_green_power_optimize,
+    green_power_rate_actual,
+    green_power_rate_optimize,
+    line_name,
+    power_cost_actual,
+    power_cost_optimize,
+    city_cost_actual,
+    city_cost_optimize
+    </sql>
+    <select id="selectOne" parameterType="pps.core.space.entity.SpaceYesterdayGreenRateView" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from space_yesterday_green_rate
+        where
+        id=#{id}
+    </select>
+    <select id="selectList" parameterType="pps.core.space.entity.SpaceYesterdayGreenRateView" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from space_yesterday_green_rate
+        where
+        id=#{id}
+    </select>
+
+    <insert id="batchInsert" parameterType="list">
+        INSERT INTO space_yesterday_green_rate (id, create_by_id, create_by_name, create_time, modify_by_id,
+        modify_by_name, modify_time, wellhead_id, well_number, record_date, start_seq, well_total_power_actual,
+        well_total_power_optimize, well_green_power_actual, well_green_power_optimize, green_power_rate_actual,
+        green_power_rate_optimize, line_name, power_cost_actual, power_cost_optimize, city_cost_actual,
+        city_cost_optimize)
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.wellheadId},
+            #{item.wellNumber},
+            #{item.recordDate},
+            #{item.startSeq},
+            #{item.wellTotalPowerActual},
+            #{item.wellTotalPowerOptimize},
+            #{item.wellGreenPowerActual},
+            #{item.wellGreenPowerOptimize},
+            #{item.greenPowerRateActual},
+            #{item.greenPowerRateOptimize},
+            #{item.lineName},
+            #{item.powerCostActual},
+            #{item.powerCostOptimize},
+            #{item.cityCostActual},
+            #{item.cityCostOptimize}
+            )
+        </foreach>
+    </insert>
+</mapper>
\ No newline at end of file

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/IPlantPredictedPowerCloudService.java

@@ -2,6 +2,8 @@ package pps.cloud.prediction.service;
 
 import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerInput;
 import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerOutput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewInput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewOutput;
 import xstartup.annotation.XService;
 import xstartup.annotation.XText;
 import xstartup.base.XContext;
@@ -48,6 +50,16 @@ public interface IPlantPredictedPowerCloudService {
     @XText("光伏预测Cloud模块--获取每小时平均发电量列表")
     XListResult<DynamicQueryPlantPredictedPowerOutput> queryAveragePowerGenerationHourListByParam(XContext context, DynamicQueryPlantPredictedPowerInput input);
 
+    /**
+     * 光伏预测Cloud模块--每30分钟一天预测发电量
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult}<{@link DynamicQueryPlantPredictedPowerOutput}>
+     */
+    @XText("光伏预测Cloud模块--每30分钟一天预测发电量")
+    XListResult<GetPredictedPowerViewOutput> queryPredictionPower30(XContext context, GetPredictedPowerViewInput input);
+
     /**
      * 日耗电日产液信息定时任务
      *

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/IThirdPowerCloudService.java

@@ -31,6 +31,17 @@ public interface IThirdPowerCloudService {
     @XText("第三方Cloud模块--获得15分钟平均功率")
     XListResult<GetThirdActivePowerOutput> queryAvgPhotovoltaicPower(XContext context, GetThirdActivePowerInput input);
 
+    /**
+     * 获得30分钟实际功率
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult }<{@link GetThirdActivePowerOutput }>
+     */
+    @XText("第三方Cloud模块--获得15分钟平均功率")
+    XListResult<GetThirdActivePowerOutput> queryPhotovoltaicPower30(XContext context, GetThirdActivePowerInput input);
+
+
     /**
      * 查询每日井场日累计数据
      *

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/plant_predicted_power_data/GetPredictedPowerViewInput.java

+package pps.cloud.prediction.service.data.plant_predicted_power_data;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Date;
+
+/**
+ * 电站预测功率短期72小时数据
+ *
+ * @author ZWT
+ * @date 2024/11/28
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class GetPredictedPowerViewInput implements Serializable {
+
+    private static final long serialVersionUID = 6448506009773270723L;
+
+    @XText("电站名称")
+    private String stationName;
+
+    @XText("电站名称列表")
+    private Collection<String> stationNames;
+
+    @XText("时间")
+    private Date dataDate;
+}

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/plant_predicted_power_data/GetPredictedPowerViewOutput.java

+package pps.cloud.prediction.service.data.plant_predicted_power_data;
+
+import lombok.Data;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 电站预测功率短期72小时数据
+ *
+ * @author ZWT
+ * @date 2024/11/28
+ */
+@Data
+public class GetPredictedPowerViewOutput implements Serializable {
+
+    private static final long serialVersionUID = -1183112288004968421L;
+
+    @XText("日期")
+    private Date createTime;
+
+    @XText("预测发电量")
+    private BigDecimal predictPower;
+
+    @XText("电站名称")
+    private String stationName;
+}

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/third_active_power/GetThirdActivePowerInput.java

@@ -6,6 +6,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import xstartup.annotation.XText;
 
+import java.util.Collection;
 import java.util.Date;
 
 /**
@@ -20,9 +21,15 @@ import java.util.Date;
 @Builder
 public class GetThirdActivePowerInput {
 
+    @XText("电站名称")
+    private String stationName;
+
     @XText("创建时间")
     private Date createDate;
 
     @XText("来源系统")
     private String systemSource;
+
+    @XText("电站名称列表")
+    private Collection<String> stationNames;
 }

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/entity/PlantPredictedPowerShortTermView.java

+package pps.core.prediction.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.Date;
+
+/**
+ * 电站预测功率短期72小时数据
+ *
+ * @author ZWT
+ * @date 2024/11/28
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class PlantPredictedPowerShortTermView implements Serializable {
+
+    private static final long serialVersionUID = 3175283261612418065L;
+
+    @TableField
+    private Integer id;
+
+    @XText("线路id")
+    @TableField
+    private String plantId;
+
+    @XText("日期")
+    @TableField
+    private String dataDate;
+
+    @XText("预测功率")
+    @TableField
+    private BigDecimal power;
+
+    @XText("创建时间")
+    @TableField
+    private Date createTime;
+
+    @XText("预测发电量")
+    @TableField
+    private BigDecimal predictPower;
+
+    @XText("电站名称")
+    @TableField(exist = false)
+    private String stationName;
+
+    @XText("电站名称列表")
+    @TableField(exist = false)
+    private Collection<String> stationNames;
+
+    @XText("开始时间")
+    @TableField(exist = false)
+    private Date startTime;
+
+    @XText("结束时间")
+    @TableField(exist = false)
+    private Date endTime;
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/entity/ThirdActivePowerView.java

@@ -9,8 +9,8 @@ import xstartup.annotation.XText;
 
 import java.io.Serializable;
 import java.math.BigDecimal;
+import java.util.Collection;
 import java.util.Date;
-import java.util.List;
 
 /**
  * 第三方有功功率
@@ -61,7 +61,7 @@ public class ThirdActivePowerView implements Serializable {
 
     @XText("电站名称列表")
     @TableField(exist = false)
-    private List<String> stationNames;
+    private Collection<String> stationNames;
 
     @XText("开始时间")
     @TableField(exist = false)

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/mapper/PlantPredictedPowerShortTermViewMapper.java

+package pps.core.prediction.mapper;
+
+import org.springframework.stereotype.Repository;
+import pps.core.prediction.entity.PlantPredictedPowerShortTermView;
+
+import java.util.List;
+
+/**
+ * 电站预测功率短期72小时数据
+ *
+ * @author ZWT
+ * @date 2024/11/28
+ */
+@Repository(value = "pps.core.prediction.mapper.PlantPredictedPowerShortTermViewMapper")
+public interface PlantPredictedPowerShortTermViewMapper {
+
+    PlantPredictedPowerShortTermView selectOne(PlantPredictedPowerShortTermView record);
+
+    List<PlantPredictedPowerShortTermView> selectList(PlantPredictedPowerShortTermView record);
+
+    /**
+     * 查询预测发电量30分钟
+     *
+     * @param record 记录
+     * @return {@link List }<{@link PlantPredictedPowerShortTermView }>
+     */
+    List<PlantPredictedPowerShortTermView> selectPredictionPower30(PlantPredictedPowerShortTermView record);
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/mapper/ThirdActivePowerViewMapper.java

@@ -57,4 +57,13 @@ public interface ThirdActivePowerViewMapper {
      * @return {@link List }<{@link ThirdActivePowerView }>
      */
     List<ThirdActivePowerView> selectAvgPower15(ThirdActivePowerView record);
+
+
+    /**
+     * 获得30分钟实际功率
+     *
+     * @param record 记录
+     * @return {@link List }<{@link ThirdActivePowerView }>
+     */
+    List<ThirdActivePowerView> selectAvgPower30(ThirdActivePowerView record);
 }

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/service/EnergyConsumptionAnalysisService.java

@@ -1799,10 +1799,14 @@ public class EnergyConsumptionAnalysisService {
         BigDecimal defaultPower = CharSequenceUtil.equals(oilFieldCode, BusinessConstant.ENV_CQ) ? BigDecimal.ZERO : null;
         for (DateTime dateTime : rangeToList) {
             if (avgMap.containsKey(dateTime)) {
+                //用电*3
                 powerConsumption = avgMap.get(dateTime).setScale(2, RoundingMode.HALF_UP);
             } else {
                 powerConsumption = defaultPower;
             }
+            if (ObjectUtil.isNotNull(powerConsumption) && powerConsumption.compareTo(BigDecimal.ZERO) > 0) {
+                powerConsumption = powerConsumption.multiply(BigDecimal.valueOf(3));
+            }
             if (powerMap.containsKey(dateTime)) {
                 powerGeneration = powerMap.get(dateTime).setScale(2, RoundingMode.HALF_UP);
             } else {

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/service/HomePageService.java

@@ -336,7 +336,11 @@ public class HomePageService {
         BigDecimal powerConsumption;
         BigDecimal defaultPower = CharSequenceUtil.equals(oilFieldCode, BusinessConstant.ENV_CQ) ? BigDecimal.ZERO : null;
         for (DateTime dateTime : rangeToList) {
+            //用电*3
             powerConsumption = avgMap.getOrDefault(dateTime, defaultPower);
+            if (ObjectUtil.isNotNull(powerConsumption) && powerConsumption.compareTo(BigDecimal.ZERO) > 0) {
+                powerConsumption = powerConsumption.multiply(BigDecimal.valueOf(3));
+            }
             powerGeneration = powerMap.getOrDefault(dateTime, BigDecimal.ZERO);
             outputs.add(GetPowerAnalyseOutput.builder()
                     .dateFormat(dateTime.toString(BusinessConstant.DATE_FORMAT_ALL))
@@ -511,12 +515,19 @@ public class HomePageService {
             plantList = ServiceUtil.getBasePhotovoltaicPlantList(context, GetBasePhotovoltaicPlantCloudInput.builder()
                     .ouId(plantId)
                     .build());
+            if (CollUtil.isEmpty(plantList)) {
+                plantIds = CollUtil.list(false, plantId);
+            } else {
+                plantIds = plantList.stream()
+                        .map(GetBasePhotovoltaicPlantCloudOutput::getId)
+                        .collect(Collectors.toList());
+            }
         } else {
             plantList = this.getPlantList(context, ServiceUtil.getOrgIdsByPath(context, context.getSession(PpsUserSession.class).getOuId()));
+            plantIds = plantList.stream()
+                    .map(GetBasePhotovoltaicPlantCloudOutput::getId)
+                    .collect(Collectors.toList());
         }
-        plantIds = plantList.stream()
-                .map(GetBasePhotovoltaicPlantCloudOutput::getId)
-                .collect(Collectors.toList());
         DateTime date = DateUtil.date();
         DateTime day = DateUtil.beginOfDay(date);
         //判断是否需要启用演示配置

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/service/PlantPredictedPowerCloudServiceImpl.java

@@ -14,12 +14,16 @@ import pps.cloud.middle.service.data.wellhead_daily_production_situation.GetWell
 import pps.cloud.prediction.service.IPlantPredictedPowerCloudService;
 import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerInput;
 import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerOutput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewInput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.GetPredictedPowerViewOutput;
 import pps.core.auth.HttpRequestClient;
 import pps.core.common.constant.BusinessConstant;
 import pps.core.common.utils.BaseUtils;
 import pps.core.prediction.constant.ThirdPartyApiConstant;
+import pps.core.prediction.entity.PlantPredictedPowerShortTermView;
 import pps.core.prediction.entity.PredictedPowerView;
 import pps.core.prediction.entity.WellheadDailyProductionSituationView;
+import pps.core.prediction.mapper.PlantPredictedPowerShortTermViewMapper;
 import pps.core.prediction.mapper.PredictedPowerViewMapper;
 import pps.core.prediction.mapper.WellheadDailyProductionSituationViewMapper;
 import pps.core.prediction.service.data.wellhead_daily_production_situation.WellheadDailyProductionSituationJob;
@@ -172,6 +176,24 @@ public class PlantPredictedPowerCloudServiceImpl implements IPlantPredictedPower
         return XListResult.success(outputs);
     }
 
+    /**
+     * 光伏预测Cloud模块--每30分钟一天预测发电量
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult }<{@link GetPredictedPowerViewOutput }>
+     */
+    @Override
+    public XListResult<GetPredictedPowerViewOutput> queryPredictionPower30(XContext context, GetPredictedPowerViewInput input) {
+        PlantPredictedPowerShortTermViewMapper mapper = context.getBean(PlantPredictedPowerShortTermViewMapper.class);
+        return XListResult.success(XCopyUtils.copyNewList(mapper.selectPredictionPower30(PlantPredictedPowerShortTermView.builder()
+                        .stationNames(input.getStationNames())
+                        .startTime(input.getDataDate())
+                        .endTime(DateUtil.offsetDay(input.getDataDate(), 1))
+                        .build()),
+                GetPredictedPowerViewOutput.class));
+    }
+
     public XServiceResult test(XContext context) {
         List<WellheadDailyProductionSituationJob> list = null;
         IWellDailyProductionSituationCloudService service = context.getBean(IWellDailyProductionSituationCloudService.class);

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/service/ThirdPowerCloudServiceImpl.java

 package pps.core.prediction.service;
 
+import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.text.CharSequenceUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import pps.cloud.prediction.service.IThirdPowerCloudService;
@@ -15,6 +16,7 @@ import pps.core.prediction.entity.WellheadDailyProductionSituationEnt;
 import pps.core.prediction.mapper.ThirdActivePowerViewMapper;
 import pps.core.prediction.mapper.ThirdDailyAccumulationUpdateMapper;
 import pps.core.prediction.mapper.WellheadDailyProductionSituationMapper;
+import pps.core.prediction.utils.ServiceUtil;
 import xstartup.annotation.XService;
 import xstartup.annotation.XText;
 import xstartup.base.XContext;
@@ -50,6 +52,26 @@ public class ThirdPowerCloudServiceImpl implements IThirdPowerCloudService {
         return XListResult.success(XCopyUtils.copyNewList(list, GetThirdActivePowerOutput.class));
     }
 
+    /**
+     * 获得30分钟实际功率
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult }<{@link GetThirdActivePowerOutput }>
+     */
+    @Override
+    public XListResult<GetThirdActivePowerOutput> queryPhotovoltaicPower30(XContext context, GetThirdActivePowerInput input) {
+        ThirdActivePowerViewMapper mapper = context.getBean(ThirdActivePowerViewMapper.class);
+        List<ThirdActivePowerView> list = mapper.selectAvgPower30(ThirdActivePowerView.builder()
+                .stationName(input.getStationName())
+                .stationNames(input.getStationNames())
+                .systemSource(ServiceUtil.getOilFieldCode(context))
+                .startTime(input.getCreateDate())
+                .endTime(DateUtil.offsetDay(input.getCreateDate(), 1))
+                .build());
+        return XListResult.success(XCopyUtils.copyNewList(list, GetThirdActivePowerOutput.class));
+    }
+
     /**
      * 查询每日井场日累计数据
      *

C12-prediction/pps-core-prediction/src/main/resources/mybatis/mapper/pps/core/prediction/PlantPredictedPowerShortTermViewMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="pps.core.prediction.mapper.PlantPredictedPowerShortTermViewMapper">
+    <resultMap id="BaseResultMap" type="pps.core.prediction.entity.PlantPredictedPowerShortTermView">
+        <id column="id" property="id" jdbcType="INTEGER"/>
+        <result column="plant_id" property="plantId" jdbcType="VARCHAR"/>
+        <result column="data_date" property="dataDate" jdbcType="VARCHAR"/>
+        <result column="power" property="power" jdbcType="DECIMAL"/>
+        <result column="create_time" property="createTime" jdbcType="VARCHAR"/>
+        <result column="predict_power" property="predictPower" jdbcType="DECIMAL"/>
+    </resultMap>
+    <sql id="Base_Column_List">
+        id
+        ,
+    plant_id,
+    data_date,
+    power,
+    create_time,
+    predict_power
+    </sql>
+    <select id="selectOne" parameterType="pps.core.prediction.entity.PlantPredictedPowerShortTermView"
+            resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from plant_predicted_power_short_term
+        where
+        id=#{id}
+    </select>
+    <select id="selectList" parameterType="pps.core.prediction.entity.PlantPredictedPowerShortTermView"
+            resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from plant_predicted_power_short_term
+        where
+        id=#{id}
+    </select>
+
+    <resultMap id="ExtResultMap" type="pps.core.prediction.entity.PlantPredictedPowerShortTermView"
+               extends="BaseResultMap">
+        <result column="station_name" property="stationName" jdbcType="VARCHAR"/>
+    </resultMap>
+
+    <select id="selectPredictionPower30" parameterType="pps.core.prediction.entity.PlantPredictedPowerShortTermView"
+            resultMap="BaseResultMap">
+        SELECT
+        z.station_name,
+        z.data_date AS create_time,
+        MAX( z.predict_power ) AS predict_power
+        FROM
+        (
+        SELECT
+        l.line_name AS station_name,
+        CASE
+        WHEN MINUTE ( t.data_date ) &lt; 31 THEN
+        DATE_FORMAT( t.data_date, '%H:00:00' ) ELSE DATE_FORMAT( t.data_date, '%H:30:00' )
+        END data_date,
+        t.predict_power
+        FROM
+        base_power_line l
+        JOIN base_power_line_plant e ON l.id = e.line_id
+        JOIN base_photovoltaic_plant p ON p.id = e.plant_id
+        JOIN plant_predicted_power_short_term t ON p.id = t.plant_id
+        WHERE
+        t.data_date BETWEEN #{startTime}
+        AND #{endTime}
+        <if test="stationNames != null and stationNames.size() > 0">
+            AND l.line_name IN
+            <foreach collection="stationNames" item="item" open="(" separator="," close=")">
+                #{item}
+            </foreach>
+        </if>
+        ) z
+        GROUP BY
+        z.station_name,
+        z.data_date
+        ORDER BY
+        z.station_name,
+        z.data_date
+    </select>
+</mapper>
\ No newline at end of file

C12-prediction/pps-core-prediction/src/main/resources/mybatis/mapper/pps/core/prediction/ThirdActivePowerViewMapper.xml

@@ -199,4 +199,44 @@
         ORDER BY
         Z.INPUT_TIME
     </select>
+
+    <select id="selectAvgPower30" parameterType="pps.core.prediction.entity.ThirdActivePowerView"
+            resultMap="BaseResultMap">
+        SELECT z.station_name,
+        z.create_date,
+        MAX(z.photovoltaic_power) AS photovoltaic_power
+        FROM (SELECT l.line_name AS station_name,
+        CASE
+        WHEN MINUTE ( t.create_date) &lt; 31 THEN
+        DATE_FORMAT( t.create_date, '%H:00:00' ) ELSE DATE_FORMAT( t.create_date, '%H:30:00' )
+        END create_date ,
+        t.photovoltaic_power
+        FROM
+        base_power_line l
+        JOIN base_power_line_plant e ON l.id = e.line_id
+        JOIN base_photovoltaic_plant p ON p.id = e.plant_id
+        JOIN third_active_power t ON p.station_name = t.station_name
+        WHERE
+        t.create_date BETWEEN #{startTime}
+        AND #{endTime}
+        <if test="systemSource != null">
+            AND t.system_source = #{systemSource}
+        </if>
+        <if test="stationName != null and stationName != ''">
+            AND t.station_name = #{stationName}
+        </if>
+        <if test="stationNames != null and stationNames.size() > 0">
+            AND l.line_name IN
+            <foreach collection="stationNames" item="item" open="(" separator="," close=")">
+                #{item}
+            </foreach>
+        </if>
+        ) z
+        GROUP BY
+        z.station_name,
+        z.create_date
+        ORDER BY
+        z.station_name,
+        z.create_date
+    </select>
 </mapper>
\ No newline at end of file

D03-deploy/deploy-pps-all/src/main/java/app/DeployPpsAllApplication.java

@@ -45,6 +45,7 @@ public class DeployPpsAllApplication {
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceCalibrationJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeUltraJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeShortJob.class));
+        startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceYesterdayGreenRateJob.class));
         startup.run(args);
     }
 }

D03-deploy/deploy-pps-all/src/main/resources/deploy-pps-all.app.properties

@@ -16,6 +16,7 @@ x.job.service=pps.core.task.job.SpaceOptimizeLongJob,\
   pps.core.task.job.SpaceOptimizeMidJob,\
   pps.core.task.job.SpaceCalibrationJob,\
   pps.core.task.job.SpaceOptimizeShortJob,\
+  pps.core.task.job.SpaceYesterdayGreenRateJob,\
   pps.core.task.job.SpaceOptimizeUltraJob
 # redis
 x.cache.type=@x.cache.type@

D03-deploy/filters/filter-dev.properties

@@ -11,17 +11,17 @@ pps.core.system.login-config.appid=mEvc
 pps.core.common.base-config.predictedUrl=http://121.36.43.217:8098/
 #\u65E5\u5FD7\u7EA7\u522B\u914D\u7F6E
 x.log.level=debug
-x.log.directory=/home/gf-jar/log
+x.log.directory=/home/zero/zero-jar/logs
 # redis
 x.cache.type=redis
 x.cache.host=127.0.0.1
 x.cache.port=6379
-x.cache.auth=BJ8HiKUS_Rg=
+x.cache.auth=vwy69PQDfShqozf4ISXEoQ==
 x.cache.db=0
 # datasource
 x.db.sharding=1
 x.db.driver=com.mysql.jdbc.Driver
-x.db.url=jdbc:mysql://120.46.208.168:3306/gf_demo?allowPublicKeyRetrieval=true&characterEncoding=utf8&allowEncodingChanges=true&serverTimezone=Asia/Shanghai&useSSL=false
+x.db.url=jdbc:mysql://127.0.0.1:3306/zero_carbon?allowPublicKeyRetrieval=true&characterEncoding=utf8&allowEncodingChanges=true&serverTimezone=Asia/Shanghai&useSSL=false
 x.db.user=root
 x.db.password=vwy69PQDfShqozf4ISXEoQ==
 x.db.naming=snake-case
@@ -34,15 +34,14 @@ x.db.pps.core.middle.password=BJ8HiKUS_Rg=
 x.db.pps.core.middle.naming=snake-case
 x.db.pps.core.middle.databaseId=Oracle
 # \u81EA\u5B9A\u4E49\u914D\u7F6E
-#weather.file.temp.path=D:/home/weather/temp/receive
 weather.file.temp.path=/home/weather-jar/temp/receive
 weather.file.icon=/home/weather-jar/icon
 weather.mail.host=pop.qq.com
 weather.mail.username=2289169069@qq.com
-weather.mail.password=nkmvazsaaehneaed
+weather.mail.password=xiytzwcreqphdiga
 weather.mail.protocol=pop3
 #\u9996\u9875
-home.image.path=/home/gf-jar/homeImg
+home.image.path=/home/zero/zero-jar/homeImg
 #\u7B2C\u4E09\u65B9\u63A5\u53E3\u5730\u5740(\u957F\u5E86)
 third-party.chang-qing.url=http://10.78.7.253
 feature.swagger.enable=true
\ No newline at end of file