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

1.优化

Browse Source
This commit is contained in:
梁州 2025-03-29 22:27:48 +08:00
parent 1552ff85bd
commit 74a83f2927
12 changed files with 480 additions and 146 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

@ -24,7 +24,8 @@ public enum ConfigMapKeyEnum {
USE_SETTING_DATE("USE_SETTING_DATE"),
SETTING_DATE("SETTING_DATE"),
RATE_MIN_TO_MAX("RATE_MIN_TO_MAX"),
WORK_PRIORITY("WORK_PRIORITY");
WORK_PRIORITY("WORK_PRIORITY"),
IF_MERGE_TOMORROW("IF_MERGE_TOMORROW");
private final String configKey;
ConfigMapKeyEnum(String configKey) {
this.configKey = configKey;

25
src/main/java/com/wms/constants/enums/KateTaskStatus.java
View File

@ -1,25 +0,0 @@
package com.wms.constants.enums;
public enum KateTaskStatus {
NEW(0, "待下发"),
WAIT(1, "已下发"),
RUN(2, "执行中"),
PICKING(3, "正在拣货"),
FINISH(5, "任务完成");
private final Integer code;
private final String name;
KateTaskStatus(Integer code, String name) {
this.code = code;
this.name = name;
}
public Integer getCode() {
return code;
}
public String getName() {
return name;
}
}

27
src/main/java/com/wms/constants/enums/MesStatus.java
View File

@ -1,27 +0,0 @@
package com.wms.constants.enums;
/**
* 向mes反馈的任务状态码
*/
public enum MesStatus {
WAIT(0, "等待执行"),
RUN(1, "执行中"),
FINISH(2, "执行完成"),
EXCEPTION(3, "任务异常");
private final Integer statusCode;
private final String statusInfo;
MesStatus(Integer statusCode, String statusInfo) {
this.statusCode = statusCode;
this.statusInfo = statusInfo;
}
public Integer getStatusCode() {
return statusCode;
}
public String getStatusInfo() {
return statusInfo;
}
}

26
src/main/java/com/wms/constants/enums/StandStatus.java
View File

@ -1,26 +0,0 @@
package com.wms.constants.enums;
/**
* 站台状态的枚举
*/
public enum StandStatus {
OK(0, "可用"),
OCCUPY(1, "占用");
private final Integer code;
private final String value;
StandStatus(Integer code, String value) {
this.code = code;
this.value = value;
}
public Integer getCode() {
return code;
}
public String getValue() {
return value;
}
}

22
src/main/java/com/wms/constants/enums/UrlEnums.java
View File

@ -1,22 +0,0 @@
package com.wms.constants.enums;
public enum UrlEnums {
URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "/api/Wms/WmsTask/SetStackerTask"),
URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "/api/Wms/WmsTask/ChangeTaskStatus");
private final String description;
private final String value;
UrlEnums(String description, String value) {
this.description = description;
this.value = value;
}
public String getDescription() {
return description;
}
public String getValue() {
return value;
}
}

26
src/main/java/com/wms/constants/enums/WcsChangeTaskStatus.java
View File

@ -1,26 +0,0 @@
package com.wms.constants.enums;
/**
* 向Wcs发送任务变更时的任务状态枚举
*/
public enum WcsChangeTaskStatus {
FINISH(0, "重新执行任务"),
CANCEL(1, "取消/删除任务"),
EXCEPTION(2, "完成任务");
private final Integer code;
private final String message;
WcsChangeTaskStatus(Integer code, String message) {
this.code = code;
this.message = message;
}
public Integer getCode() {
return code;
}
public String getMessage() {
return message;
}
}

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

@ -171,16 +171,24 @@ public class JobComponent {
if (now.isBefore(LocalDateTime.of(now.toLocalDate(), LocalTime.of(7, 40))) || now.isAfter(LocalDateTime.of(now.toLocalDate(), LocalTime.of(23, 40)))) {
return;
}
try {
workService.createTempWorkFlows();
} catch (Exception e) {
logger.error("创建当日工作发生错误：{}", e.getMessage());
}
// 轮询工作站台，判断是否需要下发任务
List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
.eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
.eq(Stand::getStandType, 2));
for (Stand workStation : stands) {
try {
// 创建工作
workService.createWork(workStation.getStandId());
// // 创建工作
// workService.createWork(workStation.getStandId());
// 分配工作
workService.distributeWorks(workStation.getStandId());
} catch (Exception e) {
logger.error("创建工作时发生错误：{}", convertJsonString(e.getMessage()));
// logger.error("创建工作时发生错误：{}", e.getMessage());
logger.error("分配工作时发生错误：{}", e.getMessage());
}
}
}

11
src/main/java/com/wms/entity/table/WorkFlow.java
View File

@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
/**
@ -85,4 +86,14 @@ public class WorkFlow {
*/
@TableField("op_user")
private String opUser;
/**
* 机器类型
*/
@TableField("machine_type")
private Integer machineType;
/**
* 计划日期
*/
@TableField("plan_date")
private LocalDate planDate;
}

11
src/main/java/com/wms/entity/table/WorkFlowLast.java
View File

@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
/**
@ -85,4 +86,14 @@ public class WorkFlowLast {
*/
@TableField("op_user")
private String opUser;
/**
* 机器类型
*/
@TableField("machine_type")
private Integer machineType;
/**
* 计划日期
*/
@TableField("plan_date")
private LocalDate planDate;
}

11
src/main/java/com/wms/entity/table/WorkSummary.java
View File

@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
/**
@ -89,4 +90,14 @@ public class WorkSummary {
*/
@TableField("e_location_id")
private String eLocationId;
/**
* 机器类型
*/
@TableField("machine_type")
private Integer machineType;
/**
* 计划日期
*/
@TableField("plan_date")
private LocalDate planDate;
}

15
src/main/java/com/wms/service/business/IWorkService.java
View File

@ -27,5 +27,18 @@ public interface IWorkService {
* 完成工作
* @param workStation 工作站台
*/
String finishWork(String workStation) throws Exception;
String finishWork(String workStation);
/**
* 创建暂存工作
* @throws Exception 异常
*/
void createTempWorkFlows() throws Exception;
/**
* 分配工作
* @param workStation 站台号
* @throws Exception 异常
*/
void distributeWorks(String workStation) throws Exception;
}

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

@ -115,6 +115,11 @@ public class WorkServiceImplements implements IWorkService {
List<WorkFlow> currentStationWorkFlows = new ArrayList<>();
// 先找MWL机型
String workPriority = configMap.get(ConfigMapKeyEnum.WORK_PRIORITY.getConfigKey());
// 查找到当前站台所有可用的电子标签
List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
.eq(ETagLocation::getWorkStation, workStation)
.eq(ETagLocation::getELocationStatus, 0)
.orderByAsc(ETagLocation::getSequenceId));
if (!StringUtils.isEmpty(workPriority) && workPriority.equals("1")) {
// 找非MWL机型--先平地机
findWorks(workStation, currentStationWorkFlows, "NOT_MWL", currentWorkDate);
@ -129,6 +134,7 @@ public class WorkServiceImplements implements IWorkService {
findWorks(workStation, currentStationWorkFlows, "NOT_MWL", currentWorkDate);
}
}
// 如果当前站台有任务
if (!currentStationWorkFlows.isEmpty()) {
// 将工作流列表添加进数据库
@ -158,6 +164,9 @@ public class WorkServiceImplements implements IWorkService {
needGoodsMap.replace(tempWorkflow.getGoodsId(), needGoodsMap.get(tempWorkflow.getGoodsId()).add(tempWorkflow.getNeedNum()));
}
}
if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
}
// 站台要料
List<GoodsToStation> goodsToStationList = new ArrayList<>();
for (String goodsId : needGoodsMap.keySet()) {
@ -188,14 +197,6 @@ public class WorkServiceImplements implements IWorkService {
}
// 电子标签库位配置
List<ELocationConfig> eLocationConfigList = new ArrayList<>();
// 查找到当前站台所有可用的电子标签
List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
.eq(ETagLocation::getWorkStation, workStation)
.eq(ETagLocation::getELocationStatus, 0)
.orderByAsc(ETagLocation::getSequenceId));
if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
}
for (ETagLocation eTagLocation : eTagLocationList) {
if (boxNoList.isEmpty()) {
break;
@ -225,6 +226,27 @@ public class WorkServiceImplements implements IWorkService {
}
}
/**
* 找到下一个工作日
*
* @param currentDate 当前日期
* @return 下一个工作日
*/
private LocalDate nextWorkDate(LocalDate currentDate) {
// 判断是否是当天开工
int indexOfCurrentDate = localWorkDateList.indexOf(currentDate);
if (indexOfCurrentDate == -1) {
// 工作日不包含此开工日期
return null;
}
int indexAfterAdjust = indexOfCurrentDate + 1;
if (indexAfterAdjust >= localWorkDateList.size()) {
// 调整后的日期不再工作日范围
return null;
}
return localWorkDateList.get(indexAfterAdjust);
}
/**
* 新版开始工作
*
@ -244,7 +266,8 @@ public class WorkServiceImplements implements IWorkService {
// 查找当前站台未开始的工作流
List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, workStation)
.ne(WorkFlow::getWorkStatus, 2));
.notIn(WorkFlow::getWorkStatus, -1, 2));
// .ne(WorkFlow::getWorkStatus, 2));
// 没有可做的任务
if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
return;
@ -422,10 +445,9 @@ public class WorkServiceImplements implements IWorkService {
*
* @param workStation 工作站台
* @return 结果
* @throws Exception 异常
*/
@Override
public String finishWork(String workStation) throws Exception {
public String finishWork(String workStation) {
if (workFinishingStations.contains(workStation)) {
// 当前站台正在完成工作
return "当前站台正在完成工作，请勿重复操作";
@ -433,9 +455,11 @@ public class WorkServiceImplements implements IWorkService {
// 添加站台
workFinishingStations.add(workStation);
}
String result = "";
try {
if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, workStation)
.notIn(WorkFlow::getWorkStatus, -1, 2)
.ne(WorkFlow::getWorkStatus, 2))) {
// 当前站台工作未全部完成
return "工作未全部做完，不允许确认完成。";
@ -521,12 +545,12 @@ public class WorkServiceImplements implements IWorkService {
.eq(GoodsToStation::getWorkStation, workStation));
} catch (Exception e) {
logger.error("完成站台：{}工作发生异常：{}", workStation, convertJsonString(e));
throw new Exception("完成站台：" + workStation + "工作发生异常!");
result = "完成站台：" + workStation + "工作发生异常!";
} finally {
// 当前站台工作完成
workFinishingStations.remove(workStation);
}
return "";
return result;
}
/**
@ -538,7 +562,8 @@ public class WorkServiceImplements implements IWorkService {
*/
private void findWorks(String workStation, List<WorkFlow> workFlows, String model, LocalDate currentWorkDate) {
// 查到当前站台所有的小工位
LambdaQueryWrapper<WorkStationConfig> stationConfigQueryWrapper = new LambdaQueryWrapper<WorkStationConfig>().eq(WorkStationConfig::getWorkStation, workStation);
LambdaQueryWrapper<WorkStationConfig> stationConfigQueryWrapper = new LambdaQueryWrapper<WorkStationConfig>()
.eq(StringUtils.isNotEmpty(workStation), WorkStationConfig::getWorkStation, workStation);
if (Objects.equals(model, "MWL")) {
stationConfigQueryWrapper.eq(WorkStationConfig::getModel, "MWL");
} else {
@ -631,6 +656,9 @@ public class WorkServiceImplements implements IWorkService {
tempWorkFlow.setWorkStatus(0);
tempWorkFlow.setLightStatus(0);
tempWorkFlow.setPickedNum(BigDecimal.ZERO);
// 改动
tempWorkFlow.setMachineType(Objects.equals(model, "MWL") ? 1 : 2);
tempWorkFlow.setPlanDate(currentWorkDate);
workFlows.add(tempWorkFlow);
}
}
@ -638,6 +666,383 @@ public class WorkServiceImplements implements IWorkService {
}
}
/**
* 获取当前的工作日期
*
* @return 当前的工作日期
*/
private LocalDate getCurrentWorkDate() {
// 先判断当日是否是工作日
LocalDate currentWorkDate = LocalDate.now();
// 获取当前配置日期
try {
String useSettingDate = configMap.get(ConfigMapKeyEnum.USE_SETTING_DATE.getConfigKey());
if (!StringUtils.isEmpty(useSettingDate) && useSettingDate.equals("1")) {
String settingDate = configMap.get(ConfigMapKeyEnum.SETTING_DATE.getConfigKey());
if (!StringUtils.isEmpty(settingDate)) {
String[] settingDateArray = settingDate.split("-");
int settingDateYear = Integer.parseInt(settingDateArray[0]);
int settingDateMonth = Integer.parseInt(settingDateArray[1]);
int settingDateDay = Integer.parseInt(settingDateArray[2]);
// 系统配置的当前日期
currentWorkDate = LocalDate.of(settingDateYear, settingDateMonth, settingDateDay);
}
}
} catch (Exception e) {
logger.error("获取配置工作日期错误，使用当前系统日期。");
}
return currentWorkDate;
}
/**
* 尝试，先生成工作流
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void createTempWorkFlows() {
LocalDate currentWorkDate = getCurrentWorkDate();
if (!localWorkDateList.contains(currentWorkDate)) {
return;
}
// 添加进总汇总数据
List<WorkFlow> allFlows = new ArrayList<>();
// 获取当天所有的装载机工作
List<WorkFlow> thisDayMWLWorks = new ArrayList<>();
findWorks("", thisDayMWLWorks, "MWL", currentWorkDate);
if (!thisDayMWLWorks.isEmpty()) {
allFlows.addAll(thisDayMWLWorks);
}
// 获取到当天所有的平地机工作
List<WorkFlow> thisDayMGWorks = new ArrayList<>();
findWorks("", thisDayMGWorks, "NOT_MWL", currentWorkDate);
if (!thisDayMGWorks.isEmpty()) {
allFlows.addAll(thisDayMGWorks);
// 查询配置是否需要合并第二天的配置
String ifMergeTomorrow = configMap.get(ConfigMapKeyEnum.IF_MERGE_TOMORROW.getConfigKey());
if (!StringUtils.isEmpty(ifMergeTomorrow) && ifMergeTomorrow.equals("1")) {
// 需要合并第二天的平地机工作
List<WorkFlow> nextDayMGWorks = new ArrayList<>();
// 获取下一个工作日
LocalDate nextWorkDate = nextWorkDate(currentWorkDate);
if (nextWorkDate != null && nextWorkDate.isAfter(currentWorkDate)) {
findWorks("", nextDayMGWorks, "NOT_MWL", nextWorkDate);
}
if (!nextDayMGWorks.isEmpty()) {
// 添加第二天的平地机工作进汇总
allFlows.addAll(nextDayMGWorks);
}
}
}
// 处理这些工作流
List<WorkFlow> oldWorkFlows = workFlowService.list();
// 按照工单号+小盒子号+料号来map一下
Map<String, WorkFlow> oldWorkFlowsMap = oldWorkFlows.stream().collect(
Collectors.toMap(workFlow ->
workFlow.getWorkOrder() + "_" + workFlow.getWorkCenter() + "_" + workFlow.getGoodsId(), workFlow -> workFlow));
// 最后需要存储的工作
List<WorkFlow> finalWorkFlows = new ArrayList<>();
for (WorkFlow workFlow : allFlows) {
String key = workFlow.getWorkOrder() + "_" + workFlow.getWorkCenter() + "_" + workFlow.getGoodsId();
if (oldWorkFlowsMap.containsKey(key)) {
continue;
}
workFlow.setWorkStatus(-1);// 设置暂存状态
finalWorkFlows.add(workFlow);
}
if (!finalWorkFlows.isEmpty()) {
// 存储数据
workFlowService.saveBatch(finalWorkFlows);
// 更新工单状态
List<String> orderIds = finalWorkFlows.stream().map(WorkFlow::getOrderId).toList();
if (!orderIds.isEmpty()) {
kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
.set(KateOrders::getOrderStatus, 1)
.in(KateOrders::getOrderId, orderIds)
.eq(KateOrders::getOrderStatus, 0));
}
// 更新dbs表
List<String> workOrderList = finalWorkFlows.stream().map(WorkFlow::getWorkOrder).distinct().toList();
if (!workOrderList.isEmpty()) {
kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
.set(KateDBS::getDbsStatus, 1)
.in(KateDBS::getWorkOrder, workOrderList)
.eq(KateDBS::getDbsStatus, 0));
}
}
}
/**
* 分配任务
*
* @param workStation 站台号
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void distributeWorks(String workStation) {
if (workCreatingStations.contains(workStation)) {
// 当前站台正在创建任务
return;
} else {
// 添加站台
workCreatingStations.add(workStation);
}
if (StringUtils.isEmpty(workStation)) {
// 站台号为空
return;
}
try {
// 获取工作优先级
String workPriority = configMap.get(ConfigMapKeyEnum.WORK_PRIORITY.getConfigKey());
List<WorkFlow> needDistributeWorks = new ArrayList<>();
if (!StringUtils.isEmpty(workPriority) && workPriority.equals("1")) {
// 当前工作优先级为先平地机后装载机
// 查询当前站台是否还有装载机的任务没做完
List<WorkFlow> oldMwlWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, workStation)
.eq(WorkFlow::getMachineType, 1)
.ne(WorkFlow::getWorkStatus, -1));
if (!oldMwlWorks.isEmpty()) {
// 装载机没做完，不允许做平地机
return;
}
// 查询已经生成的工作
List<WorkFlow> oldWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getMachineType, 2)
.eq(WorkFlow::getWorkStatus, -1));
if (oldWorkFlows.isEmpty()) {
// 判断下是否有平地机任务还未生成
List<WorkFlow> notCreatedMGWorks = new ArrayList<>();
findWorks("", notCreatedMGWorks, "NOT_MWL", getCurrentWorkDate());
if (!notCreatedMGWorks.isEmpty()) {
// 仍有未生成的平地机任务，跳过
return;
}
// 查询装载机
List<WorkFlow> mwlWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getMachineType, 1)
.eq(WorkFlow::getWorkStatus, -1));
if (mwlWorks.isEmpty()) {
// 没有装载机任务，跳过
return;
}
needDistributeWorks.addAll(mwlWorks);
} else {
needDistributeWorks.addAll(oldWorkFlows);
}
} else {
// 默认优先级为先装载机后平地机
// 查询当前站台是否还有平地机的任务没做完
List<WorkFlow> oldMgWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getWorkStation, workStation)
.eq(WorkFlow::getMachineType, 2)
.ne(WorkFlow::getWorkStatus, -1));
if (!oldMgWorks.isEmpty()) {
// 平地机没做完，不允许做装载机
return;
}
List<WorkFlow> oldWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getMachineType, 1)
.eq(WorkFlow::getWorkStatus, -1));
if (oldWorkFlows.isEmpty()) {
// 判断下是否有装载机任务还未生成
List<WorkFlow> notCreatedMWLWorks = new ArrayList<>();
findWorks("", notCreatedMWLWorks, "MWL", getCurrentWorkDate());
if (!notCreatedMWLWorks.isEmpty()) {
// 仍有未生成的装载机任务，跳过
return;
}
// 查询平地机
List<WorkFlow> mgWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
.eq(WorkFlow::getMachineType, 2)
.eq(WorkFlow::getWorkStatus, -1));
if (mgWorks.isEmpty()) {
// 没有平地机任务，跳过
return;
}
needDistributeWorks.addAll(mgWorks);
} else {
needDistributeWorks.addAll(oldWorkFlows);
}
}
// 最终需要存储的数据
List<GoodsToStation> finalGoodsToStations;// 物料分配
List<ELocationConfig> finalELocationConfigs = new ArrayList<>();// 标签库位分配
// 获取当前站台所有可用的电子标签库位
List<ETagLocation> thisStandELocations = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
.eq(ETagLocation::getWorkStation, workStation)
.eq(ETagLocation::getELocationStatus, 0)
.orderByAsc(ETagLocation::getSequenceId));
// 获取已经添加的电子标签库位分配
List<ELocationConfig> allELocationConfigs = eLocationConfigService.list();
// 筛选出剩余可用的电子标签库位
List<String> usedELocationIds = allELocationConfigs.stream().map(ELocationConfig::getELocationId).distinct().toList();
List<String> remainELocationIds = new ArrayList<>();
for (ETagLocation eTagLocation : thisStandELocations) {
if (usedELocationIds.contains(eTagLocation.getELocationId())) {
continue;
}
remainELocationIds.add(eTagLocation.getELocationId());
}
if (remainELocationIds.isEmpty()) {
// 当前站台没有可用电子标签库位分配了，跳过
return;
}
// 然后获取大盒子-订单的map
Map<String, List<WorkFlow>> workFlowsByBigBoxMap = new HashMap<>();
// 获取工站配置
List<WorkStationConfig> workStationConfigs = workStationConfigService.list();
// 根据小盒子号生成map
Map<String, String> smallBoxToBigBoxConfigMap = workStationConfigs.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getBigBox));
for (WorkFlow workFlow : needDistributeWorks) {
if (smallBoxToBigBoxConfigMap.containsKey(workFlow.getWorkCenter())) {
if (workFlowsByBigBoxMap.containsKey(smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter()))) {
String bigBox = smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter());
List<WorkFlow> thisBoxWorkFlows = new ArrayList<>(workFlowsByBigBoxMap.get(bigBox));
thisBoxWorkFlows.add(workFlow);
workFlowsByBigBoxMap.replace(bigBox, thisBoxWorkFlows);
} else {
workFlowsByBigBoxMap.put(smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter()), List.of(workFlow));
}
}
}
// 根据订单量，对大盒子号进行一个排序
List<String> bigBoxes = workFlowsByBigBoxMap.keySet().stream().sorted(Comparator.comparingInt(o -> workFlowsByBigBoxMap.get(o).size())).toList();
// 对已有的大盒子进行一个配置
Map<String, String> stationOfBigBoxMap = new HashMap<>();
// 针对此站台的料盒号（工单@工作中心）生成一个map
Map<String, String> eLocationIdOfBoxMap = new HashMap<>();
for (ELocationConfig oldELocationConfig : allELocationConfigs) {
if (!stationOfBigBoxMap.containsKey(oldELocationConfig.getWorkCenter())) {
// 默认大盒子 = 小盒子
String bigBox = oldELocationConfig.getWorkCenter();
if (smallBoxToBigBoxConfigMap.containsKey(oldELocationConfig.getWorkCenter())) {
// 设置为实际的大盒子
bigBox = smallBoxToBigBoxConfigMap.get(oldELocationConfig.getWorkCenter());
}
stationOfBigBoxMap.put(bigBox, oldELocationConfig.getWorkStation());
}
// 更新料盒号-电子标签库位Map
if (!eLocationIdOfBoxMap.containsKey(oldELocationConfig.getOrderBoxNo())) {
eLocationIdOfBoxMap.put(oldELocationConfig.getOrderBoxNo(), oldELocationConfig.getELocationId());
}
}
// 开始分配电子标签库位
List<WorkFlow> thisTimeDistributeWorkFlows = new ArrayList<>();
for (String bigBox : bigBoxes) {
if (remainELocationIds.isEmpty()) {
// 当前站台没有剩余电子标签位置可以分配了
break;
}
// 判断这个大盒子是否分配了站台
if (stationOfBigBoxMap.containsKey(bigBox) && !stationOfBigBoxMap.get(bigBox).equals(workStation)) {
continue;
}
// 获取到这个大盒子下面的所有工作流
List<WorkFlow> thisBigBoxWorks = workFlowsByBigBoxMap.get(bigBox);
// 未分配的工作流，按照boxNo分组
Map<String, List<WorkFlow>> notDistributeYetWorksByBoxMap = new HashMap<>();
for (WorkFlow workFlow : thisBigBoxWorks) {
String boxNo = workFlow.getWorkOrder() + "@" + workFlow.getWorkCenter();
if (!eLocationIdOfBoxMap.containsKey(boxNo)) {
if (notDistributeYetWorksByBoxMap.containsKey(boxNo)) {
List<WorkFlow> thisBoxNotDistributeYetWorks = new ArrayList<>(notDistributeYetWorksByBoxMap.get(boxNo));
thisBoxNotDistributeYetWorks.add(workFlow);
notDistributeYetWorksByBoxMap.replace(boxNo, thisBoxNotDistributeYetWorks);
} else {
notDistributeYetWorksByBoxMap.put(boxNo, List.of(workFlow));
}
}
}
if (notDistributeYetWorksByBoxMap.isEmpty()) {
// 当前大盒子全部分配完毕
continue;
}
// 判断电子标签库位是否足够
if (notDistributeYetWorksByBoxMap.size() > remainELocationIds.size()) {
// 这个大盒子的位置不够了，整个大盒子都不分配。
continue;
}
for (String boxNo : notDistributeYetWorksByBoxMap.keySet()) {
if (eLocationIdOfBoxMap.containsKey(boxNo)) {
continue;
}
// 获取一个电子标签库位
String eLocationId = remainELocationIds.get(0);
ELocationConfig eLocationConfig = new ELocationConfig();
eLocationConfig.setWorkOrder(boxNo.split("@")[0]);
eLocationConfig.setWorkCenter(boxNo.split("@")[1]);
eLocationConfig.setWorkStation(workStation);
eLocationConfig.setELocationId(eLocationId);
eLocationConfig.setOrderBoxNo(boxNo);
// 添加配置
finalELocationConfigs.add(eLocationConfig);
eLocationIdOfBoxMap.put(boxNo, eLocationId);
// 添加此次分配列表
thisTimeDistributeWorkFlows.addAll(notDistributeYetWorksByBoxMap.get(boxNo));
// 移除这个库位
remainELocationIds.remove(eLocationId);
}
}
// 处理分配
List<GoodsToStation> oldGoodsStations = goodsToStationService.list(
new LambdaQueryWrapper<GoodsToStation>().eq(GoodsToStation::getWorkStation, workStation)
);
// 根据料号Map一下
Map<String, GoodsToStation> oldGoodsStationsMap = oldGoodsStations.stream().collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
// 新增
Map<String, GoodsToStation> newGoodsToStationMap = new HashMap<>();
for (WorkFlow workFlow : thisTimeDistributeWorkFlows) {
if (newGoodsToStationMap.containsKey(workFlow.getGoodsId())) {
// 更新totalNum，并把状态改成分配中
GoodsToStation goodsToStation = newGoodsToStationMap.get(workFlow.getGoodsId());
goodsToStation.setTotalNum(goodsToStation.getTotalNum().add(workFlow.getNeedNum()));
newGoodsToStationMap.replace(workFlow.getGoodsId(), goodsToStation);
} else {
GoodsToStation newGoodsToStation = new GoodsToStation();
if (oldGoodsStationsMap.containsKey(workFlow.getGoodsId())) {
// 以前分配过，添加老数据，只更新totalNum与状态
newGoodsToStation.setConfigId(oldGoodsStationsMap.get(workFlow.getGoodsId()).getConfigId());
newGoodsToStation.setTotalNum(oldGoodsStationsMap.get(workFlow.getGoodsId()).getTotalNum().add(workFlow.getNeedNum()));
newGoodsToStation.setDistributeStatus(1);
} else {
newGoodsToStation.setConfigId(generateId(""));
newGoodsToStation.setGoodsId(workFlow.getGoodsId());
newGoodsToStation.setWorkStation(workStation);
newGoodsToStation.setDistributeStatus(0);
newGoodsToStation.setDistributedNum(BigDecimal.ZERO);
newGoodsToStation.setTotalNum(workFlow.getNeedNum());
}
newGoodsToStationMap.put(workFlow.getGoodsId(), newGoodsToStation);
}
}
finalGoodsToStations = newGoodsToStationMap.values().stream().toList();
// 以下开始更新数据
if (!finalGoodsToStations.isEmpty()) {
goodsToStationService.saveOrUpdateBatch(finalGoodsToStations);
}
// 添加电子标签库位分配数据
if (!finalELocationConfigs.isEmpty()) {
// 添加电子标签库位配置
eLocationConfigService.saveBatch(finalELocationConfigs);
}
// 更新工作流数据
List<String> flowIds = thisTimeDistributeWorkFlows.stream().map(WorkFlow::getWorkFlowId).toList();
if (!flowIds.isEmpty()) {
workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
.set(WorkFlow::getWorkStatus, 0)
.set(WorkFlow::getWorkStation, workStation)
.in(WorkFlow::getWorkFlowId, flowIds));
}
} catch (Exception e) {
logger.error("分配站台：{}工作发生异常：{}", workStation, convertJsonString(e));
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
} finally {
// 当前站台创建任务完成
workCreatingStations.remove(workStation);
}
}
/**
* 新版开始工作
*/
@ -915,7 +1320,7 @@ public class WorkServiceImplements implements IWorkService {
List<Stock> thisGoodsStockList = usedStockList.stream().filter(
stock ->
stock.getGoodsRelated().getGoodsId().equals(goodsId)
&& stock.getGoodsRelated().getRemainNum().compareTo(BigDecimal.ZERO) > 0).toList();
&& stock.getGoodsRelated().getRemainNum().compareTo(BigDecimal.ZERO) > 0).toList();
if (thisGoodsStockList.isEmpty()) {
// 缺料
thisGoodsToStation.setDistributeStatus(3);