bug修改

mitao

2025-04-07 18891c60ab1c06a4acc85d0ec54dee50d1b1a19f

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

@@ -8,7 +8,6 @@
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.finance.common.core.domain.entity.SysUser;
import com.finance.common.enums.CalculateTypeEnum;
import com.finance.common.enums.DataScreenConfigEnum;
@@ -22,6 +21,7 @@
import com.finance.common.utils.CalculateUtil;
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.TbBasicDataConfig;
import com.finance.system.domain.TbBasicDataConfigDetail;
@@ -30,6 +30,7 @@
import com.finance.system.domain.TbField;
import com.finance.system.domain.TbScore;
import com.finance.system.dto.CalculateItemDTO;
import com.finance.system.service.AsyncService;
import com.finance.system.service.ISysUserService;
import com.finance.system.service.TbBasicDataConfigDetailService;
import com.finance.system.service.TbBasicDataConfigService;
@@ -40,15 +41,17 @@
import com.finance.system.service.TbFieldService;
import com.finance.system.service.TbScoreService;
import com.finance.system.vo.DataScreenConfigVO;
import com.google.common.collect.Lists;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;

@Slf4j
public class HistoryDataListener extends AnalysisEventListener<Map<Integer, String>> {
@@ -67,6 +70,7 @@
    public String quarter;
    public TbDataScreenScoreService tbDataScreenScoreService;
    public TbDataScreenConfigService tbDataScreenConfigService;
    public AsyncService asyncService;
    private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(
            BATCH_COUNT);

@@ -77,7 +81,7 @@
            TbBasicDataConfigDetailService tbBasicDataConfigDetailService,
            TbScoreService tbScoreService, ISysUserService sysUserService, String quarter,
            TbDataScreenScoreService tbDataScreenScoreService,
            TbDataScreenConfigService tbDataScreenConfigService) {
            TbDataScreenConfigService tbDataScreenConfigService, AsyncService asyncService) {
        this.tbBasicDataService = tbBasicDataService;
        this.tbFieldService = tbFieldService;
        this.tbBasicDataFieldService = tbBasicDataFieldService;
@@ -88,6 +92,7 @@
        this.quarter = quarter;
        this.tbDataScreenConfigService = tbDataScreenConfigService;
        this.tbDataScreenScoreService = tbDataScreenScoreService;
        this.asyncService = asyncService;
    }

    @Override
@@ -128,6 +133,14 @@
        List<TbField> fieldList =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
        Map<Integer, String> headMap = getHeadMap();
        int remarkIndex = headMap.size() - 1;
        Map<Integer, String> dynamicFieldsMap = getDynamicHeadMap(headMap, remarkIndex);
        Map<Integer, String> dynamicCategoryOneMap = getDynamicHeadMap(cachedDataList.get(0),
                remarkIndex);
        Map<Integer, String> dynamicCategoryTwoMap = getDynamicHeadMap(cachedDataList.get(1),
                remarkIndex);
        Map<Integer, String> dynamicCategoryThreeMap = getDynamicHeadMap(cachedDataList.get(2),
                remarkIndex);
        List<Map<Integer, String>> dataMapList = getMapList();
        if (headMap == null || dataMapList == null) {
            throw new ServiceException("导入失败，请下载最新的导入模板");
@@ -135,44 +148,53 @@
        log.info("{}条数据，开始存储数据库！", dataMapList.size());
        log.info("表头：{}", JSON.toJSONString(headMap));
        log.info("填写的数据：{}", JSON.toJSONString(dataMapList));

           /*  boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
            if (dynamicFields.size() != collect.size() || !flag) {
                throw new ServiceException("导入失败，请下载最新的导入模板");
            }*/
        List<String> dynamicFields = new ArrayList<>(dynamicFieldsMap.values());
        List<String> collect = fieldList.stream().map(TbField::getFieldName)
                .collect(Collectors.toList());
        boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
        if (dynamicFields.size() != fieldList.size() || !flag) {
            throw new ServiceException("导入失败，请下载最新的导入模板");
        }
        List<SysUser> departmentList = sysUserService.lambdaQuery()
                .eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT).list();
        List<TbBasicData> basicDataList = tbBasicDataService.lambdaQuery().
                eq(TbBasicData::getQuarter, quarter).list();
        for (Map<Integer, String> dataMap : dataMapList) {
            Optional<SysUser> sysUser = sysUserService.lambdaQuery()
                    .eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT)
                    .eq(SysUser::getAreaName, dataMap.get(0)).oneOpt();
            // 查询需要填写的动态字段
            fieldList =
                    tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
            Optional<SysUser> sysUser = departmentList.stream()
                    .filter(dept -> dept.getAreaName().equals(dataMap.get(0))).findFirst();
            if (!sysUser.isPresent()) {
                throw new ServiceException("该地区不存在，请修改后重新导入！");
            }
            String areaCode = sysUser.get().getAreaCode();
            int remarkIndex = headMap.size() - 1;
            Map<Integer, String> dynamicFieldsMap = headMap.entrySet().stream()
                    .filter(entry -> !(Lists.newArrayList(0, 1, 2, 3).contains(entry.getKey())
                            || entry.getKey() == remarkIndex))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            List<String> dynamicFields = new ArrayList<>(dynamicFieldsMap.values());
            List<String> collect = fieldList.stream().map(TbField::getFieldName)
                    .collect(Collectors.toList());
            boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
            if (dynamicFields.size() != collect.size() || !flag) {
                throw new ServiceException("导入失败，请下载最新的导入模板");
            }
            LocalDate now = LocalDate.now();
            TbBasicData tbBasicData;
            Optional<TbBasicData> tbBasicDataOpt = tbBasicDataService.lambdaQuery().
                    eq(TbBasicData::getQuarter, quarter)
                    .eq(TbBasicData::getDeptAreaCode, areaCode).oneOpt();
            Optional<TbBasicData> tbBasicDataOpt = basicDataList.stream()
                    .filter(basicData -> basicData.getDeptAreaCode().equals(areaCode)).findFirst();
            tbBasicData = tbBasicDataOpt.orElseGet(TbBasicData::new);
            tbBasicData.setQuarter(quarter);
            tbBasicData.setTransferPaymentScale(dataMap.get(2));
            tbBasicData.setCurrentGdp(dataMap.get(3));
            tbBasicData.setTransferPaymentScale(dataMap.get(2).replace(",", ""));
            tbBasicData.setCurrentGdp(dataMap.get(3).replace(",", ""));
            tbBasicData.setDeptAreaCode(areaCode);
            tbBasicData.setRemark(dataMap.get(remarkIndex));
            tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
            tbBasicData.setReportingTime(DateUtils.getQuarterDate(quarter));
            long count = dataMap.entrySet().stream()
                    .filter(entry -> StringUtils.isBlank(entry.getValue())).count();
            tbBasicData.setStatus(
                    count > 0 ? ReportingStatusEnum.MISSING_DATA : ReportingStatusEnum.FILLED);
            tbBasicDataService.saveOrUpdate(tbBasicData);
            tbBasicDataFieldService.remove(Wrappers.<TbBasicDataField>lambdaQuery()
                    .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
            List<TbBasicDataField> fields = new ArrayList<>();
            //添加固定字段 转移支付规模、当期GDP
            // 添加固定字段 转移支付规模、当期GDP
            TbBasicDataField transferPaymentScale = new TbBasicDataField();
            transferPaymentScale.setBasicDataId(tbBasicData.getId());
            transferPaymentScale.setFieldId(-1L);
@@ -186,8 +208,8 @@
            currentGdp.setFieldName("当期GDP");
            currentGdp.setFieldValue(tbBasicData.getCurrentGdp());
            fields.add(currentGdp);
            //遍历动态字段map
            for (Map.Entry<Integer, String> integerStringEntry : dynamicFieldsMap.entrySet()) {
            // 遍历动态字段map
            /*for (Map.Entry<Integer, String> integerStringEntry : dynamicFieldsMap.entrySet()) {
                Optional<TbField> tbField = tbFieldService.lambdaQuery()
                        .eq(TbField::getFieldName, integerStringEntry.getValue())
                        .eq(TbField::getStatus, ShowStatusEnum.SHOW).oneOpt();
@@ -201,17 +223,102 @@
                    tbBasicDataField.setFieldValue(value);
                    fields.add(tbBasicDataField);
                }
            }*/
            // 遍历动态字段map
            for (Entry<Integer, String> entry : dynamicFieldsMap.entrySet()) {
                Integer key = entry.getKey();
                String fieldStr = entry.getValue();
                String categoryOne = dynamicCategoryOneMap.get(key);
                String categoryTwo = dynamicCategoryTwoMap.get(key);
                String categoryThree = dynamicCategoryThreeMap.get(key);

                TbField field = getFieldByFieldName(fieldList, categoryOne, categoryTwo,
                        categoryThree, fieldStr);

                if (Objects.nonNull(field)) {
                    String value = dataMap.get(key);
                    TbBasicDataField tbBasicDataField = new TbBasicDataField();
                    tbBasicDataField.setBasicDataId(tbBasicData.getId());
                    tbBasicDataField.setFieldId(field.getId());
                    tbBasicDataField.setFieldName(field.getFieldName());
                    tbBasicDataField.setFieldValue(
                            Objects.isNull(value) ? "" : value.replace(",", ""));
                    fields.add(tbBasicDataField);
                }
            }
            tbBasicDataFieldService.saveBatch(fields);
            tbBasicData.setStatus(ReportingStatusEnum.FILLED);
            tbBasicDataService.updateById(tbBasicData);
            CompletableFuture.runAsync(() -> {
                calculateScore(tbBasicData, fields);
                calculateScreenScore(tbBasicData, fields);
            });
            // CompletableFuture.runAsync(() -> {
            //     calculateScore(tbBasicData, fields);
            //     calculateScreenScore(tbBasicData, fields);
            // });
            asyncService.calculateScoreWithFixedRules(tbBasicData, fields, fieldList);
        }
        log.info(String.format("%s导入基础数据成功！", JSON.toJSONString(dataMapList)));
    }

    private TbField getFieldByFieldName(List<TbField> fieldList, String categoryOne,
            String categoryTwo,
            String categoryThree,
            String fieldStr) {
        TbField field = null;
        if (!fieldList.isEmpty()) {
            /*
            判断字段有几级分类，如果字段如果fieldStr与categoryTwo不同，说明该字段有二级分类。
            如果字段如果fieldStr与categoryThree不同，说明该字段有三级分类。
           res = 1 表示只有一级分类 res=2 表示该字段有二级分类，res=3表示该字段有三级分类
             */
            int res =
                    !fieldStr.equals(categoryTwo) ? (!fieldStr.equals(categoryThree) ? 3 : 2) : 1;
            Optional<TbField> fieldOptional = Optional.empty();
            switch (res) {
                case 1:
                    fieldOptional = fieldList.stream()
                            .filter(item -> item.getFieldName().equals(fieldStr)
                                    && item.getLevelOneCategory().equals(categoryOne)
                                    && item.getStatus()
                                    == ShowStatusEnum.SHOW)
                            .findFirst();
                    if (fieldOptional.isPresent()) {
                        field = fieldOptional.get();
                        field.setFieldName(categoryOne + "-" + field.getFieldName());
                    }
                    break;
                case 2:
                    fieldOptional = fieldList.stream()
                            .filter(item -> item.getFieldName().equals(fieldStr)
                                    && item.getLevelOneCategory().equals(categoryOne)
                                    && item.getStatus()
                                    == ShowStatusEnum.SHOW)
                            .filter(item -> item.getLevelTwoCategory().equals(categoryTwo))
                            .findFirst();
                    if (fieldOptional.isPresent()) {
                        field = fieldOptional.get();
                        field.setFieldName(
                                categoryOne + "-" + categoryTwo + "-" + field.getFieldName());
                    }
                    break;
                case 3:
                    fieldOptional = fieldList.stream()
                            .filter(item -> item.getFieldName().equals(fieldStr)
                                    && item.getLevelOneCategory().equals(categoryOne)
                                    && item.getStatus()
                                    == ShowStatusEnum.SHOW)
                            .filter(item -> item.getLevelTwoCategory().equals(categoryTwo))
                            .filter(item -> item.getLevelThreeCategory()
                                    .equals(categoryThree))
                            .findFirst();
                    if (fieldOptional.isPresent()) {
                        field = fieldOptional.get();
                        field.setFieldName(
                                categoryOne + "-" + categoryTwo + "-" + categoryThree + "-"
                                        + field.getFieldName());
                    }
                    break;
            }
        }
        return field;
    }


    /**
     * 需要导入的数据
@@ -225,6 +332,16 @@
            }
        }
        return null;
    }

    @NotNull
    private static Map<Integer, String> getDynamicHeadMap(Map<Integer, String> headMap,
            int remarkIndex) {
        Map<Integer, String> dynamicFieldsMap = headMap.entrySet().stream()
                .filter(entry -> !(Lists.newArrayList(0, 1, 2, 3).contains(entry.getKey())
                        || entry.getKey() == remarkIndex))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
        return dynamicFieldsMap;
    }

    /**
@@ -293,7 +410,7 @@
     */
    private void calculateScore(TbBasicData tbBasicData, List<TbBasicDataField> fields) {
        List<TbScore> scoreList = new ArrayList<>();
        //计算得分
        // 计算得分
        List<TbBasicDataConfig> list = tbBasicDataConfigService.lambdaQuery()
                .eq(TbBasicDataConfig::getStatus, ShowStatusEnum.SHOW).list();
        if (CollectionUtils.isEmpty(list)) {
@@ -371,7 +488,7 @@
                                            Double.parseDouble(stringStringEntry.getValue()));
                                }
                            }
                            //如果都不匹配，得分为0
                            // 如果都不匹配，得分为0
                            if (Objects.isNull(tbScore.getScore())) {
                                tbScore.setScore(0D);
                            }