大屏接口

mitao

2024-04-17 d68c61517a3a6d4ec4d47844c21bdc143f99cbab

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

@@ -4,17 +4,20 @@
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.ruoyi.common.core.domain.entity.SysUser;
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;
import com.ruoyi.common.enums.ShowStatusEnum;
import com.ruoyi.common.enums.UserTypeEnum;
import com.ruoyi.common.enums.ValueTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.CalculateUtil;
import com.ruoyi.common.utils.CollUtils;
@@ -23,22 +26,27 @@
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;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.system.service.TbBasicDataConfigDetailService;
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.HashMap;
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,6 +65,8 @@
    public TbScoreService tbScoreService;
    public ISysUserService sysUserService;
    public String quarter;
    public TbDataScreenScoreService tbDataScreenScoreService;
    public TbDataScreenConfigService tbDataScreenConfigService;
    private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(
            BATCH_COUNT);

@@ -65,7 +75,9 @@
            TbBasicDataFieldService tbBasicDataFieldService,
            TbBasicDataConfigService tbBasicDataConfigService,
            TbBasicDataConfigDetailService tbBasicDataConfigDetailService,
            TbScoreService tbScoreService, ISysUserService sysUserService, String quarter) {
            TbScoreService tbScoreService, ISysUserService sysUserService, String quarter,
            TbDataScreenScoreService tbDataScreenScoreService,
            TbDataScreenConfigService tbDataScreenConfigService) {
        this.tbBasicDataService = tbBasicDataService;
        this.tbFieldService = tbFieldService;
        this.tbBasicDataFieldService = tbBasicDataFieldService;
@@ -74,6 +86,8 @@
        this.tbScoreService = tbScoreService;
        this.sysUserService = sysUserService;
        this.quarter = quarter;
        this.tbDataScreenConfigService = tbDataScreenConfigService;
        this.tbDataScreenScoreService = tbDataScreenScoreService;
    }

    @Override
@@ -96,8 +110,7 @@
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        try {
            List<TbBasicData> tbBasicDataList = saveData();
            calculateScore(tbBasicDataList);
            saveData();
        } catch (Exception e) {
            if (e instanceof ServiceException) {
                throw new ServiceException(e.getMessage());
@@ -110,8 +123,7 @@
    /**
     * 加上存储数据库
     */
    private List<TbBasicData> saveData() {
        List<TbBasicData> tbBasicDataList = new ArrayList<>();
    private void saveData() {
        // 查询需要填写的动态字段
        List<TbField> fieldList =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
@@ -193,10 +205,12 @@
            tbBasicDataFieldService.saveBatch(fields);
            tbBasicData.setStatus(ReportingStatusEnum.FILLED);
            tbBasicDataService.updateById(tbBasicData);
            tbBasicDataList.add(tbBasicData);
            CompletableFuture.runAsync(() -> {
                calculateScore(tbBasicData, fields);
                calculateScreenScore(tbBasicData, fields);
            });
        }
        log.info(String.format("%s导入基础数据成功！", JSON.toJSONString(dataMapList)));
        return tbBasicDataList;
    }

    /**
@@ -274,11 +288,11 @@
    /**
     * 计算得分
     *
     * @param tbBasicDataList 基础数据集合
     * @param tbBasicData
     * @param fields
     */
    private void calculateScore(List<TbBasicData> tbBasicDataList) {
    private void calculateScore(TbBasicData tbBasicData, List<TbBasicDataField> fields) {
        List<TbScore> scoreList = new ArrayList<>();
        for (TbBasicData tbBasicData : tbBasicDataList) {
            //计算得分
            List<TbBasicDataConfig> list = tbBasicDataConfigService.lambdaQuery()
                    .eq(TbBasicDataConfig::getStatus, ShowStatusEnum.SHOW).list();
@@ -292,24 +306,30 @@
                    .filter(item -> !CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
                    .collect(Collectors.toList());
            tbScoreService.remove(
                    new LambdaQueryWrapper<TbScore>().eq(TbScore::getBasicDataId,
                            tbBasicData.getId()));
                new LambdaQueryWrapper<TbScore>().eq(TbScore::getBasicDataId, tbBasicData.getId()));
        Map<Long, TbBasicDataField> basicDataFieldMap = fields.stream()
                .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
            if (CollUtils.isNotEmpty(numCalculates)) {
                for (TbBasicDataConfig item : numCalculates) {
                    Map<String, Object> valueMap = new HashMap<>();
                    String numberCalculateFormula = item.getNumberCalculateFormula();
                    Map<String, Integer> fieldsAndValue = CalculateUtil.getFieldsAndValue(
                            numberCalculateFormula);
                    for (Map.Entry<String, Integer> stringIntegerEntry : fieldsAndValue.entrySet()) {
                        Optional<TbBasicDataField> tbBasicDataField = tbBasicDataFieldService.lambdaQuery()
                                .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId())
                                .eq(TbBasicDataField::getFieldId, stringIntegerEntry.getValue())
                                .oneOpt();
                        tbBasicDataField.ifPresent(
                                basicDataField -> valueMap.put(stringIntegerEntry.getKey(),
                                        basicDataField.getFieldValue()));
                List<CalculateItemDTO> calculateItemDTOS = JSONArray.parseArray(
                        numberCalculateFormula,
                        CalculateItemDTO.class);
                for (CalculateItemDTO dto : calculateItemDTOS) {
                    if (ValueTypeEnum.FIELD.equals(dto.getValueType())) {
                        TbBasicDataField tbBasicDataField = basicDataFieldMap.get(
                                Long.valueOf(dto.getContent()));
                        if (Objects.nonNull(tbBasicDataField)) {
                            dto.setContent(tbBasicDataField.getFieldValue());
                    }
                    double score = CalculateUtil.calculate(numberCalculateFormula, valueMap);
                    }
                }
                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);
@@ -328,15 +348,11 @@
                            Collectors.toMap(TbBasicDataConfigDetail::getKey,
                                    TbBasicDataConfigDetail::getValue));
                    if (CollectionUtils.isNotEmpty(details)) {
                        Optional<TbBasicDataField> tbBasicDataFieldOptional = tbBasicDataFieldService.lambdaQuery()
                                .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId())
                                .eq(TbBasicDataField::getFieldId, textAndPercentage.getFieldIdStr())
                                .oneOpt();
                        if (tbBasicDataFieldOptional.isPresent()) {
                            TbBasicDataField tbBasicDataField = tbBasicDataFieldOptional.get();
                            if (CalculateTypeEnum.TEXT.equals(
                                    textAndPercentage.getCalculateType())) {
                                String score = scoreMap.get(tbBasicDataField.getFieldValue());
                    TbBasicDataField textAndPercentageData = basicDataFieldMap.get(
                            Long.valueOf(textAndPercentage.getFieldIdStr()));
                    if (Objects.nonNull(textAndPercentageData)) {
                        if (CalculateTypeEnum.TEXT.equals(textAndPercentage.getCalculateType())) {
                            String score = scoreMap.get(textAndPercentageData.getFieldValue());
                                tbScore.setBasicDataId(tbBasicData.getId());
                                tbScore.setScore(Double.parseDouble(score));
                                tbScore.setBasicDataConfigId(textAndPercentage.getId());
@@ -345,14 +361,19 @@
                            if (CalculateTypeEnum.PERCENTAGE.equals(
                                    textAndPercentage.getCalculateType())) {
                                for (Map.Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
                                    String[] split = stringStringEntry.getKey().split("-");
                                    double v = Double.parseDouble(tbBasicDataField.getFieldValue());
                                String[] split = stringStringEntry.getKey().split("_");
                                double v = Double.parseDouble(
                                        textAndPercentageData.getFieldValue());
                                    double min = Double.parseDouble(split[0]);
                                    double max = Double.parseDouble(split[1]);
                                    if (v >= min && v <= max) {
                                        tbScore.setScore(
                                                Double.parseDouble(stringStringEntry.getValue()));
                                    }
                            }
                            //如果都不匹配，得分为0
                            if (Objects.isNull(tbScore.getScore())) {
                                tbScore.setScore(0D);
                                }
                                tbScore.setBasicDataId(tbBasicData.getId());
                                tbScore.setBasicDataConfigId(textAndPercentage.getId());
@@ -362,8 +383,73 @@
                    }
                }
            }
        }
        tbScoreService.saveBatch(scoreList);
        log.info(String.format("基础数据%s计算得分成功！", JSON.toJSONString(tbBasicDataList)));
    }

    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);
    }
}