feat(seal): 印章详情视图与编辑删除接口

gaoluyang

6 天以前 3fd8d1f2e73a843acd330e8e8b84f5800f858407

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/wm/arrivalnotice/MesWmArrivalNoticeServiceImpl.java

@@ -2,6 +2,7 @@

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
@@ -9,20 +10,34 @@
import cn.iocoder.yudao.module.mes.controller.admin.wm.arrivalnotice.vo.MesWmArrivalNoticeSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.arrivalnotice.MesWmArrivalNoticeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.arrivalnotice.MesWmArrivalNoticeLineDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.returnvendor.MesWmReturnVendorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.returnvendor.MesWmReturnVendorLineDO;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.arrivalnotice.MesWmArrivalNoticeMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.returnvendor.MesWmReturnVendorLineMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.returnvendor.MesWmReturnVendorMapper;
import cn.iocoder.yudao.module.mes.enums.wm.MesWmArrivalNoticeStatusEnum;
import cn.iocoder.yudao.module.erp.api.purchase.ErpPurchaseOrderApi;
import cn.iocoder.yudao.module.srm.api.supplier.SrmSupplierApi;
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseOrderRespDTO;
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseOrderItemRespDTO;
import cn.iocoder.yudao.module.mes.service.mdm.MesMdmItemService;
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcService;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcCheckResultEnum;
import cn.iocoder.yudao.module.mes.service.wm.itemreceipt.MesWmItemReceiptService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
@@ -36,15 +51,35 @@
public class MesWmArrivalNoticeServiceImpl implements MesWmArrivalNoticeService {

    @Resource
    private cn.iocoder.yudao.module.mes.service.qc.ncr.MesQcArrivalDispositionService arrivalDispositionService;

    @Resource
    private MesWmArrivalNoticeMapper arrivalNoticeMapper;

    @Resource
    private MesWmArrivalNoticeLineService arrivalNoticeLineService;

    @Resource
    private cn.iocoder.yudao.module.mes.service.md.vendor.MesMdVendorService vendorService;
    private MesWmReturnVendorMapper returnVendorMapper;
    @Resource
    private MesWmReturnVendorLineMapper returnVendorLineMapper;

    @Resource
    private SrmSupplierApi srmSupplierApi;

    @Resource
    private ErpPurchaseOrderApi purchaseOrderApi;

    @Resource
    private MesMdmItemService mdmItemService;

    @Resource
    @Lazy
    private MesQcIqcService iqcService;

    @Resource
    @Lazy
    private MesWmItemReceiptService itemReceiptService;

    @Override
    public Long createArrivalNotice(MesWmArrivalNoticeSaveReqVO createReqVO) {
@@ -53,6 +88,7 @@

        // 插入
        MesWmArrivalNoticeDO notice = BeanUtils.toBean(createReqVO, MesWmArrivalNoticeDO.class);
        fillContractNoFromPurchaseOrder(notice);
        notice.setStatus(MesWmArrivalNoticeStatusEnum.PREPARE.getStatus());
        arrivalNoticeMapper.insert(notice);
        return notice.getId();
@@ -67,22 +103,34 @@

        // 更新
        MesWmArrivalNoticeDO updateObj = BeanUtils.toBean(updateReqVO, MesWmArrivalNoticeDO.class);
        fillContractNoFromPurchaseOrder(updateObj);
        arrivalNoticeMapper.updateById(updateObj);
    }

    /**
     * 采购合同号未显式传入时，从关联的采购订单带入（换货到货必须能追溯到原采购合同）
     */
    private void fillContractNoFromPurchaseOrder(MesWmArrivalNoticeDO notice) {
        if (notice.getPurchaseOrderId() == null || cn.hutool.core.util.StrUtil.isNotBlank(notice.getContractNo())) {
            return;
        }
        ErpPurchaseOrderRespDTO purchaseOrder = purchaseOrderApi.getPurchaseOrder(notice.getPurchaseOrderId()).getCheckedData();
        if (purchaseOrder != null) {
            notice.setContractNo(purchaseOrder.getContractNo());
        }
    }

    private void validateArrivalNoticeSaveData(MesWmArrivalNoticeSaveReqVO reqVO) {
        // 校验编码唯一
        validateCodeUnique(reqVO.getId(), reqVO.getCode());
        // 校验供应商存在且启用
        vendorService.validateVendorExistsAndEnable(reqVO.getVendorId());
        // 校验采购订单存在，并自动填充采购订单号
        // 校验供应商存在（ERP 采购供应商）
        srmSupplierApi.getSupplier(reqVO.getVendorId());
        // 校验采购订单存在
        if (reqVO.getPurchaseOrderId() != null) {
            ErpPurchaseOrderRespDTO purchaseOrder = purchaseOrderApi.getPurchaseOrder(reqVO.getPurchaseOrderId()).getCheckedData();
            if (purchaseOrder == null) {
                throw exception(WM_PURCHASE_ORDER_NOT_EXISTS);
            }
            // 自动填充采购订单号
            reqVO.setPurchaseOrderCode(purchaseOrder.getNo());
        }
    }

@@ -112,7 +160,7 @@
    @Transactional(rollbackFor = Exception.class)
    public void submitArrivalNotice(Long id) {
        // 1.1 校验存在 + 草稿状态
        validateArrivalNoticeExistsAndDraft(id);
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExistsAndDraft(id);
        // 1.2 检查是否有行项目
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        if (CollUtil.isEmpty(lines)) {
@@ -120,22 +168,77 @@
        }

        // 2. 检查所有行的 iqcCheckFlag：如果有需要检验的行，进入待质检状态
        // 注意：来料检验单不在提交时生成，由库管点击「执行质检」时通过 createIqcForArrivalNotice 生成
        boolean needCheck = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()));
        if (needCheck) {
            // 需要检验，进入待质检
            arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                    .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus()));
            return;
        }
        // 不需要检验，直接进入待入库
        // 不需要检验，直接进入待入库，并自动生成采购入库单交给库管确认入库
        arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus()));
        autoGenerateItemReceipt(notice);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateArrivalNoticeWhenIqcFinish(Long id, Long lineId, Long iqcId, BigDecimal qualifiedQuantity) {
    public Integer createIqcForArrivalNotice(Long id) {
        // 1. 校验到货通知单存在且为待质检状态
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        if (ObjUtil.notEqual(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus(), notice.getStatus())) {
            String statusName = Arrays.stream(MesWmArrivalNoticeStatusEnum.values())
                    .filter(item -> ObjUtil.equal(item.getStatus(), notice.getStatus()))
                    .map(MesWmArrivalNoticeStatusEnum::getName).findFirst()
                    .orElse(String.valueOf(notice.getStatus()));
            throw new ServiceException(WM_ARRIVAL_NOTICE_STATUS_NOT_PENDING_QC.getCode(),
                    "到货通知单[" + notice.getCode() + "]当前状态为[" + statusName + "]，只有「待质检」状态才能执行质检。"
                            + "请刷新列表确认单据状态；若该单据已执行过质检，请直接到【质量管理 - IQC检验】录入检测结果。");
        }
        // 2. 校验需检行
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        List<MesWmArrivalNoticeLineDO> needCheckLines = lines.stream()
                .filter(line -> Boolean.TRUE.equals(line.getIqcCheckFlag()))
                .toList();
        if (needCheckLines.isEmpty()) {
            throw new ServiceException(WM_ARRIVAL_NOTICE_NO_IQC_LINE.getCode(),
                    "到货通知单[" + notice.getCode() + "]的明细行均为「不需检验」，无需生成来料检验单。"
                            + "请直接到该单据执行入库；若本应检验，请核对采购订单行的检验标识（该标识由采购订单带入，到货通知单上不可修改）。");
        }
        List<MesWmArrivalNoticeLineDO> pendingLines = needCheckLines.stream()
                .filter(line -> line.getIqcId() == null)
                .toList();
        if (pendingLines.isEmpty()) {
            throw new ServiceException(WM_ARRIVAL_NOTICE_IQC_ALREADY_CREATED.getCode(),
                    "到货通知单[" + notice.getCode() + "]的 " + needCheckLines.size()
                            + " 条需检行均已生成来料检验单，无需重复生成。请直接到【质量管理 - IQC检验】录入检测结果；"
                            + "如需重新生成，请先删除原检验单。");
        }
        // 3. 逐行生成来料检验单
        int createdCount = 0;
        for (MesWmArrivalNoticeLineDO line : pendingLines) {
            Long iqcId;
            try {
                iqcId = iqcService.createIqcFromArrivalNotice(id, line, notice.getCode(), notice.getVendorId());
            } catch (Exception ex) {
                log.error("[createIqcForArrivalNotice][到货通知单({}) 行({}) 创建 IQC 失败]", id, line.getId(), ex);
                throw new ServiceException(WM_ARRIVAL_NOTICE_IQC_CREATE_FAILED.getCode(),
                        "到货通知单[" + notice.getCode() + "]的明细行（物料ID=" + line.getItemId()
                                + "）生成来料检验单失败：" + ex.getMessage()
                                + "。请稍后重试；若持续失败，请到【质量管理 - IQC检验】手工新建检验单。");
            }
            arrivalNoticeLineService.updateArrivalNoticeLineIqcId(line.getId(), iqcId);
            createdCount++;
            log.info("[createIqcForArrivalNotice][到货通知单({}) 行({}) 生成 IQC 检验单({})]",
                    id, line.getId(), iqcId);
        }
        return createdCount;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateArrivalNoticeWhenIqcFinish(Long id, Long lineId, Long iqcId, Integer checkResult, BigDecimal qualifiedQuantity) {
        // 1.1 校验到货通知单存在
        MesWmArrivalNoticeDO notice = validateArrivalNoticeExists(id);
        // 1.2 校验状态为待质检
@@ -143,20 +246,52 @@
            throw exception(WM_ARRIVAL_NOTICE_STATUS_NOT_PENDING_QC);
        }

        // 2. 更新到货通知单行：绑定 iqcId + 合格数量
        arrivalNoticeLineService.updateArrivalNoticeLineWhenIqcFinish(lineId, iqcId, qualifiedQuantity);
        // 2. 更新到货通知单行：绑定 iqcId + 质检结果 + 合格数量
        arrivalNoticeLineService.updateArrivalNoticeLineWhenIqcFinish(lineId, iqcId, checkResult, qualifiedQuantity);

        // 3.1 判断是否所有需检行都已完成
        // 同时认可仓库已确认的来料退货；保留原始不合格结论。
        arrivalDispositionService.refresh(id);
        // 3.1 判断是否所有需检行都已完成质检
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(id);
        boolean hasUnchecked = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcId() == null);
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag()) && line.getIqcCheckResult() == null);
        if (hasUnchecked) {
            log.info("[updateArrivalNoticeWhenIqcFinish][到货通知单({}) 还有未完成检验的行，暂不更新状态]", id);
            return;
        }
        // 3.2 所有行检验完成，更新主表状态 PENDING_QC → PENDING_RECEIPT

        // 3.2 判断是否所有需检行都可以入库（合格或特采）
        boolean hasNonInbound = CollectionUtils.anyMatch(lines,
                line -> Boolean.TRUE.equals(line.getIqcCheckFlag())
                        && !MesQcCheckResultEnum.canInbound(line.getIqcCheckResult()));
        if (hasNonInbound) {
            log.info("[updateArrivalNoticeWhenIqcFinish][到货通知单({}) 存在不可入库的行（退货/报废），状态保持待质检]", id);
            return;
        }

        // 3.3 所有行检验完成且可入库，更新主表状态 PENDING_QC → PENDING_RECEIPT
        arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                .setId(id).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus()));
        // 3.4 质检合格后直接生成采购入库单（待入库），库管只需核对数量并确认入库
        autoGenerateItemReceipt(notice);
    }

    /**
     * 到货通知单进入「待入库」后自动生成采购入库单。
     * 库管无需再回到到货通知点「执行入库」，直接到【采购入库】核对数量并确认入库即可。
     */
    private void autoGenerateItemReceipt(MesWmArrivalNoticeDO notice) {
        try {
            Long receiptId = itemReceiptService.generateItemReceiptFromArrivalNotice(notice.getId());
            log.info("[autoGenerateItemReceipt][到货通知单({}) 已自动生成采购入库单({})]",
                    notice.getId(), receiptId);
        } catch (ServiceException ex) {
            log.error("[autoGenerateItemReceipt][到货通知单({}) 自动生成采购入库单失败]",
                    notice.getId(), ex);
            throw new ServiceException(ex.getCode(),
                    "到货通知单[" + notice.getCode() + "]转入待入库后自动生成采购入库单失败：" + ex.getMessage()
                            + "。本次操作未生效，请稍后重试；若持续失败请联系管理员。");
        }
    }

    @Override
@@ -256,4 +391,144 @@
        return arrivalNoticeMapper.selectCountByVendorId(vendorId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long generateArrivalNoticeFromPurchaseOrder(Long purchaseOrderId) {
        // 1. 校验是否已生成过到货通知单（防止重复生成）
        MesWmArrivalNoticeDO existNotice = arrivalNoticeMapper.selectByPurchaseOrderId(purchaseOrderId);
        if (existNotice != null) {
            throw exception(WM_ARRIVAL_NOTICE_ALREADY_EXISTS);
        }

        // 2. 获取采购订单
        ErpPurchaseOrderRespDTO purchaseOrder = purchaseOrderApi.getPurchaseOrder(purchaseOrderId).getCheckedData();
        if (purchaseOrder == null) {
            throw exception(WM_PURCHASE_ORDER_NOT_EXISTS);
        }

        // 3. 获取采购订单明细
        List<ErpPurchaseOrderItemRespDTO> items = purchaseOrderApi.getPurchaseOrderItemList(purchaseOrderId).getCheckedData();
        if (CollUtil.isEmpty(items)) {
            throw exception(WM_PURCHASE_ORDER_NO_ITEM);
        }

        // 4. 生成到货通知单编码
        String code = generateArrivalNoticeCode();

        // 5. 创建到货通知单主表，直接设为待入库状态
        MesWmArrivalNoticeDO notice = new MesWmArrivalNoticeDO();
        notice.setCode(code);
        notice.setName(purchaseOrder.getNo() + "到货通知");
        notice.setPurchaseOrderId(purchaseOrderId);
        notice.setPurchaseOrderCode(purchaseOrder.getNo());
        notice.setContractNo(purchaseOrder.getContractNo());
        notice.setVendorId(purchaseOrder.getSupplierId());
        notice.setArrivalDate(java.time.LocalDateTime.now()); // 到货时间为当前时间
        notice.setStatus(MesWmArrivalNoticeStatusEnum.PENDING_RECEIPT.getStatus());
        arrivalNoticeMapper.insert(notice);

        // 6. 遍历明细创建到货通知单行
        boolean hasNeedQc = false;
        for (ErpPurchaseOrderItemRespDTO item : items) {
            MesWmArrivalNoticeLineDO line = new MesWmArrivalNoticeLineDO();
            line.setNoticeId(notice.getId());
            line.setPurchaseOrderItemId(item.getId());
            line.setItemId(item.getProductId()); // 从采购订单明细带入物料编号
            BigDecimal arrivalQuantity = item.getCount() != null ? item.getCount().subtract(item.getInCount() != null ? item.getInCount() : BigDecimal.ZERO) : BigDecimal.ZERO;
            line.setArrivalQuantity(arrivalQuantity);
            // 从采购订单明细带入质检标识
            boolean needQc = Boolean.TRUE.equals(item.getQcCheckFlag());
            line.setIqcCheckFlag(needQc);
            // 如果不需要质检，合格数量等于到货数量
            if (!needQc) {
                line.setQualifiedQuantity(arrivalQuantity);
            } else {
                hasNeedQc = true;
            }
            arrivalNoticeLineService.createArrivalNoticeLineFromPurchaseOrderItem(line);
        }

        // 7. 如果有需要质检的行，更新状态为待质检
        // 注意：来料检验单不在生成时创建，由库管点击「执行质检」时通过 createIqcForArrivalNotice 生成
        if (hasNeedQc) {
            arrivalNoticeMapper.updateById(new MesWmArrivalNoticeDO()
                    .setId(notice.getId()).setStatus(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus()));
        }

        return notice.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createReplacementArrivalNotice(Long returnVendorId) {
        // 1. 校验退货单
        MesWmReturnVendorDO returnVendor = returnVendorMapper.selectById(returnVendorId);
        if (returnVendor == null) {
            throw exception(WM_RETURN_VENDOR_NOT_EXISTS);
        }
        if (returnVendor.getPurchaseOrderId() == null) {
            throw exception(WM_RETURN_VENDOR_PURCHASE_ORDER_REQUIRED);
        }
        List<MesWmReturnVendorLineDO> returnLines = returnVendorLineMapper.selectListByReturnId(returnVendorId);
        if (CollUtil.isEmpty(returnLines)) {
            throw exception(WM_RETURN_VENDOR_NO_LINE);
        }

        // 2. 获取采购订单明细，用于按物料匹配采购订单明细编号（保证入库后能回写入库/退货数量）
        Map<Long, Long> purchaseOrderItemIdMap = new HashMap<>();
        List<ErpPurchaseOrderItemRespDTO> orderItems = purchaseOrderApi
                .getPurchaseOrderItemList(returnVendor.getPurchaseOrderId()).getCheckedData();
        if (CollUtil.isNotEmpty(orderItems)) {
            orderItems.stream()
                    .filter(item -> item.getProductId() != null)
                    .forEach(item -> purchaseOrderItemIdMap.putIfAbsent(item.getProductId(), item.getId()));
        }

        // 3. 创建到货通知单主表，状态直接置为待质检
        MesWmArrivalNoticeDO notice = new MesWmArrivalNoticeDO();
        notice.setCode(generateArrivalNoticeCode());
        notice.setName(returnVendor.getCode() + "换货到货");
        notice.setPurchaseOrderId(returnVendor.getPurchaseOrderId());
        notice.setPurchaseOrderCode(returnVendor.getPurchaseOrderCode());
        // 换货重新关联原采购合同号：优先取退货单快照，退货单未快照时回填采购订单合同号
        notice.setContractNo(returnVendor.getContractNo());
        fillContractNoFromPurchaseOrder(notice);
        notice.setVendorId(returnVendor.getVendorId());
        notice.setArrivalDate(java.time.LocalDateTime.now());
        notice.setStatus(MesWmArrivalNoticeStatusEnum.PENDING_QC.getStatus());
        notice.setRemark("供应商退货单[" + returnVendor.getCode() + "]换货重新入库，合同号["
                + returnVendor.getContractNo() + "]");
        arrivalNoticeMapper.insert(notice);

        // 4. 遍历退货行创建到货通知单行，全部标记需要质检
        for (MesWmReturnVendorLineDO returnLine : returnLines) {
            MesWmArrivalNoticeLineDO line = new MesWmArrivalNoticeLineDO();
            line.setNoticeId(notice.getId());
            line.setPurchaseOrderItemId(purchaseOrderItemIdMap.get(returnLine.getItemId()));
            line.setItemId(returnLine.getItemId());
            line.setArrivalQuantity(returnLine.getQuantity());
            line.setIqcCheckFlag(true);
            arrivalNoticeLineService.createArrivalNoticeLineFromPurchaseOrderItem(line);
        }

        // 5. 逐行自动创建 IQC 检验单
        List<MesWmArrivalNoticeLineDO> lines = arrivalNoticeLineService.getArrivalNoticeLineListByNoticeId(notice.getId());
        for (MesWmArrivalNoticeLineDO line : lines) {
            Long iqcId = iqcService.createIqcFromArrivalNotice(
                    notice.getId(), line, notice.getCode(), notice.getVendorId());
            arrivalNoticeLineService.updateArrivalNoticeLineIqcId(line.getId(), iqcId);
            log.info("[createReplacementArrivalNotice][换货到货通知单({}) 行({}) 自动创建 IQC 检验单({})]",
                    notice.getId(), line.getId(), iqcId);
        }
        return notice.getId();
    }

    /**
     * 生成到货通知单编码
     */
    private String generateArrivalNoticeCode() {
        // TODO: 使用编码规则服务生成编码
        return "AN" + System.currentTimeMillis();
    }

}