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

@@ -0,0 +1,16 @@
+package com.rongwei.bscommon.sys.dao;
+
+import com.rongwei.bsentity.domain.ApsAnnealingDifferenceDo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ * 退火组炉度差 Mapper 接口
+ * </p>
+ *
+ * @author fpy
+ * @since 2024-09-25
+ */
+public interface ApsAnnealingDifferenceDao extends BaseMapper<ApsAnnealingDifferenceDo> {
+
+}

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

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

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

@@ -0,0 +1,16 @@
+package com.rongwei.bscommon.sys.service;
+
+import com.rongwei.bsentity.domain.ApsAnnealingDifferenceDo;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 退火组炉度差 服务类
+ * </p>
+ *
+ * @author fpy
+ * @since 2024-09-25
+ */
+public interface ApsAnnealingDifferenceService extends IService<ApsAnnealingDifferenceDo> {
+
+}

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

@@ -0,0 +1,20 @@
+package com.rongwei.bscommon.sys.service.impl;
+
+import com.rongwei.bsentity.domain.ApsAnnealingDifferenceDo;
+import com.rongwei.bscommon.sys.dao.ApsAnnealingDifferenceDao;
+import com.rongwei.bscommon.sys.service.ApsAnnealingDifferenceService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 退火组炉度差 服务实现类
+ * </p>
+ *
+ * @author fpy
+ * @since 2024-09-25
+ */
+@Service
+public class ApsAnnealingDifferenceServiceImpl extends ServiceImpl<ApsAnnealingDifferenceDao, ApsAnnealingDifferenceDo> implements ApsAnnealingDifferenceService {
+
+}

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/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/java/com/rongwei/bscommon/sys/service/impl/ApsServiceImpl.java

@@ -74,6 +74,8 @@ public class ApsServiceImpl implements ApsService {
     private ApsMergeFurnaceService apsMergeFurnaceService;
     @Autowired
     private ApsProductionOrderService apsProductionOrderService;
+    @Autowired
+    private ApsAnnealingDifferenceService apsAnnealingDifferenceService;
 
     /**
      * Aps排程
@@ -644,6 +646,8 @@ public class ApsServiceImpl implements ApsService {
             if(productionScheduleVo.getStandingyield() == null){
                 productionScheduleVo.setStandingyield(60);
             }
+            productionScheduleVo.setMiddifference(apsScheduleConfig.getMiddifference());
+            productionScheduleVo.setFurnacedifference(apsScheduleConfig.getFurnacedifference());
         } else {
             throw new CustomException("排程参数缺失");
         }
@@ -656,6 +660,9 @@ public class ApsServiceImpl implements ApsService {
         // 小卷退火兼容
         List<ApsMergeFurnaceDo> mergeFurnaceDos = apsMergeFurnaceService.list();
         productionScheduleVo.setMergeFurnaces(mergeFurnaceDos);
+        // 退火合并厚差配置数据
+        List<ApsAnnealingDifferenceDo> apsAnnealingDifferenceDos = apsAnnealingDifferenceService.list();
+        productionScheduleVo.setApsAnnealingDifferences(apsAnnealingDifferenceDos);
         return productionScheduleVo;
     }
 
@@ -844,6 +851,10 @@ public class ApsServiceImpl implements ApsService {
                             String lbtj = null;
                             for (int i = 0; i < lastpros.size(); i++) {
                                 ApsProcessOperationDo apo = lastopsMap.get(lastpros.get(i).getProcessid());
+                                if(apo == null){
+//                                    int aaa = 1;
+                                    continue;
+                                }
                                 String thislbtj = apo.getMetal() + "^_^" + apo.getProducttype() + "^_^" + apo.getProwidth();
                                 if(hasLbs == null){
                                     hasLbs = apo.getSinglerollweight();

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

@@ -0,0 +1,72 @@
+package com.rongwei.bsentity.domain;
+
+import java.math.BigDecimal;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.rongwei.rwcommon.base.BaseDo;
+import java.util.Date;
+import com.baomidou.mybatisplus.annotation.Version;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * <p>
+ * 退火组炉度差
+ * </p>
+ *
+ * @author fpy
+ * @since 2024-09-25
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Accessors(chain = true)
+@TableName("aps_annealing_difference")
+public class ApsAnnealingDifferenceDo extends BaseDo {
+
+    private static final long serialVersionUID=1L;
+
+    /**
+     * 主键ID
+     */
+    @TableId("ID")
+    private String id;
+    /**
+     * 租户ID
+     */
+    @TableField("TENANTID")
+    private String tenantid;
+    /**
+     * 扩展json格式配置
+     */
+    @TableField("ROPTION")
+    private String roption;
+    /**
+     * 厚度起
+     */
+    @TableField("STARTTHICKNESS")
+    private BigDecimal startthickness;
+    /**
+     * 厚度止
+     */
+    @TableField("ENDTHICKNESS")
+    private BigDecimal endthickness;
+    /**
+     * 中退厚差
+     */
+    @TableField("MODERATEDIFFERENCE")
+    private BigDecimal moderatedifference;
+    /**
+     * 成退厚差
+     */
+    @TableField("DECLINEDIFFERENCE")
+    private BigDecimal declinedifference;
+    /**
+     * 主表ID
+     */
+    @TableField("MAINID")
+    private String mainid;
+
+
+}

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

@@ -1,6 +1,7 @@
 package com.rongwei.bsentity.vo;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.rongwei.bsentity.domain.ApsAnnealingDifferenceDo;
 import com.rongwei.bsentity.domain.ApsFurnaceInstallationDo;
 import com.rongwei.bsentity.domain.ApsMergeFurnaceDo;
 import lombok.Data;
@@ -46,6 +47,11 @@ public class ApsOverallConfig implements Serializable {
      */
     private List<ApsMergeFurnaceDo> mergeFurnaces;
 
+    /**
+     * 退火合炉厚差配置表
+     */
+    private List<ApsAnnealingDifferenceDo> apsAnnealingDifferences;
+
     /**
      * 洗炉时间（小时）
      */
@@ -62,5 +68,13 @@ public class ApsOverallConfig implements Serializable {
      * 松散度
      */
     private BigDecimal looseness;
+    /**
+     * 中退组炉宽差,默认：250mm
+     */
+    private Integer middifference;
+    /**
+     * 成退组炉宽差,默认：200mm
+     */
+    private Integer furnacedifference;
 
 }

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

@@ -3,6 +3,7 @@ package com.rongwei.bsentity.vo;
 
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.rongwei.bsentity.domain.ApsAnnealingDifferenceDo;
 import com.rongwei.bsentity.domain.ApsFurnaceInstallationDo;
 import com.rongwei.bsentity.domain.ApsMergeFurnaceDo;
 import lombok.Data;
@@ -67,6 +68,11 @@ public class ProductionScheduleVo {
      */
     private List<ApsMergeFurnaceDo> mergeFurnaces;
 
+    /**
+     * 退火合炉厚差配置表
+     */
+    private List<ApsAnnealingDifferenceDo> apsAnnealingDifferences;
+
     /**
      * 洗炉时间（小时）
      */
@@ -93,5 +99,13 @@ public class ProductionScheduleVo {
      * 除铸轧外期望交货天数
      */
     private Integer expecteddays;
+    /**
+     * 中退组炉宽差,默认：250mm
+     */
+    private Integer middifference;
+    /**
+     * 成退组炉宽差,默认：200mm
+     */
+    private Integer furnacedifference;
 
 }

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-question/cx-question-common/src/main/java/com/rongwei/bscommon/sys/service/impl/SrmIssuesListServiceImpl.java

@@ -248,31 +248,35 @@ public class SrmIssuesListServiceImpl extends ServiceImpl<SrmIssuesListDao, SrmI
         for(SrmIssuesListVo vo:list){
             taskname = vo.getTaskname();
             try {
-                //2.条件判断节点跟超时时间截取数据
-                if (taskname.equals("问题登记人") && System.currentTimeMillis()- vo.getCreatedate().getTime() > twentyFourHoursInMillis){
-                    vo.setNodetime(vo.getCreatedate());
-                    vo.setOperationid(vo.getCreateuserid());
-                    vo.setHour(24);
-                    f= true;
-                } else if ((taskname.equals("部门长") || taskname.equals("生产副总") || taskname.equals("责任部门长") || taskname.equals("车间主任/部门经理审核")
-                        || taskname.equals("车间主任/经理审核")  || taskname.equals("发起人确认")  || taskname.equals("领导审核") || taskname.equals("SPA跟踪"))
-                        && System.currentTimeMillis()- vo.getNodetime().getTime() > fourHoursInMillis) {
-                    f= true;vo.setHour(4);
-                }else if ( (taskname.equals("SPA") || taskname.equals("任务SPA")   || taskname.equals("SPA维护标准化文件"))
-                        && System.currentTimeMillis()- vo.getNodetime().getTime() > fortyEightHoursInMillis) {
-                    f= true;vo.setHour(48);
-                }
-                if (f){
-                    // 生成个人工作台提醒
-                    addNotifyAnnounce(vo,userEmailList,keyMap, issTaskkey);
+                if (vo.getId().equals("1f8feeeae3e041f5a79727730af9f30a")){
+                    //2.条件判断节点跟超时时间截取数据
+                    if (taskname.equals("问题登记人") && System.currentTimeMillis()- vo.getCreatedate().getTime() > twentyFourHoursInMillis){
+                        vo.setNodetime(vo.getCreatedate());
+                        vo.setOperationid(vo.getCreateuserid());
+                        vo.setHour(24);
+                        f= true;
+                    } else if ((taskname.equals("部门长") || taskname.equals("生产副总") || taskname.equals("责任部门长") || taskname.equals("责任部长审核") || taskname.equals("车间主任/部门经理审核")
+                            || taskname.equals("车间主任/经理审核")  || taskname.equals("发起人确认")  || taskname.equals("领导审核") || taskname.equals("SPA跟踪"))
+                            && System.currentTimeMillis()- vo.getNodetime().getTime() > fourHoursInMillis) {
+                        f= true;vo.setHour(4);
+                    }else if ( (taskname.equals("SPA") || taskname.equals("任务SPA")   || taskname.equals("SPA维护标准化文件"))
+                            && System.currentTimeMillis()- vo.getNodetime().getTime() > fortyEightHoursInMillis) {
+                        f= true;vo.setHour(48);
+                    }
+                    if (f){
+                        // 生成个人工作台提醒
+                        addNotifyAnnounce(vo,userEmailList,keyMap, issTaskkey);
+                    }
+                    f=false;
                 }
-                f=false;
+
             }catch (Exception e){
                 log.error(" 节点 {} 问题编号 {} 出现问题 {} ",taskname,vo.getQuestionno(),e.getMessage());
             }
         }
 
         //3.发送邮件
+        log.info("开始发送邮件，人员数量{}",userEmailList.size());
         sendIssuesListEmail(userEmailList);
         log.info("生产问题审批超时提醒结束：");
         return R.ok();

cx-question/cx-question-server/src/main/java/com/rongwei/businessServer/controller/SrmIssuesListController.java

@@ -33,7 +33,7 @@ public class SrmIssuesListController {
      * 生产问题审批超时提醒
      * @return
      */
-    @Scheduled(cron = "0 0/10 * * * ? ")
+  //  @Scheduled(cron = "0 0/10 * * * ? ")
     @PostMapping("/approvalTimeoutReminder")
     public R batchSavePlansTiming(){
         R r = srmIssuesListService.approvalTimeoutReminder();