package cn.iocoder.yudao.module.crm.service.finance;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
|
import cn.iocoder.yudao.module.crm.controller.admin.finance.vo.CrmCustomerStatementRespVO;
|
import cn.iocoder.yudao.module.crm.controller.admin.finance.vo.CrmFinanceTrendRespVO;
|
import cn.iocoder.yudao.module.crm.controller.admin.finance.vo.CrmShippedNotInvoicedRespVO;
|
import cn.iocoder.yudao.module.crm.controller.admin.finance.vo.CrmUnwrittenOffRespVO;
|
import cn.iocoder.yudao.module.crm.dal.dataobject.customer.CrmCustomerDO;
|
import cn.iocoder.yudao.module.crm.dal.dataobject.invoice.CrmInvoiceDO;
|
import cn.iocoder.yudao.module.crm.dal.dataobject.receivable.CrmReceivableDO;
|
import cn.iocoder.yudao.module.crm.dal.dataobject.receivable.CrmReceivableItemDO;
|
import cn.iocoder.yudao.module.crm.dal.dataobject.receivable.CrmReceivablePlanDO;
|
import cn.iocoder.yudao.module.crm.dal.mysql.invoice.CrmInvoiceMapper;
|
import cn.iocoder.yudao.module.crm.dal.mysql.receivable.CrmReceivableItemMapper;
|
import cn.iocoder.yudao.module.crm.dal.mysql.receivable.CrmReceivableMapper;
|
import cn.iocoder.yudao.module.crm.dal.mysql.receivable.CrmReceivablePlanMapper;
|
import cn.iocoder.yudao.module.crm.enums.common.CrmAuditStatusEnum;
|
import cn.iocoder.yudao.module.crm.enums.receivable.CrmReceivableBizTypeEnum;
|
import cn.iocoder.yudao.module.crm.service.customer.CrmCustomerService;
|
import cn.iocoder.yudao.module.erp.api.sale.ErpSaleOrderApi;
|
import cn.iocoder.yudao.module.erp.api.sale.dto.ErpSaleOrderRespDTO;
|
import cn.iocoder.yudao.module.mes.api.productsales.MesWmProductSalesApi;
|
import cn.iocoder.yudao.module.mes.api.productsales.dto.MesWmProductSalesRespDTO;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.YearMonth;
|
import java.time.format.DateTimeFormatter;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
|
/**
|
* CRM 财务对账与报表 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
@Slf4j
|
public class CrmFinanceReportServiceImpl implements CrmFinanceReportService {
|
|
private static final Integer ERP_STATUS_APPROVE = 20;
|
private static final Integer MES_STATUS_FINISHED = 4;
|
private static final Integer AUDIT_APPROVE = CrmAuditStatusEnum.APPROVE.getStatus();
|
private static final Integer PLAN_STATUS_RECEIPTED = 20;
|
|
@Resource
|
private ErpSaleOrderApi saleOrderApi;
|
@Resource
|
private MesWmProductSalesApi productSalesApi;
|
|
@Resource
|
private CrmInvoiceMapper invoiceMapper;
|
@Resource
|
private CrmReceivableMapper receivableMapper;
|
@Resource
|
private CrmReceivableItemMapper receivableItemMapper;
|
@Resource
|
private CrmReceivablePlanMapper receivablePlanMapper;
|
@Resource
|
private CrmCustomerService customerService;
|
|
@Override
|
public CrmCustomerStatementRespVO getCustomerStatement(Long customerId) {
|
List<ErpSaleOrderRespDTO> orders = getApprovedOrders(customerId);
|
Map<Long, BigDecimal> collectedByOrder = getCollectedAmountByOrder(orders, customerId);
|
|
CrmCustomerStatementRespVO result = new CrmCustomerStatementRespVO();
|
result.setCustomerId(customerId);
|
result.setOrderCount(orders.size());
|
result.setOrderTotalAmount(BigDecimal.ZERO);
|
result.setShippedAmount(BigDecimal.ZERO);
|
result.setInvoicedAmount(BigDecimal.ZERO);
|
result.setCollectedAmount(BigDecimal.ZERO);
|
result.setShippedNotInvoicedAmount(BigDecimal.ZERO);
|
result.setOutstandingAmount(BigDecimal.ZERO);
|
result.setNextMonthPlanAmount(getNextMonthPlanAmount(customerId));
|
List<CrmCustomerStatementRespVO.OrderRow> rows = new ArrayList<>(orders.size());
|
for (ErpSaleOrderRespDTO order : orders) {
|
CrmCustomerStatementRespVO.OrderRow row = new CrmCustomerStatementRespVO.OrderRow();
|
row.setSaleOrderId(order.getId());
|
row.setSaleOrderNo(order.getNo());
|
row.setContractId(order.getContractId());
|
row.setOrderAmount(zeroIfNull(order.getTotalPrice()));
|
row.setShippedAmount(getShippedAmount(order.getId()));
|
row.setInvoicedAmount(getInvoicedAmount(order.getId()));
|
row.setCollectedAmount(collectedByOrder.getOrDefault(order.getId(), BigDecimal.ZERO));
|
row.setShippedNotInvoicedAmount(maxZero(row.getShippedAmount().subtract(row.getInvoicedAmount())));
|
row.setOutstandingAmount(maxZero(row.getOrderAmount().subtract(row.getCollectedAmount())));
|
rows.add(row);
|
|
result.setOrderTotalAmount(result.getOrderTotalAmount().add(row.getOrderAmount()));
|
result.setShippedAmount(result.getShippedAmount().add(row.getShippedAmount()));
|
result.setInvoicedAmount(result.getInvoicedAmount().add(row.getInvoicedAmount()));
|
result.setCollectedAmount(result.getCollectedAmount().add(row.getCollectedAmount()));
|
result.setShippedNotInvoicedAmount(result.getShippedNotInvoicedAmount().add(row.getShippedNotInvoicedAmount()));
|
result.setOutstandingAmount(result.getOutstandingAmount().add(row.getOutstandingAmount()));
|
}
|
result.setOrders(rows);
|
if (customerId != null) {
|
CrmCustomerDO customer = customerService.getCustomer(customerId);
|
result.setCustomerName(customer == null ? null : customer.getName());
|
}
|
return result;
|
}
|
|
@Override
|
public List<CrmShippedNotInvoicedRespVO> getShippedNotInvoicedList(Long customerId) {
|
List<ErpSaleOrderRespDTO> orders = getApprovedOrders(customerId);
|
if (CollUtil.isEmpty(orders)) {
|
return Collections.emptyList();
|
}
|
Map<Long, ErpSaleOrderRespDTO> orderMap = new HashMap<>();
|
orders.forEach(order -> orderMap.put(order.getId(), order));
|
Map<Long, String> customerNameMap = getCustomerNameMap(orders.stream()
|
.map(ErpSaleOrderRespDTO::getCustomerId).filter(Objects::nonNull).toList());
|
|
List<CrmShippedNotInvoicedRespVO> result = new ArrayList<>();
|
for (ErpSaleOrderRespDTO order : orders) {
|
for (MesWmProductSalesRespDTO saleOut : getFinishedSaleOuts(order.getId())) {
|
BigDecimal outAmount = zeroIfNull(saleOut.getTotalPrice());
|
BigDecimal invoicedAmount = sumInvoicePrice(invoiceMapper.selectListBySaleOutIdAndStatus(
|
saleOut.getId(), List.of(AUDIT_APPROVE)));
|
BigDecimal remainAmount = outAmount.subtract(invoicedAmount);
|
if (remainAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
continue;
|
}
|
CrmShippedNotInvoicedRespVO vo = new CrmShippedNotInvoicedRespVO();
|
vo.setSaleOutId(saleOut.getId());
|
vo.setSaleOutCode(saleOut.getCode());
|
vo.setSalesDate(saleOut.getSalesDate());
|
vo.setSaleOrderId(order.getId());
|
vo.setSaleOrderNo(order.getNo());
|
vo.setCustomerId(order.getCustomerId());
|
vo.setCustomerName(customerNameMap.get(order.getCustomerId()));
|
vo.setOutAmount(outAmount);
|
vo.setInvoicedAmount(invoicedAmount);
|
vo.setRemainInvoiceAmount(remainAmount);
|
result.add(vo);
|
}
|
}
|
return result;
|
}
|
|
@Override
|
public List<CrmUnwrittenOffRespVO> getUnwrittenOffList(Long customerId) {
|
List<CrmInvoiceDO> invoices = invoiceMapper.selectList(new LambdaQueryWrapperX<CrmInvoiceDO>()
|
.eq(CrmInvoiceDO::getAuditStatus, AUDIT_APPROVE)
|
.eqIfPresent(CrmInvoiceDO::getCustomerId, customerId)
|
.orderByAsc(CrmInvoiceDO::getInvoiceTime));
|
if (CollUtil.isEmpty(invoices)) {
|
return Collections.emptyList();
|
}
|
Map<Long, BigDecimal> collectedMap = getCollectedAmountByInvoice(customerId);
|
Map<Long, String> customerNameMap = getCustomerNameMap(invoices.stream()
|
.map(CrmInvoiceDO::getCustomerId).filter(Objects::nonNull).toList());
|
|
List<CrmUnwrittenOffRespVO> result = new ArrayList<>();
|
LocalDate today = LocalDate.now();
|
for (CrmInvoiceDO invoice : invoices) {
|
BigDecimal invoiceAmount = zeroIfNull(invoice.getPrice());
|
BigDecimal collectedAmount = collectedMap.getOrDefault(invoice.getId(), BigDecimal.ZERO);
|
BigDecimal remainAmount = invoiceAmount.subtract(collectedAmount);
|
if (remainAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
continue;
|
}
|
CrmUnwrittenOffRespVO vo = new CrmUnwrittenOffRespVO();
|
vo.setInvoiceId(invoice.getId());
|
vo.setInvoiceNo(invoice.getNo());
|
vo.setTaxInvoiceNo(invoice.getInvoiceNo());
|
vo.setCustomerId(invoice.getCustomerId());
|
vo.setCustomerName(customerNameMap.get(invoice.getCustomerId()));
|
vo.setContractId(invoice.getContractId());
|
vo.setSaleOrderId(invoice.getSaleOrderId());
|
vo.setInvoiceTime(invoice.getInvoiceTime());
|
vo.setInvoiceAmount(invoiceAmount);
|
vo.setCollectedAmount(collectedAmount);
|
vo.setRemainAmount(remainAmount);
|
long agingDays = invoice.getInvoiceTime() == null ? 0
|
: Math.max(0, ChronoUnit.DAYS.between(invoice.getInvoiceTime().toLocalDate(), today));
|
vo.setAgingDays(agingDays);
|
vo.setAgingBucket(agingBucket(agingDays));
|
result.add(vo);
|
}
|
return result;
|
}
|
|
@Override
|
public List<CrmFinanceTrendRespVO> getMonthlyTrend(Integer months) {
|
int monthCount = months == null ? 6 : Math.min(Math.max(months, 1), 36);
|
YearMonth startMonth = YearMonth.now().minusMonths(monthCount - 1L);
|
LocalDateTime beginTime = startMonth.atDay(1).atStartOfDay();
|
LocalDateTime endTime = YearMonth.now().plusMonths(1).atDay(1).atStartOfDay();
|
|
List<CrmInvoiceDO> invoices = invoiceMapper.selectList(new LambdaQueryWrapperX<CrmInvoiceDO>()
|
.eq(CrmInvoiceDO::getAuditStatus, AUDIT_APPROVE)
|
.between(CrmInvoiceDO::getInvoiceTime, beginTime, endTime));
|
List<CrmReceivableDO> receivables = receivableMapper.selectList(new LambdaQueryWrapperX<CrmReceivableDO>()
|
.eq(CrmReceivableDO::getAuditStatus, AUDIT_APPROVE)
|
.between(CrmReceivableDO::getReturnTime, beginTime, endTime));
|
|
Map<String, BigDecimal> invoicedMap = new HashMap<>();
|
Map<String, BigDecimal> collectedMap = new HashMap<>();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
|
invoices.forEach(invoice -> {
|
if (invoice.getInvoiceTime() != null) {
|
mergeAmount(invoicedMap, invoice.getInvoiceTime().format(formatter), zeroIfNull(invoice.getPrice()));
|
}
|
});
|
receivables.forEach(receivable -> {
|
if (receivable.getReturnTime() != null) {
|
mergeAmount(collectedMap, receivable.getReturnTime().format(formatter), zeroIfNull(receivable.getPrice()));
|
}
|
});
|
|
List<CrmFinanceTrendRespVO> result = new ArrayList<>(monthCount);
|
for (int i = 0; i < monthCount; i++) {
|
String month = startMonth.plusMonths(i).format(formatter);
|
CrmFinanceTrendRespVO vo = new CrmFinanceTrendRespVO();
|
vo.setMonth(month);
|
vo.setInvoicedAmount(invoicedMap.getOrDefault(month, BigDecimal.ZERO));
|
vo.setCollectedAmount(collectedMap.getOrDefault(month, BigDecimal.ZERO));
|
result.add(vo);
|
}
|
return result;
|
}
|
|
// ==================== 数据查询与计算 ====================
|
|
private List<ErpSaleOrderRespDTO> getApprovedOrders(Long customerId) {
|
List<ErpSaleOrderRespDTO> orders = customerId == null
|
? saleOrderApi.getSaleOrderList().getCheckedData()
|
: saleOrderApi.getSaleOrderListByCustomerId(customerId).getCheckedData();
|
if (CollUtil.isEmpty(orders)) {
|
return Collections.emptyList();
|
}
|
return orders.stream()
|
.filter(order -> ObjectUtilEqual(order.getStatus(), ERP_STATUS_APPROVE))
|
.toList();
|
}
|
|
private List<MesWmProductSalesRespDTO> getFinishedSaleOuts(Long saleOrderId) {
|
List<MesWmProductSalesRespDTO> saleOuts = productSalesApi.getProductSalesListBySaleOrderId(saleOrderId);
|
if (CollUtil.isEmpty(saleOuts)) {
|
return Collections.emptyList();
|
}
|
return saleOuts.stream().filter(saleOut -> ObjectUtilEqual(saleOut.getStatus(), MES_STATUS_FINISHED)).toList();
|
}
|
|
private BigDecimal getShippedAmount(Long saleOrderId) {
|
return getFinishedSaleOuts(saleOrderId).stream()
|
.map(saleOut -> zeroIfNull(saleOut.getTotalPrice()))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
private BigDecimal getInvoicedAmount(Long saleOrderId) {
|
return sumInvoicePrice(invoiceMapper.selectListBySaleOrderIdAndStatus(saleOrderId, List.of(AUDIT_APPROVE)));
|
}
|
|
/**
|
* 计算每张销售订单已回款金额
|
*
|
* 优先取核销明细（销售订单 / 开票），历史回款没有核销明细时按回款关联的开票折算到订单。
|
*/
|
private Map<Long, BigDecimal> getCollectedAmountByOrder(List<ErpSaleOrderRespDTO> orders, Long customerId) {
|
Map<Long, BigDecimal> result = new HashMap<>();
|
Map<Long, ErpSaleOrderRespDTO> orderMap = new HashMap<>();
|
orders.forEach(order -> orderMap.put(order.getId(), order));
|
if (orderMap.isEmpty()) {
|
return result;
|
}
|
// 1. 已审核回款
|
List<CrmReceivableDO> receivables = customerId == null
|
? receivableMapper.selectList(new LambdaQueryWrapperX<CrmReceivableDO>()
|
.eq(CrmReceivableDO::getAuditStatus, AUDIT_APPROVE))
|
: receivableMapper.selectListByCustomerId(customerId).stream()
|
.filter(receivable -> ObjectUtilEqual(receivable.getAuditStatus(), AUDIT_APPROVE)).toList();
|
if (CollUtil.isEmpty(receivables)) {
|
return result;
|
}
|
Map<Long, CrmReceivableDO> receivableMap = new HashMap<>();
|
receivables.forEach(receivable -> receivableMap.put(receivable.getId(), receivable));
|
// 2. 核销明细
|
List<CrmReceivableItemDO> items = receivableItemMapper.selectListByReceivableIds(receivableMap.keySet());
|
Set<Long> receivablesWithItems = new HashSet<>();
|
Set<Long> invoiceIds = new HashSet<>();
|
items.forEach(item -> {
|
receivablesWithItems.add(item.getReceivableId());
|
if (CrmReceivableBizTypeEnum.SALE_INVOICE.getType().equals(item.getBizType()) && item.getBizId() != null) {
|
invoiceIds.add(item.getBizId());
|
}
|
});
|
receivables.forEach(receivable -> {
|
if (receivable.getInvoiceId() != null) {
|
invoiceIds.add(receivable.getInvoiceId());
|
}
|
});
|
Map<Long, Long> invoiceOrderMap = new HashMap<>();
|
if (CollUtil.isNotEmpty(invoiceIds)) {
|
invoiceMapper.selectByIds(invoiceIds).forEach(invoice -> {
|
if (invoice.getSaleOrderId() != null) {
|
invoiceOrderMap.put(invoice.getId(), invoice.getSaleOrderId());
|
}
|
});
|
}
|
for (CrmReceivableItemDO item : items) {
|
if (!receivableMap.containsKey(item.getReceivableId())) {
|
continue;
|
}
|
Long orderId = null;
|
if (CrmReceivableBizTypeEnum.SALE_ORDER.getType().equals(item.getBizType())) {
|
orderId = item.getBizId();
|
} else if (CrmReceivableBizTypeEnum.SALE_INVOICE.getType().equals(item.getBizType())) {
|
orderId = invoiceOrderMap.get(item.getBizId());
|
}
|
if (orderId != null && orderMap.containsKey(orderId)) {
|
result.merge(orderId, zeroIfNull(item.getReceiptPrice()), BigDecimal::add);
|
}
|
}
|
// 3. 历史回款：没有核销明细时，按回款关联开票折算到订单（只处理订单范围内的开票）
|
for (CrmReceivableDO receivable : receivables) {
|
if (receivablesWithItems.contains(receivable.getId()) || receivable.getInvoiceId() == null) {
|
continue;
|
}
|
Long orderId = invoiceOrderMap.get(receivable.getInvoiceId());
|
if (orderId != null && orderMap.containsKey(orderId)) {
|
result.merge(orderId, zeroIfNull(receivable.getPrice()), BigDecimal::add);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 计算每张开票已回款金额（仅已审核回款）
|
*
|
* 有核销明细时按明细归集到开票；历史回款按 invoiceId 直接归集。
|
*/
|
private Map<Long, BigDecimal> getCollectedAmountByInvoice(Long customerId) {
|
Map<Long, BigDecimal> result = new HashMap<>();
|
List<CrmReceivableDO> receivables = customerId == null
|
? receivableMapper.selectList(new LambdaQueryWrapperX<CrmReceivableDO>()
|
.eq(CrmReceivableDO::getAuditStatus, AUDIT_APPROVE))
|
: receivableMapper.selectListByCustomerId(customerId).stream()
|
.filter(receivable -> ObjectUtilEqual(receivable.getAuditStatus(), AUDIT_APPROVE)).toList();
|
if (CollUtil.isEmpty(receivables)) {
|
return result;
|
}
|
Map<Long, CrmReceivableDO> receivableMap = new HashMap<>();
|
receivables.forEach(receivable -> receivableMap.put(receivable.getId(), receivable));
|
List<CrmReceivableItemDO> items = receivableItemMapper.selectListByReceivableIds(receivableMap.keySet());
|
Set<Long> receivablesWithItems = new HashSet<>();
|
for (CrmReceivableItemDO item : items) {
|
receivablesWithItems.add(item.getReceivableId());
|
if (CrmReceivableBizTypeEnum.SALE_INVOICE.getType().equals(item.getBizType()) && item.getBizId() != null) {
|
result.merge(item.getBizId(), zeroIfNull(item.getReceiptPrice()), BigDecimal::add);
|
}
|
}
|
for (CrmReceivableDO receivable : receivables) {
|
if (receivablesWithItems.contains(receivable.getId()) || receivable.getInvoiceId() == null) {
|
continue;
|
}
|
result.merge(receivable.getInvoiceId(), zeroIfNull(receivable.getPrice()), BigDecimal::add);
|
}
|
return result;
|
}
|
|
private BigDecimal getNextMonthPlanAmount(Long customerId) {
|
YearMonth nextMonth = YearMonth.now().plusMonths(1);
|
LocalDateTime beginTime = nextMonth.atDay(1).atStartOfDay();
|
LocalDateTime endTime = nextMonth.plusMonths(1).atDay(1).atStartOfDay();
|
List<CrmReceivablePlanDO> plans = receivablePlanMapper.selectList(
|
new LambdaQueryWrapperX<CrmReceivablePlanDO>()
|
.eqIfPresent(CrmReceivablePlanDO::getCustomerId, customerId)
|
.ge(CrmReceivablePlanDO::getReturnTime, beginTime)
|
.lt(CrmReceivablePlanDO::getReturnTime, endTime));
|
return plans.stream()
|
.filter(plan -> !PLAN_STATUS_RECEIPTED.equals(plan.getStatus()))
|
.map(plan -> zeroIfNull(plan.getPrice()))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
private Map<Long, String> getCustomerNameMap(Collection<Long> customerIds) {
|
if (CollUtil.isEmpty(customerIds)) {
|
return Collections.emptyMap();
|
}
|
Map<Long, CrmCustomerDO> customerMap = customerService.getCustomerMap(customerIds);
|
Map<Long, String> result = new HashMap<>();
|
customerMap.forEach((id, customer) -> result.put(id, customer.getName()));
|
return result;
|
}
|
|
private static BigDecimal sumInvoicePrice(List<CrmInvoiceDO> invoices) {
|
if (CollUtil.isEmpty(invoices)) {
|
return BigDecimal.ZERO;
|
}
|
return invoices.stream().map(invoice -> zeroIfNull(invoice.getPrice())).reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
private static void mergeAmount(Map<String, BigDecimal> map, String key, BigDecimal amount) {
|
map.merge(key, amount, BigDecimal::add);
|
}
|
|
private static String agingBucket(long days) {
|
if (days <= 30) {
|
return "0-30天";
|
}
|
if (days <= 60) {
|
return "31-60天";
|
}
|
if (days <= 90) {
|
return "61-90天";
|
}
|
return "90天以上";
|
}
|
|
private static boolean ObjectUtilEqual(Object left, Object right) {
|
return Objects.equals(left, right);
|
}
|
|
private static BigDecimal zeroIfNull(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
|
private static BigDecimal maxZero(BigDecimal value) {
|
return value.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : value;
|
}
|
|
}
|
