aps-订单评审表单校验和保存事务化

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

@@ -39,4 +39,5 @@ public interface ApsBlankOrderService extends IService<ApsBlankOrderDo> {
     R insertOrder(Map<String, Object> params) throws Exception;
 
     R checkAndSaveOrUpdateBlank(CheckAndSaveOrUpdateBlankReq req);
+    R checkBlankOrder(CheckAndSaveOrUpdateBlankReq req, int i);
 }

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

@@ -711,8 +711,8 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                                             .gt(ApsProcessOperationProcessEquDo::getPlanstartdate, productionScheduleVo.getApsPlanStartDate())
                                             .orderByAsc(ApsProcessOperationProcessEquDo::getPlanstartdate)
                                     );
-                                    if(processLastEqus != null && processLastEqus.size()>0){
-                                        ApsProcessOperationProcessEquDo lastpro = processLastEqus.get(processLastEqus.size()-1);
+                                    if (processLastEqus != null && processLastEqus.size() > 0) {
+                                        ApsProcessOperationProcessEquDo lastpro = processLastEqus.get(processLastEqus.size() - 1);
                                         ApsProcessOperationDo lastop = apsProcessOperationService.getById(lastpro.getProcessid());
                                         equipment.setLastProcessType(lastop.getProcess());
                                         // 铸轧
@@ -733,9 +733,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                                             processIds.add(equs.getProcessid());
                                         }
                                         List<ApsProcessOperationDo> processOperationDos = null;
-                                        if(processIds.size()>0){
+                                        if (processIds.size() > 0) {
                                             processOperationDos = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
-                                                    .in(ApsProcessOperationDo::getId,processIds));
+                                                    .in(ApsProcessOperationDo::getId, processIds));
                                         }
 
                                         List<EquipmentRunTime> equipmentRunTimes = new ArrayList<>();
@@ -745,9 +745,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                                             er.setEndRunTime(equs.getPlanenddate().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime());
                                             equipmentRunTimes.add(er);
                                             // 设备占用时间设置连续生产标识，参与排程
-                                            if(processOperationDos != null){
+                                            if (processOperationDos != null) {
                                                 List<ApsProcessOperationDo> pos = processOperationDos.stream().filter(v -> v.getId().equals(equs.getProcessid())).collect(Collectors.toList());
-                                                if(pos != null && pos.size()>0){
+                                                if (pos != null && pos.size() > 0) {
                                                     ApsProcessOperationDo processesDo = pos.get(0);
                                                     er.setProcessType(processesDo.getProcess());
                                                     // 铸轧
@@ -797,7 +797,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                         processes.setUnitProduceTime(operationDo.getOnceprocessmin().intValue());
 //                        processes.setProduceTime(processes.getUnitProduceTime()*processes.getProducePcNum());
                         processes.setProduceTime(operationDo.getProcesstotaltime().intValue());
-                        if(operationDo.getMinflowwaitmin() != null){
+                        if (operationDo.getMinflowwaitmin() != null) {
                             processes.setMinWaitTime(operationDo.getMinflowwaitmin().intValue());
                         }
                         if (operationDo.getMaxflowwaitmin() != null) {
@@ -829,7 +829,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             }
         }
         // 合并生产工序
-        List<ProductionProcesses> productionProcesses = mergeProcesses(processOperationMs, eqMaps,apsScheduleConfig);
+        List<ProductionProcesses> productionProcesses = mergeProcesses(processOperationMs, eqMaps, apsScheduleConfig);
         processesList.addAll(productionProcesses);
         // 加工时间松散度设置
         /*if(looseness != null){
@@ -849,7 +849,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
      * @param processOperationMs
      * @return
      */
-    private List<ProductionProcesses> mergeProcesses(List<ApsProcessOperationVo> processOperationMs, Map<String, AspCheckItemsDo> eqMaps,ApsScheduleConfigDo apsScheduleConfig) {
+    private List<ProductionProcesses> mergeProcesses(List<ApsProcessOperationVo> processOperationMs, Map<String, AspCheckItemsDo> eqMaps, ApsScheduleConfigDo apsScheduleConfig) {
         // 最终的合并工序
         List<ProductionProcesses> processesList = new ArrayList<>();
         if (processOperationMs != null && processOperationMs.size() > 0) {
@@ -880,7 +880,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 aspCheckItemMap.put(aspCheckItemsDo.getId(), aspCheckItemsDo);
                 aspCheckItemUse.put(aspCheckItemsDo.getId(), 0);
                 // 退火炉套筒间隙扣除
-                if(apsScheduleConfig != null){
+                if (apsScheduleConfig != null) {
                     aspCheckItemsDo.setEquipmentwidth(aspCheckItemsDo.getEquipmentwidth().subtract(apsScheduleConfig.getLooseness()));
                 }
             }
@@ -1143,7 +1143,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
     }
 
-    private void checkIfCanMerge(){
+    private void checkIfCanMerge() {
 
     }
 
@@ -1181,8 +1181,8 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         // 更工序作业生产状态=待排程，是否锁定=否，
         apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
                 .in(ApsProcessOperationDo::getBlankid, blankids)
-                .set(ApsProcessOperationDo::getProcessstatus,TO_BE_SCHEDULED)
-                .set(ApsProcessOperationDo::getLockmark,LOCKMARK_N)
+                .set(ApsProcessOperationDo::getProcessstatus, TO_BE_SCHEDULED)
+                .set(ApsProcessOperationDo::getLockmark, LOCKMARK_N)
         );
         // 清空作业明细
         processOperationProcessEquService.remove(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
@@ -1403,7 +1403,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             apsWorkInProgressInventoryService.updateById(apsWorkInProgressInventoryDo);
 
             //借调逻辑
-            if (progressWork.getWorkinprocessstatus().equals(SaveConstans.WorkInProgressStatus.WAIT_WORK)) {
+            if (ObjectUtil.isNotEmpty(progressWork) && ObjectUtil.isNotEmpty(progressWork.getWorkinprocessstatus()) && progressWork.getWorkinprocessstatus().equals(SaveConstans.WorkInProgressStatus.WAIT_WORK)) {
                 //获取该在制品的工序作业ID
                 String processoperationid = progressWork.getProcessoperationid();
                 //获取该在制品的批次号
@@ -1425,4 +1425,158 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         return R.ok();
     }
 
+
+    public R checkBlankOrder(CheckAndSaveOrUpdateBlankReq req, int j) {
+        //获取坯料计划内容
+        ApsBlankOrderDo apsBlankOrderDo = req.getApsBlankOrderDo();
+        //获取当前用户信息
+        //获取当前用户的所属工厂
+        SysUserVo currentUser = CXCommonUtils.getCurrentUser();
+        String tenantId = currentUser.getOrganizationDoList().get(0).getFullpid().split(",")[1];
+
+
+        //=============校验坯料长度=================
+        //如果坯料产品类型对应产品外观类型是铝板或板锭，并且坯料长度为空，则提示：坯料是铝板和板锭时长度必填
+        if (ObjectUtil.isNotEmpty(apsBlankOrderDo.getProducttypeid())) {
+            //目前数据字典存在3层关系，选择只能选择最后一层，二开查询最后一层的父节点对应数据的父节点，判断是否为铝板或板锭的主键ID
+            String pid = this.baseMapper.selectDictAboutProductType(apsBlankOrderDo.getProductionorderid());
+            //如果是铝板或板锭
+            if (ObjectUtil.isNotEmpty(pid) && (pid.equals(SaveConstans.ProductionType.BANDING_ID) || pid.equals(SaveConstans.ProductionType.LVBAN_ID))) {
+                //坯料长度为空
+                if (ObjectUtil.isEmpty(apsBlankOrderDo.getProlength())) {
+                    return R.error("第" + j + "个坯料计划 坯料是铝板和板锭时长度必填");
+                }
+            }
+        }
+        //==============拼接工艺路线输出成品==============
+        //查询坯料计划对应工艺路线的输出成品
+        List<String> processOutputList = this.baseMapper.selectProcessByBlankId(apsBlankOrderDo.getId());
+        if (processOutputList != null && processOutputList.size() > 0) {
+            String outputProcessMaterial = "";
+            //排序
+            processOutputList.sort(String::compareTo);
+            for (int i = 0; i < processOutputList.size(); i++) {
+                outputProcessMaterial += "[" + (i + 1) + "]" + processOutputList.get(i);
+                if (i < processOutputList.size() - 1) {
+                    outputProcessMaterial += ",\r\n";
+                }
+            }
+            apsBlankOrderDo.setOutputmaterial(outputProcessMaterial);
+        } else {
+            return R.error("第" + j + "个坯料计划 工艺路线没有输出成品");
+        }
+
+        //=============校验输出成品==============
+        //产品明细
+        List<ApsProductDetailDo> apsProductDetailDoList = req.getApsProductDetailDoList();
+        //输出成品
+        List<ApsProcessOutputProductDo> apsProcessOutputProductDoList = req.getApsProcessOutputProductDoList();
+
+        //如果坯料计划未开工(生产状态<=30)
+        if (apsBlankOrderDo.getProductstatus().compareTo(TO_BE_STARTED) <= 0) {
+            for (ApsProcessOutputProductDo apsProcessOutputProductDo : apsProcessOutputProductDoList) {
+                boolean haveProductDetail = false;
+                for (ApsProductDetailDo apsProductDetailDo : apsProductDetailDoList) {
+                    //判断是否存在对应的产品明细
+                    if (apsProcessOutputProductDo.getProductid().equals(apsProductDetailDo.getId())) {
+                        haveProductDetail = true;
+
+                        if (apsProductDetailDo.getInputmaterialdescription().equals(apsProcessOutputProductDo.getProductname())) {
+                            //如果输出单卷重<单卷重（起）或 输出单卷重>单卷重（止），错误提示：输出成品：{订单产品} 输出单卷重不符合订单要求
+                            if (apsProcessOutputProductDo.getOutputonerollweigth().compareTo(apsProductDetailDo.getSinglerollweightstart()) < 0
+                                    || apsProcessOutputProductDo.getOutputonerollweigth().compareTo(apsProductDetailDo.getSinglerollweightend()) > 0) {
+                                return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 输出单卷重不符合订单要求");
+                            }
+                        } else {//如果对应订单产品明细的订单产品字段值不等于输出成品的订单产品字段值，错误提示：输出成品：{订单产品} 对应订单产品已修改或已删除，请重新选择订单产品
+                            return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 对应订单产品已修改或已删除，请重新选择订单产品");
+                        }
+                        break;
+                    }
+                }
+                //存在对应的产品明细
+                if (haveProductDetail) {
+                    //如果输出单卷重>坯料单卷重，错误提示：输出单卷重不能超过坯料单卷重
+                    //（注意：成品重量和坯料重量单位吨和公斤需要转换后比较）
+                    //转化单卷重 单位统一为 公斤（kg）
+
+                    //输出的单卷重
+                    BigDecimal outputWeight = new BigDecimal(0);
+                    //坯料的单卷重
+                    BigDecimal blankWeight = new BigDecimal(0);
+                    //统一输出的重量
+                    //公斤/千克
+                    if (apsProcessOutputProductDo.getCountunit().equals(SaveConstans.CountUnit.KG)) {
+                        outputWeight = apsProcessOutputProductDo.getOutputonerollweigth();
+                    }
+                    //吨
+                    if (apsProcessOutputProductDo.getCountunit().equals(SaveConstans.CountUnit.TON)) {
+                        outputWeight = apsProcessOutputProductDo.getOutputonerollweigth().multiply(new BigDecimal(1000));
+                    }
+
+                    //统一坯料的重量
+                    if (apsBlankOrderDo.getNumberunit().equals(SaveConstans.CountUnit.KG)) {
+                        blankWeight = apsBlankOrderDo.getSinglerollweight();
+                    }
+                    if (apsBlankOrderDo.getNumberunit().equals(SaveConstans.CountUnit.TON)) {
+                        blankWeight = apsBlankOrderDo.getSinglerollweight().multiply(new BigDecimal(1000));
+                    }
+                    //输出单卷重>坯料单卷重
+                    if (outputWeight.compareTo(blankWeight) > 0) {
+                        return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 输出单卷重不能超过坯料单卷重");
+                    }
+                } else {//不存在对应的产品明细
+                    return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 对应订单产品已修改或已删除，请重新选择订单产品");
+                }
+            }
+        }
+
+        //不论坯料计划的状态，需要增加的判断
+        for (ApsProcessOutputProductDo apsProcessOutputProductDo : apsProcessOutputProductDoList) {
+            boolean haveProductDetail = false;
+            for (ApsProductDetailDo apsProductDetailDo : apsProductDetailDoList) {
+                //判断是否存在对应的产品明细
+                if (apsProcessOutputProductDo.getProductid().equals(apsProductDetailDo.getId())) {
+                    haveProductDetail = true;
+                    //计划输出订单重量 > 对应订单产品订单总数量；错误提示：输出成品 {订单产品} 计划输出订单重量 不能大于 订单总数量
+                    if (apsProcessOutputProductDo.getPlanoutputonerollweight().compareTo(apsProductDetailDo.getTotalordercount()) > 0) {
+                        return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 计划输出订单重量 不能大于 订单总数量");
+                    }
+                }
+            }
+            if (!haveProductDetail && apsProcessOutputProductDo.getPlanoutputonerollweight().compareTo(new BigDecimal(0)) > 0) {
+                return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 已修改或已删除，并已开工，计划输出订单重量 不能大于 0");
+            }
+        }
+
+
+        //============校验工艺路线=============
+        //如果坯料需求的坯料输出成品字段值不等于坯料需求的工艺输出成品字段值，错误提示：工艺路线输出成品与坯料输出成品不一致
+        if (!apsBlankOrderDo.getOutputfinishproduct().equals(apsBlankOrderDo.getOutputmaterial())) {
+            return R.error("第" + j + "个坯料计划 工艺路线输出成品与坯料输出成品不一致");
+        }
+        //如果坯料需求的是否备料=是，并且首道工序作业的是否坯料工序=是，错误提示：工艺路线错误，首道工序作业是坯料工序，备料不能作为输入物料
+        //是否备料
+        if (apsBlankOrderDo.getPreparematerial().equals("是")) {
+            //查询坯料计划的工序作业
+            List<ApsProcessOperationDo> processOperationList = apsProcessOperationService.list(new QueryWrapper<ApsProcessOperationDo>().lambda().eq(ApsProcessOperationDo::getBlankid, apsBlankOrderDo.getId()));
+            for (ApsProcessOperationDo processOperationDo : processOperationList) {
+                //没有前道工序作业ID
+                if (ObjectUtil.isEmpty(processOperationDo.getPreviousprocessid())) {
+                    if (processOperationDo.getIfblankprocess().equals("是")) {
+                        return R.error("第" + j + "个坯料计划 工艺路线错误，首道工序作业是坯料工序，备料不能作为输入物料");
+                    }
+                    break;
+                }
+            }
+        }
+
+        //============校验工序作业=============
+        Map<String, Object> params = new HashMap<>();
+        params.put("BLANKID", apsBlankOrderDo.getId());
+        R r = apsProcessOperationService.checkOperation(params);
+        if (!(r.getCode().equals("200"))) {
+            return R.error("第" + j + "个坯料计划 " + r.getMsg());
+        }
+        return R.ok();
+    }
 }

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

@@ -1,13 +1,18 @@
 package com.rongwei.bscommon.sys.service.impl;
 
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.rongwei.bscommon.sys.dao.*;
+import com.rongwei.bscommon.sys.service.ApsBlankOrderService;
+import com.rongwei.bscommon.sys.service.ApsProcessOutputProductService;
 import com.rongwei.bscommon.sys.service.ApsProductionOrderService;
 import com.rongwei.bscommon.sys.utils.ApsUtils;
+import com.rongwei.bsentity.domain.*;
+import com.rongwei.bsentity.vo.*;
 import com.rongwei.bsentity.domain.ApsBlankOrderDo;
 import com.rongwei.bsentity.domain.ApsProductionMergeOrderDo;
 import com.rongwei.bsentity.domain.ApsProductionOrderDo;
@@ -55,6 +60,10 @@ public class ApsProductionOrderServiceImpl extends ServiceImpl<ApsProductionOrde
     @Autowired
     private ApsProcessOperationProcessEquBackupDao apsProcessOperationProcessEquBackupDao;
     @Autowired
+    private ApsBlankOrderService apsBlankOrderService;
+    @Autowired
+    private ApsProcessOutputProductService apsProcessOutputProductService;
+    @Autowired
     private CXCommonFeginClient autoCommonFeginClient;
 
     public static final String ERROR_MSG = "%s上诉订单的排程交货期大于承诺交货期";
@@ -229,6 +238,17 @@ public class ApsProductionOrderServiceImpl extends ServiceImpl<ApsProductionOrde
         }
 
         //================循环校验坯料计划===============
+        for (int i = 0; i < apsBlankOrderDoList.size(); i++) {
+            CheckAndSaveOrUpdateBlankReq checkAndSaveOrUpdateBlankReq = new CheckAndSaveOrUpdateBlankReq();
+            checkAndSaveOrUpdateBlankReq.setApsBlankOrderDo(apsBlankOrderDoList.get(i));
+            checkAndSaveOrUpdateBlankReq.setApsProcessOutputProductDoList(apsProcessOutputProductService.list(new QueryWrapper<ApsProcessOutputProductDo>().lambda().eq(ApsProcessOutputProductDo::getBlankid, apsBlankOrderDoList.get(i).getId())));
+            checkAndSaveOrUpdateBlankReq.setApsProductDetailDoList(BeanUtil.copyToList(apsProductDetailVoList, ApsProductDetailDo.class));
+            R r = apsBlankOrderService.checkBlankOrder(checkAndSaveOrUpdateBlankReq, i+1);
+            if(!r.getCode().equals("200")){
+                return R.error(r.getMsg());
+            }
+        }
+
 
 
         return null;