feature 代码提交

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

@@ -2,6 +2,7 @@ package com.rongwei.bscommon.sys.dao;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.rongwei.bsentity.domain.ApsBlankOrderDo;
+import com.rongwei.bsentity.domain.ApsProcessOperationDo;
 import com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo;
 import com.rongwei.bsentity.domain.AspCheckItemsDo;
 import com.rongwei.bsentity.vo.ApsBlankOrderVo;
@@ -78,7 +79,7 @@ public interface ApsBlankOrderDao extends BaseMapper<ApsBlankOrderDo> {
     @Select("select BLANKID AS 'blankId',MAX(PROCESSSTATUS) AS 'maxProcessStatus',MIN(PROCESSSTATUS) AS 'minProcessStatus' from aps_process_operation where BLANKID = (select BLANKID from aps_process_operation where ID = #{productProcessId})")
     BlankIdAndProcessStatusVo selectProcessStatusByProcessId(@Param("productProcessId") String productProcessId);
 
-    List<String> getIdByLockTime(@Param("lockTime") Date LockTime, @Param("lockMark") String lockMark);
+    List<ApsProcessOperationDo> getProcessInfoByLockTime(@Param("lockTime") Date LockTime, @Param("lockMark") String lockMark);
 
     int checkConflictByBlankId(@Param("blankIds") List<String> blankIds);
 

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

@@ -2,7 +2,6 @@ package com.rongwei.bscommon.sys.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.date.DateField;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.date.StopWatch;
@@ -384,77 +383,116 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             log.error("锁定状态必填");
             return R.error("锁定状态必填");
         }
-        List<String> blackOrderId = orderLockVo.getBlackOrderId();
-        blackOrderId = blackOrderId.stream().filter(StringUtils::isNotBlank).collect(Collectors.toList());
+        List<String> processIds = orderLockVo.getId();
+        processIds = processIds.stream().filter(StringUtils::isNotBlank).distinct().collect(Collectors.toList());
         Date lockStartTime = orderLockVo.getLockStartTime();
-        if (blackOrderId.isEmpty() && lockStartTime == null) {
-            log.error("坯料计划ID和解锁时间都为空");
-            return R.error("坯料计划ID和解锁时间都为空");
-        }
-
-        if (!blackOrderId.isEmpty()) {
-            // 校验坯料计划是否开工
-            Integer integer = apsBlankOrderDao.selectCount(new LambdaQueryWrapper<ApsBlankOrderDo>()
-                    .in(ApsBlankOrderDo::getId, blackOrderId)
-                    .in(ApsBlankOrderDo::getProductstatus, "40", "50"));
-            if (integer > 0) {
-                log.error("所选作业坯料计划已开工，不可以解锁");
-                return R.error("所选作业坯料计划已开工，不可以解锁");
+        if (processIds.isEmpty() && lockStartTime == null) {
+            log.error("工序作业明细ID和解锁时间都为空");
+            return R.error("工序作业明细ID和解锁时间都为空");
+        }
+        // 直接解锁和锁定操作的工序作业信息
+        List<ApsProcessOperationDo> apsProcessOperationDos = Collections.emptyList();
+        if (!processIds.isEmpty()) {
+            // 校验所选择的工序作业生产状态 是否在加工或已完工
+            apsProcessOperationDos = new ArrayList<>(apsProcessOperationService.listByIds(processIds));
+            //解锁的情况下校验 工序作业对应的生产状态
+            if (LOCKMARK_N.equals(lockMark)) {
+                boolean b = apsProcessOperationDos.stream().anyMatch(info -> COMPLETED.equals(info.getProcessstatus()) ||
+                        PROCESSING.equals(info.getProcessstatus()));
+                if(b){
+                    return R.error("所选工序作业生产状态为加工或已完工，不能锁定");
+                }
             }
         }
+
         if (lockStartTime != null) {
             // 获取排程参数设置
             List<ApsScheduleConfigDo> apsConfigs = apsScheduleConfigService.list();
             // 默认最小排程时间
-            int defaultStartStartSchedulerun = 8;
+            Integer defaultStartStartSchedulerun = 8;
             if (!apsConfigs.isEmpty()) {
                 defaultStartStartSchedulerun = apsConfigs.get(0).getStartschedulerun();
             }
+            if (defaultStartStartSchedulerun == null || defaultStartStartSchedulerun <= 0) {
+                defaultStartStartSchedulerun = 8;
+            }
+
             Date date = orderLockGetSearChDate(lockStartTime, defaultStartStartSchedulerun, lockMark);
-            // 获取所有 待发布 待开工的 坯料计划
-            blackOrderId = this.baseMapper.getIdByLockTime(date, lockMark);
+            // 获取所有 待发布 待开工的 工序作业
+            apsProcessOperationDos = this.baseMapper.getProcessInfoByLockTime(date, lockMark);
+        }
+        if (apsProcessOperationDos.isEmpty()) {
+            log.debug("暂无需要锁定或者解锁的工序作业");
+            return R.ok("暂无需要锁定或者解锁的工序作业");
         }
-        if (blackOrderId.isEmpty()) {
-            log.debug("暂无需要锁定或者解锁的批量计划");
-            return R.ok("暂无需要锁定或者解锁的批量计划");
+        if (LOCKMARK_N.equals(lockMark)) {
+            return unlock(apsProcessOperationDos);
         }
-        // 组装待更新坯料计划实体
-        List<ApsBlankOrderDo> blankOrderDos = new ArrayList<>();
+        return lock(apsProcessOperationDos);
+    }
 
-        for (String id : blackOrderId) {
-            ApsBlankOrderDo blankOrderDo = new ApsBlankOrderDo();
-            blankOrderDo.setId(id);
-            blankOrderDo.setLockmark(lockMark);
-            if (LOCKMARK_N.equals(lockMark)) {
-                blankOrderDo.setProductstatus("20");
-            }
-            blankOrderDos.add(blankOrderDo);
+    /**
+     * 解锁 锁定标识  n
+     *
+     * @param blackOrderId 坯料计划ID
+     * @return
+     */
+    @Transactional
+    public R unlock(List<ApsProcessOperationDo> apsProcessOperationDos) {
+        // 获取待发布的工序作业
+        List<ApsProcessOperationDo> unlockProcessInfo = apsProcessOperationDos.stream()
+                .filter(info ->TO_BE_STARTED.equals(info.getProcessstatus()) || TO_BE_PUBLISHED.equals(info.getProcessstatus()))
+                .collect(Collectors.toList());
+        // 执行解锁作业的工序作业信息
+        List<String> processIds = unlockProcessInfo.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList());
+        // 获取工序作业对应的坯料计划信息(坯料计划生产状态=待开工)
+        List<String> blankIds = apsProcessOperationDos.stream().map(ApsProcessOperationDo::getBlankid).collect(Collectors.toList());
+        List<ApsBlankOrderDo> apsBlankOrderDos = this.list(new LambdaQueryWrapper<ApsBlankOrderDo>().in(ApsBlankOrderDo::getId, blankIds).eq(ApsBlankOrderDo::getProductstatus, TO_BE_STARTED));
+        if(!apsBlankOrderDos.isEmpty()){
+            blankIds = apsBlankOrderDos.stream().map(ApsBlankOrderDo::getId).collect(Collectors.toList());
+            // 待加工的工序作业执行撤回操作
+            publishCancel(blankIds);
+            List<ApsProcessOperationDo> list = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>().eq(ApsProcessOperationDo::getBlankid, blankIds));
+            processIds.addAll(list.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList()));
+        }
+        if(processIds.isEmpty()){
+            log.error("暂无需要执行解锁的工序作业");
+            return R.error("暂无需要执行解锁的工序作业信息");
+        }
+        //待发布更新锁定状态
+        // 更新坯料计划的锁定状态 和 生产状态
+        apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
+                .in(ApsProcessOperationDo::getId, processIds)
+                .set(ApsProcessOperationDo::getLockmark, LOCKMARK_N));
+        // 判断当前工序作业是否存在加工中或已完工的数据
+        boolean b = unlockProcessInfo.stream().anyMatch(info -> COMPLETED.equals(info.getProcessstatus()) || PROCESSING.equals(info.getProcessstatus()));
+        if (b) {
+            return R.ok("200", "解锁成功，部分已开工的作业不能解锁", processIds);
         }
-        // 坯料计划锁定标识更新
-        if (blankOrderDos.size() > 0) {
-            this.updateBatchById(blankOrderDos);
+        return R.ok("200", "解锁成功", processIds);
+    }
+
+    /**
+     * 锁定
+     *
+     * @param blackOrderId
+     * @return
+     */
+    @Transactional
+    public R lock(List<ApsProcessOperationDo> apsProcessOperationDos) {
+
+        List<String> unlockedIds = apsProcessOperationDos.stream()
+                .filter(info -> LOCKMARK_N.equals(info.getLockmark()))
+                .map(ApsProcessOperationDo::getId)
+                .collect(Collectors.toList());
+        if (unlockedIds.isEmpty()) {
+            return R.ok("200", "锁定成功", unlockedIds);
         }
-        // 工序作业锁定标识更新
+        // 更新坯料计划的锁定状态 和 生产状态
         apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
-                .set(ApsProcessOperationDo::getLockmark, lockMark)
-                .in(ApsProcessOperationDo::getBlankid, blackOrderId));
-        // 工序作业排程计划锁定
-        processOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                .set(ApsProcessOperationProcessEquDo::getLockmark, lockMark)
-                .in(ApsProcessOperationProcessEquDo::getBlankid, blackOrderId));
-        // 解锁
-        if (LOCKMARK_N.equals(lockMark)) {
-            // 更新坯料计划对应工序作业的生产状态为待发布
-            apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
-                    .in(ApsProcessOperationDo::getBlankid, blackOrderId)
-                    .set(ApsProcessOperationDo::getProcessstatus, "20")
-            );
-            apsBlankOrderService.update(new LambdaUpdateWrapper<ApsBlankOrderDo>()
-                    .in(ApsBlankOrderDo::getId, blackOrderId)
-                    .set(ApsBlankOrderDo::getSchedulingstatus, "20"));
-        }
-        // 回传坯料计划ID 用于前段更新锁定状态
-        return R.ok(blackOrderId);
+                .in(ApsProcessOperationDo::getId, unlockedIds)
+                .set(ApsProcessOperationDo::getLockmark, LOCKMARK_Y));
+        return R.ok("200", "锁定成功", unlockedIds);
     }
 
     /**
@@ -617,15 +655,15 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                     for (ProduceOrder order : produceOrder) {
                         Date endDate = Date.from(process.getEndTime().atZone(ZoneId.systemDefault()).toInstant());
                         List<ApsBlankOrderDo> hasblanks = blankIds.stream().filter(v -> v.getId().equals(order.getId())).collect(Collectors.toList());
-                        if(hasblanks != null && hasblanks.size()>0){
+                        if (hasblanks != null && hasblanks.size() > 0) {
                             ApsBlankOrderDo blankOrderDo = hasblanks.get(0);
-                            if(blankOrderDo.getScheduledatestart().compareTo(endDate)>0){
+                            if (blankOrderDo.getScheduledatestart().compareTo(endDate) > 0) {
                                 blankOrderDo.setScheduledatestart(endDate);
                             }
-                            if(blankOrderDo.getScheduledateend().compareTo(endDate)<0){
+                            if (blankOrderDo.getScheduledateend().compareTo(endDate) < 0) {
                                 blankOrderDo.setScheduledateend(endDate);
                             }
-                        }else{
+                        } else {
                             ApsBlankOrderDo blankOrder = this.getById(order.getId());
                             ApsBlankOrderDo updateBlank = new ApsBlankOrderDo();
                             updateBlank.setId(order.getId());
@@ -671,9 +709,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             }
 
             // 自动加锁坯料计划下的工序作业
-            apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>().in(ApsProcessOperationDo::getBlankid,blankKeys).set(ApsProcessOperationDo::getLockmark,"y"));
+            apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>().in(ApsProcessOperationDo::getBlankid, blankKeys).set(ApsProcessOperationDo::getLockmark, "y"));
             // 自动加锁坯料计划下的排程作业明细
-            apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid,blankKeys).set(ApsProcessOperationProcessEquDo::getLockmark,"y"));
+            apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid, blankKeys).set(ApsProcessOperationProcessEquDo::getLockmark, "y"));
         }
 
         backupProcessOperation(apsProcessOperationProcessEquDos, productionScheduleRetVo.getProcesses());

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

@@ -138,7 +138,7 @@
         </if>
     </update>
     <update id="reportCheckUpdateJobStatus">
-        update  aps_blank_order
+        update aps_blank_order
         <set>
             SCHEDULINGSTATUS = if((select GROUP_CONCAT(DISTINCT PROCESSSTATUS)='50' from aps_process_operation where
             DELETED ='0' and BLANKID=#{id}),
@@ -149,16 +149,15 @@
             AND ID=#{id}
         </where>
     </update>
-    <select id="getIdByLockTime" resultType="java.lang.String">
-        select DISTINCT abo.ID from  aps_blank_order abo
-        left join aps_process_operation apo on abo.ID= apo.BLANKID AND APO.DELETED='0'
+    <select id="getProcessInfoByLockTime" resultType="com.rongwei.bsentity.domain.ApsProcessOperationDo">
+        select apo.* from aps_process_operation apo
         left join aps_process_operation_process_equ apope on apope.PROCESSID=apo.ID and apope.DELETED='0'
         <where>
-            abo.DELETED ='0'
-            <if test='lockMark=="n"'>
-                AND abo.PRODUCTSTATUS !='40'
-                and abo.PRODUCTSTATUS !='50'
-            </if>
+            apo.DELETED ='0'
+<!--            <if test='lockMark=="n"'>-->
+<!--                AND apo.PRODUCTSTATUS !='40'-->
+<!--                and apo.PRODUCTSTATUS !='50'-->
+<!--            </if>-->
             <choose>
                 <when test='lockMark=="y"'> and apope.PLANSTARTDATE &lt; #{lockTime} </when>
                 <otherwise>and apope.PLANSTARTDATE &gt; #{lockTime}</otherwise>

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

@@ -18,4 +18,8 @@ public class OrderLockVo {
     // 解锁时间
     private Date lockStartTime;
 
+    /**
+     * 工序作业ID aps_process_operation
+     */
+    private List<String> id = new ArrayList<>();
 }