diff --git a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/controller/StationOperationController.java b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/controller/StationOperationController.java index 95ca38bd..0f84eafa 100644 --- a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/controller/StationOperationController.java +++ b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/controller/StationOperationController.java @@ -6,6 +6,7 @@ import org.jeecg.common.api.vo.Result; import org.jeecg.modules.entity.data.PointVo; import org.jeecg.modules.entity.data.StationOperation; import org.jeecg.modules.service.IStationOperationService; +import org.jeecg.modules.service.IStationProvisionEffService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.format.annotation.DateTimeFormat; @@ -24,6 +25,8 @@ public class StationOperationController { @Autowired private IStationOperationService stationOperationService; + @Autowired + private IStationProvisionEffService stationProvisionEffService; @GetMapping("findStationType") @ApiOperation(value = "查询台站/核设施类型", notes = "查询台站/核设施类型") @@ -108,4 +111,12 @@ public class StationOperationController { return stationOperationService.getSelfStationGPS(stationCode, startDate, endDate); } + @GetMapping("getStationProvisionEff") + @ApiOperation(value = "查询台站提供数据信息", notes = "查询台站提供数据信息") + public Result getStationProvisionEff(Integer[] stationIds, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { + + return stationProvisionEffService.getStationProvisionEff(stationIds, startTime, endTime); + } + + } diff --git a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/entity/data/Rate.java b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/entity/data/Rate.java index 9dd4e264..4763692f 100644 --- a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/entity/data/Rate.java +++ b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/entity/data/Rate.java @@ -7,29 +7,63 @@ import java.io.Serializable; @Data public class Rate implements Serializable { + //数据提供数量 + private double phdfOfferedNumber; + //数据有效数量 + private double phdfDataNumber; + //数据提供率 private double phdfOffered; - + //数据有效率 private double phdfEfficient; - + + private double phdOfferedNumber; + private double phdDataNumber; private double phdOffered; - private double phdEfficient; - + + private double metOfferedNumber; + private double metDataNumber; private double met; - + private double metEfficient; + + + + private double sohOfferedNumber; + private double sohDataNumber; private double soh; - + private double sohEfficient; + + private double pmtOfferedNumber; + private double pmtDataNumber; private double phdMetSoh; - + private double pmtEfficient; + public Rate() { + phdfOfferedNumber=0; + phdfDataNumber=0; phdfOffered = 0; phdfEfficient = 0; + + phdOfferedNumber=0; + phdDataNumber=0; phdOffered = 0; phdEfficient = 0; + + metOfferedNumber=0; + metDataNumber=0; met = 0; + metEfficient=0; + + sohOfferedNumber=0; + sohDataNumber=0; soh = 0; + sohEfficient=0; + + pmtOfferedNumber=0; + pmtDataNumber=0; phdMetSoh = 0; + sohEfficient=0; } } diff --git a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/IStationProvisionEffService.java b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/IStationProvisionEffService.java new file mode 100644 index 00000000..8863bc94 --- /dev/null +++ b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/IStationProvisionEffService.java @@ -0,0 +1,11 @@ +package org.jeecg.modules.service; + +import com.baomidou.mybatisplus.extension.service.IService; +import org.jeecg.common.api.vo.Result; +import org.jeecg.modules.entity.data.StationOperation; + +import java.util.Date; + +public interface IStationProvisionEffService extends IService { + Result getStationProvisionEff(Integer[] stationIds, Date startTime, Date endTime); +} diff --git a/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/impl/StationProvisionEffServiceImpl.java b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/impl/StationProvisionEffServiceImpl.java new file mode 100644 index 00000000..c81488af --- /dev/null +++ b/jeecg-module-station-operation/src/main/java/org/jeecg/modules/service/impl/StationProvisionEffServiceImpl.java @@ -0,0 +1,1003 @@ +package org.jeecg.modules.service.impl; + +import com.baomidou.dynamic.datasource.annotation.DS; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import lombok.Data; +import org.apache.commons.lang3.StringUtils; +import org.jeecg.common.CalculateStationData; +import org.jeecg.common.api.vo.Result; +import org.jeecg.common.util.DateUtils; +import org.jeecg.common.util.RedisUtil; +import org.jeecg.modules.base.entity.configuration.GardsStations; +import org.jeecg.modules.base.enums.DetectorStatus; + +import org.jeecg.modules.entity.data.*; +import org.jeecg.modules.mapper.StationOperationMapper; +import org.jeecg.modules.service.ICalCulStationDataService; +import org.jeecg.modules.service.IStationProvisionEffService; +import org.jeecgframework.core.util.ApplicationContextUtil; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.io.Serializable; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; +import java.util.stream.Collectors; + +@Service("StationProvisionEffService") +@DS("ora") +public class StationProvisionEffServiceImpl extends ServiceImpl implements IStationProvisionEffService { + @Autowired + private RedisUtil redisUtil; + @Autowired + private ICalCulStationDataService calCulStationDataService; + @Autowired + private CalculateStationData calCulateStationData; + + @Override + public Result getStationProvisionEff(Integer[] stationIds, Date startTime, Date endTime) { + + Result result = new Result(); + try { + //region 参数处理 + // 获取所有的台站信息 + HashMap stationInfoMap = (HashMap) redisUtil.get("stationInfoMap"); + List detectorsUsedList = (List) redisUtil.get("detectorsUsedList"); + + + if (Objects.isNull(startTime)) { + result.error500("The start time cannot be empty"); + return result; + } + if (Objects.isNull(endTime)) { + result.error500("The end time cannot be empty"); + return result; + } + if (Objects.isNull(stationIds)) { + result.setSuccess(true); + result.setResult(Collections.emptyList()); + return result; + } + //参数日期 不包含时分秒 + Date startDate = DateUtils.parseDate(DateUtils.formatDate(startTime, "yyyy-MM-dd") + " 00:00:00", "yyyy-MM-dd HH:mm:ss"); + Date endDate = DateUtils.parseDate(DateUtils.formatDate(endTime, "yyyy-MM-dd") + " 23:59:59", "yyyy-MM-dd HH:mm:ss"); + RateParam mRateParam = calCulateStationData.initParameter(); + //声明一个数组用于接收最后的结果情况 + List calculateDataRates = new ArrayList<>(); + + //endregion + for (Integer id : stationIds) { + GardsStations gardsStations = stationInfoMap.get(id.toString()); + if (Objects.isNull(gardsStations)) { + StationProvisionEff stationProvisionEff = new StationProvisionEff(); + calculateDataRates.add(stationProvisionEff); + continue; + } + //region StationInfo + StationInfo stationInfo = new StationInfo(); + stationInfo.setId(gardsStations.getStationId().toString()); + stationInfo.setStationCode(gardsStations.getStationCode()); + stationInfo.setCountryCode(gardsStations.getCountryCode()); + stationInfo.setLon(gardsStations.getLon().toString()); + stationInfo.setLat(gardsStations.getLat().toString()); + stationInfo.setType(gardsStations.getType()); + stationInfo.setDescription(gardsStations.getDescription()); + stationInfo.setStatus(gardsStations.getStatus()); + stationInfo.setEfficCalculType(gardsStations.getEfficCalculType()); + stationInfo.setUsed(detectorsUsedList.contains(gardsStations.getStationId()) ? "YES" : "NO"); + //endregion + + + CalculateDataRate calculateDataRate = new CalculateDataRate(); + calculateDataRate.setMPretime(startDate.toString()); + calculateDataRate.setMCurtime(endDate.toString()); + calculateDataRate.setParameter(mRateParam); + calculateDataRate.setMStationinfo(stationInfo); + //赋值台站信息 + calculateDataRate.setMStationId(stationInfo.getId()); + calculateDataRate.setMStationCode(stationInfo.getStationCode()); + calculateDataRate.setMStationType(stationInfo.getType()); + calculateDataRate.setMEfficCalculType(stationInfo.getEfficCalculType()); + Rate calculate = this.calculate(calculateDataRate, startDate, endDate); + calculateDataRate.setMRate(calculate); + StationProvisionEff stationProvisionEff = new StationProvisionEff(); + stationProvisionEff.setParameter(calculateDataRate); + calculateDataRates.add(stationProvisionEff); + } + result.setSuccess(true); + result.setResult(calculateDataRates); + + } catch (Exception e) { + throw new RuntimeException(e); + } + + + return result; + } + + + /** + * 根据台站编码及台站类型选择不同的方法 + * + * @param calculateDataRate + */ + public Rate calculate(CalculateDataRate calculateDataRate, Date startTime, Date endTime) { + + if (StringUtils.isBlank(calculateDataRate.getMStationId())) { + log.error("台站id不能为空"); + } + SimpleDateFormat customFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String pretime = customFormat.format(startTime); + String curDateTime = customFormat.format(endTime); + Rate mRate = new Rate(); + //获取台站编码 + String stationCode = calculateDataRate.getMStationCode(); + //使用efficCalculType判断台站类型 + String efficCalculType = calculateDataRate.getMEfficCalculType(); + //判断台站编码及台站类型 + if ((StringUtils.isNotBlank(stationCode) && stationCode.charAt(2) == 'X') && (StringUtils.isNotBlank(efficCalculType) && efficCalculType.equals("SAUNA"))) { + //切割台站编码 如果 第三个字符是 X 并且 EFFIC_CALCUL_TYPE类型是 SAUNA + mRate = saunacalc(calculateDataRate, pretime, curDateTime); + } else if ((StringUtils.isNotBlank(stationCode) && stationCode.charAt(2) == 'X') && (StringUtils.isNotBlank(efficCalculType) && efficCalculType.equals("SAUNA2"))) { + //切割台站编码 如果 第三个字符是 X 并且 EFFIC_CALCUL_TYPE类型是 SAUNA2 + mRate = saunacalc2(calculateDataRate, pretime, curDateTime); + } else if ((StringUtils.isNotBlank(stationCode) && stationCode.charAt(2) == 'X') && (StringUtils.isNotBlank(efficCalculType) && efficCalculType.equals("SPALAX"))) { + //切割台站编码 如果 第三个字符是 X 并且 EFFIC_CALCUL_TYPE类型是 SPALAX + mRate = spalaxcalc(calculateDataRate, pretime, curDateTime); + } else if ((StringUtils.isNotBlank(stationCode) && stationCode.charAt(2) == 'X') && (StringUtils.isNotBlank(efficCalculType) && efficCalculType.equals("SPALAX_PLC"))) { + //切割台站编码 如果 第三个字符是 X 并且 EFFIC_CALCUL_TYPE类型是 SPALAX-PLC + mRate = spalaxcalcPLC(calculateDataRate, pretime, curDateTime); + } else if (StringUtils.isNotBlank(stationCode) && stationCode.charAt(2) == 'P') { + //切割台站编码 如果 第三个字符是 P + mRate = particulatecalc(calculateDataRate, pretime, curDateTime); + } + return mRate; + } + + + public Rate saunacalc(CalculateDataRate calculateDataRate, String pretime, String curDateTime) { + Rate mRate = new Rate(); + //获取特殊台站相关集合 + Map mSpecialparam = calculateDataRate.getMSpecialparam(); + //根据台站名称获取对应的 参数信息 + Specialpara param = mSpecialparam.get(calculateDataRate.getMStationCode()); + //获取台站id + String stationId = calculateDataRate.getMStationId(); + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionRate = new ProvisionData(); + String liveLow; + String liveHigh; + String quantity; + String mdc; + String collectLow; + String collectHigh; + String xeVolume; + String nuclideName; + String liveQc; + String number; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhdf().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdfSauna().getNumber(); + } + phdfProvisionRate = calCulStationDataService.findPhdfProvisionRateSauna(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionRate)) { + double phdf_offered = phdfProvisionRate.getDataRate(); + double phdf_dataNum = phdfProvisionRate.getDataRate(); + mRate.setPhdfOffered(phdf_offered); + mRate.setPhdfOfferedNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionEfficiency = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhdf().getLiveLow(); + liveHigh = param.getPhdf().getLiveHigh(); + quantity = param.getPhdf().getQuantity(); + mdc = param.getPhdf().getMdc(); + collectLow = param.getPhdf().getCollectLow(); + collectHigh = param.getPhdf().getCollectHigh(); + xeVolume = param.getPhdf().getXeVolume(); + nuclideName = param.getPhdf().getNuclideName(); + liveQc = param.getPhdf().getLiveQc(); + number = param.getPhdf().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdfSauna().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdfSauna().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdfSauna().getQuantity(); + mdc = calculateDataRate.getMParameter().getPhdfSauna().getMdc(); + collectLow = calculateDataRate.getMParameter().getPhdfSauna().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdfSauna().getCollectHigh(); + xeVolume = calculateDataRate.getMParameter().getPhdfSauna().getXeVolume(); + nuclideName = calculateDataRate.getMParameter().getPhdfSauna().getNuclideName(); + liveQc = calculateDataRate.getMParameter().getPhdfSauna().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdfSauna().getNumber(); + } + phdfProvisionEfficiency = calCulStationDataService.findPhdfProvisionEfficiencySauna(liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionEfficiency)) { + double phdf_efficient = phdfProvisionEfficiency.getDataEfficiency(); + double phdf_dataNum = phdfProvisionEfficiency.getDataNumber(); + mRate.setPhdfEfficient(phdf_efficient); + mRate.setPhdfDataNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionRate = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhd().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdSauna().getNumber(); + } + phdProvisionRate = calCulStationDataService.findPhdProvisionRateSauna(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionRate)) { + double phd_offered = phdProvisionRate.getDataRate(); + double phd_dataNum = phdProvisionRate.getDataNumber(); + mRate.setPhdOffered(phd_offered); + mRate.setPhdOfferedNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionEfficiency = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhd().getLiveLow(); + liveHigh = param.getPhd().getLiveHigh(); + quantity = param.getPhd().getQuantity(); + mdc = param.getPhd().getMdc(); + collectLow = param.getPhd().getCollectLow(); + collectHigh = param.getPhd().getCollectHigh(); + xeVolume = param.getPhd().getXeVolume(); + nuclideName = param.getPhd().getNuclideName(); + liveQc = param.getPhd().getLiveQc(); + number = param.getPhd().getNumber(); + phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencySauna(liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, curDateTime, pretime, number, stationId); + } else { + liveLow = calculateDataRate.getMParameter().getPhdSauna().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdSauna().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdSauna().getQuantity(); + mdc = calculateDataRate.getMParameter().getPhdSauna().getMdc(); + collectLow = calculateDataRate.getMParameter().getPhdSauna().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdSauna().getCollectHigh(); + xeVolume = calculateDataRate.getMParameter().getPhdSauna().getXeVolume(); + nuclideName = calculateDataRate.getMParameter().getPhdSauna().getNuclideName(); + liveQc = calculateDataRate.getMParameter().getPhdSauna().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdSauna().getNumber(); + phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencySauna(liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, curDateTime, pretime, number, stationId); + } + if (Objects.nonNull(phdProvisionEfficiency)) { + double phd_efficient = phdProvisionEfficiency.getDataEfficiency(); + double phd_dataNum = phdProvisionEfficiency.getDataNumber(); + mRate.setPhdEfficient(phd_efficient); + mRate.setPhdDataNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算MET的数据提供率 + ProvisionData metProvision = new ProvisionData(); + String met; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + met = param.getMet(); + } else { + met = calculateDataRate.getMParameter().getMet(); + } + metProvision = calCulStationDataService.findMetProvisionSauna(curDateTime, pretime, met, stationId); + if (Objects.nonNull(metProvision)) { + double metRate = metProvision.getDataRate(); + double metDataNum = metProvision.getDataNumber(); + mRate.setMet(metRate); + mRate.setMetOfferedNumber(metDataNum); + + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sohProvision = new ProvisionData(); + String soh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + soh = param.getSoh(); + } else { + soh = calculateDataRate.getMParameter().getSoh(); + } + sohProvision = calCulStationDataService.findSohProvisionSauna(curDateTime, pretime, soh, stationId); + if (Objects.nonNull(sohProvision)) { + double sohRate = sohProvision.getDataRate(); + double sohDataNum = sohProvision.getDataNumber(); + mRate.setSoh(sohRate); + mRate.setSohOfferedNumber(sohDataNum); + } + + //计算SPHD+MET+SOH数据提供率 SPHD部分 + ProvisionData sphdProvision = calCulStationDataService.findSphdProvisionSauna(curDateTime, pretime, stationId); + String SPHD_NUM = "0"; + if (Objects.nonNull(sphdProvision)) { + SPHD_NUM = sphdProvision.getDataNumber().toString(); + } + //获取SPHD+MET+SOH数据提供率 MET部分 + ProvisionData sphdMetProvision = calCulStationDataService.findSphdMetProvisionSauna(curDateTime, pretime, stationId); + String MET_NUM = "0"; + if (Objects.nonNull(sphdMetProvision)) { + MET_NUM = sphdMetProvision.getDataNumber().toString(); + } + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sphdMetSohProvision = new ProvisionData(); + String sphdMetSoh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + sphdMetSoh = param.getSphdMetSoh(); + } else { + sphdMetSoh = calculateDataRate.getMParameter().getSphdMetSoh().getSaunaEverydaynums(); + } + sphdMetSohProvision = calCulStationDataService.findSphdMetSohProvisionSauna(SPHD_NUM, MET_NUM, curDateTime, pretime, sphdMetSoh, stationId); + if (Objects.nonNull(sphdMetSohProvision)) { + double phd_met_soh = sphdMetSohProvision.getDataRate(); + double pmtNum = sphdMetSohProvision.getDataNumber(); + mRate.setPhdMetSoh(phd_met_soh); + mRate.setPmtOfferedNumber(pmtNum); + } + return mRate; + } + + private Rate saunacalc2(CalculateDataRate calculateDataRate, String pretime, String curDateTime) { + Rate mRate = new Rate(); + //region 局部变量 + //获取特殊台站相关集合 + Map mSpecialparam = calculateDataRate.getMSpecialparam(); + //根据台站名称获取对应的 参数信息 + Specialpara param = mSpecialparam.get(calculateDataRate.getMStationCode()); + //获取台站id + String stationId = calculateDataRate.getMStationId(); + String liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, number; + //endregion + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhdf().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdfSauna2().getNumber(); + } + ProvisionData phdfProvisionRate = calCulStationDataService.findPhdfProvisionRateSauna2(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionRate)) { + double phdf_offered = phdfProvisionRate.getDataRate(); + double phdf_dataNum = phdfProvisionRate.getDataNumber(); + mRate.setPhdfOffered(phdf_offered); + mRate.setPhdfOfferedNumber(phdf_dataNum); + } + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionEfficiency; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhdf().getLiveLow(); + liveHigh = param.getPhdf().getLiveHigh(); + quantity = param.getPhdf().getQuantity(); + mdc = param.getPhdf().getMdc(); + collectLow = param.getPhdf().getCollectLow(); + collectHigh = param.getPhdf().getCollectHigh(); + xeVolume = param.getPhdf().getXeVolume(); + nuclideName = param.getPhdf().getNuclideName(); + liveQc = param.getPhdf().getLiveQc(); + number = param.getPhdf().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdfSauna2().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdfSauna2().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdfSauna2().getQuantity(); + mdc = calculateDataRate.getMParameter().getPhdfSauna2().getMdc(); + collectLow = calculateDataRate.getMParameter().getPhdfSauna2().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdfSauna2().getCollectHigh(); + xeVolume = calculateDataRate.getMParameter().getPhdfSauna2().getXeVolume(); + nuclideName = calculateDataRate.getMParameter().getPhdfSauna2().getNuclideName(); + liveQc = calculateDataRate.getMParameter().getPhdfSauna2().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdfSauna2().getNumber(); + } + phdfProvisionEfficiency = calCulStationDataService.findPhdfProvisionEfficiencySauna(liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionEfficiency)) { + double phdf_efficient = phdfProvisionEfficiency.getDataEfficiency(); + double phdf_dataNum = phdfProvisionEfficiency.getDataNumber(); + mRate.setPhdfEfficient(phdf_efficient); + mRate.setPhdfDataNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhd().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdSauna2().getNumber(); + } + ProvisionData phdProvisionRate = calCulStationDataService.findPhdProvisionRateSauna2(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionRate)) { + double phd_offered = phdProvisionRate.getDataRate(); + double phd_dataNum = phdProvisionRate.getDataNumber(); + mRate.setPhdOffered(phd_offered); + mRate.setPhdOfferedNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhd().getLiveLow(); + liveHigh = param.getPhd().getLiveHigh(); + quantity = param.getPhd().getQuantity(); + mdc = param.getPhd().getMdc(); + collectLow = param.getPhd().getCollectLow(); + collectHigh = param.getPhd().getCollectHigh(); + xeVolume = param.getPhd().getXeVolume(); + nuclideName = param.getPhd().getNuclideName(); + liveQc = param.getPhd().getLiveQc(); + number = param.getPhd().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdSauna2().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdSauna2().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdSauna2().getQuantity(); + mdc = calculateDataRate.getMParameter().getPhdSauna2().getMdc(); + collectLow = calculateDataRate.getMParameter().getPhdSauna2().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdSauna2().getCollectHigh(); + xeVolume = calculateDataRate.getMParameter().getPhdSauna2().getXeVolume(); + nuclideName = calculateDataRate.getMParameter().getPhdSauna2().getNuclideName(); + liveQc = calculateDataRate.getMParameter().getPhdSauna2().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdSauna2().getNumber(); + } + ProvisionData phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencySauna2(liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionEfficiency)) { + double phd_efficient = phdProvisionEfficiency.getDataEfficiency(); + double phd_dataNum = phdProvisionEfficiency.getDataNumber(); + mRate.setPhdEfficient(phd_efficient); + mRate.setPhdDataNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算MET的数据提供率 + String met; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + met = param.getMet(); + } else { + met = calculateDataRate.getMParameter().getMet(); + } + ProvisionData metProvision = calCulStationDataService.findMetProvisionSauna(curDateTime, pretime, met, stationId); + if (Objects.nonNull(metProvision)) { + double metNum = metProvision.getDataRate(); + double offeredNumber = metProvision.getDataNumber(); + mRate.setMet(metNum); + mRate.setMetOfferedNumber(offeredNumber); + } + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + String soh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + soh = param.getSoh(); + } else { + soh = calculateDataRate.getMParameter().getSoh(); + } + ProvisionData sohProvision = calCulStationDataService.findSohProvisionSauna(curDateTime, pretime, soh, stationId); + if (Objects.nonNull(sohProvision)) { + double sohNum = sohProvision.getDataRate(); + double offeredNumber = sohProvision.getDataNumber(); + mRate.setSoh(sohNum); + mRate.setSohOfferedNumber(offeredNumber); + } + //计算SPHD+MET+SOH数据提供率 SPHD部分 + ProvisionData sphdProvision = calCulStationDataService.findSphdProvisionSauna2(curDateTime, pretime, stationId); + String SPHD_NUM = "0"; + if (Objects.nonNull(sphdProvision)) { + SPHD_NUM = sphdProvision.getDataNumber().toString(); + } + //获取SPHD+MET+SOH数据提供率 MET部分 + ProvisionData sphdMetProvision = calCulStationDataService.findSphdMetProvisionSauna(curDateTime, pretime, stationId); + String MET_NUM = "0"; + if (Objects.nonNull(sphdMetProvision)) { + MET_NUM = sphdMetProvision.getDataNumber().toString(); + } + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + String sphdMetSoh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + sphdMetSoh = param.getSphdMetSoh(); + } else { + sphdMetSoh = calculateDataRate.getMParameter().getSphdMetSoh().getSaunaEverydaynums(); + } + ProvisionData sphdMetSohProvision = calCulStationDataService.findSphdMetSohProvisionSauna(SPHD_NUM, MET_NUM, curDateTime, pretime, sphdMetSoh, stationId); + if (Objects.nonNull(sphdMetSohProvision)) { + double phd_met_soh = sphdMetSohProvision.getDataRate(); + double offeredNumber = sphdMetSohProvision.getDataNumber(); + mRate.setPhdMetSoh(phd_met_soh); + mRate.setPmtOfferedNumber(offeredNumber); + } + return mRate; + } + + public Rate spalaxcalc(CalculateDataRate calculateDataRate, String pretime, String curDateTime) { + Rate mRate = new Rate(); + //获取特殊台站相关集合 + Map mSpecialparam = calculateDataRate.getMSpecialparam(); + //根据台站名称获取对应的 参数信息 + Specialpara param = mSpecialparam.get(calculateDataRate.getMStationCode()); + //获取台站id + String stationId = calculateDataRate.getMStationId(); + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionRate = new ProvisionData(); + String number; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhdf().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdfSpalax().getNumber(); + } + phdfProvisionRate = calCulStationDataService.findPhdfProvisionRateSpalax(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionRate)) { + double phdf_offered = phdfProvisionRate.getDataRate(); + double phdf_dataNum = phdfProvisionRate.getDataNumber(); + mRate.setPhdfOffered(phdf_offered); + mRate.setPhdfOfferedNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionEfficiency = new ProvisionData(); + String liveLow; + String liveHigh; + String quantity; + String collectLow; + String collectHigh; + String liveQc; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhdf().getLiveLow(); + liveHigh = param.getPhdf().getLiveHigh(); + quantity = param.getPhdf().getQuantity(); + collectLow = param.getPhdf().getCollectLow(); + collectHigh = param.getPhdf().getCollectHigh(); + liveQc = param.getPhdf().getLiveQc(); + number = param.getPhdf().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdfSpalax().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdfSpalax().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdfSpalax().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdfSpalax().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdfSpalax().getCollectHigh(); + liveQc = calculateDataRate.getMParameter().getPhdfSpalax().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdfSpalax().getNumber(); + } + phdfProvisionEfficiency = calCulStationDataService.findPhdfProvisionEfficiencySpalax(liveLow, liveHigh, quantity, collectLow, collectHigh, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionEfficiency)) { + double phdf_efficient = phdfProvisionEfficiency.getDataEfficiency(); + double phdf_dataNum = phdfProvisionEfficiency.getDataNumber(); + mRate.setPhdfEfficient(phdf_efficient); + mRate.setPhdfDataNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionRate = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhd().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdSpalax().getNumber(); + } + phdProvisionRate = calCulStationDataService.findPhdProvisionRateSpalax(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionRate)) { + double phd_offered = phdProvisionRate.getDataRate(); + double phd_dataNum = phdProvisionRate.getDataNumber(); + mRate.setPhdOffered(phd_offered); + mRate.setPhdOfferedNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionEfficiency = new ProvisionData(); + + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhd().getLiveLow(); + liveHigh = param.getPhd().getLiveHigh(); + quantity = param.getPhd().getQuantity(); + collectLow = param.getPhd().getCollectLow(); + collectHigh = param.getPhd().getCollectHigh(); + liveQc = param.getPhd().getLiveQc(); + number = param.getPhd().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdSpalax().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdSpalax().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdSpalax().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdSpalax().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdSpalax().getCollectHigh(); + liveQc = calculateDataRate.getMParameter().getPhdSpalax().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdSpalax().getNumber(); + } + phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencySpalax(liveLow, liveHigh, quantity, collectLow, collectHigh, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionEfficiency)) { + double phd_efficient = phdProvisionEfficiency.getDataEfficiency(); + double phd_dataNum = phdProvisionEfficiency.getDataNumber(); + mRate.setPhdEfficient(phd_efficient); + mRate.setPhdDataNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算MET的数据提供率 + ProvisionData metProvision = new ProvisionData(); + String met; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + met = param.getMet(); + } else { + met = calculateDataRate.getMParameter().getMet(); + } + metProvision = calCulStationDataService.findMetProvisionSpalax(curDateTime, pretime, met, stationId); + if (Objects.nonNull(metProvision)) { + double metRate = metProvision.getDataRate(); + double metDataNum = metProvision.getDataNumber(); + mRate.setMet(metRate); + mRate.setMetOfferedNumber(metDataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sohProvision = new ProvisionData(); + String soh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + soh = param.getSoh(); + } else { + soh = calculateDataRate.getMParameter().getSoh(); + } + sohProvision = calCulStationDataService.findSohProvisionSpalax(curDateTime, pretime, soh, stationId); + if (Objects.nonNull(sohProvision)) { + double sohRate = sohProvision.getDataRate(); + double sohDataNum = sohProvision.getDataNumber(); + mRate.setSoh(sohRate); + mRate.setSohOfferedNumber(sohDataNum); + } + + //计算SPHD+MET+SOH数据提供率 SPHD部分 + ProvisionData sphdProvision = calCulStationDataService.findSphdProvisionSpalax(curDateTime, pretime, stationId); + String SPHD_NUM = "0"; + if (Objects.nonNull(sphdProvision)) { + SPHD_NUM = sphdProvision.getDataNumber().toString(); + } + + //获取SPHD+MET+SOH数据提供率 MET部分 + ProvisionData sphdMetProvision = calCulStationDataService.findSphdMetProvisionSpalax(curDateTime, pretime, stationId); + String MET_NUM = "0"; + if (Objects.nonNull(sphdMetProvision)) { + MET_NUM = sphdMetProvision.getDataNumber().toString(); + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sphdMetSohProvision = new ProvisionData(); + String sphdMetSoh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + sphdMetSoh = param.getSphdMetSoh(); + } else { + sphdMetSoh = calculateDataRate.getMParameter().getSphdMetSoh().getSpalaxEverydaynums(); + } + sphdMetSohProvision = calCulStationDataService.findSphdMetSohProvisionSpalax(SPHD_NUM, MET_NUM, curDateTime, pretime, sphdMetSoh, stationId); + if (Objects.nonNull(sphdMetSohProvision)) { + double phd_met_soh = sphdMetSohProvision.getDataRate(); + double pmtDataNum = sphdMetSohProvision.getDataNumber(); + mRate.setPhdMetSoh(phd_met_soh); + mRate.setPmtOfferedNumber(pmtDataNum); + } + return mRate; + } + + public Rate spalaxcalcPLC(CalculateDataRate calculateDataRate, String pretime, String curDateTime) { + Rate mRate = new Rate(); + //region 局部变量 + //获取特殊台站相关集合 + Map mSpecialparam = calculateDataRate.getMSpecialparam(); + //根据台站名称获取对应的 参数信息 + Specialpara param = mSpecialparam.get(calculateDataRate.getMStationCode()); + //获取台站id + String stationId = calculateDataRate.getMStationId(); + + String liveLow, liveHigh, quantity, mdc, collectLow, collectHigh, xeVolume, nuclideName, liveQc, number; + //endregion + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhdf().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getNumber(); + } + ProvisionData phdfProvisionRate = calCulStationDataService.findPhdfProvisionRateSpalax(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionRate)) { + double phdf_offered = phdfProvisionRate.getDataRate(); + double phdf_dataNum = phdfProvisionRate.getDataNumber(); + mRate.setPhdfOffered(phdf_offered); + mRate.setPhdfOfferedNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhdf().getLiveLow(); + liveHigh = param.getPhdf().getLiveHigh(); + quantity = param.getPhdf().getQuantity(); + collectLow = param.getPhdf().getCollectLow(); + collectHigh = param.getPhdf().getCollectHigh(); + liveQc = param.getPhdf().getLiveQc(); + number = param.getPhdf().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getCollectHigh(); + liveQc = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdfSpalaxPLC().getNumber(); + } + ProvisionData phdfProvisionEfficiency = calCulStationDataService.findPhdfProvisionEfficiencySpalaxPLC(liveLow, liveHigh, quantity, collectLow, collectHigh, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionEfficiency)) { + double phdf_efficient = phdfProvisionEfficiency.getDataEfficiency(); + double phdf_dataNum = phdfProvisionEfficiency.getDataNumber(); + mRate.setPhdfEfficient(phdf_efficient); + mRate.setPhdfDataNumber(phdf_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhd().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdSpalaxPLC().getNumber(); + } + ProvisionData phdProvisionRate = calCulStationDataService.findPhdProvisionRateSpalaxPLC(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionRate)) { + double phd_offered = phdProvisionRate.getDataRate(); + double phd_dataNum = phdProvisionRate.getDataNumber(); + mRate.setPhdOffered(phd_offered); + mRate.setPhdOfferedNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhd().getLiveLow(); + liveHigh = param.getPhd().getLiveHigh(); + quantity = param.getPhd().getQuantity(); + collectLow = param.getPhd().getCollectLow(); + collectHigh = param.getPhd().getCollectHigh(); + liveQc = param.getPhd().getLiveQc(); + number = param.getPhd().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdSpalaxPLC().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdSpalaxPLC().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdSpalaxPLC().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdSpalaxPLC().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdSpalaxPLC().getCollectHigh(); + liveQc = calculateDataRate.getMParameter().getPhdSpalaxPLC().getLiveQc(); + number = calculateDataRate.getMParameter().getPhdSpalaxPLC().getNumber(); + } + ProvisionData phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencySpalaxPLC(liveLow, liveHigh, quantity, collectLow, collectHigh, liveQc, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionEfficiency)) { + double phd_efficient = phdProvisionEfficiency.getDataEfficiency(); + double phd_dataNum = phdProvisionEfficiency.getDataNumber(); + mRate.setPhdEfficient(phd_efficient); + mRate.setPhdDataNumber(phd_dataNum); + } + + //判断当前台站编码是否属于特殊计算的台站 计算MET的数据提供率 + String met; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + met = param.getMet(); + } else { + met = calculateDataRate.getMParameter().getMet(); + } + ProvisionData metProvision = calCulStationDataService.findMetProvisionSpalax(curDateTime, pretime, met, stationId); + if (Objects.nonNull(metProvision)) { + double metNum = metProvision.getDataRate(); + double offeredNumber = metProvision.getDataNumber(); + mRate.setMet(metNum); + mRate.setMetOfferedNumber(offeredNumber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + String soh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + soh = param.getSoh(); + } else { + soh = calculateDataRate.getMParameter().getSoh(); + } + ProvisionData sohProvision = calCulStationDataService.findSohProvisionSpalax(curDateTime, pretime, soh, stationId); + if (Objects.nonNull(sohProvision)) { + double sohNum = sohProvision.getDataRate(); + double offeredNumber = sohProvision.getDataNumber(); + mRate.setSoh(sohNum); + mRate.setSohOfferedNumber(offeredNumber); + } + //计算SPHD+MET+SOH数据提供率 SPHD部分 + ProvisionData sphdProvision = calCulStationDataService.findSphdProvisionSpalax(curDateTime, pretime, stationId); + String SPHD_NUM = "0"; + if (Objects.nonNull(sphdProvision)) { + SPHD_NUM = sphdProvision.getDataNumber().toString(); + } + + //获取SPHD+MET+SOH数据提供率 MET部分 + ProvisionData sphdMetProvision = calCulStationDataService.findSphdMetProvisionSpalax(curDateTime, pretime, stationId); + String MET_NUM = "0"; + if (Objects.nonNull(sphdMetProvision)) { + MET_NUM = sphdMetProvision.getDataNumber().toString(); + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + String sphdMetSoh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + sphdMetSoh = param.getSphdMetSoh(); + } else { + sphdMetSoh = calculateDataRate.getMParameter().getSphdMetSoh().getSpalaxEverydaynums(); + } + ProvisionData sphdMetSohProvision = calCulStationDataService.findSphdMetSohProvisionSpalax(SPHD_NUM, MET_NUM, curDateTime, pretime, sphdMetSoh, stationId); + if (Objects.nonNull(sphdMetSohProvision)) { + double phd_met_soh = sphdMetSohProvision.getDataRate(); + double offeredNumber = sphdMetSohProvision.getDataNumber(); + mRate.setPhdMetSoh(phd_met_soh); + mRate.setPmtOfferedNumber(offeredNumber); + } + return mRate; + } + + public Rate particulatecalc(CalculateDataRate calculateDataRate, String pretime, String curDateTime) { + Rate mRate = new Rate(); + //获取特殊台站相关集合 + Map mSpecialparam = calculateDataRate.getMSpecialparam(); + //根据台站名称获取对应的 参数信息 + Specialpara param = mSpecialparam.get(calculateDataRate.getMStationCode()); + //获取台站id + String stationId = calculateDataRate.getMStationId(); + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionRate = new ProvisionData(); + String number; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhdf().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdfParticulate().getNumber(); + } + phdfProvisionRate = calCulStationDataService.findPhdfProvisionRateParticulate(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionRate)) { + double phdf_offered = phdfProvisionRate.getDataRate(); + double phdf_nunmber = phdfProvisionRate.getDataNumber(); + mRate.setPhdfOffered(phdf_offered); + mRate.setPhdfOfferedNumber(phdf_nunmber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHDF的数据提供率 + ProvisionData phdfProvisionEfficiency = new ProvisionData(); + String liveLow; + String liveHigh; + String quantity; + String collectLow; + String collectHigh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhdf().getLiveLow(); + liveHigh = param.getPhdf().getLiveHigh(); + quantity = param.getPhdf().getQuantity(); + collectLow = param.getPhdf().getCollectLow(); + collectHigh = param.getPhdf().getCollectHigh(); + number = param.getPhdf().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdfParticulate().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdfParticulate().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdfParticulate().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdfParticulate().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdfParticulate().getCollectHigh(); + number = calculateDataRate.getMParameter().getPhdfParticulate().getNumber(); + } + phdfProvisionEfficiency = calCulStationDataService.findPhdfProvisionEfficiencyParticulate(liveLow, liveHigh, quantity, collectLow, collectHigh, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdfProvisionEfficiency)) { + double phdf_efficient = phdfProvisionEfficiency.getDataEfficiency(); + double phdf_nunmber = phdfProvisionEfficiency.getDataNumber(); + mRate.setPhdfEfficient(phdf_efficient); + mRate.setPhdfDataNumber(phdf_nunmber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionRate = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + number = param.getPhd().getNumber(); + } else { + number = calculateDataRate.getMParameter().getPhdParticulate().getNumber(); + } + phdProvisionRate = calCulStationDataService.findPhdProvisionRateParticulate(curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionRate)) { + double phd_offered = phdProvisionRate.getDataRate(); + double phd_nunmber = phdProvisionRate.getDataNumber(); + mRate.setPhdOffered(phd_offered); + mRate.setPhdOfferedNumber(phd_nunmber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算PHD的数据提供率 + ProvisionData phdProvisionEfficiency = new ProvisionData(); + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + liveLow = param.getPhd().getLiveLow(); + liveHigh = param.getPhd().getLiveHigh(); + quantity = param.getPhd().getQuantity(); + collectLow = param.getPhd().getCollectLow(); + collectHigh = param.getPhd().getCollectHigh(); + number = param.getPhd().getNumber(); + } else { + liveLow = calculateDataRate.getMParameter().getPhdParticulate().getLiveLow(); + liveHigh = calculateDataRate.getMParameter().getPhdParticulate().getLiveHigh(); + quantity = calculateDataRate.getMParameter().getPhdParticulate().getQuantity(); + collectLow = calculateDataRate.getMParameter().getPhdParticulate().getCollectLow(); + collectHigh = calculateDataRate.getMParameter().getPhdParticulate().getCollectHigh(); + number = calculateDataRate.getMParameter().getPhdParticulate().getNumber(); + } + phdProvisionEfficiency = calCulStationDataService.findPhdProvisionEfficiencyParticulate(liveLow, liveHigh, quantity, collectLow, collectHigh, curDateTime, pretime, number, stationId); + if (Objects.nonNull(phdProvisionEfficiency)) { + double phd_efficient = phdProvisionEfficiency.getDataEfficiency(); + double phd_nunmber = phdProvisionEfficiency.getDataNumber(); + mRate.setPhdEfficient(phd_efficient); + mRate.setPhdDataNumber(phd_nunmber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算MET的数据提供率 + ProvisionData metProvision = new ProvisionData(); + String met; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + met = param.getMet(); + } else { + met = calculateDataRate.getMParameter().getMet(); + } + metProvision = calCulStationDataService.findMetProvisionParticulate(curDateTime, pretime, met, stationId); + if (Objects.nonNull(metProvision)) { + double metRate = metProvision.getDataRate(); + double metNunmber = metProvision.getDataNumber(); + mRate.setMet(metRate); + mRate.setMetOfferedNumber(metNunmber); + } + + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sohProvision = new ProvisionData(); + String soh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + soh = param.getSoh(); + } else { + soh = calculateDataRate.getMParameter().getSoh(); + } + sohProvision = calCulStationDataService.findSohProvisionParticulate(curDateTime, pretime, soh, stationId); + if (Objects.nonNull(sohProvision)) { + double sohRate = sohProvision.getDataRate(); + double sohNunmber = sohProvision.getDataNumber(); + mRate.setSoh(sohRate); + mRate.setSohOfferedNumber(sohNunmber); + } + + //计算SPHD+MET+SOH数据提供率 SPHD部分 + ProvisionData sphdProvision = calCulStationDataService.findSphdProvisionParticulate(curDateTime, pretime, stationId); + String SPHD_NUM = "0"; + if (Objects.nonNull(sphdProvision)) { + SPHD_NUM = sphdProvision.getDataNumber().toString(); + } + + //获取SPHD+MET+SOH数据提供率 MET部分 + ProvisionData sphdMetProvision = calCulStationDataService.findSphdMetProvisionParticulate(curDateTime, pretime, stationId); + String MET_NUM = "0"; + if (Objects.nonNull(sphdMetProvision)) { + MET_NUM = sphdMetProvision.getDataNumber().toString(); + } + //判断当前台站编码是否属于特殊计算的台站 计算SOH的数据提供率 + ProvisionData sphdMetSohProvision = new ProvisionData(); + String sphdMetSoh; + if (mSpecialparam.containsKey(calculateDataRate.getMStationCode())) { + sphdMetSoh = param.getSphdMetSoh(); + } else { + sphdMetSoh = calculateDataRate.getMParameter().getSphdMetSoh().getParticulateEverydaynums(); + } + sphdMetSohProvision = calCulStationDataService.findSphdMetSohProvisionParticulate(SPHD_NUM, MET_NUM, curDateTime, pretime, sphdMetSoh, stationId); + if (Objects.nonNull(sphdMetSohProvision)) { + double phd_met_soh = sphdMetSohProvision.getDataRate(); + double offeredNumber = sphdMetSohProvision.getDataNumber(); + mRate.setPhdMetSoh(phd_met_soh); + mRate.setPmtOfferedNumber(offeredNumber); + } + return mRate; + } + + @Data + class StationProvisionEff implements Serializable { + + private String curtime; + + private String pretime; + + private String stationId; + + private String stationCode; + + private String stationType; + + private String efficCalculType; + + private Rate rate; + + //private StationInfo stationinfo; + + public void setParameter(CalculateDataRate calculateDataRate) { + this.curtime = calculateDataRate.getMCurtime(); + this.pretime = calculateDataRate.getMPretime(); + this.stationId = calculateDataRate.getMStationId(); + this.stationCode = calculateDataRate.getMStationCode(); + this.stationType = calculateDataRate.getMStationType(); + this.efficCalculType = calculateDataRate.getMEfficCalculType(); + this.rate = calculateDataRate.getMRate(); + // this.stationinfo = calculateDataRate.getMStationinfo(); + } + } +} diff --git a/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/controller/WebStatisticsController.java b/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/controller/WebStatisticsController.java index b37e3cb4..f08c2d3f 100644 --- a/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/controller/WebStatisticsController.java +++ b/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/controller/WebStatisticsController.java @@ -12,6 +12,7 @@ import org.jeecg.modules.base.enums.PageType; import org.jeecg.modules.entity.GardsDosDataWeb; import org.jeecg.modules.entity.GardsSampleDataWeb; import org.jeecg.modules.entity.GardsSohDataWeb; +import org.jeecg.modules.feignclient.StationInfoService; import org.jeecg.modules.service.*; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.format.annotation.DateTimeFormat; @@ -49,6 +50,8 @@ public class WebStatisticsController { private IGardsDosDataService gardsDosDataService; @Autowired private IMenuNameService menuNameService; + @Autowired + private StationInfoService stationInfoService; @GetMapping("findStationList") @ApiOperation(value = "根据菜单名称查询对应的台站信息", notes = "根据菜单名称查询对应的台站信息") @@ -259,6 +262,12 @@ public class WebStatisticsController { gardsSampleDataWebService.exportNuclideStatistics(stationIds, systemType, dbName, nuclideNames, startDate, endDate, response); } + @GetMapping("findStationProvisionEfficiency") + @ApiOperation(value="查询台站数据提供率及有效率",notes = "查询台站数据提供率及有效率") + public Result findStationProvisionEfficiency( Integer[] stationIds, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { + Result result=stationInfoService.getStationProvisionEff(stationIds,startTime,endTime); + return result; + } } diff --git a/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/feignclient/StationInfoService.java b/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/feignclient/StationInfoService.java new file mode 100644 index 00000000..9b79678b --- /dev/null +++ b/jeecg-module-web-statistics/src/main/java/org/jeecg/modules/feignclient/StationInfoService.java @@ -0,0 +1,19 @@ +package org.jeecg.modules.feignclient; + +import org.jeecg.common.api.vo.Result; +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.format.annotation.DateTimeFormat; +import org.springframework.stereotype.Component; +import org.springframework.stereotype.Service; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestParam; + +import java.util.Date; + +@Component +@Service +@FeignClient(value = "armd-station-operation",path = "/stationOperation") +public interface StationInfoService { + @GetMapping("/getStationProvisionEff") + Result getStationProvisionEff(@RequestParam Integer[] stationIds,@RequestParam("startTime") @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime,@RequestParam("endTime") @DateTimeFormat(pattern = "yyyy-MM-dd")Date endTime); +}