feat(account): 更新往来付款回款流水表及接口

云

2 天以前 684e4306a08feeae188070f264148e6765da8dcf

 src/main/java/com/ruoyi/purchase/service/impl/PurchaseLedgerServiceImpl.java

@@ -6,6 +6,7 @@
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.approve.bean.dto.ApprovalInstanceDto;
import com.ruoyi.approve.mapper.ApprovalTemplateMapper;
import com.ruoyi.approve.pojo.ApprovalInstance;
@@ -15,9 +16,11 @@
import com.ruoyi.approve.service.impl.ApproveProcessServiceImpl;
import com.ruoyi.basic.enums.ApplicationTypeEnum;
import com.ruoyi.basic.enums.RecordTypeEnum;
import com.ruoyi.basic.mapper.OilDepotMapper;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.mapper.SupplierManageMapper;
import com.ruoyi.basic.pojo.OilDepot;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.basic.pojo.SupplierManage;
@@ -34,6 +37,10 @@
import com.ruoyi.framework.security.LoginUser;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.measuringinstrumentledger.mapper.SparePartsMapper;
import com.ruoyi.measuringinstrumentledger.pojo.SpareParts;
import com.ruoyi.measuringinstrumentledger.pojo.SparePartsRecord;
import com.ruoyi.measuringinstrumentledger.service.SparePartsRecordService;
import com.ruoyi.other.mapper.TempFileMapper;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;
@@ -93,6 +100,16 @@
@RequiredArgsConstructor
public class PurchaseLedgerServiceImpl extends ServiceImpl<PurchaseLedgerMapper, PurchaseLedger> implements IPurchaseLedgerService {

    /**
     * 明细类型：采购（sales_ledger_product.type）。仅采购明细才回写备件库存
     */
    private static final Integer LEDGER_TYPE_PURCHASE = 2;

    /**
     * 备件流水来源：采购入库。见 spare_parts_record.source_type
     */
    private static final Integer SPARE_PARTS_SOURCE_PURCHASE = 1;

    private final PurchaseLedgerMapper purchaseLedgerMapper;
    private final SalesLedgerMapper salesLedgerMapper;
    private final SalesLedgerProductMapper salesLedgerProductMapper;
@@ -117,6 +134,9 @@
    private final StockInRecordService stockInRecordService;
    private final StockUtils stockUtils;
    private final ApprovalTemplateMapper approvalTemplateMapper;
    private final OilDepotMapper oilDepotMapper;
    private final SparePartsMapper sparePartsMapper;
    private final SparePartsRecordService sparePartsRecordService;

    @Override
    public List<PurchaseLedger> selectPurchaseLedgerList(PurchaseLedger purchaseLedger) {
@@ -170,6 +190,14 @@
        purchaseLedger.setSupplierName(supplierManage.getSupplierName());
        purchaseLedger.setRecorderId(purchaseLedgerDto.getRecorderId());

        // 采购油库：根据油库id回填油库名称
        if (purchaseLedgerDto.getOilDepotId() != null) {
            OilDepot oilDepot = oilDepotMapper.selectById(purchaseLedgerDto.getOilDepotId());
            if (oilDepot != null) {
                purchaseLedger.setOilDepotName(oilDepot.getDepotName());
            }
        }

        purchaseLedger.setApprovalStatus(1);
        // 实际合同金额始终等于合同金额
        purchaseLedger.setNetContractAmount(purchaseLedger.getContractAmount());
@@ -178,6 +206,8 @@
            purchaseLedger.setPurchaseContractNumber(generatePurchaseContractNo(purchaseLedger.getEntryDate()));
        }
        this.saveOrUpdate(purchaseLedger);
        // 回写主键，供调用方（如采购申请转订单）获取新生成的采购台账id
        purchaseLedgerDto.setId(purchaseLedger.getId());

        // 4. 处理子表数据
        List<SalesLedgerProduct> productList = purchaseLedgerDto.getProductData();
@@ -194,7 +224,7 @@
                .last("limit 1")
        );
        if(Objects.isNull(oldApprovalInstance)){
            addApproveByPurchase(loginUser, purchaseLedger);
            addApproveByPurchase(loginUser, purchaseLedger, productList);
        }
        // 5. 迁移临时文件到正式目录
        fileUtil.saveStorageAttachment(ApplicationTypeEnum.FILE, RecordTypeEnum.PURCHASE_LEDGER, purchaseLedger.getId(), purchaseLedgerDto.getStorageBlobDTOS());
@@ -695,6 +725,13 @@
                salesLedgerProductMapper.insert(salesLedgerProduct);
            }
        }
        // 采购明细回写备件：先按台账回滚上一次的流水，再按当前明细整体重建。
        // 编辑时明细行可能被移除，只认新增行会漏掉移除的那些；整体重建天然与当前明细对齐。
        // 注意这段必须在 insertList 之外，否则「只删明细、不新增」的编辑不会触发回滚
        if (LEDGER_TYPE_PURCHASE.equals(ledgerType)) {
            rollbackSparePartsInbound(salesLedgerId);
            recordSparePartsInbound(products, purchaseLedger);
        }

        // 计算总含税金额
        BigDecimal totalTaxInclusiveAmount = products.stream()
@@ -709,6 +746,90 @@
        }
    }

    /**
     * 按采购台账回滚备件：把该台账产生的入库流水逐备件减回库存，然后删除这些流水。
     *
     * <p>备件先由采购入账、后续被维修/保养领用出账，若入账量已经被领用掉，减回会出现负库存，
     * 此时直接拦住不让删，避免把备件账做花。删除台账与编辑重建都走这里，口径统一。</p>
     */
    private void rollbackSparePartsInbound(Long ledgerId) {
        List<SparePartsRecord> records = sparePartsRecordService.list(new LambdaQueryWrapper<SparePartsRecord>()
                .eq(SparePartsRecord::getSourceType, SPARE_PARTS_SOURCE_PURCHASE)
                .eq(SparePartsRecord::getSourceId, ledgerId));
        if (CollectionUtils.isEmpty(records)) {
            return;
        }
        Map<Long, BigDecimal> rollbackBySparePartsId = new HashMap<>();
        for (SparePartsRecord record : records) {
            BigDecimal quantity = record.getQuantity() == null ? BigDecimal.ZERO : record.getQuantity();
            rollbackBySparePartsId.merge(record.getSparePartsId(), quantity, BigDecimal::add);
        }
        for (Map.Entry<Long, BigDecimal> entry : rollbackBySparePartsId.entrySet()) {
            if (entry.getKey() == null) {
                continue;
            }
            SpareParts spareParts = sparePartsMapper.selectById(entry.getKey());
            if (spareParts == null) {
                continue;
            }
            BigDecimal current = spareParts.getQuantity() == null ? BigDecimal.ZERO : spareParts.getQuantity();
            if (current.compareTo(entry.getValue()) < 0) {
                throw new BaseException("备件「" + spareParts.getName() + "」当前库存 " + current
                        + "，不足以回滚本次采购入库的 " + entry.getValue() + "，请先处理领用记录");
            }
            spareParts.setQuantity(current.subtract(entry.getValue()));
            sparePartsMapper.updateById(spareParts);
        }
        sparePartsRecordService.removeByIds(records.stream()
                .map(SparePartsRecord::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList()));
    }

    /**
     * 采购台账明细按规格匹配备件：累加备件库存并记一条入库流水。
     * 未维护规格的备件不参与，静默跳过。
     *
     * <p>调用前必须先 {@link #rollbackSparePartsInbound(Long)}，两者成对出现：
     * 回滚旧流水 + 按当前明细重建，才能保证编辑台账后备件数量与明细一致。</p>
     */
    private void recordSparePartsInbound(List<SalesLedgerProduct> products, PurchaseLedger purchaseLedger) {
        List<Long> modelIds = products.stream()
                .map(SalesLedgerProduct::getProductModelId)
                .filter(Objects::nonNull)
                .distinct()
                .collect(Collectors.toList());
        if (modelIds.isEmpty()) {
            return;
        }
        List<SpareParts> sparePartsList = sparePartsMapper.selectList(new LambdaQueryWrapper<SpareParts>()
                .in(SpareParts::getProductModelId, modelIds));
        if (CollectionUtils.isEmpty(sparePartsList)) {
            return;
        }
        Map<Long, SpareParts> sparePartsByModelId = sparePartsList.stream()
                .collect(Collectors.toMap(SpareParts::getProductModelId, s -> s, (a, b) -> a));
        for (SalesLedgerProduct product : products) {
            SpareParts spareParts = sparePartsByModelId.get(product.getProductModelId());
            if (spareParts == null || product.getQuantity() == null
                    || product.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            BigDecimal quantity = product.getQuantity();
            spareParts.setQuantity((spareParts.getQuantity() == null ? BigDecimal.ZERO : spareParts.getQuantity()).add(quantity));
            sparePartsMapper.updateById(spareParts);

            SparePartsRecord record = new SparePartsRecord();
            record.setSparePartsId(spareParts.getId());
            record.setDirection(1);
            record.setQuantity(quantity);
            record.setSourceType(1);
            record.setSourceId(purchaseLedger.getId());
            record.setSourceNo(purchaseLedger.getPurchaseContractNumber());
            sparePartsRecordService.save(record);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deletePurchaseLedgerByIds(Long[] ids) {
@@ -720,6 +841,9 @@
            if (purchaseLedger.getApprovalStatus().equals(3)) {
                throw new BaseException(purchaseLedger.getPurchaseContractNumber()+"已经审批通过，不允许删除");
            }
            // 台账删除要把该台账采购入库时累加到备件上的数量减回去，并删掉对应流水，
            // 否则备件库存虚高、流水残留。备件已领用导致减回为负时会在这里拦住
            rollbackSparePartsInbound(id);
        }
        // 批量删除关联的采购入库记录
        LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductQueryWrapper = new LambdaQueryWrapper<>();
@@ -1016,7 +1140,12 @@
                    salesLedgerProductMapper.insert(salesLedgerProduct);
                }
                // 采购审核
                addApproveByPurchase(loginUser,salesLedger);
                List<SalesLedgerProduct> snapshotProducts = salesLedgerProductMapper.selectList(
                        new LambdaQueryWrapper<SalesLedgerProduct>()
                                .eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId())
                                .eq(SalesLedgerProduct::getType, 2)
                );
                addApproveByPurchase(loginUser, salesLedger, snapshotProducts);
            }

            return AjaxResult.success("导入成功");
@@ -1028,21 +1157,91 @@

    @Override
    public PurchaseLedgerDto getPurchaseByCode(PurchaseLedgerDto purchaseLedgerDto) {
        // 1. 查询主表
        PurchaseLedger purchaseLedger = purchaseLedgerMapper.selectOne(new LambdaQueryWrapper<PurchaseLedger>()
                .eq(PurchaseLedger::getPurchaseContractNumber, purchaseLedgerDto.getPurchaseContractNumber())
                .last("LIMIT 1"));
        if (purchaseLedger == null) {
            throw new BaseException("采购台账不存在");
        PurchaseLedger purchaseLedger = null;
        ApprovalInstance approvalSnapshotInstance = null;

        // 1. 优先按当前审批实例查询快照
        if (purchaseLedgerDto.getApprovalInstanceId() != null) {
            approvalSnapshotInstance = approvalInstanceService.getById(purchaseLedgerDto.getApprovalInstanceId());
            if (approvalSnapshotInstance != null && approvalSnapshotInstance.getBusinessId() != null) {
                purchaseLedger = purchaseLedgerMapper.selectById(approvalSnapshotInstance.getBusinessId());
            }
        }

        // 2. 查询子表
        // 2. 没传审批实例ID时，退回到按采购合同号查询
        if (purchaseLedger == null) {
            purchaseLedger = purchaseLedgerMapper.selectOne(new LambdaQueryWrapper<PurchaseLedger>()
                    .eq(PurchaseLedger::getPurchaseContractNumber, purchaseLedgerDto.getPurchaseContractNumber())
                    .last("LIMIT 1"));
            if (purchaseLedger == null) {
                throw new BaseException("采购台账不存在");
            }
        }

        // 3. 查询当前采购单对应的审批快照
        if (approvalSnapshotInstance == null) {
            approvalSnapshotInstance = approvalInstanceService.getOne(new LambdaQueryWrapper<ApprovalInstance>()
                    .eq(ApprovalInstance::getBusinessId, purchaseLedger.getId())
                    .eq(ApprovalInstance::getBusinessType, 5L)
                    .eq(ApprovalInstance::getDeleted, 0)
                    .orderByDesc(ApprovalInstance::getId)
                    .last("LIMIT 1"));
        }

        if (approvalSnapshotInstance != null && StringUtils.hasText(approvalSnapshotInstance.getFormConfig())) {
            try {
                PurchaseLedgerDto snapshot = JSON.parseObject(approvalSnapshotInstance.getFormConfig(), PurchaseLedgerDto.class);
                if (snapshot != null) {
                    snapshot.setId(purchaseLedger.getId());
                    if (snapshot.getPurchaseContractNumber() == null) {
                        snapshot.setPurchaseContractNumber(purchaseLedger.getPurchaseContractNumber());
                    }
                    if (snapshot.getSupplierId() == null) {
                        snapshot.setSupplierId(purchaseLedger.getSupplierId());
                    }
                    if (snapshot.getSupplierName() == null) {
                        snapshot.setSupplierName(purchaseLedger.getSupplierName());
                    }
                    if (snapshot.getSalesContractNo() == null) {
                        snapshot.setSalesContractNo(purchaseLedger.getSalesContractNo());
                    }
                    if (snapshot.getSalesContractNoId() == null) {
                        snapshot.setSalesContractNoId(purchaseLedger.getSalesLedgerId());
                    }
                    if (snapshot.getProjectName() == null) {
                        snapshot.setProjectName(purchaseLedger.getProjectName());
                    }
                    if (snapshot.getEntryDate() == null) {
                        snapshot.setEntryDate(purchaseLedger.getEntryDate());
                    }
                    if (snapshot.getExecutionDate() == null) {
                        snapshot.setExecutionDate(purchaseLedger.getExecutionDate());
                    }
                    if (snapshot.getRemarks() == null) {
                        snapshot.setRemarks(purchaseLedger.getRemarks());
                    }
                    if (snapshot.getRecorderId() == null) {
                        snapshot.setRecorderId(purchaseLedger.getRecorderId());
                    }
                    if (snapshot.getRecorderName() == null) {
                        snapshot.setRecorderName(purchaseLedger.getRecorderName());
                    }
                    snapshot.setProductData(snapshot.getProductData() == null ? Collections.emptyList() : snapshot.getProductData());
                    snapshot.setHasChildren(CollectionUtils.isNotEmpty(snapshot.getProductData()));
                    return snapshot;
                }
            } catch (Exception e) {
                log.warn("解析采购审批快照失败: {}", e.getMessage());
            }
        }

        // 4. 查询子表
        LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();
        productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, purchaseLedger.getId())
                .eq(SalesLedgerProduct::getType, 2);
        List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(productWrapper);

        // 4. 转换 DTO
        // 5. 转换 DTO
        PurchaseLedgerDto resultDto = new PurchaseLedgerDto();
        BeanUtils.copyProperties(purchaseLedger, resultDto);
        if (!products.isEmpty()) {
@@ -1052,7 +1251,7 @@
        return resultDto;
    }

    public void addApproveByPurchase(LoginUser loginUser,PurchaseLedger purchaseLedger) {
    public void addApproveByPurchase(LoginUser loginUser, PurchaseLedger purchaseLedger, List<SalesLedgerProduct> productList) {
        if (loginUser == null) {
            return;
        }
@@ -1077,6 +1276,10 @@
        approvalInstance.setTitle(purchaseLedger.getPurchaseContractNumber()+"审批");
        approvalInstance.setApplicantName(loginUser.getNickName());
        approvalInstance.setApplyTime(LocalDateTime.now());
        PurchaseLedgerDto snapshot = new PurchaseLedgerDto();
        BeanUtils.copyProperties(purchaseLedger, snapshot);
        snapshot.setProductData(productList == null ? Collections.emptyList() : new ArrayList<>(productList));
        approvalInstance.setFormConfig(JSON.toJSONString(snapshot));
        approvalInstanceService.add(approvalInstance);

    }