| | |
| | | private final ModelNodeMapper modelNodeMapper; |
| | | |
| | | private final EnergyIndicatorsMapper energyIndicatorsMapper; |
| | | |
| | | |
| | | private final ProductOutputMapper productOutputMapper; |
| | | |
| | | |
| | | private final SysEnergyMapper sysEnergyMapper; |
| | | |
| | | private final IDataItemService dataItemService; |
| | | |
| | | private final IModelNodeService modelNodeService; |
| | | |
| | | |
| | | @Override |
| | | public ConsumptionAnalysisVO getByArea(ConsumptionAnalysisDTO dto) { |
| | | List<ConsumptionAnalysisData> dataList = new ArrayList<>(); |
| | | List<ChartData> chartDataList = new ArrayList<>(); |
| | | |
| | | |
| | | ConsumptionAnalysisVO consumptionAnalysisVO = new ConsumptionAnalysisVO(); |
| | | final String analysisType = dto.getAnalysisType(); |
| | | final String nodeId = dto.getNodeId(); |
| | |
| | | /** |
| | | * æ¥è¯¢ç¹ä½ä¸ç¨è½åå
ä¿¡æ¯ |
| | | */ |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId,energyType); |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId, energyType); |
| | | |
| | | // if (CollectionUtils.isEmpty(nodeIndexInforList)) { |
| | | // return consumptionAnalysisVO; |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetDay(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetDay(endTime, -1); |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | | } |
| | | |
| | | |
| | | timeFormat = "yyyy-MM"; |
| | | } |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | List<DataItem> lastDataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | lastDataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(lastTime, lastEndTime, shixuTimeType, indexIds); |
| | | } |
| | |
| | | final String compareTime; |
| | | DateTime dateTime; |
| | | if (TimeType.DAY.name().equals(queryTimeType)) { |
| | | |
| | | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetDay(beginTime, -1); |
| | | } |
| | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | } |
| | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | } |
| | | compareTime = DateUtil.format(dateTime, timeFormat); |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | final List<DataItem> dataItems = dataItemMap.get(currentTime); |
| | | final List<DataItem> lastDataItems = lastDataItemMap.get(compareTime); |
| | | BigDecimal sum = new BigDecimal(0); |
| | | BigDecimal lastSum = new BigDecimal(0); |
| | | if (CollectionUtils.isNotEmpty(dataItems)) { |
| | | // æ±å |
| | | sum = BigDecimal.valueOf(dataItems.stream() |
| | | // æ±å |
| | | sum = BigDecimal.valueOf(dataItems.stream() |
| | | .mapToDouble(DataItem::getValue).sum()).setScale(CommonConst.DIGIT_2, RoundingMode.HALF_UP); |
| | | } |
| | | |
| | | if(CollectionUtils.isNotEmpty(lastDataItems)) { |
| | | |
| | | if (CollectionUtils.isNotEmpty(lastDataItems)) { |
| | | lastSum = BigDecimal.valueOf(lastDataItems.stream() |
| | | .mapToDouble(DataItem::getValue).sum()).setScale(CommonConst.DIGIT_2, RoundingMode.HALF_UP); |
| | | } |
| | |
| | | data.setCompareValue(lastSum.doubleValue()); |
| | | data.setCurrentTime(currentTime); |
| | | data.setCompareTime(compareTime); |
| | | |
| | | |
| | | |
| | | if ("YOY".equals(analysisType)) { |
| | | //åæ¯åæ |
| | |
| | | chartDataList.add(chartData); |
| | | |
| | | }); |
| | | |
| | | |
| | | consumptionAnalysisVO.setDataList(dataList); |
| | | consumptionAnalysisVO.setChartDataList(chartDataList); |
| | | return consumptionAnalysisVO; |
| | |
| | | String queryTimeType = dto.getTimeType(); |
| | | // å建ä¸ä¸ªMapæ¥å卿»å |
| | | Map<String, BigDecimal> result = new HashMap<>(); |
| | | |
| | | |
| | | |
| | | |
| | | //æ ¹æ®æ¨¡ååç§°æ¥è¯¢modelCode |
| | | final String parentId = dto.getNodeId(); |
| | | |
| | | |
| | | //æ ¹æ®æ»ç»ç¹æ¥è¯¢ |
| | | final List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeByParentId(parentId); |
| | | |
| | | final List<String> eneryIdList = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getEnergyId).distinct().collect(Collectors.toList()); |
| | | final LambdaQueryWrapper<SysEnergy> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList),SysEnergy::getEnersno,eneryIdList); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList), SysEnergy::getEnersno, eneryIdList); |
| | | final List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(queryWrapper); |
| | | final Map<String, String> energyNameMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getEnername)); |
| | | final Map<String, String> nodeNameMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String nodeId = n.getNodeId(); |
| | | final String name = n.getName(); |
| | | if(!nodeNameMap.containsKey(nodeId)){ |
| | | nodeNameMap.put(nodeId,name); |
| | | if (!nodeNameMap.containsKey(nodeId)) { |
| | | nodeNameMap.put(nodeId, name); |
| | | } |
| | | }); |
| | | |
| | | // æç
§ç¹ä½è¿è¡åç» |
| | | Map<String, List<ModelNodeIndexInfor>> nodeIndexMap = nodeIndexInforList.stream().collect( |
| | | Collectors.groupingBy(ModelNodeIndexInfor::getNodeId)); |
| | | |
| | | |
| | | // æ ¹æ®nodeIdè·åè½æºç±»å |
| | | // ææç¹ä½ä¿¡æ¯ |
| | | List<String> indexIds = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getIndexId).distinct().collect(Collectors.toList()); |
| | |
| | | endTime = DateUtil.endOfYear(queryTime); |
| | | shixuTimeType = TimeType.MONTH.name(); |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | } |
| | | final Map<String, List<DataItem>> dataItemMap = dataItemList.stream().collect(Collectors.groupingBy(DataItem::getIndexId)); |
| | | |
| | | |
| | | // æ ¹æ®ç¹ä½åç»ï¼æ±å |
| | | Map<String,BigDecimal> dataItemTotalMap = new HashMap<>(); |
| | | dataItemMap.forEach((key,value)->{ |
| | | Map<String, BigDecimal> dataItemTotalMap = new HashMap<>(); |
| | | dataItemMap.forEach((key, value) -> { |
| | | BigDecimal sum = BigDecimal.valueOf(value.stream() |
| | | .mapToDouble(DataItem::getValue).sum()).setScale(CommonConst.DIGIT_2, RoundingMode.HALF_UP); |
| | | dataItemTotalMap.put(key,sum); |
| | | dataItemTotalMap.put(key, sum); |
| | | }); |
| | | |
| | | |
| | | |
| | | nodeIndexMap.forEach((nodeId,indexList)->{ |
| | | indexList.forEach(index->{ |
| | | |
| | | nodeIndexMap.forEach((nodeId, indexList) -> { |
| | | indexList.forEach(index -> { |
| | | final String energyId = index.getEnergyId(); |
| | | final String indexId = index.getIndexId(); |
| | | final BigDecimal total = dataItemTotalMap.getOrDefault(indexId, BigDecimal.ZERO); |
| | |
| | | String energyId = keys[1]; |
| | | BigDecimal totalEnergy = entry.getValue(); |
| | | chartData.setEnergyTypeNo(energyId); |
| | | chartData.setEnergyTypeName(energyNameMap.getOrDefault(energyId,"")); |
| | | chartData.setNodeName(nodeNameMap.getOrDefault(nodeId,"")); |
| | | chartData.setEnergyTypeName(energyNameMap.getOrDefault(energyId, "")); |
| | | chartData.setNodeName(nodeNameMap.getOrDefault(nodeId, "")); |
| | | chartData.setEnergyConsumption(totalEnergy.doubleValue()); |
| | | chartData.setNodeId(nodeId); |
| | | rankingEnergyData.add(chartData); |
| | | |
| | | |
| | | } |
| | | final Map<String, List<RankingEnergyData>> collect = rankingEnergyData.stream().collect(Collectors.groupingBy(RankingEnergyData::getNodeId)); |
| | | nodeNameMap.forEach((key,value)->{ |
| | | nodeNameMap.forEach((key, value) -> { |
| | | final List<RankingEnergyData> rankingEnergyData1 = collect.get(key); |
| | | RankingDataVO rankingDataVO = new RankingDataVO(); |
| | | rankingDataVO.setNodeId(key); |
| | |
| | | rankingDataVO.setData(rankingEnergyData1); |
| | | rankingDataVOArrayList.add(rankingDataVO); |
| | | }); |
| | | |
| | | |
| | | return rankingDataVOArrayList; |
| | | } |
| | | |
| | |
| | | List<EnergyProportion> energyProportionList = new ArrayList<>(); |
| | | |
| | | ConsumptionAnalysisVO consumptionAnalysisVO = new ConsumptionAnalysisVO(); |
| | | |
| | | |
| | | //todo hmj 综åè½èå
é»è®¤å忝 |
| | | final String analysisType = "YOY"; |
| | | final String nodeId = dto.getNodeId(); |
| | |
| | | /** |
| | | * æ¥è¯¢ç¹ä½ä¸ç¨è½åå
ä¿¡æ¯ |
| | | */ |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId,energyType); |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId, energyType); |
| | | |
| | | // if (CollectionUtils.isEmpty(nodeIndexInforList)) { |
| | | // return consumptionAnalysisVO; |
| | | // } |
| | | |
| | | //ä¿®æ¹è¿æ»¤ç»è®¡ç¹ä½ |
| | | nodeIndexInforList = nodeIndexInforList.stream().filter(x -> "STATISTIC".equals(x.getIndexType())).collect(Collectors.toList()); |
| | | final List<String> eneryIdList = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getEnergyId).distinct().collect(Collectors.toList()); |
| | | final LambdaQueryWrapper<SysEnergy> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList),SysEnergy::getEnersno,eneryIdList); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList), SysEnergy::getEnersno, eneryIdList); |
| | | final List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(queryWrapper); |
| | | final Map<String, BigDecimal> energyCoefficientMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getCoefficient)); |
| | | final Map<String, String> energyNameMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno,SysEnergy::getEnername)); |
| | | final Map<String, String> energyNameMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getEnername)); |
| | | final Map<String, String> indexIdEnergyIdMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String indexId = n.getIndexId(); |
| | | final String energyId = n.getEnergyId(); |
| | | if(!indexIdEnergyIdMap.containsKey(indexId)){ |
| | | indexIdEnergyIdMap.put(indexId,energyId); |
| | | if (!indexIdEnergyIdMap.containsKey(indexId)) { |
| | | indexIdEnergyIdMap.put(indexId, energyId); |
| | | } |
| | | }); |
| | | List<String> indexIds = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getIndexId).collect(Collectors.toList()); |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetDay(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetDay(endTime, -1); |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | lastTime = DateUtil.offsetMonth(beginTime, -12); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | | lastTime = DateUtil.offsetMonth(beginTime, -1); |
| | | lastEndTime = DateUtil.offsetMonth(endTime, -1); |
| | | } |
| | | |
| | | timeFormat = "yyyy-MM"; |
| | |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | List<DataItem> lastDataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | lastDataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(lastTime, lastEndTime, shixuTimeType, indexIds); |
| | | } |
| | |
| | | // åç |
| | | BigDecimal multiple = BigDecimal.valueOf(CommonConst.DIGIT_100); |
| | | |
| | | Map<String,Double> energyProportionMap = new HashMap<>(); |
| | | Map<String, Double> energyProportionMap = new HashMap<>(); |
| | | while (!beginTime.after(endTime)) { |
| | | ConsumptionAnalysisData data = new ConsumptionAnalysisData(); |
| | | final String currentTime = DateUtil.format(beginTime, timeFormat); |
| | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetDay(beginTime, -1); |
| | | } |
| | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | } |
| | |
| | | if ("YOY".equals(analysisType)) { |
| | | //忝åæï¼æ¶é´åå»å¹´ç |
| | | dateTime = DateUtil.offsetMonth(beginTime, -12); |
| | | }else { |
| | | } else { |
| | | //ç¯æ¯åæï¼æ¶é´å æ¨å¤© |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | dateTime = DateUtil.offsetMonth(beginTime, -1); |
| | | } |
| | | compareTime = DateUtil.format(dateTime, timeFormat); |
| | | } |
| | |
| | | BigDecimal lastSum = new BigDecimal(0); |
| | | if (CollectionUtils.isNotEmpty(dataItems)) { |
| | | // æ±å |
| | | for (int i=0;i<dataItems.size(); i++){ |
| | | for (int i = 0; i < dataItems.size(); i++) { |
| | | final DataItem dataItem = dataItems.get(i); |
| | | final String indexId = dataItem.getIndexId(); |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP);; |
| | | |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP); |
| | | ; |
| | | // if(energyProportionMap.containsKey(energyId)) { |
| | | // energyProportionMap.put(energyId,energyProportionMap.get(energyId) + sum.doubleValue()); |
| | | // }else { |
| | | // energyProportionMap.put(energyId, sum.doubleValue()); |
| | | // } |
| | | } |
| | | |
| | | |
| | | } |
| | | |
| | | if(CollectionUtils.isNotEmpty(lastDataItems)) { |
| | | for (int i=0;i<lastDataItems.size(); i++){ |
| | | if (CollectionUtils.isNotEmpty(lastDataItems)) { |
| | | for (int i = 0; i < lastDataItems.size(); i++) { |
| | | final DataItem dataItem = lastDataItems.get(i); |
| | | final String indexId = dataItem.getIndexId(); |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | lastSum = lastSum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP);; |
| | | lastSum = lastSum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP); |
| | | ; |
| | | } |
| | | } |
| | | data.setCurrentValue(sum.doubleValue()); |
| | |
| | | chartDataList.add(chartData); |
| | | |
| | | }); |
| | | |
| | | Double eneryTotal = energyProportionMap.values().stream().mapToDouble(Double::doubleValue).sum(); |
| | | |
| | | Double eneryTotal = energyProportionMap.values().stream().mapToDouble(Double::doubleValue).sum(); |
| | | |
| | | Map<String, List<DataItem>> indexDataItemMap = dataItemList.stream().collect(Collectors.groupingBy(DataItem::getIndexId)); |
| | | |
| | | indexDataItemMap.forEach((indexId,value)->{ |
| | | |
| | | indexDataItemMap.forEach((indexId, value) -> { |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | final double sum = value.stream().map(DataItem::getValue).mapToDouble(Double::doubleValue).sum(); |
| | | if(energyProportionMap.containsKey(energyId)) { |
| | | energyProportionMap.put(energyId,energyProportionMap.get(energyId) + sum * coefficient.doubleValue()); |
| | | }else { |
| | | if (energyProportionMap.containsKey(energyId)) { |
| | | energyProportionMap.put(energyId, energyProportionMap.get(energyId) + sum * coefficient.doubleValue()); |
| | | } else { |
| | | energyProportionMap.put(energyId, sum * coefficient.doubleValue()); |
| | | } |
| | | }); |
| | | |
| | | energyProportionMap.forEach((key,value)->{ |
| | | |
| | | energyProportionMap.forEach((key, value) -> { |
| | | EnergyProportion energyProportion = new EnergyProportion(); |
| | | energyProportion.setEnergyNo(key); |
| | | energyProportion.setEnergyName(energyNameMap.getOrDefault(key,"")); |
| | | energyProportion.setEnergyName(energyNameMap.getOrDefault(key, "")); |
| | | energyProportion.setCount(value); |
| | | energyProportion.setPercentage(value/eneryTotal * 100); |
| | | |
| | | energyProportion.setPercentage(value / eneryTotal * 100); |
| | | |
| | | energyProportionList.add(energyProportion); |
| | | }); |
| | | |
| | |
| | | } else { |
| | | timeFormat = "yyyy"; |
| | | } |
| | | |
| | | |
| | | final Double currTotalEnergy = getTotalEnergy(dto); |
| | | |
| | | DateTime tongbiTime = DateUtil.offsetMonth(queryTime, -12); |
| | | dto.setDataTime(tongbiTime); |
| | | final Double tongbiTotalEnergy = getTotalEnergy(dto); |
| | | |
| | | |
| | | DateTime huanbiTime = DateUtil.offsetMonth(queryTime, -1); |
| | | dto.setDataTime(huanbiTime); |
| | | final Double huanbiTotalEnergy = getTotalEnergy(dto); |
| | | |
| | | |
| | | tongbi.setCurrentTime(DateUtil.format(queryTime,timeFormat)); |
| | | tongbi.setCompareTime(DateUtil.format(tongbiTime,timeFormat)); |
| | | |
| | | tongbi.setCurrentTime(DateUtil.format(queryTime, timeFormat)); |
| | | tongbi.setCompareTime(DateUtil.format(tongbiTime, timeFormat)); |
| | | tongbi.setCurrentValue(currTotalEnergy); |
| | | tongbi.setCompareValue(tongbiTotalEnergy); |
| | | if(tongbiTotalEnergy != 0) { |
| | | if (tongbiTotalEnergy != 0) { |
| | | final double tongbiRatio = (currTotalEnergy - tongbiTotalEnergy) / tongbiTotalEnergy * 100; |
| | | BigDecimal bd = new BigDecimal(tongbiRatio); |
| | | bd = bd.setScale(2, RoundingMode.HALF_UP); |
| | | tongbi.setRatio(bd.doubleValue()); |
| | | }else { |
| | | } else { |
| | | tongbi.setRatio(0); |
| | | } |
| | | |
| | | huanbi.setCurrentTime(DateUtil.format(queryTime,timeFormat)); |
| | | huanbi.setCompareTime(DateUtil.format(huanbiTime,timeFormat)); |
| | | |
| | | huanbi.setCurrentTime(DateUtil.format(queryTime, timeFormat)); |
| | | huanbi.setCompareTime(DateUtil.format(huanbiTime, timeFormat)); |
| | | huanbi.setCompareValue(huanbiTotalEnergy); |
| | | huanbi.setCurrentValue(currTotalEnergy); |
| | | |
| | | if(huanbiTotalEnergy != 0) { |
| | | |
| | | if (huanbiTotalEnergy != 0) { |
| | | final double huanbiRatio = (currTotalEnergy - huanbiTotalEnergy) / huanbiTotalEnergy * 100; |
| | | BigDecimal bd = new BigDecimal(huanbiRatio); |
| | | bd = bd.setScale(2, RoundingMode.HALF_UP); |
| | | huanbi.setRatio(bd.doubleValue()); |
| | | }else { |
| | | } else { |
| | | huanbi.setRatio(0); |
| | | } |
| | | consumptionAnalysisVO.setTongbi(tongbi); |
| | | consumptionAnalysisVO.setHuanbi(huanbi); |
| | | return consumptionAnalysisVO; |
| | | } |
| | | |
| | | public Double getTotalEnergy(ConsumptionAnalysisDTO dto){ |
| | | |
| | | public Double getTotalEnergy(ConsumptionAnalysisDTO dto) { |
| | | //todo hmj 综åè½èå
é»è®¤å忝 |
| | | final String nodeId = dto.getNodeId(); |
| | | final String energyType = dto.getEnergyType(); |
| | |
| | | /** |
| | | * æ¥è¯¢ç¹ä½ä¸ç¨è½åå
ä¿¡æ¯ |
| | | */ |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId,energyType); |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId, energyType); |
| | | |
| | | // if (CollectionUtils.isEmpty(nodeIndexInforList)) { |
| | | // return consumptionAnalysisVO; |
| | | // } |
| | | |
| | | nodeIndexInforList = nodeIndexInforList.stream().filter(x -> "STATISTIC".equals(x.getIndexType())).collect(Collectors.toList()); |
| | | final List<String> eneryIdList = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getEnergyId).distinct().collect(Collectors.toList()); |
| | | final LambdaQueryWrapper<SysEnergy> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList),SysEnergy::getEnersno,eneryIdList); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList), SysEnergy::getEnersno, eneryIdList); |
| | | final List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(queryWrapper); |
| | | final Map<String, BigDecimal> energyCoefficientMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getCoefficient)); |
| | | final Map<String, String> indexIdEnergyIdMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String indexId = n.getIndexId(); |
| | | final String energyId = n.getEnergyId(); |
| | | if(!indexIdEnergyIdMap.containsKey(indexId)){ |
| | | indexIdEnergyIdMap.put(indexId,energyId); |
| | | if (!indexIdEnergyIdMap.containsKey(indexId)) { |
| | | indexIdEnergyIdMap.put(indexId, energyId); |
| | | } |
| | | }); |
| | | List<String> indexIds = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getIndexId).collect(Collectors.toList()); |
| | |
| | | } |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | } |
| | | Map<String, List<DataItem>> dataItemMap = dataItemList.stream().collect(Collectors.groupingBy(li -> DateUtil.format(li.getDataTime(), timeFormat))); |
| | | |
| | | Map<String,Double> energyProportionMap = new HashMap<>(); |
| | | Map<String, Double> energyProportionMap = new HashMap<>(); |
| | | while (!beginTime.after(endTime)) { |
| | | final String currentTime = DateUtil.format(beginTime, timeFormat); |
| | | |
| | |
| | | BigDecimal sum = new BigDecimal(0); |
| | | if (CollectionUtils.isNotEmpty(dataItems)) { |
| | | // æ±å |
| | | for (int i=0;i<dataItems.size(); i++){ |
| | | for (int i = 0; i < dataItems.size(); i++) { |
| | | final DataItem dataItem = dataItems.get(i); |
| | | final String indexId = dataItem.getIndexId(); |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP);; |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP); |
| | | ; |
| | | // if(energyProportionMap.containsKey(energyId)) { |
| | | // energyProportionMap.put(energyId,energyProportionMap.get(energyId) + sum.doubleValue()); |
| | | // }else { |
| | |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | Map<String, List<DataItem>> indexDataItemMap = dataItemList.stream().collect(Collectors.groupingBy(DataItem::getIndexId)); |
| | | |
| | | indexDataItemMap.forEach((indexId,value)->{ |
| | | indexDataItemMap.forEach((indexId, value) -> { |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | final double sum = value.stream().map(DataItem::getValue).mapToDouble(Double::doubleValue).sum(); |
| | | if(energyProportionMap.containsKey(energyId)) { |
| | | energyProportionMap.put(energyId,energyProportionMap.get(energyId) + sum * coefficient.doubleValue()); |
| | | }else { |
| | | if (energyProportionMap.containsKey(energyId)) { |
| | | energyProportionMap.put(energyId, energyProportionMap.get(energyId) + sum * coefficient.doubleValue()); |
| | | } else { |
| | | energyProportionMap.put(energyId, sum * coefficient.doubleValue()); |
| | | } |
| | | }); |
| | | Double eneryTotal = energyProportionMap.values().stream().mapToDouble(Double::doubleValue).sum(); |
| | | Double eneryTotal = energyProportionMap.values().stream().mapToDouble(Double::doubleValue).sum(); |
| | | return eneryTotal.doubleValue(); |
| | | } |
| | | |
| | |
| | | */ |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeByParentId(nodeId); |
| | | final Map<String, String> nodeNameMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String id = n.getNodeId(); |
| | | final String name = n.getName(); |
| | | if(!nodeNameMap.containsKey(id)){ |
| | | nodeNameMap.put(id,name); |
| | | if (!nodeNameMap.containsKey(id)) { |
| | | nodeNameMap.put(id, name); |
| | | } |
| | | }); |
| | | // æç
§ç¹ä½è¿è¡åç» |
| | |
| | | Collectors.groupingBy(ModelNodeIndexInfor::getNodeId)); |
| | | final List<String> eneryIdList = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getEnergyId).distinct().collect(Collectors.toList()); |
| | | final LambdaQueryWrapper<SysEnergy> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList),SysEnergy::getEnersno,eneryIdList); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList), SysEnergy::getEnersno, eneryIdList); |
| | | final List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(queryWrapper); |
| | | //è½æºç¼å·åè½æºææ ç³»æ° |
| | | final Map<String, BigDecimal> energyCoefficientMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getCoefficient)); |
| | | //indexåè½æº |
| | | final Map<String, String> indexIdEnergyIdMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String indexId = n.getIndexId(); |
| | | final String energyId = n.getEnergyId(); |
| | | if(!indexIdEnergyIdMap.containsKey(indexId)){ |
| | | indexIdEnergyIdMap.put(indexId,energyId); |
| | | if (!indexIdEnergyIdMap.containsKey(indexId)) { |
| | | indexIdEnergyIdMap.put(indexId, energyId); |
| | | } |
| | | }); |
| | | List<String> indexIds = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getIndexId).collect(Collectors.toList()); |
| | |
| | | } |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | } |
| | | Map<String, List<DataItem>> dataItemMap = dataItemList.stream().collect(Collectors.groupingBy(DataItem::getIndexId)); |
| | | |
| | | Map<String,BigDecimal> resultMap = new HashMap<>(); |
| | | Map<String, BigDecimal> resultMap = new HashMap<>(); |
| | | nodeIndexMap.forEach((key, value) -> { |
| | | // æ¾åºindexIds |
| | | List<String> indexIdList = value.stream().map(ModelNodeIndexInfor::getIndexId).collect(Collectors.toList()); |
| | | |
| | | indexIdList.forEach(indexId->{ |
| | | |
| | | indexIdList.forEach(indexId -> { |
| | | final List<DataItem> dataItems = dataItemMap.get(indexId); |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | |
| | | if(CollectionUtils.isNotEmpty(dataItems) ){ |
| | | |
| | | if (CollectionUtils.isNotEmpty(dataItems)) { |
| | | BigDecimal sum = BigDecimal.valueOf(dataItems.stream() |
| | | .mapToDouble(DataItem::getValue).sum()).setScale(CommonConst.DIGIT_2, RoundingMode.HALF_UP).multiply(coefficient); |
| | | |
| | |
| | | }); |
| | | }); |
| | | |
| | | resultMap.forEach((key,value)->{ |
| | | resultMap.forEach((key, value) -> { |
| | | RankingEnergyData rankingEnergyData = new RankingEnergyData(); |
| | | rankingEnergyData.setNodeId(key); |
| | | rankingEnergyData.setNodeName(nodeNameMap.get(key)); |
| | |
| | | } |
| | | |
| | | LambdaQueryWrapper<EnergyIndicators> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.eq(EnergyIndicators::getTimeType,queryTimeType); |
| | | queryWrapper.eq(EnergyIndicators::getDataTime,DateUtil.format(dto.getDataTime(),timeFormat)); |
| | | queryWrapper.eq(EnergyIndicators::getNodeId,dto.getNodeId()); |
| | | queryWrapper.eq(EnergyIndicators::getEnergyType,dto.getEnergyType()); |
| | | queryWrapper.eq(EnergyIndicators::getTimeType, queryTimeType); |
| | | queryWrapper.eq(EnergyIndicators::getDataTime, DateUtil.format(dto.getDataTime(), timeFormat)); |
| | | queryWrapper.eq(EnergyIndicators::getNodeId, dto.getNodeId()); |
| | | queryWrapper.eq(EnergyIndicators::getEnergyType, dto.getEnergyType()); |
| | | // 0 æ¯è®¡åé |
| | | queryWrapper.eq(EnergyIndicators::getIndicatorsType,"0"); |
| | | queryWrapper.eq(EnergyIndicators::getIndicatorsType, "0"); |
| | | final EnergyIndicators plan = energyIndicatorsMapper.selectOne(queryWrapper); |
| | | if(null != plan && null!= plan.getNumber()) { |
| | | if (null != plan && null != plan.getNumber()) { |
| | | consumptionAnalysisVO.setPlanCount(plan.getNumber().divide(new BigDecimal(between), CommonConst.DIGIT_2, RoundingMode.HALF_UP).doubleValue()); |
| | | }else { |
| | | } else { |
| | | consumptionAnalysisVO.setPlanCount(0D); |
| | | } |
| | | queryWrapper.clear(); |
| | | |
| | | |
| | | queryWrapper.eq(EnergyIndicators::getTimeType,queryTimeType); |
| | | queryWrapper.eq(EnergyIndicators::getDataTime,DateUtil.format(dto.getDataTime(),timeFormat)); |
| | | queryWrapper.eq(EnergyIndicators::getNodeId,dto.getNodeId()); |
| | | queryWrapper.eq(EnergyIndicators::getEnergyType,dto.getEnergyType()); |
| | | queryWrapper.eq(EnergyIndicators::getIndicatorsType,"1"); |
| | | queryWrapper.eq(EnergyIndicators::getTimeType, queryTimeType); |
| | | queryWrapper.eq(EnergyIndicators::getDataTime, DateUtil.format(dto.getDataTime(), timeFormat)); |
| | | queryWrapper.eq(EnergyIndicators::getNodeId, dto.getNodeId()); |
| | | queryWrapper.eq(EnergyIndicators::getEnergyType, dto.getEnergyType()); |
| | | queryWrapper.eq(EnergyIndicators::getIndicatorsType, "1"); |
| | | final EnergyIndicators prod = energyIndicatorsMapper.selectOne(queryWrapper); |
| | | if(null != prod && null!= prod.getNumber()) { |
| | | if (null != prod && null != prod.getNumber()) { |
| | | consumptionAnalysisVO.setPlanCount(prod.getNumber().divide(new BigDecimal(between), CommonConst.DIGIT_2, RoundingMode.HALF_UP).doubleValue()); |
| | | }else { |
| | | } else { |
| | | consumptionAnalysisVO.setProdCount(0D); |
| | | } |
| | | return consumptionAnalysisVO; |
| | |
| | | /** |
| | | * æ¥è¯¢ç¹ä½ä¸ç¨è½åå
ä¿¡æ¯ |
| | | */ |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId,energyType); |
| | | List<ModelNodeIndexInfor> nodeIndexInforList = modelNodeMapper.getModelNodeIndexIdByNodeId(nodeId, energyType); |
| | | |
| | | final List<String> eneryIdList = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getEnergyId).distinct().collect(Collectors.toList()); |
| | | final LambdaQueryWrapper<SysEnergy> queryWrapper = new LambdaQueryWrapper<>(); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList),SysEnergy::getEnersno,eneryIdList); |
| | | queryWrapper.in(CollectionUtils.isNotEmpty(eneryIdList), SysEnergy::getEnersno, eneryIdList); |
| | | final List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(queryWrapper); |
| | | final Map<String, BigDecimal> energyCoefficientMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, SysEnergy::getCoefficient)); |
| | | final Map<String, String> indexIdEnergyIdMap = new HashMap<>(); |
| | | nodeIndexInforList.forEach(n->{ |
| | | nodeIndexInforList.forEach(n -> { |
| | | final String indexId = n.getIndexId(); |
| | | final String energyId = n.getEnergyId(); |
| | | if(!indexIdEnergyIdMap.containsKey(indexId)){ |
| | | indexIdEnergyIdMap.put(indexId,energyId); |
| | | if (!indexIdEnergyIdMap.containsKey(indexId)) { |
| | | indexIdEnergyIdMap.put(indexId, energyId); |
| | | } |
| | | }); |
| | | List<String> indexIds = nodeIndexInforList.stream().map(ModelNodeIndexInfor::getIndexId).collect(Collectors.toList()); |
| | |
| | | shixuTimeType = TimeType.MONTH.name(); |
| | | timeFormat = "yyyy-MM"; |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | // æ ¹æ®indexIdæ¥è¯¢dataItem |
| | | List<DataItem> dataItemList = new ArrayList<>(); |
| | | if(CollectionUtils.isNotEmpty(indexIds)) { |
| | | if (CollectionUtils.isNotEmpty(indexIds)) { |
| | | dataItemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds); |
| | | } |
| | | Map<String, List<DataItem>> dataItemMap = dataItemList.stream().collect(Collectors.groupingBy(li -> DateUtil.format(li.getDataTime(), timeFormat))); |
| | |
| | | while (!beginTime.after(endTime)) { |
| | | //æ¥è¯¢å¼å§æ¶é´åç»ææ¶é´ä¹é´ç产é |
| | | LambdaQueryWrapper<ProductOutput> indicatorsWrapper = new LambdaQueryWrapper<>(); |
| | | indicatorsWrapper.eq(ProductOutput::getTimeType,shixuTimeType); |
| | | indicatorsWrapper.eq(ProductOutput::getNodeId,dto.getNodeId()); |
| | | indicatorsWrapper.eq(ProductOutput::getDataTime,DateUtil.format(beginTime,timeFormat)); |
| | | indicatorsWrapper.eq(ProductOutput::getTimeType, shixuTimeType); |
| | | indicatorsWrapper.eq(ProductOutput::getNodeId, dto.getNodeId()); |
| | | indicatorsWrapper.eq(ProductOutput::getDataTime, DateUtil.format(beginTime, timeFormat)); |
| | | List<ProductOutput> energyIndicators = productOutputMapper.selectList(indicatorsWrapper); |
| | | prodCountMap.put(DateUtil.format(beginTime,timeFormat),energyIndicators); |
| | | |
| | | prodCountMap.put(DateUtil.format(beginTime, timeFormat), energyIndicators); |
| | | |
| | | ConsumptionAnalysisData data = new ConsumptionAnalysisData(); |
| | | final String currentTime = DateUtil.format(beginTime, timeFormat); |
| | | |
| | |
| | | BigDecimal sum = new BigDecimal(0); |
| | | if (CollectionUtils.isNotEmpty(dataItems)) { |
| | | // æ±å |
| | | for (int i=0;i<dataItems.size(); i++){ |
| | | for (int i = 0; i < dataItems.size(); i++) { |
| | | final DataItem dataItem = dataItems.get(i); |
| | | final String indexId = dataItem.getIndexId(); |
| | | final String energyId = indexIdEnergyIdMap.get(indexId); |
| | | |
| | | final BigDecimal coefficient = energyCoefficientMap.get(energyId); |
| | | if(coefficient == null){ |
| | | if (coefficient == null) { |
| | | throw new RuntimeException("è½æºç±»å" + energyId + "没æé
ç½®ææ ç³»æ°ï¼æ æ³è®¡ç®"); |
| | | } |
| | | |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP);; |
| | | sum = sum.add(new BigDecimal(dataItem.getValue()).multiply(coefficient)).setScale(2, RoundingMode.HALF_UP); |
| | | ; |
| | | } |
| | | |
| | | } |
| | |
| | | break; |
| | | } |
| | | } |
| | | dataList.forEach(d->{ |
| | | dataList.forEach(d -> { |
| | | ProductEnergyAnalysisData productEnergyAnalysisData = new ProductEnergyAnalysisData(); |
| | | final String currentTime = d.getCurrentTime(); |
| | | |
| | | |
| | | productEnergyAnalysisData.setDateTime(currentTime); |
| | | |
| | | |
| | | final List<ProductOutput> productOutputs = prodCountMap.get(currentTime); |
| | | if(StringUtils.isEmpty(dto.getProdType())){ |
| | | if (StringUtils.isEmpty(dto.getProdType())) { |
| | | productEnergyAnalysisData.setEnergyCount(format2Double(d.getCurrentValue())); |
| | | final double sum = productOutputs.stream().map(ProductOutput::getNumber).mapToDouble(BigDecimal::doubleValue).sum(); |
| | | productEnergyAnalysisData.setProductCount(format2Double(sum)); |
| | | if(sum != 0) { |
| | | if (sum != 0) { |
| | | final double averageEnergy = productEnergyAnalysisData.getEnergyCount() / productEnergyAnalysisData.getProductCount(); |
| | | // å建DecimalFormat对象ï¼è®¾ç½®ä¿ç两ä½å°æ° |
| | | DecimalFormat df = new DecimalFormat("#.00"); |
| | |
| | | // æ ¼å¼åç»æ |
| | | String formattedResult = df.format(averageEnergy); |
| | | productEnergyAnalysisData.setAverage(Double.valueOf(formattedResult)); |
| | | }else { |
| | | } else { |
| | | productEnergyAnalysisData.setAverage(0); |
| | | } |
| | | }else { |
| | | if(CollectionUtils.isNotEmpty(productOutputs)) { |
| | | } else { |
| | | if (CollectionUtils.isNotEmpty(productOutputs)) { |
| | | final Map<String, List<ProductOutput>> productTypeMap = productOutputs.stream().collect(Collectors.groupingBy(ProductOutput::getProductType)); |
| | | final double sum = productOutputs.stream().map(ProductOutput::getNumber).mapToDouble(BigDecimal::doubleValue).sum(); |
| | | final List<ProductOutput> outputList = productTypeMap.get(dto.getProdType()); |
| | | if(CollectionUtils.isNotEmpty(outputList)) { |
| | | if (CollectionUtils.isNotEmpty(outputList)) { |
| | | final double enengyProd = outputList.stream().map(ProductOutput::getNumber).mapToDouble(BigDecimal::doubleValue).sum(); |
| | | productEnergyAnalysisData.setProductCount(format2Double(enengyProd)); |
| | | productEnergyAnalysisData.setEnergyCount(format2Double(d.getCurrentValue() * enengyProd / sum)); |
| | |
| | | } else { |
| | | productEnergyAnalysisData.setAverage(0); |
| | | } |
| | | }else { |
| | | } else { |
| | | productEnergyAnalysisData.setProductCount(0); |
| | | productEnergyAnalysisData.setEnergyCount(d.getCurrentValue()); |
| | | productEnergyAnalysisData.setAverage(0); |
| | | } |
| | | }else { |
| | | } else { |
| | | productEnergyAnalysisData.setProductCount(0); |
| | | productEnergyAnalysisData.setEnergyCount(d.getCurrentValue()); |
| | | productEnergyAnalysisData.setAverage(0); |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | chart.add(productEnergyAnalysisData); |
| | | }); |
| | | |
| | |
| | | final double totalProd = chart.stream().map(ProductEnergyAnalysisData::getProductCount).mapToDouble(Double::doubleValue).sum(); |
| | | productEnergyAnalysisVO.setTotalEnergy(format2Double(totalEnergy)); |
| | | productEnergyAnalysisVO.setTotalProduct(format2Double(totalProd)); |
| | | if(totalProd != 0) { |
| | | if (totalProd != 0) { |
| | | productEnergyAnalysisVO.setAverageEnergy(format2Double(totalEnergy / totalProd)); |
| | | }else { |
| | | } else { |
| | | productEnergyAnalysisVO.setAverageEnergy(0D); |
| | | } |
| | | return productEnergyAnalysisVO; |