Merge remote-tracking branch 'origin/master_merge' into master_merge

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/point/controller/BstIvtPackageinfoivtController.java

@@ -61,7 +61,7 @@ public class BstIvtPackageinfoivtController {
     @PostMapping("/secondaryAllocationPoint")
     @SaIgnore
     ResponseEntity<Object> secondaryAllocationPoint(@RequestBody JSONObject whereJson) {
-        log.info("一楼装箱区点位二次分配接口请求参数：---------------------------------------------" + whereJson.toString());
+        log.info("一楼装箱区二次分配接口请求参数：---------------------------------------------" + whereJson.toString());
         String taskCode = whereJson.getString("taskCode");
         String actionType = whereJson.getString("actionType");
         if (StrUtil.isEmpty(whereJson.getString("taskCode")) || StrUtil.isEmpty(whereJson.getString("actionType"))) {

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/point/service/impl/BstIvtPackageinfoivtServiceImpl.java

@@ -154,15 +154,15 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
             throw new BadRequestException("该任务未执行或不存在！");
         }
         //已分配过二次分配点位
-        if (StringUtils.isNotBlank(baseTask.getRequest_param())) {
+        //        if (StringUtils.isNotBlank(baseTask.getResponse_param())) {
-            if (baseTask.getRequest_param().equals(IOSEnum.IS_SEND.code("是"))) {
+        //            if (baseTask.getResponse_param().equals(IOSEnum.IS_SEND.code("是"))) {
-                if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货分配").equals(actionType)) {
+        //                if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货分配").equals(actionType)) {
-                    return baseTask.getPoint_code1();
+        //                    return baseTask.getPoint_code1();
-                } else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
+        //                } else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
-                    return baseTask.getPoint_code2();
+        //                    return baseTask.getPoint_code2();
-                }
+        //                }
-            }
+        //            }
-        }
+        //        }
         BstIvtPackageinfoivt newPoint;
         String taskPointType = null;
         //空载具缓存位特殊二次分配逻辑：先判断是否有执行中的行架任务或补空载具任务，如未完成，不分配点位
@@ -170,7 +170,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                 baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"))
         ) {
             //检查是否满足二次分配条件
-            checkTaskInfo();
+            checkTaskInfo(baseTask);
             newPoint = checkIvtSBlock(baseTask);
         } else {
             if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区"))) {
@@ -190,11 +190,14 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
             } else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
                 baseTask.setPoint_code2(newPoint.getPoint_code());
             }
-            baseTask.setRequest_param(IOSEnum.IS_SEND.code("是"));
+            //标记二次分配已分配过点位
+            baseTask.setResponse_param(IOSEnum.IS_NOTANDYES.code("是"));
             taskService.updateById(baseTask);
+            log.info("一楼装箱区二次分配任务编号为:" + taskCode + ",接口返回最新点位：---------------------------------------------" + newPoint.getPoint_code());
             return newPoint.getPoint_code();
         } else {
-            throw new BadRequestException("存在未完成的取放货任务或点位外层有载具阻挡！");
+            log.info("一楼装箱区二次分配任务编号为:" + taskCode + ",分配失败，暂无点位资源或点位外层有载具阻挡！");
+            throw new BadRequestException("一楼装箱区二次分配任务编号为:" + taskCode + ",分配失败，暂无点位资源或点位外层有载具阻挡！");
         }
     }
 
@@ -210,12 +213,13 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
      */
     @Override
     public List<BstIvtPackageinfoivt> checkEndPointTask(String ivtType, String ivtStatus, String pointCode, String sortType, String taskType) {
+        List<BstIvtPackageinfoivt> returList = new ArrayList<>();
         List<BstIvtPackageinfoivt> packageinfoivtList = getBstIvtPackageinfoivts(ivtType, ivtStatus, sortType);
         Set<String> pointIds = packageinfoivtList.stream()
                 .map(BstIvtPackageinfoivt::getPoint_code)
                 .collect(Collectors.toSet());
         if (CollectionUtils.isEmpty(pointIds)) {
-            return Collections.emptyList();
+            return returList;
         }
         if (pointCode == null) {
             return packageinfoivtList;
@@ -234,6 +238,27 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
             taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, null, pointIds, null);
         } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货"))) {
             taskList = bstIvtPackageinfoivtMapper.getTaskList(null, pointIds, null, pointIds);
+        } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货分配"))) {
+            List<BstIvtPackageinfoivt> pointList = new ArrayList<>();
+            List<BstIvtPackageinfoivt> ivtList = packageinfoivtList.stream().filter(r -> r.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空载具"))).sorted(Comparator.comparing(BstIvtPackageinfoivt::getSort_seq)).collect(Collectors.toList());
+            //有空载具
+            if (CollectionUtils.isNotEmpty(ivtList)) {
+                //                BstIvtPackageinfoivt bstIvtPackageinfoivt = new BstIvtPackageinfoivt();
+                //                bstIvtPackageinfoivt.setPoint_code(ivtList.get(0).getPoint_code());
+                //                returList.add(bstIvtPackageinfoivt);
+                //                return returList;
+                BstIvtPackageinfoivt bstIvtPackageinfoivt = new BstIvtPackageinfoivt();
+                bstIvtPackageinfoivt.setPoint_code(ivtList.get(0).getPoint_code());
+                bstIvtPackageinfoivt.setSort_seq(ivtList.get(0).getSort_seq());
+                returList.add(bstIvtPackageinfoivt);
+                //判断是否有空载具阻挡
+                pointList.add(getBstIvtPackageinfoivt(returList, packageinfoivtList));
+                return pointList;
+            } else {
+                BstIvtPackageinfoivt bstIvtPackageinfoivt = packageinfoivtList.stream().filter(r -> r.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空"))).sorted(Comparator.comparing(BstIvtPackageinfoivt::getSort_seq).reversed()).collect(Collectors.toList()).get(0);
+                pointList.add(bstIvtPackageinfoivt);
+                return pointList;
+            }
         } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("取货任务取货分配"))) {
             taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, pointIds, pointIds, pointIds);
         } else {
@@ -263,6 +288,14 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                     ))
                     .filter(Objects::nonNull)
                     .collect(Collectors.toSet());
+            List<BstIvtPackageinfoivt> ivtList = packageinfoivtList.stream().filter(r -> r.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空载具"))).collect(Collectors.toList());
+            Set<String> ivtpointSets = ivtList.stream().map(BstIvtPackageinfoivt::getPoint_code).collect(Collectors.toSet());
+            if (CollectionUtils.isNotEmpty(ivtpointSets)) {
+                //存在任务数量+已有库存数量大于3，不创建任务
+                if (pointSets.size() + ivtpointSets.size() > 3) {
+                    return returList;
+                }
+            }
         } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("取货任务")) || pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("放货任务"))) {
             pointSets = taskList.stream()
                     .flatMap(task -> Stream.of(
@@ -288,46 +321,66 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                 .collect(Collectors.toList());
         //送空载具到空载具缓存位任务，需要判断是否存在已分配的且未完成的送空载具任务，如果存在，判断存在是否阻挡
         if (taskType.equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)")) || taskType.equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)"))) {
-            Set<String> taskPointSet = taskList.stream().filter(r->!r.getPoint_code2().equals("ZXQ_01_1")).map(SchBaseTask::getPoint_code2).collect(Collectors.toSet());
+            return getNoBlockIvt(pointCode, taskList, ivtList);
-            List<BstIvtPackageinfoivt> pointList = new ArrayList<>();
-            if (CollectionUtils.isEmpty(taskPointSet)) {
-                List<BstIvtPackageinfoivt> vehicleList = ivtList.stream()
-                        .filter(n -> n.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空载具")))
-                        .sorted(Comparator.comparing(BstIvtPackageinfoivt::getSort_seq))
-                        .collect(Collectors.toList());
-                pointList.add(getBstIvtPackageinfoivt(vehicleList,ivtList));
-                return pointList;
-            } else {
-                List<BstIvtPackageinfoivt> existPointList = bstIvtPackageinfoivtMapper.selectList(new LambdaQueryWrapper<BstIvtPackageinfoivt>().in(BstIvtPackageinfoivt::getPoint_code, taskPointSet));
-                existPointList = existPointList.stream().peek(r -> r.setIvt_status(PackageInfoIvtEnum.IVT_STATUS.code("空载具"))).collect(Collectors.toList());
-                pointList.add(getBstIvtPackageinfoivt(existPointList, ivtList));
-                return pointList;
-            }
         } else {
             return ivtList;
         }
     }
 
+    /**
+     * 获取没有阻挡的点位
+     */
+    private List<BstIvtPackageinfoivt> getNoBlockIvt(String pointCode, List<SchBaseTask> taskList, List<BstIvtPackageinfoivt> ivtList) {
+        Set<String> taskPointSet = taskList.stream().map(SchBaseTask::getPoint_code2).filter(pointCode2 -> !pointCode2.equals("ZXQ_01_1")).collect(Collectors.toSet());
+        List<BstIvtPackageinfoivt> pointList = new ArrayList<>();
+        //存在补空载具任务已分配却未完成的任务
+        if (CollectionUtils.isEmpty(taskPointSet)) {
+            List<BstIvtPackageinfoivt> vehicleList = ivtList.stream()
+                    .filter(n -> n.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空载具")))
+                    .sorted(Comparator.comparing(BstIvtPackageinfoivt::getSort_seq))
+                    .collect(Collectors.toList());
+            pointList.add(getBstIvtPackageinfoivt(vehicleList, ivtList));
+            return pointList;
+        } else {
+            List<BstIvtPackageinfoivt> existPointList = bstIvtPackageinfoivtMapper.selectList(new LambdaQueryWrapper<BstIvtPackageinfoivt>().in(BstIvtPackageinfoivt::getPoint_code, taskPointSet));
+            existPointList = existPointList.stream().peek(r -> r.setIvt_status(PackageInfoIvtEnum.IVT_STATUS.code("空载具"))).collect(Collectors.toList());
+            if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("放货任务"))) {
+                return existPointList;
+            }
+            pointList.add(getBstIvtPackageinfoivt(existPointList, ivtList));
+            return pointList;
+        }
+    }
+
     /**
      * 检查是否满足二次分配条件
      */
-    private void checkTaskInfo() {
+    private void checkTaskInfo(SchBaseTask baseTask) {
         List<SchBaseTask> taskList1 = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
                 .lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode())
+                .eq(SchBaseTask::getIs_delete, IOSEnum.IS_NOTANDYES.code("否"))
                 .and(
                         r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)"))
                                 .or()
                                 .eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)")
                                 )));
         if (CollectionUtils.isNotEmpty(taskList1)) {
-            //存在未完成的已分配的送空载具任务，需要等这个任务完成再分配
+            List<SchBaseTask> taskList3 = taskList1.stream().filter(r -> StringUtils.isNotBlank(r.getResponse_param())).collect(Collectors.toList());
-            if (taskList1.stream().anyMatch(r -> !r.getPoint_code2().equals("ZXQ_01_1"))) {
+            if (taskList3.size() == 1) {
-                throw new BadRequestException("请等待补空载具任务执行完成，再分配空载具点位");
+                //校验已分配的补空载具任务是否为当前请求的任务，是可重新分配，否不允许重新分配
+                if (!taskList3.get(0).getTask_code().equals(baseTask.getTask_code())) {
+                    log.info("一楼装箱区二次分配任务编号为:" + taskList3.get(0).getTask_code() + ",分配失败，存在多个或上一个已分配的补空载具任务未完成，请检查！");
+                    throw new BadRequestException("一楼装箱区二次分配任务编号为:" + taskList3.get(0).getTask_code() + ",分配失败，存在多个或上一个已分配的补空载具任务未完成，请检查！");
+                }
+            } else if (taskList3.size() > 1) {
+                log.info("一楼装箱区二次分配任务编号为:" + taskList3.get(0).getTask_code() + ",分配失败，存在多个或上一个已分配的补空载具任务未完成，请检查！");
+                throw new BadRequestException("一楼装箱区二次分配任务编号为:" + taskList3.get(0).getTask_code() + ",分配失败，存在多个或上一个已分配的补空载具任务未完成，请检查！");
             }
         }
-        //是否有执行中的行架任务，有就分配行架搬运起点
+        //是否有执行中的行架任务，有等待取空载具任务完成再分配
         List<SchBaseTask> taskList2 = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
-                .eq(SchBaseTask::getTask_status, TaskStatusEnum.EXECUTING.getCode())
+                .lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode())
+                .eq(SchBaseTask::getIs_delete, IOSEnum.IS_NOTANDYES.code("否"))
                 .and(
                         r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"))
                                 .or()
@@ -335,10 +388,12 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                                 )));
         if (CollectionUtils.isNotEmpty(taskList2)) {
             if (StringUtils.isBlank(taskList2.get(0).getRequest_param())) {
-                throw new BadRequestException("请等待桁架任务取空载具动作执行完成，再分配空载具点位");
+                log.info("一楼装箱区二次分配任务编号为:" + taskList2.get(0).getTask_code() + ",分配失败，请等待桁架任务取空载具动作执行完成");
+                throw new BadRequestException("一楼装箱区二次分配任务编号为:" + taskList2.get(0).getTask_code() + ",分配失败，请等待桁架任务取空载具动作执行完成");
             } else {
                 if (!taskList2.get(0).getRequest_param().equals(PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"))) {
-                    throw new BadRequestException("请等待桁架任务取空载具动作执行完成，再分配空载具点位");
+                    log.info("一楼装箱区二次分配任务编号为:" + taskList2.get(0).getTask_code() + ",分配失败，请等待桁架任务取空载具动作执行完成");
+                    throw new BadRequestException("一楼装箱区二次分配任务编号为:" + taskList2.get(0).getTask_code() + ",分配失败，请等待桁架任务取空载具动作执行完成");
                 }
             }
         }
@@ -436,6 +491,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
             if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区")) ||
                     baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务")) ||
                     baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"))) {
+                String pointCode;
                 //取满轴
                 if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区"))) {
                     List<BstIvtPackageinfoivt> ivtList = packageinfoivtService.list(new LambdaQueryWrapper<BstIvtPackageinfoivt>()
@@ -448,14 +504,15 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                     if (baseTask.getVehicle_code().equals(ivtList.get(0).getContainer_name())) {
                         upDateIvtOrTask(baseTask, baseTask.getPoint_code1(), false);
                     }
-                } else if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"))) {
+                } else if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务")) || baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"))) {
-                    //取空轴
+                    pointCode = baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务")) ? baseTask.getPoint_code3() : baseTask.getPoint_code1();
-                    upDateIvtOrTask(baseTask, baseTask.getPoint_code3(), true);
+                    if (StringUtils.isBlank(baseTask.getRequest_param())) {
-
+                        upDateIvtOrTask(baseTask, pointCode, true);
-                } else if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"))) {
+                    } else if (StringUtils.isNotBlank(baseTask.getRequest_param())) {
-                    //取空轴
+                        if (!baseTask.getRequest_param().equals(PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"))) {
-                    upDateIvtOrTask(baseTask, baseTask.getPoint_code1(), true);
+                            upDateIvtOrTask(baseTask, pointCode, true);
-
+                        }
+                    }
                 }
             }
         } else {
@@ -472,6 +529,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
                         .set("container_name", baseTask.getVehicle_code())
                         .set("ivt_status", PackageInfoIvtEnum.IVT_STATUS.code("有子卷"))
                         .eq("point_code", baseTask.getPoint_code2()));
+                log.info("一楼装箱区二次分配的任务编号为:" + baseTask.getTask_code() + ",放货完成执行成功，放货信息：点位：" + baseTask.getPoint_code2() + "子卷号为：" + baseTask.getVehicle_code());
             } else {
                 throw new BadRequestException("该点位已有库存！");
             }
@@ -495,6 +553,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
             updateWrapper1.set("request_param", PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"));
             taskService.update(updateWrapper1);
         }
+        log.info("一楼装箱区二次分配的任务编号为:" + baseTask.getTask_code() + ",取货完成执行成功，取货信息：点位：" + pointCode + "子卷号为：" + baseTask.getVehicle_code());
     }
 
     /**
@@ -522,7 +581,8 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
         BstIvtPackageinfoivt ivtInfo = getIvtInfoFromRegion(baseTask.getTask_type(), actionType);
         List<BstIvtPackageinfoivt> newPointList = packageinfoivtService.checkEndPointTask(bstIvtPackageinfoivt.getPoint_status(), ivtInfo.getIvt_status(), targetPoint, ivtInfo.getSort_seq().toString(), "");
         if (CollectionUtils.isEmpty(newPointList)) {
-            throw new BadRequestException("暂无点位资源！");
+            log.info("一楼装箱区二次分配任务编号为:" + baseTask.getTask_code() + ",分配失败，暂无点位资源或点位外层有载具阻挡！");
+            throw new BadRequestException("一楼装箱区二次分配任务编号为:" + baseTask.getTask_code() + ",分配失败，暂无点位资源或点位外层有载具阻挡！");
         }
         newPoint = newPointList.get(0);
         return newPoint;
@@ -533,7 +593,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
      */
     public BstIvtPackageinfoivt checkIvtSBlock(SchBaseTask baseTask) {
         BstIvtPackageinfoivt newPoint = new BstIvtPackageinfoivt();
-        List<BstIvtPackageinfoivt> kzjIvtList = packageinfoivtService.checkEndPointTask(PackageInfoIvtEnum.POINT_STATUS.code("空载具缓存位"), null, PackageInfoIvtEnum.TASK_POINT_TYPE.code("放货任务"), PackageInfoIvtEnum.SORT_TYPE.code("降序"), baseTask.getTask_type());
+        List<BstIvtPackageinfoivt> kzjIvtList = packageinfoivtService.checkEndPointTask(PackageInfoIvtEnum.POINT_STATUS.code("空载具缓存位"), null, (PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货分配")), PackageInfoIvtEnum.SORT_TYPE.code("降序"), baseTask.getTask_type());
         if (CollectionUtils.isNotEmpty(kzjIvtList)) {
             return kzjIvtList.get(0);
         } else {

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/task/service/IschBaseTaskService.java

@@ -78,7 +78,7 @@ public interface IschBaseTaskService extends IService<SchBaseTask> {
     /**
      *校验相同任务类型
      */
-    List<SchBaseTask> getExistTasks(String taskType1, String taskType2, String taskType3);
+    List<SchBaseTask> getExistTasks(List<String> taskTypes);
 }
 
 

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/task/service/impl/SchBaseTaskServiceImpl.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.nl.b_lms.sch.task.dao.SchBaseTask;
 import org.nl.b_lms.sch.task.dao.mapper.SchBaseTaskMapper;
@@ -132,13 +133,11 @@ public class SchBaseTaskServiceImpl extends ServiceImpl<SchBaseTaskMapper, SchBa
     }
 
 
-    public List<SchBaseTask> getExistTasks(String taskType1, String taskType2, String taskType3) {
+    public List<SchBaseTask> getExistTasks(List<String> taskTypes) {
         LambdaQueryWrapper<SchBaseTask> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode());
         queryWrapper.eq(SchBaseTask::getIs_delete, IOSEnum.IS_NOTANDYES.code("否"));
-        List<String> taskTypes = new ArrayList<>(Arrays.asList(taskType1, taskType2, taskType3));
+        if (CollectionUtils.isNotEmpty(taskTypes)) {
-        taskTypes.removeIf(StringUtils::isBlank);
-        if (!taskTypes.isEmpty()) {
             queryWrapper.in(SchBaseTask::getTask_type, taskTypes);
         }
         return this.list(queryWrapper);

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/tasks/first_floor_area/MzhcwTask.java

@@ -120,7 +120,7 @@ public class MzhcwTask extends AbstractAcsTask {
         }
         // 完成
             if (StrUtil.equals(status, TaskStatusEnum.FINISHED.getCode())) {
-            log.info("任务编号为:"+schBaseTask.getTask_code()+"的任务完成接口在"+schBaseTask.getUpdate_time()+"被调用---------------------------------------------");
+                log.info("任务编号为:" + schBaseTask.getTask_code() + "的任务完成接口在" + schBaseTask.getUpdate_time() + "被调用---------------------------------------------");
                 //1.更改任务状态为完成
                 schBaseTask.setTask_status(TaskStatusEnum.FINISHED.getCode());
                 //2.更新库存记录
@@ -128,38 +128,29 @@ public class MzhcwTask extends AbstractAcsTask {
                 //3.任务一、待检区AGV搬运任务，查询子卷信息，去分切计划表查找定级数据，桁架任务完成根据子卷定级创建AGV任务将满轴搬运至质检区或管制区
                 //createTaskToDjq(schBaseTask);
                 //4.创建空载具到输送线任务，完成后需要创建空载具缓存位->输送线任务
-            if (schBaseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"))) {
+                if (schBaseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"))) {
-                //校验任务是否存在
-                List<SchBaseTask> existTask = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"),null,null);
-                if (CollectionUtils.isEmpty(existTask)) {
-                    //如果是输送线->满轴缓存位任务
-                    List<BstIvtPackageinfoivt> kzjPointList = packageinfoivtService
-                            .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
-                                    .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用"))
-                                    .eq(BstIvtPackageinfoivt::getPoint_status, PackageInfoIvtEnum.POINT_STATUS.code("空载具缓存位"))
-                                    .eq(BstIvtPackageinfoivt::getIvt_status, PackageInfoIvtEnum.IVT_STATUS.code("空载具"))
-                                    .orderByDesc(BstIvtPackageinfoivt::getSort_seq));
-                    JSONObject toSsxTask = new JSONObject();
-                    toSsxTask.put("acs_task_type", PackageInfoIvtEnum.ACS_TASK_TYPE.code("桁架任务"));
-                    toSsxTask.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
-                    toSsxTask.put("vehicle_code", schBaseTask.getVehicle_code());
-                    //判断空载具缓存位是否有空载具库存,有就叫桁架去任一位置搬空载具,如果暂时没有空载具,定时任务会不断判断是否有空载具
-                    if (CollectionUtils.isEmpty(kzjPointList)) {
-                        toSsxTask.put("task_status", TaskStatusEnum.SURE_END.getCode());
-                        //确定终点为输送线点位
-                        toSsxTask.put("point_code2", schBaseTask.getPoint_code1());
-                    } else {
-                        toSsxTask.put("task_status", TaskStatusEnum.START_AND_POINT.getCode());
-                        //直接创建搬运空载具任务
-                        toSsxTask.put("point_code1", kzjPointList.get(0).getPoint_code());
-                        //终点为输送线点位
-                        toSsxTask.put("point_code2", schBaseTask.getPoint_code1());
-                    }
-                    ssxDjwTask.createTask(toSsxTask);
-                }
-            } else {
                     //四个点任务，改变pointCode3点位状态
                     packageinfoivtService.update(new UpdateWrapper<BstIvtPackageinfoivt>().set("ivt_status", PackageInfoIvtEnum.IVT_STATUS.code("空")).set("container_name", null).eq("point_code", schBaseTask.getPoint_code3()));
+                    //校验任务是否存在
+                    //                List<String> taskTypes = new ArrayList<>(Collections.singletonList(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)")));
+                    //                List<SchBaseTask> existTask = taskService.getExistTasks(taskTypes);
+                    //                if (CollectionUtils.isEmpty(existTask)) {
+                    //                    List<BstIvtPackageinfoivt> kzjPointList = packageinfoivtService
+                    //                            .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
+                    //                                    .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用"))
+                    //                                    .eq(BstIvtPackageinfoivt::getPoint_status, PackageInfoIvtEnum.POINT_STATUS.code("空载具缓存位"))
+                    //                                    .eq(BstIvtPackageinfoivt::getIvt_status, PackageInfoIvtEnum.IVT_STATUS.code("空载具"))
+                    //                                    .orderByDesc(BstIvtPackageinfoivt::getSort_seq));
+                    //                    JSONObject toSsxTask = new JSONObject();
+                    //                    toSsxTask.put("acs_task_type", PackageInfoIvtEnum.ACS_TASK_TYPE.code("桁架任务"));
+                    //                    toSsxTask.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
+                    //                    toSsxTask.put("vehicle_code", schBaseTask.getVehicle_code());
+                    //                    //判断空载具缓存位是否有空载具库存,有就叫桁架去任一位置搬空载具,如果暂时没有空载具,定时任务会不断判断是否有空载具
+                    //                    toSsxTask.put("task_status", TaskStatusEnum.SURE_END.getCode());
+                    //                    //终点为输送线点位
+                    //                    toSsxTask.put("point_code2", schBaseTask.getPoint_code1());
+                    //                    ssxDjwTask.createTask(toSsxTask);
+                    //                }
                 }
             }
         // 取消

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/tasks/first_floor_area/auto/AutoExecuteWaitTask.java

@@ -6,6 +6,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.nl.b_lms.sch.point.dao.BstIvtPackageinfoivt;
 import org.nl.b_lms.sch.point.service.IbstIvtPackageinfoivtService;
 import org.nl.b_lms.sch.task.dao.SchBaseTask;
@@ -23,8 +24,12 @@ import org.springframework.stereotype.Component;
 import javax.annotation.Resource;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 
 @Slf4j
@@ -72,6 +77,14 @@ public class AutoExecuteWaitTask {
                     if (task != null) {
                         String taskType = task.getTask_type();
                         if (PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)").equals(taskType)) {
+                            //校验任务是否存在
+                            List<String> taskTypes = new ArrayList<>(Arrays.asList(taskType, PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"),PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)")));
+                            List<SchBaseTask> existTask = taskService.getExistTasks(taskTypes);
+                            //过滤未分配的补空载具任务
+                            existTask = existTask.stream().filter(r-> StringUtils.isBlank(r.getResponse_param())).collect(Collectors.toList());
+                            if (existTask.size() > 0) {
+                                throw new BadRequestException("存在已分配的空载具补空任务未完成!");
+                            }
                             List<BstIvtPackageinfoivt> kzjPointList = packageinfoivtService
                                     .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
                                             .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用")
@@ -81,15 +94,18 @@ public class AutoExecuteWaitTask {
                             if (CollectionUtils.isEmpty(kzjPointList)) {
                                 return;
                             }
-                            List<SchBaseTask> existTaskList = taskService.getExistTasks(taskType,null,null);
-                            if (existTaskList.size() > 1) {
-                                throw new BadRequestException("存在多个子卷号相同的任务!");
-                            }
                             task.setPoint_code1(kzjPointList.get(0).getPoint_code());
                             task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode());
                             taskService.updateById(task);
                             ssxDjwTask.immediateNotifyAcs(null);
                         } else if (PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位").equals(taskType)) {
+                            //校验任务是否存在
+                            List<String> taskTypes = new ArrayList<>(Collections.singletonList(taskType));
+                            List<SchBaseTask> existTaskList = taskService.getExistTasks(taskTypes);
+                            //如果有就不创建，没有就创建
+                            if (existTaskList.size() > 1) {
+                                throw new BadRequestException("存在多个子卷号相同的任务!");
+                            }
                             List<BstIvtPackageinfoivt> mzPointList = packageinfoivtService
                                     .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
                                             .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用")
@@ -99,12 +115,6 @@ public class AutoExecuteWaitTask {
                             if (CollectionUtils.isEmpty(mzPointList)) {
                                 return;
                             }
-                            //校验相同是否存在相同子卷号任务
-                            List<SchBaseTask> existTaskList = taskService.getExistTasks(taskType,null,null);
-                            //如果有就不创建，没有就创建
-                            if (existTaskList.size() > 1) {
-                                throw new BadRequestException("存在多个子卷号相同的任务!");
-                            }
                             task.setPoint_code2(mzPointList.get(0).getPoint_code());
                             task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode());
                             taskService.updateById(task);

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/tasks/first_floor_area/auto/AutoSendMzToDjq.java

@@ -7,6 +7,8 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.nl.b_lms.sch.point.dao.BstIvtPackageinfoivt;
 import org.nl.b_lms.sch.point.service.IbstIvtPackageinfoivtService;
+import org.nl.b_lms.sch.task.dao.SchBaseTask;
+import org.nl.b_lms.sch.task.service.IschBaseTaskService;
 import org.nl.b_lms.sch.tasks.first_floor_area.DjqTask;
 import org.nl.common.enums.PackageInfoIvtEnum;
 import org.redisson.api.RLock;
@@ -14,6 +16,8 @@ import org.redisson.api.RedissonClient;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
@@ -24,6 +28,8 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 public class AutoSendMzToDjq {
 
+    @Resource
+    private IschBaseTaskService taskService;
     private final String THIS_CLASS = AutoSendMzToDjq.class.getName();
     @Resource
     private RedissonClient redissonClient;
@@ -67,6 +73,11 @@ public class AutoSendMzToDjq {
         boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
         try {
             if (tryLock) {
+                List<String> taskTypes = new ArrayList<>(Collections.singletonList(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区")));
+                List<SchBaseTask> existTask = taskService.getExistTasks(taskTypes);
+                if (existTask.size() > 2) {
+                    return;
+                }
                 //满轴有子卷且过滤未完成任务
                 List<BstIvtPackageinfoivt> mzqPackageinfoivtList = packageinfoivtService.checkEndPointTask(PackageInfoIvtEnum.POINT_STATUS.code("满轴缓存位"), PackageInfoIvtEnum.IVT_STATUS.code("有子卷"), PackageInfoIvtEnum.TASK_POINT_TYPE.code("四个点任务放货"), PackageInfoIvtEnum.SORT_TYPE.code("降序"), "");
                 if (CollectionUtils.isEmpty(mzqPackageinfoivtList)) {

lms/nladmin-system/src/main/java/org/nl/b_lms/sch/tasks/first_floor_area/auto/AutoSendVehicleToKzj.java

@@ -8,6 +8,8 @@ import org.apache.commons.collections4.CollectionUtils;
 import org.nl.b_lms.sch.point.dao.BstIvtPackageinfoivt;
 import org.nl.b_lms.sch.point.dao.mapper.BstIvtPackageinfoivtMapper;
 import org.nl.b_lms.sch.point.service.IbstIvtPackageinfoivtService;
+import org.nl.b_lms.sch.task.dao.SchBaseTask;
+import org.nl.b_lms.sch.task.service.IschBaseTaskService;
 import org.nl.b_lms.sch.tasks.first_floor_area.DjqToKzjhcwTask;
 import org.nl.b_lms.sch.tasks.first_floor_area.GzqToKzjhcwTask;
 import org.nl.common.enums.PackageInfoIvtEnum;
@@ -16,6 +18,8 @@ import org.redisson.api.RedissonClient;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
@@ -39,6 +43,9 @@ public class AutoSendVehicleToKzj {
     @Resource
     private IbstIvtPackageinfoivtService packageinfoivtService;
 
+    @Resource
+    private IschBaseTaskService taskService;
+
     //待检区或管制区->空载具缓存位补空
     public void run() {
         this.toKzjHcw2();
@@ -89,6 +96,12 @@ public class AutoSendVehicleToKzj {
                 JSONObject task = new JSONObject();
                 String pointCode1 = null;
                 String pointCode2;
+                //todo 校验补空任务是否小于3,后期需要根据区域动态获取任务数量
+                List<String> taskTypes = new ArrayList<>(Arrays.asList(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"), PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)")));
+                List<SchBaseTask> existTask = taskService.getExistTasks(taskTypes);
+                if (existTask.size() > 2) {
+                    return;
+                }
                 List<BstIvtPackageinfoivt> kzjIvtList = packageinfoivtService.checkEndPointTask(PackageInfoIvtEnum.POINT_STATUS.code("空载具缓存位"), null, PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货"), PackageInfoIvtEnum.SORT_TYPE.code("降序"), PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"));
                 if (CollectionUtils.isNotEmpty(kzjIvtList)) {
                     pointCode2 = kzjIvtList.get(0).getPoint_code();

lms/nladmin-system/src/main/java/org/nl/common/enums/PackageInfoIvtEnum.java

@@ -41,7 +41,7 @@ public enum PackageInfoIvtEnum {
 
 
     //起点终点类型
-    TASK_POINT_TYPE(MapOf.of("取货任务", "1", "放货任务", "2", "取货分配", "3", "放货分配", "4", "取货任务取货分配", "5", "放货任务放货分配", "6", "四个点任务放货", "7","空载具放货", "8", "四个点任务分配", "9")),
+    TASK_POINT_TYPE(MapOf.of("取货任务", "1", "放货任务", "2", "取货分配", "3", "放货分配", "4", "取货任务取货分配", "5", "放货任务放货分配", "6", "四个点任务放货", "7","空载具放货", "8", "四个点任务分配", "9","空载具放货分配", "10")),
 
     //等待点类型
     WAIT_POINT_TYPE(MapOf.of("满轴区等待点", "1", "待检区等待点", "2")),

lms/nladmin-system/src/main/java/org/nl/wms/ext/acs/service/impl/AcsToWmsServiceImpl.java

@@ -1837,7 +1837,8 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
                     }
                 } else {
                     //如果满轴位没有可用的空点位，先创建一个桁架任务但是不下发，等这边空出来点位，判断是否有这种桁架任务然后补发；
-                    List<SchBaseTask> existTaskList = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
+                    List<String> taskTypes = new ArrayList<>(Arrays.asList(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)")));
+                    List<SchBaseTask> existTaskList = taskService.getExistTasks(taskTypes);
                     //如果有就不创建，没有就创建
                     if (CollectionUtils.isEmpty(existTaskList)) {
                         //只确定起点NBJ1002
@@ -1849,12 +1850,14 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
                         jo2.put("task_status", TaskStatusEnum.SURE_START.getCode());
                         jo2.put("is_send", false);
                         mzhcwTask.createTask(jo2);
+                        //不确定起点的空载具缓存位->输送线任务
+                        createTask3(containerName);
                         result.put("status", HttpStatus.OK.value());
                         result.put("message", "反馈成功!");
                     } else {
-                        log.info("已存在任务编号为：" + existTaskList.get(0).getTask_code() + "未完成的桁架任务，请检查!");
+                        log.info("已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList.get(0).getTask_code() + "，请检查!");
                         result.put("status", HttpStatus.BAD_REQUEST.value());
-                        result.put("message", "已存在任务编号为：" + existTaskList.get(0).getTask_code() + "未完成的桁架任务，请检查!");
+                        result.put("message", "已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList.get(0).getTask_code() + "，请检查!");
                     }
                 }
             } else {
@@ -1877,15 +1880,30 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
     private JSONObject createTask2(String containerName, JSONObject jo) {
         JSONObject result = new JSONObject();
         result.put("data", containerName);
-        //如果空载具缓存位确少空载具，创建输送线->满轴缓存位两个点任务
+        //如果空载具缓存位缺少空载具，创建输送线->满轴缓存位两个点任务
-        List<SchBaseTask> existTaskList1 = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
+        List<String> taskTypes = new ArrayList<>(Arrays.asList(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)")));
+        List<SchBaseTask> existTaskList1 = taskService.getExistTasks(taskTypes);
         if (CollectionUtils.isEmpty(existTaskList1)) {
             jo.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"));
             jo.put("is_send", true);
             mzhcwTask.createTask(jo);
+            //不确定起点的空载具缓存位->输送线任务
+            createTask3(containerName);
+            result.put("status", HttpStatus.OK.value());
+            result.put("message", "反馈成功!");
+        } else {
+            log.info("已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
+            result.put("message", "已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
+            result.put("status", HttpStatus.BAD_REQUEST.value());
+        }
+        return result;
+    }
+
+    /**
+     * 不确定起点的空载具缓存位->输送线任务
+     */
+    private void createTask3(String containerName) {
         //空载具缓存位缺少空载具，下发一个确定终点的空载具缓存位->输送线任务
-            List<SchBaseTask> existTask1 = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"), null, null);
-            if (CollectionUtils.isEmpty(existTask1)) {
         JSONObject jo1 = new JSONObject();
         //创建确定终点任务
         jo1.put("acs_task_type", PackageInfoIvtEnum.ACS_TASK_TYPE.code("桁架任务"));
@@ -1896,21 +1914,14 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
         jo1.put("is_send", false);
         ssxDjwTask.createTask(jo1);
     }
-            result.put("status", HttpStatus.OK.value());
-            result.put("message", "反馈成功!");
-        } else {
-            log.info("已存在任务编号为：" + existTaskList1.get(0).getTask_code() + "未完成的桁架任务，请检查!");
-            result.put("message", "已存在任务编号为：" + existTaskList1.get(0).getTask_code() + "未完成的桁架任务，请检查!");
-            result.put("status", HttpStatus.BAD_REQUEST.value());
-        }
-        return result;
-    }
 
     private JSONObject createTask(String containerName, JSONObject jo, String pointCode3, String pointCode4) {
         JSONObject result = new JSONObject();
         result.put("data", containerName);
         // 创建前先判断是否有已创建相同任务
-        List<SchBaseTask> existTaskList1 = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
+        List<String> taskTypes = new ArrayList<>(Arrays.asList(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"), PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"), PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"), PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"), PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)")));
+        List<SchBaseTask> existTaskList1 = taskService.getExistTasks(taskTypes);
+        existTaskList1 = existTaskList1.stream().filter(r->StringUtils.isNotBlank(r.getResponse_param())).collect(Collectors.toList());
         if (CollectionUtils.isEmpty(existTaskList1)) {
             jo.put("point_code3", pointCode3);
             //终点为输送线点位
@@ -1921,8 +1932,8 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
             result.put("status", HttpStatus.OK.value());
             result.put("message", "反馈成功!");
         } else {
-            log.info("已存在任务编号为：" + existTaskList1.get(0).getTask_code() + "未完成的桁架任务，请检查!");
+            log.info("已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
-            result.put("message", "已存在任务编号为：" + existTaskList1.get(0).getTask_code() + "未完成的桁架任务，请检查!");
+            result.put("message", "已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
             result.put("status", HttpStatus.BAD_REQUEST.value());
         }
         return result;

lms/nladmin-ui/src/views/wms/basedata/st/boxInfo/boxinfo.js

@@ -0,0 +1,27 @@
+import request from '@/utils/request'
+
+export function add(data) {
+  return request({
+    url: 'api/boxinfo',
+    method: 'post',
+    data
+  })
+}
+
+export function del(ids) {
+  return request({
+    url: 'api/boxinfo/',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function edit(data) {
+  return request({
+    url: 'api/boxinfo',
+    method: 'put',
+    data
+  })
+}
+
+export default { add, edit, del }

lms/nladmin-ui/src/views/wms/basedata/st/boxInfo/index.vue

@@ -0,0 +1,208 @@
+<template>
+  <div class="app-container">
+    <!--工具栏-->
+    <div class="head-container">
+      <div v-if="crud.props.searchToggle">
+        <el-form
+          :inline="true"
+          class="demo-form-inline"
+          label-position="right"
+          label-width="80px"
+          label-suffix=":"
+        >
+          <el-form-item label="模糊搜索">
+            <el-input
+              v-model="query.search"
+              clearable
+              size="mini"
+              style="width: 230px;"
+              placeholder="木箱号、物料编码、物料名称"
+              @keyup.enter.native="crud.toQuery"
+            />
+          </el-form-item>
+
+          <rrOperation />
+        </el-form>
+      </div>
+      <!--如果想在工具栏加入更多按钮，可以使用插槽方式， slot = 'left' or 'right'-->
+      <crudOperation :permission="permission" />
+      <!--表单组件-->
+      <!--<el-dialog
+        :close-on-click-modal="false"
+        :before-close="crud.cancelCU"
+        :visible.sync="crud.status.cu > 0"
+        :title="crud.status.title"
+        width="800px"
+      >
+        <el-form ref="form" :model="form" :rules="rules" size="mini" label-width="120px">
+          <el-row :gutter="20">
+            <el-col :span="12">
+              <el-form-item label="木箱类型:" prop="box_type">
+                <el-input v-model="form.box_type" style="width: 200px;" :disabled="crud.status.edit > 0" />
+              </el-form-item>
+            </el-col>
+            <el-col :span="12">
+              <el-form-item label="木箱描述:" prop="box_name">
+                <el-input v-model="form.box_name" style="width: 200px;" :disabled="crud.status.edit > 0" />
+              </el-form-item>
+            </el-col>
+          </el-row>
+          <el-row :gutter="20">
+            <el-col :span="12">
+              <el-form-item label="捆扎模版:" prop="lash_num">
+                <el-input v-model="form.lash_num" style="width: 200px;" />
+              </el-form-item>
+            </el-col>
+            <el-col :span="12">
+              <el-form-item label="叉车取货宽度:" prop="expend_width">
+                <el-input-number :precision="2" :step="0.1" :min="0" :max="100" v-model="form.expend_width" size="mini" :controls="false" style="width: 200px" />
+              </el-form-item>
+            </el-col>
+          </el-row>
+          <el-row :gutter="20">
+            <el-col :span="12">
+              <el-form-item label="一次捆扎次数:" prop="lash_num_one">
+                <el-input-number :precision="0" :step="1" :min="0" :max="9" v-model="form.lash_num_one" size="mini" :controls="false" style="width: 200px" />
+              </el-form-item>
+            </el-col>
+            <el-col :span="12">
+              <el-form-item label="二次捆扎次数:" prop="lash_num_tow">
+                <el-input-number :precision="0" :step="1" :min="0" :max="9" v-model="form.lash_num_tow" size="mini" :controls="false" style="width: 200px" />
+              </el-form-item>
+            </el-col>
+          </el-row>
+          <el-row :gutter="20">
+            <el-col :span="12">
+              <el-form-item label="是否一次捆扎:" prop="need_lash_one">
+                <el-radio v-model="form.need_lash_one" label="1" style="width: 79px;" border>是</el-radio>
+                <el-radio v-model="form.need_lash_one" label="0" style="width: 79px;" border>否</el-radio>
+              </el-form-item>
+            </el-col>
+            <el-col :span="12">
+              <el-form-item label="是否二次捆扎:" prop="need_lash_two">
+                <el-radio v-model="form.need_lash_two" label="1" style="width: 79px;" border>是</el-radio>
+                <el-radio v-model="form.need_lash_two" label="0" style="width: 79px;" border>否</el-radio>
+              </el-form-item>
+            </el-col>
+          </el-row>
+        </el-form>
+        <div slot="footer" class="dialog-footer">
+          <el-button type="text" @click="crud.cancelCU">取消</el-button>
+          <el-button :loading="crud.cu === 2" type="primary" @click="crud.submitCU">确认</el-button>
+        </div>
+      </el-dialog>-->
+      <!--表格渲染-->
+      <el-table
+        ref="table"
+        v-loading="crud.loading"
+        :data="crud.data"
+        size="mini"
+        style="width: 100%;"
+        @selection-change="crud.selectionChangeHandler"
+      >
+        <el-table-column prop="box_no" sortable label="木箱号" :min-width="flexWidth('box_no',crud.data,'木箱号')" />
+        <el-table-column prop="material_code" label="物料编码" :min-width="flexWidth('material_code',crud.data,'物料编码')" />
+        <el-table-column prop="material_name" label="物料名称" :min-width="flexWidth('material_name',crud.data,'物料名称')" />
+        <el-table-column prop="num" label="最大子卷数" :min-width="flexWidth('num',crud.data,'最大子卷数')" />
+        <el-table-column prop="box_length" label="木箱长度" :min-width="flexWidth('box_length',crud.data,'木箱长度')" />
+        <el-table-column prop="box_width" label="木箱宽度" :min-width="flexWidth('box_width',crud.data,'木箱宽度')" />
+        <el-table-column prop="box_high" label="木箱高度" :min-width="flexWidth('box_high',crud.data,'木箱高度')" />
+        <el-table-column prop="vehicle_type" label="载具类型" :min-width="flexWidth('vehicle_type',crud.data,'载具类型')" :formatter="formattTwo"/>
+        <el-table-column prop="is_packing" label="是否装箱" :min-width="flexWidth('is_packing',crud.data,'是否装箱')" :formatter="formatOne" />
+        <el-table-column prop="box_weight" label="木箱重量" :min-width="flexWidth('box_weight',crud.data,'木箱重量')" />
+        <el-table-column prop="insert_time" label="创建时间" :min-width="flexWidth('insert_time',crud.data,'创建时间')" />
+       <!-- <el-table-column
+          v-permission="['admin','sectattr:edit','sectattr:del']"
+          label="操作"
+          width="120px"
+          fixed="right"
+          align="center"
+        >
+          <template slot-scope="scope">
+            <udOperation
+              :data="scope.row"
+              :permission="permission"
+            />
+          </template>
+        </el-table-column>-->
+      </el-table>
+      <!--分页组件-->
+      <pagination />
+    </div>
+  </div>
+</template>
+
+<script>
+import crudBoxinfo from '@/views/wms/basedata/st/boxInfo/boxinfo'
+import CRUD, { crud, form, header, presenter } from '@crud/crud'
+import rrOperation from '@crud/RR.operation'
+import crudOperation from '@crud/CRUD.operation'
+import udOperation from '@crud/UD.operation'
+import pagination from '@crud/Pagination'
+
+const defaultForm = {
+  box_id: null,
+  box_no: null,
+  material_code: null,
+  material_name: null,
+  num: null,
+  box_length: null,
+  box_width: null,
+  box_high: null,
+  insert_time: null,
+  lash_num: null,
+  vehicle_type: null,
+  is_packing: null,
+  box_weight: null
+}
+export default {
+  name: 'BoxInfo',
+  dicts: ['IS_OR_NOT'],
+  components: { pagination, crudOperation, rrOperation, udOperation },
+  mixins: [presenter(), header(), form(defaultForm), crud()],
+  cruds() {
+    return CRUD({
+      title: '木箱信息',
+      optShow: { add: false, reset: true },
+      url: 'api/boxinfo',
+      idField: 'box_id',
+      sort: 'box_no,desc',
+      crudMethod: { ...crudBoxinfo }
+    })
+  },
+  data() {
+    return {
+      stors: [],
+      permission: {
+        add: ['admin', 'user:add'],
+        edit: ['admin', 'user:edit'],
+        del: ['admin', 'user:del']
+      },
+      rules: {
+      }
+    }
+  },
+  methods: {
+    // 钩子：在获取表格数据之前执行，false 则代表不获取数据
+    [CRUD.HOOK.beforeRefresh]() {
+      return true
+    },
+    formatOne(row) {
+      return this.dict.label.IS_OR_NOT[row.is_packing]
+    },
+    formattTwo(row) {
+      if (row.vehicle_type === '1') {
+        return '小托盘'
+      }
+
+      if (row.vehicle_type === '2') {
+        return '大托盘'
+      }
+    }
+  }
+}
+</script>
+
+<style scoped>
+
+</style>

lms/nladmin-ui/src/views/wms/pdm/ivt/packageinfoivt/index.vue

@@ -197,6 +197,7 @@ const defaultForm = {
   update_optname: null,
   update_time: null
 }
+
 export default {
   name: 'Packageinfoivt',
   components: { pagination, crudOperation, rrOperation, udOperation },
@@ -220,6 +221,18 @@ export default {
   },
   data() {
     return {
+      form: {
+        check_id: '',
+        check_code: '',
+        stor_id: '',
+        stor_code: '',
+        stor_name: '',
+        status: '1',
+        dtl_num: '0',
+        check_type: '',
+        remark: '',
+        create_mode: ''
+      },
       permission: {},
       rules: {
         point_code: [

lms/nladmin-ui/src/views/wms/sch/task/index.vue

@@ -225,7 +225,7 @@ export default {
       title: '任务',
       url: 'api/task',
       idField: 'task_id',
-      sort: 'task_id,desc',
+      sort: 'create_time,desc',
       crudMethod: { ...crudTask },
       query: {
         task_code: '', is_delete: '0', vehicle_code: '', start_point_code: '', next_point_code: '', task_type: '', finished_type: '', task_status: ['-1']