From d68c61517a3a6d4ec4d47844c21bdc143f99cbab Mon Sep 17 00:00:00 2001
From: mitao <2763622819@qq.com>
Date: 星期三, 17 四月 2024 22:58:05 +0800
Subject: [PATCH] 大屏接口
---
ruoyi-system/src/main/java/com/ruoyi/system/listener/HistoryDataListener.java | 358 +++++++++++++++++++++++++++++++++++++++--------------------
1 files changed, 235 insertions(+), 123 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 f084ed3..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,40 +4,49 @@
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;
+import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.TbBasicData;
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;
@@ -56,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);
@@ -64,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;
@@ -73,42 +86,8 @@
this.tbScoreService = tbScoreService;
this.sysUserService = sysUserService;
this.quarter = quarter;
- }
-
- private static String validateFields(Map.Entry<Integer, String> integerStringEntry,
- Map<Integer, String> dataMap, TbField field) {
- String value = dataMap.get(integerStringEntry.getKey());
- if (FieldTypeEnum.NUMBER.equals(field.getFieldType())) {
- Integer numMin = field.getNumMin();
- Integer numMax = field.getNumMax();
- if (Objects.nonNull(numMin) && Objects.nonNull(numMax)) {
- if (numMin > Integer.parseInt(value) || numMax < Integer.parseInt(value)) {
- throw new ServiceException(
- String.format("字段（%s）的内容不在%d~%d范围内", field.getFieldName(),
- numMin, numMax));
- }
- }
- }
- if (FieldInputTypeEnum.MANUAL_INPUT.equals(field.getTextInputType())
- && FieldTypeEnum.TEXT.equals(field.getFieldType())) {
- Integer textMinNum = field.getTextMinNum();
- Integer textMaxNum = field.getTextMaxNum();
- if (Objects.nonNull(textMinNum) && Objects.nonNull(textMaxNum)) {
- if (textMinNum > value.length() || textMaxNum < value.length()) {
- throw new ServiceException(
- String.format("字段（%s）的内容长度超出%d~%d的范围",
- field.getFieldName(),
- textMinNum, textMaxNum));
- }
- }
- }
- if (FieldTypeEnum.PERCENTAGE.equals(field.getFieldType())) {
- if (0 > Double.parseDouble(value) || 100 < Double.parseDouble(value)) {
- throw new ServiceException(
- String.format("字段（%s）的内容不在0~100范围内", field.getFieldName()));
- }
- }
- return value;
+ this.tbDataScreenConfigService = tbDataScreenConfigService;
+ this.tbDataScreenScoreService = tbDataScreenScoreService;
}
@Override
@@ -131,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());
@@ -145,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();
@@ -190,6 +167,7 @@
tbBasicData.setDeptAreaCode(areaCode);
tbBasicData.setRemark(dataMap.get(remarkIndex));
tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
+ tbBasicData.setReportingTime(DateUtils.getQuarterDate(quarter));
tbBasicDataService.saveOrUpdate(tbBasicData);
tbBasicDataFieldService.remove(Wrappers.<TbBasicDataField>lambdaQuery()
.eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
@@ -227,12 +205,19 @@
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;
}
+ /**
+ * 需要导入的数据
+ *
+ * @return List<Map < Integer, String>>
+ */
private List<Map<Integer, String>> getMapList() {
for (int i = 0; i < cachedDataList.size(); i++) {
if (cachedDataList.get(i).get(0).equals("栏号")) {
@@ -242,6 +227,11 @@
return null;
}
+ /**
+ * 表头
+ *
+ * @return Map<Integer, String>
+ */
private Map<Integer, String> getHeadMap() {
for (int i = 0; i < cachedDataList.size(); i++) {
if (cachedDataList.get(i).get(0).equals("栏号")) {
@@ -251,93 +241,215 @@
return null;
}
- private void calculateScore(List<TbBasicData> tbBasicDataList) {
- for (TbBasicData tbBasicData : tbBasicDataList) {
- List<TbScore> scoreList = new ArrayList<>();
- //计算得分
- 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()));
- }
- double score = CalculateUtil.calculate(numberCalculateFormula, valueMap);
- TbScore tbScore = new TbScore();
- tbScore.setBasicDataId(tbBasicData.getId());
- tbScore.setScore(score);
- tbScore.setBasicDataConfigId(item.getId());
- scoreList.add(tbScore);
+ /**
+ * 校验字段内容
+ *
+ * @param integerStringEntry 动态字段表头Entry
+ * @param dataMap 数据map
+ * @param field 字段
+ * @return 值
+ */
+ private static String validateFields(Map.Entry<Integer, String> integerStringEntry,
+ Map<Integer, String> dataMap, TbField field) {
+ String value = dataMap.get(integerStringEntry.getKey());
+ if (FieldTypeEnum.NUMBER.equals(field.getFieldType())) {
+ Integer numMin = field.getNumMin();
+ Integer numMax = field.getNumMax();
+ if (Objects.nonNull(numMin) && Objects.nonNull(numMax)) {
+ if (numMin > Integer.parseInt(value) || numMax < Integer.parseInt(value)) {
+ throw new ServiceException(
+ String.format("字段（%s）的内容不在%d~%d范围内", field.getFieldName(),
+ numMin, numMax));
}
}
- 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 (FieldInputTypeEnum.MANUAL_INPUT.equals(field.getTextInputType())
+ && FieldTypeEnum.TEXT.equals(field.getFieldType())) {
+ Integer textMinNum = field.getTextMinNum();
+ Integer textMaxNum = field.getTextMaxNum();
+ if (Objects.nonNull(textMinNum) && Objects.nonNull(textMaxNum)) {
+ if (textMinNum > value.length() || textMaxNum < value.length()) {
+ throw new ServiceException(
+ String.format("字段（%s）的内容长度超出%d~%d的范围",
+ field.getFieldName(),
+ textMinNum, textMaxNum));
+ }
+ }
+ }
+ if (FieldTypeEnum.PERCENTAGE.equals(field.getFieldType())) {
+ if (0 > Double.parseDouble(value) || 100 < Double.parseDouble(value)) {
+ throw new ServiceException(
+ String.format("字段（%s）的内容不在0~100范围内", field.getFieldName()));
+ }
+ }
+ return value;
+ }
+
+ /**
+ * 计算得分
+ *
+ * @param tbBasicData
+ * @param fields
+ */
+ 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)) {
+ 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());
+ }
+ }
+ }
+ 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)) {
+ 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);
}
+ tbScoreService.saveBatch(scoreList);
+ }
+
+ 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