bug修改

mitao

2025-04-07 18891c60ab1c06a4acc85d0ec54dee50d1b1a19f

 finance-system/src/main/java/com/finance/system/service/impl/TbBasicDataServiceImpl.java

@@ -29,6 +29,7 @@
import com.finance.common.utils.EasyExcelUtil;
import com.finance.common.utils.SecurityUtils;
import com.finance.common.utils.StringUtils;
import com.finance.system.constants.QuarterConstant;
import com.finance.system.domain.TbBasicData;
import com.finance.system.domain.TbBasicDataConfig;
import com.finance.system.domain.TbBasicDataConfigDetail;
@@ -48,7 +49,9 @@
import com.finance.system.query.CurrentFieldsQuery;
import com.finance.system.query.ScoreCalculateQuery;
import com.finance.system.query.ScoreQuery;
import com.finance.system.service.AsyncService;
import com.finance.system.service.ISysUserService;
import com.finance.system.service.TbBasicDataCategoryService;
import com.finance.system.service.TbBasicDataConfigDetailService;
import com.finance.system.service.TbBasicDataConfigService;
import com.finance.system.service.TbBasicDataFieldService;
@@ -59,6 +62,7 @@
import com.finance.system.service.TbOperLogService;
import com.finance.system.service.TbScoreService;
import com.finance.system.utils.FieldBuildUtil;
import com.finance.system.vo.BasicDataConfigVO;
import com.finance.system.vo.BasicDataReportingVO;
import com.finance.system.vo.CurrentFieldsAllVO;
import com.finance.system.vo.CurrentFieldsDetailVO;
@@ -79,6 +83,7 @@
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
@@ -114,7 +119,8 @@
    private final TbOperLogService tbOperLogService;
    private final TbDataScreenScoreService tbDataScreenScoreService;
    private final TbDataScreenConfigService tbDataScreenConfigService;

    private final AsyncService asyncService;
    private final TbBasicDataCategoryService tbBasicDataCategoryService;

    public static void setFieldValues(
            List<FieldsTreeVO> fields, Map<Long, TbBasicDataField> fieldMap) {
@@ -123,6 +129,8 @@
            if (tbBasicDataField != null) {
                field.setValue(
                        tbBasicDataField.getFieldValue());
            } else {
                field.setValue("");
            }
            if (field.getChildren() != null && !field.getChildren().isEmpty()) {
                setFieldValues(field.getChildren(), fieldMap);
@@ -149,10 +157,13 @@
        LocalDate quarterStartLocalDate = instant.atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate fifteenDaysLimit = quarterStartLocalDate.plusDays(14);
        LocalDate now = LocalDate.now();
        vo.setQuarter(DateUtils.getNowQuarter());
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        DateUtils.getQuarterDate(previousQuarter);
        vo.setQuarter(previousQuarter);
        vo.setStatus(ReportingStatusEnum.UNFILLED);
        // 如果当前时间不在规定范围内：季度初1-15号 TODO
     /*   if (now.isBefore(quarterStartLocalDate) || now.isAfter(fifteenDaysLimit)) {
        // 如果当前时间不在规定范围内：季度初1-15号
        /*if (now.isBefore(quarterStartLocalDate) || now.isAfter(fifteenDaysLimit)) {
            return R.ok(vo, "请于季度初1-15号上传季度数据。");
        }*/
        // 查询是否有当前季度的填报记录
@@ -160,7 +171,11 @@
                this.getOne(
                        Wrappers.<TbBasicData>lambdaQuery()
                                .eq(TbBasicData::getDeptAreaCode, dept.getAreaCode())
                                .between(TbBasicData::getReportingTime, quarterStart, quarterEnd));
                                .eq(TbBasicData::getQuarter, previousQuarter));
        if (Objects.nonNull(basicData)) {
            vo.setCreateTime(basicData.getCreateTime());
            vo.setFinishedTime(basicData.getUpdateTime());
        }
        // 查询需要填写的字段
        List<TbField> list =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
@@ -184,7 +199,7 @@
            vo.setFields(roots);
        }
        if (Objects.isNull(basicData)) {
            vo.setQuarter(DateUtils.getNowQuarter());
            vo.setQuarter(previousQuarter);
            vo.setStatus(ReportingStatusEnum.UNFILLED);
            return R.ok(vo);
        } else {
@@ -217,7 +232,8 @@
        if (Objects.isNull(dto) || CollUtils.isEmpty(dto.getFields())) {
            return;
        }
        String nowQuarter = DateUtils.getNowQuarter();
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        // 查询需要填写的动态字段
        List<TbField> fieldList =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
@@ -225,13 +241,17 @@
                fieldList.stream().collect(Collectors.toMap(TbField::getId, e -> e));
        Optional<TbBasicData> basicDataOpt = this.lambdaQuery()
                .eq(TbBasicData::getDeptAreaCode, areaCode)
                .eq(TbBasicData::getQuarter, nowQuarter).oneOpt();
                .eq(TbBasicData::getQuarter, previousQuarter).oneOpt();
        TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);
        tbBasicData.setCurrentGdp(tbBasicData.getCurrentGdp().replace(",", ""));
        tbBasicData.setTransferPaymentScale(tbBasicData.getTransferPaymentScale().replace(",", ""));
        if (basicDataOpt.isPresent()) {
            tbBasicData.setId(basicDataOpt.get().getId());
            tbBasicData.setDeptAreaCode(areaCode);
            tbBasicData.setQuarter(basicDataOpt.get().getQuarter());
            tbBasicData.setUpdateTime(new Date());
            this.updateById(tbBasicData);
            //查询该基础数据的动态字端
            // 查询该基础数据的动态字端
            List<TbBasicDataField> originFields = tbBasicDataFieldService.lambdaQuery()
                    .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()).list();
            CompletableFuture.runAsync(
@@ -240,8 +260,8 @@
        } else {
            tbBasicData.setDeptAreaCode(areaCode);
            tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
            tbBasicData.setQuarter(nowQuarter);
            tbBasicData.setReportingTime(DateUtils.getQuarterDate(nowQuarter));
            tbBasicData.setQuarter(previousQuarter);
            tbBasicData.setReportingTime(DateUtils.getQuarterDate(previousQuarter));
            this.save(tbBasicData);
        }
        // 保存基础数据动态字段数据
@@ -318,14 +338,16 @@
                        && StringUtils.isNotEmpty(dto.getCurrentGdp()));
        if (flag) {
            tbBasicData.setStatus(ReportingStatusEnum.FILLED);
            tbBasicData.setFinishedTime(new Date());
            this.updateById(tbBasicData);
        }
        if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
        /*if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
            CompletableFuture.runAsync(() -> {
                calculateScore(tbBasicData, tbBasicDataFields);
                calculateScreenScore(tbBasicData, tbBasicDataFields);
            });
        }
        }*/
        asyncService.calculateScoreWithFixedRules(tbBasicData, tbBasicDataFields, fieldList);
    }

    private void calculateScreenScore(TbBasicData tbBasicData,
@@ -438,6 +460,7 @@
                        field.getFieldValue(), tbOperlogList, result.toString());
            }
        }
        tbOperLogService.saveBatch(tbOperlogList);
    }

    private static void wrapOperLog(LoginUser loginUser, TbBasicData tbBasicData, String before,
@@ -468,12 +491,14 @@
        LocalDate quarterStartLocalDate = instant.atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate fifteenDaysLimit = quarterStartLocalDate.plusDays(14);
        LocalDate now = LocalDate.now();
        //TODO
        // TODO
      /*  if (now.isBefore(quarterStartLocalDate) || now.isAfter(fifteenDaysLimit)) {
            throw new ServiceException("请于季度初1-15号上传季度数据。");
        }*/
        LoginUser loginUser = SecurityUtils.getLoginUser();
        String areaCode = loginUser.getUser().getAreaCode();
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        EasyExcel.read(
                        file.getInputStream(),
                        new BasicDataListener(
@@ -483,7 +508,9 @@
                                tbBasicDataFieldService,
                                tbBasicDataConfigService,
                                tbBasicDataConfigDetailService,
                                tbScoreService, tbDataScreenScoreService, tbDataScreenConfigService))
                                tbScoreService, tbDataScreenScoreService, previousQuarter,
                                tbDataScreenConfigService,
                                asyncService))
                .sheet()
                .headRowNumber(0)
                .doRead();
@@ -561,7 +588,7 @@
                        }
                        if (CalculateTypeEnum.PERCENTAGE.equals(
                                textAndPercentage.getCalculateType())) {
                            for (Map.Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
                            for (Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
                                String[] split = stringStringEntry.getKey().split("_");
                                double v = Double.parseDouble(
                                        textAndPercentageData.getFieldValue());
@@ -583,19 +610,21 @@
    }

    @Override
    public PageDTO<ScoreVO> pageScore(ScoreQuery query) {
    public PageDTO<ScoreVO> pageScore(ScoreQuery query) throws Exception {
        Page<ScoreVO> page = new Page<>(query.getPageNum(), query.getPageSize());
        SysUser user = SecurityUtils.getLoginUser().getUser();
        String areaCode = user.getAreaCode();
        Date date = new Date();
        Date quarterStart = DateUtil.beginOfQuarter(date);
        Date quarterEnd = DateUtil.endOfQuarter(date);
        String previousQuarter = DateUtils.getPreviousQuarter();
        // previousQuarter = "2024年一季度";
        // 查询是否有当前季度的填报记录
        TbBasicData basicData =
                this.getOne(
                        Wrappers.<TbBasicData>lambdaQuery()
                                .eq(TbBasicData::getDeptAreaCode, areaCode)
                                .between(TbBasicData::getReportingTime, quarterStart, quarterEnd));
                                .eq(TbBasicData::getQuarter, previousQuarter));
        if (Objects.isNull(basicData)) {
            return PageDTO.empty(page);
        }
@@ -626,7 +655,7 @@
                            vo.setPhoneNumber(item.getPhoneNumber());
                            vo.setPersonInCharge(item.getPersonInCharge());
                        });
        // 查询动态字段
       /* // 查询动态字段
        List<TbBasicDataField> basicDataFields =
                tbBasicDataFieldService
                        .lambdaQuery()
@@ -683,7 +712,44 @@
                            fieldsTreeVO.setCategory(Boolean.FALSE);
                            root.add(fieldsTreeVO);
                        });
        vo.setFields(root);
        vo.setFields(root);*/
        // 查询需要填写的字段
        List<TbField> list =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
        List<FieldsTreeVO> roots = new ArrayList<>();
        FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
        fieldsTreeVO.setId(-1L);
        fieldsTreeVO.setName("转移支付规模");
        fieldsTreeVO.setCategory(Boolean.FALSE);
        FieldsTreeVO fieldsTreeVO2 = new FieldsTreeVO();
        fieldsTreeVO2.setId(-2L);
        fieldsTreeVO2.setName("当期GDP");
        fieldsTreeVO2.setCategory(Boolean.FALSE);
        roots.add(fieldsTreeVO);
        roots.add(fieldsTreeVO2);
        if (CollUtils.isNotEmpty(list)) {
            FieldBuildUtil.buildTreeFromTbFieldList(list, roots);
            FieldsTreeVO remark = new FieldsTreeVO();
            remark.setId(-3L);
            remark.setName("备注");
            roots.add(remark);
            vo.setFields(roots);
        }
        vo.setStatus(basicData.getStatus());
        // 查询已填报数据 包含数据缺失和已填报
        List<TbBasicDataField> basicDataFields =
                tbBasicDataFieldService
                        .lambdaQuery()
                        .eq(TbBasicDataField::getBasicDataId, basicData.getId())
                        .list();

        if (CollUtils.isNotEmpty(basicDataFields)) {
            Map<Long, TbBasicDataField> fieldMap =
                    basicDataFields.stream()
                            .collect(Collectors.toMap(TbBasicDataField::getFieldId,
                                    Function.identity()));
            setFieldValues(vo.getFields(), fieldMap);
        }
        return R.ok(vo);
    }

@@ -722,11 +788,12 @@
        remark.setName("备注");
        roots.add(remark);
        vo.setFields(roots);
        String nowQuarter = DateUtils.getNowQuarter();
        String previousQuarter = DateUtils.getPreviousQuarter();
        // previousQuarter = "2024年一季度";
        // 查询上报的基础数据
        List<TbBasicData> basicDataList =
                this.lambdaQuery()
                        .eq(TbBasicData::getQuarter, nowQuarter)
                        .eq(TbBasicData::getQuarter, previousQuarter)
                        .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
                        .list();
        if (CollUtils.isNotEmpty(basicDataList)) {
@@ -880,7 +947,7 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void importData(MultipartFile file, String quarter) throws IOException {
        //校验季度
        // 校验季度
        Date quarterDate = DateUtils.getQuarterDate(quarter);

        Map<String, Date> quarterMap = DateUtils.getQuarterDate(new Date());
@@ -890,7 +957,7 @@
        if (quarterLocalDate.isAfter(dateLocalDate) || quarterLocalDate.equals(dateLocalDate)) {
            throw new ServiceException("请导入过去季度的数据。");
        }

        long start = System.currentTimeMillis();
        EasyExcel.read(
                        file.getInputStream(),
                        new HistoryDataListener(
@@ -900,9 +967,11 @@
                                tbBasicDataConfigService,
                                tbBasicDataConfigDetailService,
                                tbScoreService, sysUserService, quarter, tbDataScreenScoreService,
                                tbDataScreenConfigService))
                                tbDataScreenConfigService, asyncService))
                .sheet()
                .headRowNumber(0)
                .doRead();
        log.info("历史数据导入完成，耗时{}毫秒", System.currentTimeMillis() - start);
    }

    @Override
@@ -913,49 +982,49 @@
        response.setHeader(
                "Content-disposition",
                "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8") + ".xlsx");
        //季度数据，用于反查字段
        // 季度数据，用于反查字段
        List<TbBasicData> tbBasicDataList = this.lambdaQuery()
                .in(TbBasicData::getQuarter, quarterList)
                .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
                .groupBy(TbBasicData::getQuarter).list();
        //符合导出条件的基础数据
        // 符合导出条件的基础数据
        List<TbBasicData> tbBasicDataListAll = this.lambdaQuery()
                .in(TbBasicData::getQuarter, quarterList)
                .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
                .list();
        //基础数据id列表
        // 基础数据id列表
        Set<Long> basicDataIdList = tbBasicDataListAll.stream().map(TbBasicData::getId)
                .collect(Collectors.toSet());
        //涉及到的部门编码
        // 涉及到的部门编码
        Set<String> userAreaCodeList = tbBasicDataListAll.stream().map(TbBasicData::getDeptAreaCode)
                .collect(Collectors.toSet());
        //用户信息map
        // 用户信息map
        Map<String, SysUser> userMap = sysUserService.lambdaQuery()
                .in(SysUser::getAreaCode, userAreaCodeList).list().stream()
                .collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
        //基础数据对应的字段值列表
        // 基础数据对应的字段值列表
        List<TbBasicDataField> tbBasicDataFieldList = tbBasicDataFieldService.lambdaQuery()
                .in(TbBasicDataField::getBasicDataId, basicDataIdList)
                .list();
        //构建Excel写对象
        // 构建Excel写对象
        try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
                .registerWriteHandler(new CustomCellWriteHandler())
                .registerWriteHandler(EasyExcelUtil.getStyleStrategy()).build()) {
            WriteSheet writeSheet;
            //遍历季度基础数据
            // 遍历季度基础数据
            for (TbBasicData tbBasicData : tbBasicDataList) {
                //该季度的动态字段id列表
                // 该季度的动态字段id列表
                Set<Long> fieldIdList = tbBasicDataFieldList.stream()
                        .filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
                        .map(TbBasicDataField::getFieldId)
                        .collect(Collectors.toSet());
                //字段列表
                // 字段列表
                List<TbField> fieldList = tbFieldService.lambdaQuery()
                        .in(TbField::getId, fieldIdList)
                        .list();
                //表头
                // 表头
                List<List<String>> head = head(fieldList);
                //过滤基础数据为遍历元素的季度
                // 过滤基础数据为遍历元素的季度
                List<TbBasicData> list = tbBasicDataListAll.stream()
                        .filter(item -> tbBasicData.getQuarter().equals(item.getQuarter()))
                        .collect(Collectors.toList());
@@ -973,17 +1042,17 @@
    private List<List<Object>> dataList(List<TbField> fieldList, List<TbBasicData> list,
            List<TbBasicDataField> tbBasicDataFieldList, Map<String, SysUser> userMap,
            List<List<String>> head) {
        //所有数据集合
        // 所有数据集合
        List<List<Object>> excellist = new ArrayList<>();
        //构建栏号行
        // 构建栏号行
        List<Object> columnNo = Lists.newArrayList("栏号");
        for (int i = 1; i < head.size(); i++) {
            columnNo.add(String.valueOf(i));
        }
        excellist.add(columnNo);
        //动态字段数据行
        // 动态字段数据行
        for (TbBasicData tbBasicData : list) {
            //转换为map，方便遍历的时候取
            // 转换为map，方便遍历的时候取
            Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFieldList.stream()
                    .filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
                    .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
@@ -1069,14 +1138,18 @@
        if (Objects.isNull(dto)) {
            return;
        }
        //查询基础数据
        // 查询基础数据
        TbBasicData basicData = this.getById(dto.getId());
        if (Objects.isNull(basicData)) {
            throw new ServiceException("非法参数");
        }
        String nowQuarter = DateUtils.getNowQuarter();
        this.updateById(basicData);
        //查询该基础数据的动态字端
        // 查询该基础数据的动态字端
        // 查询需要填写的动态字段
        List<TbField> fieldList =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
        Map<Long, TbField> allFieldMap = fieldList.stream()
                .collect(Collectors.toMap(TbField::getId, e -> e));
        List<TbBasicDataField> originFields = tbBasicDataFieldService.lambdaQuery()
                .eq(TbBasicDataField::getBasicDataId, basicData.getId()).list();
        Set<Long> fieldIdList = originFields.stream().map(TbBasicDataField::getFieldId)
@@ -1088,46 +1161,56 @@
                        BeanUtils.copyBean(dto, BasicDataDTO.class),
                        fieldMap));
        TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);

        tbBasicData.setCurrentGdp(tbBasicData.getCurrentGdp().replace(",", ""));
        tbBasicData.setTransferPaymentScale(tbBasicData.getTransferPaymentScale().replace(",", ""));
        tbBasicData.setDeptAreaCode(basicData.getDeptAreaCode());
        tbBasicData.setQuarter(basicData.getQuarter());
        // 保存基础数据动态字段数据
        List<TbBasicDataField> tbBasicDataFields =
                BeanUtils.copyList(dto.getFields(), TbBasicDataField.class);

        for (TbBasicDataField item : tbBasicDataFields) {
            TbField tbField = fieldMap.get(item.getFieldId());
            Integer numMax = tbField.getNumMax();
            Integer numMin = tbField.getNumMin();
            Integer textMaxNum = tbField.getTextMaxNum();
            Integer textMinNum = tbField.getTextMinNum();
            if (FieldTypeEnum.NUMBER.equals(tbField.getFieldType()) && Objects.nonNull(
                    numMax) && Objects.nonNull(numMin)) {
                double fieldValue = Double.parseDouble(item.getFieldValue());
                if (fieldValue < numMin || fieldValue > numMax) {
                    throw new ServiceException(
                            String.format("字段%s的值不在范围%d-%d内", tbField.getFieldName(),
                                    numMin, numMax));
                }
            }
            if (FieldTypeEnum.TEXT.equals(tbField.getFieldType())
                    && FieldInputTypeEnum.MANUAL_INPUT.equals(tbField.getTextInputType())
                    && Objects.nonNull(
                    textMaxNum) && Objects.nonNull(textMinNum)) {
                String fieldValue = item.getFieldValue();
                if (fieldValue.length() < numMin || fieldValue.length() > numMax) {
                    throw new ServiceException(
                            String.format("字段%s的值的长度不在范围%d-%d内", tbField.getFieldName(),
                                    textMinNum, textMaxNum));
                }
            }
        }
        tbBasicDataFields.forEach(
                item -> {
                    item.setBasicDataId(tbBasicData.getId());
        tbBasicDataFields = tbBasicDataFields.stream().filter(f -> Objects.nonNull(f.getFieldId()))
                .peek(item -> {
                    TbField tbField = fieldMap.get(item.getFieldId());
                    if (Objects.nonNull(tbField)) {
                        Integer numMax = tbField.getNumMax();
                        Integer numMin = tbField.getNumMin();
                        Integer textMaxNum = tbField.getTextMaxNum();
                        Integer textMinNum = tbField.getTextMinNum();
                        if (FieldTypeEnum.NUMBER.equals(tbField.getFieldType()) && Objects.nonNull(
                                numMax) && Objects.nonNull(numMin)) {
                            double fieldValue = Double.parseDouble(item.getFieldValue());
                            if (fieldValue < numMin || fieldValue > numMax) {
                                throw new ServiceException(
                                        String.format("字段%s的值不在范围%d-%d内",
                                                tbField.getFieldName(),
                                                numMin, numMax));
                            }
                        }
                        if (FieldTypeEnum.TEXT.equals(tbField.getFieldType())
                                && FieldInputTypeEnum.MANUAL_INPUT.equals(
                                tbField.getTextInputType())
                                && Objects.nonNull(
                                textMaxNum) && Objects.nonNull(textMinNum)) {
                            String fieldValue = item.getFieldValue();
                            if (fieldValue.length() < numMin || fieldValue.length() > numMax) {
                                throw new ServiceException(
                                        String.format("字段%s的值的长度不在范围%d-%d内",
                                                tbField.getFieldName(),
                                                textMinNum, textMaxNum));
                            }
                        }
                        item.setBasicDataId(tbBasicData.getId());
                        item.setFieldName(tbField.getFieldName());
                        if (StringUtils.isNotBlank(item.getFieldValue())) {
                            item.setFieldValue(item.getFieldValue().replace(",", ""));
                        }
                    } else {
                        TbField field = allFieldMap.get(item.getFieldId());
                        item.setFieldName(field.getFieldName());
                        item.setBasicDataId(basicData.getId());
                    }
                });

                }).collect(Collectors.toList());
        // 添加固定字段 转移支付规模、当期GDP
        TbBasicDataField transferPaymentScale = new TbBasicDataField();
        transferPaymentScale.setBasicDataId(tbBasicData.getId());
@@ -1148,12 +1231,182 @@
        tbBasicDataFieldService.remove(
                Wrappers.<TbBasicDataField>lambdaQuery()
                        .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
        Optional<TbBasicDataField> any = tbBasicDataFields.stream()
                .filter(t -> StringUtils.isBlank(t.getFieldValue())).findAny();
        if (!any.isPresent()) {
            tbBasicData.setStatus(ReportingStatusEnum.FILLED);
            this.updateById(tbBasicData);
        }
        tbBasicDataFieldService.saveBatch(tbBasicDataFields);
        if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
        /*if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
            CompletableFuture.runAsync(() -> {
                calculateScore(tbBasicData, tbBasicDataFields);
                calculateScreenScore(tbBasicData, tbBasicDataFields);
            });
        }*/
        asyncService.calculateScoreWithFixedRules(tbBasicData, tbBasicDataFields, fieldList);
    }

    @Override
    public void exportDataV2(List<String> quarterList) throws IOException {
        {
            response.setContentType("application/vnd.ms-excel");
            response.setCharacterEncoding("utf-8");
            String fileName = "财政运行分析指标评价表";
            response.setHeader(
                    "Content-disposition",
                    "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8") + ".xlsx");
            List<TbBasicData> tbBasicDataList = this.lambdaQuery()
                    .in(TbBasicData::getQuarter, quarterList)
                    .groupBy(TbBasicData::getQuarter).list();
            // 符合导出条件的基础数据
            List<TbBasicData> tbBasicDataListAll = this.lambdaQuery()
                    .in(TbBasicData::getQuarter, quarterList)
                    .list();
            Set<Long> basicDataSet = tbBasicDataListAll.stream().map(TbBasicData::getId)
                    .collect(Collectors.toSet());
            List<TbScore> scoreList = null;
            if (CollUtils.isNotEmpty(basicDataSet)) {
                // 符合导出条件的得分
                scoreList = tbScoreService.lambdaQuery()
                        .in(TbScore::getBasicDataId, basicDataSet)
                        .list();
            }
            List<BasicDataConfigVO> configVOList = tbBasicDataConfigService.getFixedRulesConfigList();
            // 基础数据id列表
            Set<Long> basicDataIdList = tbBasicDataList.stream().map(TbBasicData::getId)
                    .collect(Collectors.toSet());
            // 涉及到的部门编码
            Set<String> userAreaCodeList = tbBasicDataList.stream()
                    .map(TbBasicData::getDeptAreaCode)
                    .collect(Collectors.toSet());
            // 用户信息map
            Map<String, SysUser> userMap = sysUserService.lambdaQuery()
                    .in(SysUser::getAreaCode, userAreaCodeList).list().stream()
                    .collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
            // 构建Excel写对象
            try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
                    .registerWriteHandler(new CustomCellWriteHandler())
                    .registerWriteHandler(EasyExcelUtil.getStyleStrategy()).build()) {
                WriteSheet writeSheet;
                // 遍历季度基础数据
                for (String quarter : quarterList) {
                    List<TbBasicData> currentBasicData = tbBasicDataListAll.stream()
                            .filter(d -> d.getQuarter().equals(quarter)).collect(
                                    Collectors.toList());
                    Set<Long> cbdIdSet = currentBasicData.stream().map(TbBasicData::getId)
                            .collect(Collectors.toSet());

                    // 表头
                    List<List<String>> head = headV2(configVOList);
                    if (CollUtils.isNotEmpty(scoreList)) {
                        List<List<Object>> dataList = dataListV2(scoreList, currentBasicData,
                                userMap, head);
                        // 构建sheet对象
                        writeSheet = EasyExcel.writerSheet(quarter).head(head).build();
                        // 写出sheet数据
                        excelWriter.write(dataList, writeSheet);
                    }
                }
            }
        }
    }

    private List<List<String>> headV2(List<BasicDataConfigVO> configVOList) {
        List<List<String>> headTitles = Lists.newArrayList();
        // 固定字段
        headTitles.add(Lists.newArrayList("财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
                "财政运行分析指标评价表", "财政运行分析指标评价表"));
        headTitles.add(Lists.newArrayList("地区"));
        headTitles.add(Lists.newArrayList("级次"));
        headTitles.add(Lists.newArrayList("得分合计"));
        headTitles.add(Lists.newArrayList("一级指标", "财政经济形式",
                "预算管理方面", "预算执行方面", "风险防控方面"));
        headTitles.add(
                Lists.newArrayList("分值", "27", "重大财税政策落实情况",
                        "26", "20", "27"));
        headTitles.add(Lists.newArrayList("二级指标", "收入占GDP比重",
                "收入执行率", "收入质量", "重大财税落实情况", "重大财税政策落实情况", "转移支付",
                "\"三保\"保障情况", "强化预算约束", "库款管理", "预算执行情况", "中央直达资金",
                "暂付款管理", "债务管理", "日常监督发现问题"));
        headTitles.add(Lists.newArrayList("分值", "8", "11", "8", "--", "重大财税政策落实情况", "9",
                "17", "--", "6", "8", "6", "9", "18", "日常监督发现问题"));
        headTitles.add(
                Lists.newArrayList("三级指标", "地方一般公共预算收入占GDP的比重",
                        "地方一般公共预算收入执行进度（地方一般公共预算收入/年初预算或调整预算）",
                        "政府性基金预算收入执行进度（政府性基金预算收入/年初预算或调整预算）",
                        "税收收入占地方一般公共预算收入比重", "减税降费落实情况",
                        "其他重大政策落实情况", "中央转移支付占地方可用财力比重",
                        "“三保”年初预算保障情况", "“三保”需求占可用财力的比重",
                        "“三保”支出保障情况", "存量资金盘活", "不得无预算、超预算拨款",
                        "库款保障水平", "一般公共预算支出执行率", "政府性基金预算支出执行率",
                        "中央直达资金支付进度", "直达资金规范使用", "违规新增暂付款",
                        "暂付款累计余额", "暂付款消化", "法定债务率", "隐性债务率", "隐性债务化解",
                        "日常监督发现问题", "日常监督发现问题"));
        headTitles.add(
                Lists.newArrayList("分值", "8", "7", "4", "8", "--", "--", "9", "6", "8", "3", "——",
                        "--", "6", "5", "3", "3", "3", "3", "3", "3", "9", "9", "--", "--", "--"));

        return headTitles;
    }

    private List<List<Object>> dataListV2(List<TbScore> scoreList,
            List<TbBasicData> list,
            Map<String, SysUser> userMap,
            List<List<String>> head) {
        // 所有数据集合
        List<List<Object>> excellist = new ArrayList<>();
        // 构建栏号行
        List<Object> columnNo = Lists.newArrayList("栏号");
        for (int i = 1; i < head.size(); i++) {
            columnNo.add(String.valueOf(i));
        }
        excellist.add(columnNo);
        // 动态字段数据行
        for (TbBasicData tbBasicData : list) {
            // 转换为map，方便遍历的时候取
         /*   Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFieldList.stream()
                    .filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
                    .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
            SysUser sysUser = userMap.get(tbBasicData.getDeptAreaCode());
            if (CollUtils.isEmpty(basicDataFieldMap) || Objects.isNull(sysUser)) {
                continue;
            }*/
           /* List<Object> valueList = Lists.newArrayList(sysUser.getAreaName(),
                    tbBasicData.getQuarter());
            TbBasicDataField transferPaymentScale = basicDataFieldMap.get(-1L);
            valueList.add(
                    Objects.nonNull(transferPaymentScale)
                            ? transferPaymentScale.getFieldValue()
                            : "");
            TbBasicDataField currentGdp = basicDataFieldMap.get(-2L);
            valueList.add(
                    Objects.nonNull(currentGdp)
                            ? currentGdp.getFieldValue()
                            : "");
            for (TbField tbField : fieldList) {
                TbBasicDataField tbBasicDataField = basicDataFieldMap.get(tbField.getId());
                valueList.add(
                        Objects.nonNull(tbBasicDataField)
                                ? tbBasicDataField.getFieldValue()
                                : "");
            }
            excellist.add(valueList);
            valueList.add(tbBasicData.getRemark());*/
        }
        return excellist;
    }

    @Override
    public List<FieldAndScoreDataVO> getFieldAndScoreData(String areaCode, String nowQuarter,
            Integer yearType, Integer isAll) {
        return baseMapper.getFieldAndScoreData(areaCode, nowQuarter, yearType, isAll);
    }
}