package com.ruoyi.basic.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.node.ObjectNode;
|
import com.ruoyi.basic.dto.StorageBlobVO;
|
import com.ruoyi.basic.mapper.CustomerFinancialReportMapper;
|
import com.ruoyi.basic.mapper.CustomerMapper;
|
import com.ruoyi.basic.mapper.CustomerUserMapper;
|
import com.ruoyi.basic.mapper.StorageBlobMapper;
|
import com.ruoyi.basic.pojo.Customer;
|
import com.ruoyi.basic.pojo.CustomerFinancialReport;
|
import com.ruoyi.basic.pojo.CustomerUser;
|
import com.ruoyi.basic.pojo.StorageBlob;
|
import com.ruoyi.basic.utils.FileUtil;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.framework.security.LoginUser;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDateTime;
|
import java.time.Year;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* 客户近3年财务报表Service
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class CustomerFinancialReportService extends ServiceImpl<CustomerFinancialReportMapper, CustomerFinancialReport> {
|
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
|
|
private final CustomerMapper customerMapper;
|
private final CustomerUserMapper customerUserMapper;
|
private final StorageBlobMapper storageBlobMapper;
|
private final FileUtil fileUtil;
|
|
/**
|
* 后台按客户查询近3年财务报表
|
*/
|
public List<CustomerFinancialReport> listByCustomer(Long customerId) {
|
if (customerId == null) {
|
throw new ServiceException("请选择客户");
|
}
|
List<CustomerFinancialReport> reports = list(new LambdaQueryWrapper<CustomerFinancialReport>()
|
.eq(CustomerFinancialReport::getCustomerId, customerId)
|
.orderByDesc(CustomerFinancialReport::getReportYear));
|
refreshFileUrls(reports);
|
fillCustomerName(reports);
|
return reports;
|
}
|
|
/**
|
* 客户账号查询自己的近3年财务报表
|
*/
|
public List<CustomerFinancialReport> listMine() {
|
Long customerId = currentCustomerId();
|
List<CustomerFinancialReport> reports = list(new LambdaQueryWrapper<CustomerFinancialReport>()
|
.eq(CustomerFinancialReport::getCustomerId, customerId)
|
.orderByDesc(CustomerFinancialReport::getReportYear));
|
refreshFileUrls(reports);
|
fillCustomerName(reports);
|
return reports;
|
}
|
|
/**
|
* 保存财务报表：同一客户同一年度仅保留一条，可反复覆盖修改
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public CustomerFinancialReport saveReport(CustomerFinancialReport input) {
|
if (input.getReportYear() == null) {
|
throw new ServiceException("请选择报表年度");
|
}
|
int currentYear = Year.now().getValue();
|
if (input.getReportYear() < currentYear - 2 || input.getReportYear() > currentYear) {
|
throw new ServiceException("只能上传最近三个年度的财务报表");
|
}
|
if (StringUtils.isBlank(input.getReportFiles())) {
|
throw new ServiceException("请上传财务报表附件");
|
}
|
|
Long customerId;
|
if (isCustomerAccount()) {
|
customerId = currentCustomerId();
|
} else {
|
customerId = input.getCustomerId();
|
if (customerId == null || customerMapper.selectById(customerId) == null) {
|
throw new ServiceException("客户不存在");
|
}
|
}
|
|
CustomerFinancialReport entity = getOne(new LambdaQueryWrapper<CustomerFinancialReport>()
|
.eq(CustomerFinancialReport::getCustomerId, customerId)
|
.eq(CustomerFinancialReport::getReportYear, input.getReportYear()), false);
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
if (entity == null) {
|
entity = new CustomerFinancialReport();
|
entity.setCustomerId(customerId);
|
entity.setReportYear(input.getReportYear());
|
}
|
entity.setReportName(input.getReportName());
|
entity.setReportFiles(input.getReportFiles());
|
// 重新提交后回到待审批状态，等待内部人员重新审批
|
entity.setAuditStatus(0);
|
entity.setAuditUserId(null);
|
entity.setAuditUserName(null);
|
entity.setAuditTime(null);
|
entity.setAuditRemark(null);
|
entity.setUploadUserId(loginUser.getUserId());
|
entity.setUploadUserName(loginUser.getNickName());
|
saveOrUpdate(entity);
|
return entity;
|
}
|
|
/**
|
* 申报审批列表：内部人员查看所有客户的提交情况
|
*/
|
public List<CustomerFinancialReport> auditList(String customerName, Integer reportYear, Integer auditStatus) {
|
LambdaQueryWrapper<CustomerFinancialReport> wrapper = new LambdaQueryWrapper<CustomerFinancialReport>()
|
.eq(reportYear != null, CustomerFinancialReport::getReportYear, reportYear)
|
.eq(auditStatus != null, CustomerFinancialReport::getAuditStatus, auditStatus)
|
.orderByDesc(CustomerFinancialReport::getUpdateTime);
|
if (StringUtils.isNotBlank(customerName)) {
|
List<Long> customerIds = customerMapper.selectList(new LambdaQueryWrapper<Customer>()
|
.like(Customer::getCustomerName, customerName))
|
.stream().map(Customer::getId).filter(Objects::nonNull).collect(Collectors.toList());
|
if (customerIds.isEmpty()) {
|
return new java.util.ArrayList<>();
|
}
|
wrapper.in(CustomerFinancialReport::getCustomerId, customerIds);
|
}
|
List<CustomerFinancialReport> reports = list(wrapper);
|
refreshFileUrls(reports);
|
fillCustomerName(reports);
|
return reports;
|
}
|
|
/**
|
* 审批财务报表：1通过 2退回
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public CustomerFinancialReport auditReport(Long id, Integer auditStatus, String auditRemark) {
|
if (isCustomerAccount()) {
|
throw new ServiceException("客户账号无权审批财务报表");
|
}
|
if (id == null) {
|
throw new ServiceException("请选择申报记录");
|
}
|
if (auditStatus == null || auditStatus != 1 && auditStatus != 2) {
|
throw new ServiceException("审批结果不正确");
|
}
|
CustomerFinancialReport entity = getById(id);
|
if (entity == null) {
|
throw new ServiceException("申报记录不存在");
|
}
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
entity.setAuditStatus(auditStatus);
|
entity.setAuditUserId(loginUser.getUserId());
|
entity.setAuditUserName(loginUser.getNickName());
|
entity.setAuditTime(LocalDateTime.now());
|
entity.setAuditRemark(auditRemark);
|
updateById(entity);
|
return entity;
|
}
|
|
/**
|
* 删除财务报表：仅后台人员可删除，客户账号不允许删除
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteReport(Long id) {
|
if (isCustomerAccount()) {
|
throw new ServiceException("客户账号无权删除财务报表");
|
}
|
CustomerFinancialReport entity = getById(id);
|
if (entity == null) {
|
throw new ServiceException("财务报表不存在");
|
}
|
removeById(id);
|
}
|
|
/**
|
* 重新生成附件预览/下载地址：数据库中保存的是上传时的带签名地址，会过期，读取时按文件id刷新
|
*/
|
private void refreshFileUrls(List<CustomerFinancialReport> reports) {
|
if (reports == null || reports.isEmpty()) {
|
return;
|
}
|
for (CustomerFinancialReport report : reports) {
|
String files = report.getReportFiles();
|
if (StringUtils.isBlank(files)) {
|
continue;
|
}
|
try {
|
JsonNode root = OBJECT_MAPPER.readTree(files);
|
if (root == null || !root.isArray()) {
|
continue;
|
}
|
for (JsonNode node : root) {
|
Long blobId = node.hasNonNull("id") ? node.get("id").asLong() : null;
|
if (blobId == null) {
|
continue;
|
}
|
StorageBlob blob = storageBlobMapper.selectById(blobId);
|
if (blob == null) {
|
continue;
|
}
|
StorageBlobVO vo = new StorageBlobVO();
|
vo.setUidFilename(blob.getUidFilename());
|
vo.setPath(blob.getPath());
|
vo.setResourceKey(blob.getResourceKey());
|
ObjectNode objectNode = (ObjectNode) node;
|
objectNode.put("url", fileUtil.buildSignedPreviewUrl(vo));
|
objectNode.put("downloadURL", fileUtil.buildSignedDownloadUrl(vo));
|
if (!node.hasNonNull("name")) {
|
objectNode.put("name", blob.getOriginalFilename());
|
}
|
}
|
report.setReportFiles(OBJECT_MAPPER.writeValueAsString(root));
|
} catch (Exception e) {
|
// 旧数据或非 JSON 格式，保持原值
|
}
|
}
|
}
|
|
private boolean isCustomerAccount() {
|
Long userId = SecurityUtils.getUserId();
|
return !SecurityUtils.isAdmin(userId) && SecurityUtils.hasRole("customer");
|
}
|
|
/**
|
* 获取当前登录账号绑定的客户id
|
*/
|
private Long currentCustomerId() {
|
CustomerUser binding = customerUserMapper.selectOne(new LambdaQueryWrapper<CustomerUser>()
|
.eq(CustomerUser::getUserId, SecurityUtils.getUserId()).last("limit 1"));
|
if (binding == null || binding.getCustomerId() == null) {
|
throw new ServiceException("当前账号尚未绑定客户，请联系管理员");
|
}
|
return binding.getCustomerId();
|
}
|
|
private void fillCustomerName(List<CustomerFinancialReport> reports) {
|
if (reports == null || reports.isEmpty()) {
|
return;
|
}
|
Set<Long> ids = reports.stream().map(CustomerFinancialReport::getCustomerId)
|
.filter(Objects::nonNull).collect(Collectors.toSet());
|
if (ids.isEmpty()) {
|
return;
|
}
|
List<Customer> customers = customerMapper.selectBatchIds(ids);
|
java.util.Map<Long, String> nameMap = customers.stream()
|
.collect(Collectors.toMap(Customer::getId, Customer::getCustomerName, (a, b) -> a));
|
reports.forEach(item -> item.setCustomerName(nameMap.getOrDefault(item.getCustomerId(), "")));
|
}
|
}
|
