root/longdianningxing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix:增加桁架任务及二次分配任务完成情况校验

Browse Source
This commit is contained in:
gongbaoxiong
2024-07-11 19:26:58 +08:00
parent e3da38f4f9
commit 62774053a3
12 changed files with 222 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@@ -154,15 +154,15 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
throw new BadRequestException("该任务未执行或不存在！"); 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; BstIvtPackageinfoivt newPoint;
String taskPointType = null; String taskPointType = null;
//空载具缓存位特殊二次分配逻辑：先判断是否有执行中的行架任务或补空载具任务，如未完成，不分配点位 //空载具缓存位特殊二次分配逻辑：先判断是否有执行中的行架任务或补空载具任务，如未完成，不分配点位
@@ -170,7 +170,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)")) baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)"))
) { ) {
//检查是否满足二次分配条件 //检查是否满足二次分配条件
checkTaskInfo(); checkTaskInfo(baseTask);
newPoint = checkIvtSBlock(baseTask); newPoint = checkIvtSBlock(baseTask);
} else { } else {
if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区"))) { if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区"))) {
@@ -190,10 +190,13 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
} else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) { } else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
baseTask.setPoint_code2(newPoint.getPoint_code()); baseTask.setPoint_code2(newPoint.getPoint_code());
} }
baseTask.setRequest_param(IOSEnum.IS_SEND.code("是")); //标记二次分配已分配过点位
baseTask.setResponse_param(IOSEnum.IS_NOTANDYES.code("是"));
taskService.updateById(baseTask); taskService.updateById(baseTask);
log.info("一楼装箱区二次分配任务编号为:" + taskCode + ",接口返回最新点位：---------------------------------------------" + newPoint.getPoint_code());
return newPoint.getPoint_code(); return newPoint.getPoint_code();
} else { } else {
log.info("一楼装箱区二次分配任务编号为:" + taskCode + ",分配失败，存在未完成的取放货任务或点位外层有载具阻挡！");
throw new BadRequestException("存在未完成的取放货任务或点位外层有载具阻挡！"); throw new BadRequestException("存在未完成的取放货任务或点位外层有载具阻挡！");
} }
} }
@@ -210,12 +213,13 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
*/ */
@Override @Override
public List<BstIvtPackageinfoivt> checkEndPointTask(String ivtType, String ivtStatus, String pointCode, String sortType, String taskType) { 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); List<BstIvtPackageinfoivt> packageinfoivtList = getBstIvtPackageinfoivts(ivtType, ivtStatus, sortType);
Set<String> pointIds = packageinfoivtList.stream() Set<String> pointIds = packageinfoivtList.stream()
.map(BstIvtPackageinfoivt::getPoint_code) .map(BstIvtPackageinfoivt::getPoint_code)
.collect(Collectors.toSet()); .collect(Collectors.toSet());
if (CollectionUtils.isEmpty(pointIds)) { if (CollectionUtils.isEmpty(pointIds)) {
return Collections.emptyList(); return returList;
} }
if (pointCode == null) { if (pointCode == null) {
return packageinfoivtList; return packageinfoivtList;
@@ -234,6 +238,16 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, null, pointIds, null); taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, null, pointIds, null);
} else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货"))) { } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货"))) {
taskList = bstIvtPackageinfoivtMapper.getTaskList(null, pointIds, null, pointIds); taskList = bstIvtPackageinfoivtMapper.getTaskList(null, pointIds, null, pointIds);
} else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("空载具放货分配"))) {
List<BstIvtPackageinfoivt> ivtList = packageinfoivtList.stream().filter(r -> r.getIvt_status().equals(PackageInfoIvtEnum.IVT_STATUS.code("空"))).sorted(Comparator.comparing(BstIvtPackageinfoivt::getSort_seq).reversed()).collect(Collectors.toList());
if (CollectionUtils.isNotEmpty(ivtList)) {
BstIvtPackageinfoivt bstIvtPackageinfoivt = new BstIvtPackageinfoivt();
bstIvtPackageinfoivt.setPoint_code(ivtList.get(0).getPoint_code());
returList.add(bstIvtPackageinfoivt);
return returList;
} else {
return returList;
}
} else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("取货任务取货分配"))) { } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("取货任务取货分配"))) {
taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, pointIds, pointIds, pointIds); taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, pointIds, pointIds, pointIds);
} else { } else {
@@ -263,6 +277,14 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
)) ))
.filter(Objects::nonNull) .filter(Objects::nonNull)
.collect(Collectors.toSet()); .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("放货任务"))) { } else if (pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("取货任务")) || pointCode.equals(PackageInfoIvtEnum.TASK_POINT_TYPE.code("放货任务"))) {
pointSets = taskList.stream() pointSets = taskList.stream()
.flatMap(task -> Stream.of( .flatMap(task -> Stream.of(
@@ -288,46 +310,66 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
.collect(Collectors.toList()); .collect(Collectors.toList());
//送空载具到空载具缓存位任务，需要判断是否存在已分配的且未完成的送空载具任务，如果存在，判断存在是否阻挡 //送空载具到空载具缓存位任务，需要判断是否存在已分配的且未完成的送空载具任务，如果存在，判断存在是否阻挡
if (taskType.equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)")) || taskType.equals(PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)"))) { 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 getBstIvtPackageinfoivts(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 { } else {
return ivtList; return ivtList;
} }
} }
/**
* 判断阻挡
*/
private List<BstIvtPackageinfoivt> getBstIvtPackageinfoivts(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>() List<SchBaseTask> taskList1 = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
.lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode()) .lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode())
.eq(SchBaseTask::getIs_delete, IOSEnum.IS_NOTANDYES.code("否"))
.and( .and(
r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)")) r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(管制区->空载具缓存位)"))
.or() .or()
.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)") .eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("补空(待检区->空载具缓存位)")
))); )));
if (CollectionUtils.isNotEmpty(taskList1)) { 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>() 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( .and(
r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务")) r -> r.eq(SchBaseTask::getTask_type, PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"))
.or() .or()
@@ -335,10 +377,12 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
))); )));
if (CollectionUtils.isNotEmpty(taskList2)) { if (CollectionUtils.isNotEmpty(taskList2)) {
if (StringUtils.isBlank(taskList2.get(0).getRequest_param())) { 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 { } else {
if (!taskList2.get(0).getRequest_param().equals(PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"))) { 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 +480,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区")) || 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("输送线四个点任务")) ||
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("满轴缓存位->待检区"))) { if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("满轴缓存位->待检区"))) {
List<BstIvtPackageinfoivt> ivtList = packageinfoivtService.list(new LambdaQueryWrapper<BstIvtPackageinfoivt>() List<BstIvtPackageinfoivt> ivtList = packageinfoivtService.list(new LambdaQueryWrapper<BstIvtPackageinfoivt>()
@@ -448,14 +493,15 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
if (baseTask.getVehicle_code().equals(ivtList.get(0).getContainer_name())) { if (baseTask.getVehicle_code().equals(ivtList.get(0).getContainer_name())) {
upDateIvtOrTask(baseTask, baseTask.getPoint_code1(), false); 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 { } else {
@@ -472,6 +518,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
.set("container_name", baseTask.getVehicle_code()) .set("container_name", baseTask.getVehicle_code())
.set("ivt_status", PackageInfoIvtEnum.IVT_STATUS.code("有子卷")) .set("ivt_status", PackageInfoIvtEnum.IVT_STATUS.code("有子卷"))
.eq("point_code", baseTask.getPoint_code2())); .eq("point_code", baseTask.getPoint_code2()));
log.info("一楼装箱区二次分配的任务编号为:" + baseTask.getTask_code() + ",放货完成执行成功，放货信息：点位：" + baseTask.getPoint_code2() + "子卷号为：" + baseTask.getVehicle_code());
} else { } else {
throw new BadRequestException("该点位已有库存！"); throw new BadRequestException("该点位已有库存！");
} }
@@ -495,6 +542,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
updateWrapper1.set("request_param", PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成")); updateWrapper1.set("request_param", PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"));
taskService.update(updateWrapper1); taskService.update(updateWrapper1);
} }
log.info("一楼装箱区二次分配的任务编号为:" + baseTask.getTask_code() + ",取货完成执行成功，取货信息：点位：" + pointCode + "子卷号为：" + baseTask.getVehicle_code());
} }
/** /**
@@ -533,7 +581,7 @@ public class BstIvtPackageinfoivtServiceImpl extends ServiceImpl<BstIvtPackagein
*/ */
public BstIvtPackageinfoivt checkIvtSBlock(SchBaseTask baseTask) { public BstIvtPackageinfoivt checkIvtSBlock(SchBaseTask baseTask) {
BstIvtPackageinfoivt newPoint = new BstIvtPackageinfoivt(); 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)) { if (CollectionUtils.isNotEmpty(kzjIvtList)) {
return kzjIvtList.get(0); return kzjIvtList.get(0);
} else { } else {

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

@@ -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);
} }

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

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.nl.b_lms.sch.task.dao.SchBaseTask; import org.nl.b_lms.sch.task.dao.SchBaseTask;
import org.nl.b_lms.sch.task.dao.mapper.SchBaseTaskMapper; 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<>(); LambdaQueryWrapper<SchBaseTask> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode()); queryWrapper.lt(SchBaseTask::getTask_status, TaskStatusEnum.FINISHED.getCode());
queryWrapper.eq(SchBaseTask::getIs_delete, IOSEnum.IS_NOTANDYES.code("否")); 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); queryWrapper.in(SchBaseTask::getTask_type, taskTypes);
} }
return this.list(queryWrapper); return this.list(queryWrapper);

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

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

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

@@ -6,6 +6,7 @@ import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows; import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils; 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.dao.BstIvtPackageinfoivt;
import org.nl.b_lms.sch.point.service.IbstIvtPackageinfoivtService; 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.dao.SchBaseTask;
@@ -23,8 +24,12 @@ import org.springframework.stereotype.Component;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.time.LocalDate; import java.time.LocalDate;
import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@Slf4j @Slf4j
@@ -72,6 +77,14 @@ public class AutoExecuteWaitTask {
if (task != null) { if (task != null) {
String taskType = task.getTask_type(); String taskType = task.getTask_type();
if (PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)").equals(taskType)) { 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<BstIvtPackageinfoivt> kzjPointList = packageinfoivtService
.list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>() .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
.eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用") .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用")
@@ -81,15 +94,18 @@ public class AutoExecuteWaitTask {
if (CollectionUtils.isEmpty(kzjPointList)) { if (CollectionUtils.isEmpty(kzjPointList)) {
return; 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.setPoint_code1(kzjPointList.get(0).getPoint_code());
task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode()); task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode());
taskService.updateById(task); taskService.updateById(task);
ssxDjwTask.immediateNotifyAcs(null); ssxDjwTask.immediateNotifyAcs(null);
} else if (PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位").equals(taskType)) { } 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<BstIvtPackageinfoivt> mzPointList = packageinfoivtService
.list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>() .list(new LambdaUpdateWrapper<BstIvtPackageinfoivt>()
.eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用") .eq(BstIvtPackageinfoivt::getIs_used, PackageInfoIvtEnum.IS_USED.code("启用")
@@ -99,12 +115,6 @@ public class AutoExecuteWaitTask {
if (CollectionUtils.isEmpty(mzPointList)) { if (CollectionUtils.isEmpty(mzPointList)) {
return; 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.setPoint_code2(mzPointList.get(0).getPoint_code());
task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode()); task.setTask_status(TaskStatusEnum.START_AND_POINT.getCode());
taskService.updateById(task); taskService.updateById(task);

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

@@ -7,6 +7,8 @@ import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.CollectionUtils;
import org.nl.b_lms.sch.point.dao.BstIvtPackageinfoivt; import org.nl.b_lms.sch.point.dao.BstIvtPackageinfoivt;
import org.nl.b_lms.sch.point.service.IbstIvtPackageinfoivtService; 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.b_lms.sch.tasks.first_floor_area.DjqTask;
import org.nl.common.enums.PackageInfoIvtEnum; import org.nl.common.enums.PackageInfoIvtEnum;
import org.redisson.api.RLock; import org.redisson.api.RLock;
@@ -14,6 +16,8 @@ import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@@ -24,6 +28,8 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor @RequiredArgsConstructor
public class AutoSendMzToDjq { public class AutoSendMzToDjq {
@Resource
private IschBaseTaskService taskService;
private final String THIS_CLASS = AutoSendMzToDjq.class.getName(); private final String THIS_CLASS = AutoSendMzToDjq.class.getName();
@Resource @Resource
private RedissonClient redissonClient; private RedissonClient redissonClient;
@@ -67,6 +73,11 @@ public class AutoSendMzToDjq {
boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS); boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
try { try {
if (tryLock) { 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("降序"), ""); 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)) { if (CollectionUtils.isEmpty(mzqPackageinfoivtList)) {

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

@@ -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.BstIvtPackageinfoivt;
import org.nl.b_lms.sch.point.dao.mapper.BstIvtPackageinfoivtMapper; 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.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.DjqToKzjhcwTask;
import org.nl.b_lms.sch.tasks.first_floor_area.GzqToKzjhcwTask; import org.nl.b_lms.sch.tasks.first_floor_area.GzqToKzjhcwTask;
import org.nl.common.enums.PackageInfoIvtEnum; import org.nl.common.enums.PackageInfoIvtEnum;
@@ -16,6 +18,8 @@ import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@@ -39,6 +43,9 @@ public class AutoSendVehicleToKzj {
@Resource @Resource
private IbstIvtPackageinfoivtService packageinfoivtService; private IbstIvtPackageinfoivtService packageinfoivtService;
@Resource
private IschBaseTaskService taskService;
//待检区或管制区->空载具缓存位补空 //待检区或管制区->空载具缓存位补空
public void run() { public void run() {
this.toKzjHcw2(); this.toKzjHcw2();
@@ -89,6 +96,12 @@ public class AutoSendVehicleToKzj {
JSONObject task = new JSONObject(); JSONObject task = new JSONObject();
String pointCode1 = null; String pointCode1 = null;
String pointCode2; 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("补空(待检区->空载具缓存位)")); 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)) { if (CollectionUtils.isNotEmpty(kzjIvtList)) {
pointCode2 = kzjIvtList.get(0).getPoint_code(); pointCode2 = kzjIvtList.get(0).getPoint_code();

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

@@ -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")), WAIT_POINT_TYPE(MapOf.of("满轴区等待点", "1", "待检区等待点", "2")),
@@ -63,7 +63,7 @@ public enum PackageInfoIvtEnum {
POINT_LOCATION(MapOf.of("上", "0", "下", "1")), POINT_LOCATION(MapOf.of("上", "0", "下", "1")),
//库存状态 //库存状态
IVT_STATUS(MapOf.of("空", "0", "空载具", "1", "有子卷", "2", "合格品", "3", "管制品", "4")); IVT_STATUS(MapOf.of("空", "0", "空载具", "1", "有子卷", "2", "合格品", "3", "管制品", "4"));
private Map<String, String> code; private Map<String, String> code;

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

@@ -1837,7 +1837,8 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
} }
} else { } 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)) { if (CollectionUtils.isEmpty(existTaskList)) {
//只确定起点NBJ1002 //只确定起点NBJ1002
@@ -1849,12 +1850,14 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
jo2.put("task_status", TaskStatusEnum.SURE_START.getCode()); jo2.put("task_status", TaskStatusEnum.SURE_START.getCode());
jo2.put("is_send", false); jo2.put("is_send", false);
mzhcwTask.createTask(jo2); mzhcwTask.createTask(jo2);
//不确定起点的空载具缓存位->输送线任务
createTask3(containerName);
result.put("status", HttpStatus.OK.value()); result.put("status", HttpStatus.OK.value());
result.put("message", "反馈成功!"); result.put("message", "反馈成功!");
} else { } else {
log.info("已存在任务编号为：" + existTaskList.get(0).getTask_code() + "未完成的桁架任务，请检查!"); log.info("已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList.get(0).getTask_code() + "，请检查!");
result.put("status", HttpStatus.BAD_REQUEST.value()); result.put("status", HttpStatus.BAD_REQUEST.value());
result.put("message", "已存在任务编号为：" + existTaskList.get(0).getTask_code() + "未完成的桁架任务，请检查!"); result.put("message", "已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList.get(0).getTask_code() + "，请检查!");
} }
} }
} else { } else {
@@ -1877,40 +1880,48 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
private JSONObject createTask2(String containerName, JSONObject jo) { private JSONObject createTask2(String containerName, JSONObject jo) {
JSONObject result = new JSONObject(); JSONObject result = new JSONObject();
result.put("data", containerName); 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)) { if (CollectionUtils.isEmpty(existTaskList1)) {
jo.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位")); jo.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("输送线->满轴缓存位"));
jo.put("is_send", true); jo.put("is_send", true);
mzhcwTask.createTask(jo); mzhcwTask.createTask(jo);
//空载具缓存位缺少空载具，下发一个确定终点的空载具缓存位->输送线任务 //不确定起点的空载具缓存位->输送线任务
List<SchBaseTask> existTask1 = taskService.getExistTasks(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"), null, null); createTask3(containerName);
if (CollectionUtils.isEmpty(existTask1)) {
JSONObject jo1 = new JSONObject();
//创建确定终点任务
jo1.put("acs_task_type", PackageInfoIvtEnum.ACS_TASK_TYPE.code("桁架任务"));
jo1.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
jo1.put("point_code2", "NBJ1002");
jo1.put("vehicle_code", containerName);
jo1.put("task_status", TaskStatusEnum.SURE_END.getCode());
jo1.put("is_send", false);
ssxDjwTask.createTask(jo1);
}
result.put("status", HttpStatus.OK.value()); result.put("status", HttpStatus.OK.value());
result.put("message", "反馈成功!"); result.put("message", "反馈成功!");
} else { } 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()); result.put("status", HttpStatus.BAD_REQUEST.value());
} }
return result; return result;
} }
/**
* 不确定起点的空载具缓存位->输送线任务
*/
private void createTask3(String containerName) {
//空载具缓存位缺少空载具，下发一个确定终点的空载具缓存位->输送线任务
JSONObject jo1 = new JSONObject();
//创建确定终点任务
jo1.put("acs_task_type", PackageInfoIvtEnum.ACS_TASK_TYPE.code("桁架任务"));
jo1.put("task_type", PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"));
jo1.put("point_code2", "NBJ1002");
jo1.put("vehicle_code", containerName);
jo1.put("task_status", TaskStatusEnum.SURE_END.getCode());
jo1.put("is_send", false);
ssxDjwTask.createTask(jo1);
}
private JSONObject createTask(String containerName, JSONObject jo, String pointCode3, String pointCode4) { private JSONObject createTask(String containerName, JSONObject jo, String pointCode3, String pointCode4) {
JSONObject result = new JSONObject(); JSONObject result = new JSONObject();
result.put("data", containerName); 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)) { if (CollectionUtils.isEmpty(existTaskList1)) {
jo.put("point_code3", pointCode3); jo.put("point_code3", pointCode3);
//终点为输送线点位 //终点为输送线点位
@@ -1921,8 +1932,8 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
result.put("status", HttpStatus.OK.value()); result.put("status", HttpStatus.OK.value());
result.put("message", "反馈成功!"); result.put("message", "反馈成功!");
} else { } 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()); result.put("status", HttpStatus.BAD_REQUEST.value());
} }
return result; return result;

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

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

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

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