package com.finance.web.controller.service;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.finance.common.basic.PageDTO;
|
import com.finance.common.core.domain.entity.SysUser;
|
import com.finance.common.enums.AreaLevelEnum;
|
import com.finance.common.enums.DataScreenConfigEnum;
|
import com.finance.common.enums.ReportingStatusEnum;
|
import com.finance.common.enums.RiskLevelEnum;
|
import com.finance.common.enums.ShowStatusEnum;
|
import com.finance.common.enums.SubTypeEnum;
|
import com.finance.common.enums.UserTypeEnum;
|
import com.finance.common.utils.BeanUtils;
|
import com.finance.common.utils.CollUtils;
|
import com.finance.common.utils.DateUtils;
|
import com.finance.common.utils.StringUtils;
|
import com.finance.system.domain.TbBasicData;
|
import com.finance.system.domain.TbBasicDataCategory;
|
import com.finance.system.domain.TbQuestion;
|
import com.finance.system.query.CalculateDetailQuery;
|
import com.finance.system.query.DeptCalculateDetailQuery;
|
import com.finance.system.query.TransferPaymentScaleQuery;
|
import com.finance.system.service.ISysUserService;
|
import com.finance.system.service.TbBasicDataCategoryService;
|
import com.finance.system.service.TbBasicDataConfigService;
|
import com.finance.system.service.TbBasicDataService;
|
import com.finance.system.service.TbDataScreenConfigService;
|
import com.finance.system.service.TbDataScreenScoreService;
|
import com.finance.system.service.TbQuestionService;
|
import com.finance.system.service.TbScoreService;
|
import com.finance.system.vo.BasicDataVO;
|
import com.finance.system.vo.CurrentFieldsDetailVO;
|
import com.finance.system.vo.DataAnalysisVO;
|
import com.finance.system.vo.DataScreenConfigVO;
|
import com.finance.system.vo.DataScreenScoreVO;
|
import com.finance.system.vo.DeptCalculateDetailVO;
|
import com.finance.system.vo.FieldAndScoreDataVO;
|
import com.finance.system.vo.ProvinceStaticsVO;
|
import com.finance.system.vo.QuestionVO;
|
import com.finance.system.vo.RiskAndTransferVO;
|
import com.finance.system.vo.RiskCountVO;
|
import com.finance.system.vo.RiskLevelVO;
|
import com.finance.system.vo.RiskMapVO;
|
import com.finance.system.vo.RiskRankingVO;
|
import com.finance.system.vo.ScoreCalculateDetailVO;
|
import com.finance.system.vo.ScoreDataVO;
|
import com.finance.system.vo.ScoreRankVO;
|
import com.finance.system.vo.ScoreRateDataVO;
|
import com.finance.system.vo.TransferPaymentScaleVO;
|
import com.google.common.collect.Lists;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
/**
|
* @author mitao
|
* @date 2024/4/16
|
*/
|
@Service
|
@Slf4j
|
@RequiredArgsConstructor
|
public class ScreenService {
|
|
private final ISysUserService sysUserService;
|
private final TbBasicDataService tbBasicDataService;
|
private final TbDataScreenScoreService tbDataScreenScoreService;
|
private final TbDataScreenConfigService tbDataScreenConfigService;
|
private final TbQuestionService tbQuestionService;
|
private final TbScoreService tbScoreService;
|
private final TbBasicDataConfigService tbBasicDataConfigService;
|
private final TbBasicDataCategoryService tbBasicDataCategoryService;
|
|
public ProvinceStaticsVO provinceStatics() {
|
ProvinceStaticsVO vo = new ProvinceStaticsVO();
|
int provinceCount = getCount(AreaLevelEnum.PROVINCE);
|
int cityCount = getCount(AreaLevelEnum.CITY);
|
int developmentZonesCount = getCount(AreaLevelEnum.DEVELOPMENT_ZONES);
|
int countyCount = getCount(AreaLevelEnum.COUNTY);
|
|
vo.setProvinceCount(provinceCount);
|
vo.setCityCount(cityCount);
|
vo.setDevelopmentZonesCount(developmentZonesCount);
|
vo.setCountyCount(countyCount);
|
return vo;
|
}
|
|
private int getCount(AreaLevelEnum level) {
|
return (int) sysUserService.count(
|
Wrappers.<SysUser>lambdaQuery().eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT)
|
.eq(SysUser::getAreaLevel, level));
|
}
|
|
public PageDTO<TransferPaymentScaleVO> transferPaymentScalePage(
|
TransferPaymentScaleQuery query) {
|
Page<TransferPaymentScaleVO> pageVO = tbBasicDataService.transferPaymentScalePage(
|
new Page<TransferPaymentScaleVO>(query.getPageNum(), query.getPageSize()),
|
query.getQuarter());
|
return PageDTO.of(pageVO);
|
}
|
|
public List<BasicDataVO> quarterList() {
|
List<TbBasicData> list = tbBasicDataService.lambdaQuery().select(TbBasicData::getQuarter)
|
.groupBy(TbBasicData::getQuarter)
|
.eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED).list();
|
return BeanUtils.copyList(list, BasicDataVO.class);
|
}
|
|
public RiskAndTransferVO getRiskAndTransfer() throws Exception {
|
RiskAndTransferVO riskAndTransferVO = new RiskAndTransferVO();
|
// 查询省本级得分排名
|
ScoreRankVO scoreRankVO = tbScoreService.queryRankAndScoreByAreaCode("510000");
|
riskAndTransferVO.setScoreRankVO(scoreRankVO);
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
// 查询转移支付规模总额
|
List<TbBasicData> list = tbBasicDataService.lambdaQuery()
|
.select(TbBasicData::getTransferPaymentScale)
|
.eq(TbBasicData::getQuarter, previousQuarter)
|
// .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
|
.list();
|
Optional<Double> reduce = list.stream()
|
.map(tbBasicData -> Double.parseDouble(tbBasicData.getTransferPaymentScale()))
|
.reduce(Double::sum);
|
riskAndTransferVO.setTransferPaymentScale(reduce.orElse(0D));
|
// 查询风险等级设置
|
DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
|
List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);
|
riskAndTransferVO.setRiskLevelVOList(riskLevelVOList);
|
RiskCountVO riskCountVO = new RiskCountVO();
|
// 地图市域得分
|
List<RiskMapVO> riskMapVOList = tbScoreService.getCityScore(previousQuarter,
|
riskLevel);
|
// List<RiskMapVO> riskMapVOList = tbScoreService.getCurrentScoreList(previousQuarter, null);
|
String[] noRiskArr = riskLevel.getNoRisk().split("_");
|
String[] lowRiskArr = riskLevel.getLowRisk().split("_");
|
String[] mediumRiskArr = riskLevel.getMediumRisk().split("_");
|
String[] highRiskArr = riskLevel.getHighRisk().split("_");
|
List<RiskMapVO> cityRiskVO = riskMapVOList.stream()
|
.filter(r -> r.getAreaLevel().equals(AreaLevelEnum.CITY))
|
.collect(Collectors.toList());
|
long noRiskCount = cityRiskVO.stream()
|
.filter(item -> item.getScore() >= Double.parseDouble(noRiskArr[0])
|
&& item.getScore() <= Double.parseDouble(noRiskArr[1])).count();
|
riskCountVO.setNoRiskCount((int) noRiskCount);
|
long lowRiskCount = cityRiskVO.stream()
|
.filter(item -> item.getScore() >= Double.parseDouble(lowRiskArr[0])
|
&& item.getScore() <= Double.parseDouble(lowRiskArr[1])).count();
|
riskCountVO.setLowRiskCount((int) lowRiskCount);
|
long mediumRiskCount = cityRiskVO.stream()
|
.filter(item -> item.getScore() >= Double.parseDouble(mediumRiskArr[0])
|
&& item.getScore() <= Double.parseDouble(mediumRiskArr[1])).count();
|
riskCountVO.setMediumRiskCount((int) mediumRiskCount);
|
long highRiskCount = cityRiskVO.stream()
|
.filter(item -> item.getScore() >= Double.parseDouble(highRiskArr[0])
|
&& item.getScore() <= Double.parseDouble(highRiskArr[1])).count();
|
riskCountVO.setHighRiskCount((int) highRiskCount);
|
|
/*for (RiskLevelVO vo : riskLevelVOList) {
|
long count = riskMapVOList.stream()
|
.filter(r -> r.getAreaLevel().equals(AreaLevelEnum.CITY))
|
.filter(item -> item.getScore() >= vo.getMin()
|
&& item.getScore() <= vo.getMax()).count();
|
|
if (vo.getRiskLevel().equals(RiskLevelEnum.L1)) {
|
riskCountVO.setNoRiskCount((int) count);
|
} else if (vo.getRiskLevel().equals(RiskLevelEnum.L2)) {
|
riskCountVO.setLowRiskCount((int) count);
|
} else if (vo.getRiskLevel().equals(RiskLevelEnum.L3)) {
|
riskCountVO.setMediumRiskCount((int) count);
|
} else if (vo.getRiskLevel().equals(RiskLevelEnum.L4)) {
|
riskCountVO.setHighRiskCount((int) count);
|
}
|
}*/
|
// TODO
|
// riskCountVO.setNoRiskCount(50);
|
// riskCountVO.setLowRiskCount(45);
|
// riskCountVO.setMediumRiskCount(30);
|
// riskCountVO.setHighRiskCount(80);
|
riskAndTransferVO.setRiskCountVO(riskCountVO);
|
// 查询风险配置对应得分
|
// List<RiskMapVO> riskMapVOList = tbDataScreenScoreService.queryScore4Map(nowQuarter,
|
// riskLevel.getId());
|
|
riskAndTransferVO.setRiskMapVOList(riskMapVOList);
|
return riskAndTransferVO;
|
}
|
|
private List<RiskLevelVO> formatRiskLevel(DataScreenConfigVO riskLevel) {
|
String[] noRiskArr = riskLevel.getNoRisk().split("_");
|
String[] lowRiskArr = riskLevel.getLowRisk().split("_");
|
String[] mediumRiskArr = riskLevel.getMediumRisk().split("_");
|
String[] highRiskArr = riskLevel.getHighRisk().split("_");
|
return handleRiskLevel(noRiskArr, lowRiskArr, mediumRiskArr,
|
highRiskArr);
|
}
|
|
private List<RiskLevelVO> handleRiskLevel(String[] noRiskArr, String[] lowRiskArr,
|
String[] mediumRiskArr, String[] highRiskArr) {
|
List<RiskLevelVO> list = new ArrayList<>();
|
String min = noRiskArr[0];
|
String max = noRiskArr[1];
|
RiskLevelVO vo1 = new RiskLevelVO();
|
vo1.setRiskLevel(RiskLevelEnum.L1);
|
vo1.setMin(Double.parseDouble(min));
|
vo1.setMax(Double.parseDouble(max));
|
list.add(vo1);
|
min = lowRiskArr[0];
|
max = lowRiskArr[1];
|
RiskLevelVO vo2 = new RiskLevelVO();
|
vo2.setRiskLevel(RiskLevelEnum.L2);
|
vo2.setMin(Double.parseDouble(min));
|
vo2.setMax(Double.parseDouble(max));
|
list.add(vo2);
|
min = mediumRiskArr[0];
|
max = mediumRiskArr[1];
|
RiskLevelVO vo3 = new RiskLevelVO();
|
vo3.setRiskLevel(RiskLevelEnum.L3);
|
vo3.setMin(Double.parseDouble(min));
|
vo3.setMax(Double.parseDouble(max));
|
list.add(vo3);
|
min = highRiskArr[0];
|
max = highRiskArr[1];
|
RiskLevelVO vo4 = new RiskLevelVO();
|
vo4.setRiskLevel(RiskLevelEnum.L4);
|
vo4.setMin(Double.parseDouble(min));
|
vo4.setMax(Double.parseDouble(max));
|
list.add(vo4);
|
return list;
|
}
|
|
public List<RiskRankingVO> riskRanking() throws Exception {
|
DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
|
List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);
|
List<RiskRankingVO> voList = tbScoreService.queryRiskRanking(
|
DateUtils.getPreviousQuarter());
|
// List<RiskRankingVO> voList = tbScoreService.queryRiskRanking(
|
// "2024年一季度");
|
int rank = 1;
|
for (RiskRankingVO riskRankingVO : voList) {
|
riskRankingVO.setRank(rank++);
|
for (RiskLevelVO vo : riskLevelVOList) {
|
// if (vo.getRiskLevel().equals(RiskLevelEnum.L1)
|
// && riskRankingVO.getScore() <= vo.getMin()) {
|
// riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
|
// }
|
if (riskRankingVO.getScore() >= vo.getMin()
|
&& riskRankingVO.getScore() <= vo.getMax()) {
|
riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
|
}
|
// if (vo.getRiskLevel().equals(RiskLevelEnum.L4)
|
// && riskRankingVO.getScore() >= vo.getMax()) {
|
// riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
|
// }
|
}
|
}
|
return voList;
|
}
|
|
public List<QuestionVO> queryQuestions() throws Exception {
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
List<TbQuestion> list = tbQuestionService.lambdaQuery()
|
.eq(TbQuestion::getQuarter, previousQuarter).list();
|
return BeanUtils.copyList(list, QuestionVO.class);
|
}
|
|
public DataAnalysisVO getDataAnalysis(String areaCode) throws Exception {
|
DataAnalysisVO dataAnalysisVO = new DataAnalysisVO();
|
// 查询得分排名
|
ScoreRankVO scoreRankVO = tbScoreService.queryRankAndScoreByAreaCode(areaCode);
|
if (Objects.isNull(scoreRankVO)) {
|
return dataAnalysisVO;
|
}
|
dataAnalysisVO.setRank(scoreRankVO.getRank());
|
dataAnalysisVO.setScore(scoreRankVO.getScore());
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
// 查询问题
|
List<TbQuestion> list = tbQuestionService.lambdaQuery()
|
.eq(TbQuestion::getQuarter, previousQuarter)
|
.eq(TbQuestion::getDeptAreaCode, areaCode)
|
.list();
|
List<QuestionVO> questionVOS = BeanUtils.copyList(list, QuestionVO.class);
|
dataAnalysisVO.setQuestions(questionVOS);
|
SysUser user = sysUserService.lambdaQuery()
|
.eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT)
|
.eq(SysUser::getAreaCode, areaCode).one();
|
if (Objects.isNull(user)) {
|
return dataAnalysisVO;
|
}
|
dataAnalysisVO.setAreaName(user.getDeptName());
|
// 查询风险得分
|
DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
|
List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);
|
|
dataAnalysisVO.setYearScore(getYearScore(areaCode, previousQuarter));
|
String lastYearQuarter = DateUtils.getLastYearQuarter(previousQuarter);
|
dataAnalysisVO.setLastYearScore(getYearScore(areaCode, lastYearQuarter));
|
// 查询风险等级
|
List<RiskMapVO> currentScoreList = tbScoreService.getCurrentScoreList(previousQuarter,
|
areaCode);
|
|
for (RiskMapVO tbDataScreenScore : currentScoreList) {
|
for (RiskLevelVO vo : riskLevelVOList) {
|
if (tbDataScreenScore.getScore() >= vo.getMin()
|
&& tbDataScreenScore.getScore() <= vo.getMax()) {
|
dataAnalysisVO.setRiskLevel(vo.getRiskLevel().getCode());
|
}
|
}
|
}
|
// 查询四个指标下的三级指标
|
List<FieldAndScoreDataVO> voList =
|
tbBasicDataService.getFieldAndScoreData(areaCode, previousQuarter, 1, 2);
|
List<FieldAndScoreDataVO> lastYearList =
|
tbBasicDataService.getFieldAndScoreData(areaCode, lastYearQuarter, 2, 2);
|
// 查询四个指标下的三级指标
|
List<FieldAndScoreDataVO> allDeptVoList =
|
tbBasicDataService.getFieldAndScoreData(areaCode, previousQuarter, 1, 1);
|
// 查询形式指标得分
|
dataAnalysisVO.setScoreDataList(handleDataIndicators(voList, lastYearList));
|
// 查询数据指标得分
|
dataAnalysisVO.setScoreRateDataList(handleDataIndicatorsRate(allDeptVoList, voList));
|
// 查询大屏下方字段列表
|
List<TbBasicDataCategory> categoryList = tbBasicDataCategoryService.lambdaQuery()
|
.eq(TbBasicDataCategory::getParentId, -1)
|
.eq(TbBasicDataCategory::getStatus, ShowStatusEnum.SHOW)
|
.last("limit 4").list();
|
|
if (categoryList.isEmpty()) {
|
dataAnalysisVO.setScoreRateDataListOne(CollUtils.emptyList());
|
dataAnalysisVO.setScoreRateDataListTwo(CollUtils.emptyList());
|
dataAnalysisVO.setScoreRateDataListThree(CollUtils.emptyList());
|
dataAnalysisVO.setScoreRateDataListFour(CollUtils.emptyList());
|
} else {
|
dataAnalysisVO.setScoreRateDataListOne(getLevelThreeIndicators(voList, "财政经济形势"));
|
dataAnalysisVO.setScoreRateDataListTwo(getLevelThreeIndicators(voList, "预算管理方面"));
|
dataAnalysisVO.setScoreRateDataListThree(
|
getLevelThreeIndicators(voList, "预算执行方面"));
|
dataAnalysisVO.setScoreRateDataListFour(
|
getLevelThreeIndicators(voList, "风险防控方面"));
|
}
|
return dataAnalysisVO;
|
}
|
|
private List<ScoreRateDataVO> handleDataIndicatorsRate(List<FieldAndScoreDataVO> allDeptVoList,
|
List<FieldAndScoreDataVO> voList) {
|
List<ScoreRateDataVO> result = new ArrayList<>();
|
|
List<String> indicatorList = Lists.newArrayList("财政经济形势", "预算管理方面",
|
"预算执行方面", "风险防控方面");
|
for (int i = 0; i < indicatorList.size(); i++) {
|
ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
|
if (CollUtils.isEmpty(voList)) {
|
scoreRateDataVO.setRank(0);
|
scoreRateDataVO.setScore(0D);
|
scoreRateDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
|
scoreRateDataVO.setScoreRate(0D);
|
} else {
|
Double indicatorOne = getLevelThreeIndicators(voList, indicatorList.get(i)).stream()
|
.map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
|
.map(BigDecimal::valueOf)
|
.orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP)
|
.doubleValue();
|
List<Double> allIndicatorsScore = getAllIndicatorsScoreByName(allDeptVoList,
|
indicatorList.get(i));
|
allIndicatorsScore.add(indicatorOne);
|
allIndicatorsScore.sort(Comparator.comparing(Double::doubleValue).reversed());
|
scoreRateDataVO.setRank(allIndicatorsScore.indexOf(indicatorOne) + 1);
|
scoreRateDataVO.setScore(indicatorOne);
|
scoreRateDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
|
scoreRateDataVO.setScoreRate(BigDecimal.valueOf(indicatorOne)
|
.divide(BigDecimal.valueOf(voList.get(i).getLevelOneIndicatorMaxScore()), 2,
|
RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100L))
|
.doubleValue());
|
}
|
result.add(scoreRateDataVO);
|
}
|
return result;
|
}
|
|
private List<Double> getAllIndicatorsScoreByName(List<FieldAndScoreDataVO> allDeptVoList,
|
String indicatorName) {
|
Map<String, List<FieldAndScoreDataVO>> collect = allDeptVoList.stream()
|
.collect(Collectors.groupingBy(FieldAndScoreDataVO::getDeptAreaCode));
|
return collect.keySet().stream().map(key -> {
|
Double score = getLevelThreeIndicators(collect.get(key), indicatorName).stream()
|
.map(FieldAndScoreDataVO::getScore).reduce(Double::sum).orElse(0D);
|
return score;
|
}).sorted(Comparator.comparing(Double::intValue).reversed()).collect(Collectors.toList());
|
}
|
|
private List<ScoreDataVO> handleDataIndicators(List<FieldAndScoreDataVO> voList,
|
List<FieldAndScoreDataVO> lastYearList) {
|
List<ScoreDataVO> scoreDataVOList = new ArrayList<>();
|
List<String> indicatorList = Lists.newArrayList("财政经济形势", "预算管理方面",
|
"预算执行方面", "风险防控方面");
|
for (int i = 0; i < indicatorList.size(); i++) {
|
ScoreDataVO scoreDataVO = new ScoreDataVO();
|
if (CollUtils.isEmpty(voList)) {
|
scoreDataVO.setLastScore(0D);
|
scoreDataVO.setScore(0D);
|
scoreDataVO.setMaxScore(0D);
|
scoreDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
|
} else {
|
Double indicatorOne = getLevelThreeIndicators(voList,
|
indicatorList.get(i)).stream()
|
.map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
|
.map(BigDecimal::valueOf)
|
.orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP)
|
.doubleValue();
|
Double indicatorOneLastYear = getLevelThreeIndicators(lastYearList,
|
indicatorList.get(i)).stream()
|
.map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
|
.map(BigDecimal::valueOf)
|
.orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
scoreDataVO.setLastScore(indicatorOneLastYear);
|
scoreDataVO.setScore(indicatorOne);
|
scoreDataVO.setMaxScore(voList.get(0).getLevelOneIndicatorMaxScore());
|
scoreDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
|
}
|
scoreDataVOList.add(scoreDataVO);
|
}
|
return scoreDataVOList;
|
}
|
|
private List<FieldAndScoreDataVO> getLevelThreeIndicators(List<FieldAndScoreDataVO> voList,
|
String indicatorName) {
|
return voList.stream().map(vo -> {
|
if (StringUtils.isNotBlank(vo.getLevelOneIndicator())) {
|
if (StringUtils.trim(vo.getLevelOneIndicator()).equals(indicatorName)) {
|
return vo;
|
} else {
|
if (StringUtils.isNotBlank(vo.getLevelTwoIndicator())
|
&& StringUtils.trim(vo.getLevelTwoIndicator()).equals(indicatorName)) {
|
return vo;
|
}
|
}
|
}
|
return null;
|
}).filter(Objects::nonNull).collect(Collectors.toList());
|
}
|
|
private Double getYearScore(String areaCode, String previousQuarter) {
|
List<RiskMapVO> thisYearScoreList = tbScoreService.getScoreByYearType(areaCode,
|
previousQuarter);
|
return thisYearScoreList.stream().map(RiskMapVO::getScore)
|
.reduce(Double::sum).map(BigDecimal::valueOf).orElse(BigDecimal.ZERO)
|
.setScale(2, RoundingMode.HALF_UP).doubleValue();
|
}
|
|
private void handleDataIndicators(String areaCode, List<ScoreDataVO> scoreDataVOList) {
|
List<DataScreenScoreVO> formalIndicatorsYear = tbDataScreenScoreService.selectIndicators(
|
areaCode, null, DataScreenConfigEnum.FORMAL_INDICATORS, 1);
|
if (CollUtils.isNotEmpty(formalIndicatorsYear)) {
|
// 形式指标一
|
for (SubTypeEnum value : SubTypeEnum.values()) {
|
ScoreDataVO scoreDataVO = new ScoreDataVO();
|
scoreDataVO.setSubType(value);
|
List<DataScreenScoreVO> formalIndicators = formalIndicatorsYear.stream()
|
.filter(item -> item.getSubType().equals(value)).collect(
|
Collectors.toList());
|
scoreDataVO.setMaxScore(formalIndicators.get(0).getMaxScore());
|
Optional<Double> formalIndicatorsYearScore = formalIndicators.stream()
|
.map(DataScreenScoreVO::getScore)
|
.reduce(Double::sum);
|
scoreDataVO.setScore(formalIndicatorsYearScore.orElse(0D));
|
List<DataScreenScoreVO> formalIndicatorsListYear = tbDataScreenScoreService.selectIndicators(
|
areaCode, null, DataScreenConfigEnum.FORMAL_INDICATORS, 2);
|
List<DataScreenScoreVO> formalIndicatorsLastYear = formalIndicatorsListYear.stream()
|
.filter(item -> item.getSubType().equals(value)).collect(
|
Collectors.toList());
|
Optional<Double> formalIndicatorsListYearScore = formalIndicatorsLastYear.stream()
|
.map(DataScreenScoreVO::getScore)
|
.reduce(Double::sum);
|
scoreDataVO.setLastScore(formalIndicatorsListYearScore.orElse(0D));
|
scoreDataVOList.add(scoreDataVO);
|
}
|
} else {
|
for (SubTypeEnum value : SubTypeEnum.values()) {
|
ScoreDataVO scoreDataVO = new ScoreDataVO();
|
scoreDataVO.setScore(0D);
|
scoreDataVO.setLastScore(0D);
|
scoreDataVO.setSubType(value);
|
scoreDataVOList.add(scoreDataVO);
|
}
|
}
|
|
}
|
|
private void handleDataIndicators(String areaCode, List<ScoreRateDataVO> scoreRateDataVOList,
|
String nowQuarter) {
|
List<DataScreenScoreVO> dataIndicatorsListYear = tbDataScreenScoreService.selectIndicators(
|
areaCode, nowQuarter, DataScreenConfigEnum.DATA_INDICATORS, null);
|
if (CollUtils.isNotEmpty(dataIndicatorsListYear)) {
|
for (SubTypeEnum value : SubTypeEnum.values()) {
|
ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
|
List<DataScreenScoreVO> formalIndicators = dataIndicatorsListYear.stream()
|
.filter(item -> item.getSubType().equals(value)).collect(
|
Collectors.toList());
|
if (CollUtils.isNotEmpty(formalIndicators)) {
|
DataScreenScoreVO dataScreenScoreVO = formalIndicators.get(0);
|
scoreRateDataVO.setScore(dataScreenScoreVO.getScore());
|
scoreRateDataVO.setScoreRate(dataScreenScoreVO.getScoreRate());
|
scoreRateDataVO.setSubType(value);
|
Integer rank = tbDataScreenScoreService.getRankByScore(
|
dataScreenScoreVO.getScore(),
|
dataScreenScoreVO.getSubType(), areaCode, nowQuarter,
|
DataScreenConfigEnum.DATA_INDICATORS);
|
scoreRateDataVO.setRank(rank);
|
scoreRateDataVOList.add(scoreRateDataVO);
|
} else {
|
scoreRateDataVO.setScore(0D);
|
scoreRateDataVO.setScoreRate(0D);
|
scoreRateDataVO.setSubType(value);
|
scoreRateDataVO.setRank(0);
|
scoreRateDataVOList.add(scoreRateDataVO);
|
}
|
}
|
} else {
|
for (SubTypeEnum value : SubTypeEnum.values()) {
|
ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
|
scoreRateDataVO.setScore(0D);
|
scoreRateDataVO.setScoreRate(0D);
|
scoreRateDataVO.setSubType(value);
|
scoreRateDataVO.setRank(0);
|
scoreRateDataVOList.add(scoreRateDataVO);
|
}
|
}
|
}
|
|
private List<FieldAndScoreDataVO> getFieldAndScoreData(List<FieldAndScoreDataVO> voList,
|
String basicDataCategoryName) {
|
return voList.stream()
|
.filter(item -> item.getBasicDataCategoryName()
|
.equals(basicDataCategoryName))
|
.collect(Collectors.toList());
|
}
|
|
public List<DeptCalculateDetailVO> deptCalculateDetail(DeptCalculateDetailQuery query)
|
throws Exception {
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
return tbScoreService.deptCalculateDetail(query, previousQuarter);
|
}
|
|
public CurrentFieldsDetailVO viewRawData(String areaCode) throws Exception {
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
Optional<TbBasicData> basicDataOptional = tbBasicDataService.lambdaQuery()
|
.eq(TbBasicData::getDeptAreaCode, areaCode)
|
.eq(TbBasicData::getQuarter, previousQuarter).oneOpt();
|
if (basicDataOptional.isPresent()) {
|
return tbBasicDataService.fieldsDetails(basicDataOptional.get().getId()).getData();
|
} else {
|
return new CurrentFieldsDetailVO();
|
}
|
}
|
|
public ScoreCalculateDetailVO fieldsDetail(CalculateDetailQuery query) {
|
List<SysUser> countyList = getCountyList(query.getCityAreaCode());
|
try {
|
return tbScoreService.fieldsDetail(query, countyList);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
public List<SysUser> getCountyList(String areaCode) {
|
String cityCode = areaCode.substring(0, 4);
|
if (areaCode.equals("510000")) {
|
cityCode = areaCode.substring(0, 3);
|
}
|
List<SysUser> list = sysUserService.lambdaQuery()
|
.select(SysUser::getAreaCode, SysUser::getAreaName, SysUser::getAreaAlias,
|
SysUser::getUserId).eq(SysUser::getUserType,
|
UserTypeEnum.DEPARTMENT)
|
.likeRight(SysUser::getAreaCode, cityCode).or(cityCode.equals("5101"))
|
.in(cityCode.equals("5101"), SysUser::getAreaCode, "510008", "510015", "510017",
|
"510025")
|
.orderByAsc(!areaCode.equals("510100"), SysUser::getAreaCode)
|
.list();
|
return list;
|
}
|
}
|
