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..21dcae45 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,77 +25,79 @@ public class StationOperationController { @Autowired private IStationOperationService stationOperationService; + @Autowired + private IStationProvisionEffService stationProvisionEffService; @GetMapping("findStationType") @ApiOperation(value = "查询台站/核设施类型", notes = "查询台站/核设施类型") - public List findStationType(){ + public List findStationType() { List result = stationOperationService.findStationType(); return result; } @GetMapping("findList") @ApiOperation(value = "查询台站/核设施信息", notes = "查询台站/核设施信息") - public List findList(String status, String stationType){ + public List findList(String status, String stationType) { List result = stationOperationService.findList(status, stationType); return result; } @GetMapping("findListApp") @ApiOperation(value = "查询台站/核设施信息", notes = "查询台站/核设施信息") - public List findListApp(@RequestParam String status,@RequestParam String stationType){ + public List findListApp(@RequestParam String status, @RequestParam String stationType) { List result = stationOperationService.findList(status, stationType); return result; } @GetMapping("findInfo") @ApiOperation(value = "查询台站/核设施详情信息", notes = "查询台站/核设施详情信息") - public Result findInfo(String stationId, String type){ + public Result findInfo(String stationId, String type) { Result result = stationOperationService.findInfo(stationId, type); return result; } @GetMapping("findInfoApp") @ApiOperation(value = "查询台站/核设施详情信息", notes = "查询台站/核设施详情信息") - public Result findInfoApp(@RequestParam String stationId,@RequestParam String type){ + public Result findInfoApp(@RequestParam String stationId, @RequestParam String type) { Result result = stationOperationService.findInfo(stationId, type); return result; } @GetMapping("findTree") @ApiOperation(value = "查询台站树形结构", notes = "查询台站树形结构") - public Result findTree(){ + public Result findTree() { Result result = stationOperationService.findTree(); return result; } @PostMapping("getHitEquList") @ApiOperation(value = "查询半径内核设施信息", notes = "查询半径内核设施信息") - public Result getHitEquList(@RequestBody PointVo pointVo){ + public Result getHitEquList(@RequestBody PointVo pointVo) { Result result = stationOperationService.getHitEquList(pointVo); return result; } @GetMapping("getDataReceivingStatus") @ApiOperation(value = "查询台站监测数据信息", notes = "查询台站监测数据信息") - public Result getDataReceivingStatus(String userId, Double cacheTime, String oneStationId){ + public Result getDataReceivingStatus(String userId, Double cacheTime, String oneStationId) { return stationOperationService.getDataReceivingStatus(userId, cacheTime, oneStationId); } @GetMapping("getDataReceivingStatusApp") @ApiOperation(value = "查询台站监测数据信息", notes = "查询台站监测数据信息") - public Result getDataReceivingStatusApp(@RequestParam String userId,@RequestParam Double cacheTime,@RequestParam String oneStationId){ + public Result getDataReceivingStatusApp(@RequestParam String userId, @RequestParam Double cacheTime, @RequestParam String oneStationId) { return stationOperationService.getDataReceivingStatus(userId, cacheTime, oneStationId); } @GetMapping("getDataProvisionEfficiency") @ApiOperation(value = "查询台站数据提供率及有效率", notes = "查询台站数据提供率及有效率") - public Result getDataProvisionEfficiency(){ + public Result getDataProvisionEfficiency() { return stationOperationService.getDataProvisionEfficiency(); } @GetMapping("getMapUrl") @ApiOperation(value = "获取地图地址", notes = "获取地图地址") - public Result getMapUrl(){ + public Result getMapUrl() { Result result = Result.OK(); result.setResult(mapUrl); return result; @@ -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 f28a02d5..3958b027 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 @@ -11,6 +11,7 @@ import org.jeecg.modules.base.entity.configuration.GardsStations; import org.jeecg.modules.base.enums.PageType; 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; @@ -46,10 +47,12 @@ public class WebStatisticsController { private IGardsAlertDataService gardsAlertDataService; @Autowired private IMenuNameService menuNameService; + @Autowired + private StationInfoService stationInfoService; @GetMapping("findStationList") @ApiOperation(value = "根据菜单名称查询对应的台站信息", notes = "根据菜单名称查询对应的台站信息") - public Result findStationList(String menuName){ + public Result findStationList(String menuName) { Result result = new Result(); List gardsStations = menuNameService.findStationListByMenuName(menuName); result.setSuccess(true); @@ -59,7 +62,7 @@ public class WebStatisticsController { @GetMapping("findStationListApp") @ApiOperation(value = "根据菜单名称查询对应的台站信息", notes = "根据菜单名称查询对应的台站信息") - public Result findStationListApp(@RequestParam String menuName){ + public Result findStationListApp(@RequestParam String menuName) { Result result = new Result(); List gardsStations = menuNameService.findStationListByMenuName(menuName); result.setSuccess(true); @@ -70,77 +73,77 @@ public class WebStatisticsController { @GetMapping("findParticulatePage") @ApiOperation(value = "气溶胶分页查询", notes = "气溶胶分页查询") public Result findParticulatePage(QueryRequest queryRequest, Integer[] stationIds, String dataType, - String spectralQualifie, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime,@DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime){ + String spectralQualifie, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { return gardsSampleDataWebService.findParticulatePage(queryRequest, stationIds, dataType, spectralQualifie, startTime, endTime); } @GetMapping("findMetPage") @ApiOperation(value = "气象数据分页查询", notes = "气象数据分页查询") - public Result findMetPage(QueryRequest queryRequest, Integer[] stationIds,@DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime,@DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime){ + public Result findMetPage(QueryRequest queryRequest, Integer[] stationIds, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { return gardsMetDataService.findMetPage(queryRequest, stationIds, startTime, endTime); } @GetMapping("findSohPage") @ApiOperation(value = "状态数据分页查询", notes = "状态数据分页查询") - public Result findSohPage(QueryRequest queryRequest, Integer[] stationIds,@DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime,@DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime){ + public Result findSohPage(QueryRequest queryRequest, Integer[] stationIds, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { return gardsSohDataService.findSohPage(queryRequest, stationIds, startTime, endTime); } @GetMapping("findAlertSohPage") @ApiOperation(value = "台站报警数据分页查询", notes = "台站报警数据分页查询") - public Result findAlertSohPage(QueryRequest queryRequest, Integer[] stationIds,@DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime,@DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime){ + public Result findAlertSohPage(QueryRequest queryRequest, Integer[] stationIds, @DateTimeFormat(pattern = "yyyy-MM-dd") Date startTime, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endTime) { return gardsSohDataService.findAlertSohPage(queryRequest, stationIds, startTime, endTime); } @GetMapping("findGeneratedReport") @ApiOperation(value = "查询报告详情页面", notes = "查询报告详情页面") - public Result findGeneratedReport(Integer sampleId){ + public Result findGeneratedReport(Integer sampleId) { return gardsSampleDataWebService.findGeneratedReport(sampleId); } @GetMapping("sampleInfo") @ApiOperation(value = "查看谱的详细信息", notes = "查看谱的详细信息") - public Result sampleInfo(@RequestParam Integer sampleId){ + public Result sampleInfo(@RequestParam Integer sampleId) { return gardsSampleDataWebService.sampleInfo(sampleId); } @GetMapping("radionuclideFile") @ApiOperation("查看Radionuclide的文件") public Result radionuclideFile(@RequestParam Integer sampleId, - HttpServletResponse response){ + HttpServletResponse response) { GardsSampleDataWeb sampleData = gardsSampleDataWebService.getOneSample(sampleId); String filePath = sampleData.getInputFileName(); if (StrUtil.isBlank(filePath)) return Result.error(Prompt.FILE_NOT_EXITS); - return readLineUtil.readFtpFile(filePath,response); + return readLineUtil.readFtpFile(filePath, response); } @GetMapping("downloadFile") @ApiOperation("查看Radionuclide的文件") - public void downloadFile(@RequestParam Integer sampleId, HttpServletResponse response){ + public void downloadFile(@RequestParam Integer sampleId, HttpServletResponse response) { gardsSampleDataWebService.downloadFile(sampleId, response); } @GetMapping("sohFile") - @ApiOperation(value = "查看RMSSHO的文件",notes = "查看RMSSHO的文件") + @ApiOperation(value = "查看RMSSHO的文件", notes = "查看RMSSHO的文件") public Result sohFile(@RequestParam Integer sohId, - HttpServletResponse response){ + HttpServletResponse response) { GardsSohDataWeb soh = gardsSohDataService.getOneSoh(sohId); String filePath = soh.getInputFileName(); if (StrUtil.isBlank(filePath)) return Result.error(Prompt.FILE_NOT_EXITS); - return readLineUtil.readFtpFile(filePath,response); + return readLineUtil.readFtpFile(filePath, response); } @GetMapping("arFile") @ApiOperation(value = "查看ARR/RRR的文件", notes = "查看ARR/RRR的文件") public Result arFile(@RequestParam String type, @RequestParam Integer sampleId, - HttpServletResponse response){ + HttpServletResponse response) { String reportPath = ""; - if (PageType.ARR.getType().equals(type)){ // 自动处理 + if (PageType.ARR.getType().equals(type)) { // 自动处理 reportPath = autoService.getOne(sampleId).getReportPath(); - }else if (PageType.RRR.getType().equals(type)){ // 人工交互 + } else if (PageType.RRR.getType().equals(type)) { // 人工交互 reportPath = reviewedService.getOne(sampleId).getReportPath(); } if (StrUtil.isBlank(reportPath)) @@ -148,65 +151,65 @@ public class WebStatisticsController { // 将FTP上的文件转为文件流返回到前端 if (!reportPath.endsWith(txt.getType())) reportPath += txt.getType(); - return readLineUtil.readFtpFile(reportPath,response); + return readLineUtil.readFtpFile(reportPath, response); } @GetMapping("radionuclideExport") - @ApiOperation(value = "导出Radionuclide的Excel",notes = "导出Radionuclide的Excel") + @ApiOperation(value = "导出Radionuclide的Excel", notes = "导出Radionuclide的Excel") public void radionuclideExport(@RequestParam Integer[] stationIds, @RequestParam String dataType, @RequestParam String pageType, String spectralQualifie, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ + HttpServletResponse response) { gardsSampleDataWebService.radionuclideExport(stationIds, dataType, pageType, spectralQualifie, startTime, endTime, response); } @GetMapping("alertsExport") - @ApiOperation(value = "导出Alerts的Excel",notes = "导出Alerts的Excel") + @ApiOperation(value = "导出Alerts的Excel", notes = "导出Alerts的Excel") public void alertsExport(@RequestParam Integer[] stationIds, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ - gardsAlertDataService.alertsExport(stationIds, startTime, endTime,response); + HttpServletResponse response) { + gardsAlertDataService.alertsExport(stationIds, startTime, endTime, response); } @GetMapping("sohExport") - @ApiOperation(value = "导出RMSSOH的Excel",notes = "导出RMSSOH的Excel") + @ApiOperation(value = "导出RMSSOH的Excel", notes = "导出RMSSOH的Excel") public void sohExport(@RequestParam Integer[] stationIds, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ + HttpServletResponse response) { gardsSohDataService.sohExport(stationIds, startTime, endTime, response); } @GetMapping("metExport") - @ApiOperation(value = "导出Met的Excel",notes = "导出Met的Excel") + @ApiOperation(value = "导出Met的Excel", notes = "导出Met的Excel") public void metExport(@RequestParam Integer[] stationIds, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ + HttpServletResponse response) { gardsMetDataService.metExport(stationIds, startTime, endTime, response); } @GetMapping("arrExport") - @ApiOperation(value = "导出ARR的Excel",notes = "导出ARR的Excel") + @ApiOperation(value = "导出ARR的Excel", notes = "导出ARR的Excel") public void arrExport(@RequestParam Integer[] stationIds, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ - autoService.arrExport(stationIds,startTime,endTime,response); + HttpServletResponse response) { + autoService.arrExport(stationIds, startTime, endTime, response); } @GetMapping("rrrExport") - @ApiOperation(value = "导出RRR的Excel",notes = "导出RRR的Excel") + @ApiOperation(value = "导出RRR的Excel", notes = "导出RRR的Excel") public void rrrExport(@RequestParam Integer[] stationIds, @RequestParam String startTime, @RequestParam String endTime, - HttpServletResponse response){ - reviewedService.rrrExport(stationIds, startTime, endTime,response); + HttpServletResponse response) { + reviewedService.rrrExport(stationIds, startTime, endTime, response); } @GetMapping("findNuclideList") @@ -218,7 +221,7 @@ public class WebStatisticsController { @GetMapping("findNuclideStatistics") @ApiOperation(value = "查询核素统计结果", notes = "查询核素统计结果") public Result findNuclideStatistics(String stationId, String systemType, String dbName, String[] nuclideNames, - @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate) { + @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate) { return gardsSampleDataWebService.findNuclideStatistics(stationId, systemType, dbName, nuclideNames, startDate, endDate); } @@ -230,6 +233,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); +}