package com.finance.system.listener;
|
|
import com.alibaba.excel.context.AnalysisContext;
|
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.finance.common.core.domain.entity.SysUser;
|
import com.finance.common.enums.CalculateTypeEnum;
|
import com.finance.common.enums.DataScreenConfigEnum;
|
import com.finance.common.enums.FieldInputTypeEnum;
|
import com.finance.common.enums.FieldTypeEnum;
|
import com.finance.common.enums.ReportingStatusEnum;
|
import com.finance.common.enums.ShowStatusEnum;
|
import com.finance.common.enums.UserTypeEnum;
|
import com.finance.common.enums.ValueTypeEnum;
|
import com.finance.common.exception.ServiceException;
|
import com.finance.common.utils.CalculateUtil;
|
import com.finance.common.utils.CollUtils;
|
import com.finance.common.utils.DateUtils;
|
import com.finance.common.utils.StringUtils;
|
import com.finance.system.domain.TbBasicData;
|
import com.finance.system.domain.TbBasicDataConfig;
|
import com.finance.system.domain.TbBasicDataConfigDetail;
|
import com.finance.system.domain.TbBasicDataField;
|
import com.finance.system.domain.TbDataScreenScore;
|
import com.finance.system.domain.TbField;
|
import com.finance.system.domain.TbScore;
|
import com.finance.system.dto.CalculateItemDTO;
|
import com.finance.system.service.AsyncService;
|
import com.finance.system.service.ISysUserService;
|
import com.finance.system.service.TbBasicDataConfigDetailService;
|
import com.finance.system.service.TbBasicDataConfigService;
|
import com.finance.system.service.TbBasicDataFieldService;
|
import com.finance.system.service.TbBasicDataService;
|
import com.finance.system.service.TbDataScreenConfigService;
|
import com.finance.system.service.TbDataScreenScoreService;
|
import com.finance.system.service.TbFieldService;
|
import com.finance.system.service.TbScoreService;
|
import com.finance.system.vo.DataScreenConfigVO;
|
import com.google.common.collect.Lists;
|
import java.time.LocalDate;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Objects;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
import lombok.extern.slf4j.Slf4j;
|
import org.jetbrains.annotations.NotNull;
|
|
@Slf4j
|
public class HistoryDataListener extends AnalysisEventListener<Map<Integer, String>> {
|
|
/**
|
* 每隔5条存储数据库，实际使用中可以1000条，然后清理list ，方便内存回收
|
*/
|
private static final int BATCH_COUNT = 1000;
|
public TbBasicDataService tbBasicDataService;
|
public TbFieldService tbFieldService;
|
public TbBasicDataFieldService tbBasicDataFieldService;
|
public TbBasicDataConfigService tbBasicDataConfigService;
|
public TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
|
public TbScoreService tbScoreService;
|
public ISysUserService sysUserService;
|
public String quarter;
|
public TbDataScreenScoreService tbDataScreenScoreService;
|
public TbDataScreenConfigService tbDataScreenConfigService;
|
public AsyncService asyncService;
|
private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(
|
BATCH_COUNT);
|
|
public HistoryDataListener(TbBasicDataService tbBasicDataService,
|
TbFieldService tbFieldService,
|
TbBasicDataFieldService tbBasicDataFieldService,
|
TbBasicDataConfigService tbBasicDataConfigService,
|
TbBasicDataConfigDetailService tbBasicDataConfigDetailService,
|
TbScoreService tbScoreService, ISysUserService sysUserService, String quarter,
|
TbDataScreenScoreService tbDataScreenScoreService,
|
TbDataScreenConfigService tbDataScreenConfigService, AsyncService asyncService) {
|
this.tbBasicDataService = tbBasicDataService;
|
this.tbFieldService = tbFieldService;
|
this.tbBasicDataFieldService = tbBasicDataFieldService;
|
this.tbBasicDataConfigService = tbBasicDataConfigService;
|
this.tbBasicDataConfigDetailService = tbBasicDataConfigDetailService;
|
this.tbScoreService = tbScoreService;
|
this.sysUserService = sysUserService;
|
this.quarter = quarter;
|
this.tbDataScreenConfigService = tbDataScreenConfigService;
|
this.tbDataScreenScoreService = tbDataScreenScoreService;
|
this.asyncService = asyncService;
|
}
|
|
@Override
|
public void invoke(Map<Integer, String> data, AnalysisContext context) {
|
log.info("解析到一条数据:{}", JSON.toJSONString(data));
|
cachedDataList.add(data);
|
if (cachedDataList.size() >= BATCH_COUNT) {
|
try {
|
saveData();
|
} catch (Exception e) {
|
if (e instanceof ServiceException) {
|
throw new ServiceException(e.getMessage());
|
}
|
throw new RuntimeException(e);
|
}
|
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
|
}
|
}
|
|
@Override
|
public void doAfterAllAnalysed(AnalysisContext context) {
|
try {
|
saveData();
|
} catch (Exception e) {
|
if (e instanceof ServiceException) {
|
throw new ServiceException(e.getMessage());
|
}
|
throw new RuntimeException(e);
|
}
|
log.info("所有数据解析完成！");
|
}
|
|
/**
|
* 加上存储数据库
|
*/
|
private void saveData() {
|
// 查询需要填写的动态字段
|
List<TbField> fieldList =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
Map<Integer, String> headMap = getHeadMap();
|
int remarkIndex = headMap.size() - 1;
|
Map<Integer, String> dynamicFieldsMap = getDynamicHeadMap(headMap, remarkIndex);
|
Map<Integer, String> dynamicCategoryOneMap = getDynamicHeadMap(cachedDataList.get(0),
|
remarkIndex);
|
Map<Integer, String> dynamicCategoryTwoMap = getDynamicHeadMap(cachedDataList.get(1),
|
remarkIndex);
|
Map<Integer, String> dynamicCategoryThreeMap = getDynamicHeadMap(cachedDataList.get(2),
|
remarkIndex);
|
List<Map<Integer, String>> dataMapList = getMapList();
|
if (headMap == null || dataMapList == null) {
|
throw new ServiceException("导入失败，请下载最新的导入模板");
|
}
|
log.info("{}条数据，开始存储数据库！", dataMapList.size());
|
log.info("表头：{}", JSON.toJSONString(headMap));
|
log.info("填写的数据：{}", JSON.toJSONString(dataMapList));
|
|
/* boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
|
if (dynamicFields.size() != collect.size() || !flag) {
|
throw new ServiceException("导入失败，请下载最新的导入模板");
|
}*/
|
List<String> dynamicFields = new ArrayList<>(dynamicFieldsMap.values());
|
List<String> collect = fieldList.stream().map(TbField::getFieldName)
|
.collect(Collectors.toList());
|
boolean flag = new ArrayList<>(dynamicFields).containsAll(collect);
|
if (dynamicFields.size() != fieldList.size() || !flag) {
|
throw new ServiceException("导入失败，请下载最新的导入模板");
|
}
|
List<SysUser> departmentList = sysUserService.lambdaQuery()
|
.eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT).list();
|
List<TbBasicData> basicDataList = tbBasicDataService.lambdaQuery().
|
eq(TbBasicData::getQuarter, quarter).list();
|
for (Map<Integer, String> dataMap : dataMapList) {
|
// 查询需要填写的动态字段
|
fieldList =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
Optional<SysUser> sysUser = departmentList.stream()
|
.filter(dept -> dept.getAreaName().equals(dataMap.get(0))).findFirst();
|
if (!sysUser.isPresent()) {
|
throw new ServiceException("该地区不存在，请修改后重新导入！");
|
}
|
String areaCode = sysUser.get().getAreaCode();
|
LocalDate now = LocalDate.now();
|
TbBasicData tbBasicData;
|
Optional<TbBasicData> tbBasicDataOpt = basicDataList.stream()
|
.filter(basicData -> basicData.getDeptAreaCode().equals(areaCode)).findFirst();
|
tbBasicData = tbBasicDataOpt.orElseGet(TbBasicData::new);
|
tbBasicData.setQuarter(quarter);
|
tbBasicData.setTransferPaymentScale(dataMap.get(2).replace(",", ""));
|
tbBasicData.setCurrentGdp(dataMap.get(3).replace(",", ""));
|
tbBasicData.setDeptAreaCode(areaCode);
|
tbBasicData.setRemark(dataMap.get(remarkIndex));
|
tbBasicData.setStatus(ReportingStatusEnum.MISSING_DATA);
|
tbBasicData.setReportingTime(DateUtils.getQuarterDate(quarter));
|
long count = dataMap.entrySet().stream()
|
.filter(entry -> StringUtils.isBlank(entry.getValue())).count();
|
tbBasicData.setStatus(
|
count > 0 ? ReportingStatusEnum.MISSING_DATA : ReportingStatusEnum.FILLED);
|
tbBasicDataService.saveOrUpdate(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())
|
.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(field.getId());
|
tbBasicDataField.setFieldName(field.getFieldName());
|
tbBasicDataField.setFieldValue(value);
|
fields.add(tbBasicDataField);
|
}
|
}*/
|
// 遍历动态字段map
|
for (Entry<Integer, String> entry : dynamicFieldsMap.entrySet()) {
|
Integer key = entry.getKey();
|
String fieldStr = entry.getValue();
|
String categoryOne = dynamicCategoryOneMap.get(key);
|
String categoryTwo = dynamicCategoryTwoMap.get(key);
|
String categoryThree = dynamicCategoryThreeMap.get(key);
|
|
TbField field = getFieldByFieldName(fieldList, categoryOne, categoryTwo,
|
categoryThree, fieldStr);
|
|
if (Objects.nonNull(field)) {
|
String value = dataMap.get(key);
|
TbBasicDataField tbBasicDataField = new TbBasicDataField();
|
tbBasicDataField.setBasicDataId(tbBasicData.getId());
|
tbBasicDataField.setFieldId(field.getId());
|
tbBasicDataField.setFieldName(field.getFieldName());
|
tbBasicDataField.setFieldValue(
|
Objects.isNull(value) ? "" : value.replace(",", ""));
|
fields.add(tbBasicDataField);
|
}
|
}
|
tbBasicDataFieldService.saveBatch(fields);
|
// CompletableFuture.runAsync(() -> {
|
// calculateScore(tbBasicData, fields);
|
// calculateScreenScore(tbBasicData, fields);
|
// });
|
asyncService.calculateScoreWithFixedRules(tbBasicData, fields, fieldList);
|
}
|
log.info(String.format("%s导入基础数据成功！", JSON.toJSONString(dataMapList)));
|
}
|
|
private TbField getFieldByFieldName(List<TbField> fieldList, String categoryOne,
|
String categoryTwo,
|
String categoryThree,
|
String fieldStr) {
|
TbField field = null;
|
if (!fieldList.isEmpty()) {
|
/*
|
判断字段有几级分类，如果字段如果fieldStr与categoryTwo不同，说明该字段有二级分类。
|
如果字段如果fieldStr与categoryThree不同，说明该字段有三级分类。
|
res = 1 表示只有一级分类 res=2 表示该字段有二级分类，res=3表示该字段有三级分类
|
*/
|
int res =
|
!fieldStr.equals(categoryTwo) ? (!fieldStr.equals(categoryThree) ? 3 : 2) : 1;
|
Optional<TbField> fieldOptional = Optional.empty();
|
switch (res) {
|
case 1:
|
fieldOptional = fieldList.stream()
|
.filter(item -> item.getFieldName().equals(fieldStr)
|
&& item.getLevelOneCategory().equals(categoryOne)
|
&& item.getStatus()
|
== ShowStatusEnum.SHOW)
|
.findFirst();
|
if (fieldOptional.isPresent()) {
|
field = fieldOptional.get();
|
field.setFieldName(categoryOne + "-" + field.getFieldName());
|
}
|
break;
|
case 2:
|
fieldOptional = fieldList.stream()
|
.filter(item -> item.getFieldName().equals(fieldStr)
|
&& item.getLevelOneCategory().equals(categoryOne)
|
&& item.getStatus()
|
== ShowStatusEnum.SHOW)
|
.filter(item -> item.getLevelTwoCategory().equals(categoryTwo))
|
.findFirst();
|
if (fieldOptional.isPresent()) {
|
field = fieldOptional.get();
|
field.setFieldName(
|
categoryOne + "-" + categoryTwo + "-" + field.getFieldName());
|
}
|
break;
|
case 3:
|
fieldOptional = fieldList.stream()
|
.filter(item -> item.getFieldName().equals(fieldStr)
|
&& item.getLevelOneCategory().equals(categoryOne)
|
&& item.getStatus()
|
== ShowStatusEnum.SHOW)
|
.filter(item -> item.getLevelTwoCategory().equals(categoryTwo))
|
.filter(item -> item.getLevelThreeCategory()
|
.equals(categoryThree))
|
.findFirst();
|
if (fieldOptional.isPresent()) {
|
field = fieldOptional.get();
|
field.setFieldName(
|
categoryOne + "-" + categoryTwo + "-" + categoryThree + "-"
|
+ field.getFieldName());
|
}
|
break;
|
}
|
}
|
return field;
|
}
|
|
|
/**
|
* 需要导入的数据
|
*
|
* @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("栏号")) {
|
return cachedDataList.subList(i + 1, cachedDataList.size());
|
}
|
}
|
return null;
|
}
|
|
@NotNull
|
private static Map<Integer, String> getDynamicHeadMap(Map<Integer, String> headMap,
|
int remarkIndex) {
|
Map<Integer, String> dynamicFieldsMap = headMap.entrySet().stream()
|
.filter(entry -> !(Lists.newArrayList(0, 1, 2, 3).contains(entry.getKey())
|
|| entry.getKey() == remarkIndex))
|
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
|
return dynamicFieldsMap;
|
}
|
|
/**
|
* 表头
|
*
|
* @return Map<Integer, String>
|
*/
|
private Map<Integer, String> getHeadMap() {
|
for (int i = 0; i < cachedDataList.size(); i++) {
|
if (cachedDataList.get(i).get(0).equals("栏号")) {
|
return cachedDataList.get(i - 1);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 校验字段内容
|
*
|
* @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 (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()));
|
}
|
}
|
// 如果都不匹配，得分为0
|
if (Objects.isNull(tbScore.getScore())) {
|
tbScore.setScore(0D);
|
}
|
tbScore.setBasicDataId(tbBasicData.getId());
|
tbScore.setBasicDataConfigId(textAndPercentage.getId());
|
scoreList.add(tbScore);
|
}
|
}
|
}
|
}
|
}
|
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);
|
}
|
}
|
