1326 lines
70 KiB
Java
1326 lines
70 KiB
Java
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;
|
||
import com.wms.mapper.StockMapper;
|
||
import com.wms.mapper.TaskMapper;
|
||
import com.wms.entity.page.TableRequest;
|
||
import com.wms.entity.page.TableResponse;
|
||
import com.wms.entity.table.*;
|
||
import com.wms.constants.WmsConstants;
|
||
import com.wms.utils.storage.LocationUtils;
|
||
import com.wms.service.*;
|
||
import com.wms.utils.HttpUtils;
|
||
import com.wms.mapper.LocationMapper;
|
||
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 梁州
|
||
* @date 2023/2/14
|
||
*/
|
||
@Controller
|
||
@CrossOrigin
|
||
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
|
||
@RequestMapping(value = "/wms/task")
|
||
public class TaskController extends BaseController {
|
||
/**
|
||
* 任务服务
|
||
*/
|
||
private final TaskService taskService;
|
||
/**
|
||
* 任务 Mapper
|
||
*/
|
||
private final TaskMapper taskMapper;
|
||
/**
|
||
* 库存 Mapper
|
||
*/
|
||
private final StockMapper stockMapper;
|
||
/**
|
||
* 库存服务
|
||
*/
|
||
private final StockService stockService;
|
||
/**
|
||
* 库位操作类
|
||
*/
|
||
private final LocationUtils locationUtils;
|
||
|
||
/**
|
||
* 零件
|
||
*/
|
||
private final PartInfoService partInfoService;
|
||
/**
|
||
* 库位服务
|
||
*/
|
||
private final LocationService locationService;
|
||
/**
|
||
* 任务记录服务
|
||
*/
|
||
private final TaskRecordService taskRecordService;
|
||
/**
|
||
* 站台服务
|
||
*/
|
||
private final StandService standService;
|
||
/**
|
||
* 载具服务
|
||
*/
|
||
private final VehicleService vehicleService;
|
||
/**
|
||
* 请求头部信息
|
||
*/
|
||
private final HttpServletRequest servletRequest;
|
||
|
||
/**
|
||
* 订单入库 Mapper
|
||
*/
|
||
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
|
||
/**
|
||
* 库位 Mapper
|
||
*/
|
||
private final LocationMapper locationMapper;
|
||
/**
|
||
* 创建入库任务（人工入库）
|
||
*
|
||
* @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);
|
||
}
|
||
int needNum = taskOutRequest.getNeedNum();
|
||
// 生成任务
|
||
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) {
|
||
if (needNum <= 0){
|
||
break;
|
||
}
|
||
tempStock.setStockStatus(StockStatus.OUT.getCode());
|
||
needNum = needNum - tempStock.getRealNum();
|
||
stockService.modifyStock(tempStock);
|
||
}
|
||
// 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);
|
||
// }
|
||
// }
|
||
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"));
|
||
//task.setTaskId(UUID);
|
||
// 任务类型
|
||
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);
|
||
List<Task> tasks = taskService.selTaskList(taskQuery);
|
||
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);
|
||
}
|
||
} |