feat(mes): 重构袋码生成与物料分类功能

云

2 天以前 f7273277023f3497ac071bf98f556a569cb4dd25

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pro/bagcode/MesProBagCodeServiceImpl.java

@@ -3,14 +3,20 @@
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.mdm.api.unit.MdmUnitMeasureApi;
import cn.iocoder.yudao.module.mdm.api.unit.dto.MdmUnitMeasureRespDTO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeBindBatchReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeBindReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeGenerateReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeGenerateRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeRawGenerateReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeReplaceItemRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeReplaceReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.MesProBagCodeReplaceRespVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.mdm.MesMdmItemDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.bagcode.MesProBagCodeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.bagcode.MesProBagCodeReplaceDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.batch.MesProBatchDO;
@@ -22,6 +28,7 @@
import cn.iocoder.yudao.module.mes.enums.pro.MesProBagCodeStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProBatchStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProPalletStatusEnum;
import cn.iocoder.yudao.module.mes.service.mdm.MesMdmItemService;
import cn.iocoder.yudao.module.mes.service.pro.pallet.MesProPalletService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
@@ -33,8 +40,13 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
@@ -60,48 +72,214 @@

    @Resource
    private MesProPalletService palletService;
    @Resource
    private MesMdmItemService mdmItemService;
    @Resource
    private MdmUnitMeasureApi unitMeasureApi;

    /**
     * 计量单位类型「吨」（无托盘模式）
     */
    private static final String UNIT_TYPE_TON = "吨";
    /**
     * 计量单位类型「N千克」：每托盘装 N 个袋码
     */
    private static final Pattern KG_TYPE_PATTERN = Pattern.compile("^(\\d{1,5})千克$");

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MesProBagCodeGenerateRespVO generateBagCodes(MesProBagCodeGenerateReqVO generateReqVO) {
        // 1. 校验批次存在且处于生产中状态
        MesProBatchDO batch = batchMapper.selectByIdForUpdate(generateReqVO.getBatchId());
        // 1. 校验品种并读取主计量单位类型
        MesMdmItemDO item = mdmItemService.validateItemExists(generateReqVO.getItemId());
        String type = getUnitType(item);

        // 2. 按类型换算袋码数量：N千克 = 每托 N 袋 × 托盘数；吨 = 直接输入袋码数（无托盘）
        boolean ton = UNIT_TYPE_TON.equals(type);
        int perPallet = ton ? 0 : parseKgPerPallet(type);
        int totalCount;
        int palletCount = 0;
        if (ton) {
            if (generateReqVO.getBagCount() == null || generateReqVO.getBagCount() <= 0) {
                throw exception(PRO_BAG_CODE_GENERATE_COUNT_INVALID);
            }
            totalCount = generateReqVO.getBagCount();
        } else {
            if (generateReqVO.getPalletCount() == null || generateReqVO.getPalletCount() <= 0) {
                throw exception(PRO_BAG_CODE_PALLET_COUNT_REQUIRED);
            }
            palletCount = generateReqVO.getPalletCount();
            totalCount = perPallet * palletCount;
        }

        // 3. 生成阶段：袋码直接绑定品种；生产批次在后续录入
        String uuid = IdUtil.fastSimpleUUID();
        List<MesProPalletDO> pallets = new ArrayList<>(palletCount);
        if (!ton) {
            int startSeq = palletMapper.selectMaxTempCodeSeq() + 1;
            for (int i = 0; i < palletCount; i++) {
                pallets.add(new MesProPalletDO()
                        .setTempCode("PL-" + StrUtil.padPre(String.valueOf(startSeq + i), 8, '0'))
                        .setBagCount(perPallet)
                        .setAutoGenerated(true)
                        .setStatus(MesProPalletStatusEnum.IN_USE.getStatus()));
            }
            palletMapper.insertBatch(pallets);
        }
        int startNo = bagCodeMapper.selectMaxBagNo() + 1;
        List<MesProBagCodeDO> bagCodes = new ArrayList<>(totalCount);
        for (int i = 0; i < totalCount; i++) {
            int bagNo = startNo + i;
            MesProPalletDO pallet = ton ? null : pallets.get(i / perPallet);
            bagCodes.add(new MesProBagCodeDO()
                    .setUuid(uuid)
                    .setCode("BAG-" + StrUtil.padPre(String.valueOf(bagNo), 8, '0'))
                    .setBagNo(bagNo)
                    .setItemId(item.getId())
                    .setItemCode(item.getCode())
                    .setItemName(item.getName())
                    .setPalletId(pallet == null ? null : pallet.getId())
                    .setPalletCode(pallet == null ? null : pallet.getTempCode())
                    .setStatus(MesProBagCodeStatusEnum.GENERATED.getStatus())
                    .setRemark(generateReqVO.getRemark()));
        }
        bagCodeMapper.insertBatch(bagCodes);
        return new MesProBagCodeGenerateRespVO()
                .setUuid(uuid)
                .setType(type)
                .setPerPallet(perPallet)
                .setTotalCount(totalCount)
                .setPalletIds(pallets.stream().map(MesProPalletDO::getId).toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MesProBagCodeGenerateRespVO generateRawBagCodes(MesProBagCodeRawGenerateReqVO generateReqVO) {
        // 原始袋码不依赖计量单位类型与托盘：仅按数量生成，袋码带品种冗余，后续可正常录入批次/绑定托盘
        MesMdmItemDO item = mdmItemService.validateItemExists(generateReqVO.getItemId());
        String uuid = IdUtil.fastSimpleUUID();
        int startNo = bagCodeMapper.selectMaxBagNo() + 1;
        List<MesProBagCodeDO> bagCodes = new ArrayList<>(generateReqVO.getCount());
        for (int i = 0; i < generateReqVO.getCount(); i++) {
            int bagNo = startNo + i;
            bagCodes.add(new MesProBagCodeDO()
                    .setUuid(uuid)
                    .setCode("BAG-" + StrUtil.padPre(String.valueOf(bagNo), 8, '0'))
                    .setBagNo(bagNo)
                    .setItemId(item.getId())
                    .setItemCode(item.getCode())
                    .setItemName(item.getName())
                    .setStatus(MesProBagCodeStatusEnum.GENERATED.getStatus())
                    .setRemark(generateReqVO.getRemark()));
        }
        bagCodeMapper.insertBatch(bagCodes);
        return new MesProBagCodeGenerateRespVO()
                .setUuid(uuid)
                .setTotalCount(bagCodes.size())
                .setPalletIds(List.of());
    }

    /**
     * 读取品种主计量单位的类型（48千克/100千克/吨），未配置或无法识别时报错
     */
    private String getUnitType(MesMdmItemDO item) {
        String type = null;
        if (item.getUnitMeasureId() != null) {
            CommonResult<MdmUnitMeasureRespDTO> result = unitMeasureApi.getUnitMeasure(item.getUnitMeasureId());
            if (result != null && result.isSuccess() && result.getData() != null) {
                type = StrUtil.trimToNull(result.getData().getType());
            }
        }
        if (type == null) {
            throw exception(PRO_BAG_CODE_ITEM_TYPE_NOT_CONFIGURED);
        }
        if (!UNIT_TYPE_TON.equals(type) && !KG_TYPE_PATTERN.matcher(type).matches()) {
            throw exception(PRO_BAG_CODE_ITEM_TYPE_NOT_CONFIGURED);
        }
        return type;
    }

    /**
     * 解析「N千克」类型得出每托盘袋数
     */
    private int parseKgPerPallet(String type) {
        Matcher matcher = KG_TYPE_PATTERN.matcher(type);
        if (!matcher.matches()) {
            throw exception(PRO_BAG_CODE_ITEM_TYPE_NOT_CONFIGURED);
        }
        return Integer.parseInt(matcher.group(1));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void bindBatch(MesProBagCodeBindBatchReqVO bindReqVO) {
        MesProBatchDO batch = batchMapper.selectByIdForUpdate(bindReqVO.getBatchId());
        if (batch == null) {
            throw exception(PRO_BATCH_NOT_EXISTS);
        }
        if (!MesProBatchStatusEnum.PRODUCING.getStatus().equals(batch.getStatus())) {
            throw exception(PRO_BATCH_STATUS_NOT_GENERATE_CODE);
        }
        if (generateReqVO.getCount() == null || generateReqVO.getCount() <= 0) {
            throw exception(PRO_BAG_CODE_GENERATE_COUNT_INVALID);
        // 临时批次（未补录正式批次号）不允许袋码录入
        if (StrUtil.isEmpty(batch.getCode())) {
            throw exception(PRO_BATCH_NOT_FILLED);
        }
        List<Long> ids = bindReqVO.getIds().stream().distinct().toList();
        List<MesProBagCodeDO> bagCodes = bagCodeMapper.selectListByIdsForUpdate(ids);
        if (bagCodes.size() != ids.size() || bagCodes.stream().anyMatch(code ->
                code.getBatchId() != null
                        || (!MesProBagCodeStatusEnum.GENERATED.getStatus().equals(code.getStatus())
                        && !MesProBagCodeStatusEnum.PRINTED.getStatus().equals(code.getStatus())))) {
            throw exception(PRO_BAG_CODE_STATUS_NOT_GENERATED);
        }
        // 录入的袋码必须属于同一品种，且与批次已有袋码品种一致（历史空白袋码 item 为空不参与校验）
        Set<Long> itemIds = new LinkedHashSet<>();
        bagCodes.stream().map(MesProBagCodeDO::getItemId).filter(Objects::nonNull).forEach(itemIds::add);
        itemIds.addAll(bagCodeMapper.selectDistinctItemIdsByBatchId(batch.getId()));
        if (itemIds.size() > 1) {
            throw exception(PRO_BAG_CODE_BIND_BATCH_ITEM_MISMATCH);
        }
        if (bagCodeMapper.bindBatchByIds(ids, batch.getId(), batch.getCode(),
                List.of(MesProBagCodeStatusEnum.GENERATED.getStatus(),
                        MesProBagCodeStatusEnum.PRINTED.getStatus())) != ids.size()) {
            throw exception(PRO_BAG_CODE_STATUS_NOT_GENERATED);
        }
        batchMapper.updateById(new MesProBatchDO().setId(batch.getId())
                .setBagQuantity(bagCodeMapper.selectEffectiveCountByBatchId(batch.getId())));
        // 级联：本组袋码绑定的未入批次托盘，分配正式托盘码并绑定批次
        bindPalletsToBatch(bagCodes, batch);
    }

        // 2. 计算起始序号（包含已逻辑删除记录，保证序号不回退、码值唯一）
        int startNo = bagCodeMapper.selectMaxBagNo(batch.getId()) + 1;

        // 3. 批量生成袋码：批次号 + - + 4 位袋序号，同一次生成共享同一 UUID（数据包）
        String uuid = IdUtil.fastSimpleUUID();
        List<MesProBagCodeDO> bagCodes = new ArrayList<>(generateReqVO.getCount());
        for (int i = 0; i < generateReqVO.getCount(); i++) {
            int bagNo = startNo + i;
            bagCodes.add(new MesProBagCodeDO()
                    .setUuid(uuid)
                    .setCode(batch.getCode() + "-" + StrUtil.padPre(String.valueOf(bagNo), 4, '0'))
                    .setBagNo(bagNo)
    /**
     * 袋码录入批次时，将其绑定的临时托盘（未绑定批次）级联绑定到同一批次：
     * 分配正式托盘码（批次号-P序号）、回写袋码上的冗余托盘码、累计批次托盘数
     */
    private void bindPalletsToBatch(List<MesProBagCodeDO> bagCodes, MesProBatchDO batch) {
        List<Long> palletIds = bagCodes.stream().map(MesProBagCodeDO::getPalletId)
                .filter(Objects::nonNull).distinct().sorted().toList();
        if (palletIds.isEmpty()) {
            return;
        }
        int nextPalletNo = palletMapper.selectMaxPalletNo(batch.getId()) + 1;
        int boundCount = 0;
        for (Long palletId : palletIds) {
            MesProPalletDO pallet = palletMapper.selectByIdForUpdate(palletId);
            if (pallet == null || pallet.getBatchId() != null || StrUtil.isNotEmpty(pallet.getCode())) {
                continue;
            }
            String palletCode = batch.getCode() + "-P" + StrUtil.padPre(String.valueOf(nextPalletNo++), 2, '0');
            palletMapper.updateById(new MesProPalletDO().setId(palletId)
                    .setCode(palletCode)
                    .setBatchId(batch.getId())
                    .setBatchCode(batch.getCode())
                    .setStatus(MesProBagCodeStatusEnum.GENERATED.getStatus())
                    .setRemark(generateReqVO.getRemark()));
                    .setPalletNo(nextPalletNo - 1));
            // 袋码上的冗余托盘码由临时码更新为正式码
            bagCodeMapper.updatePalletCodeByPalletId(palletId, palletCode);
            boundCount++;
        }
        bagCodeMapper.insertBatch(bagCodes);

        // 4. 回写批次袋码数量
        batchMapper.updateById(new MesProBatchDO().setId(batch.getId())
                .setBagQuantity((batch.getBagQuantity() == null ? 0 : batch.getBagQuantity())
                        + generateReqVO.getCount()));
        return new MesProBagCodeGenerateRespVO()
                .setUuid(uuid)
                .setAutoPallets(palletService.autoCreatePallets(batch.getId()));
        if (boundCount > 0) {
            batchMapper.updateById(new MesProBatchDO().setId(batch.getId())
                    .setPalletQuantity((batch.getPalletQuantity() == null ? 0 : batch.getPalletQuantity()) + boundCount));
        }
    }

    @Override
@@ -147,7 +325,7 @@

        String replaceUuid = IdUtil.fastSimpleUUID();
        LocalDateTime replaceTime = LocalDateTime.now();
        int startNo = bagCodeMapper.selectMaxBagNo(batch.getId()) + 1;
        int startNo = bagCodeMapper.selectMaxBagNo() + 1;
        List<MesProBagCodeDO> newBagCodes = new ArrayList<>(oldBagCodes.size());
        List<MesProBagCodeReplaceDO> replacements = new ArrayList<>(oldBagCodes.size());
        List<MesProBagCodeReplaceItemRespVO> items = new ArrayList<>(oldBagCodes.size());
@@ -165,6 +343,9 @@
                    .setBagNo(newBagNo)
                    .setBatchId(batch.getId())
                    .setBatchCode(batch.getCode())
                    .setItemId(oldBagCode.getItemId())
                    .setItemCode(oldBagCode.getItemCode())
                    .setItemName(oldBagCode.getItemName())
                    .setPalletId(pallet == null ? null : pallet.getId())
                    .setPalletCode(pallet == null ? null : pallet.getCode())
                    .setStatus(MesProBagCodeStatusEnum.GENERATED.getStatus())
@@ -224,17 +405,26 @@
        if (CollUtil.isEmpty(bagCodes)) {
            throw exception(PRO_BAG_CODE_UUID_NOT_EXISTS);
        }
        // 2. 校验均为已生成状态且未绑定托盘
        // 2. 校验均为已生成状态
        if (bagCodes.stream().anyMatch(bagCode ->
                !MesProBagCodeStatusEnum.GENERATED.getStatus().equals(bagCode.getStatus()))) {
            throw exception(PRO_BAG_CODE_STATUS_NOT_GENERATED);
        }
        if (bagCodes.stream().anyMatch(bagCode -> bagCode.getPalletId() != null)) {
            throw exception(PRO_BAG_CODE_BIND_PALLET_BOUND);
        // 3. 绑定的托盘仅限"自动生成且未绑定批次"（生成数据包时自动绑定），级联删除；已入批次的托盘不允许随包删除
        Set<Long> palletIds = new LinkedHashSet<>();
        bagCodes.stream().map(MesProBagCodeDO::getPalletId).filter(Objects::nonNull).forEach(palletIds::add);
        for (Long palletId : palletIds) {
            MesProPalletDO pallet = palletMapper.selectById(palletId);
            if (pallet != null && (pallet.getBatchId() != null || StrUtil.isNotEmpty(pallet.getCode()))) {
                throw exception(PRO_BAG_CODE_BIND_PALLET_BOUND);
            }
        }
        // 3. 删除生成组
        // 4. 删除生成组与其自动生成的临时托盘
        bagCodeMapper.deleteByIds(bagCodes.stream().map(MesProBagCodeDO::getId).toList());
        // 4. 回减批次袋码数量
        if (!palletIds.isEmpty()) {
            palletMapper.deleteByIds(palletIds);
        }
        // 5. 回减批次袋码数量
        MesProBatchDO batch = batchMapper.selectById(bagCodes.get(0).getBatchId());
        if (batch != null && batch.getBagQuantity() != null) {
            batchMapper.updateById(new MesProBatchDO().setId(batch.getId())
@@ -252,13 +442,8 @@
        }
        // 2. 锁定并校验袋码
        List<MesProBagCodeDO> bagCodes = validateBagCodesForBind(bindReqVO.getIds(), pallet, true);
        // 3. 校验不超过托盘可装袋数
        // 3. 绑定袋码并累加托盘已装袋数（托盘无容量上限）
        int currentCount = pallet.getBagCount() == null ? 0 : pallet.getBagCount();
        if (pallet.getCapacity() != null && pallet.getCapacity() > 0
                && currentCount + bagCodes.size() > pallet.getCapacity()) {
            throw exception(PRO_BAG_CODE_BIND_PALLET_OVER_CAPACITY);
        }
        // 4. 绑定袋码并累加托盘已装袋数
        bagCodeMapper.bindPalletByIds(bindReqVO.getIds(), pallet.getId(), pallet.getCode());
        palletService.updatePalletBagCount(pallet.getId(), currentCount + bagCodes.size());
    }