liangzhou/wms_server_miniload_bk7
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

代码暂存

Browse Source
This commit is contained in:
梁州 2024-06-28 17:01:43 +08:00
parent 9dca35ca43
commit c110325a11
38 changed files with 1328 additions and 754 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/java/com/wms/constants/enums/StockStatus.java
View File

@ -8,6 +8,7 @@ public enum StockStatus {
OUT(1, "出库中"),
INVENTORY(2, "盘点中"),
MOVE(3, "移库中"),
PICKING(4, "拣选中"),
LOCK(9, "库存锁定");
private final Integer code;

1
src/main/java/com/wms/constants/enums/TaskInValidationEnum.java
View File

@ -7,6 +7,7 @@ public enum TaskInValidationEnum {
OK(""),
NO_REQUEST_BODY("请求参数为空"),
NO_VEHICLE_ID("载具号为空"),
DUPLICATE_VEHICLE_ID("载具号重复入库"),
NO_IN_POINT("起点站台为空"),
ERROR_IN_POINT("错误的起点站台"),
NO_GOODS_ID("带料入库物料信息为空"),

2
src/main/java/com/wms/constants/enums/WmsTaskStatus.java
View File

@ -10,7 +10,7 @@ public enum WmsTaskStatus {
RUN(2, "任务开始执行"),
OUT_FINISHED(3, "出库完成"),
TRANS(4, "环线运输"),
PICKING(8, "键选中"),
PICKING(8, "拣选中"),
INVENTORY(9, "盘点中"),
FINISH(100, "任务完成"),
CANCEL(998, "任务取消"),

213
src/main/java/com/wms/controller/GoodsController.java
View File

@ -1,12 +1,22 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wms.annotation.MyLog;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.dto.GoodsDto;
import com.wms.entity.app.dto.PageDto;
import com.wms.entity.app.request.GoodsQuery;
import com.wms.entity.app.vo.GoodsVo;
import com.wms.entity.page.PageDomain;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.Goods;
import com.wms.service.GoodsService;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
@ -24,6 +34,8 @@ import org.springframework.web.bind.annotation.*;
import java.util.List;
import static com.wms.utils.StringUtils.convertJsonString;
/**
* WMS物料控制类
* @author 梁州
@ -48,31 +60,31 @@ public class GoodsController {
/**
* 查找所有物料
*/
@PostMapping("/getPartInfo")
@PostMapping("/getGoodsInfoByPage")
@ResponseBody
public String getPartInfo(@RequestBody TableRequest<GoodsDto, String> tableRequest){
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到查询物料数据请求：{}", JSON.toJSONString(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 orderByStr = "goodsId asc";
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String getGoodsInfoByPage(@RequestBody GoodsQuery goodsQuery){
logger.info("接收到查询物料数据请求：{}，请求ip：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
Page<Goods> page = goodsQuery.toMpPage();
Page<Goods> goodsPage = goodsService.page(page, new LambdaQueryWrapper<Goods>()
.like(StringUtils.isNotEmpty(goodsQuery.getGoodsId()), Goods::getGoodsId, goodsQuery.getGoodsId())
.like(StringUtils.isNotEmpty(goodsQuery.getGoodsName()), Goods::getGoodsName, goodsQuery.getGoodsName()));
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
List<GoodsDto> goodsList = goodsService.selGoods(tableRequest.getParam());
PageInfo<GoodsDto> goodsPageInfo = new PageInfo<>(goodsList);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询物料信息成功！");
tblResp.setRows(goodsPageInfo.getList());
tblResp.setTotal(goodsPageInfo.getTotal());
return JSON.toJSONString(tblResp);
PageDto<GoodsVo> pageDto = PageDto.of(goodsPage, goods -> BeanUtil.copyProperties(goods, GoodsVo.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询成功");
response.setReturnData(pageDto);
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询物料信息发生异常");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询物料发生异常");
return convertJsonString(response);
}
}
/**
@ -81,160 +93,151 @@ public class GoodsController {
* @param goods 物料信息
* @return 结果
*/
@PostMapping("/updatePartInfo")
@PostMapping("/updateGoodsInfo")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String updatePartInfo(@RequestBody GoodsDto goods) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到更新零件信息请求：{}", JSON.toJSONString(goods));
@MyLog(logTitle = "更新物料信息", logMethod = "updateGoodsInfo")
public String updateGoodsInfo(@RequestBody GoodsDto goods) {
logger.info("接收到更新物料信息请求：{}，请求ip：{}", convertJsonString(goods), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (StringUtils.isEmpty(goods.getGoodsId())) {// 物料编码为空，不执行
logger.error("请求物料编码为空");
logger.error("请求更新的物料编号为空");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求物料编码为空");
return JSON.toJSONString(rsp);
}
goodsService.modifyGoods(goods);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
rsp.setMessage("请求更新的物料编号为空");
return convertJsonString(rsp);
}
if (goodsService.update(BeanUtil.copyProperties(goods, Goods.class),
new LambdaUpdateWrapper<Goods>().eq(Goods::getGoodsId, goods.getGoodsId()))) {
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新物料信息成功");
return JSON.toJSONString(rsp);
} else {
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("更新物料信息失败");
}
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询物料发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("查询物料发生异常");
return convertJsonString(rsp);
}
}
/**
* 查询物料信息
* @param goods 参数
* @param goodsQuery 参数
* @return 结果
*/
@PostMapping("/queryPartInfoByPartNo")
@PostMapping("/getGoodsInfo")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String queryPartInfoByPartNo(@RequestBody GoodsDto goods) {
logger.info("前台查询物料数据");
public String getGoodsInfo(@RequestBody GoodsQuery goodsQuery) {
logger.info("接收到查询物料信息请求：{}，请求ip地址：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity rsp = new ResponseEntity();
if (goods == null || StringUtils.isEmpty(goods.getGoodsId())) {
logger.info("请求查询的参数为空");
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求查询的参数为空");
return JSON.toJSONString(rsp);
}
try {
GoodsDto goodsInfoNeed = goodsService.selGoodsByGoodsId(goods.getGoodsId());
if (goodsInfoNeed == null) {
logger.info("查询物料信息发生错误，物料编码：{}", goods.getGoodsId());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("查询的物料信息为空");
return JSON.toJSONString(rsp);
}
rsp.setReturnData(goodsInfoNeed);
logger.info("查询物料信息成功");
LambdaQueryWrapper<Goods> goodsLambdaQueryWrapper = new LambdaQueryWrapper<Goods>()
.eq(StringUtils.isNotEmpty(goodsQuery.getGoodsId()), Goods::getGoodsId, goodsQuery.getGoodsId())
.eq(StringUtils.isNotEmpty(goodsQuery.getGoodsName()), Goods::getGoodsName, goodsQuery.getGoodsName());
List<GoodsVo> goodsList = BeanUtil.copyToList(goodsService.list(goodsLambdaQueryWrapper), GoodsVo.class);
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("查询物料信息成功");
return JSON.toJSONString(rsp);
rsp.setReturnData(goodsList);
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("查询物料信息发生错误：{}", e.getMessage());
// 返回其他异常
logger.error("查询物料信息发生错误：{}", e.getMessage());
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
rsp.setMessage("查询物料发生异常");
return convertJsonString(rsp);
}
}
/**
* 自动补全物料编码信息
* @param goods 参数
* 自动补全物料编码信息---根据物料编号查询物料信息
* @param goodsQuery 参数
* @return 结果
*/
@PostMapping("/queryPartNo")
@PostMapping("/getGoodsInfoByGoodsId")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String queryPartNo(@RequestBody GoodsDto goods) {
public String getGoodsInfoByGoodsId(@RequestBody GoodsQuery goodsQuery) {
logger.info("接收到查询物料信息请求：{}，请求ip地址：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity rsp = new ResponseEntity();
if (goods == null || StringUtils.isEmpty(goods.getGoodsId())) {
logger.info("请求查询的参数为空");
if (goodsQuery == null || StringUtils.isEmpty(goodsQuery.getGoodsId())) {
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("请求查询的参数为空");
return JSON.toJSONString(rsp);
return convertJsonString(rsp);
}
try {
GoodsDto query = new GoodsDto();
query.setGoodsId(goods.getGoodsId());
List<GoodsDto> goodsInfoNeed = goodsService.selGoods(query);
if (goodsInfoNeed.size() == 0) {
logger.info("查询物料信息失败，物料编码：{}", goods.getGoodsId());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("查询物料信息为空");
return JSON.toJSONString(rsp);
}
rsp.setReturnData(goodsInfoNeed);
LambdaQueryWrapper<Goods> goodsLambdaQueryWrapper = new LambdaQueryWrapper<Goods>()
.like(Goods::getGoodsId, goodsQuery.getGoodsId());
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("查询成功");
rsp.setReturnData(goodsService.list(goodsLambdaQueryWrapper));
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("查询物料信息发生错误：{}", e.getMessage());
// 返回其他异常
logger.error("查询物料信息发生错误：{}", e.getMessage());
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
rsp.setMessage("查询物料发生异常");
return JSON.toJSONString(rsp);
}
logger.info("查询物料信息成功");
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("查询物料信息成功");
return JSON.toJSONString(rsp);
}
/**
* 删除当前物料信息
*
* @param goods 物料
* @param goodsQuery 待删除的物料
* @return 结果
*/
@PostMapping("/deletePartInfo")
@PostMapping("/deleteGoodsInfo")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String deleteVehicle(@RequestBody GoodsDto goods) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到更新物料信息请求：{}", JSON.toJSONString(goods));
@MyLog(logTitle = "删除物料信息", logMethod = "deleteGoodsInfo")
public String deleteVehicle(@RequestBody GoodsQuery goodsQuery) {
logger.info("接收到删除物料信息请求：{}，请求ip地址：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (StringUtils.isEmpty(goods.getGoodsId())) {// 物料编码为空，不做处理
if (StringUtils.isEmpty(goodsQuery.getGoodsId())) {// 物料编码为空，不做处理
logger.error("请求删除的物料编码为空");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求删除的物料编码为空");
return JSON.toJSONString(rsp);
return convertJsonString(rsp);
}
goodsService.deleteGoods(goods.getGoodsId());
// 返回成功
if (goodsService.remove(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, goodsQuery.getGoodsId()))) {
logger.info("删除物料信息成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("删除物料信息成功");
return JSON.toJSONString(rsp);
return convertJsonString(rsp);
} else {
// 返回其他异常
logger.error("删除物料信息成功");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("删除物料信息失败");
return convertJsonString(rsp);
}
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("发生异常：{}", e.getMessage());
logger.error("发生异常：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
rsp.setMessage("删除物料信息发生异常");
return convertJsonString(rsp);
}
}
}

182
src/main/java/com/wms/controller/JobComponent.java
View File

@ -1,11 +1,14 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.table.StockDto;
import com.wms.entity.table.TaskDto;
import com.wms.entity.table.WmsLogDto;
import com.wms.entity.app.dto.TaskDto;
import com.wms.entity.app.wcs.WcsTaskRequest;
import com.wms.entity.table.Task;
import com.wms.entity.table.WmsLog;
import com.wms.service.*;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
@ -18,6 +21,7 @@ import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import static com.wms.utils.StringUtils.convertJsonString;
import java.time.LocalDateTime;
import java.util.*;
import static com.wms.config.InitLocalConfig.configMap;
@ -48,63 +52,66 @@ public class JobComponent {
/**
* 每隔一秒检索一遍任务列表，同时向WCS下发任务
* 向Wcs下发任务
* 每2秒执行一次
*/
@Scheduled(fixedDelay = 1000)
@Scheduled(fixedDelay = 2000)
public void executeTasks() {
try {
// 检索任务列表，查询状态为等待状态的任务
TaskDto taskForQuery = new TaskDto();
taskForQuery.setTaskStatus(WmsTaskStatus.NEW.getCode());
List<TaskDto> tasks = taskService.selTasks(taskForQuery);
List<WcsTask> request = new ArrayList<>();
if (tasks.size() > 0) {// 存在等待中的任务
for (TaskDto task : tasks) {
if (StringUtils.isNotEmpty(task.getPreTask())) {// 该任务拥有前置任务，不下发
// 检索任务表---新建未下发的任务
LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode());
List<TaskDto> allTasks = BeanUtil.copyToList(taskService.list(waitForDistributeTaskQuery), TaskDto.class);
// 需要发送给wcs的任务列表
List<WcsTaskRequest> request = new ArrayList<>();
// 已经下发的任务组列表
List<String> taskGroupIds = new ArrayList<>();
if (!allTasks.isEmpty()) {
for (TaskDto task : allTasks) {
if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
// 查询一下前置的任务有没有存在，存在则不下发
List<TaskDto> preTasks = taskService.selTasks(new TaskDto(task.getPreTask()));
if (preTasks.size() > 0) {
if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
continue;
}
}
if (taskGroupIds.contains(task.getTaskGroup())) {
// 已经发送过的任务组，直接设置状态
task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
}
// 创建发送的任务
WcsTask tempTask = new WcsTask();
tempTask.setTaskId(task.getTaskId());
if (Objects.equals(task.getTaskType(), TaskType.INVENTORY_OUT.getCode())) {
WcsTaskRequest tempTask = new WcsTaskRequest();
tempTask.setTaskId(task.getTaskGroup());
if (Objects.equals(task.getTaskType(), TaskType.INVENTORY.getCode())) {
tempTask.setTaskType(TaskType.OUT.getCode());
} else if (Objects.equals(task.getTaskType(), TaskType.INVENTORY_IN.getCode())) {
tempTask.setTaskType(TaskType.IN.getCode());
} else {
tempTask.setTaskType(task.getTaskType());
}
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
tempTask.setVehicleNo(task.getVehicleNo());
tempTask.setVehicleNo(task.getVehicleId());
tempTask.setVehicleSize(task.getVehicleSize());
tempTask.setWeight(task.getWeight());
tempTask.setPriority(task.getTaskPriority());
request.add(tempTask);
task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
// 已经发送过的任务组
taskGroupIds.add(task.getTaskGroup());
}
if (request.size() == 0) {
return;
}
// 发送任务
String url = configMap.get("WCS_TASK");
String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
if (url != null) {
logger.info("向WCS发送任务，地址：{}，请求详情：{}", url, convertJsonString(request));
ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
try {
logService.addWmsLog(new WmsLogDto(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, new Date(), "WMS"));
logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
} catch (Exception e) {
logger.error("插入日志错误");
}
if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
// 更新任务列表
for (TaskDto task : tasks) {
// 更新任务
taskService.executeTask(task);
}
taskService.saveBatch(BeanUtil.copyToList(allTasks, Task.class));
} else {
if (result != null) {
logger.error("存在错误：{}", result.getMessage());
@ -117,67 +124,66 @@ public class JobComponent {
}
}
} catch (Exception exception) {
logger.error("发生异常：{}", convertJsonString(exception));
logger.error("查询等待任务发生异常：{}", convertJsonString(exception));
}
}
/**
* 每天查询一次是否有过期的库存
* 每天晚上8点执行一次
*/
// @Scheduled(cron = "0 0 20 * * ?")
public void detectOutOfDateStock() {
logger.info("执行定时任务：查询过期库存");
List<StockDto> outOfDateStocks = stockService.selStockOutOfDate();
if (outOfDateStocks.size() > 0) {
logger.info("过期库存数量不为0，准备更新过期库存");
for (StockDto outOfDateStock : outOfDateStocks) {
try {
outOfDateStock.setGoodsStatus(GoodsStatus.OVERDUE.getCode());
stockService.modifyStock(outOfDateStock);
logger.info("过期库存更新成功");
} catch (Exception e) {
logger.error("过期库存更新异常：{}", e.getMessage());
}
}
}
}
/**
* TODO 更新呆滞时间
* 每天查询一次是否有入库后长期未使用的库存
* 每天晚上9点执行一次
*/
// @Scheduled(cron = "0 0 21 * * ?")
public void detectStockLongTimeNoUse() {
logger.info("执行定时任务：查询是否有入库后长期未使用的库存");
List<StockDto> stocksLongTimeNoUse = stockService.selStockLongTimeNoUse(7);
if (stocksLongTimeNoUse.size() > 0) {
logger.info("有入库后长期未使用的库存, 准备更新库存状态");
for (StockDto stockLongTimeNoUse : stocksLongTimeNoUse) {
try {
stockLongTimeNoUse.setGoodsStatus(GoodsStatus.SCRAP.getCode());
stockService.modifyStock(stockLongTimeNoUse);
logger.info("长时间未使用库存状态更新成功");
} catch (Exception e) {
logger.error("长时间未使用库存状态更新异常：{}", e.getMessage());
}
}
}
}
/**
* 每天查询一次是否有过期记录
* 每天晚上10点执行一次
*/
// @Scheduled(cron = "0 0 22 * * ?")
public void deleteOutOfDateData() {
logger.info("执行定时任务：删除过期数据");
taskRecordService.deleteTaskRecordRegularly();
if (logService.deleteWmsLogsRegularly(90)) {
logger.info("删除过期日志数据成功");
} else {
logger.info("删除过期日志数据失败");
}
}
// /**
// * 每天查询一次是否有过期的库存
// * 每天晚上8点执行一次
// */
//// @Scheduled(cron = "0 0 20 * * ?")
// public void detectOutOfDateStock() {
// logger.info("执行定时任务：查询过期库存");
// List<StockDto> outOfDateStocks = stockService.selStockOutOfDate();
// if (outOfDateStocks.size() > 0) {
// logger.info("过期库存数量不为0，准备更新过期库存");
// for (StockDto outOfDateStock : outOfDateStocks) {
// try {
// outOfDateStock.setGoodsStatus(GoodsStatus.OVERDUE.getCode());
// stockService.modifyStock(outOfDateStock);
// logger.info("过期库存更新成功");
// } catch (Exception e) {
// logger.error("过期库存更新异常：{}", e.getMessage());
// }
// }
// }
// }
//
// /**
// * 每天查询一次是否有入库后长期未使用的库存
// * 每天晚上9点执行一次
// */
//// @Scheduled(cron = "0 0 21 * * ?")
// public void detectStockLongTimeNoUse() {
// logger.info("执行定时任务：查询是否有入库后长期未使用的库存");
// List<StockDto> stocksLongTimeNoUse = stockService.selStockLongTimeNoUse(7);
// if (stocksLongTimeNoUse.size() > 0) {
// logger.info("有入库后长期未使用的库存, 准备更新库存状态");
// for (StockDto stockLongTimeNoUse : stocksLongTimeNoUse) {
// try {
// stockLongTimeNoUse.setGoodsStatus(GoodsStatus.SCRAP.getCode());
// stockService.modifyStock(stockLongTimeNoUse);
// logger.info("长时间未使用库存状态更新成功");
// } catch (Exception e) {
// logger.error("长时间未使用库存状态更新异常：{}", e.getMessage());
// }
// }
// }
// }
//
// /**
// * 每天查询一次是否有过期记录
// * 每天晚上10点执行一次
// */
//// @Scheduled(cron = "0 0 22 * * ?")
// public void deleteOutOfDateData() {
// logger.info("执行定时任务：删除过期数据");
// taskRecordService.deleteTaskRecordRegularly();
// if (logService.deleteWmsLogsRegularly(90)) {
// logger.info("删除过期日志数据成功");
// } else {
// logger.info("删除过期日志数据失败");
// }
// }
}

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

@ -1,21 +1,18 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wms.annotation.MyLog;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.dto.VehicleDto;
import com.wms.entity.app.dto.extend.VehicleDetailInfo;
import com.wms.entity.app.vo.LayerLocation;
import com.wms.entity.app.dto.PageDto;
import com.wms.entity.app.request.LocationQuery;
import com.wms.entity.app.request.VehicleQuery;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.vo.RowLocation;
import com.wms.entity.page.PageDomain;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.LocationDto;
import com.wms.entity.app.vo.VehicleVO;
import com.wms.entity.table.Location;
import com.wms.entity.table.Vehicle;
import com.wms.entity.table.VehicleDto;
import com.wms.constants.enums.LocationStatus;
import com.wms.service.LocationService;
import com.wms.service.VehicleService;
import com.wms.utils.HttpUtils;
@ -32,7 +29,7 @@ import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import static com.wms.utils.StringUtils.convertJsonString;
/**
* WMS库位控制类
@ -60,248 +57,234 @@ public class LocationController {
private final HttpServletRequest servletRequest;
/**
* 查询库位
*
* @param location 查询参数
* @return 结果
*/
@PostMapping("/getLocations")
@ResponseBody
public String getLocations(@RequestBody LocationDto location) {
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 查询出所有符合条件的库位
List<LocationDto> locations = locationService.selLocations(location);
if (locations.size() < 1) {
logger.error("查询库位发生错误：库位不存在");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("查询库位发生错误：库位不存在");
return JSON.toJSONString(rsp);
}
List<RowLocation> rowLocations = new LinkedList<>();
// 查找到最大的排
locations.sort(Comparator.comparing(LocationDto::getQueue).reversed());
int maxRow = locations.get(0).getQueue();
// 按排查找库位
for (int i = 0; i < maxRow; i++) {
int finalI = i;
List<LocationDto> currentRowLocations = new ArrayList<>(locations.stream()
.filter(l -> l.getQueue().equals(finalI + 1))
.toList());
// 先查找每一层的库位
List<LayerLocation> layerLocations = new LinkedList<>();
// 找到这一排最大的层
currentRowLocations.sort(Comparator.comparing(LocationDto::getLayer).reversed());
int maxLayer = currentRowLocations.get(0).getLayer();
// 按照每一列查找库位
for (int j = 0; j < maxLayer; j++) {
int finalJ = j;
List<LocationDto> currentLayerLocations = currentRowLocations.stream()
.filter(l -> l.getLayer().equals(finalJ + 1))
.toList();
LayerLocation tempLayerLocation = new LayerLocation();
tempLayerLocation.setLayer(finalJ + 1);
tempLayerLocation.setCurrentColLocations(currentLayerLocations);
layerLocations.add(tempLayerLocation);
}
RowLocation tempRowLocation = new RowLocation();
tempRowLocation.setRow(finalI + 1);
tempRowLocation.setCurrentLayerLocations(layerLocations);
rowLocations.add(tempRowLocation);
}
logger.info("查询库位数据成功，库区：{}", location.getAreaId());
// 设置最终数据
rsp.setReturnData(rowLocations);
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("查询库位成功");
return JSON.toJSONString(rsp);
} catch (Exception e) {
logger.info("查询库位发生错误：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
}
// /**
// * 查询库位
// *
// * @param locationQuery 查询参数
// * @return 结果
// */
// @PostMapping("/getLocations")
// @ResponseBody
// @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
// @MyLog(logTitle = "删除物料信息", logMethod = "getLocations")
// public String getLocations(@RequestBody LocationQuery locationQuery) {
// // 创建响应信息
// ResponseEntity rsp = new ResponseEntity();
// try {
// // 查询出所有符合条件的库位
// List<LocationDto> locations = locationService.selLocations(location);
// if (locations.size() < 1) {
// logger.error("查询库位发生错误：库位不存在");
// // 返回错误
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("查询库位发生错误：库位不存在");
// return JSON.toJSONString(rsp);
// }
// List<RowLocation> rowLocations = new LinkedList<>();
// // 查找到最大的排
// locations.sort(Comparator.comparing(LocationDto::getQueue).reversed());
// int maxRow = locations.get(0).getQueue();
// // 按排查找库位
// for (int i = 0; i < maxRow; i++) {
// int finalI = i;
// List<LocationDto> currentRowLocations = new ArrayList<>(locations.stream()
// .filter(l -> l.getQueue().equals(finalI + 1))
// .toList());
// // 先查找每一层的库位
// List<LayerLocation> layerLocations = new LinkedList<>();
// // 找到这一排最大的层
// currentRowLocations.sort(Comparator.comparing(LocationDto::getLayer).reversed());
// int maxLayer = currentRowLocations.get(0).getLayer();
// // 按照每一列查找库位
// for (int j = 0; j < maxLayer; j++) {
// int finalJ = j;
// List<LocationDto> currentLayerLocations = currentRowLocations.stream()
// .filter(l -> l.getLayer().equals(finalJ + 1))
// .toList();
// LayerLocation tempLayerLocation = new LayerLocation();
// tempLayerLocation.setLayer(finalJ + 1);
// tempLayerLocation.setCurrentColLocations(currentLayerLocations);
// layerLocations.add(tempLayerLocation);
// }
// RowLocation tempRowLocation = new RowLocation();
// tempRowLocation.setRow(finalI + 1);
// tempRowLocation.setCurrentLayerLocations(layerLocations);
// rowLocations.add(tempRowLocation);
// }
// logger.info("查询库位数据成功，库区：{}", location.getAreaId());
// // 设置最终数据
// rsp.setReturnData(rowLocations);
// // 返回成功
// rsp.setCode(ResponseCode.OK.getCode());
// rsp.setMessage("查询库位成功");
// return JSON.toJSONString(rsp);
// } catch (Exception e) {
// logger.info("查询库位发生错误：{}", e.getMessage());
// // 返回其他异常
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage(e.getMessage());
// return JSON.toJSONString(rsp);
// }
// }
/**
* 更新库位状态
* 更新库位信息
*
* @param location 库位
* @param locationQuery 库位
* @return 结果
*/
@PostMapping("/updateLocation")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String updateLocation(@RequestBody LocationDto location) {
@MyLog(logTitle = "更新库位信息", logMethod = "updateLocation")
public String updateLocation(@RequestBody LocationQuery locationQuery) {
logger.info("接收到更新库位信息请求：{}，请求ip地址：{}", convertJsonString(locationQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
locationService.modifyLocation(location);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("更新库位状态发生错误：{}", e.getMessage());
// 返回其他异常
if (StringUtils.isEmpty(locationQuery.getLocationId())) {
logger.error("缺少库位编号");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
rsp.setMessage("缺少库位编号！");
return convertJsonString(rsp);
}
if (locationService.update(locationQuery.toLocationPO(), new LambdaQueryWrapper<Location>().eq(Location::getLocationId, locationQuery.getLocationId()))) {
// 返回成功
logger.info("更新库位信息成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新库位状态成功");
return JSON.toJSONString(rsp);
rsp.setMessage("更新库位信息成功");
} else {
// 返回失败
logger.error("更新库位信息失败");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("更新库位信息失败");
}
/**
* 更新库位状态
*
* @param location 库位
* @return 结果
*/
@PostMapping("/getAvailableLocations")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String getAvailableLocations(@RequestBody LocationDto location) {
logger.info("查询空闲可用库位");
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
LocationDto locationQuery = new LocationDto();
locationQuery.setAreaId(location.getAreaId());
locationQuery.setLocationStatus(LocationStatus.EMPTY.getCode());
locationQuery.setIsLock(0);
List<LocationDto> availableLocations = locationService.selLocations(locationQuery);
rsp.setReturnData(availableLocations);
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("查询可用库位错误：{}", e.getMessage());
logger.info("更新库位信息发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
rsp.setMessage("Exception Occurred: 发生异常");
return convertJsonString(rsp);
}
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("查询可用库位成功");
return JSON.toJSONString(rsp);
}
/**
* 查询料箱信息
* @param tableRequest 请求
* @param vehicleQuery 查询参数
* @return 结果
*/
@PostMapping("/getVehicles")
@PostMapping("/getVehiclesByPage")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String getVehicles(@RequestBody TableRequest<VehicleDto, String> tableRequest) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到查询料箱请求：{}", JSON.toJSONString(tableRequest));
TableResponse tblResp = new TableResponse();
// 解析请求数据
if (tableRequest == null || tableRequest.getPage() == null) {
tblResp.setCode(ResponseCode.ERROR.getCode());
tblResp.setMessage("请求数据为空，无法处理！");
logger.error("请求数据为空，无法处理！");
return JSON.toJSONString(tblResp);
@MyLog(logTitle = "查询载具信息", logMethod = "getVehiclesByPage")
public String getVehiclesByPage(@RequestBody VehicleQuery vehicleQuery) {
logger.info("接收到查询载具信息请求：{}，请求ip：{}", convertJsonString(vehicleQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
Page<Vehicle> page = vehicleQuery.toMpPage();
Page<Vehicle> vehiclePage = vehicleService.page(page, new LambdaQueryWrapper<Vehicle>()
.like(StringUtils.isNotEmpty(vehicleQuery.getVehicleId()), Vehicle::getVehicleId, vehicleQuery.getVehicleId())
.eq(vehicleQuery.getVehicleStatus() == null, Vehicle::getVehicleStatus, vehicleQuery.getVehicleStatus())
.eq(vehicleQuery.getIsEmpty() == null, Vehicle::getIsEmpty, vehicleQuery.getIsEmpty()));
PageDto<VehicleVO> pageDto = PageDto.of(vehiclePage, vehicle -> BeanUtil.copyProperties(vehicle, VehicleVO.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询成功");
response.setReturnData(pageDto);
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询载具信息发生异常");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询载具信息发生异常");
return convertJsonString(response);
}
// 处理分页信息
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 = "";
// }
Vehicle<VehicleDetailInfo> vehicleQuery = new Vehicle<>();
vehicleQuery.setVehicleId(tableRequest.getParam().getVehicleId());
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
List<VehicleDto<VehicleDetailInfo>> vehicles = vehicleService.selVehicles(vehicleQuery);
PageInfo<VehicleDto> vehiclePageInfo = new PageInfo<>(vehicles);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询料箱成功！");
tblResp.setRows(vehiclePageInfo.getList());
tblResp.setTotal(vehiclePageInfo.getTotal());
return JSON.toJSONString(tblResp);
}
/**
* 更新料箱信息
*
* @param vehicle 料箱
* @param vehicleQuery 料箱
* @return 结果
*/
@PostMapping("/updateVehicleInfo")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String updateVehicleInfo(@RequestBody VehicleDto vehicle) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到更新料箱信息请求：{}", JSON.toJSONString(vehicle));
@MyLog(logTitle = "更新载具信息", logMethod = "updateVehicleInfo")
public String updateVehicleInfo(@RequestBody VehicleQuery vehicleQuery) {
logger.info("接收到更新载具信息信息请求：{}，请求ip：{}", convertJsonString(vehicleQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (StringUtils.isEmpty(vehicle.getVehicleId())) {// 箱号为空，不执行
logger.error("请求箱号为空");
if (StringUtils.isEmpty(vehicleQuery.getVehicleId())) {// 载具号为空
logger.error("缺少载具号");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求箱号为空");
return JSON.toJSONString(rsp);
rsp.setMessage("缺少载具号");
return convertJsonString(rsp);
}
vehicleService.modifyVehicle(vehicle);
if (vehicleService.update(vehicleQuery.toVehiclePO(), new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, vehicleQuery.getVehicleId()))) {
// 返回成功
logger.info("更新载具信息成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新载具信息成功");
} else {
// 返回失败
logger.error("更新载具信息失败");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("更新载具信息失败");
}
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("发生异常：{}", e.getMessage());
logger.info("更新载具信息发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
rsp.setMessage("更新载具信息发生异常");
return JSON.toJSONString(rsp);
}
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新料箱信息成功");
return JSON.toJSONString(rsp);
}
/**
* 删除当前料箱信息
*
* @param vehicle 料箱
* @param vehicleQuery 料箱
* @return 结果
*/
@PostMapping("/deleteVehicle")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String deleteVehicle(@RequestBody VehicleDto vehicle) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到更新料箱信息请求：{}", JSON.toJSONString(vehicle));
@MyLog(logTitle = "删除载具信息", logMethod = "deleteVehicle")
public String deleteVehicle(@RequestBody VehicleQuery vehicleQuery) {
logger.info("接收到删除载具信息信息请求：{}，请求ip：{}", convertJsonString(vehicleQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (StringUtils.isEmpty(vehicle.getVehicleId())) {// 箱号为空，不执行
logger.error("请求箱号为空");
if (StringUtils.isEmpty(vehicleQuery.getVehicleId())) {// 箱号为空，不执行
logger.error("缺少载具号");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求箱号为空");
return JSON.toJSONString(rsp);
rsp.setMessage("缺少载具号");
return convertJsonString(rsp);
}
// 判断当前料箱是不是空箱，带料不允许删除
VehicleDto currentVehicle = vehicleService.selVehicleById(vehicle.getVehicleId());
if (currentVehicle != null && currentVehicle.getIsEmpty() != 1) {// 非空箱
logger.error("非空箱不允许删除");
if (vehicleService.remove(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, vehicleQuery.getVehicleId()))) {
// 返回成功
logger.info("删除载具成功");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("删除载具成功");
} else {
// 返回失败
logger.error("删除载具失败");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("非空箱不允许删除");
return JSON.toJSONString(rsp);
rsp.setMessage("删除载具失败");
}
vehicleService.deleteVehicle(vehicle);
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@ -311,9 +294,5 @@ public class LocationController {
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
}
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("删除料箱成功");
return JSON.toJSONString(rsp);
}
}

86
src/main/java/com/wms/controller/RecordController.java
View File

@ -1,15 +1,25 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.dto.PageDto;
import com.wms.entity.app.request.GoodsQuery;
import com.wms.entity.app.request.TaskRecordQuery;
import com.wms.entity.app.vo.GoodsVo;
import com.wms.entity.app.vo.TaskRecordVO;
import com.wms.entity.page.PageDomain;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.TaskDto;
import com.wms.entity.table.Goods;
import com.wms.entity.table.TaskRecord;
import com.wms.service.TaskRecordService;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
@ -19,10 +29,13 @@ 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.List;
import static com.wms.utils.StringUtils.convertJsonString;
/**
* WMS记录控制类
*
@ -45,49 +58,36 @@ public class RecordController {
private final HttpServletRequest servletRequest;
/**
* 查询任务记录
*
* @param tableRequest 请求
* @return 结果
* 查找所有物料
*/
@PostMapping("/getTaskRecords")
@PostMapping("/getTaskRecordByPage")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String getVehicles(@RequestBody TableRequest<TaskDto, String> tableRequest) {
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到查询任务记录请求：{}", JSON.toJSONString(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 = "";
// }
TaskDto taskRecordQuery = new TaskDto();
taskRecordQuery.setTaskType(tableRequest.getParam().getTaskType());
taskRecordQuery.setGoodsType(tableRequest.getParam().getGoodsType());
taskRecordQuery.setSpecification(tableRequest.getParam().getSpecification());
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
List<TaskDto> records = taskRecordService.selTasks(taskRecordQuery);
PageInfo<TaskDto> taskRecordPageInfo = new PageInfo<>(records);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询任务记录成功！");
tblResp.setRows(taskRecordPageInfo.getList());
tblResp.setTotal(taskRecordPageInfo.getTotal());
return JSON.toJSONString(tblResp);
public String getGoodsInfoByPage(@RequestBody TaskRecordQuery taskRecordQuery){
logger.info("接收到查询任务记录请求：{}，请求ip：{}", convertJsonString(taskRecordQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
Page<TaskRecord> page = taskRecordQuery.toMpPage();
//更新条件
LambdaQueryWrapper<TaskRecord> lambdaQueryWrapper = new LambdaQueryWrapper<TaskRecord>()
.eq(taskRecordQuery.getTaskType() != null, TaskRecord::getTaskType, taskRecordQuery.getTaskType())
.like(StringUtils.isNotEmpty(taskRecordQuery.getVehicleId()), TaskRecord::getVehicleId, taskRecordQuery.getVehicleId())
.apply(StringUtils.isNotEmpty(taskRecordQuery.getGoodsId()), "goods_related ->> '$.goodsId' like concat('%', {0}, '%')", taskRecordQuery.getGoodsId())
.apply(StringUtils.isNotEmpty(taskRecordQuery.getGoodsName()), "goods_related ->> '$.goodsName' like concat('%', {0}, '%')", taskRecordQuery.getGoodsName());
Page<TaskRecord> taskRecordPage = taskRecordService.page(page, lambdaQueryWrapper);
// 生成数据
PageDto<TaskRecordVO> pageDto = PageDto.of(taskRecordPage, records -> BeanUtil.copyProperties(records, TaskRecordVO.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询成功");
response.setReturnData(pageDto);
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询物料信息发生异常");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询物料发生异常");
return convertJsonString(response);
}
}
}

144
src/main/java/com/wms/controller/StandController.java
View File

@ -1,17 +1,27 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wms.annotation.MyLog;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.dto.GoodsDto;
import com.wms.entity.app.dto.PageDto;
import com.wms.entity.app.request.GoodsQuery;
import com.wms.entity.app.request.StandQuery;
import com.wms.entity.app.vo.GoodsVo;
import com.wms.entity.page.PageDomain;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.StandDto;
import com.wms.entity.table.Goods;
import com.wms.service.StandService;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
@ -26,6 +36,8 @@ import org.springframework.web.bind.annotation.*;
import java.util.List;
import static com.wms.utils.StringUtils.convertJsonString;
/**
* 站台控制类
*/
@ -45,92 +57,74 @@ public class StandController {
private final HttpServletRequest servletRequest;
/**
* 查询可用站台列表
* @return 符合条件的站台列表
* 查找所有站台信息
*/
@PostMapping("/getAllStands")
@ResponseBody
public List<StandDto> getAllStands(@RequestBody JSONObject type){
logger.info("查询站台{}", JSON.toJSONString(type));
int type_int = type.getIntValue("type");
StandDto query = new StandDto();
if (type_int == 1) {// 入库站台
query.setAllowIn(1);
} else if (type_int == 2) {// 出库站台
query.setAllowOut(1);
} else if (type_int == 3) {// 盘点站台
query.setAllowIn(1);
query.setAllowOut(1);
}
return standService.selStands(query);
}
/**
* 更新站台状态
*
* @param stand 站台
* @return 结果
*/
@PostMapping("/updateStandInfo")
@PostMapping("/getStandsByPage")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String updateStandInfo(@RequestBody StandDto stand) {
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
public String getStandsByPage(@RequestBody StandQuery standQuery){
logger.info("接收到查询物料数据请求：{}，请求ip：{}", convertJsonString(standQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
standService.modifyStand(stand);
Page<Goods> page = goodsQuery.toMpPage();
Page<Goods> goodsPage = goodsService.page(page, new LambdaQueryWrapper<Goods>()
.like(StringUtils.isNotEmpty(goodsQuery.getGoodsId()), Goods::getGoodsId, goodsQuery.getGoodsId())
.like(StringUtils.isNotEmpty(goodsQuery.getGoodsName()), Goods::getGoodsName, goodsQuery.getGoodsName()));
PageDto<GoodsVo> pageDto = PageDto.of(goodsPage, goods -> BeanUtil.copyProperties(goods, GoodsVo.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询成功");
response.setReturnData(pageDto);
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("更新站台信息发生错误：{}", e.getMessage());
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
return JSON.toJSONString(rsp);
logger.error("查询物料信息发生异常");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询物料发生异常");
return convertJsonString(response);
}
logger.info("更新站台信息成功：{}", stand.toLoggerString());
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新站台信息成功");
return JSON.toJSONString(rsp);
}
/**
* 查找所有库存
* 更新物料信息
*
* @param goods 物料信息
* @return 结果
*/
@PostMapping("/getStands")
@PostMapping("/updateGoodsInfo")
@ResponseBody
public String getStands(@RequestBody TableRequest<StandDto, String> tableRequest){
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest));
logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest));
TableResponse tblResp = new TableResponse();
// 解析请求数据
if (tableRequest == null || tableRequest.getPage() == null) {
tblResp.setCode(ResponseCode.ERROR.getCode());
tblResp.setMessage("请求数据为空，无法处理！");
logger.error("请求数据为空，无法处理！");
return JSON.toJSONString(tblResp);
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "更新物料信息", logMethod = "updateGoodsInfo")
public String updateGoodsInfo(@RequestBody GoodsDto goods) {
logger.info("接收到更新物料信息请求：{}，请求ip：{}", convertJsonString(goods), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (StringUtils.isEmpty(goods.getGoodsId())) {// 物料编码为空，不执行
logger.error("请求更新的物料编号为空");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("请求更新的物料编号为空");
return convertJsonString(rsp);
}
if (goodsService.update(BeanUtil.copyProperties(goods, Goods.class),
new LambdaUpdateWrapper<Goods>().eq(Goods::getGoodsId, goods.getGoodsId()))) {
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新物料信息成功");
} else {
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("更新物料信息失败");
}
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询物料发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("查询物料发生异常");
return convertJsonString(rsp);
}
// 处理分页信息
PageDomain pageRequest = tableRequest.getPage();
// String[] orderByArr = {"location_id", "vehicle_id", "goods_id", "batch_no", "remain_num", "expiration_date", "create_time"};
String orderByStr = "";
// if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
// orderByStr = pageRequest.getOrderBy();
// } else {
// // 默认排序
// orderByStr = "expiration_date desc";
// }
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
List<StandDto> stands = standService.selStands(tableRequest.getParam());
PageInfo<StandDto> standPageInfo = new PageInfo<>(stands);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询库存成功！");
tblResp.setRows(standPageInfo.getList());
tblResp.setTotal(standPageInfo.getTotal());
logger.info("查询库存成功，总数：{}，当前页：{}，当前页数量：{}", standPageInfo.getTotal(), standPageInfo.getPageNum(), standPageInfo.getPageSize());
return JSON.toJSONString(tblResp);
}
}

11
src/main/java/com/wms/controller/SystemController.java
View File

@ -1,9 +1,8 @@
package com.wms.controller;
import com.alibaba.fastjson2.JSON;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.table.UserDto;
import com.wms.entity.app.request.UserQuery;
import com.wms.system_service.ISystemService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
@ -37,14 +36,14 @@ public class SystemController {
@PostMapping("/restartSystem")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String restartSystem(@RequestBody UserDto user) {
public String restartSystem(@RequestBody UserQuery user) {
logger.info("接收到重启系统请求：{}", convertJsonString(user));
ResponseEntity response = new ResponseEntity();
if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启
logger.error("非管理员不允许重启");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("非管理员不允许重启");
return JSON.toJSONString(convertJsonString(response));
return convertJsonString(response);
}
if (systemService.restartSystem()) {
logger.info("重启成功");
@ -67,14 +66,14 @@ public class SystemController {
@PostMapping("/reloadConfig")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String reloadConfig(@RequestBody UserDto user) {
public String reloadConfig(@RequestBody UserQuery user) {
logger.info("接收到重载配置请求：{}", convertJsonString(user));
ResponseEntity response = new ResponseEntity();
if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启
logger.error("非管理员不允许重载配置");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("非管理员不允许重载配置");
return JSON.toJSONString(convertJsonString(response));
return convertJsonString(response);
}
if (systemService.reloadConfig()) {
logger.info("重载配置成功");

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

@ -8,6 +8,7 @@ import com.wms.annotation.MyLog;
import com.wms.constants.enums.*;
import com.wms.entity.app.*;
import com.wms.entity.app.dto.TaskDto;
import com.wms.entity.app.dto.extend.StockDetailInfo;
import com.wms.entity.app.dto.extend.TaskDetailInfo;
import com.wms.entity.app.dto.extend.VehicleDetailInfo;
import com.wms.entity.app.request.GoodsInRequest;
@ -272,7 +273,18 @@ public class TaskController {
return TaskInValidationEnum.NO_VEHICLE_ID.getErrorMessage();
}
// 验证载具号是否重复入库
// TODO
if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, taskInRequest.getVehicleId())
.and(wrapper -> {
wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
.or().eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode());
}))) {
return TaskInValidationEnum.DUPLICATE_VEHICLE_ID.getErrorMessage();
}
// 验证当前载具是否已经有入库任务
if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getVehicleId, taskInRequest.getVehicleId())
.and(wrapper -> wrapper.eq(Task::getTaskType, TaskType.IN.getCode())))) {
return TaskInValidationEnum.DUPLICATE_VEHICLE_ID.getErrorMessage();
}
// 验证重量
if (taskInRequest.getTotalWeight() == null) {
return TaskInValidationEnum.NO_WEIGHT.getErrorMessage();
@ -678,83 +690,155 @@ public class TaskController {
int taskStatus = wcsTaskResultRequest.getTaskStatus();
// 判断任务状态
if (taskStatus == WcsTaskStatus.FINISH.getCode()) {// 任务完成
// TODO 入库任务完成
// 入库任务完成
if (taskType == TaskType.IN.getCode()) {
// 对所有任务组里面的移库任务进行处理
// 对所有任务组里面的入库任务进行处理
for (Task inTask : feedBackTasks) {
if (!Objects.equals(inTask.getTaskType(), TaskType.IN.getCode())) {
// 非入库任务跳过
continue;
}
//
// 更新库存
LambdaUpdateWrapper<Stock> lambdaUpdateWrapperOfStock = new LambdaUpdateWrapper<Stock>()
.set(Stock::getLocationId, moveTask.getDestination())
.set(Stock::getStockStatus, StockStatus.OK.getCode())
.set(Stock::getLastUpdateTime, LocalDateTime.now())
.set(Stock::getLastUpdateUser, moveTask.getUserName())
.eq(Stock::getVehicleId, moveTask.getVehicleId())
.eq(Stock::getStockStatus, StockStatus.MOVE.getCode());
stockService.update(lambdaUpdateWrapperOfStock);
// 当前载具是否有移库任务
boolean haveMoveTask = taskService.exists(new LambdaQueryWrapper<Task>()
.eq(Task::getVehicleId, inTask.getVehicleId())
.eq(Task::getTaskType, TaskType.MOVE.getCode()));
// 如果是入库
if (inTask.getTaskId().startsWith("RK")) {
// 添加库存
if (inTask.getGoodsRelated() != null && !inTask.getGoodsRelated().getGoodsId().isEmpty()) {
// 查询这个物料有没有库存
// TODO 查询条件根据项目要求调整
Stock existStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
.apply("goods_related -> '$.goodsId' = {0}", inTask.getGoodsRelated().getGoodsId())
.eq(Stock::getVehicleId, inTask.getVehicleId()));
if (existStock != null) {
// 已有库存，直接更新数量
existStock.getGoodsRelated().setRemainNum(existStock.getGoodsRelated().getRemainNum().add(inTask.getGoodsRelated().getOpNum()));
existStock.getGoodsRelated().setTotalNum(existStock.getGoodsRelated().getTotalNum().add(inTask.getGoodsRelated().getOpNum()));
existStock.setLastUpdateTime(LocalDateTime.now());
existStock.setLastUpdateUser(inTask.getUserName());
existStock.setLocationId(inTask.getDestination());
stockService.update(existStock, new LambdaUpdateWrapper<Stock>().eq(Stock::getStockId, existStock.getStockId()));
} else {
Stock newStock = new Stock();
newStock.setStockId(generateId("ST_"));
newStock.setVehicleId(inTask.getVehicleId());
newStock.setLocationId(inTask.getDestination());
newStock.setNoUseDays(0);
newStock.setIsInventory(0);
newStock.setCreateTime(LocalDateTime.now());
newStock.setWeight(inTask.getWeight());
newStock.setLastUpdateUser(inTask.getUserName());
StockDetailInfo detailInfo = new StockDetailInfo();
detailInfo.setGoodsId(inTask.getGoodsRelated().getGoodsId());
detailInfo.setGoodsName(inTask.getGoodsRelated().getGoodsName());
detailInfo.setGoodsStatus(GoodsStatus.OK.getCode());
detailInfo.setRemainNum(inTask.getGoodsRelated().getOpNum());
detailInfo.setTotalNum(inTask.getGoodsRelated().getOpNum());
newStock.setGoodsRelated(detailInfo);
stockService.save(newStock);
}
}
}
// 更新库存状态
List<Stock> backStocks = stockService.list(new LambdaQueryWrapper<Stock>()
.eq(Stock::getVehicleId, inTask.getVehicleId()));
backStocks.forEach(stock -> {
if (haveMoveTask) {
// 后续有移库
stock.setStockStatus(StockStatus.MOVE.getCode());
} else {
// 后续没有移库
stock.setStockStatus(StockStatus.OK.getCode());
}
stock.setLastUpdateTime(LocalDateTime.now());
stock.setLastUpdateUser(inTask.getUserName());
stockService.update(stock, new LambdaUpdateWrapper<Stock>().eq(Stock::getStockId, stock.getStockId()));
});
// 当前载具
Vehicle currentVehicle = vehicleService.getOne(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, inTask.getVehicleId()));
if (currentVehicle == null) {
// 添加载具
Vehicle newVehicle = new Vehicle();
newVehicle.setVehicleId(inTask.getVehicleId());
newVehicle.setVehicleType(1);
newVehicle.setVehicleStatus(VehicleStatus.ON.getCode());
newVehicle.setCurrentLocation(inTask.getDestination());
if (haveMoveTask) {
newVehicle.setVehicleStatus(VehicleStatus.MOVE.getCode());
} else {
newVehicle.setVehicleStatus(VehicleStatus.ON.getCode());
}
boolean haveStocks = stockService.exists(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, inTask.getVehicleId()));
if (haveStocks) {
newVehicle.setIsEmpty(0);
} else {
newVehicle.setIsEmpty(1);
}
vehicleService.save(newVehicle);
} else {
// 更新载具
LambdaUpdateWrapper<Vehicle> lambdaUpdateWrapperOfVehicle = new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
.set(Vehicle::getCurrentLocation, moveTask.getDestination())
.eq(Vehicle::getVehicleId, moveTask.getVehicleId())
.eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode());
vehicleService.update(lambdaUpdateWrapperOfVehicle);
// 释放原来的库位
LambdaUpdateWrapper<Location> lambdaUpdateWrapperOfLocation = new LambdaUpdateWrapper<Location>()
.set(Location::getLocationStatus, LocationStatus.EMPTY.getCode())
.set(Location::getVehicleId, "")
.eq(Location::getLocationId, moveTask.getOrigin())
.eq(Location::getLocationStatus, LocationStatus.OCCUPY.getCode());
locationService.update(lambdaUpdateWrapperOfLocation);
currentVehicle.setCurrentLocation(inTask.getDestination());
if (haveMoveTask) {
currentVehicle.setVehicleStatus(VehicleStatus.MOVE.getCode());
} else {
currentVehicle.setVehicleStatus(VehicleStatus.ON.getCode());
}
boolean haveStocks = stockService.exists(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, inTask.getVehicleId()));
if (haveStocks) {
currentVehicle.setIsEmpty(0);
} else {
currentVehicle.setIsEmpty(1);
}
vehicleService.update(currentVehicle, new LambdaUpdateWrapper<Vehicle>().eq(Vehicle::getVehicleId, currentVehicle.getVehicleId()));
}
// 添加任务记录
moveTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
moveTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(moveTask, TaskRecord.class));
inTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
inTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(inTask, TaskRecord.class));
// 删除移库任务
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, moveTask.getTaskId()));
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, inTask.getTaskId()));
}
}
// TODO 出库任务完成
// 出库任务
if (taskType == TaskType.OUT.getCode()) {
// 对所有任务组里面的移库任务进行处理
// 对所有任务组里面的出库任务进行处理
for (Task outTask : feedBackTasks) {
if (!Objects.equals(moveTask.getTaskType(), TaskType.MOVE.getCode())) {
if (!Objects.equals(outTask.getTaskType(), TaskType.OUT.getCode())) {
// 非移库任务跳过
continue;
}
// 更新库存
LambdaUpdateWrapper<Stock> lambdaUpdateWrapperOfStock = new LambdaUpdateWrapper<Stock>()
.set(Stock::getLocationId, moveTask.getDestination())
.set(Stock::getStockStatus, StockStatus.OK.getCode())
.set(Stock::getLastUpdateTime, LocalDateTime.now())
.set(Stock::getLastUpdateUser, moveTask.getUserName())
.eq(Stock::getVehicleId, moveTask.getVehicleId())
.eq(Stock::getStockStatus, StockStatus.MOVE.getCode());
stockService.update(lambdaUpdateWrapperOfStock);
// 更新载具
LambdaUpdateWrapper<Vehicle> lambdaUpdateWrapperOfVehicle = new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
.set(Vehicle::getCurrentLocation, moveTask.getDestination())
.eq(Vehicle::getVehicleId, moveTask.getVehicleId())
.eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode());
vehicleService.update(lambdaUpdateWrapperOfVehicle);
// 释放原来的库位
LambdaUpdateWrapper<Location> lambdaUpdateWrapperOfLocation = new LambdaUpdateWrapper<Location>()
.set(Location::getLocationStatus, LocationStatus.EMPTY.getCode())
.set(Location::getVehicleId, "")
.eq(Location::getLocationId, moveTask.getOrigin())
.eq(Location::getLocationStatus, LocationStatus.OCCUPY.getCode());
locationService.update(lambdaUpdateWrapperOfLocation);
if (outTask.getIsPicking() == 1) {
// 拣选任务，更新任务状态
taskService.update(new LambdaUpdateWrapper<Task>()
.set(Task::getTaskStatus, WmsTaskStatus.PICKING.getCode())
.eq(Task::getTaskId, outTask.getTaskId()));
// 当前载具上所有库存状态设置为拣选
stockService.update(new LambdaUpdateWrapper<Stock>()
.set(Stock::getStockStatus, StockStatus.PICKING.getCode())
.eq(Stock::getVehicleId, outTask.getVehicleId())
.ne(Stock::getStockStatus, StockStatus.PICKING.getCode()));
// 当前载具设置为出库中状态
vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
.eq(Vehicle::getVehicleId, outTask.getVehicleId())
.ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
} else {
// 添加任务记录
moveTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
moveTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(moveTask, TaskRecord.class));
outTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
outTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(outTask, TaskRecord.class));
// 删除移库任务
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, moveTask.getTaskId()));
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, outTask.getTaskId()));
// 删除当前载具上所有库存
stockService.remove(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, outTask.getVehicleId()));
// 删除载具
vehicleService.remove(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, outTask.getVehicleId()));
}
// 释放原来的库位
locationService.update(new LambdaUpdateWrapper<Location>()
.set(Location::getLocationStatus, LocationStatus.EMPTY.getCode())
.eq(Location::getLocationId, outTask.getOrigin()));
}
}
// 移库任务完成
@ -796,10 +880,11 @@ public class TaskController {
taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, moveTask.getTaskId()));
}
}
} else if (taskStatus == WcsTaskStatus.RUN.getCode()) {// 任务完成
// TODO
}
return convertJsonString(response);
} catch (Exception e) {
// 回滚事务
@ -814,6 +899,7 @@ public class TaskController {
/**
* 验证任务反馈的请求信息
*
* @param wcsTaskResultRequest 任务反馈的请求
* @return 验证结果
*/

92
src/main/java/com/wms/controller/UserController.java
View File

@ -1,16 +1,18 @@
package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.dto.MenuDto;
import com.wms.entity.app.dto.UserDto;
import com.wms.entity.app.request.UserQuery;
import com.wms.entity.app.vo.MenuEntity;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.vo.UserConfigEntity;
import com.wms.entity.table.MenuDto;
import com.wms.entity.table.UserDto;
import com.wms.service.MenuService;
import com.wms.service.UserService;
import com.wms.utils.MyPassword;
import com.wms.constants.WmsConstants;
import com.wms.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -23,7 +25,8 @@ import org.springframework.web.bind.annotation.*;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import static com.wms.utils.StringUtils.convertJsonString;
/**
* WMS用户控制类
@ -52,96 +55,96 @@ public class UserController {
/**
* 带密码登录
* @param user 用户
* @param userQuery 用户
* @return 结果
*/
@PostMapping("/loginWithAuth")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String loginWithAuth(@RequestBody UserDto user) {
logger.info("WMS前端用户登录，登录账户名：{}", user.getLoginAccount());
public String loginWithAuth(@RequestBody UserQuery userQuery) {
logger.info("请求登录，登录账户名：{}", userQuery.getLoginAccount());
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 查找对应用户的信息
UserDto userForQuery = new UserDto();
userForQuery.setLoginAccount(user.getLoginAccount());
List<UserDto> waitForAuthUsers = userService.selectUsers(userForQuery);
if (waitForAuthUsers.size() < 1) {
logger.error("用户不存在，登录账户名：{}", user.getLoginAccount());
if (StringUtils.isEmpty(userQuery.getLoginAccount())) {
logger.error("请输入用户名");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("用户不存在");
return JSON.toJSONString(rsp);
rsp.setMessage("请输入用户名");
return convertJsonString(rsp);
}
// 验证密码
UserDto waitForAuthUser = waitForAuthUsers.get(0);
if (!Objects.equals(MyPassword.encrypt(user.getLoginPassword()), waitForAuthUser.getLoginPassword())) {
logger.error("密码错误，登录账户名：{}", user.getLoginAccount());
// 验证用户信息
UserDto validatedUser = userService.validateUser(userQuery.toUserPO(), true);
if (validatedUser == null || StringUtils.isEmpty(validatedUser.getLoginAccount())) {
logger.error("登录错误，用户不存在或密码错误");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("密码错误");
return JSON.toJSONString(rsp);
rsp.setMessage("登录错误，用户不存在或密码错误");
return convertJsonString(rsp);
}
// 当前用户
UserDto currentUser = waitForAuthUsers.get(0);
// 返回成功
logger.info("登录成功，登录账户名：{}", currentUser.getLoginAccount());
logger.info("登录成功，登录账户名：{}", validatedUser.getLoginAccount());
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("登录成功");
// 返回用户数据
rsp.setReturnData(generateUserInfo(currentUser));
rsp.setReturnData(generateUserInfo(validatedUser));
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("数据库错误：{}", e.getMessage());
logger.info("数据库错误：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage(e.getMessage());
rsp.setMessage("登录异常");
return JSON.toJSONString(rsp);
}
}
/**
* 无密码登录
* @param user 用户
* @param userQuery 用户
* @return 结果
*/
@PostMapping("/loginWithoutAuth")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String loginWithoutAuth(@RequestBody UserDto user) {
logger.info("WMS前端用户登录，登录账户名：{}", user.getLoginAccount());
public String loginWithoutAuth(@RequestBody UserQuery userQuery) {
logger.info("请求无密码登录，登录账户名：{}", userQuery.getLoginAccount());
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 查找对应用户的信息
UserDto userForQuery = new UserDto();
userForQuery.setLoginAccount(user.getLoginAccount());
List<UserDto> waitForAuthUsers = userService.selectUsers(userForQuery);
if (waitForAuthUsers.size() < 1) {
if (StringUtils.isEmpty(userQuery.getLoginAccount())) {
logger.error("请输入用户名");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("用户不存在");
return JSON.toJSONString(rsp);
rsp.setMessage("请输入用户名");
return convertJsonString(rsp);
}
UserDto currentUser = waitForAuthUsers.get(0);
// 验证用户信息
UserDto validatedUser = userService.validateUser(userQuery.toUserPO(), false);
if (validatedUser == null || StringUtils.isEmpty(validatedUser.getLoginAccount())) {
logger.error("登录错误，用户不存在或密码错误");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("登录错误，用户不存在或密码错误");
return convertJsonString(rsp);
}
// 返回成功
logger.info("登录成功，登录账户名：{}", currentUser.getLoginAccount());
logger.info("登录成功，登录账户名：{}", validatedUser.getLoginAccount());
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("登录成功");
// 返回用户数据
rsp.setReturnData(generateUserInfo(currentUser));
rsp.setReturnData(generateUserInfo(validatedUser));
return JSON.toJSONString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("数据库错误：{}", e.getMessage());
logger.info("数据库错误：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("数据库错误");
rsp.setMessage("登录异常");
return JSON.toJSONString(rsp);
}
}
@ -154,6 +157,9 @@ public class UserController {
private UserConfigEntity generateUserInfo (UserDto currentUser) {
UserConfigEntity userConfigEntity = new UserConfigEntity();
try {
if (currentUser.getRoleId() == null) {
return null;
}
List<MenuDto> menus = menuService.selMenuByRoleId(currentUser.getRoleId());
List<MenuEntity> menuList = new LinkedList<>();
// 查找一级菜单
@ -198,7 +204,7 @@ public class UserController {
}
logger.info("构造用户信息成功，当前用户：{}", currentUser.getUserName());
// 设置返回信息
userConfigEntity.setUser(currentUser);
userConfigEntity.setUser(BeanUtil.copyProperties(currentUser, UserDto.class));
userConfigEntity.setMenuList(menuList);
} catch (Exception e) {
logger.error("构造用户信息失败，当前用户：{}", currentUser.getUserName());

61
src/main/java/com/wms/controller/WmsLogController.java
View File

@ -1,16 +1,17 @@
package com.wms.controller;
import com.alibaba.fastjson2.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wms.constants.enums.ResponseCode;
import com.wms.entity.page.PageDomain;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.dto.PageDto;
import com.wms.entity.app.request.WmsLogQuery;
import com.wms.entity.app.vo.WmsLogVo;
import com.wms.entity.table.WmsLog;
import com.wms.entity.table.WmsLogDto;
import com.wms.service.LogService;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
@ -20,9 +21,10 @@ 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.List;
import static com.wms.utils.StringUtils.convertJsonString;
@Controller
@CrossOrigin
@ -42,30 +44,37 @@ public class WmsLogController {
/**
* 查询日志
*
* @param tableRequest 请求参数
* @param logQuery 请求参数
* @return 结果
*/
@PostMapping("/queryWmsLog")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String queryLogs(@RequestBody TableRequest<WmsLog, String> tableRequest) {
logger.info("查询日志，ip地址：{}, 用户名：{}", HttpUtils.getIpAddr(servletRequest), tableRequest.getParam().getLogUser());
TableResponse tblResp = new TableResponse();
public String getGoodsInfoByPage(@RequestBody WmsLogQuery logQuery){
logger.info("接收到查询日志请求：{}，请求ip：{}", convertJsonString(logQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
// 处理分页信息
PageDomain pageRequest = tableRequest.getPage();
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize());
List<WmsLog> logList = logService.selWmsLogs(tableRequest.getParam().getLogRequest());
PageInfo<WmsLog> logListPage = new PageInfo<>(logList);
tblResp.setCode(ResponseCode.OK.getCode());
tblResp.setMessage("查询日志成功！");
tblResp.setRows(logListPage.getList());
tblResp.setTotal(logListPage.getTotal());
return JSON.toJSONString(tblResp);
Page<WmsLog> page = logQuery.toMpPage();
Page<WmsLog> logPage = logService.page(page, new LambdaQueryWrapper<WmsLog>()
.like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogTitle, logQuery.getQueryParam())
.or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogMethod, logQuery.getQueryParam())
.or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogRequest, logQuery.getQueryParam())
.or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogResponse, logQuery.getQueryParam())
.or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogIp, logQuery.getQueryParam())
.or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogUser, logQuery.getQueryParam()));
PageDto<WmsLogVo> pageDto = PageDto.of(logPage, log -> BeanUtil.copyProperties(log, WmsLogVo.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询成功");
response.setReturnData(pageDto);
return convertJsonString(response);
} catch (Exception e) {
tblResp.setCode(ResponseCode.ERROR.getCode());
tblResp.setMessage("查询日志失败");
}
return JSON.toJSONString(tblResp);
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("查询日志信息发生异常：{}", convertJsonString(e));
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询日志信息发生异常");
return convertJsonString(response);
}
}
}

44
src/main/java/com/wms/entity/app/request/LocationQuery.java Normal file
View File

@ -0,0 +1,44 @@
package com.wms.entity.app.request;
import cn.hutool.core.bean.BeanUtil;
import com.wms.entity.table.Location;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(value = "库位查询")
public class LocationQuery extends PageQuery {
@ApiModelProperty(value = "库位号")
private String locationId;
@ApiModelProperty(value = "库区编号")
private Integer areaId;
@ApiModelProperty(value = "设备编号")
private Integer equipmentId;
@ApiModelProperty(value = "库位类型")
private Integer locationType;
@ApiModelProperty(value = "排")
private Integer wRow;
@ApiModelProperty(value = "列")
private Integer wCol;
@ApiModelProperty(value = "层")
private Integer wLayer;
@ApiModelProperty(value = "深度")
private Integer wDepth;
@ApiModelProperty(value = "是否锁定")
private Integer isLock;
@ApiModelProperty(value = "库位状态")
private Integer locationStatus;
@ApiModelProperty(value = "载具号")
private String vehicleId;
/**
* 将locationQuery转化为LocationPO
* @return locationPO
*/
public Location toLocationPO() {
return BeanUtil.copyProperties(this, Location.class);
}
}

2
src/main/java/com/wms/entity/app/request/PageQuery.java
View File

@ -43,6 +43,6 @@ public class PageQuery {
* @param <PO> 实体类
*/
public <PO> Page<PO> toMpPage(String defaultSortValue, Boolean isAsc){
return toMpPage(new OrderItem().setColumn(sortBy).setAsc(isAsc));
return toMpPage(new OrderItem().setColumn(defaultSortValue).setAsc(isAsc));
}
}

39
src/main/java/com/wms/entity/app/request/StandQuery.java Normal file
View File

@ -0,0 +1,39 @@
package com.wms.entity.app.request;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(value = "站台查询")
public class StandQuery extends PageQuery {
/**
* 站台id
*/
@ApiModelProperty(value = "站台号")
private String standId;
/**
* 站台是否锁定
*/
@ApiModelProperty(value = "是否锁定")
private Integer isLock;
/**
* 站台状态
*/
@ApiModelProperty(value = "站台状态")
private Integer standStatus;
/**
* 站台类型
*/
@ApiModelProperty(value = "站台类型")
private Integer standType;
/**
* 设备类型
*/
@ApiModelProperty(value = "设备类型")
private Integer equipmentType;
}

55
src/main/java/com/wms/entity/app/request/UserQuery.java Normal file
View File

@ -0,0 +1,55 @@
package com.wms.entity.app.request;
import cn.hutool.core.bean.BeanUtil;
import com.wms.entity.table.User;
import com.wms.utils.MyPassword;
import com.wms.utils.StringUtils;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(value = "载具查询")
public class UserQuery extends PageQuery{
/** 用户ID */
@ApiModelProperty(value = "用户id")
private Integer userId;
/** 用户名 */
@ApiModelProperty(value = "用户名")
private String userName;
/** 角色Id */
@ApiModelProperty(value = "角色id")
private Integer roleId;
/** 登录账户 */
@ApiModelProperty(value = "登录账号")
private String loginAccount;
/** 登录密码 */
@ApiModelProperty(value = "登录密码")
private String loginPassword;
/** 添加时间 */
@ApiModelProperty(value = "添加时间")
private LocalDateTime addTime;
/** 更新时间 */
@ApiModelProperty(value = "更新时间")
private LocalDateTime updateTime;
/** 添加用户名 */
@ApiModelProperty(value = "添加用户")
private String addUser;
/**
* 将UserQuery转化为UserPO
* @return UserVO结果
*/
public User toUserPO() {
User user = BeanUtil.copyProperties(this, User.class);
if (StringUtils.isNotEmpty(user.getLoginPassword())) {
user.setLoginPassword(MyPassword.encrypt(user.getLoginPassword()));
}
return user;
}
}

36
src/main/java/com/wms/entity/app/request/VehicleQuery.java Normal file
View File

@ -0,0 +1,36 @@
package com.wms.entity.app.request;
import cn.hutool.core.bean.BeanUtil;
import com.wms.entity.table.Location;
import com.wms.entity.table.Vehicle;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(value = "载具查询")
public class VehicleQuery extends PageQuery {
@ApiModelProperty(value = "载具编号")
private String vehicleId;
@ApiModelProperty(value = "载具状态")
private Integer vehicleStatus;
@ApiModelProperty(value = "是否为空")
private Integer isEmpty;
@ApiModelProperty(value = "当前位置")
private String currentLocation;
/**
* 将VehicleQuery转化为VehiclePO
* @return VehiclePO
*/
public Vehicle toVehiclePO() {
Vehicle vehiclePO = new Vehicle();
vehiclePO.setVehicleId(vehicleId);
vehiclePO.setVehicleStatus(vehicleStatus);
vehiclePO.setIsEmpty(isEmpty);
vehiclePO.setCurrentLocation(currentLocation);
return vehiclePO;
}
}

30
src/main/java/com/wms/entity/app/request/WmsLogQuery.java Normal file
View File

@ -0,0 +1,30 @@
package com.wms.entity.app.request;
import com.wms.entity.table.WmsLog;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(value = "日志查询")
public class WmsLogQuery extends PageQuery {
@ApiModelProperty(value = "日志查询参数")
private String queryParam;
/**
* 将日志查询条件转化为LogPO
* @return logPO
*/
public WmsLog toLogPO() {
WmsLog logPO = new WmsLog();
logPO.setLogTitle(this.queryParam);
logPO.setLogMethod(this.queryParam);
logPO.setLogRequest(this.queryParam);
logPO.setLogResponse(this.queryParam);
logPO.setLogIp(this.queryParam);
logPO.setLogUser(this.queryParam);
return logPO;
}
}

45
src/main/java/com/wms/entity/app/vo/GoodsVo.java Normal file
View File

@ -0,0 +1,45 @@
package com.wms.entity.app.vo;
import lombok.Data;
import java.util.Date;
@Data
public class GoodsVo {
/**
* 物料编号
*/
private String goodsId;
/**
* 物料名称
*/
private String goodsName;
/**
* 单位
*/
private String goodsUnit;
/**
* 物料ID
*/
private String itemId;
/**
* 物料分类
*/
private String goodsType;
/**
* 有效天数
*/
private Integer lifeDays;
/**
* 仓储分类
*/
private String invCategory;
/**
* 最后更新日期
*/
private Date lastUpdateTime;
/**
* 最后更新用户
*/
private String lastUpdateUser;
}

51
src/main/java/com/wms/entity/app/vo/LocationVo.java Normal file
View File

@ -0,0 +1,51 @@
package com.wms.entity.app.vo;
import lombok.Data;
@Data
public class LocationVo {
/**
* 库位编号
*/
private String locationId;
/**
* 库区编号
*/
private Integer areaId;
/**
* 设备编号
*/
private Integer equipmentId;
/**
* 库位类型
*/
private Integer locationType;
/**
* 排
*/
private Integer wRow;
/**
* 列
*/
private Integer wCol;
/**
* 层
*/
private Integer wLayer;
/**
* 深度
*/
private Integer wDepth;
/**
* 是否锁定
*/
private Integer isLock;
/**
* 库位状态
*/
private Integer locationStatus;
/**
* 载具号
*/
private String vehicleId;
}

54
src/main/java/com/wms/entity/app/vo/StandVo.java Normal file
View File

@ -0,0 +1,54 @@
package com.wms.entity.app.vo;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class StandVo {
/**
* 站台id
*/
private String standId;
/**
* 是否允许入库
*/
private Integer allowIn;
/**
* 是否允许出库
*/
private Integer allowOut;
/**
* 站台是否锁定
*/
private Integer isLock;
/**
* 站台状态
*/
private Integer standStatus;
/**
* 设备编号
*/
private Integer equipmentId;
/**
* 库区编号
*/
private Integer areaId;
/**
* 站台类型
*/
private Integer standType;
/**
* 站台ip
*/
private String standIp;
/**
* 外部id
* 如果对接，其它系统的站台id
*/
private String outerId;
/**
* 最近一次的使用时间
*/
private LocalDateTime lastUseTime;
}

80
src/main/java/com/wms/entity/app/vo/TaskRecordVO.java Normal file
View File

@ -0,0 +1,80 @@
package com.wms.entity.app.vo;
import com.wms.entity.app.dto.extend.TaskDetailInfo;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 任务记录VO
*/
public class TaskRecordVO {
/**
* 任务号
*/
private String taskId;
/**
* 任务类型
*/
private Integer taskType;
/**
* 任务状态
*/
private Integer taskStatus;
/**
* 起点
*/
private String origin;
/**
* 终点
*/
private String destination;
/**
* 任务优先级
*/
private Integer taskPriority;
/**
* 任务组
*/
private String taskGroup;
/**
* 载具号
*/
private String vehicleId;
/**
* 重量
*/
private BigDecimal weight;
/**
* 载具尺寸
*/
private Integer vehicleSize;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 完成时间
*/
private LocalDateTime finishTime;
/**
* 用户名
*/
private String userName;
/**
* 物料相关
*/
private TaskDetailInfo goodsRelated;
/**
* 前置任务号
*/
private String preTask;
/**
* 是否拣选
*/
private Integer isPicking;
/**
* 拣选站台
*/
private String pickStand;
}

2
src/main/java/com/wms/entity/app/vo/UserConfigEntity.java
View File

@ -1,6 +1,6 @@
package com.wms.entity.app.vo;
import com.wms.entity.table.UserDto;
import com.wms.entity.app.dto.UserDto;
import io.swagger.annotations.ApiModel;
import java.util.List;

35
src/main/java/com/wms/entity/app/vo/VehicleVO.java Normal file
View File

@ -0,0 +1,35 @@
package com.wms.entity.app.vo;
import com.wms.entity.app.dto.extend.VehicleDetailInfo;
import lombok.Data;
/**
* 载具VO
*/
@Data
public class VehicleVO {
/**
* 载具编号
*/
private String vehicleId;
/**
* 当前所在位置
*/
private String currentLocation;
/**
* 载具状态
*/
private Integer vehicleStatus;
/**
* 是否是空箱
*/
private Integer isEmpty;
/**
* 载具类型
*/
private Integer vehicleType;
/**
* 额外信息
*/
private VehicleDetailInfo details;
}

41
src/main/java/com/wms/entity/app/vo/WmsLogVo.java Normal file
View File

@ -0,0 +1,41 @@
package com.wms.entity.app.vo;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class WmsLogVo {
/**
* id
*/
private String logId;
/**
* 描述/标题
*/
private String logTitle;
/**
* 方法
*/
private String logMethod;
/**
* 请求参数
*/
private Object logRequest;
/**
* 响应参数
*/
private Object logResponse;
/**
* 请求的ip
*/
private String logIp;
/**
* 请求时间
*/
private LocalDateTime logTime;
/**
* 请求用户
*/
private String logUser;
}

14
src/main/java/com/wms/entity/table/WmsLog.java
View File

@ -54,4 +54,18 @@ public class WmsLog {
*/
@TableField(value = "log_user")
private String logUser;
public WmsLog() {
}
public WmsLog(String logId, String logTitle, String logMethod, Object logRequest, Object logResponse, String logIp, LocalDateTime logTime, String logUser) {
this.logId = logId;
this.logTitle = logTitle;
this.logMethod = logMethod;
this.logRequest = logRequest;
this.logResponse = logResponse;
this.logIp = logIp;
this.logTime = logTime;
this.logUser = logUser;
}
}

1
src/main/java/com/wms/mapper/LogMapper.java
View File

@ -6,5 +6,4 @@ import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface LogMapper extends BaseMapper<WmsLog> {
}

14
src/main/java/com/wms/mapper/MenuMapper.java
View File

@ -1,13 +1,21 @@
package com.wms.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wms.entity.table.MenuDto;
import com.wms.entity.table.Menu;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 菜单Mapper
*/
@Mapper
public interface MenuMapper extends BaseMapper<MenuDto> {
public interface MenuMapper extends BaseMapper<Menu> {
/**
* 根据角色查询对应的菜单项
* @param roleId 角色id
* @return 菜单
*/
List<Menu> selMenuByRoleId(@Param("roleId") int roleId);
}

4
src/main/java/com/wms/mapper/UserMapper.java
View File

@ -1,10 +1,10 @@
package com.wms.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wms.entity.table.UserDto;
import com.wms.entity.table.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper<UserDto> {
public interface UserMapper extends BaseMapper<User> {
}

2
src/main/java/com/wms/service/LogService.java
View File

@ -3,6 +3,8 @@ package com.wms.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.wms.entity.table.WmsLog;
import java.util.List;
public interface LogService extends IService<WmsLog> {
/**
* 定期删除日志记录（30天清一次）

17
src/main/java/com/wms/service/MenuService.java
View File

@ -1,5 +1,20 @@
package com.wms.service;
public interface MenuService {
import com.baomidou.mybatisplus.extension.service.IService;
import com.wms.entity.app.dto.MenuDto;
import com.wms.entity.table.Menu;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 菜单服务
*/
public interface MenuService extends IService<Menu> {
/**
* 根据角色查询对应的菜单项
* @param roleId 角色id
* @return 菜单
*/
List<MenuDto> selMenuByRoleId(int roleId);
}

11
src/main/java/com/wms/service/UserService.java
View File

@ -1,5 +1,14 @@
package com.wms.service;
public interface UserService {
import com.baomidou.mybatisplus.extension.service.IService;
import com.wms.entity.app.dto.UserDto;
import com.wms.entity.table.User;
public interface UserService extends IService<User> {
/**
* 验证用户正确性
* @param user 用户
* @return 验证结果---返回用户信息
*/
public UserDto validateUser(User user, boolean withAuth);
}

6
src/main/java/com/wms/service/serviceImplements/LogServiceImplements.java
View File

@ -1,14 +1,20 @@
package com.wms.service.serviceImplements;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wms.entity.app.dto.WmsLogDto;
import com.wms.entity.table.WmsLog;
import com.wms.mapper.LogMapper;
import com.wms.service.LogService;
import com.wms.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class LogServiceImplements extends ServiceImpl<LogMapper, WmsLog> implements LogService {

11
src/main/java/com/wms/service/serviceImplements/MenuServiceImplements.java
View File

@ -1,6 +1,9 @@
package com.wms.service.serviceImplements;
import com.wms.entity.table.MenuDto;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wms.entity.app.dto.MenuDto;
import com.wms.entity.table.Menu;
import com.wms.mapper.MenuMapper;
import com.wms.service.MenuService;
import lombok.RequiredArgsConstructor;
@ -11,13 +14,11 @@ import java.util.List;
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class MenuServiceImplements implements MenuService {
public class MenuServiceImplements extends ServiceImpl<MenuMapper, Menu> implements MenuService {
private final MenuMapper menuMapper;
@Override
public List<MenuDto> selMenuByRoleId(int roleId) {
return this.menuMapper.selMenuByRoleId(roleId);
return BeanUtil.copyToList(menuMapper.selMenuByRoleId(roleId), MenuDto.class);
}
}

24
src/main/java/com/wms/service/serviceImplements/UserServiceImplements.java
View File

@ -1,24 +1,26 @@
package com.wms.service.serviceImplements;
import com.wms.entity.table.UserDto;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wms.entity.app.dto.UserDto;
import com.wms.entity.table.User;
import com.wms.mapper.UserMapper;
import com.wms.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImplements implements UserService {
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class UserServiceImplements extends ServiceImpl<UserMapper, User> implements UserService {
private final UserMapper userMapper;
@Autowired
public UserServiceImplements(UserMapper userMapper) {
this.userMapper = userMapper;
}
@Override
public List<UserDto> selectUsers(UserDto user) {
return userMapper.selectUsers(user);
public UserDto validateUser(User user, boolean withAuth) {
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<User>()
.eq(User::getLoginAccount, user.getLoginAccount())
.eq(withAuth, User::getLoginPassword, user.getLoginPassword());
return BeanUtil.copyProperties(super.getOne(queryWrapper), UserDto.class);
}
}

8
src/main/java/com/wms/utils/MyPassword.java
View File

@ -16,8 +16,8 @@ public class MyPassword {
/**
* 加密
* @param originalPassword
* @return
* @param originalPassword 原始密码
* @return 加密密码
*/
public static String encrypt(String originalPassword) {
byte[] targetPassword;
@ -46,8 +46,8 @@ public class MyPassword {
/**
* 解密
* @param targetPassword
* @return
* @param targetPassword 加密密码
* @return 解密密码
*/
public static String decrypt(String targetPassword) {
byte[] originalPassword;

76
src/main/resources/mapper/LogMapper.xml
View File

@ -2,80 +2,4 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wms.mapper.LogMapper">
<resultMap type="WmsLog" id="WmsLogMap">
<result property="logId" column="log_id"/>
<result property="logTitle" column="log_title"/>
<result property="logMethod" column="log_method"/>
<result property="logRequest" column="log_request"/>
<result property="logResponse" column="log_response"/>
<result property="logIp" column="log_ip"/>
<result property="logTime" column="log_time"/>
<result property="logUser" column="log_user"/>
</resultMap>
<sql id="selectAll">
select log_id, log_title, log_method, log_request, log_response, log_ip, log_time, log_user
from tbl_sys_log
</sql>
<select id="selWmsLogs" parameterType="String" resultMap="WmsLogMap">
<include refid="selectAll"/>
<where>
<if test="query != null and query != ''">
log_title like concat('%', #{query}, '%') or
log_method like concat('%', #{query}, '%') or
log_request like concat('%', #{query}, '%') or
log_response like concat('%', #{query}, '%') or
log_ip like concat('%', #{query}, '%') or
log_user like concat('%', #{query}, '%')
</if>
</where>
order by log_time desc
</select>
<insert id="addWmsLog" parameterType="WmsLog">
insert into tbl_sys_log
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="logId != null">log_id,</if>
<if test="logTitle != null">log_title,</if>
<if test="logMethod != null">log_method,</if>
<if test="logRequest != null">log_request,</if>
<if test="logResponse != null">log_response,</if>
<if test="logIp != null">log_ip,</if>
<if test="logTime != null">log_time,</if>
<if test="logUser != null">log_user,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="logId != null">#{logId},</if>
<if test="logTitle != null">#{logTitle},</if>
<if test="logMethod != null">#{logMethod},</if>
<if test="logRequest != null">#{logRequest},</if>
<if test="logResponse != null">#{logResponse},</if>
<if test="logIp != null">#{logIp},</if>
<if test="logTime != null">#{logTime},</if>
<if test="logUser != null">#{logUser},</if>
</trim>
</insert>
<update id="modifyWmsLog" parameterType="WmsLog">
update tbl_sys_log
<trim prefix="SET" suffixOverrides=",">
<if test="logTitle != null and logTitle != ''">log_title = #{logTitle},</if>
<if test="logMethod != null and logMethod != ''">log_method = #{logMethod},</if>
<if test="logRequest != null and logRequest != ''">log_request = #{logRequest},</if>
<if test="logResponse != null and logResponse != ''">log_response = #{logResponse},</if>
<if test="logIp != null and logIp != ''">log_ip = #{logIp},</if>
<if test="logTime != null">log_time = #{logTime},</if>
<if test="logUser != null and logUser != ''">log_user = #{logUser},</if>
</trim>
where log_id = #{logId}
</update>
<delete id="deleteWmsLog" parameterType="String">
delete from tbl_sys_log where log_id = #{logId}
</delete>
<delete id="deleteWmsLogsRegularly" parameterType="String">
delete from tbl_sys_log where log_time &lt; date_add(curdate(),INTERVAL -30 DAY)
</delete>
</mapper>

16
src/main/resources/mapper/MenuMapper.xml
View File

@ -2,14 +2,14 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wms.mapper.MenuMapper">
<resultMap type="Menu" id="MenuMap">
<result property="menuId" column="menu_id"/>
<result property="labelName" column="label_name"/>
<result property="iconValue" column="icon_value"/>
<result property="path" column="path"/>
<result property="parentId" column="parent_id"/>
</resultMap>
<select id="selMenuByRoleId" parameterType="Integer" resultMap="MenuMap">
<!-- <resultMap type="com.wms.entity.table.Menu" id="MenuMap">-->
<!-- <result property="menuId" column="menu_id"/>-->
<!-- <result property="labelName" column="label_name"/>-->
<!-- <result property="iconValue" column="icon_value"/>-->
<!-- <result property="path" column="path"/>-->
<!-- <result property="parentId" column="parent_id"/>-->
<!-- </resultMap>-->
<select id="selMenuByRoleId" parameterType="Integer" resultType="com.wms.entity.table.Menu">
select tsm.menu_id, tsm.label_name, tsm.icon_value, tsm.path, tsm.parent_id
from tbl_sys_menu tsm left join tbl_sys_permission tsp on tsm.menu_id = tsp.menu_id
where tsp.role_id = #{roleId}