Merge remote-tracking branch 'origin/mode-min-unit' into mode-min-unit

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/dao/ApsProcessOperationProcessEquDao.java

@@ -79,7 +79,8 @@ public interface ApsProcessOperationProcessEquDao extends BaseMapper<ApsProcessO
 
     void publishCancel(@Param("productIdList") List<String> productIdList);
 
-    List<OptionalEquipmentVo> getOptionalEquipmentById(@Param("idList")List<String> id);
+    List<OptionalEquipmentVo> getOptionalEquipmentById(@Param("idList")List<String> id,
+                                                       @Param("factoryId") String factoryId);
 
     List<String> checkConflict(@Param("checkConflictVos") List<CheckConflictVo> checkConflictVos);
 

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 = IF(REMARK = '待加工','备料中',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() + "领料");
+            }
 
-                //查找该批次号物料=在制品的作业输出物料ID对应输出物料
-                //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
-                //错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
-                String s1 = apsWorkInProgressInventoryDo.getJoboutputmaterial();
-                String s2 = apsBlankOrderDo.getInputreportdescribe();
-                if (!s1.equals(s2)) {
-                    return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料" + s2 + "");
+//            //如果在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+//            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=(空)
-         * 更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
-         * 在制品的在制品状态=待加工
-         * 在制品的备料计划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-common/src/main/java/com/rongwei/bscommon/sys/service/impl/ApsProcessOperationProcessEquServiceImpl.java

@@ -507,6 +507,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
      */
     @Override
     public R getOptionalEquipment(List<String> operationJobDetailsId) {
+        String currentUserFactoryId = CXCommonUtils.getCurrentUserFactoryId(null);
         if (operationJobDetailsId.isEmpty()) {
             log.error("工序作业明细必选");
             return R.error("工序作业明细必选");
@@ -514,7 +515,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         log.debug("根据工序作业明细：{},获取可选设备", operationJobDetailsId);
         // 防止工序作业ID重复
         operationJobDetailsId = operationJobDetailsId.stream().distinct().filter(StringUtils::isNotBlank).collect(Collectors.toList());
-        List<OptionalEquipmentVo> optionalEquipment = this.baseMapper.getOptionalEquipmentById(null);
+        List<OptionalEquipmentVo> optionalEquipment = this.baseMapper.getOptionalEquipmentById(null,currentUserFactoryId);
         if (optionalEquipment.isEmpty()) {
             log.error("当前所选作业不存在共同的加工设备");
             return R.error("没有可共用的加工设备,无法合并换线");

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

@@ -491,93 +491,99 @@ public class ApsProductDetailServiceImpl extends ServiceImpl<ApsProductDetailDao
             //产品明细变更
             ApsProductDetailDo apsProductDetailDo = nowUpdateList.get(0);
 
-            //复制新的产品明细
-            apsProductDetailDo.setId(SecurityUtil.getUUID());
-            updateOrInsertDetailList.add(apsProductDetailDo);
-
-            //====================更新坯料计划及其输出成品===========================
-            //检查订单产品明细对应的所有相关的坯料计划的输出成品，
-            //如果订单产品明细的订单产品字段值不等于坯料计划输出成品的订单产品字段值，
-            //则订单产品明细ID=（新ID），更新订单产品明细的坯料计划输出总重量=0
-            //查询当前产品明细ID对应的坯料计划输出成品
-            List<ApsProcessOutputProductAndBlankStatusVo> apsProcessOutputProductAndBlankStatusVoList = this.baseMapper.selectAboutBlankOutputByDetailId(nowId);
-            //筛选其中待排程和待发布的坯料计划的输出成品
-            List<ApsProcessOutputProductAndBlankStatusVo> needUpdateOutputList = apsProcessOutputProductAndBlankStatusVoList.stream().filter(item ->
-                    ObjectUtil.isNotEmpty(item.getBlankStatus())
-                            //坯料计划的生产状态为 待排程或待发布
-                            && Integer.parseInt(item.getBlankStatus()) <= Integer.parseInt(SaveConstans.ProductionStatus.TO_BE_PUBLISHED)).collect(Collectors.toList());
-            if (apsProcessOutputProductAndBlankStatusVoList.size() > 0) {
-                Set<String> needUpdateBlankIds = new HashSet<>();
-                for (ApsProcessOutputProductAndBlankStatusVo vo : needUpdateOutputList) {
-                    if (!vo.getProductname().equals(apsProductDetailDo.getInputmaterialdescription())) {
-                        //变更产品明细对应的输出成品
-                        ApsProcessOutputProductDo apsProcessOutputProductDo = new ApsProcessOutputProductDo();
-                        apsProcessOutputProductDo.setId(vo.getId());
-                        apsProcessOutputProductDo.setAlloy(apsProductDetailDo.getAlloy());
-                        apsProcessOutputProductDo.setAlloystatus(apsProductDetailDo.getAlloystatus());
-                        apsProcessOutputProductDo.setThickness(apsProductDetailDo.getThickness());
-                        apsProcessOutputProductDo.setProwidth(apsProductDetailDo.getProwidth());
-                        apsProcessOutputProductDo.setProlength(apsProductDetailDo.getProlength());
-                        apsProcessOutputProductDo.setRollweightrequirement(apsProductDetailDo.getRollweightrequirement());
-                        apsProcessOutputProductDo.setRolldiameterrequirement(apsProductDetailDo.getRolldiameterrequirement());
-                        apsProcessOutputProductDo.setRollnumberrequirement(apsProductDetailDo.getRollnumberrequirement());
-                        apsProcessOutputProductDo.setProductname(apsProductDetailDo.getInputmaterialdescription());
-                        apsProcessOutputProductDo.setProductid(apsProductDetailDo.getId());
-                        String alloy = apsProcessOutputProductDo.getAlloy();
-                        String alloyStatus = apsProcessOutputProductDo.getAlloystatus();
-                        String productType = vo.getProducttype();
-                        if (ObjectUtil.isNotEmpty(vo.getChangealloy())) {
-                            alloy = vo.getChangealloy();
-                        }
-                        if (ObjectUtil.isNotEmpty(vo.getChangealloystatus())) {
-                            alloyStatus = vo.getChangealloystatus();
-                        }
-                        if (ObjectUtil.isNotEmpty(vo.getChangeproducttype())) {
-                            productType = vo.getChangeproducttype();
-                        }
+            ApsProductDetailDo oldProductDetail = this.getById(apsProductDetailDo.getId());
 
-                        //拼接输出成品的输出物料类型字段
-                        apsProcessOutputProductDo.setOutmatertype(alloy + productType + apsProcessOutputProductDo.getThickness());
-                        //拼接输出成品的输出物料规格字段
-                        apsProcessOutputProductDo.setOutmaterspecification(alloy + alloyStatus + productType + " " + apsProcessOutputProductDo.getProductname().split(" ")[1]);
-                        //拼接输出成品的输出成品字段
-                        apsProcessOutputProductDo.setOutputresult(apsProcessOutputProductDo.getOutmaterspecification() + " " + CXCommonUtils.removeExtraZerosAndDecimal(vo.getOutputonerollweigth()) + "吨 * " + vo.getPlanoutputorderroll() + "卷");
+            //如果订单产品明细的订单产品字段值改变了
+            if (!oldProductDetail.getInputmaterialdescription().equals(apsProductDetailDo.getInputmaterialdescription())) {
 
-                        apsProcessOutputProductService.updateById(apsProcessOutputProductDo);
-                        needUpdateBlankIds.add(vo.getBlankId());
+                //复制新的产品明细
+                apsProductDetailDo.setId(SecurityUtil.getUUID());
+                updateOrInsertDetailList.add(apsProductDetailDo);
+
+                //====================更新坯料计划及其输出成品===========================
+                //检查订单产品明细对应的所有相关的坯料计划的输出成品，
+                //如果订单产品明细的订单产品字段值不等于坯料计划输出成品的订单产品字段值，
+                //则订单产品明细ID=（新ID），更新订单产品明细的坯料计划输出总重量=0
+                //查询当前产品明细ID对应的坯料计划输出成品
+                List<ApsProcessOutputProductAndBlankStatusVo> apsProcessOutputProductAndBlankStatusVoList = this.baseMapper.selectAboutBlankOutputByDetailId(nowId);
+                //筛选其中待排程和待发布的坯料计划的输出成品
+                List<ApsProcessOutputProductAndBlankStatusVo> needUpdateOutputList = apsProcessOutputProductAndBlankStatusVoList.stream().filter(item ->
+                        ObjectUtil.isNotEmpty(item.getBlankStatus())
+                                //坯料计划的生产状态为 待排程或待发布
+                                && Integer.parseInt(item.getBlankStatus()) <= Integer.parseInt(SaveConstans.ProductionStatus.TO_BE_PUBLISHED)).collect(Collectors.toList());
+                if (apsProcessOutputProductAndBlankStatusVoList.size() > 0) {
+                    Set<String> needUpdateBlankIds = new HashSet<>();
+                    for (ApsProcessOutputProductAndBlankStatusVo vo : needUpdateOutputList) {
+                        if (!vo.getProductname().equals(apsProductDetailDo.getInputmaterialdescription())) {
+                            //变更产品明细对应的输出成品
+                            ApsProcessOutputProductDo apsProcessOutputProductDo = new ApsProcessOutputProductDo();
+                            apsProcessOutputProductDo.setId(vo.getId());
+                            apsProcessOutputProductDo.setAlloy(apsProductDetailDo.getAlloy());
+                            apsProcessOutputProductDo.setAlloystatus(apsProductDetailDo.getAlloystatus());
+                            apsProcessOutputProductDo.setThickness(apsProductDetailDo.getThickness());
+                            apsProcessOutputProductDo.setProwidth(apsProductDetailDo.getProwidth());
+                            apsProcessOutputProductDo.setProlength(apsProductDetailDo.getProlength());
+                            apsProcessOutputProductDo.setRollweightrequirement(apsProductDetailDo.getRollweightrequirement());
+                            apsProcessOutputProductDo.setRolldiameterrequirement(apsProductDetailDo.getRolldiameterrequirement());
+                            apsProcessOutputProductDo.setRollnumberrequirement(apsProductDetailDo.getRollnumberrequirement());
+                            apsProcessOutputProductDo.setProductname(apsProductDetailDo.getInputmaterialdescription());
+                            apsProcessOutputProductDo.setProductid(apsProductDetailDo.getId());
+                            String alloy = apsProcessOutputProductDo.getAlloy();
+                            String alloyStatus = apsProcessOutputProductDo.getAlloystatus();
+                            String productType = vo.getProducttype();
+                            if (ObjectUtil.isNotEmpty(vo.getChangealloy())) {
+                                alloy = vo.getChangealloy();
+                            }
+                            if (ObjectUtil.isNotEmpty(vo.getChangealloystatus())) {
+                                alloyStatus = vo.getChangealloystatus();
+                            }
+                            if (ObjectUtil.isNotEmpty(vo.getChangeproducttype())) {
+                                productType = vo.getChangeproducttype();
+                            }
+
+                            //拼接输出成品的输出物料类型字段
+                            apsProcessOutputProductDo.setOutmatertype(alloy + productType + apsProcessOutputProductDo.getThickness());
+                            //拼接输出成品的输出物料规格字段
+                            apsProcessOutputProductDo.setOutmaterspecification(alloy + alloyStatus + productType + " " + apsProcessOutputProductDo.getProductname().split(" ")[1]);
+                            //拼接输出成品的输出成品字段
+                            apsProcessOutputProductDo.setOutputresult(apsProcessOutputProductDo.getOutmaterspecification() + " " + CXCommonUtils.removeExtraZerosAndDecimal(vo.getOutputonerollweigth()) + "吨 * " + vo.getPlanoutputorderroll() + "卷");
+
+                            apsProcessOutputProductService.updateById(apsProcessOutputProductDo);
+                            needUpdateBlankIds.add(vo.getBlankId());
+                        }
+                    }
+                    //遍历需要更新的坯料计划，更新 输出订单产品、输出成品、坯料输出物料类型、坯料输出物料规格
+                    for (String needUpdateBlankId : needUpdateBlankIds) {
+                        apsBlankOrderService.updateBlankSplicingColumn(needUpdateBlankId);
                     }
                 }
-                //遍历需要更新的坯料计划，更新 输出订单产品、输出成品、坯料输出物料类型、坯料输出物料规格
-                for (String needUpdateBlankId : needUpdateBlankIds) {
-                    apsBlankOrderService.updateBlankSplicingColumn(needUpdateBlankId);
-                }
-            }
 
-            //=================更新技术要求==========================
-            //查询相关的技术要求
-            List<ApsProductionTechnicalRequirementDo> apsProductionTechnicalRequirementDoList = apsProductionTechnicalRequirementService.list(new QueryWrapper<ApsProductionTechnicalRequirementDo>().lambda().like(ApsProductionTechnicalRequirementDo::getOrderdetailids, nowId).orderByDesc(ApsProductionTechnicalRequirementDo::getModifydate));
-            if (apsProductionTechnicalRequirementDoList.size() > 0) {
-                //只会存在一个
-                ApsProductionTechnicalRequirementDo apsProductionTechnicalRequirementDo = apsProductionTechnicalRequirementDoList.get(0);
-                //更新原来的产品明细为新的产品明细
-                ApsProductionTechnicalRequirementDo updateTechnicalRequirement = new ApsProductionTechnicalRequirementDo();
-                updateTechnicalRequirement.setId(apsProductionTechnicalRequirementDo.getId());
-
-                //获取原来的产品明细IDs和产品明细的名称
-                String orderdetailids = apsProductionTechnicalRequirementDo.getOrderdetailids();
-                String orderdetailnames = apsProductionTechnicalRequirementDo.getOrderdetailnames();
-                List<String> orderDetailIdList = Arrays.asList(orderdetailids.split(","));
-                List<String> orderDetailNameList = Arrays.asList(orderdetailnames.split(",\r\n"));
-                //获取 原产品明细的ID的下标
-                int index = orderDetailIdList.indexOf(nowId);
-                //替换成新的产品明细
-                orderDetailIdList.set(index, apsProductDetailDo.getId());
-                orderDetailNameList.set(index, apsProductDetailDo.getInputmaterialdescription());
-
-                updateTechnicalRequirement.setOrderdetailids(String.join(",", orderDetailIdList));
-                updateTechnicalRequirement.setOrderdetailnames(String.join(",\r\n", orderDetailNameList));
-                //更新技术要求
-                apsProductionTechnicalRequirementService.updateById(updateTechnicalRequirement);
+                //=================更新技术要求==========================
+                //查询相关的技术要求
+                List<ApsProductionTechnicalRequirementDo> apsProductionTechnicalRequirementDoList = apsProductionTechnicalRequirementService.list(new QueryWrapper<ApsProductionTechnicalRequirementDo>().lambda().like(ApsProductionTechnicalRequirementDo::getOrderdetailids, nowId).orderByDesc(ApsProductionTechnicalRequirementDo::getModifydate));
+                if (apsProductionTechnicalRequirementDoList.size() > 0) {
+                    //只会存在一个
+                    ApsProductionTechnicalRequirementDo apsProductionTechnicalRequirementDo = apsProductionTechnicalRequirementDoList.get(0);
+                    //更新原来的产品明细为新的产品明细
+                    ApsProductionTechnicalRequirementDo updateTechnicalRequirement = new ApsProductionTechnicalRequirementDo();
+                    updateTechnicalRequirement.setId(apsProductionTechnicalRequirementDo.getId());
+
+                    //获取原来的产品明细IDs和产品明细的名称
+                    String orderdetailids = apsProductionTechnicalRequirementDo.getOrderdetailids();
+                    String orderdetailnames = apsProductionTechnicalRequirementDo.getOrderdetailnames();
+                    List<String> orderDetailIdList = Arrays.asList(orderdetailids.split(","));
+                    List<String> orderDetailNameList = Arrays.asList(orderdetailnames.split(",\r\n"));
+                    //获取 原产品明细的ID的下标
+                    int index = orderDetailIdList.indexOf(nowId);
+                    //替换成新的产品明细
+                    orderDetailIdList.set(index, apsProductDetailDo.getId());
+                    orderDetailNameList.set(index, apsProductDetailDo.getInputmaterialdescription());
+
+                    updateTechnicalRequirement.setOrderdetailids(String.join(",", orderDetailIdList));
+                    updateTechnicalRequirement.setOrderdetailnames(String.join(",\r\n", orderDetailNameList));
+                    //更新技术要求
+                    apsProductionTechnicalRequirementService.updateById(updateTechnicalRequirement);
+                }
             }
         }
 

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

@@ -1107,6 +1107,8 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
             } catch (Exception ignored) {
             }
             workInProgressInventoryDo.setJoboutputmaterial(outPut);
+            //计划输出卷重
+            workInProgressInventoryDo.setPlansinglerollweight(apsProcessOperationOutMaterDo.getSinglerollweight());
 
             needAddWorkInProgressInventoryList.add(workInProgressInventoryDo);
         }
@@ -1390,21 +1392,40 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
          * 查找输入物料所有后道作业明细，即前道作业明细的所有后道作业明细中，
          * 其工序作业的输入物料ID和报工记录的工序作业的输入物料ID相同的所有作业明细，将这些作业明细的待加工料卷批次号去掉“{输入批次号}，”
          */
+        //更新待加工料卷批次号
+        if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+            List<ApsProcessOperationProcessEquDo> needUpdateBatchNumber = apsProcessOperationProcessEquService.list(new QueryWrapper<ApsProcessOperationProcessEquDo>().lambda().eq(ApsProcessOperationProcessEquDo::getPreviousprocessesids, apsProcessOperationProcessEquDo.getPreviousprocessesids()));
+            if (ObjectUtil.isNotEmpty(needUpdateBatchNumber)) {
+                List<ApsProcessOperationProcessEquDo> needUpdateList = new LinkedList<>();
+
+                for (ApsProcessOperationProcessEquDo processOperationProcessEquDo : needUpdateBatchNumber) {
+                    List<String> oldList = new LinkedList<>();
+                    //原待加工批次号不为空
+                    if (ObjectUtil.isNotEmpty(processOperationProcessEquDo.getBachmaterialprocess())) {
+                        oldList = new LinkedList<>(Arrays.asList(processOperationProcessEquDo.getBachmaterialprocess().split(",")));
+                        oldList.removeAll(inputBatchNumberList);
+
+                        String newBatch = String.join(",", oldList);
+                        ApsProcessOperationProcessEquDo needUpdate = new ApsProcessOperationProcessEquDo();
+                        needUpdate.setId(processOperationProcessEquDo.getId());
+                        needUpdate.setBachmaterialprocess(newBatch);
+                        needUpdateList.add(needUpdate);
+                    }
+                }
+                if (ObjectUtil.isNotEmpty(needUpdateList)) {
+                    apsProcessOperationProcessEquService.updateBatchById(needUpdateList);
+                }
+            }
+        }
+
+
         for (String inputBatchNumber : inputBatchNumberList) {
             //更新在制品状态
             apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
                     .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "加工中")
                     .eq(ApsWorkInProgressInventoryDo::getBatchnumber, inputBatchNumber)
                     .eq(ApsWorkInProgressInventoryDo::getDeleted, "0"));
-            //更新待加工料卷批次号
-            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
-                List<ApsProcessOperationProcessEquDo> needUpdateBatchNumber = apsProcessOperationProcessEquService.list(new QueryWrapper<ApsProcessOperationProcessEquDo>().lambda().eq(ApsProcessOperationProcessEquDo::getPreviousprocessesids, apsProcessOperationProcessEquDo.getPreviousprocessesids()));
-                if (ObjectUtil.isNotEmpty(needUpdateBatchNumber)) {
-                    List<String> needUpdateIds = needUpdateBatchNumber.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-                    String join = String.join(",", needUpdateIds);
-                    this.baseMapper.updateAllProcessEquBatchNumberByIds(inputBatchNumber, join);
-                }
-            }
+
         }
         //========更新工序作业明细==========
         ApsProcessOperationProcessEquDo needUpdateProcessEqu = new ApsProcessOperationProcessEquDo();

cx-aps/cx-aps-common/src/main/resources/mybatis/ApsProcessOperationProcessEquDao.xml

@@ -189,7 +189,10 @@
         a7.CUSTOMERABBREVIATION as CUSTOMERABBREVIATION,
         a7.CUSTOMERUNIT,
         a3.BLANKNUMBER as blankNumber,
-        a3.PLANHAVEMATERIALDATE as planhavematerialdate
+        a3.PLANHAVEMATERIALDATE as planhavematerialdate,
+        a2.SINGLEROLLWEIGHT,
+        a2.SINGLEROLLWEIGHT * a1.PLANPROCESSRALL as totalRollWeight
+
         FROM
         aps_process_operation_process_equ a1
         LEFT JOIN aps_process_operation a2 ON a1.PROCESSID = a2.ID
@@ -357,11 +360,10 @@
         CONCAT(aci.USEDEPTID, '/', aci.ID ) AS value ,
         CONCAT(aci.USEDEPTNAME, '/', aci.CHECKITEMNAME) AS label
         FROM asp_check_items aci
-        LEFT JOIN aps_process_operation_process_equ apope ON aci.ID=apope.PROCESSDEVICEID
         where
-        apope.DELETED = '0'
-        and aci.DELETED='0'
-        and apope.PROCESSDEVICEID is not null
+        aci.DELETED='0'
+        and aci.TENANTID=#{factoryId}
+        and IFNULL(DEVICESTATUS,'正常使用')!='停用' and IFNULL(DEVICESTATUS,'正常使用')!='报废'  and  PRODUCETYPE='1'
         GROUP BY aci.ID
         ORDER BY aci.USEDEPTNAME,aci.CHECKITEMNAME,aci.CHECKITEMNAME ASC
         <!--        SELECT-->

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-entity/src/main/java/com/rongwei/bsentity/vo/GanttVos.java

@@ -2,6 +2,7 @@ package com.rongwei.bsentity.vo;
 
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.util.Date;
 
 /**
@@ -225,4 +226,13 @@ public class GanttVos {
      * 预计来料日期
      */
     private Date planhavematerialdate;
+    /**
+     * 计划单卷重
+     */
+    private BigDecimal singlerollweight;
+
+    /**
+     * 合计卷重
+     */
+    private BigDecimal totalRollWeight;
 }

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);
+    }
 }
 

cx-safe-check/cx-save-check-common/src/main/java/com/rongwei/sfcommon/sys/service/impl/CheckTemplateServiceImpl.java

@@ -313,6 +313,7 @@ public class CheckTemplateServiceImpl extends ServiceImpl<CheckTemplateDao, Chec
         List<PointCheckDo> pointChecks = new ArrayList<>();
         List<PointCheckItemDo> pointCheckItems = new ArrayList<>();
         Map<PointCheckNewsVo,List<String>> notifyType = new HashMap<>();
+        int index=0;
         // 每班几次就生成几个任务
         for(List<CheckTemplateItemsDo> checkItems:items){
             // 点检名称 班次+模板名称+当前日期
@@ -323,7 +324,6 @@ public class CheckTemplateServiceImpl extends ServiceImpl<CheckTemplateDao, Chec
             String templatetype = checkTemplate.getTemplatetype();
             if(StringUtils.isNotEmpty(checkitemsids)){
                 String[] checkitemsidArray = checkitemsids.split(",");
-                int index=0;
                 for (String checkitemsid : checkitemsidArray) {
                     // 每个设备生成一条点检任务
                     CheckItemsDo checkItemsdo = checkItemsService.getById(checkitemsid);
@@ -452,6 +452,7 @@ public class CheckTemplateServiceImpl extends ServiceImpl<CheckTemplateDao, Chec
         }
 
         if(!notifyType.isEmpty()){
+            logger.debug("如下数据:{}需要生产点检任务,班次为：{}",notifyType,shift);
             List<SysDictDo> dictsByType = commonDictService.getDictsByType("template-type");
             notifyType.forEach((k,v)-> {
                 String pointcheckname = k.getPointcheckname();