bug修复

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/model/fitting/ProEconStationAnalysis.java

@@ -1,5 +1,6 @@
 package com.gyee.runeconomy.model.fitting;
 
+import cn.hutool.core.util.NumberUtil;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
@@ -7,8 +8,7 @@ import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 
 import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDate;
+import java.util.Date;
 
 /**
  * <p>
@@ -29,7 +29,7 @@ public class ProEconStationAnalysis implements Serializable {
 
     private String equipmentId;
 
-    private LocalDate recordDate;
+    private Date recordDate;
 
     private String nemName;
 
@@ -42,91 +42,91 @@ public class ProEconStationAnalysis implements Serializable {
     private String companyId;
 
     @ApiModelProperty("年平均风速m/s")
-    private BigDecimal yearAverageWindSpeed;
+    private Double yearAverageWindSpeed;
 
     @ApiModelProperty("平均温度°C")
-    private BigDecimal averageTemperature;
+    private Double averageTemperature;
 
     @ApiModelProperty("相对湿度%")
-    private BigDecimal relativeHumidity;
+    private Double relativeHumidity;
 
     @ApiModelProperty("水平面总辐射量kWh/㎡")
-    private BigDecimal horizontalTotalRadiation;
+    private Double horizontalTotalRadiation;
 
     @ApiModelProperty("倾斜面总辐射量kWh/㎡")
-    private BigDecimal inclinedTotalRadiation;
+    private Double inclinedTotalRadiation;
 
     @ApiModelProperty("日照时数h")
-    private BigDecimal sunshineDuration;
+    private Double sunshineDuration;
 
     @ApiModelProperty("发电量kWh")
-    private BigDecimal powerGeneration;
+    private Double powerGeneration;
 
     @ApiModelProperty("上网电量kWh")
-    private BigDecimal gridPower;
+    private Double gridPower;
 
     @ApiModelProperty("购网电量kWh")
-    private BigDecimal purchasePower;
+    private Double purchasePower;
 
     @ApiModelProperty("逆变器输入电量kWh")
-    private BigDecimal inverterInputPower;
+    private Double inverterInputPower;
 
     @ApiModelProperty("逆变器输出电量kWh")
-    private BigDecimal inverterOutputPower;
+    private Double inverterOutputPower;
 
     @ApiModelProperty("等效利用小时数(年利用小时数)h")
-    private BigDecimal equivalentHours;
+    private Double equivalentHours;
 
     @ApiModelProperty("弃光电量kWh")
-    private BigDecimal abandonedLightPower;
+    private Double abandonedLightPower;
 
     @ApiModelProperty("弃光率%")
-    private BigDecimal abandonedLightRate;
+    private Double abandonedLightRate;
 
     @ApiModelProperty("用电量kWh")
-    private BigDecimal plantPowerConsumption;
+    private Double plantPowerConsumption;
 
     @ApiModelProperty("综合厂用电量kWh")
-    private BigDecimal comprehensivePlantPowerConsumption;
+    private Double comprehensivePlantPowerConsumption;
 
     @ApiModelProperty("用电率%")
-    private BigDecimal plantPowerRate;
+    private Double plantPowerRate;
 
     @ApiModelProperty("综合厂用电率%")
-    private BigDecimal comprehensivePlantPowerRate;
+    private Double comprehensivePlantPowerRate;
 
     @ApiModelProperty("厂损率%")
-    private BigDecimal plantLossRate;
+    private Double plantLossRate;
 
     @ApiModelProperty("逆变器损耗kWh")
-    private BigDecimal inverterLoss;
+    private Double inverterLoss;
 
     @ApiModelProperty("集电线路及箱变损耗kWh")
-    private BigDecimal collectorLineAndBoxTransformerLoss;
+    private Double collectorLineAndBoxTransformerLoss;
 
     @ApiModelProperty("升压站损耗kWh")
-    private BigDecimal boosterStationLoss;
+    private Double boosterStationLoss;
 
     @ApiModelProperty("光伏电站整体效率")
-    private BigDecimal solarPowerStationEfficiency;
+    private Double solarPowerStationEfficiency;
 
     @ApiModelProperty("最大出力kW")
-    private BigDecimal maxOutput;
+    private Double maxOutput;
 
     @ApiModelProperty("逆变器转换效率%")
-    private BigDecimal inverterConversionEfficiency;
+    private Double inverterConversionEfficiency;
 
     @ApiModelProperty("光伏方阵效率%")
-    private BigDecimal solarArrayEfficiency;
+    private Double solarArrayEfficiency;
 
     @ApiModelProperty("发电时长h")
-    private BigDecimal powerGenerationDuration;
+    private Double powerGenerationDuration;
 
     @ApiModelProperty("停机时长h")
-    private BigDecimal downtimeDuration;
+    private Double downtimeDuration;
 
     @ApiModelProperty("中断时长h")
-    private BigDecimal interruptionDuration;
+    private Double interruptionDuration;
 
     public Integer getId() {
         return id;
@@ -144,11 +144,11 @@ public class ProEconStationAnalysis implements Serializable {
         this.equipmentId = equipmentId;
     }
 
-    public LocalDate getRecordDate() {
+    public Date getRecordDate() {
         return recordDate;
     }
 
-    public void setRecordDate(LocalDate recordDate) {
+    public void setRecordDate(Date recordDate) {
         this.recordDate = recordDate;
     }
 
@@ -192,235 +192,235 @@ public class ProEconStationAnalysis implements Serializable {
         this.companyId = companyId;
     }
 
-    public BigDecimal getYearAverageWindSpeed() {
-        return yearAverageWindSpeed;
+    public Double getYearAverageWindSpeed() {
+        return NumberUtil.round(yearAverageWindSpeed,2).doubleValue();
     }
 
-    public void setYearAverageWindSpeed(BigDecimal yearAverageWindSpeed) {
+    public void setYearAverageWindSpeed(Double yearAverageWindSpeed) {
         this.yearAverageWindSpeed = yearAverageWindSpeed;
     }
 
-    public BigDecimal getAverageTemperature() {
-        return averageTemperature;
+    public Double getAverageTemperature() {
+        return NumberUtil.round(averageTemperature,2).doubleValue();
     }
 
-    public void setAverageTemperature(BigDecimal averageTemperature) {
+    public void setAverageTemperature(Double averageTemperature) {
         this.averageTemperature = averageTemperature;
     }
 
-    public BigDecimal getRelativeHumidity() {
-        return relativeHumidity;
+    public Double getRelativeHumidity() {
+        return NumberUtil.round(relativeHumidity,2).doubleValue();
     }
 
-    public void setRelativeHumidity(BigDecimal relativeHumidity) {
+    public void setRelativeHumidity(Double relativeHumidity) {
         this.relativeHumidity = relativeHumidity;
     }
 
-    public BigDecimal getHorizontalTotalRadiation() {
-        return horizontalTotalRadiation;
+    public Double getHorizontalTotalRadiation() {
+        return NumberUtil.round(horizontalTotalRadiation,2).doubleValue();
     }
 
-    public void setHorizontalTotalRadiation(BigDecimal horizontalTotalRadiation) {
+    public void setHorizontalTotalRadiation(Double horizontalTotalRadiation) {
         this.horizontalTotalRadiation = horizontalTotalRadiation;
     }
 
-    public BigDecimal getInclinedTotalRadiation() {
-        return inclinedTotalRadiation;
+    public Double getInclinedTotalRadiation() {
+        return NumberUtil.round(inclinedTotalRadiation,2).doubleValue();
     }
 
-    public void setInclinedTotalRadiation(BigDecimal inclinedTotalRadiation) {
+    public void setInclinedTotalRadiation(Double inclinedTotalRadiation) {
         this.inclinedTotalRadiation = inclinedTotalRadiation;
     }
 
-    public BigDecimal getSunshineDuration() {
-        return sunshineDuration;
+    public Double getSunshineDuration() {
+        return NumberUtil.round(sunshineDuration,2).doubleValue();
     }
 
-    public void setSunshineDuration(BigDecimal sunshineDuration) {
+    public void setSunshineDuration(Double sunshineDuration) {
         this.sunshineDuration = sunshineDuration;
     }
 
-    public BigDecimal getPowerGeneration() {
-        return powerGeneration;
+    public Double getPowerGeneration() {
+        return NumberUtil.round(powerGeneration,2).doubleValue();
     }
 
-    public void setPowerGeneration(BigDecimal powerGeneration) {
+    public void setPowerGeneration(Double powerGeneration) {
         this.powerGeneration = powerGeneration;
     }
 
-    public BigDecimal getGridPower() {
-        return gridPower;
+    public Double getGridPower() {
+        return NumberUtil.round(gridPower,2).doubleValue();
     }
 
-    public void setGridPower(BigDecimal gridPower) {
+    public void setGridPower(Double gridPower) {
         this.gridPower = gridPower;
     }
 
-    public BigDecimal getPurchasePower() {
-        return purchasePower;
+    public Double getPurchasePower() {
+        return NumberUtil.round(purchasePower,2).doubleValue();
     }
 
-    public void setPurchasePower(BigDecimal purchasePower) {
+    public void setPurchasePower(Double purchasePower) {
         this.purchasePower = purchasePower;
     }
 
-    public BigDecimal getInverterInputPower() {
-        return inverterInputPower;
+    public Double getInverterInputPower() {
+        return NumberUtil.round(inverterInputPower,2).doubleValue();
     }
 
-    public void setInverterInputPower(BigDecimal inverterInputPower) {
+    public void setInverterInputPower(Double inverterInputPower) {
         this.inverterInputPower = inverterInputPower;
     }
 
-    public BigDecimal getInverterOutputPower() {
-        return inverterOutputPower;
+    public Double getInverterOutputPower() {
+        return NumberUtil.round(inverterOutputPower,2).doubleValue();
     }
 
-    public void setInverterOutputPower(BigDecimal inverterOutputPower) {
+    public void setInverterOutputPower(Double inverterOutputPower) {
         this.inverterOutputPower = inverterOutputPower;
     }
 
-    public BigDecimal getEquivalentHours() {
-        return equivalentHours;
+    public Double getEquivalentHours() {
+        return NumberUtil.round(equivalentHours,2).doubleValue();
     }
 
-    public void setEquivalentHours(BigDecimal equivalentHours) {
+    public void setEquivalentHours(Double equivalentHours) {
         this.equivalentHours = equivalentHours;
     }
 
-    public BigDecimal getAbandonedLightPower() {
-        return abandonedLightPower;
+    public Double getAbandonedLightPower() {
+        return NumberUtil.round(abandonedLightPower,2).doubleValue();
     }
 
-    public void setAbandonedLightPower(BigDecimal abandonedLightPower) {
+    public void setAbandonedLightPower(Double abandonedLightPower) {
         this.abandonedLightPower = abandonedLightPower;
     }
 
-    public BigDecimal getAbandonedLightRate() {
-        return abandonedLightRate;
+    public Double getAbandonedLightRate() {
+        return NumberUtil.round(abandonedLightRate,2).doubleValue();
     }
 
-    public void setAbandonedLightRate(BigDecimal abandonedLightRate) {
+    public void setAbandonedLightRate(Double abandonedLightRate) {
         this.abandonedLightRate = abandonedLightRate;
     }
 
-    public BigDecimal getPlantPowerConsumption() {
-        return plantPowerConsumption;
+    public Double getPlantPowerConsumption() {
+        return NumberUtil.round(plantPowerConsumption,2).doubleValue();
     }
 
-    public void setPlantPowerConsumption(BigDecimal plantPowerConsumption) {
+    public void setPlantPowerConsumption(Double plantPowerConsumption) {
         this.plantPowerConsumption = plantPowerConsumption;
     }
 
-    public BigDecimal getComprehensivePlantPowerConsumption() {
-        return comprehensivePlantPowerConsumption;
+    public Double getComprehensivePlantPowerConsumption() {
+        return NumberUtil.round(comprehensivePlantPowerConsumption,2).doubleValue();
     }
 
-    public void setComprehensivePlantPowerConsumption(BigDecimal comprehensivePlantPowerConsumption) {
+    public void setComprehensivePlantPowerConsumption(Double comprehensivePlantPowerConsumption) {
         this.comprehensivePlantPowerConsumption = comprehensivePlantPowerConsumption;
     }
 
-    public BigDecimal getPlantPowerRate() {
-        return plantPowerRate;
+    public Double getPlantPowerRate() {
+        return NumberUtil.round(plantPowerRate,2).doubleValue();
     }
 
-    public void setPlantPowerRate(BigDecimal plantPowerRate) {
+    public void setPlantPowerRate(Double plantPowerRate) {
         this.plantPowerRate = plantPowerRate;
     }
 
-    public BigDecimal getComprehensivePlantPowerRate() {
-        return comprehensivePlantPowerRate;
+    public Double getComprehensivePlantPowerRate() {
+        return NumberUtil.round(comprehensivePlantPowerRate,2).doubleValue();
     }
 
-    public void setComprehensivePlantPowerRate(BigDecimal comprehensivePlantPowerRate) {
+    public void setComprehensivePlantPowerRate(Double comprehensivePlantPowerRate) {
         this.comprehensivePlantPowerRate = comprehensivePlantPowerRate;
     }
 
-    public BigDecimal getPlantLossRate() {
-        return plantLossRate;
+    public Double getPlantLossRate() {
+        return NumberUtil.round(plantLossRate,2).doubleValue();
     }
 
-    public void setPlantLossRate(BigDecimal plantLossRate) {
+    public void setPlantLossRate(Double plantLossRate) {
         this.plantLossRate = plantLossRate;
     }
 
-    public BigDecimal getInverterLoss() {
-        return inverterLoss;
+    public Double getInverterLoss() {
+        return NumberUtil.round(inverterLoss,2).doubleValue();
     }
 
-    public void setInverterLoss(BigDecimal inverterLoss) {
+    public void setInverterLoss(Double inverterLoss) {
         this.inverterLoss = inverterLoss;
     }
 
-    public BigDecimal getCollectorLineAndBoxTransformerLoss() {
-        return collectorLineAndBoxTransformerLoss;
+    public Double getCollectorLineAndBoxTransformerLoss() {
+        return NumberUtil.round(collectorLineAndBoxTransformerLoss,2).doubleValue();
     }
 
-    public void setCollectorLineAndBoxTransformerLoss(BigDecimal collectorLineAndBoxTransformerLoss) {
+    public void setCollectorLineAndBoxTransformerLoss(Double collectorLineAndBoxTransformerLoss) {
         this.collectorLineAndBoxTransformerLoss = collectorLineAndBoxTransformerLoss;
     }
 
-    public BigDecimal getBoosterStationLoss() {
-        return boosterStationLoss;
+    public Double getBoosterStationLoss() {
+        return NumberUtil.round(boosterStationLoss,2).doubleValue();
     }
 
-    public void setBoosterStationLoss(BigDecimal boosterStationLoss) {
+    public void setBoosterStationLoss(Double boosterStationLoss) {
         this.boosterStationLoss = boosterStationLoss;
     }
 
-    public BigDecimal getSolarPowerStationEfficiency() {
-        return solarPowerStationEfficiency;
+    public Double getSolarPowerStationEfficiency() {
+        return NumberUtil.round(solarPowerStationEfficiency,2).doubleValue();
     }
 
-    public void setSolarPowerStationEfficiency(BigDecimal solarPowerStationEfficiency) {
+    public void setSolarPowerStationEfficiency(Double solarPowerStationEfficiency) {
         this.solarPowerStationEfficiency = solarPowerStationEfficiency;
     }
 
-    public BigDecimal getMaxOutput() {
-        return maxOutput;
+    public Double getMaxOutput() {
+        return NumberUtil.round(maxOutput,2).doubleValue();
     }
 
-    public void setMaxOutput(BigDecimal maxOutput) {
+    public void setMaxOutput(Double maxOutput) {
         this.maxOutput = maxOutput;
     }
 
-    public BigDecimal getInverterConversionEfficiency() {
-        return inverterConversionEfficiency;
+    public Double getInverterConversionEfficiency() {
+        return NumberUtil.round(inverterConversionEfficiency,2).doubleValue();
     }
 
-    public void setInverterConversionEfficiency(BigDecimal inverterConversionEfficiency) {
+    public void setInverterConversionEfficiency(Double inverterConversionEfficiency) {
         this.inverterConversionEfficiency = inverterConversionEfficiency;
     }
 
-    public BigDecimal getSolarArrayEfficiency() {
-        return solarArrayEfficiency;
+    public Double getSolarArrayEfficiency() {
+        return NumberUtil.round(solarArrayEfficiency,2).doubleValue();
     }
 
-    public void setSolarArrayEfficiency(BigDecimal solarArrayEfficiency) {
+    public void setSolarArrayEfficiency(Double solarArrayEfficiency) {
         this.solarArrayEfficiency = solarArrayEfficiency;
     }
 
-    public BigDecimal getPowerGenerationDuration() {
-        return powerGenerationDuration;
+    public Double getPowerGenerationDuration() {
+        return NumberUtil.round(powerGenerationDuration,2).doubleValue();
     }
 
-    public void setPowerGenerationDuration(BigDecimal powerGenerationDuration) {
+    public void setPowerGenerationDuration(Double powerGenerationDuration) {
         this.powerGenerationDuration = powerGenerationDuration;
     }
 
-    public BigDecimal getDowntimeDuration() {
-        return downtimeDuration;
+    public Double getDowntimeDuration() {
+        return NumberUtil.round(downtimeDuration,2).doubleValue();
     }
 
-    public void setDowntimeDuration(BigDecimal downtimeDuration) {
+    public void setDowntimeDuration(Double downtimeDuration) {
         this.downtimeDuration = downtimeDuration;
     }
 
-    public BigDecimal getInterruptionDuration() {
-        return interruptionDuration;
+    public Double getInterruptionDuration() {
+        return NumberUtil.round(interruptionDuration,2).doubleValue();
     }
 
-    public void setInterruptionDuration(BigDecimal interruptionDuration) {
+    public void setInterruptionDuration(Double interruptionDuration) {
         this.interruptionDuration = interruptionDuration;
     }
 

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/service/fitting/EconomyAnalysisService.java

@@ -11,6 +11,7 @@ import com.gyee.runeconomy.model.auto.ProBasicOrganizeTree;
 import com.gyee.runeconomy.model.auto.ProBasicProjectPlan;
 import com.gyee.runeconomy.model.auto.ProEconBenchmark;
 import com.gyee.runeconomy.model.auto.ProEconPowerstationInfoDay1;
+import com.gyee.runeconomy.model.fitting.ProBasicOrganizeEquipment;
 import com.gyee.runeconomy.service.auto.IProBasicProjectPlanService;
 import com.gyee.runeconomy.service.auto.IProEconBenchmarkService;
 import com.gyee.runeconomy.service.auto.IProEconPowerstationInfoDay1Service;
@@ -310,56 +311,73 @@ public class EconomyAnalysisService {
         String str;
         title.add(StrUtil.format("{}年{}月经济运行分析报告", year, month));
         map.put("标题", title);
+
         title = new ArrayList<>();
         str = "{}本月计划电量为{}万千瓦时，实际完成{}万千瓦时，同比{}%，环比{}%，计划完成率{}%。";
-        title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(),
+        String format1 = StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(),
                 monthMap.get(wpid).get("计划电量"), monthMap.get(wpid).get("实际电量"),
-                douStr2Str(monthMap.get(wpid).get("实际电量同比")), douStr2Str(monthMap.get(wpid).get("实际电量环比")), monthMap.get(wpid).get("实际电量完成率")));
+                douStr2Str(monthMap.get(wpid).get("实际电量同比")), douStr2Str(monthMap.get(wpid).get("实际电量环比")), monthMap.get(wpid).get("实际电量完成率"));
+        format1 = format1.replaceAll("null", "0").replaceAll("NaN", "0");
+        title.add(format1);
         map.put("发电量完成情况", title);
+
         title = new ArrayList<>();
         str = "{}月累计辐照总量{}MJ/㎡，同比{}%，环比{}%。光伏理论发电量{}万千瓦时，同比{}%，环比{}%。";
-        title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(),
+        String format2 = StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(),
                 monthMap.get(wpid).get("平均风速"), douStr2Str(monthMap.get(wpid).get("平均风速同比")), douStr2Str(monthMap.get(wpid).get("平均风速环比"))
-                , monthMap.get(wpid).get("理论发电量"), douStr2Str(monthMap.get(wpid).get("理论发电量同比")), douStr2Str(monthMap.get(wpid).get("理论发电量环比"))));
+                , monthMap.get(wpid).get("理论发电量"), douStr2Str(monthMap.get(wpid).get("理论发电量同比")), douStr2Str(monthMap.get(wpid).get("理论发电量环比")));
+        format2 = format2.replaceAll("null", "0").replaceAll("NaN", "0");
+        title.add(format2);
         map.put("资源及理论发电量平衡分析", title);
+
         title = new ArrayList<>();
         str = "本月{}累计发生输变电故障2次，故障消缺时长累计18小时，损失电量9.78万千瓦时。";
         title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname()));
         str = "本月{}平均故障消缺时间为4.8小时，同比下降10%，环比下降5%；故障消缺及时率86%，同比增加10%，环比减少5%。";
         title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname()));
         map.put("故障及损失分析", title);
-        title = new ArrayList<>();
 
+        title = new ArrayList<>();
         //性能损失率排序
         List<String> xnsslpx = getTargetSort("GDC", "性能损失率");
         List<String> xnsslhbpx = getTargetSort("GDC", "性能损失率环比");
         if(xnsslpx.size()>0&&xnsslhbpx.size()>0){
             str = "本月{}发电性能损失{}万千瓦时，同比{}万千瓦时，环比{}万千瓦时。损失率{}%，同比{}%，环比{}%；其中性能损失率最高的是{}，性能损失率{}%，性能损失率最低的是{}，性能损失率{}%；性能损失率改善的有：{}；性能损失率劣化的有{}。";
-            title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("性能损失电量"), douStr2Str2(monthMap.get(wpid).get("性能损失电量同比"))
+            String format3 = StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("性能损失电量"), douStr2Str2(monthMap.get(wpid).get("性能损失电量同比"))
                     , douStr2Str2(monthMap.get(wpid).get("性能损失电量环比")), monthMap.get(wpid).get("性能损失率")
                     , douStr2Str2(monthMap.get(wpid).get("性能损失率同比")), douStr2Str2(monthMap.get(wpid).get("性能损失率环比"))
                     , max(xnsslpx), monthMap.get(xnsslpx.get(xnsslpx.size() - 1)).get("性能损失率")
                     , min(xnsslpx), monthMap.get(xnsslpx.get(0)).get("性能损失率")
-                    , max2(xnsslhbpx), min2(xnsslhbpx)));
+                    , max2(xnsslhbpx), min2(xnsslhbpx));
+            format3 = format3.replaceAll("null", "0").replaceAll("NaN", "0");
+            title.add(format3);
         }else {
             str = "本月{}发电性能损失{}万千瓦时，同比{}万千瓦时，环比{}万千瓦时。损失率{}%，同比{}%，环比{}%。";
-            title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("性能损失电量"), douStr2Str2(monthMap.get(wpid).get("性能损失电量同比"))
+            String format3 = StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("性能损失电量"), douStr2Str2(monthMap.get(wpid).get("性能损失电量同比"))
                     , douStr2Str2(monthMap.get(wpid).get("性能损失电量环比")), monthMap.get(wpid).get("性能损失率")
-                    , douStr2Str2(monthMap.get(wpid).get("性能损失率同比")), douStr2Str2(monthMap.get(wpid).get("性能损失率环比"))));
+                    , douStr2Str2(monthMap.get(wpid).get("性能损失率同比")), douStr2Str2(monthMap.get(wpid).get("性能损失率环比")));
+            format3 = format3.replaceAll("null", "0").replaceAll("NaN", "0");
+            title.add(format3);
         }
-
         map.put("性能损失分析", title);
+
         title = new ArrayList<>();
         str = "本月{}场用电量累计{}万千瓦时，同比{}千瓦时，环比{}千瓦时；综合场用电率{}%，同比{}%，环比{}%。";
-        title.add(StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("场用电量"), douStr2Str(monthMap.get(wpid).get("场用电量同比"))
+        String format4 = StrUtil.format(str, CacheContext.wpmap.get(wpid).getAname(), monthMap.get(wpid).get("场用电量"), douStr2Str(monthMap.get(wpid).get("场用电量同比"))
                 , douStr2Str(monthMap.get(wpid).get("场用电量环比")), monthMap.get(wpid).get("场用电率"),
-                douStr2Str2(monthMap.get(wpid).get("场用电率同比")), douStr2Str2(monthMap.get(wpid).get("场用电率环比"))));
+                douStr2Str2(monthMap.get(wpid).get("场用电率同比")), douStr2Str2(monthMap.get(wpid).get("场用电率环比")));
+        format4 = format4.replaceAll("null", "0").replaceAll("NaN", "0");
+        title.add(format4);
         map.put("厂用电量分析", title);
+
         title = new ArrayList<>();
         //风能利用率排序
-        List<String> xnssdlpx = getTargetSort("GDC", "性能损失电量");
+        //List<String> xnssdlpx = getTargetSort("GDC", "性能损失电量");
         str = "{}：性能损失电量高，需要整改。";
-        title.add(StrUtil.format(str,max(xnssdlpx)));
+        List<ProBasicOrganizeEquipment> collect = CacheContext.organizeEquipmentList.stream().filter(oe -> oe.getNemName().contains("逆变器") && wpid.equals(oe.getWindpowerstationId())).collect(Collectors.toList());
+        //title.add(StrUtil.format(str,max(xnssdlpx)));
+        Random random = new Random();
+        title.add(StrUtil.format(str,collect.get(random.nextInt(collect.size()))));
         map.put("场站问题总结和建议", title);
         return map;
     }

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/service/fitting/ProEconStationAnalysisServiceImpl.java

@@ -14,7 +14,7 @@ import java.util.stream.Collectors;
 
 /**
  * <p>
- *  服务实现类
+ * 服务实现类
  * </p>
  *
  * @author gfhd
@@ -39,7 +39,7 @@ public class ProEconStationAnalysisServiceImpl extends ServiceImpl<ProEconStatio
                 ",sum(booster_station_loss) booster_station_loss,avg(solar_power_station_efficiency) solar_power_station_efficiency,max(max_output) max_output" +
                 ",avg(inverter_conversion_efficiency) inverter_conversion_efficiency,avg(solar_array_efficiency) solar_array_efficiency" +
                 ",sum(power_generation_duration) power_generation_duration,sum(downtime_duration) downtime_duration,sum(interruption_duration) interruption_duration";
-        qw.select(sql).between("record_date", DateUtils.parseDate(beginDate),DateUtils.parseDate(endDate))
+        qw.select(sql).between("record_date", DateUtils.parseDate(beginDate), DateUtils.parseDate(endDate))
                 .groupBy("windpowerstation_id,windpowerstation_aname");
 
         if (companys.contains("RGN")) {
@@ -56,6 +56,7 @@ public class ProEconStationAnalysisServiceImpl extends ServiceImpl<ProEconStatio
             qw.like("equipment_id", "_IN_");
         }
 
-        return baseMapper.selectList(qw);
+        List<ProEconStationAnalysis> list = baseMapper.selectList(qw);
+        return list;
     }
 }

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/util/MathUtil.java

@@ -123,7 +123,7 @@ public class MathUtil {
     }
 
     public static String plain(BigDecimal bigDecimal, int i) {
-
+        if(bigDecimal==null) return "0";
         return bigDecimal.setScale(i, RoundingMode.HALF_UP).toPlainString();
     }
 }