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

1. 增加需求日期的调整；

Browse Source 
2. 增加导入工单和dbs时存在不在工作日的日期时报错；
3. 增加显示工作日历的后台功能；
4. 增加一键切换创建与分配。
This commit is contained in:
梁州 2026-01-08 17:02:33 +08:00
parent b380628d7a
commit 25ce3ec144
11 changed files with 408 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/com/wms/constants/enums/ConfigMapKeyEnum.java
View File

@ -37,7 +37,8 @@ public enum ConfigMapKeyEnum {
SAME_MACHINE("SAME_MACHINE"),
SAME_AREA("SAME_AREA"),
RATE_TYPE("RATE_TYPE"),
USE_REQUIRE_DATE("USE_REQUIRE_DATE");// 是否使用需求时间
USE_REQUIRE_DATE("USE_REQUIRE_DATE"),// 是否使用需求时间
START_DATE_ADJUST("START_DATE_ADJUST");// 开工日期调整天数
private final String configKey;
ConfigMapKeyEnum(String configKey) {
this.configKey = configKey;

153
src/main/java/com/wms/controller/KateWorkQueryController.java
View File

@ -29,10 +29,12 @@ import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
import static com.wms.config.InitLocalConfig.localWorkDateList;
import static com.wms.utils.StringUtils.convertJsonString;
/**
@ -87,6 +89,10 @@ public class KateWorkQueryController {
* 库位配置服务
*/
private final ELocationConfigLastService eLocationConfigLastService;
/**
* 工作日历服务
*/
private final WorkDateService workDateService;
/**
* 请求头部信息
*/
@ -950,4 +956,151 @@ public class KateWorkQueryController {
return convertJsonString(response);
}
}
/**
* 查询工作日历
* @param workDateQuery 查询参数
* @return 查询结果
*/
@PostMapping("/queryWorkDate")
@ResponseBody
public String getOrders(@RequestBody WorkDateQuery workDateQuery) {
logger.info("接收到查询工作日历请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
ResponseEntity response = new ResponseEntity();
try {
if (workDateQuery.getSourceType() == null) {
logger.error("查询工作日历的请求参数缺少来源类型。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询工作日历的请求参数缺少来源类型。");
return convertJsonString(response);
}
if (workDateQuery.getSourceType() == 1) {
// 查询当前正在使用的
List<WorkDateVo> workDateVoList = new ArrayList<>();
int index = 1;
for (LocalDate workDate : localWorkDateList) {
WorkDateVo workDateVo = new WorkDateVo();
workDateVo.setKeyId(index);
workDateVo.setWorkDate(workDate);
workDateVoList.add(workDateVo);
index++;
}
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询工作日历成功");
response.setReturnData(workDateVoList);
return convertJsonString(response);
} else if (workDateQuery.getSourceType() == 2) {
// 查询数据库
Page<WorkDate> page = workDateQuery.toMpPage();
Page<WorkDate> workDatePage = workDateService.page(page, new LambdaQueryWrapper<WorkDate>()
.eq(workDateQuery.getWorkDate() != null, WorkDate::getWorkDate, workDateQuery.getWorkDate()));
PageDto<WorkDateVo> pageDto = PageDto.of(workDatePage, workDate -> BeanUtil.copyProperties(workDate, WorkDateVo.class));
response.setCode(ResponseCode.OK.getCode());
response.setMessage("查询工作日历成功。");
response.setReturnData(pageDto);
return convertJsonString(response);
} else {
logger.error("查询工作日历的请求参数来源类型错误。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询工作日历的请求参数来源类型错误。");
return convertJsonString(response);
}
} catch (Exception e) {
logger.error("查询工作日历发生异常：{}", convertJsonString(e));
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("查询工作日历发生异常");
return convertJsonString(response);
}
}
/**
* 增加一个工作日
*
* @param workDateQuery 新增的工作日信息
* @return 结果
*/
@PostMapping("/addWorkDate")
@ResponseBody
@MyLog(logTitle = "新增工作日", logMethod = "addWorkDate")
public String addWorkDate(@RequestBody WorkDateQuery workDateQuery) {
logger.info("接收到新增工作日请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (workDateQuery.getWorkDate() == null) {// id为空，不允许执行
logger.error("不可新增空的工作日。");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("不可新增空的工作日。");
return convertJsonString(rsp);
}
// 先查询所有的工作日
List<WorkDate> workDateList = workDateService.list(new LambdaQueryWrapper<>());
WorkDate newWorkDate = new WorkDate();
newWorkDate.setWorkDate(workDateQuery.getWorkDate());
newWorkDate.setRemark(workDateQuery.getRemark());
workDateList.add(newWorkDate);
boolean updateResult = workDateService.updateWorkDate(workDateList);
if (updateResult) {
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) {
logger.error("新增工作日发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("新增工作日发生异常");
return convertJsonString(rsp);
}
}
/**
* 删除工作日
*
* @param workDateQuery 删除参数
* @return 结果
*/
@PostMapping("/deleteWorkDate")
@ResponseBody
@MyLog(logTitle = "删除工作日", logMethod = "deleteWorkDate")
public String deleteWorkDate(@RequestBody WorkDateQuery workDateQuery) {
logger.info("接收到删除工作日请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
if (workDateQuery.getWorkDate() == null) {// id为空，不允许执行
logger.error("不可删除空的工作日。");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("不可删除增空的工作日。");
return convertJsonString(rsp);
}
// 先查询所有的工作日
List<WorkDate> workDateList = workDateService.list(new LambdaQueryWrapper<>());
workDateList.removeIf(workDate -> workDate.getWorkDate().equals(workDateQuery.getWorkDate()));
boolean updateResult = workDateService.updateWorkDate(workDateList);
if (updateResult) {
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) {
logger.error("删除工作日发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("删除工作日发生异常");
return convertJsonString(rsp);
}
}
}

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

@ -137,6 +137,90 @@ public class StandController {
}
}
/**
* 一键切换至创建工作状态
*
* @param request 站台信息
* @return 结果
*/
@PostMapping("/switchToCreate")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "一键切换至创建工作状态", logMethod = "switchToCreate")
public String switchToCreate(@RequestBody StandQuery request) {
logger.info("接收到一键切换至创建工作状态请求：{}，请求ip：{}", convertJsonString(request), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 更新信息
LambdaUpdateWrapper<Stand> lambdaUpdateWrapper = new LambdaUpdateWrapper<Stand>()
.set(Stand::getStandStatus, 1)
.eq(Stand::getIsLock, 0)
.eq(Stand::getStandType, 2);
if (standService.update(lambdaUpdateWrapper)) {
logger.info("一键切换创建工作成功。");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("一键切换创建工作成功。");
} else {
logger.error("一键切换创建工作失败。");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("一键切换创建工作失败。");
}
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("一键切换创建工作发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("一键切换创建工作发生异常");
return convertJsonString(rsp);
}
}
/**
* 一键切换至分配工作状态
*
* @param request 站台信息
* @return 结果
*/
@PostMapping("/switchToDistribute")
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
@MyLog(logTitle = "一键切换至分配工作状态", logMethod = "switchToDistribute")
public String switchToDistribute(@RequestBody StandQuery request) {
logger.info("接收到一键切换至分配工作状态请求：{}，请求ip：{}", convertJsonString(request), HttpUtils.getIpAddr(servletRequest));
// 创建响应信息
ResponseEntity rsp = new ResponseEntity();
try {
// 更新信息
LambdaUpdateWrapper<Stand> lambdaUpdateWrapper = new LambdaUpdateWrapper<Stand>()
.set(Stand::getStandStatus, 0)
.eq(Stand::getIsLock, 0)
.eq(Stand::getStandType, 2);
if (standService.update(lambdaUpdateWrapper)) {
logger.info("一键切换至分配工作成功。");
rsp.setCode(ResponseCode.OK.getCode());
rsp.setMessage("一键切换至分配工作成功。");
} else {
logger.error("一键切换至分配工作失败。");
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("一键切换至分配工作失败。");
}
return convertJsonString(rsp);
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
logger.error("一键切换至分配工作发生异常：{}", convertJsonString(e));
// 返回其他异常
rsp.setCode(ResponseCode.ERROR.getCode());
rsp.setMessage("一键切换至分配工作发生异常");
return convertJsonString(rsp);
}
}
/**
* 堆垛机状态变更
*

34
src/main/java/com/wms/entity/app/request/WorkDateQuery.java Normal file
View File

@ -0,0 +1,34 @@
package com.wms.entity.app.request;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDate;
/**
* 工作日历查询参数
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class WorkDateQuery extends PageQuery {
/**
* 工作日
*/
@JsonProperty("workDate")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate workDate;
/**
* 备注
*/
@JsonProperty("remark")
private String remark;
/**
* 查询来源
*/
@JsonProperty("sourceType")
private Integer sourceType;
}

32
src/main/java/com/wms/entity/app/vo/WorkDateVo.java Normal file
View File

@ -0,0 +1,32 @@
package com.wms.entity.app.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDate;
/**
* 工作日历显示类
*/
@Data
public class WorkDateVo {
/**
* id
*/
@JsonProperty("id")
private Integer keyId;
/**
* 工作日
*/
@JsonProperty("workDate")
@JsonFormat(pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private LocalDate workDate;
/**
* 备注
*/
@JsonProperty("remark")
private String remark;
}

7
src/main/java/com/wms/service/WorkDateService.java
View File

@ -3,8 +3,15 @@ package com.wms.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.wms.entity.table.WorkDate;
import java.util.List;
/**
* 卡特DBS服务接口
*/
public interface WorkDateService extends IService<WorkDate> {
/**
* 更新工作日历
* @param workDateList 工作日列表
*/
boolean updateWorkDate(List<WorkDate> workDateList);
}

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

@ -1033,10 +1033,32 @@ public class WorkServiceImplements implements IWorkService {
//开始时间：
LocalDateTime startTime = LocalDateTime.now();
System.out.println("分析当日工作流，开始时间：" + startTime);
// 获取开工日期调整配置
int dateAdjust = 0;
try {
String dateAdjustStr = configMap.get(ConfigMapKeyEnum.START_DATE_ADJUST.getConfigKey());
if (StringUtils.isNotEmpty(dateAdjustStr)) {
dateAdjust = Integer.parseInt(dateAdjustStr);
}
} catch (Exception e) {
logger.error("获取开工日期调整配置失败：{}，使用默认值0。", e.getMessage());
}
// 获取到需要查询的需求日期
int currentDateIndex = localWorkDateList.indexOf(currentWorkDate);
if (currentDateIndex == -1) {
logger.error("当前日期不在配置的工作日历中。");
return;
}
// 获取到需要查询的工单
int requireDateIndex = currentDateIndex - dateAdjust;
if (requireDateIndex < 0 || requireDateIndex >= localWorkDateList.size()) {
logger.error("当前日期对应的需求日期不在配置的工作日历中。");
return;
}
List<KateOrders> currentDateKateWorkOrders = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
.eq(KateOrders::getOrderStatus, 0)
.eq(KateOrders::getSortString, configMap.get(ConfigMapKeyEnum.SLOC_FILTER_STRING.getConfigKey()))
.eq(KateOrders::getPlanStartDate, currentWorkDate));
.eq(KateOrders::getPlanStartDate, localWorkDateList.get(requireDateIndex)));
if (currentDateKateWorkOrders.isEmpty()) {
logger.info("没有当日待生成工作流的工单。");
return;

41
src/main/java/com/wms/service/serviceImplements/WorkDateServiceImpl.java
View File

@ -1,17 +1,54 @@
package com.wms.service.serviceImplements;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wms.entity.table.WorkDate;
import com.wms.mapper.WorkDateMapper;
import com.wms.service.WorkDateService;
import com.wms.utils.DbTransUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Comparator;
import java.util.List;
import static com.wms.config.InitLocalConfig.localWorkDateList;
/**
* 工作日历
*/
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@RequiredArgsConstructor
@Slf4j
public class WorkDateServiceImpl extends ServiceImpl<WorkDateMapper, WorkDate> implements WorkDateService {
private final DbTransUtils dbTransUtils;
/**
* 更新工作日历---实现
* @param workDateList 工作日列表
*/
@Override
public boolean updateWorkDate(List<WorkDate> workDateList) {
// 对工作日列表进行排序
List<WorkDate> sortedWorkDateList = workDateList.stream().sorted(Comparator.comparing(WorkDate::getWorkDate)).toList();
// 设定id
int idIndex = 1;
for (WorkDate workDate : sortedWorkDateList) {
workDate.setKeyId(idIndex);
idIndex++;
}
boolean doTransResult = dbTransUtils.useTran(() -> {
// 删除所有工作日
super.remove(new LambdaQueryWrapper<>());
// 批量插入工作日
super.saveBatch(sortedWorkDateList);
});
if (!doTransResult) {
log.error("更新工作日的事务执行失败。");
}
// 更新本地缓存的工作日历
localWorkDateList = sortedWorkDateList.stream().map(WorkDate::getWorkDate).distinct().toList();
log.info("更新本地缓存的工作日历成功。");
return doTransResult;
}
}

23
src/main/java/com/wms/utils/excel/listener/UploadDbsListener.java
View File

@ -17,6 +17,7 @@ import java.util.List;
import java.util.Map;
import static com.wms.config.InitLocalConfig.configMap;
import static com.wms.config.InitLocalConfig.localWorkDateList;
import static com.wms.utils.WmsUtils.generateId;
/**
@ -52,7 +53,7 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
public void onException(Exception exception, AnalysisContext context) throws Exception {
int rowCount = context.readRowHolder().getRowIndex() + 1;
logger.error("处理Dbs数据发生异常，第{}行发生异常。", rowCount);
throw new Exception("第" + rowCount + "行数据异常。");
throw new Exception("第" + rowCount + "行数据异常。" + exception.getMessage());
}
/**
@ -66,18 +67,22 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
if (kateDbsExcelVo.getWorkSequence() != null
&& StringUtils.isNotEmpty(kateDbsExcelVo.getWorkOrder())
&& StringUtils.isNotEmpty(kateDbsExcelVo.getMachineNo())) {
if (!isAddReqmtDate) {
if(kateDbsExcelVo.getPlanStartDate() != null){
cachedDataList.add(kateDbsExcelVo);
} else {
int rowCount = analysisContext.readRowHolder().getRowIndex() + 1;
if (kateDbsExcelVo.getPlanStartDate() != null) {
// 需要判断日期是否在配置的工作日历里面
int indexOfCurrentDate = localWorkDateList.indexOf(kateDbsExcelVo.getPlanStartDate().toLocalDate());
if (indexOfCurrentDate == -1) {
// 工作日不包含此开工日期
logger.error("第{}行DBS开工日期为非工作日。", rowCount);
throw new RuntimeException("第" + rowCount + "行DBS开工日期为非工作日。");
}
cachedDataList.add(kateDbsExcelVo);
}
if (!isAddReqmtDate) {
// 缺少开工日期
logger.error("第{}行DBS缺少开工日期。", rowCount);
throw new RuntimeException("第" + rowCount + "行DBS缺少开工日期。");
}
} else {
cachedDataList.add(kateDbsExcelVo);
}
}
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
if (cachedDataList.size() >= BATCH_COUNT) {

21
src/main/java/com/wms/utils/excel/listener/UploadKateOrdersListener.java
View File

@ -16,6 +16,7 @@ import java.time.LocalDateTime;
import java.util.*;
import static com.wms.config.InitLocalConfig.configMap;
import static com.wms.config.InitLocalConfig.localWorkDateList;
import static com.wms.utils.WmsUtils.generateId;
/**
@ -71,18 +72,22 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
&& StringUtils.isNotEmpty(kateOrdersExcelVo.getSupplyArea())
&& kateOrdersExcelVo.getRequirementQuantity() != null
&& kateOrdersExcelVo.getRequirementQuantity().compareTo(BigDecimal.ZERO) > 0) {
if (isAddReqmtDate) {
if(kateOrdersExcelVo.getPlanStartDate() != null){
cachedDataList.add(kateOrdersExcelVo);
} else {
int rowCount = analysisContext.readRowHolder().getRowIndex() + 1;
if (kateOrdersExcelVo.getPlanStartDate() != null) {
// 需要判断日期是否在配置的工作日历里面
int indexOfCurrentDate = localWorkDateList.indexOf(kateOrdersExcelVo.getPlanStartDate());
if (indexOfCurrentDate == -1) {
// 工作日不包含此开工日期
logger.error("第{}行工单需求日期为非工作日。", rowCount);
throw new RuntimeException("第" + rowCount + "行工单需求日期为非工作日。");
}
cachedDataList.add(kateOrdersExcelVo);
}
if (!isAddReqmtDate) {
// 缺少开工日期
logger.error("第{}行工单缺少开工日期。", rowCount);
throw new RuntimeException("第" + rowCount + "行工单缺少开工日期。");
}
} else {
// 符合条件
cachedDataList.add(kateOrdersExcelVo);
}
}
}
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM

13
src/main/java/com/wms/utils/excel/listener/UploadWorkDateListener.java
View File

@ -11,6 +11,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -28,7 +29,6 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
private static final int BATCH_COUNT = 100;
private List<WorkDateExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
private final WorkDateService workDateService;// 工作日服务
private int key = 1;// 主键
private final Map<LocalDate, WorkDate> newWorkDateMap = new HashMap<>();// 新的工作日
public UploadWorkDateListener(WorkDateService workDateService) {
this.workDateService = workDateService;
@ -86,11 +86,9 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
}
// 创建一个新的工作日历对象
WorkDate workDate = new WorkDate();
workDate.setKeyId(key);
workDate.setWorkDate(workDateExcelVo.getWorkDate());
workDate.setRemark(workDateExcelVo.getRemark());
newWorkDateMap.put(workDateExcelVo.getWorkDate(), workDate);
key++;
}
}
@ -99,11 +97,10 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
*/
private void insertIntoDb() {
logger.info("此次共导入{}条数据。", newWorkDateMap.size());
// 保存数据
workDateService.saveOrUpdateBatch(newWorkDateMap.values(), BATCH_COUNT);
// 先移除之前的数据
if (!workDateService.updateWorkDate(new ArrayList<>(newWorkDateMap.values()))) {
throw new RuntimeException("保存数据库失败。");
}
logger.info("保存成功{}条数据。", newWorkDateMap.size());
// 生成工作日历
localWorkDateList = workDateService.list(new LambdaQueryWrapper<WorkDate>().orderByAsc(WorkDate::getWorkDate)).stream().map(WorkDate::getWorkDate).distinct().toList();
logger.info("生成工作日历Map成功。");
}
}