luyifan/wms-serve-mule
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
3d1f0ec758
wms-serve-mule/src/main/java/com/wms/controller/TaskController.java

1326 lines
70 KiB
Java
Raw Normal View History

新建
2024-07-04 07:43:04 +08:00
package com.wms.controller;
import com.alibaba.fastjson2.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wms.constants.enums.*;
import com.wms.entity.app.*;
import com.wms.entity.app.wcs.*;
import com.wms.entity.page.PageDomain;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
新建
2024-07-04 07:43:04 +08:00
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.*;
import com.wms.constants.WmsConstants;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
import com.wms.utils.storage.LocationUtils;
新建
2024-07-04 07:43:04 +08:00
import com.wms.service.*;
import com.wms.utils.HttpUtils;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
import com.wms.mapper.LocationMapper;
新建
2024-07-04 07:43:04 +08:00
import com.wms.utils.StringUtils;
import com.wms.utils.WmsUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* WMS任务控制类
*
* @author 梁州
* &#064;date 2023/2/14
*/
@Controller
@CrossOrigin
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@RequestMapping(value = "/wms/task")
public class TaskController extends BaseController {
/**
* 任务服务
*/
private final TaskService taskService;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
/**
* 任务 Mapper
*/
private final TaskMapper taskMapper;
/**
* 库存 Mapper
*/
private final StockMapper stockMapper;
新建
2024-07-04 07:43:04 +08:00
/**
* 库存服务
*/
private final StockService stockService;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
/**
* 库位操作类
*/
private final LocationUtils locationUtils;
新建
2024-07-04 07:43:04 +08:00
/**
* 零件
*/
private final PartInfoService partInfoService;
/**
* 库位服务
*/
private final LocationService locationService;
/**
* 任务记录服务
*/
private final TaskRecordService taskRecordService;
/**
* 站台服务
*/
private final StandService standService;
/**
* 载具服务
*/
private final VehicleService vehicleService;
/**
* 请求头部信息
*/
private final HttpServletRequest servletRequest;
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
/**
* 订单入库 Mapper
*/
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
/**
* 库位 Mapper
*/
private final LocationMapper locationMapper;
新建
2024-07-04 07:43:04 +08:00
/**
* 创建入库任务（人工入库）
*
* @param taskInRequestEntityList 入库任务
* @return 结果
*/
@PostMapping("/sendGoodsInTask")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String receiveGoodsInTask(@RequestBody List<TaskInRequestEntity> taskInRequestEntityList) {
logger.info("接收到入库任务：{}，ip地址：{}", JSON.toJSONString(taskInRequestEntityList), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 根据ip获得站台信息
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() < 1) {// 请求的地址不是站台电脑
logger.error("请用站台电脑下发任务");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请用站台电脑下发任务");
return JSON.toJSONString(rsp);
}
// 同一次请求为同一载具任务，为同一任务组
String taskGroupId = WmsUtils.generateUUIDString();
// 下一个库位
Location nextLocation = new Location();
// 当前载具
String currentVehicleNo = taskInRequestEntityList.get(0).getVehicleNo();
// 入库设备号
int currentSelEquip = 0;
// 查询当前载具库存信息
Vehicle vehicleQuery = new Vehicle();
vehicleQuery.setVehicleId(currentVehicleNo);
List<Vehicle> existVehicles = vehicleService.selVehicles(vehicleQuery);
if (existVehicles.size() > 0 && Objects.equals(existVehicles.get(0).getVehicleStatus(), VehicleStatus.ON.getCode())) {
logger.error("载具{}已经在库存中，请勿重复入库！", currentVehicleNo);
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("该托盘已经在库存中，请勿重复入库！");
return JSON.toJSONString(rsp);
}
Task taskQuery = new Task();
taskQuery.setVehicleNo(currentVehicleNo);
List<Task> sameVehicleTasks = taskService.selTasks(taskQuery);
if (sameVehicleTasks.size() > 0) {
logger.error("载具{}存在其他任务，请勿重复入库！", currentVehicleNo);
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("该载具存在其他任务，请勿重复入库！");
return JSON.toJSONString(rsp);
}
if (existVehicles.size() > 0) {
nextLocation = locationService.selLocations(new Location(existVehicles.get(0).getCurrentLocation())).get(0);
}
for (TaskInRequestEntity taskInRequestEntity : taskInRequestEntityList) {// 循环生成入库任务
// 生成任务
Task task_new = new Task();
// 保存必要的物料信息
task_new.setTaskId(WmsUtils.generateId("RK"));
// 设置发送给WCS的任务信息
task_new.setTaskType(TaskType.IN.getCode());
task_new.setTaskStatus(WmsTaskStatus.NEW.getCode());
task_new.setTaskGroup(taskGroupId);
// 查找库位时过滤掉不可用堆垛机
Stand standQuery1 = new Stand();
standQuery1.setStandType(3);
standQuery1.setIsLock(0);
standQuery1.setStandStatus(0);
List<Stand> availableEquips = standService.selStands(standQuery1);
if (availableEquips.size() < 1) {// 没有可用堆垛机，请稍后重试
logger.error("当前库无可用堆垛机，请稍后重试！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前库无可用堆垛机，请稍后重试！");
return JSON.toJSONString(rsp);
}
// 找到占用库位数量最少的堆垛机
int occupyLocationsNum = 1000000;
for (Stand availableEquip : availableEquips) {
Location locationQuery1 = new Location();
locationQuery1.setEquipmentId(availableEquip.getEquipmentId());
locationQuery1.setLocationStatus(LocationStatus.OCCUPY.getCode());
List<Location> locations1 = locationService.selLocations(locationQuery1);
if (locations1.size() < occupyLocationsNum) {// 当前最小
occupyLocationsNum = locations1.size();
currentSelEquip = availableEquip.getEquipmentId();
}
}
//查找到对应的入库站台
Stand standQuery2 = new Stand();
standQuery2.setAllowIn(1);
standQuery2.setAllowOut(0);
standQuery2.setEquipmentId(currentSelEquip);
standQuery2.setIsLock(0);
standQuery2.setStandStatus(0);
standQuery2.setStandType(1);
List<Stand> availableStands = standService.selStands(standQuery2);
if (availableStands.size() < 1) {
logger.error("当前堆垛机无可用入库站台，请稍后重试！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前堆垛机无可用入库站台，请稍后重试！");
return JSON.toJSONString(rsp);
}
task_new.setOrigin(availableStands.get(0).getStandId());
// 查找下一个可用库位
if (StringUtils.isEmpty(nextLocation.getLocationId())) {
List<Location> nextLocations = locationService.selNextLocation(new Location(currentSelEquip));
if (nextLocations.size() < 1) {
logger.error("入库错误：没有可用储存位");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("入库错误：没有可用储存位");
return JSON.toJSONString(rsp);
}
nextLocation = nextLocations.get(0);
}
nextLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
nextLocation.setVehicleId(taskInRequestEntity.getVehicleNo());
task_new.setDestination(nextLocation.getLocationId());
task_new.setWeight(taskInRequestEntity.getWeight() == null ? 0 : taskInRequestEntity.getWeight());
task_new.setVehicleNo(taskInRequestEntity.getVehicleNo());
task_new.setCreateTime(new Date());
task_new.setUserName(taskInRequestEntity.getUserName());
task_new.setGoodsId(taskInRequestEntity.getGoodsId());
if (!taskInRequestEntity.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {
// 查询物料信息后设定
PartInfo partInfo = partInfoService.selPartByPartNo(taskInRequestEntity.getGoodsId());
task_new.setGoodsName(partInfo.getItemDesc());
if (Double.parseDouble(partInfo.getSLED()) > 0) {
task_new.setProductionDate(taskInRequestEntity.getProductionDate());
task_new.setExpirationDate(WmsUtils.calculationMonth(taskInRequestEntity.getProductionDate(), (int) (12 * Double.parseDouble(partInfo.getSLED()))));
}
}
task_new.setOperateNum(taskInRequestEntity.getGoodsNum());
task_new.setTotalNum(0);
task_new.setTaskPriority(1);
// 插入入库任务
taskService.addTask(task_new);
}
// 锁定库位
locationService.modifyLocation(nextLocation);
// 添加载具/更新载具
if (existVehicles.size() == 0) {
Vehicle newVehicle = new Vehicle();
newVehicle.setVehicleId(currentVehicleNo);
newVehicle.setVehicleStatus(VehicleStatus.IN.getCode());// 入库中
newVehicle.setCurrentLocation(nextLocation.getLocationId());
if (Objects.equals(taskInRequestEntityList.get(0).getIsEmpty(), "0")) {
newVehicle.setIsEmpty(1);
} else {
newVehicle.setIsEmpty(0);
}
vehicleService.addVehicle(newVehicle);
} else {
Vehicle oldVehicle = existVehicles.get(0);
oldVehicle.setVehicleStatus(VehicleStatus.IN.getCode());//
oldVehicle.setCurrentLocation(nextLocation.getLocationId());
if (Objects.equals(taskInRequestEntityList.get(0).getIsEmpty(), "0")) {
oldVehicle.setIsEmpty(1);
} else {
oldVehicle.setIsEmpty(0);
}
vehicleService.modifyVehicle(oldVehicle);
}
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("创建入库任务成功");
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
}
/**
* 出库---根据零件号出库
* @param taskOutRequest 请求
* @return 结果
*/
@PostMapping("/sendGoodsOutTask")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String receiveGoodsOutTask(@RequestBody TaskOutRequestEntity taskOutRequest) {
logger.info("接收到出库请求：{}，ip地址：{}", JSON.toJSONString(taskOutRequest), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
StringBuilder returnMessage = new StringBuilder();
try {
// 根据ip获得站台信息
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() < 1) {// 请求的地址不是站台电脑
logger.error("请用站台电脑下发任务");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请用站台电脑下发任务");
return JSON.toJSONString(rsp);
}
// 判断物料编号和数量有没有输入
if (taskOutRequest== null || StringUtils.isEmpty(taskOutRequest.getGoodsId()) || taskOutRequest.getNeedNum() == null || taskOutRequest.getNeedNum() == 0) {
logger.error("物料号和数量必须输入，请确认！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("物料号和数量必须输入，请确认！");
return JSON.toJSONString(rsp);
}
// 查找库存
Stock stockQuery = new Stock();
stockQuery.setGoodsId(taskOutRequest.getGoodsId());
stockQuery.setVehicleId(taskOutRequest.getVehicleNo());
stockQuery.setStockStatus(StockStatus.OK.getCode());
List<Stock> needStocks = stockService.selStocks(stockQuery);
if (needStocks.size() == 0) {// 没有库存
logger.error("选择的库存不存在，无法出库！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("选择的库存不存在，无法出库！");
return JSON.toJSONString(rsp);
}
int needNum = taskOutRequest.getNeedNum();
Location currentLocation;
for (Stock needStock : needStocks) {
if (needNum > 0 && needStock.getRemainNum() > 0) {// 还有需求数量
Task tempTask = new Task();
tempTask.setTaskId(WmsUtils.generateId("CK"));
tempTask.setTaskType(TaskType.OUT.getCode());
tempTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
tempTask.setTaskGroup(WmsUtils.generateUUIDString());
tempTask.setTaskPriority(1);
tempTask.setPickStand(stands.get(0).getStandId());
tempTask.setVehicleNo(needStock.getVehicleId());
tempTask.setUserName(taskOutRequest.getUserName());
tempTask.setGoodsId(needStock.getGoodsId());
tempTask.setGoodsName(needStock.getGoodsName());
tempTask.setCreateTime(new Date());
tempTask.setProductionDate(needStock.getProductionDate());
tempTask.setExpirationDate(needStock.getExpirationDate());
tempTask.setTotalNum(needStock.getRealNum());
tempTask.setOrigin(needStock.getLocationId());
//查找到对应的出库
currentLocation = locationService.selLocations(new Location(needStock.getLocationId())).get(0);
Stand standQuery2 = new Stand();
standQuery2.setAllowIn(0);
standQuery2.setAllowOut(1);
standQuery2.setEquipmentId(currentLocation.getEquipmentId());
standQuery2.setIsLock(0);
standQuery2.setStandStatus(0);
standQuery2.setStandType(1);
List<Stand> availableStands = standService.selStands(standQuery2);
if (availableStands.size() < 1) {
logger.error("当前库存的出库站台不可用！");
// 返回错误信息
returnMessage.append("当前库存所在载具").append(currentLocation.getVehicleId()).append("的出库站台不可用！\n");
}
tempTask.setDestination(availableStands.get(0).getStandId());
if (needNum <= needStock.getRemainNum()) {// 数量足够
tempTask.setOperateNum(needNum);
needNum = 0;
needStock.setRemainNum(needStock.getRemainNum() - needNum);
} else {
tempTask.setOperateNum(needStock.getRemainNum());
needNum -= needStock.getRemainNum();
needStock.setRemainNum(0);
}
// 添加任务
taskService.addTask(tempTask);
logger.info("添加任务成功，{}", JSON.toJSONString(tempTask));
// 更新库存
needStock.setStockStatus(StockStatus.OUT.getCode());
stockService.modifyStock(needStock);
logger.info("更新库存信息成功，{}", JSON.toJSONString(needStock));
// 更新载具信息
Vehicle currentVehicle = vehicleService.selVehicleById(needStock.getVehicleId());
if (currentVehicle == null) {
currentVehicle = new Vehicle();
currentVehicle.setVehicleId(needStock.getVehicleId());
currentVehicle.setIsEmpty(0);
currentVehicle.setCurrentLocation(needStock.getLocationId());
currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
vehicleService.addVehicle(currentVehicle);
} else {
currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
vehicleService.modifyVehicle(currentVehicle);
}
logger.info("更新载具信息，{}", JSON.toJSONString(currentVehicle));
// 将当前载具的其他库存也设置为相同状态
Stock stockQuery2 = new Stock();
stockQuery2.setVehicleId(needStock.getVehicleId());
List<Stock> sameVehicleStocks = stockService.selStocks(stockQuery2);
for (Stock sameVehicleStock : sameVehicleStocks) {
if (!Objects.equals(sameVehicleStock.getStockId(), needStock.getStockId())) {
sameVehicleStock.setStockStatus(StockStatus.OUT.getCode());
stockService.modifyStock(sameVehicleStock);
}
}
logger.info("更新载具中其他库存信息，{}", needStock.getVehicleId());
}
}
if (needNum > 0) {// 库存不足的情况下
returnMessage.append("当前可用数量不足，已将能够出库的库存出库。\n");
}
logger.info("下发出库任务成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage(String.valueOf(returnMessage));
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("创建出库任务发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
}
/**
* 出库---根据料箱号出
* @param taskOutRequest 请求
* @return 结果
*/
@PostMapping("/vehicleOut")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String selectVehicleOut(@RequestBody TaskOutRequestEntity taskOutRequest) {
logger.info("接收到出箱请求：{}，ip地址：{}", JSON.toJSONString(taskOutRequest), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 根据ip获得站台信息
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() < 1) {// 请求的地址不是站台电脑
logger.error("请用站台电脑下发任务");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请用站台电脑下发任务");
return JSON.toJSONString(rsp);
}
// 判断物料编号和数量有没有输入
if (taskOutRequest== null || StringUtils.isEmpty(taskOutRequest.getVehicleNo())) {
logger.error("箱号必须输入，请确认！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("箱号必须输入，请确认！");
return JSON.toJSONString(rsp);
}
Vehicle vehicle = vehicleService.selVehicleById(taskOutRequest.getVehicleNo());
if (vehicle == null || !Objects.equals(vehicle.getVehicleStatus(), VehicleStatus.ON.getCode())) {
logger.error("当前箱子不可用，请确认！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前箱子不可用，请确认！");
return JSON.toJSONString(rsp);
}
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
int needNum = taskOutRequest.getNeedNum();
新建
2024-07-04 07:43:04 +08:00
// 生成任务
Task tempTask = new Task();
tempTask.setVehicleNo(taskOutRequest.getVehicleNo());
tempTask.setTaskId(WmsUtils.generateId("RKCK"));
tempTask.setTaskGroup(WmsUtils.generateUUIDString());
tempTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
tempTask.setTaskType(TaskType.OUT.getCode());
tempTask.setOperateNum(0);
tempTask.setCreateTime(new Date());
tempTask.setGoodsId(WmsConstants.EMPTY_STOCK_GOODS_ID);
tempTask.setUserName(taskOutRequest.getUserName());
tempTask.setPickStand(stands.get(0).getStandId());
tempTask.setTaskPriority(1);
tempTask.setWeight((double) 0);
tempTask.setOrigin(vehicle.getCurrentLocation());
//查找到对应的出库站台
Location currentLocation = locationService.selLocations(new Location(vehicle.getCurrentLocation())).get(0);
Stand standQuery2 = new Stand();
standQuery2.setAllowIn(0);
standQuery2.setAllowOut(1);
standQuery2.setEquipmentId(currentLocation.getEquipmentId());
standQuery2.setIsLock(0);
standQuery2.setStandStatus(0);
standQuery2.setStandType(1);
List<Stand> availableStands = standService.selStands(standQuery2);
if (availableStands.size() < 1) {
logger.error("当前箱子的出库站台不可用！");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前箱子的出库站台不可用！");
return JSON.toJSONString(rsp);
}
tempTask.setDestination(availableStands.get(0).getStandId());
taskService.addTask(tempTask);
logger.info("下发出箱任务成功");
// 更新料箱状态
vehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
vehicleService.modifyVehicle(vehicle);
logger.info("更新料箱状态成功");
// 该箱子上的库存状态变更
Stock stockQuery = new Stock();
stockQuery.setVehicleId(taskOutRequest.getVehicleNo());
List<Stock> stocks = stockService.selStocks(stockQuery);
for (Stock tempStock : stocks) {
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
if (needNum <= 0){
break;
}
新建
2024-07-04 07:43:04 +08:00
tempStock.setStockStatus(StockStatus.OUT.getCode());
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
needNum = needNum - tempStock.getRealNum();
新建
2024-07-04 07:43:04 +08:00
stockService.modifyStock(tempStock);
}
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
// for (Stock tempStock : stocks){
// if (!Objects.equals(tempStock.getStockStatus(), StockStatus.OUT.getCode())){
// //生成回库任务
// String vehicleNo = taskOutRequest.getVehicleNo(); // 载具号
// /* 查找一个空库位 */
// Location emptyLocation = new Location();
// emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
// emptyLocation.setAreaId(1);
// List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
// if(emptyLocations == null) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("库位查找失败，网络连接异常，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// if(emptyLocations.isEmpty()){
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("没有可用库位");
// return JSON.toJSONString(rsp);
// }
// Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
// if(emptyLocationItem == null) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("没有可用库位或者库位存在干涉，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// // 该空库位可用，生成一个入库任务，并将库存表更新库位
// // 更新库位表，占掉库位
// Location updateLocation = new Location();
// updateLocation.setLocationId(emptyLocationItem.getLocationId());
// updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
// updateLocation.setVehicleId(taskOutRequest.getVehicleNo());
// locationMapper.modifyLocation(updateLocation); // 占掉库位
// // ---- 更新库存中库位
// stockMapper.updateLocationIdWithBetchNo(taskOutRequest.getVehicleNo(), emptyLocationItem.getLocationId()); // 绑定载具和库位
// // 更新入库单
// appOrderInMapper.updateStatusWithVehicleNo(vehicleNo, OrderInStatusEnum.IN.getCode()); // 更新入库单为入库中
// // 添加入库任务
// Task task = new Task();
// task.setTaskId(UUID.randomUUID().toString());
// task.setTaskType(TaskType.IN.getCode());
// task.setTaskStatus(WmsTaskStatus.NEW.getCode());
// task.setTaskGroup(UUID.randomUUID().toString());
// task.setOrigin(tempTask.getDestination());
// task.setDestination(emptyLocationItem.getLocationId());
// task.setPickStand("");
// task.setWeight(0.0);
// task.setVehicleNo(taskOutRequest.getVehicleNo());
// task.setCreateTime(new Date());
// task.setUserName("wcs");
// task.setGoodsId(vehicleNo);
// task.setGoodsName("");
// task.setOperateNum(0);
// task.setTotalNum(0);
// task.setTaskPriority(1);
// int addTask = taskMapper.addTask(task);
// if(addTask > 0) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("存在入库任务，申请成功！");
// return JSON.toJSONString(rsp);
// }
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("添加入库任务失败，网络连接异常，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// }
新建
2024-07-04 07:43:04 +08:00
logger.info("更新库存状态成功");
logger.info("下发出库任务成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("箱号" + taskOutRequest.getVehicleNo() + "生成出库任务成功");
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("创建出库任务发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
}
/**
* 盘点出库
*
* @param request 请求
* @return 结果
*/
@PostMapping("/sendInventoryTask")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String sendInventoryTask(@RequestBody InventoryTask request) {
// TODO 盘点优化
logger.info("接收到盘库请求：{}，ip地址：{}", JSON.toJSONString(request), HttpUtils.getIpAddr(servletRequest));
ResponseEntity rsp = new ResponseEntity();
try {
// 根据ip获得站台信息
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() < 1) {// 请求的地址不是站台电脑
logger.error("请用站台电脑下发盘库任务");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请用站台电脑下发盘库任务");
return JSON.toJSONString(rsp);
}
// 判断零件号是否输入
if (StringUtils.isEmpty(request.getGoodsId())) {
logger.error("未选择盘点零件");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请选择盘点零件");
return JSON.toJSONString(rsp);
}
// 判断当前零件是否有其他任务
Task taskQuery2 = new Task();
taskQuery2.setGoodsId(request.getGoodsId());
taskQuery2.setVehicleNo(request.getVehicleId());
List<Task> sameGoodsTasks = taskService.selTasks(taskQuery2);
if (sameGoodsTasks.size() > 0) {
logger.error("当前零件存在其他任务");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前零件存在其他任务，请勿执行盘点");
return JSON.toJSONString(rsp);
}
// 判断库存中是否有此物料
Stock stockQuery1 = new Stock();
stockQuery1.setGoodsId(request.getGoodsId());
stockQuery1.setVehicleId(request.getVehicleId());
stockQuery1.setStockStatus(StockStatus.OK.getCode());
List<Stock> detailStocks = stockService.selStocks(stockQuery1);
List<Stock> summaryStocks = stockService.selStocksByGoodsId(stockQuery1);
if (detailStocks.size() == 0) {// 当前零件无库存
logger.error("当前零件无库存");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前零件无库存");
return JSON.toJSONString(rsp);
}
if (summaryStocks.size() == 0) {
logger.error("当前零件无库存");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("当前零件无库存");
return JSON.toJSONString(rsp);
}
for (Stock tempDetailStock : detailStocks) {
// 根据库存生成任务
// 生成出库任务
Task task = new Task();
// 任务编号
task.setTaskId(WmsUtils.generateId("PDCK"));
<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能 - 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务 - 添加补盘功能，处理空托盘出库和创建出库任务
2024-07-18 13:26:56 +08:00
//task.setTaskId(UUID);
新建
2024-07-04 07:43:04 +08:00
// 任务类型
task.setTaskType(TaskType.INVENTORY.getCode());
// 起点
task.setOrigin(tempDetailStock.getLocationId());
// 查找对应库位对应的站台
Location locationQuery = new Location();
locationQuery.setLocationId(tempDetailStock.getLocationId());
Location currentLocation = locationService.selLocations(locationQuery).get(0);
Stand standQuery = new Stand();
standQuery.setEquipmentId(currentLocation.getEquipmentId());
standQuery.setAllowIn(0);
standQuery.setAllowOut(1);
standQuery.setStandType(1);
Stand targetStand = standService.selStands(standQuery).get(0);
task.setDestination(targetStand.getStandId());
task.setPickStand(stands.get(0).getStandId());
// 重量
// 查找零件数据，然后计算重量
PartInfo partInfo = partInfoService.selPartByPartNo(tempDetailStock.getGoodsId());
task.setWeight(partInfo.getPartWeight() * tempDetailStock.getRealNum());// 重量
// 载具编号
task.setVehicleNo(tempDetailStock.getVehicleId());
// 尺寸
task.setVehicleSize(1);
task.setCreateTime(new Date());
// 用户名
task.setUserName(request.getUserName());
task.setGoodsId(tempDetailStock.getGoodsId());
task.setGoodsName(tempDetailStock.getGoodsName());
task.setProductionDate(tempDetailStock.getProductionDate());
task.setExpirationDate(tempDetailStock.getExpirationDate());
task.setOperateNum(0);
task.setTotalNum(tempDetailStock.getRealNum());
task.setTaskPriority(2);
tempDetailStock.setIsInventory(1);
tempDetailStock.setInventoryTaskId(task.getTaskId());
task.setTaskStatus(WmsTaskStatus.NEW.getCode());// 新建出库任务
task.setTaskGroup(WmsUtils.generateUUIDString());// group
taskService.addTask(task);
// 将库存设定为盘点出库状态
tempDetailStock.setStockStatus(StockStatus.OUT.getCode());
stockService.modifyStock(tempDetailStock);
// 将这个托盘上的其他库存都设定为盘点出库状态
List<Stock> sameVehicleStock = stockService.selStocks(new Stock(tempDetailStock.getVehicleId()));
for (Stock tempStock : sameVehicleStock) {
if (Objects.equals(tempStock.getStockId(), tempDetailStock.getStockId())) {
continue;
}
tempStock.setStockStatus(StockStatus.OUT.getCode());
stockService.modifyStock(tempStock);
}
// 将当前的载具设置为出库中
Vehicle currentVehicle = vehicleService.selVehicleById(tempDetailStock.getVehicleId());
currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
vehicleService.modifyVehicle(currentVehicle);
}
logger.info("创建盘点任务成功，零件号：{}", request.getGoodsId());
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("创建盘库任务成功");
rsp.setReturnData(summaryStocks.size() > 0 ? summaryStocks.get(0) : new Stock());
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("创建盘库任务发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
}
/**
* 接收WCS发送的任务结果
*
* @param wmsReceiveTaskResultEntity 请求
* @return 响应结果
*/
@PostMapping("/sendTaskResult")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String receiveTaskResult(@RequestBody WmsReceiveTaskResultEntity wmsReceiveTaskResultEntity) {
logger.info("接收到任务反馈：{}，ip地址：{}", wmsReceiveTaskResultEntity.toLoggerString(), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 获取任务号
String taskId = wmsReceiveTaskResultEntity.getTaskId();
Integer result = wmsReceiveTaskResultEntity.getTaskStatus();
String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
// 查找对应任务
Task taskForQuery = new Task();
taskForQuery.setTaskGroup(taskId);
List<Task> tasks = taskService.selTasks(taskForQuery);
if (tasks.size() < 1) {
logger.error("任务号不正确");
// 返回失败
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("任务号不正确");
return JSON.toJSONString(rsp);
}
// 设定任务类型
Integer taskType = tasks.get(0).getTaskType();
if (result.compareTo(WcsTaskStatus.FINISH.getCode()) == 0) {// 任务完成
// 回原库位
if (taskType.compareTo(TaskType.IN.getCode()) == 0) {// 入库任务
logger.info("入库任务完成，开始处理");
// 更新载具信息
Vehicle currentVehicle = vehicleService.selVehicleById(vehicleNo);
currentVehicle.setVehicleStatus(2);// 在库中
currentVehicle.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
vehicleService.modifyVehicle(currentVehicle);
// 添加库存
for (Task task : tasks) {
if (!Objects.equals(task.getTaskType(), TaskType.IN.getCode())) {
continue;
}
if (task.getTaskId().startsWith("HK")) {// 回库的库存
// 查询是不是回库的库存
Stock stockQuery1 = new Stock();
stockQuery1.setVehicleId(vehicleNo);
stockQuery1.setGoodsId(task.getGoodsId());
List<Stock> backStocks = stockService.selStocks(stockQuery1);
for (Stock tempBackStock : backStocks) {
tempBackStock.setLocationId(task.getDestination());
tempBackStock.setStockStatus(StockStatus.OK.getCode());
tempBackStock.setLastUpdateTime(new Date());
stockService.modifyStock(tempBackStock);
logger.info("更新回库库存");
}
} else if (task.getTaskId().startsWith("RK")) {// 新增库存
if (!task.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {// 空箱入库的情况下不生成库存
Stock exsitStockQuery = new Stock();
exsitStockQuery.setVehicleId(vehicleNo);
exsitStockQuery.setGoodsId(task.getGoodsId());
List<Stock> exsitStocks = stockService.selStocks(exsitStockQuery);
if (exsitStocks.size() > 0) {// 说明该箱子上已有该零件
// 直接添加数量
Stock exsitStock = exsitStocks.get(0);
exsitStock.setRemainNum(exsitStock.getRemainNum() + task.getOperateNum());
exsitStock.setRealNum(exsitStock.getRealNum() + task.getOperateNum());
exsitStock.setStockStatus(StockStatus.OK.getCode());
exsitStock.setLocationId(task.getDestination());
stockService.modifyStock(exsitStock);
logger.info("已有库存增加数量成功：{}", JSON.toJSONString(exsitStock));
} else {
Stock stockTemp = new Stock();
stockTemp.setStockId(WmsUtils.generateId("ST"));
stockTemp.setLocationId(task.getDestination());
stockTemp.setVehicleId(vehicleNo);
stockTemp.setGoodsId(task.getGoodsId());
// 查询物料信息后设定
PartInfo partInfo = partInfoService.selPartByPartNo(task.getGoodsId());
stockTemp.setGoodsName(partInfo.getItemDesc());
if (Double.parseDouble(partInfo.getSLED()) > 0) {
stockTemp.setProductionDate(task.getProductionDate());
stockTemp.setShelfLife(Double.parseDouble(partInfo.getSLED()));
stockTemp.setExpirationDate(task.getExpirationDate());
}
stockTemp.setAvailableNum(task.getOperateNum());
stockTemp.setRemainNum(task.getOperateNum());
stockTemp.setRealNum(task.getOperateNum());
stockTemp.setProviderId(partInfo.getVendorId());
stockTemp.setProviderName(partInfo.getVendorNameCN());
stockTemp.setStockStatus(StockStatus.OK.getCode());
stockTemp.setGoodsStatus(GoodsStatus.OK.getCode());
stockTemp.setCreateTime(new Date());
stockTemp.setLastUpdateTime(new Date());
stockTemp.setIsInventory(0);
stockTemp.setCurrentLocation(task.getDestination());
logger.info("生成新库存：{}", JSON.toJSONString(stockTemp));
stockService.addStock(stockTemp);
}
}
}
// 查看当前料箱上还有没有其他料
logger.info("更新料箱上其他库存");
Stock stockQuery3 = new Stock();
stockQuery3.setVehicleId(vehicleNo);
List<Stock> backStocks3 = stockService.selStocks(stockQuery3);
for (Stock tempBackStock3 : backStocks3) {
if (Objects.equals(tempBackStock3.getGoodsId(), task.getGoodsId())) {
continue;
}
if (tempBackStock3.getRealNum() <= 0) {// 无库存
stockService.deleteStock(tempBackStock3.getStockId());
} else {
tempBackStock3.setLocationId(task.getDestination());
tempBackStock3.setStockStatus(StockStatus.OK.getCode());
stockService.modifyStock(tempBackStock3);
}
}
}
// 对完成的入库任务进行处理
for (Task task : tasks) {
// 入库任务完成，先添加任务记录，然后删除任务。
task.setTaskStatus(WmsTaskStatus.FINISH.getCode());
task.setFinishTime(new Date());
taskRecordService.addTask(task);
taskService.deleteTask(task.getTaskId());
}
} else if (taskType.compareTo(TaskType.OUT.getCode()) == 0) {// 出库任务
logger.info("出库任务完成，开始处理");
// 更改载具位置为站台
Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
vehicleService.modifyVehicle(vehicle);
// 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(vehicleNo);
List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
for (Stock temp : tempStockList1) {
temp.setStockStatus(StockStatus.TRANS.getCode());
temp.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
temp.setLastUpdateTime(new Date());
stockService.modifyStock(temp);
}
for (Task task : tasks) {
if (!Objects.equals(task.getTaskType(), TaskType.OUT.getCode())) {
continue;
}
if (task.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {
task.setTaskStatus(WmsTaskStatus.FINISH.getCode());// 出库完成状态
task.setFinishTime(new Date());
taskRecordService.addTask(task);
taskService.deleteTask(task.getTaskId());
} else {
task.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());// 出库完成状态
taskService.executeTask(task);
}
}
} else if (taskType.compareTo(TaskType.INVENTORY.getCode()) == 0) {// 盘点任务
logger.info("盘点任务完成，开始处理");
// 更改载具位置为站台
Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
vehicleService.modifyVehicle(vehicle);
// 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(vehicleNo);
List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
for (Stock temp : tempStockList1) {
temp.setStockStatus(StockStatus.TRANS.getCode());
temp.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
temp.setLastUpdateTime(new Date());
stockService.modifyStock(temp);
}
for (Task task : tasks) {
if (!Objects.equals(task.getTaskType(), TaskType.INVENTORY.getCode())) {
continue;
}
task.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());// 出库完成状态
taskService.executeTask(task);
}
}
} else if (result.compareTo(WcsTaskStatus.RUN.getCode()) == 0) {// 任务开始执行
logger.info("任务开始执行");
for (Task task : tasks) {
task.setTaskStatus(WmsTaskStatus.RUN.getCode());// 任务开始执行
taskService.executeTask(task);
}
} else if (result.compareTo(WcsTaskStatus.EXCEPTION.getCode()) == 0) {// 任务开始执行
logger.info("任务发生异常");
for (Task task : tasks) {
task.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());// 任务开始执行
taskService.executeTask(task);
}
} else if (result.compareTo(WcsTaskStatus.CANCEL.getCode()) == 0) {
if (taskType.compareTo(TaskType.IN.getCode()) == 0) {// 入库任务取消
logger.info("入库任务取消，开始处理");
for (Task tempInTask : tasks) {
if (tempInTask.getTaskId().startsWith("HK")) {// 回库任务，需要删除库存
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(vehicleNo);
stockQueryParam1.setGoodsId(tempInTask.getGoodsId());
List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
for (Stock temp : tempStockList1) {
stockService.deleteStock(temp.getStockId());
}
}
}
} else if (taskType.compareTo(TaskType.OUT.getCode()) == 0) {// 出库任务取消
logger.info("出库任务取消，开始处理");
// 更改载具位置为站台
logger.info("更新载具为在库中");
Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
vehicleService.modifyVehicle(vehicle);
// 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
logger.info("更新库存为正常状态");
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(vehicleNo);
List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
for (Stock temp : tempStockList1) {
temp.setStockStatus(StockStatus.OK.getCode());
stockService.modifyStock(temp);
}
} else if (taskType.compareTo(TaskType.INVENTORY.getCode()) == 0) {// 盘点任务取消
logger.info("盘点任务取消，开始处理");
// 更改载具位置为站台
logger.info("更新载具为在库中");
Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
vehicleService.modifyVehicle(vehicle);
// 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
logger.info("更新库存为正常状态");
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(vehicleNo);
List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
for (Stock temp : tempStockList1) {
temp.setStockStatus(StockStatus.OK.getCode());
stockService.modifyStock(temp);
}
}
// 更新任务状态
logger.info("删除取消的任务，并添加任务记录");
for (Task task : tasks) {
task.setTaskStatus(WmsTaskStatus.CANCEL.getCode());// 任务开始执行
task.setFinishTime(new Date());
taskService.deleteTask(task.getTaskId());
taskRecordService.addTask(task);
}
}
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("发生异常");
// 返回失败
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("发生异常，请尝试重新发送一次");
return JSON.toJSONString(rsp);
}
logger.info("获取任务反馈处理成功");
// 返回失败
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("任务处理成功");
return JSON.toJSONString(rsp);
}
/**
* WCS向WMS上报箱子到达拣货口
* @param pickTask 拣选任务
* @return 结果
*/
@PostMapping("/boxArrive")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String boxArrive(@RequestBody PickTaskResponse pickTask) {
logger.info("接收到WCS向WMS上报箱子到达拣货点：{}", JSON.toJSONString(pickTask));
ResponseEntity response = new ResponseEntity();
try {
// 根据载具号加拣选点位找到对应的任务----出库任务/盘点任务
Task taskQueryParam1 = new Task();
taskQueryParam1.setVehicleNo(pickTask.getVehicleNo());
taskQueryParam1.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());
List<Task> tasks = taskService.selTasks(taskQueryParam1);
if (tasks.size() < 1) {
logger.error("当前反馈的箱号{}不存在可以操作的任务", pickTask.getVehicleNo());
// 返回失败
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前反馈的箱号没有对应的任务");
return JSON.toJSONString(response);
}
// 更新当前载具的当前位置为拣选站台
Vehicle vehicle = vehicleService.selVehicleById(pickTask.getVehicleNo());
if (vehicle == null) {
logger.error("没查询到对应载具{}", pickTask.getVehicleNo());
// 返回失败
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("没查询到对应载具信息");
return JSON.toJSONString(response);
}
vehicleService.modifyVehicle(vehicle);
// 更新库存位置
Stock stockQueryParam1 = new Stock();
stockQueryParam1.setVehicleId(pickTask.getVehicleNo());
List<Stock> stocks = stockService.selStocks(stockQueryParam1);
if (stocks.size() < 1) {
logger.error("载具{}没查询到对应库存", pickTask.getVehicleNo());
// 返回失败
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("反馈的载具没查询到对应库存");
return JSON.toJSONString(response);
}
for (Stock tempStock : stocks) {
tempStock.setStockStatus(StockStatus.PICKING.getCode());
tempStock.setCurrentLocation(pickTask.getPickStand());
stockService.modifyStock(tempStock);
}
// 更新任务状态
for (Task tempTaskForPicking : tasks) {
if (Objects.equals(tempTaskForPicking.getTaskType(), TaskType.OUT.getCode())) {
// 更新任务状态
tempTaskForPicking.setTaskStatus(WmsTaskStatus.PICKING.getCode());
taskService.executeTask(tempTaskForPicking);
} else if (Objects.equals(tempTaskForPicking.getTaskType(), TaskType.INVENTORY.getCode())) {// 盘点出库
// 更新任务状态
tempTaskForPicking.setTaskStatus(WmsTaskStatus.INVENTORY.getCode());
taskService.executeTask(tempTaskForPicking);
}
}
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("发生异常：{}", e.getMessage());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("发生异常");
return JSON.toJSONString(response);
}
logger.info("处理成功");
response.setCode(ResponseCode.OK.getCode());
response.setMessage("成功");
return JSON.toJSONString(response);
}
/**
* 当前箱子请求回库
*
* @param request 请求
* @return 结果
*/
@PostMapping("/finishPicking")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String finishPicking(@RequestBody FinishPickTaskRequest request) {
logger.info("确认拣货完成：{}", JSON.toJSONString(request));
ResponseEntity response = new ResponseEntity();
try {
if (StringUtils.isEmpty(request.getTaskId())) {//
logger.error("任务号为空");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("任务号为空");
return JSON.toJSONString(response);
}
// 将当前任务信息更新
Task taskQuery1 = new Task();
taskQuery1.setTaskId(request.getTaskId());
List<Task> tasks1 = taskService.selTasks(taskQuery1);
if (tasks1.size() < 1) {
logger.error("数据库中查询不到当前正在执行的任务：{}", request.getTaskId());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("数据库中查询不到当前正在执行的任务");
return JSON.toJSONString(response);
}
Task currentTask = tasks1.get(0);
currentTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
if (request.getPickNum() != null) {
currentTask.setOperateNum(request.getPickNum());
}
if (Objects.equals(currentTask.getTaskType(), TaskType.INVENTORY.getCode())) {// 盘点任务
currentTask.setOperateNum(currentTask.getTotalNum() - request.getRealNum());
}
currentTask.setFinishTime(new Date());
taskRecordService.addTask(currentTask);
taskService.deleteTask(currentTask.getTaskId());
// 根据这个任务的数据来更新库存
Stock stockQuery1 = new Stock();
stockQuery1.setVehicleId(currentTask.getVehicleNo());
stockQuery1.setGoodsId(currentTask.getGoodsId());
List<Stock> stocks = stockService.selStocks(stockQuery1);
if (stocks.size() < 1) {
logger.error("查询不到对应库存");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询不到对应库存");
return JSON.toJSONString(response);
}
Stock currentStock = stocks.get(0);
if (request.getRealNum() != null) {
currentStock.setRealNum(request.getRealNum());
if (Objects.equals(currentTask.getTaskType(), TaskType.INVENTORY.getCode())) {
currentStock.setRemainNum(currentStock.getRealNum());
currentStock.setAvailableNum(currentStock.getRealNum());
}
} else {
currentStock.setRealNum(currentStock.getRealNum() - currentTask.getOperateNum());
}
// 判断当前任务的载具号是否还有其他任务
Task taskQuery2 = new Task();
taskQuery2.setVehicleNo(request.getVehicleNo());
taskQuery2.setTaskType(TaskType.OUT.getCode());
List<Task> sameVehicleTasks = taskService.selTasks(taskQuery2);
if (sameVehicleTasks.size() > 0) {// 存在其他任务
logger.info("当前载具还有其他任务");
// 库存只更新
stockService.modifyStock(currentStock);
} else {
// 标记当前箱子入库中
// 标记当前载具为空箱
Vehicle currentVehicle = vehicleService.selVehicleById(currentTask.getVehicleNo());
currentVehicle.setVehicleStatus(VehicleStatus.IN.getCode());
vehicleService.modifyVehicle(currentVehicle);
//查找到对应的入库站台
Stand standQuery2 = new Stand();
standQuery2.setAllowIn(1);
standQuery2.setAllowOut(0);
standQuery2.setStandType(1);
// 判断库存是否为0
if (currentStock.getRealNum() <= 0) {// 库存为0
logger.info("拣货后库存为0，空箱回库");
// 删除当前库存
stockService.deleteStock(currentStock.getStockId());
// 根据这个任务的数据来更新库存
Stock stockQuery2 = new Stock();
stockQuery2.setVehicleId(currentTask.getVehicleNo());
List<Stock> stocks2 = stockService.selStocks(stockQuery2);
// 判断当前载具上是否还有其他库存
if (stocks2.size() == 0) {// 当前载具是空托
// 标记当前载具为空箱
currentVehicle.setIsEmpty(1);
vehicleService.modifyVehicle(currentVehicle);
} else {// 更新载具上其他库存为回库状态
for (Stock tempSameVehicleStock : stocks2) {
tempSameVehicleStock.setStockStatus(StockStatus.BACKING.getCode());
stockService.modifyStock(tempSameVehicleStock);
}
}
// 生成空托回库任务---回到原来位置
Task emptyBackTask = new Task();
emptyBackTask.setTaskId(WmsUtils.generateId("HK"));
emptyBackTask.setTaskType(TaskType.IN.getCode());
emptyBackTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
emptyBackTask.setTaskGroup(WmsUtils.generateUUIDString());
emptyBackTask.setDestination(currentStock.getLocationId());
// 根据库位查找站台
Location currentLocation = locationService.selLocations(new Location(currentStock.getLocationId())).get(0);
standQuery2.setEquipmentId(currentLocation.getEquipmentId());
List<Stand> availableStands = standService.selStands(standQuery2);
emptyBackTask.setOrigin(availableStands.get(0).getStandId());
emptyBackTask.setWeight((double) 0);
emptyBackTask.setVehicleNo(currentTask.getVehicleNo());
emptyBackTask.setVehicleSize(0);
emptyBackTask.setCreateTime(new Date());
emptyBackTask.setUserName(currentTask.getUserName());
emptyBackTask.setGoodsId(WmsConstants.EMPTY_STOCK_GOODS_ID);
emptyBackTask.setTaskPriority(1);
taskService.addTask(emptyBackTask);
} else {
logger.info("拣货后库存不为0，回库");
// 更新库存
currentStock.setRemainNum(currentStock.getRealNum());
stockService.modifyStock(currentStock);
// 设置当前载具的其他库存也为回库中
Stock stockQuery2 = new Stock();
stockQuery2.setVehicleId(currentTask.getVehicleNo());
List<Stock> stocks2 = stockService.selStocks(stockQuery2);
for (Stock sameVehicleStock : stocks2) {
sameVehicleStock.setStockStatus(StockStatus.BACKING.getCode());
stockService.modifyStock(sameVehicleStock);
}
// 生成入库任务
Task backTask = new Task();
backTask.setTaskId(WmsUtils.generateId("HK"));
backTask.setTaskType(TaskType.IN.getCode());
backTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
backTask.setTaskGroup(WmsUtils.generateUUIDString());
backTask.setDestination(currentStock.getLocationId());
// 根据库位查找站台
Location currentLocation = locationService.selLocations(new Location(currentStock.getLocationId())).get(0);
standQuery2.setEquipmentId(currentLocation.getEquipmentId());
List<Stand> availableStands = standService.selStands(standQuery2);
backTask.setOrigin(availableStands.get(0).getStandId());
backTask.setWeight((double) 0);
backTask.setVehicleNo(currentTask.getVehicleNo());
backTask.setVehicleSize(0);
backTask.setCreateTime(new Date());
backTask.setUserName(currentTask.getUserName());
backTask.setGoodsId(currentStock.getGoodsId());
backTask.setGoodsName(currentStock.getGoodsName());
backTask.setProductionDate(currentStock.getProductionDate());
backTask.setExpirationDate(currentStock.getExpirationDate());
backTask.setOperateNum(currentStock.getRealNum());
backTask.setTotalNum(currentStock.getRealNum());
backTask.setTaskPriority(1);
taskService.addTask(backTask);
}
}
logger.info("物料回库成功");
response.setCode(0);
response.setMessage("成功");
return JSON.toJSONString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("发生异常：{}", e.getMessage());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("发生异常");
return JSON.toJSONString(response);
}
}
/**
* 查找所有任务
*/
@PostMapping("/getTasks")
@ResponseBody
public String getTasks(@RequestBody TableRequest<Task, String> tableRequest) {
TableResponse tblResp = new TableResponse();
// 解析请求数据
if (tableRequest == null || tableRequest.getPage() == null) {
tblResp.setCode(ResponseCode.ERROR.getCode());
tblResp.setMessage("请求数据为空，无法处理！");
logger.error("请求数据为空，无法处理！");
return JSON.toJSONString(tblResp);
}
// 处理分页信息
PageDomain pageRequest = tableRequest.getPage();
String[] orderByArr = {"task_id", "task_type", "task_status", "goods_id", "goods_name", "task_priority", "expiration_date", "create_time"};
String orderByStr;
if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
orderByStr = pageRequest.getOrderBy();
} else {
// 默认排序
orderByStr = "";
}
Task taskQuery = new Task();
taskQuery.setTaskType(tableRequest.getParam().getTaskType());
taskQuery.setGoodsId(tableRequest.getParam().getGoodsId());
taskQuery.setVehicleNo(tableRequest.getParam().getVehicleNo());
// 查找对应站台
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() > 0 && (Objects.equals(taskQuery.getTaskType(), TaskType.OUT.getCode()) || Objects.equals(taskQuery.getTaskType(), TaskType.INVENTORY.getCode()))) {
taskQuery.setPickStand(stands.get(0).getStandId());
}
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
feat(location): 根据托盘号进行分组; 从task表中查询出库入库记录;移库库位逻辑修改
2025-03-07 13:53:38 +08:00
List<Task> tasks = taskService.selTaskList(taskQuery);
新建
2024-07-04 07:43:04 +08:00
PageInfo<Task> taskPageInfo = new PageInfo<>(tasks);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询任务成功！");
tblResp.setRows(taskPageInfo.getList());
tblResp.setTotal(taskPageInfo.getTotal());
return JSON.toJSONString(tblResp);
}
/**
* 根据参数查询wms任务
*/
@PostMapping("/getTaskByTask")
@ResponseBody
public String getTaskByTask(@RequestBody Task request) {
ResponseEntity response = new ResponseEntity();
if (request == null) {
logger.error("请求参数为空");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("请求参数为空");
return JSON.toJSONString(response);
}
List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
if (stands.size() > 0) {
request.setPickStand(stands.get(0).getStandId());
} else {
request.setPickStand("other");
}
List<Task> tasks = taskService.selTasks(request);
response.setCode(ResponseCode.OK.getCode());
response.setMessage("成功");
response.setReturnData(tasks.size() > 0 ? tasks.get(0) : null);
return JSON.toJSONString(response);
}
}
Reference in New Issue Copy Permalink