feat(system): 优化用户搜索功能并完善ERP和MES模块验证逻辑

云

2026-10-25 d54fbc9d4f8981fa0f7f613b33a28a8cd4f764ea

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pro/mps/MesProMpsServiceImpl.java

@@ -3,33 +3,62 @@
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pro.mps.vo.MesProMpsImportExcelVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.mps.vo.MesProMpsImportRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.mps.vo.MesProMpsPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.mps.vo.MesProMpsSaveReqVO;
import cn.iocoder.yudao.module.mes.api.event.ProductionCanceledEvent;
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.MesProWorkOrderSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.mps.MesProMpsDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.mps.MesProMpsMergeItemDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.mps.MesProMpsMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.mps.MesProMpsMergeItemMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.feedback.MesProFeedbackMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderMapper;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProductBomDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProductDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemTypeDO;
import cn.iocoder.yudao.module.mes.enums.md.MesMdItemTypeEnum;
import cn.iocoder.yudao.module.mes.enums.md.autocode.MesMdAutoCodeRuleCodeEnum;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemTypeService;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
import cn.iocoder.yudao.module.mes.enums.pro.MesProMpsStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProFeedbackStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProWorkOrderSourceTypeEnum;
import cn.iocoder.yudao.module.mes.service.md.autocode.MesMdAutoCodeRecordService;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteProductService;
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteProcessService;
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderProcessService;
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.process.MesProWorkOrderProcessSaveReqVO;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
@@ -37,17 +66,12 @@
/**
 * MES 生产主计划（MPS）Service 实现类
 *
 * @author 芋道源码
 * @author 超级管理员
 */
@Service
@Validated
@Slf4j
public class MesProMpsServiceImpl implements MesProMpsService {

    /**
     * MPS 编码规则
     */
    private static final String MPS_CODE_RULE = "MPS";

    @Resource
    private MesProMpsMapper mpsMapper;
@@ -58,9 +82,23 @@
    @Resource
    private MesMdItemService itemService;
    @Resource
    private MesMdItemTypeService itemTypeService;
    @Resource
    private MesMdAutoCodeRecordService autoCodeRecordService;
    @Resource
    private CrmCustomerApi customerApi;
    @Resource
    private MesProFeedbackMapper feedbackMapper;
    @Resource
    private MesProWorkOrderMapper workOrderMapper;
    @Resource
    private MesProRouteProductService routeProductService;
    @Resource
    private MesProRouteProcessService routeProcessService;
    @Resource
    private MesProWorkOrderProcessService workOrderProcessService;
    @Resource
    private ApplicationEventPublisher eventPublisher;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -68,11 +106,12 @@
                          Long mdmItemId, String productName, BigDecimal quantity, Long clientId,
                          String requestDate, String remark) {
        // 1. 根据 MDM 物料 ID 查找 MES 产品
        cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO mesItem = itemService.getItemByMdmItemId(mdmItemId);
        MesMdItemDO mesItem = itemService.getItemByMdmItemId(mdmItemId);
        if (mesItem == null) {
            // MES 产品不存在，抛出异常并包含产品名称提示
            throw exception(PRO_MPS_MES_PRODUCT_NOT_EXISTS, productName != null ? productName : mdmItemId);
        }
        validateProductItem(mesItem.getId());

        // 2. 生成 MPS 编码
        String code = generateMpsCode();
@@ -112,8 +151,8 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createMps(MesProMpsSaveReqVO createReqVO) {
        // 校验产品存在
        itemService.validateItemExists(createReqVO.getProductId());
        // 校验产品存在、启用且为产品类型
        validateProductItem(createReqVO.getProductId());

        // 如果未填写编码，自动生成
        if (StrUtil.isBlank(createReqVO.getCode())) {
@@ -139,6 +178,8 @@
    public void updateMps(MesProMpsSaveReqVO updateReqVO) {
        // 校验存在 + 草稿状态
        validateMpsExistsAndDraft(updateReqVO.getId());
        // 校验产品存在、启用且为产品类型
        validateProductItem(updateReqVO.getProductId());

        // 校验编码唯一
        validateMpsCodeUnique(updateReqVO.getId(), updateReqVO.getCode());
@@ -271,6 +312,10 @@
        mpsMapper.updateById(new MesProMpsDO()
                .setId(id)
                .setStatus(MesProMpsStatusEnum.CANCELED.getStatus()));
        // 来源于销售订单时，同步恢复销售订单生产状态，允许重新创建生产计划
        if (mps.getSaleOrderId() != null) {
            eventPublisher.publishEvent(new ProductionCanceledEvent(mps.getSaleOrderId()));
        }
    }

    @Override
@@ -331,6 +376,161 @@
        mpsMapper.updateProducedQuantity(id, incrQuantity);
    }

    @Override
    public Boolean checkSaleOrderProductionFinished(Long saleOrderId) {
        if (saleOrderId == null) {
            return false;
        }
        // 1. 查询该销售订单所有 MPS（通过 saleOrderId 关联）
        List<MesProMpsDO> mpsList = mpsMapper.selectList(
                MesProMpsDO::getSaleOrderId, saleOrderId);
        if (CollUtil.isEmpty(mpsList)) {
            // 无 MPS 关联，视为完成
            return true;
        }
        // 2. 检查每个 MPS 是否完成
        for (MesProMpsDO mps : mpsList) {
            if (!isMpsFinished(mps)) {
                return false;
            }
        }
        return true;
    }

    @Override
    public MesProMpsDO getMpsByWorkOrderId(Long workOrderId) {
        if (workOrderId == null) {
            return null;
        }
        return mpsMapper.selectOne(MesProMpsDO::getWorkOrderId, workOrderId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean checkAndFinishMps(Long mpsId) {
        if (mpsId == null) {
            log.warn("[checkAndFinishMps] mpsId is null");
            return false;
        }
        MesProMpsDO mps = mpsMapper.selectById(mpsId);
        if (mps == null) {
            log.warn("[checkAndFinishMps] MPS not found, mpsId={}", mpsId);
            return false;
        }
        // 已完成或已取消，直接返回 true
        if (MesProMpsStatusEnum.FINISHED.getStatus().equals(mps.getStatus())
                || MesProMpsStatusEnum.CANCELED.getStatus().equals(mps.getStatus())) {
            log.info("[checkAndFinishMps] MPS {} already finished or canceled, status={}", mpsId, mps.getStatus());
            return true;
        }
        // 检查是否满足完成条件
        boolean finished = isMpsFinished(mps);
        log.info("[checkAndFinishMps] MPS {} check result: {}, quantity={}, produced={}, workOrderId={}",
                mpsId, finished, mps.getQuantity(), mps.getQuantityProduced(), mps.getWorkOrderId());
        if (finished) {
            // 自动完成 MPS
            mpsMapper.updateById(new MesProMpsDO()
                    .setId(mpsId)
                    .setStatus(MesProMpsStatusEnum.FINISHED.getStatus())
                    .setFinishDate(LocalDateTime.now()));
            log.info("[checkAndFinishMps] MPS {} auto finished", mpsId);
            return true;
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MesProMpsImportRespVO importMpsList(List<MesProMpsImportExcelVO> importList, boolean updateSupport) {
        if (CollUtil.isEmpty(importList)) {
            throw exception(MES_PRO_MPS_IMPORT_LIST_IS_EMPTY);
        }
        MesProMpsImportRespVO respVO = MesProMpsImportRespVO.builder()
                .createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
                .failureCodes(new LinkedHashMap<>()).build();
        AtomicInteger index = new AtomicInteger(1);
        importList.forEach(importItem -> {
            int currentIndex = index.getAndIncrement();
            String key = StrUtil.blankToDefault(importItem.getCode(), "第 " + currentIndex + " 行");
            // 1. 解析产品
            if (StrUtil.isBlank(importItem.getProductCode())) {
                respVO.getFailureCodes().put(key, "产品编码不能为空");
                return;
            }
            MesMdItemDO item = itemService.getItemByCode(importItem.getProductCode().trim());
            if (item == null) {
                respVO.getFailureCodes().put(key, "产品编码[" + importItem.getProductCode() + "]不存在");
                return;
            }
            // 2. 解析客户
            Long clientId = null;
            if (StrUtil.isNotBlank(importItem.getClientName())) {
                CrmCustomerRespDTO customer = customerApi.getCustomerByName(importItem.getClientName().trim());
                if (customer == null) {
                    respVO.getFailureCodes().put(key, "客户名称[" + importItem.getClientName() + "]不存在");
                    return;
                }
                clientId = customer.getId();
            }
            // 3. 构建请求并创建/更新（复用现有 create/update 服务）
            MesProMpsSaveReqVO reqVO = BeanUtils.toBean(importItem, MesProMpsSaveReqVO.class);
            reqVO.setProductId(item.getId());
            reqVO.setUnitMeasureId(item.getUnitMeasureId());
            reqVO.setClientId(clientId);
            try {
                if (StrUtil.isBlank(importItem.getCode())) {
                    // 编码为空：仅创建（自动生成编码）
                    reqVO.setId(null);
                    reqVO.setCode(null);
                    createMps(reqVO);
                    respVO.getCreateCodes().add(StrUtil.isBlank(reqVO.getCode())
                            ? String.valueOf(currentIndex) : reqVO.getCode());
                } else {
                    MesProMpsDO existMps = mpsMapper.selectByCode(importItem.getCode());
                    if (existMps == null) {
                        reqVO.setId(null);
                        createMps(reqVO);
                        respVO.getCreateCodes().add(importItem.getCode());
                    } else if (updateSupport) {
                        reqVO.setId(existMps.getId());
                        updateMps(reqVO);
                        respVO.getUpdateCodes().add(importItem.getCode());
                    } else {
                        respVO.getFailureCodes().put(key, "MPS 编码已存在");
                    }
                }
            } catch (ServiceException e) {
                respVO.getFailureCodes().put(key, e.getMessage());
            }
        });
        return respVO;
    }

    /**
     * 判断单个 MPS 是否完成
     */
    private boolean isMpsFinished(MesProMpsDO mps) {
        // 1. 已生产数量 >= 计划数量
        BigDecimal quantityProduced = ObjUtil.defaultIfNull(mps.getQuantityProduced(), BigDecimal.ZERO);
        if (quantityProduced.compareTo(mps.getQuantity()) < 0) {
            log.debug("[isMpsFinished] MPS {} quantity not enough: produced={}, required={}",
                    mps.getId(), quantityProduced, mps.getQuantity());
            return false;
        }
        // 2. 检查工单下所有报工是否完成（确保质检完成）
        if (mps.getWorkOrderId() != null) {
            Long unfinishedCount = feedbackMapper.selectCount(
                    new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<MesProFeedbackDO>()
                            .eq(MesProFeedbackDO::getWorkOrderId, mps.getWorkOrderId())
                            .ne(MesProFeedbackDO::getStatus, MesProFeedbackStatusEnum.FINISHED.getStatus()));
            log.debug("[isMpsFinished] MPS {} unfinished feedback count: {}", mps.getId(), unfinishedCount);
            if (unfinishedCount > 0) {
                return false;
            }
        }
        return true;
    }

    // ========== 私有方法 ==========

    /**
@@ -338,10 +538,11 @@
     */
    private String generateMpsCode() {
        try {
            return autoCodeRecordService.generateAutoCode(MPS_CODE_RULE);
            return autoCodeRecordService.generateAutoCode(MesMdAutoCodeRuleCodeEnum.PRO_MPS_CODE.getCode());
        } catch (Exception e) {
            // 如果编码规则不存在，使用时间戳生成
            log.warn("[generateMpsCode] 编码规则 {} 不存在，使用时间戳生成", MPS_CODE_RULE);
            log.warn("[generateMpsCode] 编码规则 {} 不存在，使用时间戳生成",
                    MesMdAutoCodeRuleCodeEnum.PRO_MPS_CODE.getCode(), e);
            return "MPS" + System.currentTimeMillis();
        }
    }
@@ -395,9 +596,34 @@
    }

    /**
     * 校验产品存在、启用且为产品类型
     */
    private void validateProductItem(Long itemId) {
        MesMdItemDO item = itemService.validateItemExistsAndEnable(itemId);
        MesMdItemTypeDO itemType = itemTypeService.getItemType(item.getItemTypeId());
        if (itemType == null || !MesMdItemTypeEnum.isProduct(itemType.getItemOrProduct())) {
            throw exception(PRO_MPS_PRODUCT_TYPE_INVALID);
        }
    }

    /**
     * 根据 MPS 创建生产工单
     */
    private Long createWorkOrderFromMps(MesProMpsDO mps, BigDecimal quantity) {
        // 1. 校验产品是否存在工艺路线
        MesProRouteProductDO routeProduct = routeProductService.getRouteProductByItemId(mps.getProductId());
        if (routeProduct == null) {
            throw exception(PRO_ROUTE_NOT_EXISTS);
        }
        Long routeId = routeProduct.getRouteId();

        // 2. 校验工艺路线是否有工序
        List<MesProRouteProcessDO> routeProcesses = routeProcessService.getRouteProcessListByRouteId(routeId);
        if (CollUtil.isEmpty(routeProcesses)) {
            throw exception(PRO_ROUTE_ENABLE_NO_PROCESS);
        }

        // 3. 创建生产工单
        MesProWorkOrderSaveReqVO workOrderReq = new MesProWorkOrderSaveReqVO();
        workOrderReq.setCode(generateWorkOrderCode());
        workOrderReq.setName("生产工单-" + mps.getCode());
@@ -412,7 +638,44 @@

        Long workOrderId = workOrderService.createWorkOrder(workOrderReq);

        // 工单直接确认为已确认状态（跳过草稿）
        // 4. 更新工单工艺路线
        workOrderMapper.updateById(new MesProWorkOrderDO().setId(workOrderId).setRouteId(routeId));

        // 5. 保存工单工序（从工艺路线工序带入，含投料BOM）
        Map<Long, List<MesProRouteProductBomDO>> bomMap = routeProcessService.getRouteProcessBomMapByProductId(mps.getProductId());
        List<MesProWorkOrderProcessSaveReqVO> processList = new ArrayList<>();
        for (MesProRouteProcessDO rp : routeProcesses) {
            MesProWorkOrderProcessSaveReqVO process = new MesProWorkOrderProcessSaveReqVO();
            process.setWorkOrderId(workOrderId);
            process.setProcessId(rp.getProcessId());
            process.setSort(rp.getSort());
            process.setKeyFlag(rp.getKeyFlag());
            process.setCheckFlag(rp.getCheckFlag());
            process.setBackflushFlag(rp.getBackflushFlag());
            if (rp.getOutputItemId() != null && !rp.getOutputItemId().isBlank()) {
                process.setOutputItemIds(Arrays.stream(rp.getOutputItemId().split(","))
                        .map(String::trim).filter(s -> !s.isEmpty())
                        .map(Long::valueOf).collect(Collectors.toList()));
            }
            process.setColorCode(rp.getColorCode());
            // 带入工序投料BOM
            List<MesProRouteProductBomDO> routeBomItems = bomMap != null ? bomMap.get(rp.getProcessId()) : null;
            if (CollUtil.isNotEmpty(routeBomItems)) {
                List<MesProWorkOrderProcessSaveReqVO.BomItem> bomItems = new ArrayList<>();
                for (MesProRouteProductBomDO bomDO : routeBomItems) {
                    MesProWorkOrderProcessSaveReqVO.BomItem bomItem = new MesProWorkOrderProcessSaveReqVO.BomItem();
                    bomItem.setItemId(bomDO.getItemId());
                    bomItem.setQuantity(bomDO.getQuantity());
                    bomItem.setRemark(bomDO.getRemark());
                    bomItems.add(bomItem);
                }
                process.setBomItems(bomItems);
            }
            processList.add(process);
        }
        workOrderProcessService.batchSaveWorkOrderProcess(processList);

        // 6. 工单直接确认为已确认状态
        workOrderService.confirmWorkOrder(workOrderId);

        return workOrderId;
@@ -423,11 +686,13 @@
     */
    private String generateWorkOrderCode() {
        try {
            return autoCodeRecordService.generateAutoCode("WO");
            return autoCodeRecordService.generateAutoCode(
                    MesMdAutoCodeRuleCodeEnum.PRO_WORK_ORDER_CODE.getCode());
        } catch (Exception e) {
            log.warn("[generateWorkOrderCode] 编码规则 WO 不存在，使用时间戳生成");
            log.warn("[generateWorkOrderCode] 编码规则 {} 不存在，使用时间戳生成",
                    MesMdAutoCodeRuleCodeEnum.PRO_WORK_ORDER_CODE.getCode(), e);
            return "WO" + System.currentTimeMillis();
        }
    }

}
}