FeiDaBaoKai/wms_server_kate_suzhou
11
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修复bug，回退测试方法

Browse Source
This commit is contained in:
梁州 2025-11-13 10:48:09 +08:00
parent 504b7cb96b
commit dc62dd9cfa
4 changed files with 120 additions and 571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
src/main/java/com/wms/controller/TaskController.java
View File

@ -490,8 +490,6 @@ public class TaskController {
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, inTask.getTaskId())); taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, inTask.getTaskId()));
// 移除当前料箱所有的拣选任务 // 移除当前料箱所有的拣选任务
pickTaskService.remove(new LambdaQueryWrapper<PickTask>().eq(PickTask::getVehicleId, inTask.getVehicleId())); pickTaskService.remove(new LambdaQueryWrapper<PickTask>().eq(PickTask::getVehicleId, inTask.getVehicleId()));
// 移除当前料箱所有的outsideVehicles---todo 这张表已经废弃不用
// outsideVehiclesService.remove(new LambdaQueryWrapper<OutsideVehicles>().eq(OutsideVehicles::getVehicleId, inTask.getVehicleId()));
// 清除当前料箱的所有盘点任务 // 清除当前料箱的所有盘点任务
inventoryService.remove(new LambdaQueryWrapper<InventoryList>().eq(InventoryList::getVehicleId, inTask.getVehicleId())); inventoryService.remove(new LambdaQueryWrapper<InventoryList>().eq(InventoryList::getVehicleId, inTask.getVehicleId()));
} }
@ -512,22 +510,16 @@ public class TaskController {
.set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()) .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
.eq(Vehicle::getVehicleId, outTask.getVehicleId()) .eq(Vehicle::getVehicleId, outTask.getVehicleId())
.ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())); .ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
// 当前载具上所有库存状态设置为拣选---todo 是否要更改为outed状态 // 当前载具上所有库存状态设置为拣选
stockService.update(new LambdaUpdateWrapper<Stock>() stockService.update(new LambdaUpdateWrapper<Stock>()
.set(Stock::getStockStatus, StockStatus.PICKING.getCode()) .set(Stock::getStockStatus, StockStatus.OUTED.getCode())
.eq(Stock::getVehicleId, outTask.getVehicleId()) .eq(Stock::getVehicleId, outTask.getVehicleId())
.ne(Stock::getStockStatus, StockStatus.PICKING.getCode())); .ne(Stock::getStockStatus, StockStatus.OUTED.getCode()));
// 将该载具对应的拣选任务设置为可发送状态 // 将该载具对应的拣选任务设置为可发送状态
pickTaskService.update(new LambdaUpdateWrapper<PickTask>() pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
.set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode()) .set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())
.eq(PickTask::getVehicleId, outTask.getVehicleId()) .eq(PickTask::getVehicleId, outTask.getVehicleId())
.eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode())); .eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode()));
// 设置特殊---todo 此表废弃
// standStackerTaskService.update(new LambdaUpdateWrapper<StandStackerTask>()
// .set(StandStackerTask::getTaskStatus, 1)
// .set(StandStackerTask::getFinishTime, LocalDateTime.now())
// .eq(StandStackerTask::getVehicleId, outTask.getVehicleId())
// .ne(StandStackerTask::getTaskStatus, 1));
} else {// 代表整出 } else {// 代表整出
// 删除当前载具上所有库存 // 删除当前载具上所有库存
List<Stock> removeStocks = stockService.list(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, outTask.getVehicleId())); List<Stock> removeStocks = stockService.list(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, outTask.getVehicleId()));
@ -912,7 +904,7 @@ public class TaskController {
.set(PickTask::getLastUpdateTime, LocalDateTime.now()) .set(PickTask::getLastUpdateTime, LocalDateTime.now())
.eq(PickTask::getVehicleId, boxArriveRequest.getVehicleNo()) .eq(PickTask::getVehicleId, boxArriveRequest.getVehicleNo())
.eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode())); .eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode()));
// 重置当前站台非当前箱子的已完成拣选任务 todo // 重置当前站台非当前箱子的已完成拣选任务
pickTaskService.update(new LambdaUpdateWrapper<PickTask>() pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
.set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode()) .set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())
.set(PickTask::getLastUpdateTime, LocalDateTime.now()) .set(PickTask::getLastUpdateTime, LocalDateTime.now())
@ -923,6 +915,11 @@ public class TaskController {
standService.update(new LambdaUpdateWrapper<Stand>() standService.update(new LambdaUpdateWrapper<Stand>()
.set(Stand::getPickVehicle, boxArriveRequest.getVehicleNo()) .set(Stand::getPickVehicle, boxArriveRequest.getVehicleNo())
.eq(Stand::getStandId, pickTask.getStandId())); .eq(Stand::getStandId, pickTask.getStandId()));
// 更新库存为拣选中
stockService.update(new LambdaUpdateWrapper<Stock>()
.set(Stock::getStockStatus, StockStatus.PICKING.getCode())
.eq(Stock::getVehicleId, boxArriveRequest.getVehicleNo())
.ne(Stock::getStockStatus, StockStatus.PICKING.getCode()));
response.setCode(ResponseCode.OK.getCode()); response.setCode(ResponseCode.OK.getCode());
response.setMessage("上报成功"); response.setMessage("上报成功");
@ -1084,46 +1081,33 @@ public class TaskController {
wcsETaskRequest.setOrderId(generateId(workQuery.getGoodsId() + "_")); wcsETaskRequest.setOrderId(generateId(workQuery.getGoodsId() + "_"));
wcsETaskRequest.setVehicleNo(vehicleId); wcsETaskRequest.setVehicleNo(vehicleId);
String sendToWcsETaskUrl = configMap.get(ConfigMapKeyEnum.URL_WCS_E_TASK.getConfigKey()); String sendToWcsETaskUrl = configMap.get(ConfigMapKeyEnum.URL_WCS_E_TASK.getConfigKey());
if (StringUtils.isEmpty(sendToWcsETaskUrl)) {
// TODO 这里是模拟的 // url地址为空
// 更新workFlow数据 logger.error("向Wcs发送电子标签亮灯任务的地址为空");
workFlowService.updateBatchById(workFlows); throw new Exception("向Wcs发送电子标签亮灯任务的地址为空");
// 更新亮灯数据 } else {
etagLocationService.update(new LambdaUpdateWrapper<ETagLocation>() // 发送信息
.set(ETagLocation::getPickStatus, 1) logger.info("发送电子标签亮灯请求：{}", convertJsonString(wcsETaskRequest));
.set(ETagLocation::getTaskType, wcsETaskRequest.getTaskType()) ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(sendToWcsETaskUrl, convertJsonString(wcsETaskRequest)), ResponseEntity.class);
.set(ETagLocation::getVehicleNo, wcsETaskRequest.getVehicleNo()) try {
.in(ETagLocation::getELocationId, eTaskDataList.stream().map(ETaskData::getLocation).collect(Collectors.toList()))); logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "发送电子标签任务", "eTagTask", convertJsonString(wcsETaskRequest), convertJsonString(result), sendToWcsETaskUrl, LocalDateTime.now(), "WMS"));
} catch (Exception e) {
logger.error("插入日志错误");
// TODO 模拟结束要去掉注释 }
// if (StringUtils.isEmpty(sendToWcsETaskUrl)) { if (result == null || !Objects.equals(result.getCode(), ResponseCode.OK.getCode())) {
// // url地址为空 logger.error("发送电子标签亮灯任务失败：{}", convertJsonString(result));
// logger.error("向Wcs发送电子标签亮灯任务的地址为空"); throw new Exception("发送电子标签亮灯任务失败");
// throw new Exception("向Wcs发送电子标签亮灯任务的地址为空"); } else {
// } else { // 更新workFlow数据
// // 发送信息 workFlowService.updateBatchById(workFlows);
// logger.info("发送电子标签亮灯请求：{}", convertJsonString(wcsETaskRequest)); // 更新亮灯数据
// ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(sendToWcsETaskUrl, convertJsonString(wcsETaskRequest)), ResponseEntity.class); etagLocationService.update(new LambdaUpdateWrapper<ETagLocation>()
// try { .set(ETagLocation::getPickStatus, 1)
// logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "发送电子标签任务", "eTagTask", convertJsonString(wcsETaskRequest), convertJsonString(result), sendToWcsETaskUrl, LocalDateTime.now(), "WMS")); .set(ETagLocation::getTaskType, wcsETaskRequest.getTaskType())
// } catch (Exception e) { .set(ETagLocation::getVehicleNo, wcsETaskRequest.getVehicleNo())
// logger.error("插入日志错误"); .in(ETagLocation::getELocationId, eTaskDataList.stream().map(ETaskData::getLocation).collect(Collectors.toList())));
// } }
// if (result == null || !Objects.equals(result.getCode(), ResponseCode.OK.getCode())) { }
// logger.error("发送电子标签亮灯任务失败：{}", convertJsonString(result));
// throw new Exception("发送电子标签亮灯任务失败");
// } else {
// // 更新workFlow数据
// workFlowService.updateBatchById(workFlows);
// // 更新亮灯数据
// etagLocationService.update(new LambdaUpdateWrapper<ETagLocation>()
// .set(ETagLocation::getPickStatus, 1)
// .set(ETagLocation::getTaskType, wcsETaskRequest.getTaskType())
// .set(ETagLocation::getVehicleNo, wcsETaskRequest.getVehicleNo())
// .in(ETagLocation::getELocationId, eTaskDataList.stream().map(ETaskData::getLocation).collect(Collectors.toList())));
// }
// }
} }
// 更新站台数据 // 更新站台数据
standService.update(new LambdaUpdateWrapper<Stand>() standService.update(new LambdaUpdateWrapper<Stand>()
@ -1412,49 +1396,6 @@ public class TaskController {
} }
// 更新实际拣选数量 // 更新实际拣选数量
workFlow.setPickedNum(workFlow.getPickedNum().add(BigDecimal.valueOf(eTaskFeedbackRequest.getConfirmNum()))); workFlow.setPickedNum(workFlow.getPickedNum().add(BigDecimal.valueOf(eTaskFeedbackRequest.getConfirmNum())));
// todo---下面两张表废弃使用
// if (eTaskFeedbackRequest.getConfirmNum().compareTo(eTaskFeedbackRequest.getNeedNum()) < 0) {
// int diffNum = eTaskFeedbackRequest.getNeedNum() - eTaskFeedbackRequest.getConfirmNum();
// // 查站台要料表---未分配以及分配但未完全分配
// GoodsToStation goodsToStation = goodsToStationService.getOne(new LambdaQueryWrapper<GoodsToStation>()
// .eq(GoodsToStation::getWorkStation, workFlow.getWorkStation())
// .eq(GoodsToStation::getGoodsId, workFlow.getGoodsId())
// .last("limit 1"));
// if (goodsToStation != null) {
// // 更新站台要料数量
// BigDecimal newDistributeNum = goodsToStation.getDistributedNum().subtract(BigDecimal.valueOf(diffNum));
// goodsToStation.setDistributedNum(newDistributeNum.compareTo(BigDecimal.ZERO) <= 0 ? BigDecimal.ZERO : newDistributeNum);
// goodsToStation.setDistributeStatus(1);
// goodsToStationService.updateById(goodsToStation);
// }
// // 查询当前站台的拣货任务
// PickTask pickTask = pickTaskService.getOne(new LambdaQueryWrapper<PickTask>()
// .eq(PickTask::getStandId, workFlow.getWorkStation())
// .eq(PickTask::getPickStatus, PickTaskStatusEnum.FINISH.getCode())
// .last("limit 1"));
// if (pickTask != null) {
// // 更新当前的outsideVehicles状态为一个新状态，拉取任务时不拉取它
// List<OutsideVehicles> outsideVehiclesList = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()
// .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
// .eq(OutsideVehicles::getGoodsId, workFlow.getGoodsId()));
// for (OutsideVehicles outsideVehicles : outsideVehiclesList) {
// outsideVehicles.setOutStatus(2);
// }
// outsideVehiclesService.updateBatchById(outsideVehiclesList);
// }
// // 更新workFlow状态
// workFlow.setLightStatus(0);// 未亮灯
// workFlow.setWorkStatus(1);// 正在做
// } else {
// if (workFlow.getPickedNum().compareTo(workFlow.getNeedNum()) < 0) {
// // 缺料未完成
// workFlow.setLightStatus(0);// 未亮灯
// workFlow.setWorkStatus(1);// 正在做
// } else {
// workFlow.setLightStatus(2);// 已拍灯
// workFlow.setWorkStatus(2);// 已完成
// }
// }
if (workFlow.getPickedNum().compareTo(workFlow.getNeedNum()) < 0) { if (workFlow.getPickedNum().compareTo(workFlow.getNeedNum()) < 0) {
// 缺料未完成 // 缺料未完成
workFlow.setLightStatus(0);// 未亮灯 workFlow.setLightStatus(0);// 未亮灯
@ -1582,8 +1523,8 @@ public class TaskController {
.last("limit 1")); .last("limit 1"));
if (pickTask == null) { if (pickTask == null) {
// 没有拣货任务，直接放行 // 没有拣货任务，直接放行
// 调用Wcs的放行接口 TODO 测试时注释 // 调用Wcs的放行接口
// wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, null)); wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, null));
// 更新站台信息 // 更新站台信息
standService.update(new LambdaUpdateWrapper<Stand>() standService.update(new LambdaUpdateWrapper<Stand>()
.set(Stand::getLastUseTime, LocalDateTime.now()) .set(Stand::getLastUseTime, LocalDateTime.now())
@ -1609,25 +1550,6 @@ public class TaskController {
stockService.updateById(existStock); stockService.updateById(existStock);
stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore); stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore);
} }
// todo---此表废弃使用
// OutsideVehicles currentGoodsVehicle = outsideVehiclesService.getOne(new LambdaQueryWrapper<OutsideVehicles>()
// .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
// .eq(OutsideVehicles::getGoodsId, workConfirmRequest.getGoodsId())
// .last("limit 1"));
// if (workConfirmRequest.getRemainNumReal().compareTo(BigDecimal.ZERO) == 0) {// 实际剩余数量为0
// // 更新流转载具表剩余数量
// if (currentGoodsVehicle != null) {
// currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
// currentGoodsVehicle.setOutStatus(2);
// outsideVehiclesService.updateById(currentGoodsVehicle);
// }
// } else {
// // 更新流转载具表剩余数量 todo
// if (currentGoodsVehicle != null) {
// currentGoodsVehicle.setRemainNum(currentGoodsVehicle.getRemainNum().add(workConfirmRequest.getRemainNumReal().subtract(workConfirmRequest.getRemainNumOrigin())));
// outsideVehiclesService.updateById(currentGoodsVehicle);
// }
// }
} else { } else {
if (existStock != null && existStock.getGoodsRelated() != null) { if (existStock != null && existStock.getGoodsRelated() != null) {
if (workConfirmRequest.getRemainNumOrigin().compareTo(BigDecimal.ZERO) == 0) { if (workConfirmRequest.getRemainNumOrigin().compareTo(BigDecimal.ZERO) == 0) {
@ -1638,14 +1560,6 @@ public class TaskController {
existStock.setGoodsRelated(goodsDetail); existStock.setGoodsRelated(goodsDetail);
stockService.updateById(existStock); stockService.updateById(existStock);
stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore); stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore);
// todo---此表废弃使用
// OutsideVehicles currentGoodsVehicle = outsideVehiclesService.getOne(new LambdaQueryWrapper<OutsideVehicles>()
// .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
// .eq(OutsideVehicles::getGoodsId, workConfirmRequest.getGoodsId())
// .last("limit 1"));
// currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
// currentGoodsVehicle.setOutStatus(2);
// outsideVehiclesService.updateById(currentGoodsVehicle);
} }
} }
} }
@ -1689,8 +1603,8 @@ public class TaskController {
pickTaskRecordService.save(pickTaskRecord); pickTaskRecordService.save(pickTaskRecord);
// 删除当前拣选任务 // 删除当前拣选任务
pickTaskService.removeById(pickTask); pickTaskService.removeById(pickTask);
// 不需要，放行 TODO 测试时注释 // 不需要，放行
// wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, pickTask.getVehicleId())); wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, pickTask.getVehicleId()));
// 判断是不是已经完成工作 // 判断是不是已经完成工作
if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>() if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, standId) .eq(WorkFlow::getWorkStation, standId)
@ -1728,8 +1642,8 @@ public class TaskController {
pickTaskRecordService.save(pickTaskRecord); pickTaskRecordService.save(pickTaskRecord);
// 删除当前拣选任务 // 删除当前拣选任务
pickTaskService.removeById(pickTask); pickTaskService.removeById(pickTask);
// 放行 TODO 测试时注释 // 放行
// wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, pickTask.getVehicleId())); wcsService.sendWcsDisposeVehicle(new WcsDisposeVehicleRequest(standId, pickTask.getVehicleId()));
// 判断是不是已经完成工作 // 判断是不是已经完成工作
if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>() if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, standId) .eq(WorkFlow::getWorkStation, standId)
@ -2855,7 +2769,7 @@ public class TaskController {
return convertJsonString(response); return convertJsonString(response);
} }
// TODO 以下是非计划领料变动 // 以下是非计划领料变动
// 1. 判断当前站台是否允许非计划 // 1. 判断当前站台是否允许非计划
if (targetStand.getAllowNoPlan() != 1) { if (targetStand.getAllowNoPlan() != 1) {
logger.error("当前站台不允许非计划领料：{}。", targetStand.getStandId()); logger.error("当前站台不允许非计划领料：{}。", targetStand.getStandId());
@ -2889,11 +2803,10 @@ public class TaskController {
// 出库任务列表 // 出库任务列表
List<Task> outTasks = new ArrayList<>(); List<Task> outTasks = new ArrayList<>();
// TODO 非计划变动 // 非计划变动
// 拣选任务列表 // 拣选任务列表
List<PickTask> pickTasks = new ArrayList<>(); List<PickTask> pickTasks = new ArrayList<>();
// 尝试生成出库任务 // 尝试生成出库任务
List<String> pickStandIds = new ArrayList<>(); List<String> pickStandIds = new ArrayList<>();
for (Stock tempStock : stockList) { for (Stock tempStock : stockList) {
@ -2931,7 +2844,7 @@ public class TaskController {
tempOutTask.setIsPicking(1); tempOutTask.setIsPicking(1);
outTasks.add(tempOutTask); outTasks.add(tempOutTask);
// TODO 非计划变动 // 非计划变动
// 只有备料站台才下发拣选任务 // 只有备料站台才下发拣选任务
if (targetStand.getStandType() == 2) { if (targetStand.getStandType() == 2) {
// 创建拣选任务 // 创建拣选任务
@ -2973,7 +2886,7 @@ public class TaskController {
.eq(Task::getVehicleId, tempStock.getVehicleId()) .eq(Task::getVehicleId, tempStock.getVehicleId())
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())); .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// TODO 非计划变动 // 非计划变动
if (targetStand.getStandType() == 1) { if (targetStand.getStandType() == 1) {
// 入库站台 // 入库站台
thisVehiclePickTasks.forEach(pickTask -> { thisVehiclePickTasks.forEach(pickTask -> {
@ -3004,7 +2917,7 @@ public class TaskController {
// 保存出库任务 // 保存出库任务
taskService.saveBatch(outTasks); taskService.saveBatch(outTasks);
// TODO 非计划变动 // 非计划变动
// 保存拣选任务 // 保存拣选任务
if (!pickTasks.isEmpty()) { if (!pickTasks.isEmpty()) {
pickTaskService.saveBatch(pickTasks); pickTaskService.saveBatch(pickTasks);
@ -3284,9 +3197,6 @@ public class TaskController {
} }
} }
// TODO 以下是盘点待做
/** /**
* 盘点请求 * 盘点请求
* *

4
src/main/java/com/wms/quartz/job_executor/KateWorkExecutor.java
View File

@ -39,10 +39,10 @@ public class KateWorkExecutor implements Job {
public void execute(JobExecutionContext jobExecutionContext) { public void execute(JobExecutionContext jobExecutionContext) {
// 创建工作 // 创建工作
createWork(); createWork();
// 执行工作
doWork();
// 修复工作 // 修复工作
repairWork(); repairWork();
// 执行工作
doWork();
} }
/** /**

490
src/main/java/com/wms/service/business/serviceImplements/WmsJobServiceImplements.java
View File

@ -105,12 +105,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
continue; continue;
} }
} }
// if (task.getTaskPriority() == 1) {
// if (Objects.equals(task.getTaskType(), TaskType.OUT.getCode())
// && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())) {
// continue;
// }
// }
// 创建发送的任务 // 创建发送的任务
WcsTaskRequest tempTask = new WcsTaskRequest(); WcsTaskRequest tempTask = new WcsTaskRequest();
tempTask.setTaskId(task.getTaskGroup()); tempTask.setTaskId(task.getTaskGroup());
@ -134,45 +128,45 @@ public class WmsJobServiceImplements implements IWmsJobService {
return; return;
} }
// 下面这行代码模拟wcs下发成功 // 下面这行代码模拟wcs下发成功
simulateSendPickOutTasks(taskGroupIds, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()); // simulateSendPickOutTasks(taskGroupIds, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
// // 发送任务 // 发送任务
// String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey()); String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
// if (url != null) { if (url != null) {
// logger.info("向WCS发送任务，地址：{}，请求详情：{}", url, convertJsonString(request)); logger.info("向WCS发送任务，地址：{}，请求详情：{}", url, convertJsonString(request));
// ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class); ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
// try { try {
// logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS")); logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
// } catch (Exception e) { } catch (Exception e) {
// logger.error("保存发送任务的日志错误。"); logger.error("保存发送任务的日志错误。");
// } }
// if (result == null) { if (result == null) {
// logger.error("发送任务异常。"); logger.error("发送任务异常。");
// } else { } else {
// if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) { if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
// logger.info("发送WCS任务成功。"); logger.info("发送WCS任务成功。");
// taskService.update(new LambdaUpdateWrapper<Task>() taskService.update(new LambdaUpdateWrapper<Task>()
// .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode()) .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
// .in(Task::getTaskGroup, taskGroupIds) .in(Task::getTaskGroup, taskGroupIds)
// .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())); .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// } else { } else {
// // 判断returnData的数据 // 判断returnData的数据
// if (result.getReturnData() != null) { if (result.getReturnData() != null) {
// List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class); List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class);
// if (!errorTasks.isEmpty()) { if (!errorTasks.isEmpty()) {
// List<String> failedTaskIds = errorTasks.stream().map(WcsTaskRequest::getTaskId).distinct().toList(); List<String> failedTaskIds = errorTasks.stream().map(WcsTaskRequest::getTaskId).distinct().toList();
// // 更新任务状态为异常 // 更新任务状态为异常
// taskService.update(new LambdaUpdateWrapper<Task>() taskService.update(new LambdaUpdateWrapper<Task>()
// .set(Task::getTaskStatus, WmsTaskStatus.EXCEPTION.getCode()) .set(Task::getTaskStatus, WmsTaskStatus.EXCEPTION.getCode())
// .in(Task::getTaskGroup, failedTaskIds) .in(Task::getTaskGroup, failedTaskIds)
// .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())); .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// } }
// } }
// logger.error("发送任务错误：{}", convertJsonString(result)); logger.error("发送任务错误：{}", convertJsonString(result));
// } }
// } }
// } else { } else {
// logger.error("WCS发送任务地址为空。"); logger.error("WCS发送任务地址为空。");
// } }
} }
} catch (Exception exception) { } catch (Exception exception) {
logger.error("向WCS发送任务时发生异常：{}", convertJsonString(exception)); logger.error("向WCS发送任务时发生异常：{}", convertJsonString(exception));
@ -180,362 +174,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
} }
} }
/**
* 发送PickOut任务
* @throws Exception 异常
*/
// @Override
// public void sendPickOutTasks() throws Exception {
// try {
// // 检索任务表---新建未下发的任务
// LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
// .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())
// .eq(Task::getTaskType, TaskType.OUT.getCode())
// .eq(Task::getTaskPriority, 1);
// List<Task> allTasks = taskService.list(waitForDistributeTaskQuery);
// if (!allTasks.isEmpty()) {
// String max_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_NUMS.getConfigKey());
// String max_wcs_accept_nums = configMap.get(ConfigMapKeyEnum.MAX_WCS_ACCEPT_NUMS.getConfigKey());
// String max_stand_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_STAND_VEHICLE_NUMS.getConfigKey());
// if (StringUtils.isEmpty(max_vehicle_nums) || StringUtils.isEmpty(max_wcs_accept_nums) || StringUtils.isEmpty(max_stand_vehicle_nums)) {
// logger.error("配置未生成");
// return;
// }
// int maxVehicleNums = Integer.parseInt(max_vehicle_nums);// 线体最大箱子数量
// int maxWcsAcceptNums = Integer.parseInt(max_wcs_accept_nums);// wcs最大一次性可接受任务数量
// int maxStandVehicleNums = Integer.parseInt(max_stand_vehicle_nums);// 每个站台最大箱子数量
// List<String> outsideVehicles = outsideVehiclesService.selectDistinctVehicles();
// if (outsideVehicles == null || outsideVehicles.isEmpty()) {
// outsideVehicles = Collections.emptyList();
// }
// int remainVehicleNums = maxVehicleNums - outsideVehicles.size();// 线体剩余箱子数量
// if (remainVehicleNums <= 0) {
// return;
// }
//
// // 需要发送给wcs的任务列表
// List<WcsTaskRequest> request = new ArrayList<>();
// // 已经下发的任务组列表
// List<String> taskGroupIds = new ArrayList<>();
// // 本次生成的箱子
// List<String> pickVehicleIds = new ArrayList<>();
// // 本次跳过的箱子
// List<String> skipVehicleIds = new ArrayList<>();
// // 查找所有站台拣选任务
// List<PickTask> standPickTasks = pickTaskService.list();
// // 生成一个Map，计算每个站台已经出库的拣选任务
// Map<String, Integer> outPickTaskMap = new HashMap<>();
// Map<String, Integer> updatedOutPickTaskMap = new HashMap<>();
// // 轮询工作站台，判断是否需要下发任务
// List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
// .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
// .eq(Stand::getStandType, 2));
// for (Stand workStation : stands) {
// outPickTaskMap.put(workStation.getStandId(), workStation.getPickVehicleCount());
// updatedOutPickTaskMap.put(workStation.getStandId(), workStation.getPickVehicleCount());
// }
// // 轮询堆垛机状态
// List<Stand> stackerList = standService.list(new LambdaQueryWrapper<Stand>()
// .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
// .eq(Stand::getStandType, 3));
// List<Task> stackRunningTasks = taskService.list(new LambdaQueryWrapper<Task>()
// .eq(Task::getTaskType, TaskType.OUT.getCode())
// .and(wrapper -> wrapper.eq(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
// .or().eq(Task::getTaskStatus, WmsTaskStatus.RUN.getCode())));
// Map<Integer, Integer> runningTaskNumToEquipmentMap = new HashMap<>();
// for (Stand stacker : stackerList) {
// // 找这台堆垛机正在执行的拣选出库任务数量
// runningTaskNumToEquipmentMap.put(stacker.getEquipmentId(), 0);
// }
// // 生成堆垛机可用列表
// for (Task tempStackRunningTask : stackRunningTasks) {
// if (instantLocationMap.containsKey(tempStackRunningTask.getOrigin())) {
// int key = instantLocationMap.get(tempStackRunningTask.getOrigin()).getEquipmentId();
// if (runningTaskNumToEquipmentMap.isEmpty()) {
// // 没有可用堆垛机
// break;
// }
// if (runningTaskNumToEquipmentMap.containsKey(key)) {
// if (runningTaskNumToEquipmentMap.get(key) >= 3) {
// runningTaskNumToEquipmentMap.remove(key);
// } else {
// runningTaskNumToEquipmentMap.replace(key, runningTaskNumToEquipmentMap.get(key) + 1);
// }
// }
// }
// }
// if (runningTaskNumToEquipmentMap.isEmpty()) {
// // 没有可用堆垛机
// return;
// }
// // 还有可用堆垛机
// while(!runningTaskNumToEquipmentMap.isEmpty()) {
// if (request.size() >= maxWcsAcceptNums || remainVehicleNums <= 0) {
// // 超过wcs一次可接受数量
// break;
// }
// if (outPickTaskMap.isEmpty()) {
// // 没有站台可以使用
// break;
// }
// // 先找出目前数量最少的站台
// String standId = outPickTaskMap.entrySet().stream()
// .min(Comparator.comparingInt(Map.Entry::getValue))
// .map(Map.Entry::getKey)
// .orElse("");
// List<String> vehicleIds;
// if (StringUtils.isNotEmpty(standId)) {
// // 如果这个站台箱子数量超过最大每个站台的箱子数量，则跳过
// if (outPickTaskMap.get(standId) >= maxStandVehicleNums) {
// outPickTaskMap.remove(standId);
// continue;
// }
// // 查找这个站台未下发的料箱
// vehicleIds = standPickTasks.stream()
// .filter(pickTask -> pickTask.getStandId().equals(standId) && pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
// && !pickVehicleIds.contains(pickTask.getVehicleId())
// && !skipVehicleIds.contains(pickTask.getVehicleId()))
// .map(PickTask::getVehicleId)
// .distinct()
// .toList();
// if (vehicleIds.isEmpty()) {
// outPickTaskMap.remove(standId);
// continue;
// }
// } else {
// vehicleIds = standPickTasks.stream()
// .filter(pickTask -> pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
// && !pickVehicleIds.contains(pickTask.getVehicleId())
// && !skipVehicleIds.contains(pickTask.getVehicleId()))
// .map(PickTask::getVehicleId)
// .distinct()
// .toList();
// if (vehicleIds.isEmpty()) {
// break;
// }
// }
// // 生成箱子-站台数量的Map
// Map<String, Integer> vehicleStandsMap = new HashMap<>();
// standPickTasks.forEach(pickTask -> {
// if (vehicleIds.contains(pickTask.getVehicleId())) {
// vehicleStandsMap.put(pickTask.getVehicleId(),
// vehicleStandsMap.getOrDefault(pickTask.getVehicleId(), 0) + 1);
// }
// });
// // 最多使用的箱子
// String maxVehicleId = vehicleStandsMap.entrySet().stream()
// .max(Comparator.comparingInt(Map.Entry::getValue))
// .map(Map.Entry::getKey)
// .orElse("");
// if (!StringUtils.isEmpty(maxVehicleId)) {
// // 找到这个箱子的任务
// List<Task> outPickTasks = allTasks.stream().filter(task -> task.getVehicleId().equals(maxVehicleId) && !pickVehicleIds.contains(task.getVehicleId())
// && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
// if (!outPickTasks.isEmpty()) {
// // 更新每个站台的拣选箱数量
// List<String> maxStandIds = standPickTasks.stream()
// .filter(pickTask -> pickTask.getVehicleId().equals(maxVehicleId))
// .map(PickTask::getStandId)
// .distinct()
// .toList();
// // 给当前设备号+1
// int equipmentId = instantLocationMap.get(outPickTasks.get(0).getOrigin()).getEquipmentId();
// if (runningTaskNumToEquipmentMap.containsKey(equipmentId)) {
// boolean flag = false;
// for (Task task : outPickTasks) {
// if (taskGroupIds.contains(task.getTaskGroup())) {
// // 该任务组已经下发
// continue;
// }
// if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
// // 查询一下前置的任务有没有存在，存在则不下发
// if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
// continue;
// }
// }
// // 创建发送的任务
// WcsTaskRequest tempTask = new WcsTaskRequest();
// tempTask.setTaskId(task.getTaskGroup());
// tempTask.setTaskType(task.getTaskType());
// tempTask.setOrigin(task.getOrigin());
// tempTask.setDestination(task.getDestination());
// tempTask.setVehicleNo(task.getVehicleId());
// tempTask.setVehicleSize(task.getVehicleSize());
// tempTask.setWeight(task.getWeight());
// tempTask.setPriority(task.getTaskPriority());
// request.add(tempTask);
// // 已经发送过的任务组
// taskGroupIds.add(task.getTaskGroup());
// flag = true;
// }
// if (flag) {
// if (!maxStandIds.isEmpty()) {
// maxStandIds.forEach(tempStandId -> {
// outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1);
// updatedOutPickTaskMap.put(tempStandId, updatedOutPickTaskMap.getOrDefault(tempStandId, 0) + 1);
// });
// }
// runningTaskNumToEquipmentMap.replace(equipmentId, runningTaskNumToEquipmentMap.get(equipmentId) + 1);
// // 已经发送过的vehicleId
// pickVehicleIds.add(maxVehicleId);
// vehicleStandsMap.remove(maxVehicleId);
// // 剩余线体可继续出库料箱数量
// remainVehicleNums--;
// }
// } else {
// if (!skipVehicleIds.contains(maxVehicleId)) {
// skipVehicleIds.add(maxVehicleId);
// }
// }
// } else {
// if (!skipVehicleIds.contains(maxVehicleId)) {
// skipVehicleIds.add(maxVehicleId);
// }
// }
// }
// // 最少使用的箱子
// String minVehicleId = vehicleStandsMap.entrySet().stream()
// .min(Comparator.comparingInt(Map.Entry::getValue))
// .map(Map.Entry::getKey)
// .orElse("");
// if (!StringUtils.isEmpty(minVehicleId)) {
// // 找到这个箱子的任务
// List<Task> outPickTasks = allTasks.stream().filter(task -> task.getVehicleId().equals(minVehicleId) && !pickVehicleIds.contains(task.getVehicleId())
// && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
// if (!outPickTasks.isEmpty()) {
// // 更新每个站台的拣选箱数量
// List<String> minStandIds = standPickTasks.stream()
// .filter(pickTask -> pickTask.getVehicleId().equals(minVehicleId))
// .map(PickTask::getStandId)
// .distinct()
// .toList();
// // 给当前设备号+1
// int equipmentId = instantLocationMap.get(outPickTasks.get(0).getOrigin()).getEquipmentId();
// if (runningTaskNumToEquipmentMap.containsKey(equipmentId)) {
// boolean flag = false;
// for (Task task : outPickTasks) {
// if (taskGroupIds.contains(task.getTaskGroup())) {
// // 该任务组已经下发
// continue;
// }
// if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
// // 查询一下前置的任务有没有存在，存在则不下发
// if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
// continue;
// }
// }
// // 创建发送的任务
// WcsTaskRequest tempTask = new WcsTaskRequest();
// tempTask.setTaskId(task.getTaskGroup());
// tempTask.setTaskType(task.getTaskType());
// tempTask.setOrigin(task.getOrigin());
// tempTask.setDestination(task.getDestination());
// tempTask.setVehicleNo(task.getVehicleId());
// tempTask.setVehicleSize(task.getVehicleSize());
// tempTask.setWeight(task.getWeight());
// tempTask.setPriority(task.getTaskPriority());
// request.add(tempTask);
// // 已经发送过的任务组
// taskGroupIds.add(task.getTaskGroup());
// flag = true;
// }
// if (flag) {
// if (!minStandIds.isEmpty()) {
// minStandIds.forEach(tempStandId -> {
// outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1);
// updatedOutPickTaskMap.put(tempStandId, updatedOutPickTaskMap.getOrDefault(tempStandId, 0) + 1);
// });
// }
// runningTaskNumToEquipmentMap.replace(equipmentId, runningTaskNumToEquipmentMap.get(equipmentId) + 1);
// // 已经发送过的vehicleId
// pickVehicleIds.add(minVehicleId);
// vehicleStandsMap.remove(minVehicleId);
// // 剩余线体可继续出库料箱数量
// remainVehicleNums--;
// }
// } else {
// if (!skipVehicleIds.contains(minVehicleId)) {
// skipVehicleIds.add(minVehicleId);
// }
// }
// } else {
// if (!skipVehicleIds.contains(minVehicleId)) {
// skipVehicleIds.add(minVehicleId);
// }
// }
// }
// List<Integer> removeKeys = new ArrayList<>(runningTaskNumToEquipmentMap.keySet().stream().toList());
// for (int equipmentId : removeKeys) {
// // 剩余任务有没有这台堆垛机的
// List<Task> remainTasks = allTasks.stream().filter(task -> !skipVehicleIds.contains(task.getVehicleId()) && !pickVehicleIds.contains(task.getVehicleId())
// && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
// if (remainTasks.isEmpty() || runningTaskNumToEquipmentMap.get(equipmentId) >= 3) {
// runningTaskNumToEquipmentMap.remove(equipmentId);
// }
// }
// }
//
// if (request.size() == 0) {
// // 没有新任务发送
// return;
// }
// // 发送任务
// String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
// if (url != null) {
// logger.info("向WCS发送拣选出库任务，地址：{}，请求详情：{}", url, convertJsonString(request));
// ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
// try {
// logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
// } catch (Exception e) {
// logger.error("插入日志错误。");
// }
// if (result == null) {
// logger.error("发送拣选出库任务异常。");
// } else {
// if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
// logger.info("发送WCS拣选出库任务成功。");
// taskService.update(new LambdaUpdateWrapper<Task>()
// .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
// .in(Task::getTaskGroup, taskGroupIds)
// .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// // 流转载具状态变更
// if (!pickVehicleIds.isEmpty()) {
// outsideVehiclesService.update(new LambdaUpdateWrapper<OutsideVehicles>()
// .set(OutsideVehicles::getOutStatus, 1)
// .in(OutsideVehicles::getVehicleId, pickVehicleIds));
// // 更新站台拣选箱数
// for (String tempStandId : updatedOutPickTaskMap.keySet()) {
// standService.update(new LambdaUpdateWrapper<Stand>()
// .set(Stand::getPickVehicleCount, updatedOutPickTaskMap.get(tempStandId))
// .eq(Stand::getStandId, tempStandId));
// }
// }
// } else {
// // 判断returnData的数据
// if (result.getReturnData() != null) {
// List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class);
// if (!errorTasks.isEmpty()) {
// List<String> failedTaskIds = errorTasks.stream().map(WcsTaskRequest::getTaskId).distinct().toList();
// // 更新任务状态为异常
// taskService.update(new LambdaUpdateWrapper<Task>()
// .set(Task::getTaskStatus, WmsTaskStatus.EXCEPTION.getCode())
// .in(Task::getTaskGroup, failedTaskIds)
// .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// }
// }
// logger.error("发送拣选出库任务错误：{}", convertJsonString(result));
// }
// }
// } else {
// logger.error("WCS发送任务地址为空。");
// }
// }
// } catch (Exception exception) {
// logger.error("向WCS发送拣选出库任务时发生异常：{}", convertJsonString(exception));
// throw new Exception("向WCS发送拣选出库任务时发生异常。");
// }
// }
/** /**
* 发送拣选任务 * 发送拣选任务
*/ */
@ -577,31 +215,31 @@ public class WmsJobServiceImplements implements IWmsJobService {
request.add(requestSingle); request.add(requestSingle);
} }
// 下面是模拟发送wcs拣选任务 // 下面是模拟发送wcs拣选任务
simulateSendPickTasks(vehicleAndStansMap.keySet().stream().toList()); // simulateSendPickTasks(vehicleAndStansMap.keySet().stream().toList());
// if (!request.isEmpty()) { if (!request.isEmpty()) {
// // 发送任务 // 发送任务
// String url = configMap.get(ConfigMapKeyEnum.URL_WCS_PICK_TASK.getConfigKey()); String url = configMap.get(ConfigMapKeyEnum.URL_WCS_PICK_TASK.getConfigKey());
// if (url != null) { if (url != null) {
// logger.info("向WCS发送拣选任务，地址：{}，请求详情：{}", url, convertJsonString(request)); logger.info("向WCS发送拣选任务，地址：{}，请求详情：{}", url, convertJsonString(request));
// ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class); ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
// try { try {
// logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送拣选任务", "setConveyTask", convertJsonString(request), convertJsonString(result), url, LocalDateTime.now(), "WMS")); logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送拣选任务", "setConveyTask", convertJsonString(request), convertJsonString(result), url, LocalDateTime.now(), "WMS"));
// } catch (Exception e) { } catch (Exception e) {
// logger.error("插入日志错误。"); logger.error("插入日志错误。");
// } }
// if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) { if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
// logger.info("发送拣选任务成功。"); logger.info("发送拣选任务成功。");
// pickTaskService.update(new LambdaUpdateWrapper<PickTask>() pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
// .set(PickTask::getPickStatus, PickTaskStatusEnum.SEND.getCode()) .set(PickTask::getPickStatus, PickTaskStatusEnum.SEND.getCode())
// .in(PickTask::getVehicleId, vehicleAndStansMap.keySet()) .in(PickTask::getVehicleId, vehicleAndStansMap.keySet())
// .eq(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())); .eq(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode()));
// } else { } else {
// logger.error("发送拣选任务错误：{}", convertJsonString(result)); logger.error("发送拣选任务错误：{}", convertJsonString(result));
// } }
// } else { } else {
// logger.error("WCS发送拣选任务地址为空。"); logger.error("WCS发送拣选任务地址为空。");
// } }
// } }
} catch (Exception exception) { } catch (Exception exception) {
logger.error("向WCS发送拣选任务时发生异常：{}", convertJsonString(exception)); logger.error("向WCS发送拣选任务时发生异常：{}", convertJsonString(exception));
throw new Exception("向WCS发送拣选任务时发生异常。"); throw new Exception("向WCS发送拣选任务时发生异常。");

13
src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java
View File

@ -393,7 +393,7 @@ public class WorkServiceImplements implements IWorkService {
// 分出在库的物料 // 分出在库的物料
List<Stock> onStockStockList = allStockList.stream().filter(stock -> Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())).sorted(Comparator.comparing(Stock::getCreateTime)).toList(); List<Stock> onStockStockList = allStockList.stream().filter(stock -> Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())).sorted(Comparator.comparing(Stock::getCreateTime)).toList();
for (String standId : canUseStandIdList) { for (String standId : canUseStandIdList) {
Map<Integer, String> equipVehicleOfThisStandMap = new HashMap<>(); Map<Integer, Integer> equipTaskOfThisStandMap = new HashMap<>();
// 生成这个站台在这个设备出库的箱子 // 生成这个站台在这个设备出库的箱子
for (Task task : outTaskList) { for (Task task : outTaskList) {
if (StringUtils.isEmpty(task.getPickStand())) { if (StringUtils.isEmpty(task.getPickStand())) {
@ -401,9 +401,9 @@ public class WorkServiceImplements implements IWorkService {
continue; continue;
} }
int equipmentId = getStackerIdByLocationId(task.getOrigin()); int equipmentId = getStackerIdByLocationId(task.getOrigin());
if (equipmentId != 0 && !equipVehicleOfThisStandMap.containsKey(equipmentId) && Objects.equals(task.getPickStand(), standId)) { if (equipmentId != 0 && Objects.equals(task.getPickStand(), standId)) {
// 当前设备当前站台的任务 // 当前设备当前站台的任务
equipVehicleOfThisStandMap.put(equipmentId, task.getVehicleId()); equipTaskOfThisStandMap.put(equipmentId, equipTaskOfThisStandMap.getOrDefault(equipmentId, 0) + 1);
} }
} }
Map<String, String> thisStandOutVehicleMap = new HashMap<>();// 键为载具号，值为库存id Map<String, String> thisStandOutVehicleMap = new HashMap<>();// 键为载具号，值为库存id
@ -433,8 +433,8 @@ public class WorkServiceImplements implements IWorkService {
continue; continue;
} }
// 判断这个设备能否出库 // 判断这个设备能否出库
if (equipVehicleOfThisStandMap.containsKey(equipmentId)) { if (equipTaskOfThisStandMap.containsKey(equipmentId) && equipTaskOfThisStandMap.get(equipmentId) >= 2) {
// 这个站台在这台设备已经生成过任务，不再重复生成 // 这个站台在这台设备已经生成过两条任务，不再生成
continue; continue;
} }
// 判断这个库存是否被当前站台需要 // 判断这个库存是否被当前站台需要
@ -505,7 +505,7 @@ public class WorkServiceImplements implements IWorkService {
// 添加本次出库载具 // 添加本次出库载具
thisTimeOutVehicleIds.add(stock.getVehicleId()); thisTimeOutVehicleIds.add(stock.getVehicleId());
// 添加设备 // 添加设备
equipVehicleOfThisStandMap.put(equipmentId, stock.getVehicleId()); equipTaskOfThisStandMap.put(equipmentId, equipTaskOfThisStandMap.getOrDefault(equipmentId, 0) + 1);
// 此处是为了将同一个载具尽量在同一个站台捡完 // 此处是为了将同一个载具尽量在同一个站台捡完
thisStandOutVehicleMap.put(stock.getVehicleId(), stock.getStockId()); thisStandOutVehicleMap.put(stock.getVehicleId(), stock.getStockId());
} }
@ -1076,6 +1076,7 @@ public class WorkServiceImplements implements IWorkService {
continue; continue;
} }
workFlow.setWorkStatus(-1);// 设置暂存状态 workFlow.setWorkStatus(-1);// 设置暂存状态
workFlow.setDistributedNum(BigDecimal.ZERO);
finalWorkFlows.add(workFlow); finalWorkFlows.add(workFlow);
} }
if (!finalWorkFlows.isEmpty()) { if (!finalWorkFlows.isEmpty()) {