From 604d00f67ddcf25a9d079ceddd1c668b2a4e5288 Mon Sep 17 00:00:00 2001
From: mitao <2763622819@qq.com>
Date: 星期五, 19 四月 2024 15:08:22 +0800
Subject: [PATCH] bug修复
---
ruoyi-system/src/main/java/com/ruoyi/system/listener/HistoryDataListener.java | 258 ++++++++++++++++++++++++++++++++++-----------------
1 files changed, 172 insertions(+), 86 deletions(-)
diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/listener/HistoryDataListener.java b/ruoyi-system/src/main/java/com/ruoyi/system/listener/HistoryDataListener.java
index 4a4ed90..de4ba56 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/listener/HistoryDataListener.java
+++ b/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,96 +288,168 @@
/**
* 计算得分
*
- * @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();
- if (CollectionUtils.isEmpty(list)) {
- throw new ServiceException("计算得分失败，平台未配置得分计算规则");
- }
- List<TbBasicDataConfig> numCalculates = list.stream()
- .filter(item -> CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
- .collect(Collectors.toList());
- List<TbBasicDataConfig> textAndPercentages = list.stream()
- .filter(item -> !CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
- .collect(Collectors.toList());
- tbScoreService.remove(
- new LambdaQueryWrapper<TbScore>().eq(TbScore::getBasicDataId,
- tbBasicData.getId()));
- 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<TbBasicDataConfig> list = tbBasicDataConfigService.lambdaQuery()
+ .eq(TbBasicDataConfig::getStatus, ShowStatusEnum.SHOW).list();
+ if (CollectionUtils.isEmpty(list)) {
+ throw new ServiceException("计算得分失败，平台未配置得分计算规则");
+ }
+ List<TbBasicDataConfig> numCalculates = list.stream()
+ .filter(item -> CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
+ .collect(Collectors.toList());
+ List<TbBasicDataConfig> textAndPercentages = list.stream()
+ .filter(item -> !CalculateTypeEnum.NUMBER.equals(item.getCalculateType()))
+ .collect(Collectors.toList());
+ tbScoreService.remove(
+ 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) {
+ String numberCalculateFormula = item.getNumberCalculateFormula();
+ 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);
- TbScore tbScore = new TbScore();
- tbScore.setBasicDataId(tbBasicData.getId());
- tbScore.setScore(score);
- tbScore.setBasicDataConfigId(item.getId());
- scoreList.add(tbScore);
}
+ 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);
+ tbScore.setBasicDataConfigId(item.getId());
+ scoreList.add(tbScore);
}
- if (CollUtils.isNotEmpty(textAndPercentages)) {
- for (TbBasicDataConfig textAndPercentage : textAndPercentages) {
- TbScore tbScore = new TbScore();
- List<TbBasicDataConfigDetail> details = tbBasicDataConfigDetailService.lambdaQuery()
- .eq(TbBasicDataConfigDetail::getBasicDataConfigId,
- textAndPercentage.getId())
- .list();
- Map<String, String> scoreMap = details.stream().collect(
- 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());
- tbScore.setBasicDataId(tbBasicData.getId());
- tbScore.setScore(Double.parseDouble(score));
- tbScore.setBasicDataConfigId(textAndPercentage.getId());
- scoreList.add(tbScore);
- }
- 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());
- double min = Double.parseDouble(split[0]);
- double max = Double.parseDouble(split[1]);
- if (v >= min && v <= max) {
- tbScore.setScore(
- Double.parseDouble(stringStringEntry.getValue()));
- }
+ }
+ if (CollUtils.isNotEmpty(textAndPercentages)) {
+ for (TbBasicDataConfig textAndPercentage : textAndPercentages) {
+ TbScore tbScore = new TbScore();
+ List<TbBasicDataConfigDetail> details = tbBasicDataConfigDetailService.lambdaQuery()
+ .eq(TbBasicDataConfigDetail::getBasicDataConfigId,
+ textAndPercentage.getId())
+ .list();
+ Map<String, String> scoreMap = details.stream().collect(
+ Collectors.toMap(TbBasicDataConfigDetail::getKey,
+ TbBasicDataConfigDetail::getValue));
+ if (CollectionUtils.isNotEmpty(details)) {
+ 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());
+ scoreList.add(tbScore);
+ }
+ if (CalculateTypeEnum.PERCENTAGE.equals(
+ textAndPercentage.getCalculateType())) {
+ for (Map.Entry<String, String> stringStringEntry : scoreMap.entrySet()) {
+ 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()));
}
- tbScore.setBasicDataId(tbBasicData.getId());
- tbScore.setBasicDataConfigId(textAndPercentage.getId());
- scoreList.add(tbScore);
}
+ //如果都不匹配，得分为0
+ if (Objects.isNull(tbScore.getScore())) {
+ tbScore.setScore(0D);
+ }
+ tbScore.setBasicDataId(tbBasicData.getId());
+ tbScore.setBasicDataConfigId(textAndPercentage.getId());
+ scoreList.add(tbScore);
}
}
}
}
}
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);
}
}
--
Gitblit v1.7.1