大屏接口

mitao

2024-04-17 d68c61517a3a6d4ec4d47844c21bdc143f99cbab

 ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java

@@ -10,6 +10,7 @@
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.ruoyi.common.enums.CalculateTypeEnum;
import com.ruoyi.common.enums.DataScreenConfigEnum;
import com.ruoyi.common.enums.FieldInputTypeEnum;
import com.ruoyi.common.enums.FieldTypeEnum;
import com.ruoyi.common.enums.ReportingStatusEnum;
@@ -23,6 +24,7 @@
import com.ruoyi.system.domain.TbBasicDataConfig;
import com.ruoyi.system.domain.TbBasicDataConfigDetail;
import com.ruoyi.system.domain.TbBasicDataField;
import com.ruoyi.system.domain.TbDataScreenScore;
import com.ruoyi.system.domain.TbField;
import com.ruoyi.system.domain.TbScore;
import com.ruoyi.system.dto.CalculateItemDTO;
@@ -30,14 +32,18 @@
import com.ruoyi.system.service.TbBasicDataConfigService;
import com.ruoyi.system.service.TbBasicDataFieldService;
import com.ruoyi.system.service.TbBasicDataService;
import com.ruoyi.system.service.TbDataScreenConfigService;
import com.ruoyi.system.service.TbDataScreenScoreService;
import com.ruoyi.system.service.TbFieldService;
import com.ruoyi.system.service.TbScoreService;
import com.ruoyi.system.vo.DataScreenConfigVO;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;

@@ -57,13 +63,16 @@
    public TbBasicDataConfigService tbBasicDataConfigService;
    public TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
    public TbScoreService tbScoreService;
    public TbDataScreenScoreService tbDataScreenScoreService;
    public TbDataScreenConfigService tbDataScreenConfigService;

    public BasicDataListener(TbBasicDataService tbBasicDataService,
            TbFieldService tbFieldService,
            String areaCode, TbBasicDataFieldService tbBasicDataFieldService,
            TbBasicDataConfigService tbBasicDataConfigService,
            TbBasicDataConfigDetailService tbBasicDataConfigDetailService,
            TbScoreService tbScoreService) {
            TbScoreService tbScoreService, TbDataScreenScoreService tbDataScreenScoreService,
            TbDataScreenConfigService tbDataScreenConfigService) {
        this.tbBasicDataService = tbBasicDataService;
        this.tbFieldService = tbFieldService;
        this.areaCode = areaCode;
@@ -71,6 +80,8 @@
        this.tbBasicDataConfigService = tbBasicDataConfigService;
        this.tbBasicDataConfigDetailService = tbBasicDataConfigDetailService;
        this.tbScoreService = tbScoreService;
        this.tbDataScreenConfigService = tbDataScreenConfigService;
        this.tbDataScreenScoreService = tbDataScreenScoreService;
    }

    @Override
@@ -215,7 +226,10 @@
        tbBasicData.setStatus(ReportingStatusEnum.FILLED);
        tbBasicDataService.updateById(tbBasicData);
        log.info(String.format("%s导入基础数据成功！", dataMap.get(0)));
        CompletableFuture.runAsync(() -> {
        calculateScore(tbBasicData, fields);
            calculateScreenScore(tbBasicData, fields);
        });
    }

    private void calculateScore(TbBasicData tbBasicData, List<TbBasicDataField> fields) {
@@ -254,6 +268,9 @@
                String numberCalculateFormulaStr = calculateItemDTOS.stream()
                        .map(CalculateItemDTO::getContent).collect(Collectors.joining());
                double score = CalculateUtil.calculate(numberCalculateFormulaStr);
                if (Objects.nonNull(item.getMaxScore()) && score > item.getMaxScore()) {
                    score = item.getMaxScore();
                }
                TbScore tbScore = new TbScore();
                tbScore.setBasicDataId(tbBasicData.getId());
                tbScore.setScore(score);
@@ -285,7 +302,7 @@
                        if (CalculateTypeEnum.PERCENTAGE.equals(
                                textAndPercentage.getCalculateType())) {
                            for (Map.Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
                                String[] split = stringStringEntry.getKey().split("-");
                                String[] split = stringStringEntry.getKey().split("_");
                                double v = Double.parseDouble(
                                        textAndPercentageData.getFieldValue());
                                double min = Double.parseDouble(split[0]);
@@ -294,6 +311,10 @@
                                    tbScore.setScore(
                                            Double.parseDouble(stringStringEntry.getValue()));
                                }
                            }
                            //如果都不匹配，得分为0
                            if (Objects.isNull(tbScore.getScore())) {
                                tbScore.setScore(0D);
                            }
                            tbScore.setBasicDataId(tbBasicData.getId());
                            tbScore.setBasicDataConfigId(textAndPercentage.getId());
@@ -305,4 +326,71 @@
        }
        tbScoreService.saveBatch(scoreList);
    }

    private void calculateScreenScore(TbBasicData tbBasicData,
            List<TbBasicDataField> tbBasicDataFields) {
        Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFields.stream()
                .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
        DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
        List<DataScreenConfigVO> dataIndicatorsConfig = tbDataScreenConfigService.getIndicatorsConfig(
                DataScreenConfigEnum.DATA_INDICATORS);
        List<DataScreenConfigVO> formalIndicatorsConfig = tbDataScreenConfigService.getIndicatorsConfig(
                DataScreenConfigEnum.FORMAL_INDICATORS);
        handleScoreCalculate(tbBasicData, riskLevel, basicDataFieldMap);
        for (DataScreenConfigVO config : dataIndicatorsConfig) {
            handleScoreCalculate(tbBasicData, config, basicDataFieldMap);
        }
        for (DataScreenConfigVO config : formalIndicatorsConfig) {
            handleScoreCalculate(tbBasicData, config, basicDataFieldMap);
        }
    }

    private void handleScoreCalculate(TbBasicData tbBasicData, DataScreenConfigVO vo,
            Map<Long, TbBasicDataField> basicDataFieldMap) {
        TbDataScreenScore tbDataScreenScore = tbDataScreenScoreService.lambdaQuery()
                .eq(TbDataScreenScore::getBasicDataId, tbBasicData.getId()).eq(
                        TbDataScreenScore::getDataScreenConfigId, vo.getId()).one();
        if (Objects.isNull(tbDataScreenScore)) {
            tbDataScreenScore = new TbDataScreenScore();
            tbDataScreenScore.setDataScreenConfigId(vo.getId());
            tbDataScreenScore.setBasicDataId(tbBasicData.getId());
            tbDataScreenScore.setDeptAreaCode(tbBasicData.getDeptAreaCode());
        }
        List<CalculateItemDTO> scoreCalculateList = vo.getScoreCalculateList();
        for (CalculateItemDTO item : scoreCalculateList) {
            if (item.getValueType().equals(ValueTypeEnum.FIELD)) {
                TbBasicDataField basicDataField = basicDataFieldMap.get(
                        Long.valueOf(item.getContent()));
                if (Objects.nonNull(basicDataField)) {
                    item.setContent(basicDataField.getFieldValue());
                }
            }
        }
        String calculateFormulaStr = scoreCalculateList.stream()
                .map(CalculateItemDTO::getContent).collect(Collectors.joining());
        double score = CalculateUtil.calculate(calculateFormulaStr);
        if (vo.getType().equals(DataScreenConfigEnum.FORMAL_INDICATORS)) {
            if (Objects.nonNull(vo.getMaxScore()) && score > vo.getMaxScore()) {
                score = vo.getMaxScore();
            }
        }
        tbDataScreenScore.setScore(score);
        if (vo.getType().equals(DataScreenConfigEnum.DATA_INDICATORS)) {
            List<CalculateItemDTO> rateCalculateList = vo.getRateCalculateList();
            for (CalculateItemDTO calculateItemDTO : rateCalculateList) {
                if (calculateItemDTO.getValueType().equals(ValueTypeEnum.FIELD)) {
                    TbBasicDataField basicDataField = basicDataFieldMap.get(
                            Long.valueOf(calculateItemDTO.getContent()));
                    if (Objects.nonNull(basicDataField)) {
                        calculateItemDTO.setContent(basicDataField.getFieldValue());
                    }
                }
            }
            String calculateRateFormulaStr = rateCalculateList.stream()
                    .map(CalculateItemDTO::getContent).collect(Collectors.joining());
            double scoreRate = CalculateUtil.calculate(calculateRateFormulaStr);
            tbDataScreenScore.setScoreRate(scoreRate);
        }
        tbDataScreenScoreService.saveOrUpdate(tbDataScreenScore);
    }
}