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

bs-common/src/main/java/com/rongwei/safecommon/utils/SaveConstans.java

@@ -376,7 +376,7 @@ public class SaveConstans {
         /**
          * 安全附件催办提醒
          */
-        public static final String SAFETY_ATTACHMENT_VERIFICATION_URGING_TITLE = "安全附件检验提醒";
+        public static final String SAFETY_ATTACHMENT_VERIFICATION_URGING_TITLE = "安全附件检验--催办提醒";
         /**
          * 报工不合格提醒
          */

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

@@ -60,4 +60,6 @@ public interface ApsBlankOrderService extends IService<ApsBlankOrderDo> {
 
     //插单重新排程
     void insertSchedule(Map<String, Object> params);
+
+    R addMaterial(AddMaterialReq req);
 }

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

@@ -1897,6 +1897,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             blankUpdateWrapper.set(ApsBlankOrderDo::getBlankappearance, apsBlankOrderDo.getBlankappearance());
             blankUpdateWrapper.set(ApsBlankOrderDo::getMaxheatroll, apsBlankOrderDo.getMaxheatroll());
             blankUpdateWrapper.set(ApsBlankOrderDo::getBlankcomefrom, apsBlankOrderDo.getBlankcomefrom());
+            blankUpdateWrapper.set(ApsBlankOrderDo::getIssubmitprocessroute, apsBlankOrderDo.getIssubmitprocessroute());
 
             this.update(blankUpdateWrapper);
         } else {
@@ -2085,6 +2086,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             /**
              * 如果有评审日志，并且变更内容为空，则错误提示：请填写变更内容(暂未实现)
              * 如果有任一坯料计划的承诺交货期-起或止为空，错误提示：请填写所有坯料计划的承诺交货期
+             * 如果有坯料计划的承诺交货期-起<排程交货期-起，错误提示：第{几}个坯料计划的承诺交货期-起不能早于排程交货期-起{排程交货期}
              * 如果有坯料计划的承诺交货期-止 < 排程交货期，错误提示：第{几}个坯料计划的承诺交货期-止不能早于排程交货期{排程交货期}
              */
             if (req.getCheckDevice()) {
@@ -2094,6 +2096,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 if (ObjectUtil.isEmpty(apsBlankOrderDo.getScheduledateend())) {
                     return R.error("第" + j + "个坯料计划 排程交货期-止不能为空");
                 }
+                if (apsBlankOrderDo.getPromisedatestart().compareTo(apsBlankOrderDo.getScheduledatestart()) < 0) {
+                    return R.error("第" + j + "个坯料计划的承诺交货期-起不能早于排程交货期-起" + DateUtil.format(apsBlankOrderDo.getScheduledatestart(), "yyyy-MM-dd"));
+                }
                 if (apsBlankOrderDo.getPromisedateend().compareTo(apsBlankOrderDo.getScheduledateend()) < 0) {
                     return R.error("第" + j + "个坯料计划的承诺交货期-止不能早于排程交货期-止" + DateUtil.format(apsBlankOrderDo.getScheduledateend(), "yyyy-MM-dd"));
                 }
@@ -2964,4 +2969,151 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             processLoadingMap.put(lastProcessId, processLoading);
         }
     }
+
+    @Override
+    @Transactional
+    public R addMaterial(AddMaterialReq req) {
+        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为空");
+        }
+        //分割批次号
+        List<String> batchNumberList = Arrays.asList(req.getBatchNumbers().split(","));
+        //查询坯料计划详情
+        ApsBlankOrderDo apsBlankOrderDo = apsBlankOrderService.getById(req.getBlankId());
+        //如果坯料类型=热轧，检查每个批次号
+        //如果批次号不是9位数，则错误提示：热轧坯料批次号{批次号}错误，应该是9位
+        if (apsBlankOrderDo.getBlanktype().equals("热轧")) {
+            for (String s : batchNumberList) {
+                if (s.length() != 9) {
+                    return R.error("热轧坯料批次号" + s + "错误，应该是9位");
+                }
+            }
+        }
+        //原来的批次号
+        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);
+            }
+        }
+
+
+        /**
+         * 如果坯料类型=铸轧，检查每个批次号
+         * 如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
+         * 如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+         * 如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+         * 如果在制品状态=待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+         * 如果在制品状态=备料中，并且在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+         * 查找该批次号物料=在制品的作业输出物料ID对应输出物料
+         * 如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
+         * 错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+         */
+        //如果坯料类型=铸轧，检查每个批次号
+        if (apsBlankOrderDo.getBlanktype().equals("铸轧")) {
+            List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos =
+                    apsWorkInProgressInventoryService.list(new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                            .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                            .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+            for (String s : addBatchNumberList) {
+                //如果该批次号物料在制品库存中没找到，则错误提示：批次号{批次号}错误
+                ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = workInProgressInventoryDos.stream().filter(item -> item.getBatchnumber().equals(s)).findFirst().orElse(null);
+                if (ObjectUtil.isEmpty(apsWorkInProgressInventoryDo)) {
+                    return R.error("批次号" + s + "错误");
+                }
+
+                //如果在制品备料计划ID不为空，并且不等于该坯料计划ID，错误提示：该坯料已经被其他坯料计划领料
+                if (ObjectUtil.isNotEmpty(apsWorkInProgressInventoryDo.getPlanmaterialid())
+                        && !apsWorkInProgressInventoryDo.getPlanmaterialid().equals(req.getBlankId())) {
+                    ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getById(apsWorkInProgressInventoryDo.getPlanmaterialid());
+                    return R.error("该坯料已经被坯料计划" + blankOrderDo.getBlanknumber() + "领料");
+                }
+
+                //如果在制品状态=待加工或加工中或待检验，错误提示：批次号{批次号}错误，该料卷在加工中
+                if (Arrays.asList("待加工", "加工中", "待检验").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+                    return R.error("批次号" + s + "错误，该料卷在加工中");
+                }
+
+                //如果在制品状态=备料中、待入库或已入库或已出库，并且订单号对应订单的客户的客户类型不是内部客户，错误提示：批次号{批次号}错误，该料卷是其他客户订单的成品
+                if (Arrays.asList("备料中", "待入库", "已入库", "已出库").contains(apsWorkInProgressInventoryDo.getWorkinprocessstatus())) {
+                    ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(apsWorkInProgressInventoryDo.getProcessoperationid());
+                    ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getById(apsProcessOperationDo.getBlankid());
+                    ApsProductionOrderDo apsProductionOrderDo = apsProductionOrderService.getById(blankOrderDo.getProductionorderid());
+
+                    if (ObjectUtil.isNotEmpty(apsProductionOrderDo) && apsProductionOrderDo.getOrdertype().equals("客户订单")) {
+                        return R.error("批次号" + s + "错误，该料卷是其他客户订单的成品");
+                    }
+
+                }
+
+                //如果在制品类型=不良在制品，错误提示：批次号{批次号}错误，该料卷检验不合格
+                if (apsWorkInProgressInventoryDo.getWorkinprocesstype().equals("不良在制品")) {
+                    return R.error("批次号" + s + "错误，该料卷检验不合格");
+                }
+
+                //查找该批次号物料=在制品的作业输出物料ID对应输出物料
+                //如果{该批次号物料的输入物料描述}与{坯料的输入物料描述}不相同，
+                //错误提示：该批次号{批次号}物料：{该批次号物料的输入物料描述}不是该坯料计划所需的坯料{坯料的输入物料描述}
+
+                String joboutputmaterialid = apsWorkInProgressInventoryDo.getJoboutputmaterialid();
+                ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo = apsProcessOperationOutMaterService.getById(joboutputmaterialid);
+                String s1 = apsProcessOperationOutMaterDo.getOutputfinishproduct().split(" ")[0];
+                String s2 = apsBlankOrderDo.getInputreportdescribe();
+                if (!s1.equals(s2)) {
+                    return R.error("该批次号" + s + "物料：" + s1 + "不是该坯料计划所需的坯料" + s2 + "");
+                }
+            }
+        }
+
+        /**
+         * 检验通过，
+         * 原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
+         * 更新坯料计划的第一道工序作业的所有工序作业明细的待加工料卷批次号=领料批次号逗号拼接
+         * 在制品的在制品状态=待加工
+         * 在制品的备料计划ID=该坯料计划ID
+         */
+        //原批次号（修改前的值），对应的所有在制品的在制品状态=备料中，在制品的备料计划ID=(空)
+        apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, null)
+                .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "备料中")
+                .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
+        apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                .set(ApsWorkInProgressInventoryDo::getPlanmaterialid, req.getBlankId())
+                .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "待加工")
+                .eq(ApsWorkInProgressInventoryDo::getDeleted, "0")
+                .in(ApsWorkInProgressInventoryDo::getBatchnumber, addBatchNumberList));
+
+        return R.ok();
+    }
 }

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

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

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

@@ -99,9 +99,10 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
         apsReportCheckoutService.remove(new QueryWrapper<ApsReportCheckoutDo>().lambda().eq(ApsReportCheckoutDo::getMainid, recordId));
 
         //批次号list
-        List<String> batchNumberList = Arrays.asList(recordsDo.getBatchnumber().split(","));
+        List<String> batchNumberList = new LinkedList<>();
         //更新输入物料在制品：如果输入物料有批次号，并且在制品库存中有输入物料批次号的在制品，则更新该在制品的在制品状态=待加工
         if (ObjectUtil.isNotEmpty(recordsDo.getBatchnumber())) {
+            batchNumberList = Arrays.asList(recordsDo.getBatchnumber().split(","));
             ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = new ApsWorkInProgressInventoryDo();
             apsWorkInProgressInventoryDo.setWorkinprocessstatus("待加工");
             apsWorkInProgressInventoryService.update(apsWorkInProgressInventoryDo, new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
@@ -949,11 +950,11 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
             needUpdate.setId(outputDo.getId());
             String outputdesc = "";
             outputdesc += outputDo.getOutputmaterial().split(" ")[0];
-            outputdesc += " 厚" + outputDo.getThickness() + "*宽" + outputDo.getWidth();
+            outputdesc += " 厚" + CXCommonUtils.removeExtraZerosAndDecimal(outputDo.getThickness()) + "*宽" + CXCommonUtils.removeExtraZerosAndDecimal(outputDo.getWidth());
             if (ObjectUtil.isNotEmpty(outputDo.getLength())) {
-                outputdesc += "*长" + outputDo.getLength();
+                outputdesc += "*长" + CXCommonUtils.removeExtraZerosAndDecimal(outputDo.getLength());
             }
-            outputdesc += " mm " + outputDo.getWeight() + "吨";
+            outputdesc += " mm " + CXCommonUtils.removeExtraZerosAndDecimal(outputDo.getWeight()) + "吨";
             needUpdate.setOutputdesc(outputdesc);
             apsReportOutputService.updateById(needUpdate);
         }
@@ -982,8 +983,15 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
                                          OrganizationCodeAndDeviceCodeVo organizationCodeAndDeviceCodeVo,
                                          ApsProductionOrderDo apsProductionOrderDo,
                                          ApsBlankOrderDo apsBlankOrderDo) {
+        //获取所有报工输出物料对应的工序输出物料
+        List<String> apsProcessMaterialIds = apsReportOutputDos.stream().map(ApsReportOutputDo::getOutputid).distinct().collect(Collectors.toList());
+        Collection<ApsProcessOperationOutMaterDo> apsProcessOperationOutMaterDos = apsProcessOperationOutMaterService.listByIds(apsProcessMaterialIds);
+
         List<ApsWorkInProgressInventoryDo> needAddWorkInProgressInventoryList = new LinkedList<>();
         for (ApsReportOutputDo apsReportOutputDo : apsReportOutputDos) {
+            //获取报工输出物料对应的工序输出物料
+            ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo = apsProcessOperationOutMaterDos.stream().filter(item -> item.getId().equals(apsReportOutputDo.getOutputid())).findFirst().orElse(null);
+
             ApsWorkInProgressInventoryDo workInProgressInventoryDo = new ApsWorkInProgressInventoryDo();
             workInProgressInventoryDo.setId(SecurityUtil.getUUID());
             //获取当前用户相关信息
@@ -1031,6 +1039,25 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
             //报工记录对应工序作业的订单号
             workInProgressInventoryDo.setOrdernumber(apsProductionOrderDo.getOrderno());
             workInProgressInventoryDo.setWorkinprocessstatus("待检验");
+            //客户订单号
+            workInProgressInventoryDo.setCustomorderno(apsProductionOrderDo.getCustomorderno());
+            //订单类型
+            workInProgressInventoryDo.setOrdertype(apsProductionOrderDo.getOrdertype());
+            //作业输出物料
+            String outPut = "";
+            try {
+                outPut = apsProcessOperationOutMaterDo.getMetal()
+                        + apsProcessOperationOutMaterDo.getMetalstate()
+                        + apsProcessOperationOutMaterDo.getProducttype()
+                        + " 厚" + CXCommonUtils.removeExtraZerosAndDecimal(apsProcessOperationOutMaterDo.getThickness())
+                        + "*宽" + CXCommonUtils.removeExtraZerosAndDecimal(apsProcessOperationOutMaterDo.getProwidth());
+                if (ObjectUtil.isNotEmpty(apsProcessOperationOutMaterDo.getProlength())
+                        && !CXCommonUtils.removeExtraZerosAndDecimal(apsProcessOperationOutMaterDo.getProlength()).equals("0")) {
+                    outPut = outPut + "*长" + CXCommonUtils.removeExtraZerosAndDecimal(apsProcessOperationOutMaterDo.getProlength());
+                }
+            } catch (Exception ignored) {
+            }
+            workInProgressInventoryDo.setJoboutputmaterial(outPut);
 
             needAddWorkInProgressInventoryList.add(workInProgressInventoryDo);
         }

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

@@ -407,6 +407,9 @@ public class GanttServiceImpl implements GanttService {
                 dateVo.setWorkstatus(ganttVos.stream().map(GanttVos::getWorkstatus).distinct().collect(Collectors.joining(",")));
                 dateVo.setLockmark(ganttVos.stream().map(GanttVos::getLockmark).distinct().collect(Collectors.joining(",")));
                 dateVo.setProductionorderid(ganttVos.stream().map(GanttVos::getProductionorderid).collect(Collectors.joining(",")));
+                dateVo.setPlanhavematerialdate( ganttVos.stream().filter(data -> data.getPlanhavematerialdate() != null)
+                        .max(Comparator.comparing(GanttVos::getPlanhavematerialdate))
+                        .map(GanttVos::getPlanhavematerialdate).orElse(null));
                 // 冲突描述
                 List<GanttVos> conflictdes = ganttVos.stream().filter(v -> StringUtils.isNotBlank(v.getConflictdes())).collect(Collectors.toList());
                 if (!conflictdes.isEmpty()) {

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

@@ -188,7 +188,8 @@
         Date(a6.SCHEDULEDELIVERYDATE) as SCHEDULEDELIVERYDATE,
         a7.CUSTOMERABBREVIATION as CUSTOMERABBREVIATION,
         a7.CUSTOMERUNIT,
-        a3.BLANKNUMBER as blankNumber
+        a3.BLANKNUMBER as blankNumber,
+        a3.PLANHAVEMATERIALDATE as planhavematerialdate
         FROM
         aps_process_operation_process_equ a1
         LEFT JOIN aps_process_operation a2 ON a1.PROCESSID = a2.ID
@@ -369,13 +370,14 @@
                     #{id}
                 </foreach>
             </if>
+            and apo.CANCHOOSEDEVICEID is not null
             GROUP BY  aci.ID
             <if test="idList !=null and idList.size() >1">
                 <!-- 存在多选工序作业时 筛选共有的设备 -->
                 <bind name="idLength" value="idList.size()"/>
                 HAVING count(*)>=#{idLength}
             </if>
-            order by c.VALUE,aci.CHECKITEMNAME asc
+            ORDER BY aci.USEDEPTNAME,aci.CHECKITEMNAME,aci.CHECKITEMNAME ASC
         </where>
     </select>
     <select id="checkConflict" resultType="java.lang.String">

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

@@ -302,5 +302,10 @@ public class ApsBlankOrderDo extends BaseDo {
      */
     @TableField("EXPECTEDDAYS")
     private Integer expecteddays;
+    /**
+     * 是否提交工艺路线
+     */
+    @TableField("ISSUBMITPROCESSROUTE")
+    private String issubmitprocessroute;
 
 }

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

@@ -148,6 +148,21 @@ public class ApsWorkInProgressInventoryDo extends BaseDo implements Serializable
      */
     private String planmaterialid;
 
+    /**
+     * 客户订单号
+     */
+    private String customorderno;
+
+    /**
+     * 订单类型
+     */
+    private String ordertype;
+
+    /**
+     * 作业输出物料
+     */
+    private String joboutputmaterial;
+
     @TableField(exist = false)
     private static final long serialVersionUID = 1L;
 }

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

@@ -0,0 +1,23 @@
+package com.rongwei.bsentity.vo;
+
+import lombok.Data;
+
+/**
+ * @author ：sc
+ * @since ：2024/9/19
+ */
+@Data
+public class AddMaterialReq {
+    //批次号 多个英文逗号隔开
+    private String batchNumbers;
+
+    //坯料计划ID
+    private String blankId;
+
+    //旧的批次号
+    private String oldBatchNumbers;
+
+    //坯料计划第一道工序作业的ID
+    private String processId;
+
+}

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

@@ -221,4 +221,8 @@ public class GanttVos {
      * 坯料计划编号
      */
     private String blankNumber;
+    /**
+     * 预计来料日期
+     */
+    private Date planhavematerialdate;
 }

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

@@ -127,6 +127,10 @@ public class ScheduleGanttVo {
      * 坯料计划编号
      */
     private String blankNumber;
+    /**
+     * 预计来料日期
+     */
+    private Date planhavematerialdate;
     /**
      * 详细对象
      */

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

@@ -5,10 +5,7 @@ import com.rongwei.bscommon.sys.service.ApsBlankOrderService;
 import com.rongwei.bscommon.sys.service.ApsService;
 import com.rongwei.bsentity.domain.ApsBlankOrderDo;
 import com.rongwei.bsentity.domain.ApsProductionTechnicalRequirementDo;
-import com.rongwei.bsentity.vo.ApsPlanVo;
-import com.rongwei.bsentity.vo.CheckAndSaveOrUpdateBlankReq;
-import com.rongwei.bsentity.vo.CheckScheduleReq;
-import com.rongwei.bsentity.vo.OrderLockVo;
+import com.rongwei.bsentity.vo.*;
 import com.rongwei.rwcommon.base.R;
 import com.rongwei.rwcommon.vo.CriteriaQuery;
 import lombok.extern.slf4j.Slf4j;
@@ -200,5 +197,14 @@ public class ApsBlankOrderController {
         log.info("生产计划跟踪报表，入参为：{}", req);
         return apsBlankOrderService.productPlanReport(req);
     }
+
+    /**
+     * 领料
+     */
+    @PostMapping("/addMaterial")
+    public R addMaterial(@RequestBody AddMaterialReq req){
+        log.info("领料 入参：{}", req);
+        return apsBlankOrderService.addMaterial(req);
+    }
 }
 

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

@@ -4,6 +4,7 @@ import com.rongwei.rwcommon.base.R;
 import com.rongwei.rwcommon.vo.MailDo;
 import com.rongwei.safecommon.utils.CXCommonUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
 
 import java.util.List;
 
@@ -24,6 +25,7 @@ public interface UrgingService {
      * @param content 内容
      * @param reMails 收件人
      */
+    @Async("customThreadPool")
     default void sendEmail(String title,String content,String[] reMails) {
         MailDo mailDo = new MailDo();
         mailDo.setReceiveEmail(reMails);

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

@@ -285,7 +285,7 @@ public class CheckItemsServiceImpl extends ServiceImpl<CheckItemsDao, CheckItems
                 //设备名称
                 String checkitemname = ObjectUtil.isNotEmpty(checkItemsDo.getCheckitemname()) ? checkItemsDo.getCheckitemname() : "";
                 //下次检验日期
-                Date devicecheckdate = checkItemsDo.getDevicecheckdate();
+                Date devicecheckdate = checkItemsDo.getNextcheckdate();
                 String checkDate = "";
                 if (ObjectUtil.isNotEmpty(devicecheckdate)) {
                     checkDate = DateUtil.format(devicecheckdate, "yyyy-MM-dd");

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

@@ -22,6 +22,7 @@ import java.util.stream.Collectors;
 
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyContent.SAFETY_ATTACHMENT_VERIFICATION_URGING_CONTENT;
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyTitle.SAFETY_ATTACHMENT_VERIFICATION_URGING_TITLE;
+import static com.rongwei.safecommon.utils.SaveConstans.NotifyType.SAFETY_ATTACHMENT_VERIFICATION;
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyType.SPECIALEQUIPMENT;
 
 /**
@@ -68,7 +69,7 @@ public class SecurityAttachmentsUrgingServiceImpl implements UrgingService {
                 String.format(SAFETY_ATTACHMENT_VERIFICATION_URGING_CONTENT, currentUser.getName(), safeAttachmentsDos.size())
                 , userInfo.stream().map(UserMailOrgVo::getId).collect(Collectors.toList()),
                 safeAttachmentsDos.stream().map(AspSafeAttachmentsDo::getId).collect(Collectors.joining(","))
-                , SPECIALEQUIPMENT);
+                , SAFETY_ATTACHMENT_VERIFICATION);
 
         // 收件箱
         String[] array = userInfo.stream().map(UserMailOrgVo::getEmail).filter(StringUtils::isNotBlank).toArray(String[]::new);
@@ -93,6 +94,6 @@ public class SecurityAttachmentsUrgingServiceImpl implements UrgingService {
         }
         // 发送通知邮件
         sendEmail(SAFETY_ATTACHMENT_VERIFICATION_URGING_TITLE, String.format(MAIL_CONTENT, currentUser.getName(), StringUtils.join(str, "\n")), array);
-        return null;
+        return R.ok("催办成功");
     }
 }

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

@@ -25,6 +25,7 @@ import static com.rongwei.safecommon.utils.SaveConstans.NotifyContent.PERSONNEL_
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyContent.SAFETY_ATTACHMENT_VERIFICATION_URGING_CONTENT;
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyTitle.PERSONNEL_CERTIFICATES_URGING_TITLE;
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyTitle.SAFETY_ATTACHMENT_VERIFICATION_URGING_TITLE;
+import static com.rongwei.safecommon.utils.SaveConstans.NotifyType.PERSONNEL_CERTIFICATES;
 import static com.rongwei.safecommon.utils.SaveConstans.NotifyType.SPECIALEQUIPMENT;
 
 /**
@@ -71,7 +72,7 @@ public class SpecialCertificateUrgingServiceImpl implements UrgingService {
                         aspSpecialEquipmentCertificateDos.size())
                 , userInfo.stream().map(UserMailOrgVo::getId).collect(Collectors.toList()),
                 aspSpecialEquipmentCertificateDos.stream().map(AspSpecialEquipmentCertificateDo::getId).collect(Collectors.joining(","))
-                , SPECIALEQUIPMENT);
+                , PERSONNEL_CERTIFICATES);
         // 收件箱
         String[] array = userInfo.stream().map(UserMailOrgVo::getEmail).filter(StringUtils::isNotBlank).toArray(String[]::new);
         if (array.length == 0) {
@@ -85,9 +86,9 @@ public class SpecialCertificateUrgingServiceImpl implements UrgingService {
         List<String> str = new ArrayList<>();
         for (int i = 0; i < aspSpecialEquipmentCertificateDos.size(); i++) {
             aspSpecialEquipmentCertificateDo = aspSpecialEquipmentCertificateDos.get(i);
-            String jobType = aspSpecialEquipmentCertificateDo.getJobtype();
+            String certificatesort = aspSpecialEquipmentCertificateDo.getCertificatesort();
             SysDictDo sysDictDo = sysDictDoList.stream()
-                    .filter(data -> data.getValue().equals(jobType))
+                    .filter(data -> data.getValue().equals(certificatesort))
                     .findFirst()
                     .orElse(null);
             str.add(String.format(MAIL_CONTENT_ITEM, i + 1, aspSpecialEquipmentCertificateDo.getName(),
@@ -96,6 +97,6 @@ public class SpecialCertificateUrgingServiceImpl implements UrgingService {
         }
         // 发送通知邮件
         sendEmail(PERSONNEL_CERTIFICATES_URGING_TITLE, String.format(MAIL_CONTENT,currentUser.getName(), StringUtils.join(str, "\n")), array);
-        return R.ok();
+        return R.ok("催办成功");
     }
 }

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

@@ -35,7 +35,7 @@ public class SpecialEquipmentUrgingServiceImpl implements UrgingService {
     public static final String MAIL_CONTENT = "  您好！【%s】提醒您，有如下特种设备即将年检到期，请尽快处理！\n" +
             "%s" +
             "\n详见安全生产平台，如果无法点击请复制链接到浏览器中：http://192.168.100.78/#/page/lr/9329c07dd31b4b8b95d4decaa021adc3";
-    public static final String MAIL_CONTENT_ITEM = "  %d、设备类型：【%s】，设备编号：【%s】，设备名称：【%s】，检验日期：【%tF】";
+    public static final String MAIL_CONTENT_ITEM = "  %d、设备类型：【%s】，出厂编号：【%s】，设备名称：【%s】，检验日期：【%tF】";
     public static final List<String> ROLE_CODE_LIST = new ArrayList<String>() {{
         add("code-safe");
         add("role031");
@@ -88,12 +88,12 @@ public class SpecialEquipmentUrgingServiceImpl implements UrgingService {
                     .findFirst()
                     .orElse(null);
             str.add(String.format(MAIL_CONTENT_ITEM, i + 1, sysDictDo == null ? "" : sysDictDo.getName(),
-                    checkItemsDo.getDevicecode(), checkItemsDo.getCheckitemname(),
+                    checkItemsDo.getDeviceoutcode(), checkItemsDo.getCheckitemname(),
                     checkItemsDo.getNextcheckdate()));
         }
 
         // 发送通知邮件
         sendEmail(SPECIALEQUIPMENT_URGING_TITLE, String.format(MAIL_CONTENT, currentUser.getName(), StringUtils.join(str, "\n")), array);
-        return R.ok();
+        return R.ok("催办成功");
     }
 }

cx-safe-check/cx-save-check-server/src/main/java/com/rongwei/savecheck/controller/UrgingController.java

@@ -1,5 +1,6 @@
 package com.rongwei.savecheck.controller;
 
+import com.rongwei.rwcommon.base.R;
 import com.rongwei.rwcommon.utils.SpringContextUtils;
 import com.rongwei.rwcommon.utils.StringUtils;
 import com.rongwei.sfcommon.sys.service.UrgingService;
@@ -10,6 +11,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -37,32 +39,30 @@ public class UrgingController {
     private final Logger log = LoggerFactory.getLogger(this.getClass().getName());
 
     @PostMapping("/send")
-    public void complaintForm(@RequestBody Map<String, List<String>> params) {
-        log.info("开发发送催办提醒：{}",params);
-        params.forEach((k, v) -> {
-            if (StringUtils.isBlank(k)) {
-                log.error("催办类型为空");
-                return;
-            }
-            if (v == null) {
-                log.error("催办数据ID为空");
-                return;
-            }
-            UrgingService urgingService;
-            if (SPECIAL_EQUIPMENT.equals(k)) {
-                urgingService = SpringContextUtils.getBean("specialEquipmentUrgingServiceImpl");
-            } else if (SPECIAL_CERTIFICATE.equals(k)) {
-                urgingService = SpringContextUtils.getBean("specialCertificateUrgingServiceImpl");
-            } else if (SECURITY_ATTACHMENTS.equals(k)) {
-                urgingService = SpringContextUtils.getBean("securityAttachmentsUrgingServiceImpl");
-            } else {
-                log.error("催办类型不正确：{}", k);
-                urgingService = null;
-            }
-            if (urgingService != null) {
-                log.error("当前催办类型为：{},需要被催办的数据为：{}", k, v);
-                urgingService.emailAndNotifyUrging(v);
-            }
-        });
+    public R complaintForm(@RequestBody Map<String, List<String>> params) {
+        log.info("开发发送催办提醒：{}", params);
+
+        List<String> dataIds;
+        String beanName;
+        if (params.containsKey(SPECIAL_EQUIPMENT)) {
+            beanName = "specialEquipmentUrgingServiceImpl";
+            dataIds = params.getOrDefault(SPECIAL_EQUIPMENT, new ArrayList<>());
+        } else if (params.containsKey(SPECIAL_CERTIFICATE)) {
+            beanName = "specialCertificateUrgingServiceImpl";
+            dataIds = params.getOrDefault(SPECIAL_CERTIFICATE, new ArrayList<>());
+        } else if (params.containsKey(SECURITY_ATTACHMENTS)) {
+            beanName = "securityAttachmentsUrgingServiceImpl";
+            dataIds = params.getOrDefault(SECURITY_ATTACHMENTS, new ArrayList<>());
+        } else {
+            beanName = "";
+            dataIds = new ArrayList<>();
+        }
+        if (StringUtils.isBlank(beanName) || dataIds == null || dataIds.isEmpty()) {
+            log.error("催办类型不正确：{}或者暂无需要催办的数据：{}", params.keySet(), dataIds);
+            return R.error("当前类型暂不支持催办");
+        }
+        UrgingService urgingService = SpringContextUtils.getBean(beanName);
+        log.error("当前催办类型为：{},需要被催办的数据为：{}", beanName, dataIds);
+        return urgingService.emailAndNotifyUrging(dataIds);
     }
 }