package com.finance.system.service.impl;
|
|
import cn.hutool.core.date.DateUtil;
|
import com.alibaba.excel.EasyExcel;
|
import com.alibaba.excel.ExcelWriter;
|
import com.alibaba.excel.write.metadata.WriteSheet;
|
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;
|
import com.finance.common.basic.PageDTO;
|
import com.finance.common.core.domain.R;
|
import com.finance.common.core.domain.entity.SysUser;
|
import com.finance.common.core.domain.model.LoginUser;
|
import com.finance.common.enums.BusinessType;
|
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.BeanUtils;
|
import com.finance.common.utils.CalculateUtil;
|
import com.finance.common.utils.CollUtils;
|
import com.finance.common.utils.DateUtils;
|
import com.finance.common.utils.EasyExcelUtil;
|
import com.finance.common.utils.SecurityUtils;
|
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.TbOperLog;
|
import com.finance.system.domain.TbScore;
|
import com.finance.system.dto.BasicDataDTO;
|
import com.finance.system.dto.BasicDataFieldDTO;
|
import com.finance.system.dto.CalculateItemDTO;
|
import com.finance.system.dto.update.BasicDataUpdDTO;
|
import com.finance.system.handler.CustomCellWriteHandler;
|
import com.finance.system.listener.BasicDataListener;
|
import com.finance.system.listener.HistoryDataListener;
|
import com.finance.system.mapper.TbBasicDataMapper;
|
import com.finance.system.query.CurrentFieldsQuery;
|
import com.finance.system.query.ScoreCalculateQuery;
|
import com.finance.system.query.ScoreQuery;
|
import com.finance.system.service.AsyncService;
|
import com.finance.system.service.ISysUserService;
|
import com.finance.system.service.TbBasicDataCategoryService;
|
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.TbOperLogService;
|
import com.finance.system.service.TbScoreService;
|
import com.finance.system.utils.FieldBuildUtil;
|
import com.finance.system.vo.BasicDataConfigVO;
|
import com.finance.system.vo.BasicDataReportingVO;
|
import com.finance.system.vo.CurrentFieldsAllVO;
|
import com.finance.system.vo.CurrentFieldsDetailVO;
|
import com.finance.system.vo.CurrentFieldsVO;
|
import com.finance.system.vo.DataScreenConfigVO;
|
import com.finance.system.vo.FieldAndScoreDataVO;
|
import com.finance.system.vo.FieldsTreeVO;
|
import com.finance.system.vo.ScoreCalculateVO;
|
import com.finance.system.vo.ScoreVO;
|
import com.finance.system.vo.TransferPaymentScaleVO;
|
import com.google.common.collect.Lists;
|
import java.io.IOException;
|
import java.net.URLEncoder;
|
import java.time.Instant;
|
import java.time.LocalDate;
|
import java.time.ZoneId;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
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;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
/**
|
* 基础数据表 服务实现类
|
*
|
* @author mitao
|
* @since 2024-03-13
|
*/
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class TbBasicDataServiceImpl extends ServiceImpl<TbBasicDataMapper, TbBasicData>
|
implements TbBasicDataService {
|
|
private final HttpServletResponse response;
|
private final TbFieldService tbFieldService;
|
private final TbBasicDataFieldService tbBasicDataFieldService;
|
private final TbBasicDataConfigService tbBasicDataConfigService;
|
private final TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
|
private final TbScoreService tbScoreService;
|
private final ISysUserService sysUserService;
|
private final TbOperLogService tbOperLogService;
|
private final TbDataScreenScoreService tbDataScreenScoreService;
|
private final TbDataScreenConfigService tbDataScreenConfigService;
|
private final AsyncService asyncService;
|
private final TbBasicDataCategoryService tbBasicDataCategoryService;
|
|
public static void setFieldValues(
|
List<FieldsTreeVO> fields, Map<Long, TbBasicDataField> fieldMap) {
|
for (FieldsTreeVO field : fields) {
|
TbBasicDataField tbBasicDataField = fieldMap.get(field.getId());
|
if (tbBasicDataField != null) {
|
field.setValue(
|
tbBasicDataField.getFieldValue());
|
} else {
|
field.setValue("");
|
}
|
if (field.getChildren() != null && !field.getChildren().isEmpty()) {
|
setFieldValues(field.getChildren(), fieldMap);
|
}
|
}
|
}
|
|
@Override
|
public R<BasicDataReportingVO> getBasicFields() throws Exception {
|
SysUser user = SecurityUtils.getLoginUser().getUser();
|
String deptAreaCode = user.getAreaCode();
|
BasicDataReportingVO vo = new BasicDataReportingVO();
|
// 校验区划代码
|
SysUser dept =
|
sysUserService.getOne(
|
Wrappers.<SysUser>lambdaQuery().eq(SysUser::getAreaCode, deptAreaCode));
|
if (Objects.isNull(dept)) {
|
throw new ServiceException(String.format("区划代码%s不存在", deptAreaCode));
|
}
|
Date date = new Date();
|
Date quarterStart = DateUtil.beginOfQuarter(date);
|
Date quarterEnd = DateUtil.endOfQuarter(date);
|
Instant instant = quarterStart.toInstant();
|
LocalDate quarterStartLocalDate = instant.atZone(ZoneId.systemDefault()).toLocalDate();
|
LocalDate fifteenDaysLimit = quarterStartLocalDate.plusDays(14);
|
LocalDate now = LocalDate.now();
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
DateUtils.getQuarterDate(previousQuarter);
|
vo.setQuarter(previousQuarter);
|
vo.setStatus(ReportingStatusEnum.UNFILLED);
|
// 如果当前时间不在规定范围内：季度初1-15号
|
/*if (now.isBefore(quarterStartLocalDate) || now.isAfter(fifteenDaysLimit)) {
|
return R.ok(vo, "请于季度初1-15号上传季度数据。");
|
}*/
|
// 查询是否有当前季度的填报记录
|
TbBasicData basicData =
|
this.getOne(
|
Wrappers.<TbBasicData>lambdaQuery()
|
.eq(TbBasicData::getDeptAreaCode, dept.getAreaCode())
|
.eq(TbBasicData::getQuarter, previousQuarter));
|
if (Objects.nonNull(basicData)) {
|
vo.setCreateTime(basicData.getCreateTime());
|
vo.setFinishedTime(basicData.getUpdateTime());
|
}
|
// 查询需要填写的字段
|
List<TbField> list =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
List<FieldsTreeVO> roots = new ArrayList<>();
|
FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
|
fieldsTreeVO.setId(-1L);
|
fieldsTreeVO.setName("转移支付规模");
|
fieldsTreeVO.setCategory(Boolean.FALSE);
|
FieldsTreeVO fieldsTreeVO2 = new FieldsTreeVO();
|
fieldsTreeVO2.setId(-2L);
|
fieldsTreeVO2.setName("当期GDP");
|
fieldsTreeVO2.setCategory(Boolean.FALSE);
|
roots.add(fieldsTreeVO);
|
roots.add(fieldsTreeVO2);
|
if (CollUtils.isNotEmpty(list)) {
|
FieldBuildUtil.buildTreeFromTbFieldList(list, roots);
|
FieldsTreeVO remark = new FieldsTreeVO();
|
remark.setId(-3L);
|
remark.setName("备注");
|
roots.add(remark);
|
vo.setFields(roots);
|
}
|
if (Objects.isNull(basicData)) {
|
vo.setQuarter(previousQuarter);
|
vo.setStatus(ReportingStatusEnum.UNFILLED);
|
return R.ok(vo);
|
} else {
|
vo.setStatus(basicData.getStatus());
|
// 查询已填报数据 包含数据缺失和已填报
|
List<TbBasicDataField> basicDataFields =
|
tbBasicDataFieldService
|
.lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, basicData.getId())
|
.list();
|
|
if (CollUtils.isNotEmpty(basicDataFields)) {
|
Map<Long, TbBasicDataField> fieldMap =
|
basicDataFields.stream()
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId,
|
Function.identity()));
|
setFieldValues(vo.getFields(), fieldMap);
|
return R.ok(vo);
|
}
|
}
|
return R.ok(vo);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveBasicData(BasicDataDTO dto) throws Exception {
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
String areaCode = loginUser.getUser().getAreaCode();
|
// 数据校验
|
if (Objects.isNull(dto) || CollUtils.isEmpty(dto.getFields())) {
|
return;
|
}
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
// 查询需要填写的动态字段
|
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, previousQuarter).oneOpt();
|
TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);
|
tbBasicData.setCurrentGdp(tbBasicData.getCurrentGdp().replace(",", ""));
|
tbBasicData.setTransferPaymentScale(tbBasicData.getTransferPaymentScale().replace(",", ""));
|
if (basicDataOpt.isPresent()) {
|
tbBasicData.setId(basicDataOpt.get().getId());
|
tbBasicData.setDeptAreaCode(areaCode);
|
tbBasicData.setQuarter(basicDataOpt.get().getQuarter());
|
tbBasicData.setUpdateTime(new Date());
|
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(previousQuarter);
|
tbBasicData.setReportingTime(DateUtils.getQuarterDate(previousQuarter));
|
this.save(tbBasicData);
|
}
|
// 保存基础数据动态字段数据
|
List<TbBasicDataField> tbBasicDataFieldsOrg =
|
BeanUtils.copyList(dto.getFields(), TbBasicDataField.class);
|
List<TbBasicDataField> tbBasicDataFields = tbBasicDataFieldsOrg.stream()
|
.filter(item -> Objects.nonNull(item.getFieldValue())).collect(
|
Collectors.toList());
|
tbBasicDataFields.forEach(
|
item -> {
|
item.setBasicDataId(tbBasicData.getId());
|
TbField tbField = fieldMap.get(item.getFieldId());
|
if (Objects.nonNull(tbField)) {
|
item.setFieldName(tbField.getFieldName());
|
}
|
Integer numMax = tbField.getNumMax();
|
Integer numMin = tbField.getNumMin();
|
Integer textMaxNum = tbField.getTextMaxNum();
|
Integer textMinNum = tbField.getTextMinNum();
|
if (FieldTypeEnum.NUMBER.equals(tbField.getFieldType()) && Objects.nonNull(
|
numMax) && Objects.nonNull(numMin)) {
|
double fieldValue = Double.parseDouble(item.getFieldValue());
|
if (fieldValue < numMin || fieldValue > numMax) {
|
throw new ServiceException(
|
String.format("字段%s的值不在范围%d-%d内",
|
tbField.getFieldName(),
|
numMin, numMax));
|
}
|
}
|
if (FieldTypeEnum.TEXT.equals(tbField.getFieldType())
|
&& FieldInputTypeEnum.MANUAL_INPUT.equals(
|
tbField.getTextInputType())
|
&& Objects.nonNull(
|
textMaxNum) && Objects.nonNull(textMinNum)) {
|
String fieldValue = item.getFieldValue();
|
if (fieldValue.length() < numMin || fieldValue.length() > numMax) {
|
throw new ServiceException(
|
String.format("字段%s的值的长度不在范围%d-%d内",
|
tbField.getFieldName(),
|
textMinNum, textMaxNum));
|
}
|
}
|
});
|
// 添加固定字段 转移支付规模、当期GDP
|
TbBasicDataField transferPaymentScale = new TbBasicDataField();
|
transferPaymentScale.setBasicDataId(tbBasicData.getId());
|
transferPaymentScale.setFieldId(-1L);
|
transferPaymentScale.setFieldValue(tbBasicData.getTransferPaymentScale());
|
tbBasicDataFields.add(transferPaymentScale);
|
TbBasicDataField currentGdp = new TbBasicDataField();
|
currentGdp.setBasicDataId(tbBasicData.getId());
|
currentGdp.setFieldId(-2L);
|
currentGdp.setFieldValue(tbBasicData.getCurrentGdp());
|
tbBasicDataFields.add(currentGdp);
|
TbBasicDataField remark = new TbBasicDataField();
|
remark.setBasicDataId(tbBasicData.getId());
|
remark.setFieldId(-3L);
|
remark.setFieldValue(tbBasicData.getRemark());
|
tbBasicDataFields.add(remark);
|
// 将该基础数据的动态字段数据全部删除
|
tbBasicDataFieldService.remove(
|
Wrappers.<TbBasicDataField>lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
|
tbBasicDataFieldService.saveBatch(tbBasicDataFields);
|
// 需要填写的动态字段
|
Set<Long> fieldIds = fieldList.stream().map(TbField::getId).collect(Collectors.toSet());
|
// 用户填写的动态字段
|
Set<Long> deptFieldIds =
|
tbBasicDataFields.stream().map(TbBasicDataField::getFieldId)
|
.collect(Collectors.toSet());
|
boolean flag =
|
deptFieldIds.containsAll(fieldIds)
|
&& (StringUtils.isNotEmpty(dto.getTransferPaymentScale())
|
&& StringUtils.isNotEmpty(dto.getCurrentGdp()));
|
if (flag) {
|
tbBasicData.setStatus(ReportingStatusEnum.FILLED);
|
tbBasicData.setFinishedTime(new Date());
|
this.updateById(tbBasicData);
|
}
|
/*if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
|
CompletableFuture.runAsync(() -> {
|
calculateScore(tbBasicData, tbBasicDataFields);
|
calculateScreenScore(tbBasicData, tbBasicDataFields);
|
});
|
}*/
|
asyncService.calculateScoreWithFixedRules(tbBasicData, tbBasicDataFields, fieldList);
|
}
|
|
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);
|
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);
|
}
|
|
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());
|
}
|
}
|
tbOperLogService.saveBatch(tbOperlogList);
|
}
|
|
private static void wrapOperLog(LoginUser loginUser, TbBasicData tbBasicData, String before,
|
String after, List<TbOperLog> tbOperlogList, String fieldName) {
|
SysUser user = loginUser.getUser();
|
TbOperLog tbOperLog = new TbOperLog();
|
tbOperLog.setOperation(tbBasicData.getQuarter());
|
tbOperLog.setStaffName(
|
user.getUserType() == UserTypeEnum.PLATFORM ? user
|
.getUserName()
|
: user.getNickName());
|
tbOperLog.setAreaName(
|
user.getUserType() == UserTypeEnum.PLATFORM ? "平台" : user.getAreaName());
|
tbOperLog.setFieldName(fieldName);
|
tbOperLog.setBusinessType(BusinessType.UPDBASICDATA.ordinal());
|
tbOperLog.setBeforeEdit(before);
|
tbOperLog.setAfterEdit(after);
|
tbOperlogList.add(tbOperLog);
|
}
|
|
@Override
|
public void importBasicData(MultipartFile file) throws Exception {
|
Date date = new Date();
|
Date quarterStart = DateUtil.beginOfQuarter(date);
|
Date quarterEnd = DateUtil.endOfQuarter(date);
|
// 判断当前时间是否在季度初1-15号
|
Instant instant = quarterStart.toInstant();
|
LocalDate quarterStartLocalDate = instant.atZone(ZoneId.systemDefault()).toLocalDate();
|
LocalDate fifteenDaysLimit = quarterStartLocalDate.plusDays(14);
|
LocalDate now = LocalDate.now();
|
// TODO
|
/* if (now.isBefore(quarterStartLocalDate) || now.isAfter(fifteenDaysLimit)) {
|
throw new ServiceException("请于季度初1-15号上传季度数据。");
|
}*/
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
String areaCode = loginUser.getUser().getAreaCode();
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
EasyExcel.read(
|
file.getInputStream(),
|
new BasicDataListener(
|
this,
|
tbFieldService,
|
areaCode,
|
tbBasicDataFieldService,
|
tbBasicDataConfigService,
|
tbBasicDataConfigDetailService,
|
tbScoreService, tbDataScreenScoreService, previousQuarter,
|
tbDataScreenConfigService,
|
asyncService))
|
.sheet()
|
.headRowNumber(0)
|
.doRead();
|
}
|
|
private void calculateScore(TbBasicData tbBasicData, List<TbBasicDataField> fields) {
|
// 计算得分
|
List<TbBasicDataConfig> list =
|
tbBasicDataConfigService
|
.lambdaQuery()
|
.eq(TbBasicDataConfig::getStatus, ShowStatusEnum.SHOW)
|
.list();
|
if (CollUtils.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());
|
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);
|
TbScore tbScore = new TbScore();
|
tbScore.setBasicDataId(tbBasicData.getId());
|
tbScore.setScore(score);
|
tbScore.setBasicDataConfigId(item.getId());
|
tbScoreService.save(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 (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(textAndPercentageData.getFieldValue());
|
tbScore.setBasicDataId(tbBasicData.getId());
|
tbScore.setScore(Double.parseDouble(score));
|
tbScore.setBasicDataConfigId(textAndPercentage.getId());
|
tbScoreService.save(tbScore);
|
}
|
if (CalculateTypeEnum.PERCENTAGE.equals(
|
textAndPercentage.getCalculateType())) {
|
for (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());
|
tbScoreService.save(tbScore);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
@Override
|
public PageDTO<ScoreVO> pageScore(ScoreQuery query) throws Exception {
|
Page<ScoreVO> page = new Page<>(query.getPageNum(), query.getPageSize());
|
SysUser user = SecurityUtils.getLoginUser().getUser();
|
String areaCode = user.getAreaCode();
|
Date date = new Date();
|
Date quarterStart = DateUtil.beginOfQuarter(date);
|
Date quarterEnd = DateUtil.endOfQuarter(date);
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
// 查询是否有当前季度的填报记录
|
TbBasicData basicData =
|
this.getOne(
|
Wrappers.<TbBasicData>lambdaQuery()
|
.eq(TbBasicData::getDeptAreaCode, areaCode)
|
.eq(TbBasicData::getQuarter, previousQuarter));
|
if (Objects.isNull(basicData)) {
|
return PageDTO.empty(page);
|
}
|
query.setBasicDataId(basicData.getId());
|
// 查询对应的基础数据配置
|
Page<ScoreVO> pageVO = tbScoreService.pageScore(query, page);
|
return PageDTO.of(pageVO);
|
}
|
|
@Override
|
public R<CurrentFieldsDetailVO> fieldsDetails(Long id) {
|
// 从数据库中获取基本数据
|
TbBasicData basicData = this.getById(id);
|
if (Objects.isNull(basicData)) {
|
throw new ServiceException("非法参数");
|
}
|
CurrentFieldsDetailVO vo = BeanUtils.copyBean(basicData, CurrentFieldsDetailVO.class);
|
vo.setId(basicData.getId());
|
// 查询用户信息
|
sysUserService
|
.lambdaQuery()
|
.eq(SysUser::getAreaCode, basicData.getDeptAreaCode())
|
.eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT.getCode())
|
.oneOpt()
|
.ifPresent(
|
item -> {
|
vo.setAreaName(item.getAreaName());
|
vo.setPhoneNumber(item.getPhoneNumber());
|
vo.setPersonInCharge(item.getPersonInCharge());
|
});
|
/* // 查询动态字段
|
List<TbBasicDataField> basicDataFields =
|
tbBasicDataFieldService
|
.lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, basicData.getId())
|
.list();
|
// 获取所有字段ID
|
Set<Long> fieldIds =
|
basicDataFields.stream().map(TbBasicDataField::getFieldId)
|
.collect(Collectors.toSet());
|
// 根据字段ID查询字段信息并构建字段ID到字段对象的映射
|
Map<Long, TbField> fieldMap =
|
tbFieldService
|
.lambdaQuery()
|
.in(!fieldIds.isEmpty(), TbField::getId, fieldIds)
|
.list()
|
.stream()
|
.collect(Collectors.toMap(TbField::getId, e -> e));
|
// 根节点
|
List<FieldsTreeVO> root = new ArrayList<>();
|
basicDataFields.stream()
|
.filter(item -> item.getFieldId() == -1)
|
.findFirst()
|
.ifPresent(
|
item -> {
|
FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
|
fieldsTreeVO.setId(item.getFieldId());
|
fieldsTreeVO.setName("转移支付规模");
|
fieldsTreeVO.setValue(item.getFieldValue());
|
fieldsTreeVO.setCategory(Boolean.FALSE);
|
root.add(fieldsTreeVO);
|
});
|
basicDataFields.stream()
|
.filter(item -> item.getFieldId() == -2)
|
.findFirst()
|
.ifPresent(
|
item -> {
|
FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
|
fieldsTreeVO.setId(item.getFieldId());
|
fieldsTreeVO.setName("当期GDP");
|
fieldsTreeVO.setValue(item.getFieldValue());
|
fieldsTreeVO.setCategory(Boolean.FALSE);
|
root.add(fieldsTreeVO);
|
});
|
FieldBuildUtil.buildTreeStructure(basicDataFields, fieldMap, root);
|
basicDataFields.stream()
|
.filter(item -> item.getFieldId() == -3)
|
.findFirst()
|
.ifPresent(
|
item -> {
|
FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
|
fieldsTreeVO.setId(item.getFieldId());
|
fieldsTreeVO.setName("备注");
|
fieldsTreeVO.setValue(item.getFieldValue());
|
fieldsTreeVO.setCategory(Boolean.FALSE);
|
root.add(fieldsTreeVO);
|
});
|
vo.setFields(root);*/
|
// 查询需要填写的字段
|
List<TbField> list =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
List<FieldsTreeVO> roots = new ArrayList<>();
|
FieldsTreeVO fieldsTreeVO = new FieldsTreeVO();
|
fieldsTreeVO.setId(-1L);
|
fieldsTreeVO.setName("转移支付规模");
|
fieldsTreeVO.setCategory(Boolean.FALSE);
|
FieldsTreeVO fieldsTreeVO2 = new FieldsTreeVO();
|
fieldsTreeVO2.setId(-2L);
|
fieldsTreeVO2.setName("当期GDP");
|
fieldsTreeVO2.setCategory(Boolean.FALSE);
|
roots.add(fieldsTreeVO);
|
roots.add(fieldsTreeVO2);
|
if (CollUtils.isNotEmpty(list)) {
|
FieldBuildUtil.buildTreeFromTbFieldList(list, roots);
|
FieldsTreeVO remark = new FieldsTreeVO();
|
remark.setId(-3L);
|
remark.setName("备注");
|
roots.add(remark);
|
vo.setFields(roots);
|
}
|
vo.setStatus(basicData.getStatus());
|
// 查询已填报数据 包含数据缺失和已填报
|
List<TbBasicDataField> basicDataFields =
|
tbBasicDataFieldService
|
.lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, basicData.getId())
|
.list();
|
|
if (CollUtils.isNotEmpty(basicDataFields)) {
|
Map<Long, TbBasicDataField> fieldMap =
|
basicDataFields.stream()
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId,
|
Function.identity()));
|
setFieldValues(vo.getFields(), fieldMap);
|
}
|
return R.ok(vo);
|
}
|
|
@Override
|
public R<PageDTO<CurrentFieldsVO>> fieldsStatics(CurrentFieldsQuery dto) {
|
Page<CurrentFieldsVO> page = new Page<>(dto.getPageNum(), dto.getPageSize());
|
return R.ok(PageDTO.of(baseMapper.fieldsStatics(page, dto)));
|
}
|
|
@Override
|
public CurrentFieldsAllVO fieldsStaticsAll() throws Exception {
|
CurrentFieldsAllVO vo = new CurrentFieldsAllVO();
|
List<FieldsTreeVO> roots = new ArrayList<>();
|
// 获取表头
|
FieldsTreeVO area = new FieldsTreeVO();
|
area.setCategory(Boolean.FALSE);
|
area.setName("地区");
|
FieldsTreeVO quarter = new FieldsTreeVO();
|
quarter.setCategory(Boolean.FALSE);
|
quarter.setName("填报季度");
|
FieldsTreeVO transferPaymentScale = new FieldsTreeVO();
|
transferPaymentScale.setName("转移支付规模");
|
FieldsTreeVO currentGdp = new FieldsTreeVO();
|
currentGdp.setCategory(Boolean.FALSE);
|
currentGdp.setName("当期GDP");
|
roots.add(area);
|
roots.add(quarter);
|
roots.add(transferPaymentScale);
|
roots.add(currentGdp);
|
// 查询当前季度填写字段
|
List<TbField> fieldList =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
FieldBuildUtil.buildTreeFromTbFieldList(fieldList, roots);
|
FieldsTreeVO remark = new FieldsTreeVO();
|
remark.setCategory(Boolean.FALSE);
|
remark.setName("备注");
|
roots.add(remark);
|
vo.setFields(roots);
|
String previousQuarter = DateUtils.getPreviousQuarter();
|
// previousQuarter = "2024年一季度";
|
// 查询上报的基础数据
|
List<TbBasicData> basicDataList =
|
this.lambdaQuery()
|
.eq(TbBasicData::getQuarter, previousQuarter)
|
.eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
|
.list();
|
if (CollUtils.isNotEmpty(basicDataList)) {
|
Set<String> areaCodeList =
|
basicDataList.stream().map(TbBasicData::getDeptAreaCode)
|
.collect(Collectors.toSet());
|
Map<String, SysUser> userMap =
|
sysUserService.lambdaQuery().in(SysUser::getAreaCode, areaCodeList).list()
|
.stream()
|
.collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
|
Set<Long> basicDataIds =
|
basicDataList.stream().map(TbBasicData::getId).collect(Collectors.toSet());
|
|
List<TbBasicDataField> tbBasicDataFieldList = tbBasicDataFieldService
|
.lambdaQuery()
|
.in(TbBasicDataField::getBasicDataId, basicDataIds)
|
.list();
|
// 值
|
List<Object> result = new ArrayList<>();
|
for (TbBasicData tbBasicData : basicDataList) {
|
SysUser user = userMap.get(tbBasicData.getDeptAreaCode());
|
Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFieldList.stream()
|
.filter(field -> field.getBasicDataId().equals(tbBasicData.getId()))
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
|
List<String> item = new ArrayList<>();
|
item.add(Objects.nonNull(user) ? user.getAreaName() : "");
|
item.add(tbBasicData.getQuarter());
|
item.add(tbBasicData.getTransferPaymentScale());
|
item.add(tbBasicData.getCurrentGdp());
|
for (TbField tbField : fieldList) {
|
TbBasicDataField tbBasicDataField = basicDataFieldMap.get(tbField.getId());
|
item.add(
|
Objects.nonNull(tbBasicDataField)
|
? tbBasicDataField.getFieldValue()
|
: "");
|
}
|
item.add(tbBasicData.getRemark());
|
result.add(item);
|
}
|
vo.setValue(result);
|
}
|
return vo;
|
}
|
|
@Override
|
public R<PageDTO<CurrentFieldsVO>> historyFieldsStatics(CurrentFieldsQuery dto) {
|
Page<CurrentFieldsVO> page = new Page<>(dto.getPageNum(), dto.getPageSize());
|
// 当前所在季度
|
return R.ok(PageDTO.of(baseMapper.fieldsStatics(page, dto)));
|
}
|
|
@Override
|
public PageDTO<ScoreCalculateVO> scoreCalculatePage(ScoreCalculateQuery query) {
|
Page<ScoreCalculateVO> page = new Page<>(query.getPageNum(), query.getPageSize());
|
Page<ScoreCalculateVO> pageVO = tbBasicDataConfigService.scoreCalculatePage(query, page);
|
return PageDTO.of(pageVO);
|
}
|
|
@Override
|
public CurrentFieldsAllVO fieldsStaticsAll(String quarterStr) {
|
CurrentFieldsAllVO vo = new CurrentFieldsAllVO();
|
List<FieldsTreeVO> roots = new ArrayList<>();
|
// 获取表头
|
FieldsTreeVO area = new FieldsTreeVO();
|
area.setCategory(Boolean.FALSE);
|
area.setName("地区");
|
FieldsTreeVO quarter = new FieldsTreeVO();
|
quarter.setCategory(Boolean.FALSE);
|
quarter.setName("填报季度");
|
FieldsTreeVO transferPaymentScale = new FieldsTreeVO();
|
transferPaymentScale.setName("转移支付规模");
|
FieldsTreeVO currentGdp = new FieldsTreeVO();
|
currentGdp.setCategory(Boolean.FALSE);
|
currentGdp.setName("当期GDP");
|
roots.add(area);
|
roots.add(quarter);
|
roots.add(transferPaymentScale);
|
roots.add(currentGdp);
|
List<TbBasicData> basicDataList =
|
this.lambdaQuery()
|
.eq(TbBasicData::getQuarter, quarterStr)
|
.eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
|
.list();
|
if (CollUtils.isEmpty(basicDataList)) {
|
throw new ServiceException("非法参数");
|
}
|
Long basicDataId = basicDataList.get(0).getId();
|
Set<Long> fieldIds =
|
tbBasicDataFieldService
|
.lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, basicDataId)
|
.ne(TbBasicDataField::getFieldId, -1L)
|
.ne(TbBasicDataField::getFieldId, -2L)
|
.list()
|
.stream()
|
.map(TbBasicDataField::getFieldId)
|
.collect(Collectors.toSet());
|
List<TbField> fieldList = tbFieldService.lambdaQuery().in(TbField::getId, fieldIds).list();
|
if (CollUtils.isEmpty(fieldList)) {
|
FieldsTreeVO remark = new FieldsTreeVO();
|
remark.setCategory(Boolean.FALSE);
|
remark.setName("备注");
|
roots.add(remark);
|
vo.setFields(roots);
|
return vo;
|
}
|
FieldBuildUtil.buildTreeFromTbFieldList(fieldList, roots);
|
FieldsTreeVO remark = new FieldsTreeVO();
|
remark.setCategory(Boolean.FALSE);
|
remark.setName("备注");
|
roots.add(remark);
|
vo.setFields(roots);
|
Set<String> areaCodeList =
|
basicDataList.stream().map(TbBasicData::getDeptAreaCode)
|
.collect(Collectors.toSet());
|
Map<String, SysUser> userMap =
|
sysUserService.lambdaQuery().in(SysUser::getAreaCode, areaCodeList).list().stream()
|
.collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
|
Set<Long> basicDataIds =
|
basicDataList.stream().map(TbBasicData::getId).collect(Collectors.toSet());
|
List<TbBasicDataField> basicDataFieldList = tbBasicDataFieldService
|
.lambdaQuery()
|
.in(TbBasicDataField::getBasicDataId, basicDataIds)
|
.list();
|
// 值
|
List<Object> result = new ArrayList<>();
|
for (TbBasicData tbBasicData : basicDataList) {
|
Map<Long, TbBasicDataField> basicDataFieldMap = basicDataFieldList.stream()
|
.filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
|
SysUser user = userMap.get(tbBasicData.getDeptAreaCode());
|
List<String> item = new ArrayList<>();
|
item.add(Objects.nonNull(user) ? user.getAreaName() : "");
|
item.add(tbBasicData.getQuarter());
|
item.add(tbBasicData.getTransferPaymentScale());
|
item.add(tbBasicData.getCurrentGdp());
|
for (TbField tbField : fieldList) {
|
TbBasicDataField tbBasicDataField = basicDataFieldMap.get(tbField.getId());
|
item.add(
|
Objects.nonNull(tbBasicDataField)
|
? tbBasicDataField.getFieldValue()
|
: "");
|
}
|
item.add(tbBasicData.getRemark());
|
result.add(item);
|
}
|
vo.setValue(result);
|
return vo;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void importData(MultipartFile file, String quarter) throws IOException {
|
// 校验季度
|
Date quarterDate = DateUtils.getQuarterDate(quarter);
|
|
Map<String, Date> quarterMap = DateUtils.getQuarterDate(new Date());
|
Date date = quarterMap.get("first");
|
LocalDate quarterLocalDate = DateUtils.dateToLocalDate(quarterDate);
|
LocalDate dateLocalDate = DateUtils.dateToLocalDate(date);
|
if (quarterLocalDate.isAfter(dateLocalDate) || quarterLocalDate.equals(dateLocalDate)) {
|
throw new ServiceException("请导入过去季度的数据。");
|
}
|
long start = System.currentTimeMillis();
|
EasyExcel.read(
|
file.getInputStream(),
|
new HistoryDataListener(
|
this,
|
tbFieldService,
|
tbBasicDataFieldService,
|
tbBasicDataConfigService,
|
tbBasicDataConfigDetailService,
|
tbScoreService, sysUserService, quarter, tbDataScreenScoreService,
|
tbDataScreenConfigService, asyncService))
|
.sheet()
|
.headRowNumber(0)
|
.doRead();
|
log.info("历史数据导入完成，耗时{}毫秒", System.currentTimeMillis() - start);
|
}
|
|
@Override
|
public void exportData(List<String> quarterList) throws Exception {
|
response.setContentType("application/vnd.ms-excel");
|
response.setCharacterEncoding("utf-8");
|
String fileName = "地方财政运行及“三保”情况统计表";
|
response.setHeader(
|
"Content-disposition",
|
"attachment;filename=" + URLEncoder.encode(fileName, "UTF-8") + ".xlsx");
|
// 季度数据，用于反查字段
|
List<TbBasicData> tbBasicDataList = this.lambdaQuery()
|
.in(TbBasicData::getQuarter, quarterList)
|
.eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
|
.groupBy(TbBasicData::getQuarter).list();
|
// 符合导出条件的基础数据
|
List<TbBasicData> tbBasicDataListAll = this.lambdaQuery()
|
.in(TbBasicData::getQuarter, quarterList)
|
.eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
|
.list();
|
// 基础数据id列表
|
Set<Long> basicDataIdList = tbBasicDataListAll.stream().map(TbBasicData::getId)
|
.collect(Collectors.toSet());
|
// 涉及到的部门编码
|
Set<String> userAreaCodeList = tbBasicDataListAll.stream().map(TbBasicData::getDeptAreaCode)
|
.collect(Collectors.toSet());
|
// 用户信息map
|
Map<String, SysUser> userMap = sysUserService.lambdaQuery()
|
.in(SysUser::getAreaCode, userAreaCodeList).list().stream()
|
.collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
|
// 基础数据对应的字段值列表
|
List<TbBasicDataField> tbBasicDataFieldList = tbBasicDataFieldService.lambdaQuery()
|
.in(TbBasicDataField::getBasicDataId, basicDataIdList)
|
.list();
|
// 构建Excel写对象
|
try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
|
.registerWriteHandler(new CustomCellWriteHandler())
|
.registerWriteHandler(EasyExcelUtil.getStyleStrategy()).build()) {
|
WriteSheet writeSheet;
|
// 遍历季度基础数据
|
for (TbBasicData tbBasicData : tbBasicDataList) {
|
// 该季度的动态字段id列表
|
Set<Long> fieldIdList = tbBasicDataFieldList.stream()
|
.filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
|
.map(TbBasicDataField::getFieldId)
|
.collect(Collectors.toSet());
|
// 字段列表
|
List<TbField> fieldList = tbFieldService.lambdaQuery()
|
.in(TbField::getId, fieldIdList)
|
.list();
|
// 表头
|
List<List<String>> head = head(fieldList);
|
// 过滤基础数据为遍历元素的季度
|
List<TbBasicData> list = tbBasicDataListAll.stream()
|
.filter(item -> tbBasicData.getQuarter().equals(item.getQuarter()))
|
.collect(Collectors.toList());
|
List<List<Object>> dataList = dataList(fieldList, list, tbBasicDataFieldList,
|
userMap,
|
head);
|
// 构建sheet对象
|
writeSheet = EasyExcel.writerSheet(tbBasicData.getQuarter()).head(head).build();
|
// 写出sheet数据
|
excelWriter.write(dataList, writeSheet);
|
}
|
}
|
}
|
|
private List<List<Object>> dataList(List<TbField> fieldList, List<TbBasicData> list,
|
List<TbBasicDataField> tbBasicDataFieldList, Map<String, SysUser> userMap,
|
List<List<String>> head) {
|
// 所有数据集合
|
List<List<Object>> excellist = new ArrayList<>();
|
// 构建栏号行
|
List<Object> columnNo = Lists.newArrayList("栏号");
|
for (int i = 1; i < head.size(); i++) {
|
columnNo.add(String.valueOf(i));
|
}
|
excellist.add(columnNo);
|
// 动态字段数据行
|
for (TbBasicData tbBasicData : list) {
|
// 转换为map，方便遍历的时候取
|
Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFieldList.stream()
|
.filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
|
SysUser sysUser = userMap.get(tbBasicData.getDeptAreaCode());
|
if (CollUtils.isEmpty(basicDataFieldMap) || Objects.isNull(sysUser)) {
|
continue;
|
}
|
List<Object> valueList = Lists.newArrayList(sysUser.getAreaName(),
|
tbBasicData.getQuarter());
|
TbBasicDataField transferPaymentScale = basicDataFieldMap.get(-1L);
|
valueList.add(
|
Objects.nonNull(transferPaymentScale)
|
? transferPaymentScale.getFieldValue()
|
: "");
|
TbBasicDataField currentGdp = basicDataFieldMap.get(-2L);
|
valueList.add(
|
Objects.nonNull(currentGdp)
|
? currentGdp.getFieldValue()
|
: "");
|
for (TbField tbField : fieldList) {
|
TbBasicDataField tbBasicDataField = basicDataFieldMap.get(tbField.getId());
|
valueList.add(
|
Objects.nonNull(tbBasicDataField)
|
? tbBasicDataField.getFieldValue()
|
: "");
|
}
|
excellist.add(valueList);
|
valueList.add(tbBasicData.getRemark());
|
}
|
return excellist;
|
}
|
|
|
private List<List<String>> head(List<TbField> list) {
|
List<List<String>> headTitles = Lists.newArrayList();
|
// 固定字段
|
headTitles.add(Lists.newArrayList("地区"));
|
headTitles.add(Lists.newArrayList("填报季度"));
|
headTitles.add(Lists.newArrayList("转移支付规模"));
|
headTitles.add(Lists.newArrayList("当期GDP"));
|
list.forEach(
|
item -> {
|
String levelOneCategory = item.getLevelOneCategory();
|
String levelTwoCategory = item.getLevelTwoCategory();
|
String levelThreeCategory = item.getLevelThreeCategory();
|
String fieldName = item.getFieldName();
|
headTitles.add(
|
Lists.newArrayList(
|
levelOneCategory,
|
StringUtils.isBlank(levelTwoCategory) ? fieldName
|
: levelTwoCategory,
|
StringUtils.isBlank(levelThreeCategory) ? fieldName
|
: levelThreeCategory,
|
fieldName));
|
});
|
headTitles.add(Lists.newArrayList("备注"));
|
return headTitles;
|
}
|
|
@Override
|
public Page<TransferPaymentScaleVO> transferPaymentScalePage(Page<TransferPaymentScaleVO> page,
|
String quarter) {
|
Page<TransferPaymentScaleVO> pageVO = baseMapper.transferPaymentScalePage(
|
page, quarter);
|
int rank = 1;
|
for (TransferPaymentScaleVO record : pageVO.getRecords()) {
|
record.setRank(rank++);
|
}
|
return pageVO;
|
}
|
|
@Override
|
public List<FieldAndScoreDataVO> selectBasicDataFieldsConfig(String areaCode,
|
String nowQuarter) {
|
return baseMapper.selectBasicDataFieldsConfig(areaCode, nowQuarter);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void editBasicData(BasicDataUpdDTO dto) throws Exception {
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
// 数据校验
|
if (Objects.isNull(dto)) {
|
return;
|
}
|
// 查询基础数据
|
TbBasicData basicData = this.getById(dto.getId());
|
if (Objects.isNull(basicData)) {
|
throw new ServiceException("非法参数");
|
}
|
this.updateById(basicData);
|
// 查询该基础数据的动态字端
|
// 查询需要填写的动态字段
|
List<TbField> fieldList =
|
tbFieldService.lambdaQuery().eq(TbField::getStatus, ShowStatusEnum.SHOW).list();
|
Map<Long, TbField> allFieldMap = fieldList.stream()
|
.collect(Collectors.toMap(TbField::getId, e -> e));
|
List<TbBasicDataField> originFields = tbBasicDataFieldService.lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, basicData.getId()).list();
|
Set<Long> fieldIdList = originFields.stream().map(TbBasicDataField::getFieldId)
|
.collect(Collectors.toSet());
|
Map<Long, TbField> fieldMap = tbFieldService.lambdaQuery().in(TbField::getId, fieldIdList)
|
.list().stream().collect(Collectors.toMap(TbField::getId, e -> e));
|
CompletableFuture.runAsync(
|
() -> saveExchangeLog(loginUser, basicData, originFields,
|
BeanUtils.copyBean(dto, BasicDataDTO.class),
|
fieldMap));
|
TbBasicData tbBasicData = BeanUtils.copyBean(dto, TbBasicData.class);
|
tbBasicData.setCurrentGdp(tbBasicData.getCurrentGdp().replace(",", ""));
|
tbBasicData.setTransferPaymentScale(tbBasicData.getTransferPaymentScale().replace(",", ""));
|
tbBasicData.setDeptAreaCode(basicData.getDeptAreaCode());
|
tbBasicData.setQuarter(basicData.getQuarter());
|
// 保存基础数据动态字段数据
|
List<TbBasicDataField> tbBasicDataFields =
|
BeanUtils.copyList(dto.getFields(), TbBasicDataField.class);
|
tbBasicDataFields = tbBasicDataFields.stream().filter(f -> Objects.nonNull(f.getFieldId()))
|
.peek(item -> {
|
TbField tbField = fieldMap.get(item.getFieldId());
|
if (Objects.nonNull(tbField)) {
|
Integer numMax = tbField.getNumMax();
|
Integer numMin = tbField.getNumMin();
|
Integer textMaxNum = tbField.getTextMaxNum();
|
Integer textMinNum = tbField.getTextMinNum();
|
if (FieldTypeEnum.NUMBER.equals(tbField.getFieldType()) && Objects.nonNull(
|
numMax) && Objects.nonNull(numMin)) {
|
double fieldValue = Double.parseDouble(item.getFieldValue());
|
if (fieldValue < numMin || fieldValue > numMax) {
|
throw new ServiceException(
|
String.format("字段%s的值不在范围%d-%d内",
|
tbField.getFieldName(),
|
numMin, numMax));
|
}
|
}
|
if (FieldTypeEnum.TEXT.equals(tbField.getFieldType())
|
&& FieldInputTypeEnum.MANUAL_INPUT.equals(
|
tbField.getTextInputType())
|
&& Objects.nonNull(
|
textMaxNum) && Objects.nonNull(textMinNum)) {
|
String fieldValue = item.getFieldValue();
|
if (fieldValue.length() < numMin || fieldValue.length() > numMax) {
|
throw new ServiceException(
|
String.format("字段%s的值的长度不在范围%d-%d内",
|
tbField.getFieldName(),
|
textMinNum, textMaxNum));
|
}
|
}
|
item.setBasicDataId(tbBasicData.getId());
|
item.setFieldName(tbField.getFieldName());
|
if (StringUtils.isNotBlank(item.getFieldValue())) {
|
item.setFieldValue(item.getFieldValue().replace(",", ""));
|
}
|
} else {
|
TbField field = allFieldMap.get(item.getFieldId());
|
item.setFieldName(field.getFieldName());
|
item.setBasicDataId(basicData.getId());
|
}
|
|
}).collect(Collectors.toList());
|
// 添加固定字段 转移支付规模、当期GDP
|
TbBasicDataField transferPaymentScale = new TbBasicDataField();
|
transferPaymentScale.setBasicDataId(tbBasicData.getId());
|
transferPaymentScale.setFieldId(-1L);
|
transferPaymentScale.setFieldValue(tbBasicData.getTransferPaymentScale());
|
tbBasicDataFields.add(transferPaymentScale);
|
TbBasicDataField currentGdp = new TbBasicDataField();
|
currentGdp.setBasicDataId(tbBasicData.getId());
|
currentGdp.setFieldId(-2L);
|
currentGdp.setFieldValue(tbBasicData.getCurrentGdp());
|
tbBasicDataFields.add(currentGdp);
|
TbBasicDataField remark = new TbBasicDataField();
|
remark.setBasicDataId(tbBasicData.getId());
|
remark.setFieldId(-3L);
|
remark.setFieldValue(tbBasicData.getRemark());
|
tbBasicDataFields.add(remark);
|
// 将该基础数据的动态字段数据全部删除
|
tbBasicDataFieldService.remove(
|
Wrappers.<TbBasicDataField>lambdaQuery()
|
.eq(TbBasicDataField::getBasicDataId, tbBasicData.getId()));
|
Optional<TbBasicDataField> any = tbBasicDataFields.stream()
|
.filter(t -> StringUtils.isBlank(t.getFieldValue())).findAny();
|
if (!any.isPresent()) {
|
tbBasicData.setStatus(ReportingStatusEnum.FILLED);
|
this.updateById(tbBasicData);
|
}
|
tbBasicDataFieldService.saveBatch(tbBasicDataFields);
|
/*if (ReportingStatusEnum.FILLED.equals(tbBasicData.getStatus())) {
|
CompletableFuture.runAsync(() -> {
|
calculateScore(tbBasicData, tbBasicDataFields);
|
calculateScreenScore(tbBasicData, tbBasicDataFields);
|
});
|
}*/
|
asyncService.calculateScoreWithFixedRules(tbBasicData, tbBasicDataFields, fieldList);
|
}
|
|
@Override
|
public void exportDataV2(List<String> quarterList) throws IOException {
|
{
|
response.setContentType("application/vnd.ms-excel");
|
response.setCharacterEncoding("utf-8");
|
String fileName = "财政运行分析指标评价表";
|
response.setHeader(
|
"Content-disposition",
|
"attachment;filename=" + URLEncoder.encode(fileName, "UTF-8") + ".xlsx");
|
List<TbBasicData> tbBasicDataList = this.lambdaQuery()
|
.in(TbBasicData::getQuarter, quarterList)
|
.groupBy(TbBasicData::getQuarter).list();
|
// 符合导出条件的基础数据
|
List<TbBasicData> tbBasicDataListAll = this.lambdaQuery()
|
.in(TbBasicData::getQuarter, quarterList)
|
.list();
|
Set<Long> basicDataSet = tbBasicDataListAll.stream().map(TbBasicData::getId)
|
.collect(Collectors.toSet());
|
List<TbScore> scoreList = null;
|
if (CollUtils.isNotEmpty(basicDataSet)) {
|
// 符合导出条件的得分
|
scoreList = tbScoreService.lambdaQuery()
|
.in(TbScore::getBasicDataId, basicDataSet)
|
.list();
|
}
|
List<BasicDataConfigVO> configVOList = tbBasicDataConfigService.getFixedRulesConfigList();
|
// 基础数据id列表
|
Set<Long> basicDataIdList = tbBasicDataList.stream().map(TbBasicData::getId)
|
.collect(Collectors.toSet());
|
// 涉及到的部门编码
|
Set<String> userAreaCodeList = tbBasicDataList.stream()
|
.map(TbBasicData::getDeptAreaCode)
|
.collect(Collectors.toSet());
|
// 用户信息map
|
Map<String, SysUser> userMap = sysUserService.lambdaQuery()
|
.in(SysUser::getAreaCode, userAreaCodeList).list().stream()
|
.collect(Collectors.toMap(SysUser::getAreaCode, e -> e));
|
// 构建Excel写对象
|
try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
|
.registerWriteHandler(new CustomCellWriteHandler())
|
.registerWriteHandler(EasyExcelUtil.getStyleStrategy()).build()) {
|
WriteSheet writeSheet;
|
// 遍历季度基础数据
|
for (String quarter : quarterList) {
|
List<TbBasicData> currentBasicData = tbBasicDataListAll.stream()
|
.filter(d -> d.getQuarter().equals(quarter)).collect(
|
Collectors.toList());
|
Set<Long> cbdIdSet = currentBasicData.stream().map(TbBasicData::getId)
|
.collect(Collectors.toSet());
|
|
// 表头
|
List<List<String>> head = headV2(configVOList);
|
if (CollUtils.isNotEmpty(scoreList)) {
|
List<List<Object>> dataList = dataListV2(scoreList, currentBasicData,
|
userMap, head);
|
// 构建sheet对象
|
writeSheet = EasyExcel.writerSheet(quarter).head(head).build();
|
// 写出sheet数据
|
excelWriter.write(dataList, writeSheet);
|
}
|
}
|
}
|
}
|
}
|
|
private List<List<String>> headV2(List<BasicDataConfigVO> configVOList) {
|
List<List<String>> headTitles = Lists.newArrayList();
|
// 固定字段
|
headTitles.add(Lists.newArrayList("财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表", "财政运行分析指标评价表",
|
"财政运行分析指标评价表", "财政运行分析指标评价表"));
|
headTitles.add(Lists.newArrayList("地区"));
|
headTitles.add(Lists.newArrayList("级次"));
|
headTitles.add(Lists.newArrayList("得分合计"));
|
headTitles.add(Lists.newArrayList("一级指标", "财政经济形式",
|
"预算管理方面", "预算执行方面", "风险防控方面"));
|
headTitles.add(
|
Lists.newArrayList("分值", "27", "重大财税政策落实情况",
|
"26", "20", "27"));
|
headTitles.add(Lists.newArrayList("二级指标", "收入占GDP比重",
|
"收入执行率", "收入质量", "重大财税落实情况", "重大财税政策落实情况", "转移支付",
|
"\"三保\"保障情况", "强化预算约束", "库款管理", "预算执行情况", "中央直达资金",
|
"暂付款管理", "债务管理", "日常监督发现问题"));
|
headTitles.add(Lists.newArrayList("分值", "8", "11", "8", "--", "重大财税政策落实情况", "9",
|
"17", "--", "6", "8", "6", "9", "18", "日常监督发现问题"));
|
headTitles.add(
|
Lists.newArrayList("三级指标", "地方一般公共预算收入占GDP的比重",
|
"地方一般公共预算收入执行进度（地方一般公共预算收入/年初预算或调整预算）",
|
"政府性基金预算收入执行进度（政府性基金预算收入/年初预算或调整预算）",
|
"税收收入占地方一般公共预算收入比重", "减税降费落实情况",
|
"其他重大政策落实情况", "中央转移支付占地方可用财力比重",
|
"“三保”年初预算保障情况", "“三保”需求占可用财力的比重",
|
"“三保”支出保障情况", "存量资金盘活", "不得无预算、超预算拨款",
|
"库款保障水平", "一般公共预算支出执行率", "政府性基金预算支出执行率",
|
"中央直达资金支付进度", "直达资金规范使用", "违规新增暂付款",
|
"暂付款累计余额", "暂付款消化", "法定债务率", "隐性债务率", "隐性债务化解",
|
"日常监督发现问题", "日常监督发现问题"));
|
headTitles.add(
|
Lists.newArrayList("分值", "8", "7", "4", "8", "--", "--", "9", "6", "8", "3", "——",
|
"--", "6", "5", "3", "3", "3", "3", "3", "3", "9", "9", "--", "--", "--"));
|
|
return headTitles;
|
}
|
|
private List<List<Object>> dataListV2(List<TbScore> scoreList,
|
List<TbBasicData> list,
|
Map<String, SysUser> userMap,
|
List<List<String>> head) {
|
// 所有数据集合
|
List<List<Object>> excellist = new ArrayList<>();
|
// 构建栏号行
|
List<Object> columnNo = Lists.newArrayList("栏号");
|
for (int i = 1; i < head.size(); i++) {
|
columnNo.add(String.valueOf(i));
|
}
|
excellist.add(columnNo);
|
// 动态字段数据行
|
for (TbBasicData tbBasicData : list) {
|
// 转换为map，方便遍历的时候取
|
/* Map<Long, TbBasicDataField> basicDataFieldMap = tbBasicDataFieldList.stream()
|
.filter(item -> tbBasicData.getId().equals(item.getBasicDataId()))
|
.collect(Collectors.toMap(TbBasicDataField::getFieldId, e -> e));
|
SysUser sysUser = userMap.get(tbBasicData.getDeptAreaCode());
|
if (CollUtils.isEmpty(basicDataFieldMap) || Objects.isNull(sysUser)) {
|
continue;
|
}*/
|
/* List<Object> valueList = Lists.newArrayList(sysUser.getAreaName(),
|
tbBasicData.getQuarter());
|
TbBasicDataField transferPaymentScale = basicDataFieldMap.get(-1L);
|
valueList.add(
|
Objects.nonNull(transferPaymentScale)
|
? transferPaymentScale.getFieldValue()
|
: "");
|
TbBasicDataField currentGdp = basicDataFieldMap.get(-2L);
|
valueList.add(
|
Objects.nonNull(currentGdp)
|
? currentGdp.getFieldValue()
|
: "");
|
for (TbField tbField : fieldList) {
|
TbBasicDataField tbBasicDataField = basicDataFieldMap.get(tbField.getId());
|
valueList.add(
|
Objects.nonNull(tbBasicDataField)
|
? tbBasicDataField.getFieldValue()
|
: "");
|
}
|
excellist.add(valueList);
|
valueList.add(tbBasicData.getRemark());*/
|
}
|
return excellist;
|
}
|
|
@Override
|
public List<FieldAndScoreDataVO> getFieldAndScoreData(String areaCode, String nowQuarter,
|
Integer yearType, Integer isAll) {
|
return baseMapper.getFieldAndScoreData(areaCode, nowQuarter, yearType, isAll);
|
}
|
}
|
