aps-坯料计划增加行按钮领料功能

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/dao/ApsBlankOrderDao.java

@@ -132,4 +132,8 @@ public interface ApsBlankOrderDao extends BaseMapper<ApsBlankOrderDo> {
     List<UpdateBlankDeliveryDateVo> getBlankDeliveryDate(@Param("blankId") String blankId);
 
     IPage<ProductPlanReportVo> selectPageReport(Page<ProductPlanReportVo> queryPage, @Param("param") ProductPlanReportParamVo param);
+
+    @Select("select count(1) from aps_work_in_progress_inventory where DELETED = 0 AND (BLANKBATCHNUMBER =  #{batchNumber} OR BLANKBATCHNUMBER like CONCAT(#{batchNumber},'-%') OR #{batchNumber} like CONCAT(BLANKBATCHNUMBER,'-%'))")
+    Integer selectCountWorkIn(@Param("batchNumber") String batchNumber);
+
 }

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/service/ApsBlankOrderService.java

@@ -62,4 +62,6 @@ public interface ApsBlankOrderService extends IService<ApsBlankOrderDo> {
     void insertSchedule(Map<String, Object> params);
 
     R addMaterial(AddMaterialReq req);
+
+    R checkAddMaterial(AddMaterialReq req);
 }

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/service/impl/ApsBlankOrderServiceImpl.java

@@ -2718,7 +2718,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
         logger.debug("开始更新坯料计划：{}对应的交货期没", apsBlankOrderDo.getId());
         List<UpdateBlankDeliveryDateVo> blankDeliveryDate = this.getBaseMapper().getBlankDeliveryDate(apsBlankOrderDo.getId());
-        logger.debug("获取当前坯料计划的相关的计划完工时间:{}",blankDeliveryDate);
+        logger.debug("获取当前坯料计划的相关的计划完工时间:{}", blankDeliveryDate);
         if (blankDeliveryDate.isEmpty()) {
             return;
         }
@@ -2746,7 +2746,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 .set(ApsBlankOrderDo::getScheduledateend, endDate)
                 .set(ApsBlankOrderDo::getPromisedatestart, newStartDate)
                 .set(ApsBlankOrderDo::getPromisedateend, newEndDate));
-        logger.debug("坯料计划新的承诺交货日期：{}-{},旧的为{}-{}", newStartDate,newEndDate,
+        logger.debug("坯料计划新的承诺交货日期：{}-{},旧的为{}-{}", newStartDate, newEndDate,
                 apsBlankOrderDo.getPromisedatestart(), apsBlankOrderDo.getPromisedateend());
 
 
@@ -2754,12 +2754,12 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         List<String> removeIds = new ArrayList<>();
         if (startDate.compareTo(newStartDate) > 0) {
             updateIds.add(blankDeliveryDate.get(0).getId());
-        }else{
+        } else {
             removeIds.add(blankDeliveryDate.get(0).getId());
         }
         if (endDate.compareTo(newEndDate) > 0) {
             updateIds.add(blankDeliveryDate.get(1).getId());
-        }else{
+        } else {
             removeIds.add(blankDeliveryDate.get(1).getId());
         }
 
@@ -2778,7 +2778,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 apsProcessOperationProcessEquService.updateBatchById(equDos);
             }
         }
-        if(!removeIds.isEmpty()){
+        if (!removeIds.isEmpty()) {
             List<ApsProcessOperationProcessEquDo> equDos = apsProcessOperationProcessEquService.getBaseMapper().selectBatchIds(removeIds);
             logger.debug("记录冲突信息超出承诺交货期:{}", equDos);
             equDos.forEach(data -> {
@@ -3029,6 +3029,177 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         List<String> batchNumberList = new LinkedList<>();
 //        if (ObjectUtil.isEmpty(req.getBatchNumbers())) {
 //            return R.error("批次号不可为空");
+//        }
+        if (ObjectUtil.isEmpty(req.getBlankId())) {
+            return R.error("坯料计划ID为空");
+        }
+        if (ObjectUtil.isEmpty(req.getProcessId())) {
+            return R.error("坯料计划第一道工序作业的ID为空");
+        }
+        if (ObjectUtil.isNotEmpty(req.getBatchNumbers())) {
+            batchNumberList = new LinkedList<>(Arrays.asList(req.getBatchNumbers().split(",")));
+        }
+        //查询坯料计划第一道工序作业的详情
+        ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(req.getProcessId());
+        int needStartRoll = apsProcessOperationDo.getPlanprocessrall() - apsProcessOperationDo.getStartingroll() - apsProcessOperationDo.getCancelroll();
+        if (batchNumberList.size() > needStartRoll) {
+            return R.error("领料数量不能大于计划加工卷数-已开工卷数-已取消卷数=" + needStartRoll);
+        }
+
+        //原来的批次号
+        String oldBatchNumbers = req.getOldBatchNumbers();
+        LinkedList<String> oldBatchNumberList = new LinkedList<>();
+        if (ObjectUtil.isNotEmpty(oldBatchNumbers)) {
+            oldBatchNumberList = new LinkedList<>(Arrays.asList(oldBatchNumbers.split(",")));
+        }
+
+        //新的批次号集合
+        List<String> addBatchNumberList = new LinkedList<>();
+        //删除的批次号集合
+        List<String> delBatchNumberList = new LinkedList<>();
+
+        for (String s : oldBatchNumberList) {
+            if (!batchNumberList.contains(s)) {
+                delBatchNumberList.add(s);
+            }
+        }
+        for (String s : batchNumberList) {
+            if (!oldBatchNumberList.contains(s)) {
+                addBatchNumberList.add(s);
+            }
+        }
+
+//        //如果批次号有重复，则错误提示：批次号{批次号}重复
+//        for (String item : batchNumberList) {
+//            if (batchNumberList.stream().filter(i -> i.equals(item)).count() > 1) {
+//                return R.error("批次号" + item + "重复");
+//            }
+//        }
+//
+//
+////        //如果批次号不是9位数，则错误提示：热轧坯料批次号{批次号}错误，应该是9位
+////
+////        for (String s : batchNumberList) {
+////            if (s.length() != 9) {
+////                return R.error("热轧坯料批次号" + s + "错误，应该是9位");
+////            }
+////        }
+//        List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
+//        if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
+//            //查询新增的批次号
+//            workInProgressInventoryDos =
+//                    apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
+//                            .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+//                            .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+//        }
+//
+////        //如果坯料类型=热轧，检查每个批次号
+////        if (apsBlankOrderDo.getBlanktype().equals("热轧")) {
+////            for (String s : addBatchNumberList) {
+////                //如果该批次号物料在制品库存中存在，则错误提示：批次号{批次号}错误
+////                ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(s)).findFirst().orElse(null);
+////                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo)) {
+////                    return R.error("批次号" + s + "错误");
+////                }
+////            }
+////        }
+//
+//        /**
+//         * 如果该批次号物料在制品库存中存在
+//         * 如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+//         * 如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+//         * 如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+//         * 如果在制品状态=备料中，并且在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+//         * 查找该批次号物料=在制品的作业输出物料ID对应输出物料
+//         * 如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
+//         * 错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+//         */
+//
+//        for (String s : addBatchNumberList) {
+//            //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
+//            ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(s)).findFirst().orElse(null);
+//            if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
+//                continue;
+//            }
+//
+//            //如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+//            if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getPlanmaterialid())
+//                    && !apsWorkInProgressInventoryDo.getPlanmaterialid().equals(req.getBlankId())) {
+//                ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getById(apsWorkInProgressInventoryDo.getPlanmaterialid());
+//                return R.error("该坯料已经被坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+//            }
+//
+////            //如果在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+////            if (apsWorkInProgressInventoryDo.getWorkinprocesstype().equals("不良在制品")) {
+////                return R.error("批次号" + s + "错误，该料卷检验不合格");
+////            }
+//
+//            //如果在制品状态=加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+//            if (Arrays.asList("加工中", "待检验").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+//                return R.error("批次号" + s + "错误，该料卷在加工中");
+//            }
+//
+//            //如果在制品状态=待入库或已入库或已出库，并且在制品的订单号对应订单的订单类型=客户订单，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+//            if (Arrays.asList("待入库", "已入库", "已出库").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+//                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getOrdertype()) && apsWorkInProgressInventoryDo.getOrdertype().equals("客户订单")) {
+//                    return R.error("批次号" + s + "错误，该料卷是其他客户订单的成品");
+//                }
+//
+//            }
+//
+//            //查找该批次号物料=在制品的作业输出物料ID对应输出物料
+//            //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，或者坯料类型不等于坯料计划的坯料类型
+//            //错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+//            String s1 = apsWorkInProgressInventoryDo.getJoboutputmaterial();
+//            String s2 = apsBlankOrderDo.getInputreportdescribe();
+//            if (!s1.equals(s2)) {
+//                return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料" + s2 + "");
+//            }
+//        }
+
+
+        /**
+         * 检验通过，
+         * 原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
+         * 更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
+         * 在制品的在制品状态=待加工
+         * 在制品的备料计划ID=该坯料计划ID
+         */
+        //原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
+        if (ObjectUtil.isNotEmpty(delBatchNumberList)) {
+            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                    .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, null)
+                    .setSql("WORKINPROCESSSTATUS = REMARK")
+                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                    .in(ApsWorkInProgressInventoryDo::getBatchnumber, delBatchNumberList));
+        }
+
+        //更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
+        apsProcessOperationProcessEquService.update(new UpdateWrapper<ApsProcessOperationProcessEquDo>().lambda()
+                .set(ApsProcessOperationProcessEquDo::getBachmaterialprocess, String.join(",", batchNumberList))
+                .eq(ApsProcessOperationProcessEquDo::getDeleted, "0")
+                .eq(ApsProcessOperationProcessEquDo::getProcessid, req.getProcessId()));
+
+        //在制品的在制品状态=待加工
+        //在制品的备料计划ID=该坯料计划ID
+        if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
+            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                    .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, req.getBlankId())
+                    .setSql("REMARK = WORKINPROCESSSTATUS")
+                    .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "待加工")
+                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                    .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+        }
+
+        return R.ok();
+    }
+
+    @Override
+    public R checkAddMaterial(AddMaterialReq req) {
+        //分割批次号
+        List<String> batchNumberList = new LinkedList<>();
+//        if (ObjectUtil.isEmpty(req.getBatchNumbers())) {
+//            return R.error("批次号不可为空");
 //        }
         if (ObjectUtil.isEmpty(req.getBlankId())) {
             return R.error("坯料计划ID为空");
@@ -3079,13 +3250,6 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
 
 
-        //如果批次号不是9位数，则错误提示：热轧坯料批次号{批次号}错误，应该是9位
-
-        for (String s : batchNumberList) {
-            if (s.length() != 9) {
-                return R.error("热轧坯料批次号" + s + "错误，应该是9位");
-            }
-        }
         List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
         if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
             //查询新增的批次号
@@ -3095,19 +3259,14 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                             .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
         }
 
-        //如果坯料类型=热轧，检查每个批次号
-        if (apsBlankOrderDo.getBlanktype().equals("热轧")) {
-            for (String s : addBatchNumberList) {
-                //如果该批次号物料在制品库存中存在，则错误提示：批次号{批次号}错误
-                ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(s)).findFirst().orElse(null);
-                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo)) {
-                    return R.error("批次号" + s + "错误");
-                }
-            }
-        }
+
+        //线下批次号
+        List<String> offLineBatchNumberList = new LinkedList<>();
+        //线上批次号 卷重不同集合
+        List<String> onLineBatchNumberWarnList = new LinkedList<>();
 
         /**
-         * 如果坯料类型=铸轧，按以下步骤检查新增的每个批次号，如果该批次号物料在制品库存中存在
+         * 如果该批次号物料在制品库存中存在
          * 如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
          * 如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
          * 如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
@@ -3116,84 +3275,88 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
          * 如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
          * 错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
          */
-        //如果坯料类型=铸轧，检查每个批次号
-        if (apsBlankOrderDo.getBlanktype().equals("铸轧")) {
-            for (String s : addBatchNumberList) {
-                //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
-                ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(s)).findFirst().orElse(null);
-                if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
-                    continue;
-                }
 
-                //如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
-                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getPlanmaterialid())
-                        && !apsWorkInProgressInventoryDo.getPlanmaterialid().equals(req.getBlankId())) {
-                    ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getById(apsWorkInProgressInventoryDo.getPlanmaterialid());
-                    return R.error("该坯料已经被坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+        for (String s : addBatchNumberList) {
+            String addBatchNumber = s;
+            //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
+            ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(addBatchNumber)).findFirst().orElse(null);
+            if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
+                /**
+                 * 如果该批次号没有对应在制品库存，表示线下批次号，
+                 * 如果批次号没有前缀*，则加上前缀*
+                 * 如果有在制品库存的坯料批次号包含{该批次号+“-”}或{该批次号+“-”}包含在制品库存的坯料批次号+“-”，
+                 * 则错误提示：线下批次号{批次号1，批次号2}与其他线下批次号重复
+                 * 提示确认：{批次号1，批次号2}是线下批次号，确认领料吗？
+                 */
+                if (!s.startsWith("*")) {
+                    s = "*" + s;
                 }
 
-                //如果在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
-                if (apsWorkInProgressInventoryDo.getWorkinprocesstype().equals("不良在制品")) {
-                    return R.error("批次号" + s + "错误，该料卷检验不合格");
+                Integer count = this.baseMapper.selectCountWorkIn(s);
+                if (count > 0) {
+                    return R.error("线下批次号" + s + "与其他线下批次号重复");
                 }
 
-                //如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
-                if (Arrays.asList("待加工", "加工中", "待检验").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
-                    return R.error("批次号" + s + "错误，该料卷在加工中");
-                }
 
-                //如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
-                if (Arrays.asList("待入库", "已入库", "已出库").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
-                    if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getOrdertype()) && apsWorkInProgressInventoryDo.getOrdertype().equals("客户订单")) {
-                        return R.error("批次号" + s + "错误，该料卷是其他客户订单的成品");
-                    }
+                offLineBatchNumberList.add(s);
+                continue;
+            }
 
-                }
+            //如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+            if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getPlanmaterialid())
+                    && !apsWorkInProgressInventoryDo.getPlanmaterialid().equals(req.getBlankId())) {
+                ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getById(apsWorkInProgressInventoryDo.getPlanmaterialid());
+                return R.error("该坯料已经被坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+            }
+
+//            //如果在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+//            if (apsWorkInProgressInventoryDo.getWorkinprocesstype().equals("不良在制品")) {
+//                return R.error("批次号" + s + "错误，该料卷检验不合格");
+//            }
+
+            //如果在制品状态=加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+            if (Arrays.asList("加工中", "待检验").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+                return R.error("批次号" + s + "错误，该料卷在加工中");
+            }
 
-                //查找该批次号物料=在制品的作业输出物料ID对应输出物料
-                //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
-                //错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
-                String s1 = apsWorkInProgressInventoryDo.getJoboutputmaterial();
-                String s2 = apsBlankOrderDo.getInputreportdescribe();
-                if (!s1.equals(s2)) {
-                    return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料" + s2 + "");
+            //如果在制品状态=待入库或已入库或已出库，并且在制品的订单号对应订单的订单类型=客户订单，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+            if (Arrays.asList("待入库", "已入库", "已出库").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getOrdertype()) && apsWorkInProgressInventoryDo.getOrdertype().equals("客户订单")) {
+                    return R.error("批次号" + s + "错误，该料卷是其他客户订单的成品");
                 }
+
             }
-        }
 
-        /**
-         * 检验通过，
-         * 原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
-         * 更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
-         * 在制品的在制品状态=待加工
-         * 在制品的备料计划ID=该坯料计划ID
-         */
-        //原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
-        if (ObjectUtil.isNotEmpty(delBatchNumberList)) {
-            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
-                    .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, null)
-                    .setSql("WORKINPROCESSSTATUS = REMARK")
-                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
-                    .in(ApsWorkInProgressInventoryDo::getBatchnumber, delBatchNumberList));
-        }
+            //查找该批次号物料=在制品的作业输出物料ID对应输出物料
+            //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，或者坯料类型不等于坯料计划的坯料类型
+            //错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+            String s1 = apsWorkInProgressInventoryDo.getJoboutputmaterial();
+            String s2 = apsBlankOrderDo.getInputreportdescribe();
+            if (!s1.equals(s2)) {
+                return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料" + s2 + "");
+            }
 
-        //更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
-        apsProcessOperationProcessEquService.update(new UpdateWrapper<ApsProcessOperationProcessEquDo>().lambda()
-                .set(ApsProcessOperationProcessEquDo::getBachmaterialprocess, String.join(",", batchNumberList))
-                .eq(ApsProcessOperationProcessEquDo::getDeleted, "0")
-                .eq(ApsProcessOperationProcessEquDo::getProcessid, req.getProcessId()));
+            //如果在制品的坯料类型不等于坯料计划的坯料类型，
+            // 则错误提示：该批次号{批次号}物料：{在制品的作业输出物料}不是该坯料计划所需的坯料类型
+            if (!apsWorkInProgressInventoryDo.getBlanktype().equals(apsBlankOrderDo.getBlanktype())) {
+                return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料类型");
+            }
 
-        //在制品的在制品状态=待加工
-        //在制品的备料计划ID=该坯料计划ID
-        if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
-            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
-                    .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, req.getBlankId())
-                    .setSql("REMARK = WORKINPROCESSSTATUS")
-                    .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "待加工")
-                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
-                    .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+            //如果在制品的计划输出卷重不等于坯料的卷重，
+            // 提示确认：批次号{批次号1，批次号2}物料卷重与坯料需求的卷重不同，确认领料吗？
+            if (!apsWorkInProgressInventoryDo.getPlansinglerollweight().equals(apsBlankOrderDo.getSinglerollweight())) {
+                onLineBatchNumberWarnList.add(s);
+            }
         }
 
-        return R.ok();
+        String res = "";
+        if (ObjectUtil.isNotEmpty(offLineBatchNumberList)) {
+            res = "<b>" + String.join(",", offLineBatchNumberList) + "是线下批次号，确认领料吗？</b><br>";
+        }
+        if (ObjectUtil.isNotEmpty(onLineBatchNumberWarnList)) {
+            res = res + "<b>批次号" + String.join(",", onLineBatchNumberWarnList) + "物料卷重与坯料需求的卷重不同，确认领料吗？</b>";
+        }
+
+        return R.ok(res);
     }
 }

cx-aps/cx-aps-entity/src/main/java/com/rongwei/bsentity/domain/ApsWorkInProgressInventoryDo.java

@@ -7,6 +7,7 @@ import com.rongwei.rwcommon.base.BaseDo;
 import lombok.Data;
 
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.util.Date;
 
 /**
@@ -163,6 +164,16 @@ public class ApsWorkInProgressInventoryDo extends BaseDo implements Serializable
      */
     private String joboutputmaterial;
 
+    /**
+     * 计划输出卷重
+     */
+    private BigDecimal plansinglerollweight;
+
+    /**
+     * 实测卷重
+     */
+    private BigDecimal actualsinglerollweight;
+
     @TableField(exist = false)
     private static final long serialVersionUID = 1L;
 }

cx-aps/cx-aps-server/src/main/java/com/rongwei/bsserver/controller/ApsBlankOrderController.java

@@ -206,5 +206,14 @@ public class ApsBlankOrderController {
         log.info("领料 入参：{}", req);
         return apsBlankOrderService.addMaterial(req);
     }
+
+    /**
+     * 领料校验
+     */
+    @PostMapping("/checkAddMaterial")
+    public R checkAddMaterial(@RequestBody AddMaterialReq req){
+        log.info("领料校验 入参：{}", req);
+        return apsBlankOrderService.checkAddMaterial(req);
+    }
 }