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

代码更新：

Browse Source 
1. 增加盘点功能
2. 修改呼叫料箱逻辑：少少多
3. 间接物料
This commit is contained in:
梁州 2025-01-05 16:51:47 +08:00
parent 7d681334d4
commit b7e40c73ef
7 changed files with 452 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -165,6 +165,9 @@ public class TaskController {
private final IWorkService workService;
private final WorkFlowLastService workFlowLastService;// 服务
private final StandStackerTaskService standStackerTaskService;// 特殊服务
private final InventoryListService inventoryService;
private final WorkSummaryService workSummaryService;
private final InventoryHistoryService inventoryHistoryService;
/**
* 接收入库任务请求
@ -485,6 +488,8 @@ public class TaskController {
pickTaskService.remove(new LambdaQueryWrapper<PickTask>().eq(PickTask::getVehicleId, inTask.getVehicleId()));
// 移除当前料箱所有的outsideVehicles
outsideVehiclesService.remove(new LambdaQueryWrapper<OutsideVehicles>().eq(OutsideVehicles::getVehicleId, inTask.getVehicleId()));
// 清除当前料箱的所有盘点任务
inventoryService.remove(new LambdaQueryWrapper<InventoryList>().eq(InventoryList::getVehicleId, inTask.getVehicleId()));
}
}
// 出库任务
@ -2079,36 +2084,41 @@ public class TaskController {
return convertJsonString(response);
}
// 验证请求信息
if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
// TODO 间接物料需要确认
if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
logger.error("间接物料必须输入物料号");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("间接物料必须输入物料号");
return convertJsonString(response);
}
// 查询物料是否是间接物料
Goods goods = goodsService.getOne(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, callEmptyVehicleRequest.getGoodsId()).eq(Goods::getGoodsInVehicleType, "间接物料").last("limit 1"));
if (goods == null) {
logger.error("当前物料不是间接物料");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前物料不是间接物料");
return convertJsonString(response);
}
callEmptyVehicleRequest.setVehicleType1(goods.getVehicleType());
}
// if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
// // TODO 间接物料需要确认
// if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
// logger.error("间接物料必须输入物料号");
// response.setCode(ResponseCode.ERROR.getCode());
// response.setMessage("间接物料必须输入物料号");
// return convertJsonString(response);
// }
// // 查询物料是否是间接物料
// Goods goods = goodsService.getOne(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, callEmptyVehicleRequest.getGoodsId()).eq(Goods::getGoodsInVehicleType, "间接物料").last("limit 1"));
// if (goods == null) {
// logger.error("当前物料不是间接物料");
// response.setCode(ResponseCode.ERROR.getCode());
// response.setMessage("当前物料不是间接物料");
// return convertJsonString(response);
// }
// callEmptyVehicleRequest.setVehicleType1(goods.getVehicleType());
// }
// 生成料箱出库任务
int needNum = callEmptyVehicleRequest.getNeedNum();
List<Task> vehicleOutTasks = new ArrayList<>();// 任务列表
List<String> outVehicleIds = new ArrayList<>();// 料箱列表
// 查询出需求数量的空箱
List<Vehicle> emptyVehicles = vehicleService.list(new LambdaQueryWrapper<Vehicle>()
.eq(StringUtils.isNotEmpty(callEmptyVehicleRequest.getVehicleType1()), Vehicle::getVehicleType, callEmptyVehicleRequest.getVehicleType1())
LambdaQueryWrapper<Vehicle> emptyVehicleQueryWrapper = new LambdaQueryWrapper<Vehicle>()
.eq(Vehicle::getIsEmpty, 1)
.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
.orderByAsc(Vehicle::getLastInTime)
.last("limit " + needNum));
.last("limit " + needNum);
if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
emptyVehicleQueryWrapper.eq(Vehicle::getVehicleType, "间接物料");
} else {
emptyVehicleQueryWrapper.ne(Vehicle::getVehicleType, "间接物料");
}
List<Vehicle> emptyVehicles = vehicleService.list(emptyVehicleQueryWrapper);
for (Vehicle emptyVehicle : emptyVehicles) {
if (needNum <= 0) {
break;
@ -3128,6 +3138,14 @@ public class TaskController {
response.setMessage("请求缺少必须参数，箱号、料号、数量不可缺少。");
return convertJsonString(response);
}
List<InventoryList> inventoryListList = inventoryService.list(new LambdaQueryWrapper<InventoryList>()
.eq(InventoryList::getVehicleId, pickNumQuery.getVehicleId()));
if (!inventoryListList.isEmpty()) {
logger.error("这个箱子还有盘点任务，请先执行盘点。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("这个箱子还有盘点任务，请先执行盘点。");
return convertJsonString(response);
}
// 验证载具号是否重复入库
if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, pickNumQuery.getVehicleId())
.and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
@ -3263,4 +3281,299 @@ public class TaskController {
return convertJsonString(response);
}
}
// TODO 以下是盘点待做
/**
* 盘点请求
*
* @param inventoryRequest 请求信息
* @return 结果
*/
@PostMapping("/inventoryOut")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "盘点请求", logMethod = "inventoryOut")
public String inventoryOut(@RequestBody InventoryRequest inventoryRequest) {
logger.info("盘点请求：{}，ip地址：{}", convertJsonString(inventoryRequest), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
if (StringUtils.isEmpty(inventoryRequest.getGoodsId())) {
logger.error("盘点，请输入料号。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("盘点，请输入料号。");
return convertJsonString(response);
}
// 查询库存
List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
.apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, inventoryRequest.getGoodsId())
.eq(StringUtils.isNotEmpty(inventoryRequest.getVehicleId()), Stock::getVehicleId, inventoryRequest.getVehicleId()));
List<Stock> outedStockList = stockList.stream().filter(stock -> !stock.getStockStatus().equals(StockStatus.OK.getCode())).toList();
if (!outedStockList.isEmpty()) {
logger.error("当前想要盘点的物料未全部在库中，请稍后再试。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前想要盘点的物料未全部在库中，请稍后再试。");
return convertJsonString(response);
}
// 生成出库任务
List<Task> outTasks = new ArrayList<>();
List<InventoryList> inventoryList = new ArrayList<>();
for (Stock stock : stockList) {
// 创建出库任务
Task tempOutTask = new Task();
tempOutTask.setTaskId(generateId("INV_"));
tempOutTask.setTaskType(TaskType.OUT.getCode());
tempOutTask.setTaskGroup(generateId(""));
tempOutTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
tempOutTask.setTaskPriority(2);
tempOutTask.setVehicleId(stock.getVehicleId());
tempOutTask.setUserName(inventoryRequest.getUserName());
tempOutTask.setOrigin(stock.getLocationId());
tempOutTask.setDestination("");
tempOutTask.setCreateTime(LocalDateTime.now());
tempOutTask.setIsPicking(1);
outTasks.add(tempOutTask);
// 创建盘点
InventoryList tempInventoryList = new InventoryList();
tempInventoryList.setInventoryId(generateId("INV_"));
tempInventoryList.setGoodsId(stock.getGoodsRelated().getGoodsId());
tempInventoryList.setStockNum(stock.getGoodsRelated().getRemainNum());
tempInventoryList.setInventoryStatus(0);
tempInventoryList.setInventoryUser(inventoryRequest.getUserName());
tempInventoryList.setVehicleId(stock.getVehicleId());
tempInventoryList.setInventoryDate(LocalDateTime.now());
inventoryList.add(tempInventoryList);
}
// 添加出库任务
if (!outTasks.isEmpty()) {
// 保存出库任务
taskService.saveBatch(outTasks);
// 保存盘点
inventoryService.saveBatch(inventoryList);
List<String> vehicleIds = outTasks.stream().map(Task::getVehicleId).distinct().toList();
// 更新库存状态
stockService.update(new LambdaUpdateWrapper<Stock>()
.set(Stock::getStockStatus, StockStatus.OUT.getCode())
.in(Stock::getVehicleId, vehicleIds)
.eq(Stock::getStockStatus, StockStatus.OK.getCode()));
// 更新料箱状态
vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
.in(Vehicle::getVehicleId, vehicleIds)
.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()));
}
logger.info("下发盘点成功，请等待料箱到达。");
response.setCode(ResponseCode.OK.getCode());
response.setMessage("下发盘点成功，请等待料箱到达。");
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("处理盘点请求异常，{}", convertJsonString(e));
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("处理盘点请求异常。");
return convertJsonString(response);
}
}
/**
* 根据物料获取当前的盘点信息
*
* @param inventoryRequest 请求信息
* @return 结果
*/
@PostMapping("/getCurrentGoodsInventory")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "根据物料获取当前的盘点信息", logMethod = "getCurrentGoodsInventory")
public String getCurrentGoodsInventory(@RequestBody InventoryRequest inventoryRequest) {
logger.info("根据物料获取当前的盘点信息：{}，ip地址：{}", convertJsonString(inventoryRequest), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
if (StringUtils.isEmpty(inventoryRequest.getGoodsId())) {
logger.error("请输入物料信息。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("请输入物料信息。");
return convertJsonString(response);
}
List<InventoryVo> inventoryVos = new ArrayList<>();
// 查询这个料关于配料的信息
List<WorkSummary> workSummaryList = workSummaryService.list(new LambdaQueryWrapper<WorkSummary>()
.eq(WorkSummary::getGoodsId, inventoryRequest.getGoodsId())
.orderByDesc(WorkSummary::getFinishTime));
InventoryVo firstInventoryVo = new InventoryVo();
if (!workSummaryList.isEmpty()) {
// 查询station-config以获取工位信息
List<WorkStationConfig> workStationConfigList = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
.eq(WorkStationConfig::getSmallBox, workSummaryList.get(0).getWorkCenter()));
firstInventoryVo.setFeedingWS(workStationConfigList.isEmpty() ? "" : workStationConfigList.get(0).getWorkCenter());
// 查询DBS以获取机器序列号
List<KateDBS> kateDBSList = kateDBSService.list(new LambdaQueryWrapper<KateDBS>()
.eq(KateDBS::getWorkOrder, workSummaryList.get(0).getWorkOrder()));
firstInventoryVo.setLastFeedingMachineNo(kateDBSList.isEmpty() ? "" : kateDBSList.get(0).getMachineNo());
firstInventoryVo.setLastFeedingTime(workSummaryList.get(0).getFinishTime());
firstInventoryVo.setIsLack(workSummaryList.get(0).getLackStatus() == 1 ? "是" : "否");
}
// 查询库存信息
List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
.apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, inventoryRequest.getGoodsId()));
for (Stock stock : stockList) {
InventoryVo inventoryVo = new InventoryVo();
inventoryVo.setGoodsId(inventoryRequest.getGoodsId());
inventoryVo.setVehiclesQuantity(stockList.size());
inventoryVo.setVehicleIds(stock.getVehicleId());
String vehicleStatus = "";
if (Objects.equals(StockStatus.OK.getCode(), stock.getStockStatus())) {
vehicleStatus = "在库中";
} else if (Objects.equals(StockStatus.OUT.getCode(), stock.getStockStatus())) {
vehicleStatus = "等待出库中";
} else {
vehicleStatus = "在库外";
}
inventoryVo.setVehicleStatus(vehicleStatus);
inventoryVo.setFeedingWS(firstInventoryVo.getFeedingWS());
inventoryVo.setLastFeedingMachineNo(firstInventoryVo.getLastFeedingMachineNo());
inventoryVo.setLastFeedingTime(firstInventoryVo.getLastFeedingTime());
inventoryVo.setIsLack(firstInventoryVo.getIsLack());
inventoryVos.add(inventoryVo);
}
response.setCode(ResponseCode.OK.getCode());
response.setMessage("根据物料获取当前的盘点信息成功。");
response.setReturnData(inventoryVos);
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("根据物料获取当前的盘点信息异常，{}", convertJsonString(e));
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("根据物料获取当前的盘点信息异常。");
return convertJsonString(response);
}
}
/**
* 盘点确认
*
* @param confirmRequest 请求信息
* @return 结果
*/
@PostMapping("/inventoryConfirmBack")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "盘点确认", logMethod = "inventoryConfirmBack")
public String inventoryConfirmBack(@RequestBody InventoryRequest confirmRequest) {
logger.info("盘点确认：{}，ip地址：{}", convertJsonString(confirmRequest), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
// 判断信息是否完备
if (StringUtils.isEmpty(confirmRequest.getGoodsId())
|| StringUtils.isEmpty(confirmRequest.getVehicleId())
|| confirmRequest.getConfirmNum() == null) {
logger.error("缺少必须信息。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("缺少必须信息。");
return convertJsonString(response);
}
// 查询盘点列表
List<InventoryList> inventoryListList = inventoryService.list(new LambdaQueryWrapper<InventoryList>()
.eq(InventoryList::getVehicleId, confirmRequest.getVehicleId()));
List<InventoryList> currentGoodsInvList = inventoryListList.stream()
.filter(inventoryList -> inventoryList.getGoodsId().equals(confirmRequest.getGoodsId()))
.toList();
// 查询下当前库存
Stock existStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
.apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, confirmRequest.getGoodsId())
.eq(Stock::getVehicleId, confirmRequest.getVehicleId())
.last("limit 1"));
// 保存盘点记录
List<InventoryHistory> historyList = new ArrayList<>();
for (InventoryList inventoryList : currentGoodsInvList) {
InventoryHistory tempHistory = new InventoryHistory();
tempHistory.setInventoryId(inventoryList.getInventoryId());
tempHistory.setGoodsId(inventoryList.getGoodsId());
tempHistory.setVehicleId(inventoryList.getVehicleId());
tempHistory.setStockNum(existStock == null ? BigDecimal.ZERO : existStock.getGoodsRelated().getRemainNum());
tempHistory.setRealNum(confirmRequest.getConfirmNum());
tempHistory.setInventoryStatus(1);
tempHistory.setInventoryResult(tempHistory.getRealNum().compareTo(tempHistory.getStockNum()) == 0 ? 0 : 1);
tempHistory.setInventoryUser(confirmRequest.getUserName());
tempHistory.setInventoryDate(LocalDateTime.now());
historyList.add(tempHistory);
}
inventoryHistoryService.saveBatch(historyList);
inventoryService.removeBatchByIds(currentGoodsInvList);
// 判断当前料箱是否还需要盘点
List<InventoryList> notCurrentGoodsInvList = inventoryListList.stream()
.filter(inventoryList -> !inventoryList.getGoodsId().equals(confirmRequest.getGoodsId()))
.toList();
if (!notCurrentGoodsInvList.isEmpty()) {
logger.info("当前料箱其他料仍需要盘点，请继续。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前料箱其他料仍需要盘点，请继续。");
} else {
// 验证载具号是否重复入库
if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, confirmRequest.getVehicleId())
.and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
logger.error("盘点确认完，但当前箱子{}已在库中，无法回库。", confirmRequest.getVehicleId());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("盘点确认完，当前箱子" + confirmRequest.getVehicleId() + "已在库中，无法回库。");
return convertJsonString(response);
}
// 判断这个箱子是否还有拣选任务
boolean hasPickTasks = pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
.eq(PickTask::getVehicleId, confirmRequest.getVehicleId()));
if (!hasPickTasks) {
// 判断当前载具是否有回库任务
boolean hasBackTask = taskService.exists(new LambdaQueryWrapper<Task>()
.eq(Task::getVehicleId, confirmRequest.getVehicleId())
.eq(Task::getTaskType, TaskType.IN.getCode())
.likeRight(Task::getTaskId, "HK_"));
if (!hasBackTask) {
// 判断当前载具是否有入库任务
boolean hasInTask = taskService.exists(new LambdaQueryWrapper<Task>()
.eq(Task::getVehicleId, confirmRequest.getVehicleId())
.eq(Task::getTaskType, TaskType.IN.getCode())
.likeRight(Task::getTaskId, "RK_"));
if (!hasInTask) {
// 生成回库任务
Task backTask = new Task();
backTask.setTaskId(generateId("HK_PD_"));
backTask.setTaskGroup(generateId(""));
backTask.setTaskType(TaskType.IN.getCode());
backTask.setTaskStatus(WmsTaskStatus.TEMP.getCode());
backTask.setVehicleId(confirmRequest.getVehicleId());
backTask.setVehicleSize(1);
backTask.setWeight(BigDecimal.ZERO);
backTask.setTaskPriority(1);
backTask.setUserName(confirmRequest.getUserName());
backTask.setCreateTime(LocalDateTime.now());
taskService.save(backTask);
}
}
logger.info("盘点确认结束且确认回库成功。");
response.setCode(ResponseCode.OK.getCode());
response.setMessage("盘点确认结束且确认回库成功。");
} else {
logger.error("盘点已经确认完，当前箱子还有拣选任务，不能回库，请将箱子置入拣货环线。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("盘点已经确认完，当前箱子还有拣选任务，不能回库，请将箱子置入拣货环线。");
}
}
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("处理盘点确认请求异常，{}", convertJsonString(e));
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("处理盘点确认请求异常。");
return convertJsonString(response);
}
}
}

37
src/main/java/com/wms/entity/app/request/InventoryRequest.java Normal file
View File

@ -0,0 +1,37 @@
package com.wms.entity.app.request;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* 盘点请求
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class InventoryRequest {
/**
* 料号
*/
@JsonProperty("goodsId")
private String goodsId;
/**
* 箱号
*/
@JsonProperty("vehicleId")
private String vehicleId;
/**
* 确认数量
*/
@JsonProperty("confirmNum")
private BigDecimal confirmNum;
/**
* 操作人员
*/
@JsonProperty("userName")
private String userName;
}

61
src/main/java/com/wms/entity/app/vo/InventoryVo.java Normal file
View File

@ -0,0 +1,61 @@
package com.wms.entity.app.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
/**
* 盘点信息显示列表
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class InventoryVo {
/**
* 料号
*/
@JsonProperty("goodsId")
private String goodsId;
/**
* 料箱数量
*/
@JsonProperty("vehiclesQuantity")
private Integer vehiclesQuantity;
/**
* 料箱号
*/
@JsonProperty("vehicleIds")
private String vehicleIds;
/**
* 料箱状态
*/
@JsonProperty("vehicleStatus")
private String vehicleStatus;
/**
* 备料工位
*/
@JsonProperty("feedingWS")
private String feedingWS;
/**
* 最后一台备料机器序列号
*/
@JsonProperty("lastFeedingMachineNo")
private String lastFeedingMachineNo;
/**
* 备料最后一台车日期
*/
@JsonProperty("lastFeedingTime")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime lastFeedingTime;
/**
* 是否缺料
*/
@JsonProperty("isLack")
private String isLack;
}

5
src/main/java/com/wms/entity/table/InventoryHistory.java
View File

@ -54,4 +54,9 @@ public class InventoryHistory {
*/
@TableField("vehicle_id")
private String vehicleId;
/**
* 盘点结果
*/
@TableField("inventory_result")
private Integer inventoryResult;
}

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

@ -776,7 +776,9 @@ public class WmsJobServiceImplements implements IWmsJobService {
// 找到之前完成的
List<StandStackerTask> currentStandFinishedTasks = standStackerTasks.stream().filter(standStackerTask -> standStackerTask.getStandId().equals(pickStand.getStandId()) && standStackerTask.getTaskType() == 1 && standStackerTask.getTaskStatus() == 1).toList();
if (!currentStandFinishedTasks.isEmpty()) {
thisQtyType = currentStandFinishedTasks.get(0).getLastQtyType() == 1 ? 2 : 1;
if (currentStandFinishedTasks.get(0).getLastQtyType() <= 2) {
thisQtyType = currentStandFinishedTasks.get(0).getLastQtyType() + 1;
}
}
// 设置分配策略
StandStackerTask newStandStackerTask = new StandStackerTask();
@ -808,7 +810,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
}
});
String vehicleId;
if (thisQtyType == 1) {
if (thisQtyType == 1 || thisQtyType == 2) {
// 最少使用的箱子
vehicleId = vehicleStandsMap.entrySet().stream()
.min(Comparator.comparingInt(Map.Entry::getValue))
@ -881,7 +883,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
while (availNum > 0) {
// 设置分配策略
StandStackerTask newStandStackerTask = new StandStackerTask();
newStandStackerTask.setLastQtyType(1);// 超额固定为1
newStandStackerTask.setLastQtyType(2);// 超额固定为2
// 查询这个这台堆垛机的料箱号
List<String> thisStackerVehicleIds = new ArrayList<>();
for (Task task : allTasks) {
@ -928,7 +930,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
}
});
String vehicleId = vehicleStandsMap.entrySet().stream()
.min(Comparator.comparingInt(Map.Entry::getValue))
.max(Comparator.comparingInt(Map.Entry::getValue))
.map(Map.Entry::getKey)
.orElse("");
if (!StringUtils.isEmpty(vehicleId)) {

1
src/main/java/com/wms/service/serviceImplements/LocationServiceImplements.java
View File

@ -209,6 +209,7 @@ public class LocationServiceImplements extends ServiceImpl<LocationMapper, Locat
}
}
LambdaQueryWrapper<Location> locationQueryWrapper = new LambdaQueryWrapper<Location>()
.ne(Location::getGoodsType, "间接物料")
.eq(Location::getAreaId, 1)
.eq(Location::getLocationStatus, 0)
.eq(Location::getLocationType, 1)

16
src/main/resources/application.yml
View File

@ -8,20 +8,20 @@ spring:
# 主库
master:
# 卡特数据库服务器
url: jdbc:mysql://10.90.36.71:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
username: developer
password: developer
driver-class-name: com.mysql.cj.jdbc.Driver
# url: jdbc:mysql://10.90.36.71:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
# username: developer
# password: developer
# driver-class-name: com.mysql.cj.jdbc.Driver
# 宝开服务器--内网
# url: jdbc:mysql://192.168.3.254:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
# username: coder
# password: coder
# driver-class-name: com.mysql.cj.jdbc.Driver
# # 本地环境
# url: jdbc:mysql://localhost:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
# username: developer
# password: developer
# driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
username: developer
password: developer
driver-class-name: com.mysql.cj.jdbc.Driver
# 从库
# slave_1:
# url: jdbc:mysql://localhost:3306/wms_aaa?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true