package cn.iocoder.yudao.module.mes.service.pro.mps;
|
|
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.framework.security.core.util.SecurityFrameworkUtils;
|
import cn.iocoder.yudao.module.bpm.api.task.BpmProcessInstanceApi;
|
import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
|
import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceStatusEnum;
|
import cn.iocoder.yudao.module.erp.api.purchase.ErpPurchaseOrderApi;
|
import cn.iocoder.yudao.module.erp.api.purchase.ErpPurchaseRequestApi;
|
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseOrderItemRespDTO;
|
import cn.iocoder.yudao.module.erp.api.purchase.dto.ErpPurchaseRequestCreateReqDTO;
|
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.controller.admin.pro.workorder.vo.MesProWorkOrderItemRespVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.MesProWorkOrderSaveReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
|
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.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.enums.pro.MesProWorkOrderStatusEnum;
|
import cn.iocoder.yudao.module.mes.service.md.autocode.MesMdAutoCodeRecordService;
|
import cn.iocoder.yudao.module.mes.service.pro.material.MesProMaterialRequirementService;
|
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 jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
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.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
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.*;
|
|
/**
|
* MES 生产主计划（MPS）Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
@Slf4j
|
public class MesProMpsServiceImpl implements MesProMpsService {
|
|
/**
|
* MPS 编码规则
|
*/
|
private static final String MPS_CODE_RULE = "MPS";
|
|
/**
|
* MPS 审批流程定义 Key（BPM 流程模型中配置）
|
*/
|
private static final String MPS_APPROVE_PROCESS_DEFINITION_KEY = "mes-pro-mps-audit";
|
|
@Resource
|
private MesProMpsMapper mpsMapper;
|
@Resource
|
private MesProMpsMergeItemMapper mergeItemMapper;
|
@Resource
|
private MesProWorkOrderService workOrderService;
|
@Resource
|
private MesMdItemService itemService;
|
@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 MesProMaterialRequirementService materialRequirementService;
|
@Resource
|
private ErpPurchaseOrderApi purchaseOrderApi;
|
@Resource
|
private ErpPurchaseRequestApi purchaseRequestApi;
|
@Resource
|
private BpmProcessInstanceApi processInstanceApi;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createMps(Long saleOrderId, String saleOrderNo, Long saleOrderItemId,
|
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);
|
if (mesItem == null) {
|
// MES 产品不存在，抛出异常并包含产品名称提示
|
throw exception(PRO_MPS_MES_PRODUCT_NOT_EXISTS, productName != null ? productName : mdmItemId);
|
}
|
|
// 2. 生成 MPS 编码
|
String code = generateMpsCode();
|
|
// 3. 解析需求日期
|
LocalDateTime requestDateTime = null;
|
if (StrUtil.isNotBlank(requestDate)) {
|
try {
|
requestDateTime = LocalDateTime.parse(requestDate, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
|
} catch (Exception e) {
|
requestDateTime = LocalDateTime.parse(requestDate, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
}
|
}
|
|
// 4. 创建 MPS（使用 MES 产品 ID）
|
MesProMpsDO mps = new MesProMpsDO();
|
mps.setCode(code);
|
mps.setStatus(MesProMpsStatusEnum.DRAFT.getStatus());
|
mps.setSaleOrderId(saleOrderId);
|
mps.setSaleOrderNo(saleOrderNo);
|
mps.setSaleOrderItemId(saleOrderItemId);
|
mps.setProductId(mesItem.getId()); // 使用 MES 产品 ID
|
mps.setQuantity(quantity);
|
mps.setQuantityProduced(BigDecimal.ZERO);
|
mps.setUnitMeasureId(mesItem.getUnitMeasureId()); // 从 MES 产品获取计量单位
|
mps.setClientId(clientId);
|
mps.setRequestDate(requestDateTime);
|
mps.setMergeFlag(0);
|
mps.setRemark(remark);
|
|
mpsMapper.insert(mps);
|
log.info("[createMps] 创建 MPS 成功，id={}, code={}, saleOrderItemId={}, mdmItemId={}, productId={}",
|
mps.getId(), mps.getCode(), mps.getSaleOrderItemId(), mdmItemId, mesItem.getId());
|
return mps.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createMps(MesProMpsSaveReqVO createReqVO) {
|
// 校验产品存在
|
itemService.validateItemExists(createReqVO.getProductId());
|
// 计量单位未填写时，默认取产品单位
|
if (createReqVO.getUnitMeasureId() == null) {
|
MesMdItemDO product = itemService.getItem(createReqVO.getProductId());
|
if (product != null) {
|
createReqVO.setUnitMeasureId(product.getUnitMeasureId());
|
}
|
}
|
|
// 如果未填写编码，自动生成
|
if (StrUtil.isBlank(createReqVO.getCode())) {
|
createReqVO.setCode(generateMpsCode());
|
} else {
|
// 校验编码唯一
|
validateMpsCodeUnique(null, createReqVO.getCode());
|
}
|
|
// 插入
|
MesProMpsDO mps = BeanUtils.toBean(createReqVO, MesProMpsDO.class);
|
mps.setStatus(MesProMpsStatusEnum.DRAFT.getStatus());
|
mps.setQuantityProduced(BigDecimal.ZERO);
|
mps.setMergeFlag(0);
|
mpsMapper.insert(mps);
|
|
log.info("[createMps] 手动创建 MPS 成功，id={}, code={}", mps.getId(), mps.getCode());
|
return mps.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateMps(MesProMpsSaveReqVO updateReqVO) {
|
// 校验存在 + 可编辑状态（未开始、审核中）
|
MesProMpsDO mps = validateMpsExistsAndEditable(updateReqVO.getId());
|
|
// 校验编码唯一
|
validateMpsCodeUnique(updateReqVO.getId(), updateReqVO.getCode());
|
|
// 更新（仅草稿可编辑）
|
MesProMpsDO updateObj = BeanUtils.toBean(updateReqVO, MesProMpsDO.class);
|
mpsMapper.updateById(updateObj);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteMps(Long id) {
|
// 校验存在 + 可编辑状态（未开始、审核中）
|
MesProMpsDO mps = validateMpsExistsAndEditable(id);
|
|
// 校验是否已关联工单
|
if (mps.getWorkOrderId() != null) {
|
throw exception(PRO_MPS_HAS_WORK_ORDER);
|
}
|
|
// 删除
|
mpsMapper.deleteById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void submitMps(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
// 只有草稿可以提交审核；审核中的计划需等待协同办公审批结果
|
if (!MesProMpsStatusEnum.DRAFT.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_DRAFT);
|
}
|
// 全局免审批：不做 BPM 流程，直接按审批通过处理
|
if (processInstanceApi.isGlobalAutoApprove()) {
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.AUDITING.getStatus())
|
.setProcessInstanceId(""));
|
handleBpmProcessResult(id, BpmProcessInstanceStatusEnum.APPROVE.getStatus(), "全局免审批自动通过", null);
|
return;
|
}
|
// 启动 BPM 流程，审批在协同办公完成，结果由监听器回写
|
String processInstanceId;
|
try {
|
processInstanceId = processInstanceApi.createProcessInstance(SecurityFrameworkUtils.getLoginUserId(),
|
new BpmProcessInstanceCreateReqDTO()
|
.setProcessDefinitionKey(MPS_APPROVE_PROCESS_DEFINITION_KEY)
|
.setBusinessKey(String.valueOf(id)));
|
} catch (ServiceException ex) {
|
// 流程未部署时 BPM 只抛「流程定义不存在」，补上可执行的提示
|
if (StrUtil.contains(ex.getMessage(), "流程定义不存在")) {
|
log.warn("[submitMps] 生产计划审批流程({}) 未部署，mpsId={}", MPS_APPROVE_PROCESS_DEFINITION_KEY, id);
|
throw exception(PRO_MPS_PROCESS_NOT_DEPLOYED);
|
}
|
throw ex;
|
}
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.AUDITING.getStatus())
|
.setProcessInstanceId(processInstanceId));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void handleBpmProcessResult(Long id, Integer bpmResult, String reason, Long auditUserId) {
|
// 1. 柔性校验：计划存在且处于审核中
|
MesProMpsDO mps = mpsMapper.selectById(id);
|
if (mps == null) {
|
log.warn("[handleBpmProcessResult] 生产计划({}) 不存在", id);
|
return;
|
}
|
if (!MesProMpsStatusEnum.AUDITING.getStatus().equals(mps.getStatus())) {
|
log.warn("[handleBpmProcessResult] 生产计划({}) 不处于审核中状态，当前状态：{}", id, mps.getStatus());
|
return;
|
}
|
|
// 2. 根据审批结果更新状态
|
if (BpmProcessInstanceStatusEnum.APPROVE.getStatus().equals(bpmResult)) {
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.APPROVED.getStatus())
|
.setAuditUserId(auditUserId)
|
.setAuditTime(LocalDateTime.now())
|
.setAuditRemark(StrUtil.blankToDefault(reason, "审核通过")));
|
} else if (BpmProcessInstanceStatusEnum.REJECT.getStatus().equals(bpmResult)
|
|| BpmProcessInstanceStatusEnum.CANCEL.getStatus().equals(bpmResult)) {
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.DRAFT.getStatus())
|
.setAuditUserId(auditUserId)
|
.setAuditTime(LocalDateTime.now())
|
.setAuditRemark(StrUtil.blankToDefault(reason, "审批驳回")));
|
}
|
}
|
|
@Override
|
public List<MesProWorkOrderItemRespVO> getMpsItemList(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
// 按产品 BOM（优先工艺路线 BOM）展开叶子物料，并按计划数量折算需求；
|
// 计划尚未生成工单，无来源为本计划的在途采购，直接按可用库存判断是否充足
|
return materialRequirementService.getItemListByProduct(mps.getProductId(), mps.getQuantity());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long generatePurchaseRequest(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
if (!MesProMpsStatusEnum.APPROVED.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_APPROVED);
|
}
|
// 1. 物料需求为空说明产品未维护任何 BOM，直接提示，避免误报“库存充足”
|
List<MesProWorkOrderItemRespVO> materialItems = getMpsItemList(id);
|
if (CollUtil.isEmpty(materialItems)) {
|
MesMdItemDO product = itemService.getItem(mps.getProductId());
|
throw exception(PRO_MPS_NO_MATERIAL_BOM, mps.getCode(),
|
product != null ? product.getName() : String.valueOf(mps.getProductId()));
|
}
|
// 2. 只对缺口物料生成采购明细：缺口 = 需求 - 可用库存 - 在途采购
|
List<ErpPurchaseRequestCreateReqDTO.Item> shortageItems = new ArrayList<>();
|
for (MesProWorkOrderItemRespVO item : materialItems) {
|
if (Boolean.TRUE.equals(item.getStockSufficient())) {
|
continue;
|
}
|
BigDecimal supply = nullToZero(item.getStockQuantity())
|
.add(nullToZero(item.getPurchaseOrderQuantity()));
|
BigDecimal shortage = nullToZero(item.getQuantity()).subtract(supply);
|
if (shortage.compareTo(BigDecimal.ZERO) <= 0) {
|
continue;
|
}
|
MesMdItemDO itemDO = itemService.getItem(item.getItemId());
|
if (itemDO == null) {
|
continue;
|
}
|
shortageItems.add(new ErpPurchaseRequestCreateReqDTO.Item()
|
.setProductId(item.getItemId())
|
.setProductUnitId(itemDO.getUnitMeasureId())
|
.setCount(shortage)
|
.setDemandTime(mps.getRequestDate() != null ? mps.getRequestDate().toLocalDate() : null)
|
.setRemark("生产计划 " + mps.getCode() + " 库存缺口 " + shortage.stripTrailingZeros().toPlainString()));
|
}
|
if (CollUtil.isEmpty(shortageItems)) {
|
throw exception(PRO_MPS_NO_MATERIAL_SHORTAGE);
|
}
|
// 3. 生成采购申请单（草稿，无供应商，后续由采购人员补充并按流程提交）
|
ErpPurchaseRequestCreateReqDTO createReqDTO = new ErpPurchaseRequestCreateReqDTO()
|
.setRequestTime(LocalDateTime.now())
|
.setRequestReason("生产计划 " + mps.getCode() + " 辅料采购")
|
.setRemark("由生产计划自动生成，共 " + shortageItems.size() + " 项物料库存不足")
|
.setItems(shortageItems);
|
Long purchaseRequestId = purchaseRequestApi.createPurchaseRequest(createReqDTO).getCheckedData();
|
// 4. 回写采购申请单编号，便于从计划追溯
|
mpsMapper.updateById(new MesProMpsDO().setId(id).setPurchaseRequestId(purchaseRequestId));
|
log.info("[generatePurchaseRequest] 计划({}) 生成采购申请单({})，明细 {} 项", mps.getCode(), purchaseRequestId, shortageItems.size());
|
return purchaseRequestId;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long issueMps(Long id) {
|
// 校验存在 + 已审核状态
|
MesProMpsDO mps = validateMpsExistsAndApproved(id);
|
|
// 创建生产工单
|
Long workOrderId = createWorkOrderFromMps(mps, mps.getQuantity());
|
|
// 更新 MPS 状态
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.ISSUED.getStatus())
|
.setWorkOrderId(workOrderId)
|
.setIssueDate(LocalDateTime.now()));
|
|
log.info("[issueMps] MPS 下发成功，mpsId={}, workOrderId={}", id, workOrderId);
|
return workOrderId;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long mergeAndIssueMps(List<Long> mpsIds) {
|
// 校验 MPS 列表
|
if (CollUtil.isEmpty(mpsIds) || mpsIds.size() < 2) {
|
throw exception(PRO_MPS_MERGE_AT_LEAST_TWO);
|
}
|
|
List<MesProMpsDO> mpsList = mpsMapper.selectBatchIds(mpsIds);
|
if (mpsList.size() != mpsIds.size()) {
|
throw exception(PRO_MPS_NOT_EXISTS);
|
}
|
|
// 校验：必须是相同产品、已审核状态
|
Long productId = null;
|
for (MesProMpsDO mps : mpsList) {
|
if (!MesProMpsStatusEnum.APPROVED.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_APPROVED);
|
}
|
if (productId == null) {
|
productId = mps.getProductId();
|
} else if (!productId.equals(mps.getProductId())) {
|
throw exception(PRO_MPS_MERGE_PRODUCT_MISMATCH);
|
}
|
}
|
|
// 计算合并数量
|
BigDecimal totalQuantity = mpsList.stream()
|
.map(MesProMpsDO::getQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
// 取第一条 MPS 作为主记录，创建生产工单
|
MesProMpsDO firstMps = mpsList.get(0);
|
Long workOrderId = createWorkOrderFromMps(firstMps, totalQuantity);
|
|
// 生成合并批次号
|
String mergeBatchNo = generateMergeBatchNo();
|
|
// 更新所有 MPS 状态，记录合并关系
|
for (MesProMpsDO mps : mpsList) {
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(mps.getId())
|
.setStatus(MesProMpsStatusEnum.ISSUED.getStatus())
|
.setWorkOrderId(workOrderId)
|
.setMergeFlag(1)
|
.setMergeBatchNo(mergeBatchNo)
|
.setIssueDate(LocalDateTime.now()));
|
|
// 记录合并明细
|
MesProMpsMergeItemDO mergeItem = new MesProMpsMergeItemDO();
|
mergeItem.setMergeBatchNo(mergeBatchNo);
|
mergeItem.setMpsId(mps.getId());
|
mergeItem.setWorkOrderId(workOrderId);
|
mergeItem.setQuantity(mps.getQuantity());
|
mergeItemMapper.insert(mergeItem);
|
}
|
|
log.info("[mergeAndIssueMps] MPS 合并下发成功，mpsIds={}, workOrderId={}, totalQuantity={}",
|
mpsIds, workOrderId, totalQuantity);
|
return workOrderId;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void cancelMps(Long id) {
|
// 校验存在
|
MesProMpsDO mps = validateMpsExists(id);
|
|
// 校验状态：只有已下发状态才能取消
|
if (!MesProMpsStatusEnum.ISSUED.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_ISSUED);
|
}
|
|
// 级联取消关联的生产工单（跟随工单当前状态，且不误伤合并下发的共享工单）
|
if (mps.getWorkOrderId() != null) {
|
// 新增逻辑：若该工单有报工记录，则不允许取消 MPS
|
Long feedbackCount = feedbackMapper.selectCount(MesProFeedbackDO::getWorkOrderId, mps.getWorkOrderId());
|
if (feedbackCount != null && feedbackCount > 0) {
|
throw exception(PRO_MPS_WORK_ORDER_HAS_FEEDBACK);
|
}
|
|
// 1. 统计该工单被多少条 MPS 引用：合并下发的多条 MPS 共享同一个工单
|
Long refCount = mpsMapper.selectCount(MesProMpsDO::getWorkOrderId, mps.getWorkOrderId());
|
if (refCount != null && refCount > 1) {
|
// 共享工单：只取消当前 MPS，不动工单
|
log.info("[cancelMps] 生产工单({}) 被 {} 条 MPS 共用，跳过级联取消工单",
|
mps.getWorkOrderId(), refCount);
|
} else {
|
MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(mps.getWorkOrderId());
|
if (workOrder != null
|
&& MesProWorkOrderStatusEnum.CONFIRMED.getStatus().equals(workOrder.getStatus())) {
|
// 只有"已确认"状态的工单才需要级联取消
|
workOrderService.cancelWorkOrder(mps.getWorkOrderId());
|
log.info("[cancelMps] 级联取消生产工单，workOrderId={}", mps.getWorkOrderId());
|
} else {
|
// 工单已是草稿/已完成/已取消，无需级联取消，直接取消 MPS
|
log.info("[cancelMps] 生产工单({}) 状态为 {}，无需级联取消",
|
mps.getWorkOrderId(), workOrder != null ? workOrder.getStatus() : "null");
|
}
|
}
|
}
|
|
// 更新 MPS 状态
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.CANCELED.getStatus()));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void finishMps(Long id) {
|
// 校验存在
|
MesProMpsDO mps = validateMpsExists(id);
|
|
// 校验状态：只有已下发状态才能完成
|
if (!MesProMpsStatusEnum.ISSUED.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_ISSUED);
|
}
|
|
// 更新状态
|
mpsMapper.updateById(new MesProMpsDO()
|
.setId(id)
|
.setStatus(MesProMpsStatusEnum.FINISHED.getStatus())
|
.setFinishDate(LocalDateTime.now()));
|
}
|
|
@Override
|
public MesProMpsDO getMpsBySaleOrderItemId(Long saleOrderItemId) {
|
return mpsMapper.selectBySaleOrderItemId(saleOrderItemId);
|
}
|
|
@Override
|
public MesProMpsDO getMps(Long id) {
|
return mpsMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<MesProMpsDO> getMpsPage(MesProMpsPageReqVO pageReqVO) {
|
return mpsMapper.selectPage(pageReqVO, (List<Long>) null);
|
}
|
|
@Override
|
public List<MesProMpsDO> getMpsList(Collection<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return Collections.emptyList();
|
}
|
return mpsMapper.selectBatchIds(ids);
|
}
|
|
@Override
|
public List<MesProMpsDO> getMpsListBySaleOrderItemIds(Collection<Long> saleOrderItemIds) {
|
return mpsMapper.selectListBySaleOrderItemIds(saleOrderItemIds);
|
}
|
|
@Override
|
public List<MesProMpsDO> getMergeableMpsList(Long productId) {
|
return mpsMapper.selectMergeableList(productId);
|
}
|
|
@Override
|
public void updateProducedQuantity(Long id, BigDecimal incrQuantity) {
|
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;
|
}
|
|
/**
|
* 判断单个 MPS 是否完成
|
*/
|
private boolean isMpsFinished(MesProMpsDO mps) {
|
// 已取消的 MPS 视为终态，不再阻塞生产完成判断（与 checkCanCreateSalesNotice 的口径保持一致）
|
if (MesProMpsStatusEnum.CANCELED.getStatus().equals(mps.getStatus())) {
|
return true;
|
}
|
// 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;
|
}
|
|
// ========== 私有方法 ==========
|
|
/**
|
* 生成 MPS 编码
|
*/
|
private String generateMpsCode() {
|
try {
|
return autoCodeRecordService.generateAutoCode(MPS_CODE_RULE);
|
} catch (Exception e) {
|
// 如果编码规则不存在，使用时间戳生成
|
log.warn("[generateMpsCode] 编码规则 {} 不存在，使用时间戳生成", MPS_CODE_RULE);
|
return "MPS" + System.currentTimeMillis();
|
}
|
}
|
|
/**
|
* 生成合并批次号
|
*/
|
private String generateMergeBatchNo() {
|
return "MERGE" + System.currentTimeMillis();
|
}
|
|
/**
|
* 校验 MPS 存在
|
*/
|
private MesProMpsDO validateMpsExists(Long id) {
|
MesProMpsDO mps = mpsMapper.selectById(id);
|
if (mps == null) {
|
throw exception(PRO_MPS_NOT_EXISTS);
|
}
|
return mps;
|
}
|
|
/**
|
* 校验 MPS 存在 + 草稿状态
|
*/
|
private MesProMpsDO validateMpsExistsAndDraft(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
if (!MesProMpsStatusEnum.DRAFT.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_DRAFT);
|
}
|
return mps;
|
}
|
|
/**
|
* 校验 MPS 存在 + 已审核状态
|
*/
|
private MesProMpsDO validateMpsExistsAndApproved(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
if (!MesProMpsStatusEnum.APPROVED.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_APPROVED);
|
}
|
return mps;
|
}
|
|
/**
|
* 校验 MPS 存在 + 可编辑状态（仅草稿；审核中的计划需等待协同办公审批）
|
*/
|
private MesProMpsDO validateMpsExistsAndEditable(Long id) {
|
MesProMpsDO mps = validateMpsExists(id);
|
if (!MesProMpsStatusEnum.DRAFT.getStatus().equals(mps.getStatus())) {
|
throw exception(PRO_MPS_NOT_DRAFT);
|
}
|
return mps;
|
}
|
|
private static BigDecimal nullToZero(BigDecimal value) {
|
return value != null ? value : BigDecimal.ZERO;
|
}
|
|
/**
|
* 校验 MPS 编码唯一
|
*/
|
private void validateMpsCodeUnique(Long id, String code) {
|
if (StrUtil.isBlank(code)) {
|
return;
|
}
|
MesProMpsDO mps = mpsMapper.selectByCode(code);
|
if (mps == null) {
|
return;
|
}
|
if (id == null) {
|
throw exception(PRO_MPS_CODE_DUPLICATE);
|
}
|
if (!id.equals(mps.getId())) {
|
throw exception(PRO_MPS_CODE_DUPLICATE);
|
}
|
}
|
|
/**
|
* 根据 MPS 创建生产工单
|
*/
|
private Long createWorkOrderFromMps(MesProMpsDO mps, BigDecimal quantity) {
|
// 1. 查找产品工艺路线；未配置时不阻断，按单工序生产处理
|
MesProRouteProductDO routeProduct = routeProductService.getRouteProductByItemId(mps.getProductId());
|
Long routeId = routeProduct != null ? routeProduct.getRouteId() : null;
|
List<MesProRouteProcessDO> routeProcesses = routeProduct != null
|
? routeProcessService.getRouteProcessListByProductId(mps.getProductId())
|
: Collections.emptyList();
|
|
// 3. 创建生产工单
|
MesProWorkOrderSaveReqVO workOrderReq = new MesProWorkOrderSaveReqVO();
|
workOrderReq.setCode(generateWorkOrderCode());
|
workOrderReq.setName("生产工单-" + mps.getCode());
|
workOrderReq.setType(1); // 自行生产
|
workOrderReq.setOrderSourceType(MesProWorkOrderSourceTypeEnum.ORDER.getType());
|
workOrderReq.setOrderSourceCode(mps.getSaleOrderNo());
|
workOrderReq.setProductId(mps.getProductId());
|
workOrderReq.setQuantity(quantity);
|
workOrderReq.setClientId(mps.getClientId());
|
workOrderReq.setRequestDate(mps.getRequestDate() != null ? mps.getRequestDate() : LocalDateTime.now());
|
workOrderReq.setRemark("来自 MPS: " + mps.getCode());
|
|
Long workOrderId = workOrderService.createWorkOrder(workOrderReq);
|
|
// 4. 更新工单工艺路线（未配置路线时保持为空，按单工序生产）
|
if (routeId != null) {
|
workOrderMapper.updateById(new MesProWorkOrderDO().setId(workOrderId).setRouteId(routeId));
|
}
|
|
// 5. 保存工单工序（仅配置了工艺路线工序时带入，含投料BOM）
|
if (CollUtil.isNotEmpty(routeProcesses)) {
|
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());
|
// 带入工艺路线产品配置的报工仓库
|
process.setWarehouseId(routeProduct.getWarehouseId());
|
process.setLocationId(routeProduct.getLocationId());
|
process.setAreaId(routeProduct.getAreaId());
|
// 带入工序投料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;
|
}
|
|
/**
|
* 生成生产工单编码
|
*/
|
private String generateWorkOrderCode() {
|
try {
|
return autoCodeRecordService.generateAutoCode("WO");
|
} catch (Exception e) {
|
log.warn("[generateWorkOrderCode] 编码规则 WO 不存在，使用时间戳生成");
|
return "WO" + System.currentTimeMillis();
|
}
|
}
|
|
}
|
