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, "出库中"), OUT(1, "出库中"),
INVENTORY(2, "盘点中"), INVENTORY(2, "盘点中"),
MOVE(3, "移库中"), MOVE(3, "移库中"),
PICKING(4, "拣选中"),
LOCK(9, "库存锁定"); LOCK(9, "库存锁定");
private final Integer code; private final Integer code;

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

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

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

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

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

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

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

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

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

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

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

@ -1,17 +1,27 @@
package com.wms.controller; package com.wms.controller;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSON; import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject; 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.PageHelper;
import com.github.pagehelper.PageInfo; import com.github.pagehelper.PageInfo;
import com.wms.annotation.MyLog;
import com.wms.constants.enums.ResponseCode; import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity; 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.PageDomain;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse; 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.service.StandService;
import com.wms.utils.HttpUtils; import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -26,6 +36,8 @@ import org.springframework.web.bind.annotation.*;
import java.util.List; import java.util.List;
import static com.wms.utils.StringUtils.convertJsonString;
/** /**
* 站台控制类 * 站台控制类
*/ */
@ -45,92 +57,74 @@ public class StandController {
private final HttpServletRequest servletRequest; private final HttpServletRequest servletRequest;
/** /**
* 查询可用站台列表 * 查找所有站台信息
* @return 符合条件的站台列表
*/ */
@PostMapping("/getAllStands") @PostMapping("/getStandsByPage")
@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")
@ResponseBody @ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED) @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String updateStandInfo(@RequestBody StandDto stand) { public String getStandsByPage(@RequestBody StandQuery standQuery){
// 创建响应信息 logger.info("接收到查询物料数据请求：{}，请求ip：{}", convertJsonString(standQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity rsp = new ResponseEntity(); ResponseEntity response = new ResponseEntity();
try { 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) { } catch (Exception e) {
// 回滚事务 // 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.info("更新站台信息发生错误：{}", e.getMessage()); logger.error("查询物料信息发生异常");
// 返回其他异常 response.setCode(ResponseCode.ERROR.getCode());
rsp.setCode(ResponseCode.ERROR.getCode()); response.setMessage("查询物料发生异常");
rsp.setMessage(e.getMessage()); return convertJsonString(response);
return JSON.toJSONString(rsp);
} }
logger.info("更新站台信息成功：{}", stand.toLoggerString());
// 返回成功
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("更新站台信息成功");
return JSON.toJSONString(rsp);
} }
/** /**
* 查找所有库存 * 更新物料信息
*
* @param goods 物料信息
* @return 结果
*/ */
@PostMapping("/getStands") @PostMapping("/updateGoodsInfo")
@ResponseBody @ResponseBody
public String getStands(@RequestBody TableRequest<StandDto, String> tableRequest){ @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
logger.info("请求的ip地址：{}", HttpUtils.getIpAddr(servletRequest)); @MyLog(logTitle = "更新物料信息", logMethod = "updateGoodsInfo")
logger.info("接收到查询库存请求：{}", JSON.toJSONString(tableRequest)); public String updateGoodsInfo(@RequestBody GoodsDto goods) {
TableResponse tblResp = new TableResponse(); logger.info("接收到更新物料信息请求：{}，请求ip：{}", convertJsonString(goods), HttpUtils.getIpAddr(servletRequest));
// 解析请求数据 // 创建响应信息
if (tableRequest == null || tableRequest.getPage() == null) { ResponseEntity rsp = new ResponseEntity();
tblResp.setCode(ResponseCode.ERROR.getCode()); try {
tblResp.setMessage("请求数据为空，无法处理！"); if (StringUtils.isEmpty(goods.getGoodsId())) {// 物料编码为空，不执行
logger.error("请求数据为空，无法处理！"); logger.error("请求更新的物料编号为空");
return JSON.toJSONString(tblResp); 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; package com.wms.controller;
import com.alibaba.fastjson2.JSON;
import com.wms.constants.enums.ResponseCode; import com.wms.constants.enums.ResponseCode;
import com.wms.entity.app.ResponseEntity; 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 com.wms.system_service.ISystemService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -37,14 +36,14 @@ public class SystemController {
@PostMapping("/restartSystem") @PostMapping("/restartSystem")
@ResponseBody @ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED) @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String restartSystem(@RequestBody UserDto user) { public String restartSystem(@RequestBody UserQuery user) {
logger.info("接收到重启系统请求：{}", convertJsonString(user)); logger.info("接收到重启系统请求：{}", convertJsonString(user));
ResponseEntity response = new ResponseEntity(); ResponseEntity response = new ResponseEntity();
if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启 if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启
logger.error("非管理员不允许重启"); logger.error("非管理员不允许重启");
response.setCode(ResponseCode.ERROR.getCode()); response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("非管理员不允许重启"); response.setMessage("非管理员不允许重启");
return JSON.toJSONString(convertJsonString(response)); return convertJsonString(response);
} }
if (systemService.restartSystem()) { if (systemService.restartSystem()) {
logger.info("重启成功"); logger.info("重启成功");
@ -67,14 +66,14 @@ public class SystemController {
@PostMapping("/reloadConfig") @PostMapping("/reloadConfig")
@ResponseBody @ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED) @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String reloadConfig(@RequestBody UserDto user) { public String reloadConfig(@RequestBody UserQuery user) {
logger.info("接收到重载配置请求：{}", convertJsonString(user)); logger.info("接收到重载配置请求：{}", convertJsonString(user));
ResponseEntity response = new ResponseEntity(); ResponseEntity response = new ResponseEntity();
if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启 if (user == null || user.getRoleId() != 1) {// 不是管理员不允许重启
logger.error("非管理员不允许重载配置"); logger.error("非管理员不允许重载配置");
response.setCode(ResponseCode.ERROR.getCode()); response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("非管理员不允许重载配置"); response.setMessage("非管理员不允许重载配置");
return JSON.toJSONString(convertJsonString(response)); return convertJsonString(response);
} }
if (systemService.reloadConfig()) { if (systemService.reloadConfig()) {
logger.info("重载配置成功"); 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.constants.enums.*;
import com.wms.entity.app.*; import com.wms.entity.app.*;
import com.wms.entity.app.dto.TaskDto; 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.TaskDetailInfo;
import com.wms.entity.app.dto.extend.VehicleDetailInfo; import com.wms.entity.app.dto.extend.VehicleDetailInfo;
import com.wms.entity.app.request.GoodsInRequest; import com.wms.entity.app.request.GoodsInRequest;
@ -272,7 +273,18 @@ public class TaskController {
return TaskInValidationEnum.NO_VEHICLE_ID.getErrorMessage(); 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) { if (taskInRequest.getTotalWeight() == null) {
return TaskInValidationEnum.NO_WEIGHT.getErrorMessage(); return TaskInValidationEnum.NO_WEIGHT.getErrorMessage();
@ -678,83 +690,155 @@ public class TaskController {
int taskStatus = wcsTaskResultRequest.getTaskStatus(); int taskStatus = wcsTaskResultRequest.getTaskStatus();
// 判断任务状态 // 判断任务状态
if (taskStatus == WcsTaskStatus.FINISH.getCode()) {// 任务完成 if (taskStatus == WcsTaskStatus.FINISH.getCode()) {// 任务完成
// TODO 入库任务完成 // 入库任务完成
if (taskType == TaskType.IN.getCode()) { if (taskType == TaskType.IN.getCode()) {
// 对所有任务组里面的移库任务进行处理 // 对所有任务组里面的入库任务进行处理
for (Task inTask : feedBackTasks) { for (Task inTask : feedBackTasks) {
if (!Objects.equals(inTask.getTaskType(), TaskType.IN.getCode())) { if (!Objects.equals(inTask.getTaskType(), TaskType.IN.getCode())) {
// 非入库任务跳过 // 非入库任务跳过
continue; continue;
} }
// // 当前载具是否有移库任务
// 更新库存 boolean haveMoveTask = taskService.exists(new LambdaQueryWrapper<Task>()
LambdaUpdateWrapper<Stock> lambdaUpdateWrapperOfStock = new LambdaUpdateWrapper<Stock>() .eq(Task::getVehicleId, inTask.getVehicleId())
.set(Stock::getLocationId, moveTask.getDestination()) .eq(Task::getTaskType, TaskType.MOVE.getCode()));
.set(Stock::getStockStatus, StockStatus.OK.getCode()) // 如果是入库
.set(Stock::getLastUpdateTime, LocalDateTime.now()) if (inTask.getTaskId().startsWith("RK")) {
.set(Stock::getLastUpdateUser, moveTask.getUserName()) // 添加库存
.eq(Stock::getVehicleId, moveTask.getVehicleId()) if (inTask.getGoodsRelated() != null && !inTask.getGoodsRelated().getGoodsId().isEmpty()) {
.eq(Stock::getStockStatus, StockStatus.MOVE.getCode()); // 查询这个物料有没有库存
stockService.update(lambdaUpdateWrapperOfStock); // 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>() currentVehicle.setCurrentLocation(inTask.getDestination());
.set(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()) if (haveMoveTask) {
.set(Vehicle::getCurrentLocation, moveTask.getDestination()) currentVehicle.setVehicleStatus(VehicleStatus.MOVE.getCode());
.eq(Vehicle::getVehicleId, moveTask.getVehicleId()) } else {
.eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode()); currentVehicle.setVehicleStatus(VehicleStatus.ON.getCode());
vehicleService.update(lambdaUpdateWrapperOfVehicle); }
// 释放原来的库位 boolean haveStocks = stockService.exists(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, inTask.getVehicleId()));
LambdaUpdateWrapper<Location> lambdaUpdateWrapperOfLocation = new LambdaUpdateWrapper<Location>() if (haveStocks) {
.set(Location::getLocationStatus, LocationStatus.EMPTY.getCode()) currentVehicle.setIsEmpty(0);
.set(Location::getVehicleId, "") } else {
.eq(Location::getLocationId, moveTask.getOrigin()) currentVehicle.setIsEmpty(1);
.eq(Location::getLocationStatus, LocationStatus.OCCUPY.getCode()); }
locationService.update(lambdaUpdateWrapperOfLocation); vehicleService.update(currentVehicle, new LambdaUpdateWrapper<Vehicle>().eq(Vehicle::getVehicleId, currentVehicle.getVehicleId()));
}
// 添加任务记录 // 添加任务记录
moveTask.setTaskStatus(WmsTaskStatus.FINISH.getCode()); inTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
moveTask.setFinishTime(LocalDateTime.now()); inTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(moveTask, TaskRecord.class)); 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()) { if (taskType == TaskType.OUT.getCode()) {
// 对所有任务组里面的移库任务进行处理 // 对所有任务组里面的出库任务进行处理
for (Task outTask : feedBackTasks) { for (Task outTask : feedBackTasks) {
if (!Objects.equals(moveTask.getTaskType(), TaskType.MOVE.getCode())) { if (!Objects.equals(outTask.getTaskType(), TaskType.OUT.getCode())) {
// 非移库任务跳过 // 非移库任务跳过
continue; continue;
} }
// 更新库存 if (outTask.getIsPicking() == 1) {
LambdaUpdateWrapper<Stock> lambdaUpdateWrapperOfStock = new LambdaUpdateWrapper<Stock>() // 拣选任务，更新任务状态
.set(Stock::getLocationId, moveTask.getDestination()) taskService.update(new LambdaUpdateWrapper<Task>()
.set(Stock::getStockStatus, StockStatus.OK.getCode()) .set(Task::getTaskStatus, WmsTaskStatus.PICKING.getCode())
.set(Stock::getLastUpdateTime, LocalDateTime.now()) .eq(Task::getTaskId, outTask.getTaskId()));
.set(Stock::getLastUpdateUser, moveTask.getUserName()) // 当前载具上所有库存状态设置为拣选
.eq(Stock::getVehicleId, moveTask.getVehicleId()) stockService.update(new LambdaUpdateWrapper<Stock>()
.eq(Stock::getStockStatus, StockStatus.MOVE.getCode()); .set(Stock::getStockStatus, StockStatus.PICKING.getCode())
stockService.update(lambdaUpdateWrapperOfStock); .eq(Stock::getVehicleId, outTask.getVehicleId())
// 更新载具 .ne(Stock::getStockStatus, StockStatus.PICKING.getCode()));
LambdaUpdateWrapper<Vehicle> lambdaUpdateWrapperOfVehicle = new LambdaUpdateWrapper<Vehicle>() // 当前载具设置为出库中状态
.set(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()) vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getCurrentLocation, moveTask.getDestination()) .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
.eq(Vehicle::getVehicleId, moveTask.getVehicleId()) .eq(Vehicle::getVehicleId, outTask.getVehicleId())
.eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode()); .ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
vehicleService.update(lambdaUpdateWrapperOfVehicle); } else {
// 释放原来的库位
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);
// 添加任务记录 // 添加任务记录
moveTask.setTaskStatus(WmsTaskStatus.FINISH.getCode()); outTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
moveTask.setFinishTime(LocalDateTime.now()); outTask.setFinishTime(LocalDateTime.now());
taskRecordService.save(BeanUtil.copyProperties(moveTask, TaskRecord.class)); 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())); taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, moveTask.getTaskId()));
} }
} }
} else if (taskStatus == WcsTaskStatus.RUN.getCode()) {// 任务完成
// TODO
} }
return convertJsonString(response); return convertJsonString(response);
} catch (Exception e) { } catch (Exception e) {
// 回滚事务 // 回滚事务
@ -814,6 +899,7 @@ public class TaskController {
/** /**
* 验证任务反馈的请求信息 * 验证任务反馈的请求信息
*
* @param wcsTaskResultRequest 任务反馈的请求 * @param wcsTaskResultRequest 任务反馈的请求
* @return 验证结果 * @return 验证结果
*/ */

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

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

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

@ -1,16 +1,17 @@
package com.wms.controller; package com.wms.controller;
import com.alibaba.fastjson2.JSON; import cn.hutool.core.bean.BeanUtil;
import com.github.pagehelper.PageHelper; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.pagehelper.PageInfo; import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wms.constants.enums.ResponseCode; import com.wms.constants.enums.ResponseCode;
import com.wms.entity.page.PageDomain; import com.wms.entity.app.ResponseEntity;
import com.wms.entity.page.TableRequest; import com.wms.entity.app.dto.PageDto;
import com.wms.entity.page.TableResponse; 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.WmsLog;
import com.wms.entity.table.WmsLogDto;
import com.wms.service.LogService; import com.wms.service.LogService;
import com.wms.utils.HttpUtils; import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -20,9 +21,10 @@ import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.List; import static com.wms.utils.StringUtils.convertJsonString;
@Controller @Controller
@CrossOrigin @CrossOrigin
@ -42,30 +44,37 @@ public class WmsLogController {
/** /**
* 查询日志 * 查询日志
* *
* @param tableRequest 请求参数 * @param logQuery 请求参数
* @return 结果 * @return 结果
*/ */
@PostMapping("/queryWmsLog") @PostMapping("/queryWmsLog")
@ResponseBody @ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED) @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public String queryLogs(@RequestBody TableRequest<WmsLog, String> tableRequest) { public String getGoodsInfoByPage(@RequestBody WmsLogQuery logQuery){
logger.info("查询日志，ip地址：{}, 用户名：{}", HttpUtils.getIpAddr(servletRequest), tableRequest.getParam().getLogUser()); logger.info("接收到查询日志请求：{}，请求ip：{}", convertJsonString(logQuery), HttpUtils.getIpAddr(servletRequest));
TableResponse tblResp = new TableResponse(); ResponseEntity response = new ResponseEntity();
try { try {
// 处理分页信息 Page<WmsLog> page = logQuery.toMpPage();
PageDomain pageRequest = tableRequest.getPage(); Page<WmsLog> logPage = logService.page(page, new LambdaQueryWrapper<WmsLog>()
PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize()); .like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogTitle, logQuery.getQueryParam())
List<WmsLog> logList = logService.selWmsLogs(tableRequest.getParam().getLogRequest()); .or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogMethod, logQuery.getQueryParam())
PageInfo<WmsLog> logListPage = new PageInfo<>(logList); .or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogRequest, logQuery.getQueryParam())
tblResp.setCode(ResponseCode.OK.getCode()); .or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogResponse, logQuery.getQueryParam())
tblResp.setMessage("查询日志成功！"); .or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogIp, logQuery.getQueryParam())
tblResp.setRows(logListPage.getList()); .or().like(StringUtils.isNotEmpty(logQuery.getQueryParam()), WmsLog::getLogUser, logQuery.getQueryParam()));
tblResp.setTotal(logListPage.getTotal());
return JSON.toJSONString(tblResp); 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) { } catch (Exception e) {
tblResp.setCode(ResponseCode.ERROR.getCode()); // 回滚事务
tblResp.setMessage("查询日志失败"); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
} logger.error("查询日志信息发生异常：{}", convertJsonString(e));
return JSON.toJSONString(tblResp); 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> 实体类 * @param <PO> 实体类
*/ */
public <PO> Page<PO> toMpPage(String defaultSortValue, Boolean isAsc){ 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; 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 io.swagger.annotations.ApiModel;
import java.util.List; 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") @TableField(value = "log_user")
private String logUser; 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 @Mapper
public interface LogMapper extends BaseMapper<WmsLog> { 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; package com.wms.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; 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.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/** /**
* 菜单Mapper * 菜单Mapper
*/ */
@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; package com.wms.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; 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; import org.apache.ibatis.annotations.Mapper;
@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.baomidou.mybatisplus.extension.service.IService;
import com.wms.entity.table.WmsLog; import com.wms.entity.table.WmsLog;
import java.util.List;
public interface LogService extends IService<WmsLog> { public interface LogService extends IService<WmsLog> {
/** /**
* 定期删除日志记录（30天清一次） * 定期删除日志记录（30天清一次）

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

@ -1,5 +1,20 @@
package com.wms.service; 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; 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; package com.wms.service.serviceImplements;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 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.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wms.entity.app.dto.WmsLogDto;
import com.wms.entity.table.WmsLog; import com.wms.entity.table.WmsLog;
import com.wms.mapper.LogMapper; import com.wms.mapper.LogMapper;
import com.wms.service.LogService; import com.wms.service.LogService;
import com.wms.utils.StringUtils;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List;
@Service @Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired)) @RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class LogServiceImplements extends ServiceImpl<LogMapper, WmsLog> implements LogService { 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; 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.mapper.MenuMapper;
import com.wms.service.MenuService; import com.wms.service.MenuService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@ -11,13 +14,11 @@ import java.util.List;
@Service @Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired)) @RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class MenuServiceImplements implements MenuService { public class MenuServiceImplements extends ServiceImpl<MenuMapper, Menu> implements MenuService {
private final MenuMapper menuMapper; private final MenuMapper menuMapper;
@Override @Override
public List<MenuDto> selMenuByRoleId(int roleId) { 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; 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.mapper.UserMapper;
import com.wms.service.UserService; import com.wms.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List;
@Service @Service
public class UserServiceImplements implements UserService { @RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class UserServiceImplements extends ServiceImpl<UserMapper, User> implements UserService {
private final UserMapper userMapper; private final UserMapper userMapper;
@Autowired
public UserServiceImplements(UserMapper userMapper) {
this.userMapper = userMapper;
}
@Override @Override
public List<UserDto> selectUsers(UserDto user) { public UserDto validateUser(User user, boolean withAuth) {
return userMapper.selectUsers(user); 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 * @param originalPassword 原始密码
* @return * @return 加密密码
*/ */
public static String encrypt(String originalPassword) { public static String encrypt(String originalPassword) {
byte[] targetPassword; byte[] targetPassword;
@ -46,8 +46,8 @@ public class MyPassword {
/** /**
* 解密 * 解密
* @param targetPassword * @param targetPassword 加密密码
* @return * @return 解密密码
*/ */
public static String decrypt(String targetPassword) { public static String decrypt(String targetPassword) {
byte[] originalPassword; 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" <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"> "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wms.mapper.LogMapper"> <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> </mapper>

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

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