1.得分计算部分调整； 2.大屏得分计算；

mitao

2024-04-15 ce7e6574a1f9942fc090d989b52aceaa11ba8f3e

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

@@ -3,7 +3,7 @@
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.alibaba.fastjson2.JSONArray;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -12,10 +12,13 @@
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.CalculateTypeEnum;
import com.ruoyi.common.enums.DataScreenConfigEnum;
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.BeanUtils;
import com.ruoyi.common.utils.CalculateUtil;
@@ -28,10 +31,14 @@
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.TbDept;
import com.ruoyi.system.domain.TbField;
import com.ruoyi.system.domain.TbOperLog;
import com.ruoyi.system.domain.TbScore;
import com.ruoyi.system.dto.BasicDataDTO;
import com.ruoyi.system.dto.BasicDataFieldDTO;
import com.ruoyi.system.dto.CalculateItemDTO;
import com.ruoyi.system.handler.CustomCellWriteHandler;
import com.ruoyi.system.listener.BasicDataListener;
import com.ruoyi.system.listener.HistoryDataListener;
@@ -45,13 +52,17 @@
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.TbOperLogService;
import com.ruoyi.system.service.TbScoreService;
import com.ruoyi.system.utils.FieldBuildUtil;
import com.ruoyi.system.vo.BasicDataReportingVO;
import com.ruoyi.system.vo.CurrentFieldsAllVO;
import com.ruoyi.system.vo.CurrentFieldsDetailVO;
import com.ruoyi.system.vo.CurrentFieldsVO;
import com.ruoyi.system.vo.DataScreenConfigVO;
import com.ruoyi.system.vo.FieldsTreeVO;
import com.ruoyi.system.vo.ScoreCalculateVO;
import com.ruoyi.system.vo.ScoreVO;
@@ -62,12 +73,12 @@
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
@@ -97,6 +108,9 @@
    private final TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
    private final TbScoreService tbScoreService;
    private final ISysUserService sysUserService;
    private final TbOperLogService tbOperLogService;
    private final TbDataScreenScoreService tbDataScreenScoreService;
    private final TbDataScreenConfigService tbDataScreenConfigService;

    public static void setFieldValues(
            List<FieldsTreeVO> fields, Map<Long, TbBasicDataField> fieldMap) {
@@ -204,20 +218,35 @@
            return;
        }
        String nowQuarter = DateUtils.getNowQuarter();
        TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);
        tbBasicData.setDeptAreaCode(areaCode);
        tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
        tbBasicData.setQuarter(nowQuarter);
        tbBasicData.setReportingTime(DateUtils.getQuarterDate(nowQuarter));
        this.saveOrUpdate(tbBasicData);
        // 保存基础数据动态字段数据
        List<TbBasicDataField> tbBasicDataFields =
                BeanUtils.copyList(dto.getFields(), TbBasicDataField.class);
        // 查询需要填写的动态字段
        List<TbField> fieldList =
                tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
        Map<Long, TbField> fieldMap =
                fieldList.stream().collect(Collectors.toMap(TbField::getId, e -> e));
        Optional<TbBasicData> basicDataOpt = this.lambdaQuery()
                .eq(TbBasicData::getDeptAreaCode, areaCode)
                .eq(TbBasicData::getQuarter, nowQuarter).oneOpt();
        TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);
        if (basicDataOpt.isPresent()) {
            tbBasicData.setId(basicDataOpt.get().getId());
            this.updateById(tbBasicData);
            //查询该基础数据的动态字端
            List<TbBasicDataField> originFields = tbBasicDataFieldService.lambdaQuery()
                    .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()).list();
            CompletableFuture.runAsync(
                    () -> saveExchangeLog(loginUser, basicDataOpt.get(), originFields, dto,
                            fieldMap));
        } else {
            tbBasicData.setDeptAreaCode(areaCode);
            tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
            tbBasicData.setQuarter(nowQuarter);
            tbBasicData.setReportingTime(DateUtils.getQuarterDate(nowQuarter));
            this.save(tbBasicData);
        }
        // 保存基础数据动态字段数据
        List<TbBasicDataField> tbBasicDataFields =
                BeanUtils.copyList(dto.getFields(), TbBasicDataField.class);

        tbBasicDataFields.forEach(
                item -> {
                    item.setBasicDataId(tbBasicData.getId());
@@ -262,12 +291,116 @@
            this.updateById(tbBasicData);
        }
        if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
            calculateScore(tbBasicData);
            calculateScore(tbBasicData, tbBasicDataFields);
            CompletableFuture.runAsync(() -> calculateScreenScore(tbBasicData, tbBasicDataFields));
        }
    }

    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 riskLevel,
            Map<Long, TbBasicDataField> basicDataFieldMap) {
        List<CalculateItemDTO> scoreCalculateList = riskLevel.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);
        TbDataScreenScore tbDataScreenScore = new TbDataScreenScore();
        tbDataScreenScore.setDataScreenConfigId(riskLevel.getId());
        tbDataScreenScore.setDataScreenConfigId(riskLevel.getId());
        tbDataScreenScore.setDeptAreaCode(tbBasicData.getDeptAreaCode());
        tbDataScreenScore.setScore(score);
        tbDataScreenScoreService.save(tbDataScreenScore);
    }

    private void saveExchangeLog(LoginUser loginUser, TbBasicData tbBasicData,
            List<TbBasicDataField> originFields,
            BasicDataDTO dto, Map<Long, TbField> fieldMap) {
        List<TbOperLog> tbOperlogList = new ArrayList<>();
        String transferPaymentScale = tbBasicData.getTransferPaymentScale();
        String currentGdp = tbBasicData.getCurrentGdp();
        String remark = tbBasicData.getRemark();
        String transferPaymentScaleEdit = dto.getTransferPaymentScale();
        String currentGdpEdit = dto.getCurrentGdp();
        String remarkEdit = dto.getRemark();
        if (!transferPaymentScale.equals(transferPaymentScaleEdit)) {
            wrapOperLog(loginUser, tbBasicData, transferPaymentScale, transferPaymentScaleEdit,
                    tbOperlogList, "转移支付规模");
        }
        if (!currentGdp.equals(currentGdpEdit)) {
            wrapOperLog(loginUser, tbBasicData, currentGdp, currentGdpEdit, tbOperlogList,
                    "当期GDP");
        }
        if (!remark.equals(remarkEdit)) {
            wrapOperLog(loginUser, tbBasicData, remark, remarkEdit, tbOperlogList, "备注");
        }
        Map<Long, TbBasicDataField> basicDataFieldMap = originFields.stream()
                .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
        for (BasicDataFieldDTO field : dto.getFields()) {
            TbBasicDataField tbBasicDataField = basicDataFieldMap.get(field.getFieldId());
            TbField tbField = fieldMap.get(field.getFieldId());
            if (Objects.nonNull(tbBasicDataField) && Objects.nonNull(tbField)
                    && !tbBasicDataField.getFieldValue().equals(field.getFieldValue())) {
                String levelOneCategory = tbField.getLevelOneCategory();
                String levelTwoCategory = tbField.getLevelTwoCategory();
                String levelThreeCategory = tbField.getLevelThreeCategory();
                String fieldName = tbField.getFieldName();
                StringBuilder result = new StringBuilder();
                result.append(levelOneCategory).append("-");
                if (StringUtils.isNotBlank(levelTwoCategory)) {
                    result.append(levelTwoCategory).append("-");
                    if (StringUtils.isNotBlank(levelThreeCategory)) {
                        result.append(levelThreeCategory).append("-").append(fieldName);
                    } else {
                        result.append(fieldName);
                    }
                } else {
                    result.append(field);
                }
                wrapOperLog(loginUser, tbBasicData, tbBasicDataField.getFieldValue(),
                        field.getFieldValue(), tbOperlogList, result.toString());
            }
        }
    }

    private static void wrapOperLog(LoginUser loginUser, TbBasicData tbBasicData, String before,
            String after, List<TbOperLog> tbOperlogList, String fieldName) {
        TbOperLog tbOperLog = new TbOperLog();
        tbOperLog.setOperation(tbBasicData.getQuarter());
        tbOperLog.setStaffName(loginUser.getUser().getNickName());
        tbOperLog.setAreaName(loginUser.getUser().getAreaName());
        tbOperLog.setFieldName(fieldName);
        tbOperLog.setBusinessType(BusinessType.UPDBASICDATA.ordinal());
        tbOperLog.setBeforeEdit(before);
        tbOperLog.setAfterEdit(after);
        tbOperlogList.add(tbOperLog);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void importBasicData(MultipartFile file) throws Exception {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        String areaCode = loginUser.getUser().getAreaCode();
@@ -285,14 +418,14 @@
                .doRead();
    }

    private void calculateScore(TbBasicData tbBasicData) {
    private void calculateScore(TbBasicData tbBasicData, List<TbBasicDataField> fields) {
        // 计算得分
        List<TbBasicDataConfig> list =
                tbBasicDataConfigService
                        .lambdaQuery()
                        .eq(TbBasicDataConfig::getStatus, ShowStatusEnum.SHOW)
                        .list();
        if (CollectionUtils.isEmpty(list)) {
        if (CollUtils.isEmpty(list)) {
            throw new ServiceException("计算得分失败，平台未配置得分计算规则");
        }
        List<TbBasicDataConfig> numCalculates =
@@ -303,36 +436,33 @@
                list.stream()
                        .filter(item -> !CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
                        .collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(numCalculates)) {
            numCalculates.forEach(
                    item -> {
                        Map<String, Object> valueMap = new HashMap<>();
        Map<Long, TbBasicDataField> basicDataFieldMap = fields.stream()
                .collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
        if (CollUtils.isNotEmpty(numCalculates)) {
            for (TbBasicDataConfig item : numCalculates) {
                        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);
                        TbScore tbScore = new TbScore();
                        tbScore.setBasicDataId(tbBasicData.getId());
                        tbScore.setScore(score);
                        tbScore.setBasicDataConfigId(item.getId());
                        tbScoreService.save(tbScore);
                    });
        }
        if (CollectionUtils.isNotEmpty(textAndPercentages)) {
        }
        if (CollUtils.isNotEmpty(textAndPercentages)) {
            for (TbBasicDataConfig textAndPercentage : textAndPercentages) {
                TbScore tbScore = new TbScore();
                List<TbBasicDataConfigDetail> details =
@@ -347,18 +477,12 @@
                                        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 (CollUtils.isNotEmpty(details)) {
                    TbBasicDataField textAndPercentageData = basicDataFieldMap.get(
                            Long.valueOf(textAndPercentage.getFieldIdStr()));
                    if (Objects.nonNull(textAndPercentageData)) {
                        if (CalculateTypeEnum.TEXT.equals(textAndPercentage.getCalculateType())) {
                            String score = scoreMap.get(tbBasicDataField.getFieldValue());
                            String score = scoreMap.get(textAndPercentageData.getFieldValue());
                            tbScore.setBasicDataId(tbBasicData.getId());
                            tbScore.setScore(Double.parseDouble(score));
                            tbScore.setBasicDataConfigId(textAndPercentage.getId());
@@ -368,7 +492,8 @@
                                textAndPercentage.getCalculateType())) {
                            for (Map.Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
                                String[] split = stringStringEntry.getKey().split("-");
                                double v = Double.parseDouble(tbBasicDataField.getFieldValue());
                                double v = Double.parseDouble(
                                        textAndPercentageData.getFieldValue());
                                double min = Double.parseDouble(split[0]);
                                double max = Double.parseDouble(split[1]);
                                if (v >= min && v <= max) {