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")
@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"))) {

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("该任务未执行或不存在！");
}
//已分配过二次分配点位
if (StringUtils.isNotBlank(baseTask.getRequest_param())) {
if (baseTask.getRequest_param().equals(IOSEnum.IS_SEND.code("是"))) {
if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货分配").equals(actionType)) {
return baseTask.getPoint_code1();
} else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
return baseTask.getPoint_code2();
}
}
}
// if (StringUtils.isNotBlank(baseTask.getResponse_param())) {
// if (baseTask.getResponse_param().equals(IOSEnum.IS_SEND.code("是"))) {
// if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货分配").equals(actionType)) {
// return baseTask.getPoint_code1();
// } else if (PackageInfoIvtEnum.TASK_ACTION_TYPE.code("放货分配").equals(actionType)) {
// 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,10 +190,13 @@ 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 {
log.info("一楼装箱区二次分配任务编号为:" + taskCode + ",分配失败，存在未完成的取放货任务或点位外层有载具阻挡！");
throw new BadRequestException("存在未完成的取放货任务或点位外层有载具阻挡！");
}
}
@@ -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,16 @@ 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> 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("取货任务取货分配"))) {
taskList = bstIvtPackageinfoivtMapper.getTaskList(pointIds, pointIds, pointIds, pointIds);
} else {
@@ -263,6 +277,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 +310,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());
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;
}
return getBstIvtPackageinfoivts(pointCode, taskList, ivtList);
} else {
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>()
.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)) {
//存在未完成的已分配的送空载具任务，需要等这个任务完成再分配
if (taskList1.stream().anyMatch(r -> !r.getPoint_code2().equals("ZXQ_01_1"))) {
throw new BadRequestException("请等待补空载具任务执行完成，再分配空载具点位");
List<SchBaseTask> taskList3 = taskList1.stream().filter(r -> StringUtils.isNotBlank(r.getResponse_param())).collect(Collectors.toList());
if (taskList3.size() == 1) {
//校验已分配的补空载具任务是否为当前请求的任务，是可重新分配，否不允许重新分配
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 +377,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 +480,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 +493,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("输送线四个点任务"))) {
//取空轴
upDateIvtOrTask(baseTask, baseTask.getPoint_code3(), true);
} else if (baseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("放空(空载具缓存位->输送线)"))) {
//取空轴
upDateIvtOrTask(baseTask, baseTask.getPoint_code1(), true);
} 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();
if (StringUtils.isBlank(baseTask.getRequest_param())) {
upDateIvtOrTask(baseTask, pointCode, true);
} else if (StringUtils.isNotBlank(baseTask.getRequest_param())) {
if (!baseTask.getRequest_param().equals(PackageInfoIvtEnum.TASK_ACTION_TYPE.code("取货完成"))) {
upDateIvtOrTask(baseTask, pointCode, true);
}
}
}
}
} else {
@@ -472,6 +518,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 +542,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());
}
/**
@@ -533,7 +581,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 {

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.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));
taskTypes.removeIf(StringUtils::isBlank);
if (!taskTypes.isEmpty()) {
if (CollectionUtils.isNotEmpty(taskTypes)) {
queryWrapper.in(SchBaseTask::getTask_type, taskTypes);
}
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())) {
log.info("任务编号为:"+schBaseTask.getTask_code()+"的任务完成接口在"+schBaseTask.getUpdate_time()+"被调用---------------------------------------------");
//1.更改任务状态为完成
schBaseTask.setTask_status(TaskStatusEnum.FINISHED.getCode());
//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()));
//3.任务一、待检区AGV搬运任务，查询子卷信息，去分切计划表查找定级数据，桁架任务完成根据子卷定级创建AGV任务将满轴搬运至质检区或管制区
//createTaskToDjq(schBaseTask);
//4.创建空载具到输送线任务，完成后需要创建空载具缓存位->输送线任务
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);
log.info("任务编号为:" + schBaseTask.getTask_code() + "的任务完成接口在" + schBaseTask.getUpdate_time() + "被调用---------------------------------------------");
//1.更改任务状态为完成
schBaseTask.setTask_status(TaskStatusEnum.FINISHED.getCode());
//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()));
//3.任务一、待检区AGV搬运任务，查询子卷信息，去分切计划表查找定级数据，桁架任务完成根据子卷定级创建AGV任务将满轴搬运至质检区或管制区
//createTaskToDjq(schBaseTask);
//4.创建空载具到输送线任务，完成后需要创建空载具缓存位->输送线任务
if (schBaseTask.getTask_type().equals(PackageInfoIvtEnum.TASK_TYPE.code("输送线四个点任务"))) {
//四个点任务，改变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);
// }
}
} 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 (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.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);

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.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)) {

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.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();

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")),
@@ -63,7 +63,7 @@ public enum PackageInfoIvtEnum {
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;

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 {
//如果满轴位没有可用的空点位，先创建一个桁架任务但是不下发，等这边空出来点位，判断是否有这种桁架任务然后补发；
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,40 +1880,48 @@ 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);
//空载具缓存位缺少空载具，下发一个确定终点的空载具缓存位->输送线任务
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("桁架任务"));
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);
}
//不确定起点的空载具缓存位->输送线任务
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() + "未完成的桁架任务，请检查!");
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) {
//空载具缓存位缺少空载具，下发一个确定终点的空载具缓存位->输送线任务
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) {
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() + "未完成的桁架任务，请检查!");
result.put("message", "已存在任务编号为：" + existTaskList1.get(0).getTask_code() + "未完成的桁架任务，请检查!");
log.info("已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
result.put("message", "已存在未完成的且已分配的补空载具或桁架任务,任务编号为：" + existTaskList1.get(0).getTask_code() + "，请检查!");
result.put("status", HttpStatus.BAD_REQUEST.value());
}
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_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: [

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

@@ -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']