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/ApsProductDetailDao.java

@@ -67,6 +67,8 @@ public interface ApsProductDetailDao extends BaseMapper<ApsProductDetailDo> {
     List<GetOldTechnicalRequirementRes> selectMyList(@Param("technicalRequirementId") String technicalRequirementId, @Param("id") String id, @Param("alloy") String alloy, @Param("alloystatus") String alloystatus, @Param("orderProductTypeId") String orderProductTypeId);
 
     List<GetOldTechnicalRequirementRes> selectMyList1(@Param("technicalRequirementId") String technicalRequirementId, @Param("id") String id, @Param("customId") String customId, @Param("alloy") String alloy);
+
     List<GetOldTechnicalRequirementRes> selectMyList2(@Param("technicalRequirementId") String technicalRequirementId, @Param("id") String id, @Param("customId") String customId, @Param("alloystatus") String alloystatus);
+
     List<GetOldTechnicalRequirementRes> selectMyList3(@Param("technicalRequirementId") String technicalRequirementId, @Param("id") String id, @Param("customId") String customId, @Param("orderProductTypeId") String orderProductTypeId);
 }

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

@@ -30,6 +30,7 @@ import com.rongwei.rwcommon.vo.SearchColumnVo;
 import com.rongwei.rwcommon.vo.SearchOrderVo;
 import com.rongwei.safecommon.utils.CXCommonUtils;
 import com.rongwei.safecommon.utils.SaveConstans;
+import org.apache.commons.collections.list.SynchronizedList;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeanUtils;
@@ -42,6 +43,7 @@ import java.math.RoundingMode;
 import java.text.Collator;
 import java.time.ZoneId;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 import static com.rongwei.bscommon.sys.service.impl.ApsProductionOrderServiceImpl.ERROR_MSG;
@@ -3191,6 +3193,10 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
     }
 
+    //领料锁
+    private final ArrayList<String> addMaterialList = new ArrayList<String>();
+    private final List<String> addMaterialLock = Collections.synchronizedList(addMaterialList);
+
     @Override
     @Transactional
     public R addMaterial(AddMaterialReq req) {
@@ -3208,95 +3214,104 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         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);
+
+        for (String s : batchNumberList) {
+            if (addMaterialLock.contains(s)) {
+                log.error("批次号" + s + "正被操作，请稍后重试");
+                return R.error("批次号" + s + "正被操作，请稍后重试");
+            }
         }
+        addMaterialLock.addAll(batchNumberList);
+        try {
+            //查询坯料计划第一道工序作业的详情
+            ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(req.getProcessId());
+            int needStartRoll = apsProcessOperationDo.getPlanprocessrall() - apsProcessOperationDo.getStartingroll() - apsProcessOperationDo.getCancelroll();
+            if (batchNumberList.size() > needStartRoll) {
+                return R.error("领料数量不能大于计划加工卷数-已开工卷数-已取消卷数=" + needStartRoll);
+            }
 
-        //查询目前的作业明细包含的批次号
-        String nowNumber = this.baseMapper.selectBatchNumbersByProcessId(apsProcessOperationDo.getId());
+            //查询目前的作业明细包含的批次号
+            String nowNumber = this.baseMapper.selectBatchNumbersByProcessId(apsProcessOperationDo.getId());
 
-        //原来的批次号
-        String oldBatchNumbers = req.getOldBatchNumbers();
-        LinkedList<String> oldBatchNumberList = new LinkedList<>();
-        if (ObjectUtil.isNotEmpty(oldBatchNumbers)) {
-            oldBatchNumberList = new LinkedList<>(Arrays.asList(oldBatchNumbers.split(",")));
-        }
+            //原来的批次号
+            String oldBatchNumbers = req.getOldBatchNumbers();
+            LinkedList<String> oldBatchNumberList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(oldBatchNumbers)) {
+                oldBatchNumberList = new LinkedList<>(Arrays.asList(oldBatchNumbers.split(",")));
+            }
 
-        //判断旧的批次号有没有变化
-        List<String> nowNumberList = new LinkedList<>();
-        if (ObjectUtil.isNotEmpty(nowNumber)) {
-            nowNumberList = new LinkedList<>(Arrays.asList(nowNumber.split(",")));
-        }
-        if (nowNumberList.size() != oldBatchNumberList.size()) {
-            return R.error("领料批次号可能已经被使用，请刷新后重新领料");
-        }
-        for (String s : nowNumberList) {
-            if (!oldBatchNumberList.contains(s)) {
-                return R.error("领料批次号可能已经被使用，请刷新后重新领料");
+            //判断旧的批次号有没有变化
+            List<String> nowNumberList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(nowNumber)) {
+                nowNumberList = new LinkedList<>(Arrays.asList(nowNumber.split(",")));
             }
-        }
-        for (String s : oldBatchNumberList) {
-            if (!nowNumberList.contains(s)) {
+            if (nowNumberList.size() != oldBatchNumberList.size()) {
                 return R.error("领料批次号可能已经被使用，请刷新后重新领料");
             }
-        }
+            for (String s : nowNumberList) {
+                if (!oldBatchNumberList.contains(s)) {
+                    return R.error("领料批次号可能已经被使用，请刷新后重新领料");
+                }
+            }
+            for (String s : oldBatchNumberList) {
+                if (!nowNumberList.contains(s)) {
+                    return R.error("领料批次号可能已经被使用，请刷新后重新领料");
+                }
+            }
 
-        //新的批次号集合
-        List<String> addBatchNumberList = new LinkedList<>();
-        //删除的批次号集合
-        List<String> delBatchNumberList = new LinkedList<>();
+            //新的批次号集合
+            List<String> addBatchNumberList = new LinkedList<>();
+            //删除的批次号集合
+            List<String> delBatchNumberList = new LinkedList<>();
 
-        for (String s : oldBatchNumberList) {
-            if (!batchNumberList.contains(s)) {
-                delBatchNumberList.add(s);
+            for (String s : oldBatchNumberList) {
+                if (!batchNumberList.contains(s)) {
+                    delBatchNumberList.add(s);
+                }
             }
-        }
-        for (String s : batchNumberList) {
-            if (!oldBatchNumberList.contains(s)) {
-                addBatchNumberList.add(s);
+            for (String s : batchNumberList) {
+                if (!oldBatchNumberList.contains(s)) {
+                    addBatchNumberList.add(s);
+                }
             }
-        }
 
-        List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
-        if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
+            List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
 
-            //查询是否已被其他坯料计划领料
-            for (String batchNumber : addBatchNumberList) {
-                ApsBlankOrderDo blankOrderDo = this.baseMapper.countThisBatchNumber(batchNumber);
-                if (ObjectUtil.isNotEmpty(blankOrderDo)) {
-                    return R.error("该批次号" + batchNumber + "已被其他坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+                //查询是否已被其他坯料计划领料
+                for (String batchNumber : addBatchNumberList) {
+                    ApsBlankOrderDo blankOrderDo = this.baseMapper.countThisBatchNumber(batchNumber);
+                    if (ObjectUtil.isNotEmpty(blankOrderDo)) {
+                        return R.error("该批次号" + batchNumber + "已被其他坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+                    }
                 }
-            }
 
-            //查询新增的批次号
-            workInProgressInventoryDos =
-                    apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
-                            .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
-                            .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
-        }
-        for (int i = 0; i < addBatchNumberList.size(); i++) {
-            String s = addBatchNumberList.get(i);
-            String addBatchNumber = s;
-            //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
-            ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(addBatchNumber)).findFirst().orElse(null);
-            if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
-                /**
-                 * 如果该批次号没有对应在制品库存，表示线下批次号，
-                 * 如果批次号没有前缀*，则加上前缀*
-                 */
-                if (!s.startsWith("*")) {
-                    s = "*" + s;
-                    addBatchNumberList.set(i, s);
-                    batchNumberList.set(batchNumberList.indexOf(addBatchNumber), s);
+                //查询新增的批次号
+                workInProgressInventoryDos =
+                        apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                                .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                                .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+            }
+            for (int i = 0; i < addBatchNumberList.size(); i++) {
+                String s = addBatchNumberList.get(i);
+                String addBatchNumber = s;
+                //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
+                ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(addBatchNumber)).findFirst().orElse(null);
+                if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
+                    /**
+                     * 如果该批次号没有对应在制品库存，表示线下批次号，
+                     * 如果批次号没有前缀*，则加上前缀*
+                     */
+                    if (!s.startsWith("*")) {
+                        s = "*" + s;
+                        addBatchNumberList.set(i, s);
+                        batchNumberList.set(batchNumberList.indexOf(addBatchNumber), s);
+                    }
+                } else {
+                    //借调逻辑
+                    borrowBlank(apsWorkInProgressInventoryDo);
                 }
-            } else {
-                //借调逻辑
-                borrowBlank(apsWorkInProgressInventoryDo);
             }
-        }
 
 //        //如果批次号有重复，则错误提示：批次号{批次号}重复
 //        for (String item : batchNumberList) {
@@ -3386,94 +3401,98 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
 //            }
 //        }
 
-        //更新坯料计划对应的领料批次号
-        ApsBlankOrderDo apsBlankOrderDo = this.getById(req.getBlankId());
-        List<String> preparematerialbatchnoList = new LinkedList<>();
-        if (ObjectUtil.isNotEmpty(apsBlankOrderDo.getPreparematerialbatchno())) {
-            preparematerialbatchnoList = new LinkedList<>(Arrays.asList(apsBlankOrderDo.getPreparematerialbatchno().split(",")));
-        }
-        preparematerialbatchnoList.removeAll(delBatchNumberList);
-        preparematerialbatchnoList.addAll(addBatchNumberList);
-        ApsBlankOrderDo updateBlank = new ApsBlankOrderDo();
-        updateBlank.setId(apsBlankOrderDo.getId());
-        updateBlank.setPreparematerialbatchno(String.join(",", preparematerialbatchnoList));
-        this.updateById(updateBlank);
+            //更新坯料计划对应的领料批次号
+            ApsBlankOrderDo apsBlankOrderDo = this.getById(req.getBlankId());
+            List<String> preparematerialbatchnoList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(apsBlankOrderDo.getPreparematerialbatchno())) {
+                preparematerialbatchnoList = new LinkedList<>(Arrays.asList(apsBlankOrderDo.getPreparematerialbatchno().split(",")));
+            }
+            preparematerialbatchnoList.removeAll(delBatchNumberList);
+            preparematerialbatchnoList.addAll(addBatchNumberList);
+            ApsBlankOrderDo updateBlank = new ApsBlankOrderDo();
+            updateBlank.setId(apsBlankOrderDo.getId());
+            updateBlank.setPreparematerialbatchno(String.join(",", preparematerialbatchnoList));
+            this.updateById(updateBlank);
 
-        /**
-         * 检验通过，
-         * 原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划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));
+            /**
+             * 检验通过，
+             * 原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划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));
 //            //更新坯料计划该字段为空
 //            apsBlankOrderService.update(new UpdateWrapper<ApsBlankOrderDo>().lambda()
 //                    .set(ApsBlankOrderDo::getPreparematerialbatchno, null)
 //                    .eq(ApsBlankOrderDo::getId, apsBlankOrderDo.getId()));
-        }
+            }
 
-        //更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
+            //更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
 //        apsProcessOperationProcessEquService.update(new UpdateWrapper<ApsProcessOperationProcessEquDo>().lambda()
 //                .set(ApsProcessOperationProcessEquDo::getBachmaterialprocess, String.join(",", batchNumberList))
 //                .eq(ApsProcessOperationProcessEquDo::getDeleted, "0")
 //                .eq(ApsProcessOperationProcessEquDo::getProcessid, req.getProcessId()));
-        /**
-         * 需求变更:根据作业明细的计划开工时间先后顺序以及剩余待开工卷数（=计划加工卷数-已开工卷数-已取消卷数）自动将领料批次号依次重新分配给这些作业明细，只用管剩余待开工卷数大于0的
-         * 注意：是重新分配待加工料卷批次号，需要清空原待加工料卷批次号，不是在原有待加工料卷批次号后面追加
-         */
-        List<ApsProcessOperationProcessEquDo> updateOperationProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>()
-                .eq(ApsProcessOperationProcessEquDo::getDeleted, "0")
-                .eq(ApsProcessOperationProcessEquDo::getProcessid, req.getProcessId())
-                .orderByAsc(ApsProcessOperationProcessEquDo::getPlanstartdate));
-        List<String> finalBatchNumberList = batchNumberList;
-        List<ApsProcessOperationProcessEquDo> needUpdateProcessEquList = new ArrayList<>();
-        List<ApsProcessOperationProcessEquDo> clearBachMaterialProcessEquList = new ArrayList<>();
-        //符合条件的需要先清除原待加工料卷批次号
-        updateOperationProcessEquList.forEach(equDo -> {
-            //剩余待开工卷数 =计划加工卷数-已开工卷数-已取消卷数
-            int leaveWaitWorkRoll = equDo.getPlanprocessrall() - equDo.getStartingroll() - equDo.getCancelroll();
-            if (leaveWaitWorkRoll > 0) {
-                if (StringUtils.isNotBlank(equDo.getBachmaterialprocess())) {
-                    equDo.setBachmaterialprocess("");
-                    clearBachMaterialProcessEquList.add(equDo);
+            /**
+             * 需求变更:根据作业明细的计划开工时间先后顺序以及剩余待开工卷数（=计划加工卷数-已开工卷数-已取消卷数）自动将领料批次号依次重新分配给这些作业明细，只用管剩余待开工卷数大于0的
+             * 注意：是重新分配待加工料卷批次号，需要清空原待加工料卷批次号，不是在原有待加工料卷批次号后面追加
+             */
+            List<ApsProcessOperationProcessEquDo> updateOperationProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>()
+                    .eq(ApsProcessOperationProcessEquDo::getDeleted, "0")
+                    .eq(ApsProcessOperationProcessEquDo::getProcessid, req.getProcessId())
+                    .orderByAsc(ApsProcessOperationProcessEquDo::getPlanstartdate));
+            List<String> finalBatchNumberList = batchNumberList;
+            List<ApsProcessOperationProcessEquDo> needUpdateProcessEquList = new ArrayList<>();
+            List<ApsProcessOperationProcessEquDo> clearBachMaterialProcessEquList = new ArrayList<>();
+            //符合条件的需要先清除原待加工料卷批次号
+            updateOperationProcessEquList.forEach(equDo -> {
+                //剩余待开工卷数 =计划加工卷数-已开工卷数-已取消卷数
+                int leaveWaitWorkRoll = equDo.getPlanprocessrall() - equDo.getStartingroll() - equDo.getCancelroll();
+                if (leaveWaitWorkRoll > 0) {
+                    if (StringUtils.isNotBlank(equDo.getBachmaterialprocess())) {
+                        equDo.setBachmaterialprocess("");
+                        clearBachMaterialProcessEquList.add(equDo);
+                    }
                 }
+            });
+            if (ObjectUtil.isNotEmpty(clearBachMaterialProcessEquList)) {
+                apsProcessOperationProcessEquService.updateBatchById(clearBachMaterialProcessEquList);
+            }
+            updateOperationProcessEquList.forEach(equDo -> {
+                //剩余待开工卷数 =计划加工卷数-已开工卷数-已取消卷数
+                int leaveWaitWorkRoll = equDo.getPlanprocessrall() - equDo.getStartingroll() - equDo.getCancelroll();
+                if (leaveWaitWorkRoll > 0 && finalBatchNumberList.size() > 0) {
+                    //有几个剩余待开工卷数就要分配几个batchNumberList中批次号的个数
+                    List<String> distributionNumbers = finalBatchNumberList.stream().limit(leaveWaitWorkRoll).collect(Collectors.toList());
+                    equDo.setBachmaterialprocess(String.join(",", distributionNumbers));
+                    finalBatchNumberList.removeAll(distributionNumbers);
+                    needUpdateProcessEquList.add(equDo);
+                }
+            });
+            if (ObjectUtil.isNotEmpty(needUpdateProcessEquList)) {
+                apsProcessOperationProcessEquService.updateBatchById(needUpdateProcessEquList);
             }
-        });
-        if (ObjectUtil.isNotEmpty(clearBachMaterialProcessEquList)) {
-            apsProcessOperationProcessEquService.updateBatchById(clearBachMaterialProcessEquList);
-        }
-        updateOperationProcessEquList.forEach(equDo -> {
-            //剩余待开工卷数 =计划加工卷数-已开工卷数-已取消卷数
-            int leaveWaitWorkRoll = equDo.getPlanprocessrall() - equDo.getStartingroll() - equDo.getCancelroll();
-            if (leaveWaitWorkRoll > 0 && finalBatchNumberList.size() > 0) {
-                //有几个剩余待开工卷数就要分配几个batchNumberList中批次号的个数
-                List<String> distributionNumbers = finalBatchNumberList.stream().limit(leaveWaitWorkRoll).collect(Collectors.toList());
-                equDo.setBachmaterialprocess(String.join(",", distributionNumbers));
-                finalBatchNumberList.removeAll(distributionNumbers);
-                needUpdateProcessEquList.add(equDo);
-            }
-        });
-        if (ObjectUtil.isNotEmpty(needUpdateProcessEquList)) {
-            apsProcessOperationProcessEquService.updateBatchById(needUpdateProcessEquList);
-        }
 
 
-        //在制品的在制品状态=待加工
-        //在制品的备料计划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));
+            //在制品的在制品状态=待加工
+            //在制品的备料计划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));
+            }
+        } finally {
+            log.debug("领料完毕，从list中清空当前领料锁，批次号：" + batchNumberList);
+            addMaterialLock.removeAll(batchNumberList);
         }
 
         return R.ok();
@@ -3609,6 +3628,10 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
     }
 
+    //领料锁
+    private final ArrayList<String> checkAddMaterialList = new ArrayList<String>();
+    private final List<String> checkAddMaterialLock = Collections.synchronizedList(checkAddMaterialList);
+
     @Override
     public R checkAddMaterial(AddMaterialReq req) {
         //分割批次号
@@ -3625,131 +3648,141 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         if (ObjectUtil.isNotEmpty(req.getBatchNumbers())) {
             batchNumberList = new LinkedList<>(Arrays.asList(req.getBatchNumbers().split(",")));
         }
-        //查询坯料计划详情
-        ApsBlankOrderDo apsBlankOrderDo = apsBlankOrderService.getById(req.getBlankId());
-        //查询坯料计划第一道工序作业的详情
-        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(",")));
+        for (String s : batchNumberList) {
+            if (checkAddMaterialLock.contains(s)) {
+                log.error("批次号" + s + "正被操作，请稍后重试");
+                return R.error("批次号" + s + "正被操作，请稍后重试");
+            }
         }
+        checkAddMaterialLock.addAll(batchNumberList);
+        String res = "";
+        try {
+            //查询坯料计划详情
+            ApsBlankOrderDo apsBlankOrderDo = apsBlankOrderService.getById(req.getBlankId());
+            //查询坯料计划第一道工序作业的详情
+            ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(req.getProcessId());
+            int needStartRoll = apsProcessOperationDo.getPlanprocessrall() - apsProcessOperationDo.getStartingroll() - apsProcessOperationDo.getCancelroll();
+            if (batchNumberList.size() > needStartRoll) {
+                return R.error("领料数量不能大于计划加工卷数-已开工卷数-已取消卷数=" + needStartRoll);
+            }
 
-        //新的批次号集合
-        List<String> addBatchNumberList = new LinkedList<>();
-        //删除的批次号集合
-        List<String> delBatchNumberList = new LinkedList<>();
+            //原来的批次号
+            String oldBatchNumbers = req.getOldBatchNumbers();
+            LinkedList<String> oldBatchNumberList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(oldBatchNumbers)) {
+                oldBatchNumberList = new LinkedList<>(Arrays.asList(oldBatchNumbers.split(",")));
+            }
 
-        for (String s : oldBatchNumberList) {
-            if (!batchNumberList.contains(s)) {
-                delBatchNumberList.add(s);
+            //新的批次号集合
+            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 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 + "重复");
+            //如果批次号有重复，则错误提示：批次号{批次号}重复
+            for (String item : batchNumberList) {
+                if (batchNumberList.stream().filter(i -> i.equals(item)).count() > 1) {
+                    return R.error("批次号" + item + "重复");
+                }
             }
-        }
 
 
-        List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
-        if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
-            //查询是否已被其他坯料计划领料
-            for (String batchNumber : addBatchNumberList) {
-                ApsBlankOrderDo blankOrderDo = this.baseMapper.countThisBatchNumber(batchNumber);
-                if (ObjectUtil.isNotEmpty(blankOrderDo)) {
-                    return R.error("该批次号" + batchNumber + "已被其他坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+            List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(addBatchNumberList)) {
+                //查询是否已被其他坯料计划领料
+                for (String batchNumber : addBatchNumberList) {
+                    ApsBlankOrderDo blankOrderDo = this.baseMapper.countThisBatchNumber(batchNumber);
+                    if (ObjectUtil.isNotEmpty(blankOrderDo)) {
+                        return R.error("该批次号" + batchNumber + "已被其他坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+                    }
                 }
-            }
 
 
-            //查询新增的批次号
-            workInProgressInventoryDos =
-                    apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
-                            .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
-                            .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
-        }
+                //查询新增的批次号
+                workInProgressInventoryDos =
+                        apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                                .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                                .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+            }
 
 
-        //线下批次号
-        List<String> offLineBatchNumberList = new LinkedList<>();
-        //线上批次号 不匹配提示
-        List<String> onLineBatchNumberWarnList = new LinkedList<>();
+            //线下批次号
+            List<String> offLineBatchNumberList = new LinkedList<>();
+            //线上批次号 不匹配提示
+            List<String> onLineBatchNumberWarnList = new LinkedList<>();
 
-        /**
-         * 如果该批次号物料在制品库存中存在
-         * 如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
-         * 如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
-         * 如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
-         * 如果在制品状态=备料中，并且在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
-         * 查找该批次号物料=在制品的作业输出物料ID对应输出物料
-         * 如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
-         * 错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
-         */
+            /**
+             * 如果该批次号物料在制品库存中存在
+             * 如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+             * 如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+             * 如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+             * 如果在制品状态=备料中，并且在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+             * 查找该批次号物料=在制品的作业输出物料ID对应输出物料
+             * 如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
+             * 错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+             */
 
-        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;
-                }
+            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;
+                    }
 
-                Integer count = this.baseMapper.selectCountWorkIn(s);
-                if (count > 0) {
-                    return R.error("线下批次号" + s + "与其他线下批次号重复");
-                }
+                    Integer count = this.baseMapper.selectCountWorkIn(s);
+                    if (count > 0) {
+                        return R.error("线下批次号" + s + "与其他线下批次号重复");
+                    }
 
 
-                offLineBatchNumberList.add(s);
-                continue;
-            }
+                    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不为空，并且不等于该坯料计划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 + "错误，该料卷是其他客户订单的成品");
+                //如果在制品状态=加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+                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对应输出物料
 //            //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，或者坯料类型不等于坯料计划的坯料类型
@@ -3766,11 +3799,11 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             则提示确认：该批次号{批次号}物料：
             “{在制品的坯料类型} {在制品的作业输出物料} {在制品的计划输出卷重}吨”与该坯料计划所需的坯料“{坯料计划的坯料类型} {坯料输入物料描述} {坯料的卷重}吨”不相同，确认领料吗？
              */
-            String a = apsWorkInProgressInventoryDo.getBlanktype() + " " + apsWorkInProgressInventoryDo.getJoboutputmaterial() + " " + CXCommonUtils.removeExtraZerosAndDecimal(apsWorkInProgressInventoryDo.getPlansinglerollweight()) + "吨";
-            String b = apsBlankOrderDo.getBlanktype() + " " + apsBlankOrderDo.getInputreportdescribe() + " " + CXCommonUtils.removeExtraZerosAndDecimal(apsBlankOrderDo.getSinglerollweight()) + "吨";
-            if (!a.equals(b)) {
-                onLineBatchNumberWarnList.add("该批次号" + s + "物料:'" + a + "'与该坯料计划所需的坯料：'" + b + "'不相同，确认领料吗？");
-            }
+                String a = apsWorkInProgressInventoryDo.getBlanktype() + " " + apsWorkInProgressInventoryDo.getJoboutputmaterial() + " " + CXCommonUtils.removeExtraZerosAndDecimal(apsWorkInProgressInventoryDo.getPlansinglerollweight()) + "吨";
+                String b = apsBlankOrderDo.getBlanktype() + " " + apsBlankOrderDo.getInputreportdescribe() + " " + CXCommonUtils.removeExtraZerosAndDecimal(apsBlankOrderDo.getSinglerollweight()) + "吨";
+                if (!a.equals(b)) {
+                    onLineBatchNumberWarnList.add("该批次号" + s + "物料:'" + a + "'与该坯料计划所需的坯料：'" + b + "'不相同，确认领料吗？");
+                }
 
 //            //如果在制品的坯料类型不等于坯料计划的坯料类型，
 //            // 则错误提示：该批次号{批次号}物料：{在制品的作业输出物料}不是该坯料计划所需的坯料类型
@@ -3783,18 +3816,21 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
 //            if (!apsWorkInProgressInventoryDo.getPlansinglerollweight().equals(apsBlankOrderDo.getSinglerollweight())) {
 //                onLineBatchNumberWarnList.add(s);
 //            }
-        }
+            }
 
-        String res = "";
-        if (ObjectUtil.isNotEmpty(offLineBatchNumberList)) {
-            res = "<b>" + String.join(",", offLineBatchNumberList) + "是线下批次号，确认领料吗？</b><br>";
-        }
-        if (ObjectUtil.isNotEmpty(onLineBatchNumberWarnList)) {
-            for (String s : onLineBatchNumberWarnList) {
-                res = res + "<b>" + s + "</b>";
+
+            if (ObjectUtil.isNotEmpty(offLineBatchNumberList)) {
+                res = "<b>" + String.join(",", offLineBatchNumberList) + "是线下批次号，确认领料吗？</b><br>";
             }
+            if (ObjectUtil.isNotEmpty(onLineBatchNumberWarnList)) {
+                for (String s : onLineBatchNumberWarnList) {
+                    res = res + "<b>" + s + "</b>";
+                }
+            }
+        } finally {
+            log.debug("领料校验完毕，从list中清空当前领料锁，批次号：" + batchNumberList);
+            checkAddMaterialLock.removeAll(batchNumberList);
         }
-
         return R.ok(res);
     }
 }

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

@@ -66,8 +66,14 @@ public class ApsProductDetailServiceImpl extends ServiceImpl<ApsProductDetailDao
     @Override
     public R getCustomOrderData(Map<String, Object> params) {
         R r = new R();
+        String curtenantid = params.get("CURTENANTID").toString();
         List<String> orderNos = new ArrayList<>();
         orderNos.add(params.get("CUSTOMORDERNO").toString());
+        List<ApsProductionOrderDo> apsProductionOrderDos = apsProductDetailDao.getProductionOrders(curtenantid, orderNos);
+        if (apsProductionOrderDos.size() > 0) {
+            return R.error("该客户订单已经存在");
+        }
+
         List<VNcOrderVo> vNcOrderVos = slaveSourceService.getVNcOrderVo(orderNos);
         if (vNcOrderVos.size() == 0) {
             return R.error("客户订单系统没有找到该订单");
@@ -630,9 +636,9 @@ public class ApsProductDetailServiceImpl extends ServiceImpl<ApsProductDetailDao
         String alloystatus = orderDetail.getAlloystatus();
 
 //        List<GetOldTechnicalRequirementRes> apsProductDetailDoList = this.baseMapper.selectMyList(technicalRequirementId, orderDetail.getId(), alloy, alloystatus, orderProductTypeId);
-        List<GetOldTechnicalRequirementRes> list1 = this.baseMapper.selectMyList1(technicalRequirementId, orderDetail.getId(),customId, alloy);
-        List<GetOldTechnicalRequirementRes> list2 = this.baseMapper.selectMyList2(technicalRequirementId, orderDetail.getId(),customId, alloystatus);
-        List<GetOldTechnicalRequirementRes> list3 = this.baseMapper.selectMyList3(technicalRequirementId, orderDetail.getId(),customId, orderProductTypeId);
+        List<GetOldTechnicalRequirementRes> list1 = this.baseMapper.selectMyList1(technicalRequirementId, orderDetail.getId(), customId, alloy);
+        List<GetOldTechnicalRequirementRes> list2 = this.baseMapper.selectMyList2(technicalRequirementId, orderDetail.getId(), customId, alloystatus);
+        List<GetOldTechnicalRequirementRes> list3 = this.baseMapper.selectMyList3(technicalRequirementId, orderDetail.getId(), customId, orderProductTypeId);
 
         //合并三个list
         List<GetOldTechnicalRequirementRes> apsProductDetailDoList = new LinkedList<>();

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

@@ -990,6 +990,18 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
                     return R.error("该坯料批次号:" + String.join(",", batchNumbers) + " 已经存在");
                 }
             }
+            if ("铸轧".equals(apsProcessOperationDo.getProcess())&&"是".equals(apsProcessOperationDo.getIfblankprocess())){
+                for (ApsReportOutputDo outputDo:apsReportOutputDoList){
+                    //后端补充校验：当'铸轧'工序并且'是否坯料工序'为是的时候校验输出物料中序列号必须大于等于批次号后三位
+                    if (ObjectUtil.isNotEmpty(outputDo.getOutputnumber())){
+                        //取出批次号最后三位字符串
+                        String lastThreeChars = outputDo.getOutputnumber().substring(outputDo.getOutputnumber().length() - 3);
+                        if (outputDo.getSerialnumber()!= null&&outputDo.getSerialnumber()<Long.parseLong(lastThreeChars)){
+                            return R.error("序列号必须大于等于批次号的后三位");
+                        }
+                    }
+                }
+            }
 
             //=============更新作业明细信息=============
             Integer reduceNum = 1;
@@ -1206,7 +1218,11 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
                     List<ApsWorkInProgressInventoryDo> apsWorkInProgressInventoryDos = apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
                             .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
                             .in(ApsWorkInProgressInventoryDo::getBatchnumber, Arrays.asList(apsReportRecordsDo.getBatchnumber().split(","))));
-                    ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = apsWorkInProgressInventoryDos.get(0);
+                    ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = null;
+                    if (!apsWorkInProgressInventoryDos.isEmpty()) {
+                        apsWorkInProgressInventoryDo = apsWorkInProgressInventoryDos.get(0);
+                    }
+
                     //不为空，则删除数据（逻辑删除）
                     if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDos)) {
                         apsWorkInProgressInventoryService.removeByIds(apsWorkInProgressInventoryDos.stream().map(ApsWorkInProgressInventoryDo::getId).collect(Collectors.toList()));
@@ -2007,7 +2023,7 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
                         //取出批次号最后三位字符串
                         String lastThreeChars = outputCode.substring(outputCode.length() - 3);
                         //校验序列号大小是否大于等于批次号后三位
-                        if (info.getSerialnumber() != null && info.getSerialnumber() != Long.parseLong(lastThreeChars)) {
+                        if (info.getSerialnumber() != null && info.getSerialnumber() >= Long.parseLong(lastThreeChars)) {
                             // 删除批次号原来的后三位字符串，将序列号的三位数字更新到批次号中
                             String newOutput = outputCode.substring(0, outputCode.length() - 3);
                             String formatSerialnumber = String.format("%03d", info.getSerialnumber());

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

@@ -171,8 +171,8 @@
         apope.ACTUALSTARTDATE,
         apope.ACTUALFINISHDATE,
         apo.PROCESSNAME,
-        apo.LOCKMARK as processLock, -- 原工序作业的是否锁定改名
-        apope.LOCKMARKDETAIL as LOCKMARK, -- 增加作业明细的是否锁定字段
+        apo.LOCKMARK, -- 原工序作业的是否锁定改名
+--         apope.LOCKMARKDETAIL as LOCKMARK, -- 增加作业明细的是否锁定字段
         apo.PROCESSWAY,
         abo.ID AS blankOrderId,
         abo.OUTPUTORDERPRODUCT,
@@ -197,14 +197,14 @@
         IF(IFNULL(apope.BLANKBATCHNUMBER,'')='',SUBSTRING_INDEX(abo.PREPAREMATERIALBATCHNO, ',', 1),apope.BLANKBATCHNUMBER),
         IF(apo.PROCESS = "小卷成退"OR apo.PROCESS = "小卷包装",
         CONCAT_WS(',',
-        SUBSTRING_INDEX( trim( BOTH ',' FROM IFNULL(apope.BACHMATERIALPROCESS,'') ), ',', 1 ),
-        SUBSTRING_INDEX( trim( BOTH ',' FROM IFNULL(apope.DOINGBATCHNUMBER,'') ), ',', 1 ),
-        SUBSTRING_INDEX( trim( BOTH ',' FROM IFNULL(apope.REPORTBATCHNUMBER,'') ), ',', 1 )
+        SUBSTRING_INDEX( if(apope.BACHMATERIALPROCESS='',null,trim( BOTH ',' FROM apope.BACHMATERIALPROCESS)), ',', 1 ),
+        SUBSTRING_INDEX( if(apope.DOINGBATCHNUMBER='',null,trim( BOTH ',' FROM apope.DOINGBATCHNUMBER)), ',', 1 ),
+        SUBSTRING_INDEX( if(apope.REPORTBATCHNUMBER='',null,trim( BOTH ',' FROM apope.REPORTBATCHNUMBER)), ',', 1 )
         ),
         CONCAT_WS(',',
-        trim( BOTH ',' FROM IFNULL(apope.BACHMATERIALPROCESS,'') ),
-        trim( BOTH ',' FROM IFNULL(apope.DOINGBATCHNUMBER,'') ),
-        trim( BOTH ',' FROM IFNULL(apope.REPORTBATCHNUMBER,'') )
+        if(apope.BACHMATERIALPROCESS='',null,trim( BOTH ',' FROM apope.BACHMATERIALPROCESS)),
+        if(apope.DOINGBATCHNUMBER='',null,trim( BOTH ',' FROM apope.DOINGBATCHNUMBER)),
+        if(apope.REPORTBATCHNUMBER='',null,trim( BOTH ',' FROM apope.REPORTBATCHNUMBER))
         )
         )
         ) AS SHOWBATCHNUMBER

cx-aps/cx-aps-entity/src/main/java/com/rongwei/bsentity/vo/GanttVos.java

@@ -240,8 +240,8 @@ public class GanttVos {
      * 批次号
      */
     private String showbatchnumber;
-    /**
-     * 工序作业锁定状态
-     */
-    private String processLock;
+//    /**
+//     * 工序作业锁定状态
+//     */
+//    private String processLock;
 }

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

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