From a7a8a50f48c1bff5ddc52b3bad1782328f8043d8 Mon Sep 17 00:00:00 2001
From: mitao <2763622819@qq.com>
Date: 星期五, 12 四月 2024 18:50:20 +0800
Subject: [PATCH] 基础数据配置接口修改
---
ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java | 273 +++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 228 insertions(+), 45 deletions(-)
diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java b/ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java
index e3ae9c4..b23a913 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/listener/BasicDataListener.java
@@ -4,47 +4,71 @@
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.fastjson2.JSON;
+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.NumberDisplaceChineseUtil;
+import com.ruoyi.common.enums.CalculateTypeEnum;
+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.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.TbDept;
import com.ruoyi.system.domain.TbField;
+import com.ruoyi.system.domain.TbScore;
+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.TbFieldService;
-import lombok.extern.slf4j.Slf4j;
-
+import com.ruoyi.system.service.TbScoreService;
import java.time.LocalDate;
-import java.util.*;
+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.stream.Collectors;
+import lombok.extern.slf4j.Slf4j;
@Slf4j
public class BasicDataListener extends AnalysisEventListener<Map<Integer, String>> {
- /**
- * 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
- */
- private static final int BATCH_COUNT = 10;
- private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
- public TbBasicDataService tbBasicDataService;
- public List<TbField> fieldList;
- public TbFieldService tbFieldService;
- public TbDept dept;
- public TbBasicDataFieldService tbBasicDataFieldService;
- public BasicDataListener() {
- }
- public BasicDataListener(TbBasicDataService tbBasicDataService, List<TbField> fieldList, TbFieldService tbFieldService, TbDept dept, TbBasicDataFieldService tbBasicDataFieldService) {
+ /**
+ * 每隔5条存储数据库，实际使用中可以1000条，然后清理list ，方便内存回收
+ */
+ private static final int BATCH_COUNT = 1000;
+ private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(
+ BATCH_COUNT);
+ public TbBasicDataService tbBasicDataService;
+ public TbFieldService tbFieldService;
+ public String areaCode;
+ public TbBasicDataFieldService tbBasicDataFieldService;
+ public TbBasicDataConfigService tbBasicDataConfigService;
+ public TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
+ public TbScoreService tbScoreService;
+
+ public BasicDataListener(TbBasicDataService tbBasicDataService,
+ TbFieldService tbFieldService,
+ String areaCode, TbBasicDataFieldService tbBasicDataFieldService,
+ TbBasicDataConfigService tbBasicDataConfigService,
+ TbBasicDataConfigDetailService tbBasicDataConfigDetailService,
+ TbScoreService tbScoreService) {
this.tbBasicDataService = tbBasicDataService;
- this.fieldList = fieldList;
this.tbFieldService = tbFieldService;
- this.dept = dept;
+ this.areaCode = areaCode;
this.tbBasicDataFieldService = tbBasicDataFieldService;
+ this.tbBasicDataConfigService = tbBasicDataConfigService;
+ this.tbBasicDataConfigDetailService = tbBasicDataConfigDetailService;
+ this.tbScoreService = tbScoreService;
}
@Override
@@ -55,6 +79,9 @@
try {
saveData();
} catch (Exception e) {
+ if (e instanceof ServiceException) {
+ throw new ServiceException(e.getMessage());
+ }
throw new RuntimeException(e);
}
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
@@ -64,58 +91,214 @@
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
try {
- saveData();
+ TbBasicData tbBasicData = saveData();
+ calculateScore(tbBasicData);
} catch (Exception e) {
+ if (e instanceof ServiceException) {
+ throw new ServiceException(e.getMessage());
+ }
throw new RuntimeException(e);
}
log.info("所有数据解析完成！");
}
+ 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;
+ }
+
/**
* 加上存储数据库
*/
- private void saveData() throws Exception {
- Map<Integer, String> headMap = cachedDataList.get(2);
- Map<Integer, String> quarterMap = cachedDataList.get(4);
- Map<Integer, String> dataMap = cachedDataList.get(5);
+ private TbBasicData saveData() throws Exception {
+ // 查询需要填写的动态字段
+ List<TbField> fieldList =
+ tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
+ Map<Integer, String> headMap = cachedDataList.get(cachedDataList.size() - 3);
+ Map<Integer, String> dataMap = cachedDataList.get(cachedDataList.size() - 1);
log.info("{}条数据，开始存储数据库！", cachedDataList.size());
log.info("表头：{}", JSON.toJSONString(headMap));
- log.info("填写的数据：{}",JSON.toJSONString(dataMap));
- int remarkIndex = headMap.size()-1;
- Map<Integer, String> dynamicFieldsMap = headMap.entrySet().stream().filter(entry -> {
- return !(Lists.newArrayList(0, 1, 2, 3).contains(entry.getKey()) || entry.getKey() == remarkIndex);
- }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+ log.info("填写的数据：{}", JSON.toJSONString(dataMap));
+ 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());
+ List<String> collect = fieldList.stream().map(TbField::getFieldName)
+ .collect(Collectors.toList());
boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
- if (dynamicFields.size() != collect.size() || flag){
+ if (dynamicFields.size() != collect.size() || !flag) {
throw new ServiceException("导入失败，请下载最新的导入模板");
}
- Date date = new Date();
- //当前所在季度
- int quarterOfYear = DateUtils.getQuarterOfYear(date);
- String quarterOfYearStr = NumberDisplaceChineseUtil.numberToChinese(quarterOfYear);
LocalDate now = LocalDate.now();
- TbBasicData tbBasicData = new TbBasicData();
- tbBasicData.setQuarter(String.format("%s年%s",now.getYear(),quarterMap.get(1)));
+ TbBasicData tbBasicData;
+ String quarter = String.format("%s年%s", now.getYear(), dataMap.get(1));
+ Optional<TbBasicData> tbBasicDataOpt = tbBasicDataService.lambdaQuery().
+ eq(TbBasicData::getQuarter, quarter)
+ .eq(TbBasicData::getDeptAreaCode, areaCode).oneOpt();
+ tbBasicData = tbBasicDataOpt.orElseGet(TbBasicData::new);
+ tbBasicData.setQuarter(DateUtils.getNowQuarter());
tbBasicData.setTransferPaymentScale(dataMap.get(2));
tbBasicData.setCurrentGdp(dataMap.get(3));
- tbBasicData.setDeptAreaCode(dept.getAreaCode());
+ 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));
+ tbBasicDataFieldService.remove(Wrappers.<TbBasicDataField>lambdaQuery()
+ .eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
+ List<TbBasicDataField> fields = new ArrayList<>();
+ //添加固定字段 转移支付规模、当期GDP
+ TbBasicDataField transferPaymentScale = new TbBasicDataField();
+ transferPaymentScale.setBasicDataId(tbBasicData.getId());
+ transferPaymentScale.setFieldId(-1L);
+ transferPaymentScale.setFieldName("转移支付规模");
+ transferPaymentScale.setFieldValue(tbBasicData.getTransferPaymentScale());
+ fields.add(transferPaymentScale);
+
+ TbBasicDataField currentGdp = new TbBasicDataField();
+ currentGdp.setBasicDataId(tbBasicData.getId());
+ currentGdp.setFieldId(-2L);
+ currentGdp.setFieldName("当期GDP");
+ currentGdp.setFieldValue(tbBasicData.getCurrentGdp());
+ fields.add(currentGdp);
+ //遍历动态字段map
for (Map.Entry<Integer, String> integerStringEntry : dynamicFieldsMap.entrySet()) {
- Optional<TbField> tbField = tbFieldService.lambdaQuery().eq(TbField::getFieldName, integerStringEntry.getValue())
+ Optional<TbField> tbField = tbFieldService.lambdaQuery()
+ .eq(TbField::getFieldName, integerStringEntry.getValue())
.eq(TbField::getStatus, ShowStatusEnum.SHOW).oneOpt();
if (tbField.isPresent()) {
+ TbField field = tbField.get();
+ String value = validateFields(integerStringEntry, dataMap, field);
TbBasicDataField tbBasicDataField = new TbBasicDataField();
tbBasicDataField.setBasicDataId(tbBasicData.getId());
- tbBasicDataField.setFieldId(tbField.get().getId());
- tbBasicDataField.setFieldValue(dataMap.get(integerStringEntry.getKey()));
- tbBasicDataFieldService.save(tbBasicDataField);
+ tbBasicDataField.setFieldId(field.getId());
+ tbBasicDataField.setFieldName(field.getFieldName());
+ tbBasicDataField.setFieldValue(value);
+ fields.add(tbBasicDataField);
}
}
- log.info("存储数据库成功！");
+ tbBasicDataFieldService.saveBatch(fields);
+ tbBasicData.setStatus(ReportingStatusEnum.FILLED);
+ tbBasicDataService.updateById(tbBasicData);
+ log.info(String.format("%s导入基础数据成功！", dataMap.get(0)));
+ return tbBasicData;
+ }
+
+ private void calculateScore(TbBasicData tbBasicData) {
+ 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);
+ }
+ }
+ 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()));
+ }
+ }
+ tbScore.setBasicDataId(tbBasicData.getId());
+ tbScore.setBasicDataConfigId(textAndPercentage.getId());
+ scoreList.add(tbScore);
+ }
+ }
+ }
+ }
+ }
+ tbScoreService.saveBatch(scoreList);
}
}
--
Gitblit v1.7.1