root/HuaYuJingMi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add:新增功能提交；

Browse Source
This commit is contained in:
gongbaoxiong
2026-05-21 15:10:47 +08:00
parent 8a7cd4332c
commit eca0edad64
670 changed files with 2095 additions and 651 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
nladmin-system/nlsso-server/src/main/java/org/nl/common/utils/RedissonUtils.java
View File

@@ -37,7 +37,7 @@ public class RedissonUtils {
if (isLock){
process.process();
} else {
throw new BadRequestException("当前业务:"+key+"正在执行请稍后再试");
throw new BadRequestException("当前业务:"+key+"已经正在执行，请勿频繁提交。");
}
}catch (Exception ex){
log.error("key:"+ex.getMessage());

10
nladmin-system/nlsso-server/src/main/java/org/nl/wms/basedata_manage/controller/StructattrController.java
View File

@@ -17,6 +17,8 @@ import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
@@ -66,8 +68,16 @@ public class StructattrController {
@PutMapping("/changeActive")
@Log("修改仓位状态")
public ResponseEntity<Object> update(@RequestBody JSONObject json) {
structattrService.changeActive(json);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
@Log("设为超托")
@PostMapping("/setStructType")
public ResponseEntity<Object> setStructType(@RequestBody JSONObject params) {
return new ResponseEntity<>(Collections.singletonMap("message", structattrService.setStructType(params)), HttpStatus.OK);
}
}

9
nladmin-system/nlsso-server/src/main/java/org/nl/wms/basedata_manage/service/IStructattrService.java
View File

@@ -79,6 +79,15 @@ public interface IStructattrService extends IService<Structattr> {
*/
void changeActive(JSONObject json);
/**
* type为1普通库位/2设为超托
*
* @param params 参数，包含type和data（仓位编码列表）
* @return 操作结果提示信息
*/
String setStructType(JSONObject params);
void updateStatusByCode(String operate, JSONObject JSONObject);
/**

203
nladmin-system/nlsso-server/src/main/java/org/nl/wms/basedata_manage/service/impl/StructattrServiceImpl.java
View File

@@ -92,58 +92,91 @@ public class StructattrServiceImpl extends ServiceImpl<StructattrMapper, Structa
String sect_code = (String) whereJson.get("sect_code");
String lock_type = (String) whereJson.get("lock_type");
String layer_num = (String) whereJson.get("layer_num");
String row_num = (String) whereJson.get("row_num");
String col_num = (String) whereJson.get("col_num");
//是否超托
String is_storType = (String) whereJson.get("is_storType");
//托盘类型
String is_width = (String) whereJson.get("is_width");
String is_used = (String) whereJson.get("is_used");
String is_have = (String) whereJson.get("is_have");
LambdaQueryWrapper<Structattr> queryWrapper = new LambdaQueryWrapper<>();
// 处理搜索条件
if (StrUtil.isNotEmpty(search)) {
if (search.contains("CT")) {
if (search.length() < 12) {
throw new BadRequestException("输入长度有误，请输入正确的仓位信息：" + search);
}
String suffix = search.substring(search.length() - 6);
int rowNum = Integer.parseInt(suffix.substring(0, 2));
int colNum = Integer.parseInt(suffix.substring(2, 4));
int layerNum = Integer.parseInt(suffix.substring(4, 6));
String remark = search.substring(2);
String prefixForRemark1 = remark.substring(0, remark.length() - 6);
int newCol = colNum + 1;
if (newCol > 99) {
throw new BadRequestException("列号+1后超出范围（>99）：" + search);
}
String newSixDigits = String.format("%02d", rowNum) +
String.format("%02d", newCol) +
String.format("%02d", layerNum);
String remark1 = prefixForRemark1 + newSixDigits;
queryWrapper.and(wrapper ->
wrapper.like(Structattr::getStruct_code, remark)
.or()
.like(Structattr::getStruct_code, remark1).or()
.like(Structattr::getStruct_name, search)
);
// 超托单库位搜索
boolean isSuperPalletSearch = StrUtil.isNotEmpty(is_width) && "2".equals(is_width) && search.contains("CT");
if (isSuperPalletSearch) {
buildSuperPalletSearchQuery(queryWrapper, search);
} else {
queryWrapper.and(wrapper ->
wrapper.like(Structattr::getStruct_code, search)
.or()
.like(Structattr::getStruct_name, search).or()
.like(Structattr::getStruct_name, search)
.or()
.like(Structattr::getStoragevehicle_code, search)
);
}
}
if (StrUtil.isNotEmpty(is_width)) {
switch (is_width) {
case "1":
queryWrapper.isNull(Structattr::getStor_type).and(wrapper -> wrapper.isNull(Structattr::getWidth));
break;
case "2":
queryWrapper.isNotNull(Structattr::getStor_type);
break;
case "3":
queryWrapper.isNotNull(Structattr::getWidth);
break;
}
}
queryWrapper.eq(StrUtil.isNotEmpty(stor_id), Structattr::getStor_id, stor_id)
.eq(StrUtil.isNotEmpty(sect_id), Structattr::getSect_id, sect_id)
.eq(StrUtil.isNotEmpty(sect_code), Structattr::getSect_code, sect_code)
.eq(StrUtil.isNotEmpty(lock_type), Structattr::getLock_type, lock_type)
.eq(StrUtil.isNotEmpty(row_num), Structattr::getRow_num, row_num)
.eq(StrUtil.isNotEmpty(col_num), Structattr::getCol_num, col_num)
.eq(StrUtil.isNotEmpty(layer_num), Structattr::getLayer_num, layer_num)
.eq(StrUtil.isNotEmpty(is_used), Structattr::getIs_used, is_used)
.isNull("0".equals(is_storType), Structattr::getStor_type)
.isNotNull("1".equals(is_storType), Structattr::getStor_type)
.isNull("1".equals(is_have), Structattr::getStoragevehicle_code)
.isNotNull("2".equals(is_have), Structattr::getStoragevehicle_code)
.orderByAsc(Structattr::getStruct_code);
return structattrMapper.selectPage(new Page<>(page.getPage() + 1, page.getSize()), queryWrapper);
}
/**
* 超托库位搜索条件
*/
private void buildSuperPalletSearchQuery(LambdaQueryWrapper<Structattr> queryWrapper, String search) {
if (search.length() < 12) {
throw new BadRequestException("输入长度有误，请输入正确的仓位信息：" + search);
}
String suffix = search.substring(search.length() - 6);
int rowNum = Integer.parseInt(suffix.substring(0, 2));
int colNum = Integer.parseInt(suffix.substring(2, 4));
int layerNum = Integer.parseInt(suffix.substring(4, 6));
String remark = search.substring(2); // 去掉CT前缀
String prefixForRemark1 = remark.substring(0, remark.length() - 6);
int newCol = colNum + 1;
if (newCol > 99) {
throw new BadRequestException("列号+1后超出范围（>99）：" + search);
}
String newSixDigits = String.format("%02d", rowNum) +
String.format("%02d", newCol) +
String.format("%02d", layerNum);
String remark1 = prefixForRemark1 + newSixDigits;
queryWrapper.and(wrapper ->
wrapper.like(Structattr::getStruct_code, remark)
.or()
.like(Structattr::getStruct_code, remark1)
.or()
.like(Structattr::getStruct_name, search)
);
}
@Override
public Structattr findById(String struct_id) {
return structattrMapper.selectById(struct_id);
@@ -521,9 +554,121 @@ public class StructattrServiceImpl extends ServiceImpl<StructattrMapper, Structa
record.setGrowth(changeDto.getInBound());
records.add(record);
}
if (!CollectionUtils.isEmpty(records)){
if (!CollectionUtils.isEmpty(records)) {
stIvtStructivtflowService.saveBatch(records);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public String setStructType(JSONObject params) {
String msg;
String type = params.getString("type");
List<String> structCodeList = params.getJSONArray("data").toJavaList(String.class);
if (CollectionUtils.isEmpty(structCodeList)) {
throw new BadRequestException("仓位编码列表不能为空");
}
structCodeList.stream().allMatch(x -> {
if (!x.contains("CT")) {
throw new BadRequestException("只有以CH开头的库位才能进行库位类型变更!");
}
return true;
});
// 查询超托与关联库位，并过滤出符合条件的库位
List<String> remarkCodeList = new ArrayList<>();
List<String> validStructCodeList = new ArrayList<>();
for (String structCode : structCodeList) {
Structattr structattr = this.findByCode(structCode);
if (structattr != null) {
// 符合变更超托的库位：无载具且未锁定
if (ObjectUtil.isEmpty(structattr.getStoragevehicle_code()) && "0".equals(structattr.getLock_type())) {
validStructCodeList.add(structCode);
if (StrUtil.isNotEmpty(structattr.getRemark())) {
remarkCodeList.add(structattr.getRemark());
}
if (StrUtil.isNotEmpty(structattr.getRemark1())) {
remarkCodeList.add(structattr.getRemark1());
}
}
}
}
//有效库位列表
structCodeList = validStructCodeList;
List<String> allStructList = new ArrayList<>();
allStructList.addAll(structCodeList);
allStructList.addAll(remarkCodeList);
LambdaUpdateWrapper<Structattr> updateWrapper = new LambdaUpdateWrapper<>();
//不符合设置超托的库位集合
List<Structattr> errorStructs = new ArrayList<>();
//设为普通库位
if ("1".equals(type)) {
if (!CollectionUtils.isEmpty(structCodeList)) {
msg = lockTypeCheck(structCodeList, errorStructs);
updateWrapper.set(Structattr::getStor_type, null);
}else {
msg = "操作失败,检查库位是否有货或被锁住!";
}
} else if ("2".equals(type)) {
if (!CollectionUtils.isEmpty(remarkCodeList)) {
msg = lockTypeCheck(remarkCodeList, errorStructs);
if (!CollectionUtils.isEmpty(errorStructs)) {
// 收集有问题的关联库位编码
List<String> errorChildCodes = errorStructs.stream()
.map(Structattr::getStruct_code)
.collect(Collectors.toList());
LambdaQueryWrapper<Structattr> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.and(wrapper ->
wrapper.in(Structattr::getRemark, errorChildCodes)
.or()
.in(Structattr::getRemark1, errorChildCodes)
);
List<Structattr> structListResult = this.list(queryWrapper);
//有问题的关联库位 + 对应的超托库位
List<String> codesToRemove = new ArrayList<>(errorChildCodes);
codesToRemove.addAll(structListResult.stream()
.map(Structattr::getStruct_code)
.collect(Collectors.toList()));
allStructList.removeAll(codesToRemove);
}
}else{
msg = "操作失败,检查库位是否有货或被锁住!";
}
//设为超托
updateWrapper.set(Structattr::getStor_type, 1);
} else {
throw new BadRequestException("不支持的类型: " + type);
}
if (ObjectUtil.isNotEmpty(allStructList)) {
updateWrapper.in(Structattr::getStruct_code, allStructList);
this.update(updateWrapper);
}
return msg;
}
private String lockTypeCheck(List<String> structList, List<Structattr> errorStructs) {
String errorMsg = "操作成功!";
LambdaQueryWrapper<Structattr> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(Structattr::getStruct_code, structList);
List<Structattr> structListResult = this.list(queryWrapper);
// 检查是否有货物
List<String> occupiedStructs = new ArrayList<>();
for (Structattr struct : structListResult) {
if (StrUtil.isNotEmpty(struct.getStoragevehicle_code()) || !"0".equals(struct.getLock_type())) {
String structInfo = String.format("库位[%s]", struct.getStruct_code());
if (StrUtil.isNotEmpty(struct.getStoragevehicle_code())) {
structInfo += String.format("，载具号[%s]", struct.getStoragevehicle_code());
}
if (StrUtil.isNotEmpty(struct.getLock_type()) && !"0".equals(struct.getLock_type())) {
structInfo += ("，存在入库或出库锁，请检查或修改");
}
errorStructs.add(struct);
occupiedStructs.add(structInfo);
}
}
if (!CollectionUtils.isEmpty(occupiedStructs)) {
errorMsg = "部分库位更改成功，但有以下库位更改失败，原因为：关联库位有货物，请出库后再变更库位类型：\n" + String.join("\n", occupiedStructs);
}
return errorMsg;
}
}

5
nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext_manage/enums/ResultAcsStatus.java
View File

@@ -18,6 +18,11 @@ public enum ResultAcsStatus {
*/
FINISHED("2", "完成", "完成"),
/**
* 完成
*/
CANCEL("3", "取消", "取消"),
/**
* 取货完成
*/

8
nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext_manage/service/impl/AcsToWmsServiceImpl.java
View File

@@ -143,13 +143,15 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
schBasePoint.setLock_up(true);
iSchBasePointService.update(schBasePoint);
taskObj.setPoint_code2(finish_code);
taskObj.setTask_status(TaskStatus.FINISHFP.getCode());
taskObj.setTask_status(TaskStatus.APPLY.getCode());
iSchBaseTaskService.update(taskObj);
}
status = TaskStatus.FINISHFP;
} else {
status = TaskStatus.APPLY;
} else if (ResultAcsStatus.CANCEL.getCode().equals(acs_task_status)){
// 取消
status = TaskStatus.CANCELED;
}else {
return result;
}
// 根据配置编码执行相关配置内的方法
AbstractTask task = taskFactory.getTask(taskObj.getConfig_code());

8
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/enums/TaskStatus.java
View File

@@ -7,13 +7,13 @@ package org.nl.wms.sch_manage.enums;
*/
public enum TaskStatus {
/**
* 申请
* 生成
*/
CREATE("0", "生成", "生成"),
/**
* 申请
* 二次分配完成
*/
APPLY("1", "申请", "申请"),
APPLY("1", "二次分配完成", "二次分配完成"),
/**
* 创建完成
*/
@@ -29,7 +29,7 @@ public enum TaskStatus {
/**
* 分配完成
*/
FINISHFP("8", "执行中", "执行中"),
// FINISHFP("8", "分配完成", "分配完成"),
/**
* 完成
*/

148
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/AbstractTask.java
View File

@@ -7,6 +7,7 @@ import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.nl.wms.ext_manage.service.WmsToAcsService;
@@ -19,7 +20,9 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/**
@@ -42,7 +45,13 @@ public abstract class AbstractTask {
*/
@Autowired
private WmsToAcsService wmsToAcsService;
// 新增方法，子类可继承或复用
public void sendTaskBatch(List<String> taskIds) {
List<AcsTaskDto> taskDtoList = taskIds.stream()
.map(this::sendAcsParam) // 复用原有的参数构建方法
.collect(Collectors.toList());
this.renotifyAcs(taskDtoList);
}
/**
* 任务创建
* 根据配置生成任务
@@ -90,9 +99,88 @@ public abstract class AbstractTask {
public AcsResponse sendTaskOne(String task_id) {
List<AcsTaskDto> taskDtoList = new ArrayList<>();
taskDtoList.add(this.sendAcsParam(task_id));
//return AcsResponse.requestOk();
return this.renotifyAcs(taskDtoList);
}
@SneakyThrows
protected AcsResponse renotifyAcs(List<AcsTaskDto> taskDtoList) {
AcsResponse resultForAcs = AcsResponse.requestOk();
if (ObjectUtil.isEmpty(taskDtoList)) {
return resultForAcs;
}
JSONArray errArr = new JSONArray();
int successCount = 0;
for (AcsTaskDto dto : taskDtoList) {
String taskCode = dto.getTask_code();
//当 status=CREATE 时才更新为 ISSUED
LambdaUpdateWrapper<SchBaseTask> updateWrapper = new LambdaUpdateWrapper<SchBaseTask>()
.eq(SchBaseTask::getTask_code, taskCode)
.eq(SchBaseTask::getTask_status, TaskStatus.CREATE.getCode())
.set(SchBaseTask::getTask_status, TaskStatus.ISSUED.getCode());
boolean occupied = taskService.update(updateWrapper);
if (!occupied) {
log.warn("任务已被其他线程处理，跳过: {}", taskCode);
continue;
}
// 下发单个任务
try {
AcsResponse singleResp = wmsToAcsService.renotifyAcs(Collections.singletonList(dto));
if (singleResp.getCode() == HttpStatus.HTTP_OK) {
// 检查该任务是否在 ACS 的 errArr 中
JSONArray singleErrArr = singleResp.getErrArr();
boolean hasError = false;
if (ObjectUtil.isNotEmpty(singleErrArr)) {
for (int i = 0; i < singleErrArr.size(); i++) {
JSONObject errObj = singleErrArr.getJSONObject(i);
if (taskCode.equals(errObj.getString("task_code"))) {
// 该任务下发失败，需要回滚
rollbackTask(taskCode, errObj.getString("message"));
addToErrArr(errArr, taskCode, errObj.getString("message"));
hasError = true;
break;
}
}
}
if (!hasError) {
successCount++;
log.info("任务下发成功: {}", taskCode);
}
} else {
rollbackTask(taskCode, "ACS返回非200: " + singleResp.getMessage());
addToErrArr(errArr, taskCode, "ACS返回非200: " + singleResp.getMessage());
}
} catch (Exception e) {
log.error("任务下发异常: taskCode={}", taskCode, e);
rollbackTask(taskCode, "下发异常: " + e.getMessage());
addToErrArr(errArr, taskCode, "下发异常: " + e.getMessage());
}
}
if (errArr.isEmpty()) {
resultForAcs.setCode(HttpStatus.HTTP_OK);
resultForAcs.setMessage("success");
} else {
resultForAcs.setCode(HttpStatus.HTTP_BAD_REQUEST);
resultForAcs.setMessage(String.format("部分任务下发失败，成功：%d，失败：%d", successCount, errArr.size()));
resultForAcs.setErrArr(errArr);
}
return resultForAcs;
}
//回滚单个任务状态
private void rollbackTask(String taskCode, String remark) {
LambdaUpdateWrapper<SchBaseTask> rollbackWrapper = new LambdaUpdateWrapper<SchBaseTask>()
.eq(SchBaseTask::getTask_code, taskCode)
.set(SchBaseTask::getTask_status, TaskStatus.CREATE.getCode())
.set(SchBaseTask::getRemark, remark);
taskService.update(rollbackWrapper);
}
//向errArr 添加一条错误记录
private void addToErrArr(JSONArray errArr, String taskCode, String message) {
JSONObject errObj = new JSONObject();
errObj.put("task_code", taskCode);
errObj.put("message", message);
errArr.add(errObj);
}
/**
* 下发任务
@@ -100,8 +188,33 @@ public abstract class AbstractTask {
* @return AcsResponse
*/
@SneakyThrows
protected AcsResponse renotifyAcs(List<AcsTaskDto> taskDtoList) {
protected AcsResponse renotifyAcs1(List<AcsTaskDto> taskDtoList) {
AcsResponse resultForAcs = AcsResponse.requestOk();
// 先更新任务状态为下发中，防止重复下发
List<String> taskCodes = taskDtoList.stream()
.map(AcsTaskDto::getTask_code)
.collect(Collectors.toList());
if (ObjectUtil.isNotEmpty(taskCodes)) {
List<SchBaseTask> taskList = taskService.list(
new QueryWrapper<SchBaseTask>().lambda()
.in(SchBaseTask::getTask_code, taskCodes)
.eq(SchBaseTask::getTask_status, TaskStatus.CREATE.getCode())
);
if (ObjectUtil.isNotEmpty(taskList)) {
for (SchBaseTask schBaseTask : taskList) {
schBaseTask.setTask_status(TaskStatus.ISSUED.getCode());
}
taskService.updateBatchById(taskList);
log.info("任务状态已更新为下发中: {}", taskCodes);
} else {
log.warn("任务可能已被下发，跳过重复下发: {}", taskCodes);
return AcsResponse.requestOk();
}
}
try {
// 创建下发对象
resultForAcs = wmsToAcsService.renotifyAcs(taskDtoList);
@@ -110,33 +223,46 @@ public abstract class AbstractTask {
resultForAcs.setResponseDate(DateUtil.now());
resultForAcs.setCode(HttpStatus.HTTP_BAD_REQUEST);
resultForAcs.setMessage(e.getMessage());
// 下发失败，回滚状态
if (ObjectUtil.isNotEmpty(taskCodes)) {
List<SchBaseTask> rollbackTasks = taskService.list(
new QueryWrapper<SchBaseTask>().lambda()
.in(SchBaseTask::getTask_code, taskCodes)
);
for (SchBaseTask schBaseTask : rollbackTasks) {
schBaseTask.setTask_status(TaskStatus.CREATE.getCode());
schBaseTask.setRemark("下发失败: " + e.getMessage());
}
taskService.updateBatchById(rollbackTasks);
}
}
// 如果下发完毕，就修改状态
if (resultForAcs.getCode() == HttpStatus.HTTP_OK) {
// 根据下发结果更新状态
if (resultForAcs.getCode() == HttpStatus.HTTP_OK) {
// 查询所有任务
List<SchBaseTask> taskList = taskService.list(
new QueryWrapper<SchBaseTask>().lambda()
.in(SchBaseTask::getTask_code, taskDtoList.stream()
.map(AcsTaskDto::getTask_code)
.collect(Collectors.toList())
)
.in(SchBaseTask::getTask_code, taskCodes)
);
// 解析并备注
JSONArray errArr = resultForAcs.getErrArr();
for (SchBaseTask schBaseTask : taskList) {
schBaseTask.setTask_status(TaskStatus.ISSUED.getCode());
// 判断是否是出错的任务
boolean hasError = false;
for (int i = 0; ObjectUtil.isNotEmpty(errArr) && i < errArr.size(); i++) {
JSONObject errObj = errArr.getJSONObject(i);
String taskCode = errObj.getString("task_code");
if (taskCode.equals(schBaseTask.getTask_code())) {
// 出错的任务就设置出错信息为备注，不是出错就设置下发
// 出错的任务就设置出错信息为备注，回滚为创建状态
schBaseTask.setTask_status(TaskStatus.CREATED.getCode());
schBaseTask.setRemark(errObj.getString("message"));
hasError = true;
break;
}
}
// 如果没有错误，保持ISSUED状态
}
taskService.updateBatchById(taskList);
}

226
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/AutoTask.java
View File

@@ -8,6 +8,9 @@ import org.apache.commons.lang3.StringUtils;
import org.nl.wms.sch_manage.enums.TaskStatus;
import org.nl.wms.sch_manage.service.ISchBaseTaskService;
import org.nl.wms.sch_manage.service.dao.SchBaseTask;
import org.nl.wms.system_manage.enums.SysParamConstant;
import org.nl.wms.system_manage.service.param.ISysParamService;
import org.nl.wms.system_manage.service.param.dao.Param;
import org.nl.wms.warehouse_manage.enums.IOSConstant;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
@@ -16,9 +19,7 @@ import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@@ -34,6 +35,9 @@ public class AutoTask {
*/
private ScheduledExecutorService delayExecutor;
@Autowired
private ISysParamService iSysParamService;
@Autowired
private ISchBaseTaskService taskService;
@@ -42,6 +46,14 @@ public class AutoTask {
private final RedissonClient redissonClient;
/**
* 缓存的参数值，避免频繁查询数据库
*/
private volatile Integer onlyInTaskCounts = 4; // 默认值：只有入库任务时的最大数量
private volatile Integer hasOutTaskCounts = 4; // 默认值：有出库任务时入库任务的最大数量
private volatile long lastParamLoadTime = 0;
private static final long PARAM_CACHE_TIMEOUT = 30000; // 参数缓存超时时间：60秒
@PostConstruct
public void init() {
//无界线程池，线程数
@@ -94,54 +106,196 @@ public class AutoTask {
/**
* 定时下发任务
*/
private void sendTask() {
// 1. 查询待发送的任务
List<SchBaseTask> taskList = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
private void sendTask1() {
//查询待发送的任务
List<SchBaseTask> allTaskList = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
.eq(SchBaseTask::getIs_delete, IOSConstant.IS_DELETE_NO)
.eq(SchBaseTask::getTask_status, TaskStatus.CREATE.getCode()));
.lt(SchBaseTask::getTask_status, TaskStatus.FINISHED.getCode()));
Map<Boolean, List<SchBaseTask>> partition1 = allTaskList.stream()
.collect(Collectors.partitioningBy(task -> TaskStatus.CREATE.getCode().equals(task.getTask_status())));
//生成状态任务
List<SchBaseTask> taskList = partition1.get(true);
//执行中的任务
List<SchBaseTask> otherTasks = partition1.get(false);
if (ObjectUtil.isEmpty(taskList)) {
return;
}
// 2. 统一设置默认优先级并分组
Map<Boolean, List<SchBaseTask>> partitioned = taskList.stream()
//获取最大任务数量
loadTaskCountParamsIfNeeded();
Map<Boolean, List<SchBaseTask>> partition2 = taskList.stream()
.peek(task -> {
if (StringUtils.isBlank(task.getPriority())) {
task.setPriority("1");
}
// 设置入库任务的优先级
if ("STInTask".equals(task.getConfig_code())) {
task.setPriority("10");
}
})
.collect(Collectors.partitioningBy(r -> "STInTask".equals(r.getConfig_code())));
List<SchBaseTask> immediatelyTaskList = partitioned.get(false);
List<SchBaseTask> delayTaskList = partitioned.get(true);
// 3. 立即下发任务
if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
for (SchBaseTask task : immediatelyTaskList) {
try {
AbstractTask taskExecutor = taskFactory.getTask(task.getConfig_code());
taskExecutor.sendTaskOne(task.getTask_id());
} catch (Exception e) {
log.error("任务下发失败: taskId={}, configCode={}", task.getTask_id(), task.getConfig_code(), e);
}
}
}
// 4. 延迟下发任务（间隔 7 秒，异步执行）
List<SchBaseTask> immediatelyTaskList = partition2.get(false); // 非入库任务
List<SchBaseTask> delayTaskList = partition2.get(true); // 入库任务
//入库任务进行数量控制
if (ObjectUtil.isNotEmpty(delayTaskList)) {
delayTaskList.sort(Comparator.comparing(SchBaseTask::getTask_code));
long delaySeconds = 0;
for (SchBaseTask task : delayTaskList) {
delayExecutor.schedule(() -> {
long outTaskCount = otherTasks.stream()
.filter(r -> !"STInTask".equals(r.getConfig_code()))
.count();
long inTaskIngCount = otherTasks.stream()
.filter(r -> "STInTask".equals(r.getConfig_code())
&& !TaskStatus.CREATE.getCode().equals(r.getTask_status()))
.count();
int maxInTaskCount = outTaskCount > 0 ? hasOutTaskCounts : onlyInTaskCounts;
int canSend = maxInTaskCount - (int) inTaskIngCount;
//在进行的入库任务数量小于最大数量时，才进行下发
if (canSend > 0) {
int take = Math.min(canSend, delayTaskList.size());
delayTaskList.sort(Comparator.comparing(SchBaseTask::getTask_code));
List<SchBaseTask> toSend = new ArrayList<>(delayTaskList.subList(0, take));
for (SchBaseTask task : toSend) {
final String taskId = task.getTask_id();
final String configCode = task.getConfig_code();
final String taskCode = task.getTask_code();
try {
AbstractTask taskExecutor = taskFactory.getTask(task.getConfig_code());
taskExecutor.sendTaskOne(task.getTask_id());
//log.info("延迟任务下发成功: taskCode={}, configCode={}", task.getTask_code(), task.getConfig_code());
AbstractTask taskExecutor = taskFactory.getTask(configCode);
taskExecutor.sendTaskOne(taskId);
log.info("延迟任务下发成功: taskCode={}, configCode={}", taskCode, configCode);
} catch (Exception e) {
log.error("延迟任务下发失败: taskId={}, configCode={}", task.getTask_id(), task.getConfig_code(), e);
log.error("延迟任务下发失败: taskId={}, configCode={}", taskId, configCode, e);
}
}, delaySeconds, TimeUnit.SECONDS);
delaySeconds += 7;
}
if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
sendImmediatelyTasks(immediatelyTaskList);
}
} else if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
// 如果不能下发延迟任务，但存在立即任务，则直接下发立即任务
sendImmediatelyTasks(immediatelyTaskList);
}
}else if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
// 如果不存在延迟任务，直接下发立即任务
sendImmediatelyTasks(immediatelyTaskList);
}
}
/**
* 定时下发任务
*/
private void sendTask() {
//查询待发送的任务
List<SchBaseTask> allTaskList = taskService.list(new LambdaQueryWrapper<SchBaseTask>()
.eq(SchBaseTask::getIs_delete, IOSConstant.IS_DELETE_NO)
.lt(SchBaseTask::getTask_status, TaskStatus.FINISHED.getCode()));
Map<Boolean, List<SchBaseTask>> partition1 = allTaskList.stream()
.collect(Collectors.partitioningBy(task -> TaskStatus.CREATE.getCode().equals(task.getTask_status())));
//生成状态任务
List<SchBaseTask> taskList = partition1.get(true);
//执行中的任务
List<SchBaseTask> otherTasks = partition1.get(false);
if (ObjectUtil.isEmpty(taskList)) {
return;
}
//获取最大任务数量
loadTaskCountParamsIfNeeded();
Map<Boolean, List<SchBaseTask>> partition2 = taskList.stream()
.peek(task -> {
if (StringUtils.isBlank(task.getPriority())) {
task.setPriority("1");
}
// 设置入库任务的优先级
if ("STInTask".equals(task.getConfig_code())) {
task.setPriority("10");
}
})
.collect(Collectors.partitioningBy(r -> "STInTask".equals(r.getConfig_code())));
List<SchBaseTask> immediatelyTaskList = partition2.get(false); // 非入库任务
List<SchBaseTask> delayTaskList = partition2.get(true); // 入库任务
//入库任务进行数量控制
if (ObjectUtil.isNotEmpty(delayTaskList)) {
long outTaskCount = otherTasks.stream()
.filter(r -> !"STInTask".equals(r.getConfig_code()))
.count();
long inTaskIngCount = otherTasks.stream()
.filter(r -> "STInTask".equals(r.getConfig_code())
&& !TaskStatus.CREATE.getCode().equals(r.getTask_status()))
.count();
int maxInTaskCount = outTaskCount > 0 ? hasOutTaskCounts : onlyInTaskCounts;
int canSend = maxInTaskCount - (int) inTaskIngCount;
//在进行的入库任务数量小于最大数量时，才进行下发
if (canSend > 0) {
int take = Math.min(canSend, delayTaskList.size());
delayTaskList.sort(Comparator.comparing(SchBaseTask::getTask_code));
List<SchBaseTask> toSend = new ArrayList<>(delayTaskList.subList(0, take));
long delaySeconds = 0;
for (SchBaseTask task : toSend) {
final String taskId = task.getTask_id();
final String configCode = task.getConfig_code();
final String taskCode = task.getTask_code();
delayExecutor.schedule(() -> {
try {
AbstractTask taskExecutor = taskFactory.getTask(configCode);
taskExecutor.sendTaskOne(taskId);
//log.info("延迟任务下发成功: taskCode={}, configCode={}", taskCode, configCode);
} catch (Exception e) {
log.error("延迟任务下发失败: taskId={}, configCode={}", taskCode, configCode, e);
}
}, delaySeconds, TimeUnit.SECONDS);
delaySeconds += 1;
}
// 计算最后一个延迟任务的完成时间，在此之后下发立即任务
long finalDelaySeconds = delaySeconds;
if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
delayExecutor.schedule(() -> {
sendImmediatelyTasks(immediatelyTaskList);
}, finalDelaySeconds, TimeUnit.SECONDS);
}
} else if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
// 如果不能下发延迟任务，但存在立即任务，则直接下发立即任务
sendImmediatelyTasks(immediatelyTaskList);
}
} else if (ObjectUtil.isNotEmpty(immediatelyTaskList)) {
// 如果不存在延迟任务，直接下发立即任务
sendImmediatelyTasks(immediatelyTaskList);
}
}
/**
* 下发立即任务列表
* @param immediatelyTaskList 立即任务列表
*/
private void sendImmediatelyTasks(List<SchBaseTask> immediatelyTaskList) {
for (SchBaseTask task : immediatelyTaskList) {
try {
AbstractTask taskExecutor = taskFactory.getTask(task.getConfig_code());
taskExecutor.sendTaskOne(task.getTask_id());
} catch (Exception e) {
log.error("任务下发失败: taskId={}, configCode={}", task.getTask_id(), task.getConfig_code(), e);
}
}
}
/**
* 如果缓存未过期则直接使用缓存值，否则从数据库重新加载
*/
private void loadTaskCountParamsIfNeeded() {
long currentTime = System.currentTimeMillis();
try {
if (currentTime - lastParamLoadTime < PARAM_CACHE_TIMEOUT) {
return;
}
Param onlyInTaskParam = iSysParamService.findByCode(SysParamConstant.ONLY_IN_TASK_COUNTS);
Param hasOutTaskParam = iSysParamService.findByCode(SysParamConstant.HAS_OUT_TASK_COUNTS);
// 更新缓存值
if (onlyInTaskParam != null && StringUtils.isNotBlank(onlyInTaskParam.getValue())) {
this.onlyInTaskCounts = Integer.parseInt(onlyInTaskParam.getValue());
}
if (hasOutTaskParam != null && StringUtils.isNotBlank(hasOutTaskParam.getValue())) {
this.hasOutTaskCounts = Integer.parseInt(hasOutTaskParam.getValue());
}
this.lastParamLoadTime = System.currentTimeMillis();
log.debug("任务数量参数已更新: onlyInTaskCounts={}, hasOutTaskCounts={}",
this.onlyInTaskCounts, this.hasOutTaskCounts);
} catch (Exception e) {
log.error("加载任务数量参数失败，使用缓存值", e);
}
}
}

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/BackInTask.java
View File

@@ -77,6 +77,7 @@ public class BackInTask extends AbstractTask {
AcsTaskDto acsTaskDto = new AcsTaskDto();
acsTaskDto.setExt_task_uuid(taskDao.getTask_id());
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/CheckInTask.java
View File

@@ -98,6 +98,7 @@ public class CheckInTask extends AbstractTask {
AcsTaskDto acsTaskDto = new AcsTaskDto();
acsTaskDto.setExt_task_uuid(taskDao.getTask_id());
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/CheckMoveTask.java
View File

@@ -97,6 +97,7 @@ public class CheckMoveTask extends AbstractTask {
AcsTaskDto acsTaskDto = new AcsTaskDto();
acsTaskDto.setExt_task_uuid(taskDao.getTask_id());
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/CheckOutTask.java
View File

@@ -95,6 +95,7 @@ public class CheckOutTask extends AbstractTask {
AcsTaskDto acsTaskDto = new AcsTaskDto();
acsTaskDto.setExt_task_uuid(taskDao.getTask_id());
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/MoveTask.java
View File

@@ -75,6 +75,7 @@ public class MoveTask extends AbstractTask {
AcsTaskDto acsTaskDto = new AcsTaskDto();
acsTaskDto.setExt_task_uuid(taskDao.getTask_id());
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/StInTask.java
View File

@@ -91,6 +91,7 @@ public class StInTask extends AbstractTask {
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setPriority(taskDao.getPriority());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setTask_type("1");
acsTaskDto.setCar_type(taskDao.getCar_type());
if(StringUtils.isNoneBlank(taskDao.getCar_width())){

1
nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/util/tasks/StOutTask.java
View File

@@ -74,6 +74,7 @@ public class StOutTask extends AbstractTask {
acsTaskDto.setTask_code(taskDao.getTask_code());
acsTaskDto.setStart_device_code(taskDao.getPoint_code1());
acsTaskDto.setNext_device_code(taskDao.getPoint_code2());
acsTaskDto.setVehicle_code(taskDao.getVehicle_code());
acsTaskDto.setPriority(taskDao.getPriority());
acsTaskDto.setTask_type("2");
acsTaskDto.setCar_type(taskDao.getCar_type());

12
nladmin-system/nlsso-server/src/main/java/org/nl/wms/system_manage/enums/SysParamConstant.java
View File

@@ -7,6 +7,18 @@ package org.nl.wms.system_manage.enums;
*/
public class SysParamConstant {
/**
* 只有入库任务限制任务数
*/
public final static String ONLY_IN_TASK_COUNTS = "only_In_Task_Counts";
/**
* 存在出库任务限制任务数
*/
public final static String HAS_OUT_TASK_COUNTS = "has_Out_Task_Counts";
/**
* 是否反馈IWMS
*/

203
nladmin-system/nlsso-server/src/main/java/org/nl/wms/wbwms/service/impl/WmsToIWmsServiceImpl.java
View File

@@ -11,6 +11,7 @@ import org.apache.commons.lang3.StringUtils;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.CodeUtil;
import org.nl.common.utils.IdUtil;
import org.nl.common.utils.RedissonUtils;
import org.nl.config.SpringContextHolder;
import org.nl.wms.basedata_manage.controller.GroupController;
import org.nl.wms.basedata_manage.enums.BaseDataEnum;
@@ -125,53 +126,56 @@ public class WmsToIWmsServiceImpl implements WmsToIWmsService {
@Override
@Transactional
public WmstoIWmsResponse groupTask(JSONObject parm) {
log.info("WMS入库请求参数参数为：-------------------" + parm.toString());
if (StringUtils.isBlank(parm.getString("point_code"))) {
throw new BadRequestException("未传入地面入库点");
}
if (StringUtils.isBlank(parm.getString("storagevehicle_code"))) {
throw new BadRequestException("未传入载具码");
}
String storagevehicle_code = parm.getString("storagevehicle_code");
SchBasePoint one = iSchBasePointService.getOne(
new QueryWrapper<SchBasePoint>().lambda()
.eq(SchBasePoint::getPoint_code, parm.getString("point_code")).eq(SchBasePoint::getIs_used, BaseDataEnum.IS_YES_NOT.code("是"))
);
//起点校验
if (ObjectUtil.isEmpty(one)) {
if (ObjectUtil.isNotEmpty(iStructattrService.getByCode(parm.getString("point_code")))) {
Structattr structattr = iStructattrService.getByCode(parm.getString("point_code"));
if (!storagevehicle_code.equals(structattr.getStoragevehicle_code())) {
throw new BadRequestException("该仓位存放托盘与所传托盘的编码不对" + "传入的托盘号：" + storagevehicle_code + "，现在存放的托盘号：" + structattr.getStoragevehicle_code());
}
if (!"0".equals(structattr.getLock_type())) {
throw new BadRequestException("传入仓位有正在执行的任务，无法生成，请检查仓位管理的仓位信息！");
}
parm.put("notStructCheck", "true");
}
}
WmstoIWmsResponse result = new WmstoIWmsResponse();
//生成载具信息
iMdPbStoragevehicleinfoService.create(parm);
//生成组盘记录
groupController.createSingle(parm);
//新增入库表
String iostorinv_id = iInBillService.insertDtl1(parm);
//入库分配货位
parm.put("iostorinv_id", iostorinv_id);
String point_code1 = iInBillService.divStruct1(parm);
parm.put("struct_code", point_code1);
//判断是否已经分配好货位
iInBillService.divPoint1(parm);
result.setCode(String.valueOf(HttpStatus.OK.value()));
result.setMsg("入库任务生成成功");
result.setTotalElements(0);
JSONObject data = new JSONObject();
data.put("bill_code", iostorinv_id);
data.put("urnin_struct_code", point_code1);
data.put("bill_code", parm.getString("bill_code"));
result.setData(data);
log.info("WMS入库返回参数为：-------------------" + result.toString());
RedissonUtils.lock(() -> {
log.info("WMS入库请求参数参数为：-------------------" + parm.toString());
if (StringUtils.isBlank(parm.getString("point_code"))) {
throw new BadRequestException("未传入地面入库点");
}
if (StringUtils.isBlank(parm.getString("storagevehicle_code"))) {
throw new BadRequestException("未传入载具码");
}
String storagevehicle_code = parm.getString("storagevehicle_code");
SchBasePoint one = iSchBasePointService.getOne(
new QueryWrapper<SchBasePoint>().lambda()
.eq(SchBasePoint::getPoint_code, parm.getString("point_code")).eq(SchBasePoint::getIs_used, BaseDataEnum.IS_YES_NOT.code("是"))
);
//起点校验
if (ObjectUtil.isEmpty(one)) {
if (ObjectUtil.isNotEmpty(iStructattrService.getByCode(parm.getString("point_code")))) {
Structattr structattr = iStructattrService.getByCode(parm.getString("point_code"));
if (!storagevehicle_code.equals(structattr.getStoragevehicle_code())) {
throw new BadRequestException("该仓位存放托盘与所传托盘的编码不对" + "传入的托盘号：" + storagevehicle_code + "，现在存放的托盘号：" + structattr.getStoragevehicle_code());
}
if (!"0".equals(structattr.getLock_type())) {
throw new BadRequestException("传入仓位有正在执行的任务，无法生成，请检查仓位管理的仓位信息！");
}
parm.put("notStructCheck", "true");
}
}
//生成载具信息
iMdPbStoragevehicleinfoService.create(parm);
//生成组盘记录
groupController.createSingle(parm);
//新增入库表
String iostorinv_id = iInBillService.insertDtl1(parm);
//入库分配货位
parm.put("iostorinv_id", iostorinv_id);
String point_code1 = iInBillService.divStruct1(parm);
parm.put("struct_code", point_code1);
//判断是否已经分配好货位
iInBillService.divPoint1(parm);
result.setCode(String.valueOf(HttpStatus.OK.value()));
result.setMsg("入库任务生成成功");
result.setTotalElements(0);
JSONObject data = new JSONObject();
data.put("bill_code", iostorinv_id);
data.put("urnin_struct_code", point_code1);
data.put("bill_code", parm.getString("bill_code"));
result.setData(data);
log.info("WMS入库返回参数为：-------------------" + result.toString());
}, "groupTask", null);
return result;
}
@Override
@@ -351,7 +355,7 @@ public class WmsToIWmsServiceImpl implements WmsToIWmsService {
for (SchBasePoint point : list) {
JSONObject pointData = new JSONObject();
pointData.put("point_code", point.getPoint_code());
pointData.put("status", point.getPoint_status().equals(PointStatusEnum.EMPTY_POINT.getCode()) && point.getLock_up()? "0" : "1");
pointData.put("status", point.getPoint_status().equals(PointStatusEnum.EMPTY_POINT.getCode()) && !point.getLock_up() ? "0" : "1");
dataList.add(pointData);
}
}
@@ -368,66 +372,69 @@ public class WmsToIWmsServiceImpl implements WmsToIWmsService {
@Override
@Transactional
public WmstoIWmsResponse outBillTask(JSONObject parm) {
log.info("WMS 出库请求参数参数为：-------------------" + parm.toString());
WmstoIWmsResponse result = new WmstoIWmsResponse();
JSONArray tableData = parm.getJSONArray("tableData");
if (CollectionUtils.isEmpty(tableData)) {
throw new BadRequestException("tableData 不能为空");
}
List<String> turnoutStructCodes = new ArrayList<>();
for (int i = 0; i < tableData.size(); i++) {
JSONObject item = tableData.getJSONObject(i);
turnoutStructCodes.add(item.getString("turnout_struct_code"));
}
List<Structattr> structattrList = iStructattrService.list(new LambdaQueryWrapper<Structattr>()
.in(Structattr::getStruct_code, turnoutStructCodes));
if (CollectionUtils.isEmpty(structattrList)) {
throw new BadRequestException("wms 上不存在这些点位");
}
java.util.Map<String, Structattr> structattrMap = structattrList.stream()
.collect(java.util.stream.Collectors.toMap(Structattr::getStruct_code, s -> s));
for (int i = 0; i < tableData.size(); i++) {
JSONObject jsonObject = tableData.getJSONObject(i);
String storage_code = jsonObject.getString("storage_code");
String turnout_struct_code = jsonObject.getString("turnout_struct_code");
Structattr structattr = structattrMap.get(turnout_struct_code);
if (ObjectUtil.isEmpty(structattr)) {
throw new BadRequestException("wms上不存在该点位：" + turnout_struct_code);
RedissonUtils.lock(() -> {
log.info("WMS 出库请求参数参数为：-------------------" + parm.toString());
JSONArray tableData = parm.getJSONArray("tableData");
if (CollectionUtils.isEmpty(tableData)) {
throw new BadRequestException("tableData 不能为空");
}
if (!storage_code.equals(structattr.getStoragevehicle_code())) {
throw new BadRequestException("该仓位存放托盘与所传托盘的编码不对" + "传入的托盘号：" + storage_code + "，现在存放的托盘号：" + structattr.getStoragevehicle_code());
List<String> turnoutStructCodes = new ArrayList<>();
for (int i = 0; i < tableData.size(); i++) {
JSONObject item = tableData.getJSONObject(i);
turnoutStructCodes.add(item.getString("turnout_struct_code"));
}
if (!"0".equals(structattr.getLock_type())) {
throw new BadRequestException("传入点位有任务：" + turnout_struct_code);
List<Structattr> structattrList = iStructattrService.list(new LambdaQueryWrapper<Structattr>()
.in(Structattr::getStruct_code, turnoutStructCodes));
if (CollectionUtils.isEmpty(structattrList)) {
throw new BadRequestException("wms 上不存在这些点位");
}
}
Structattr structattr = structattrList.get(0);
parm.put("sect_id",structattr.getSect_id());
parm.put("stor_id",structattr.getStor_id());
java.util.Map<String, Structattr> structattrMap = structattrList.stream()
.collect(java.util.stream.Collectors.toMap(Structattr::getStruct_code, s -> s));
for (int i = 0; i < tableData.size(); i++) {
JSONObject jsonObject = tableData.getJSONObject(i);
String storage_code = jsonObject.getString("storage_code");
String turnout_struct_code = jsonObject.getString("turnout_struct_code");
Structattr structattr = structattrMap.get(turnout_struct_code);
if (ObjectUtil.isEmpty(structattr)) {
throw new BadRequestException("wms上不存在该点位：" + turnout_struct_code);
}
if (!storage_code.equals(structattr.getStoragevehicle_code())) {
throw new BadRequestException("该仓位存放托盘与所传托盘的编码不对" + "传入的托盘号：" + storage_code + "，现在存放的托盘号：" + structattr.getStoragevehicle_code());
}
if (!"0".equals(structattr.getLock_type())) {
throw new BadRequestException("传入点位有任务：" + turnout_struct_code);
}
}
Structattr structattr = structattrList.get(0);
parm.put("sect_id",structattr.getSect_id());
parm.put("stor_id",structattr.getStor_id());
// parm.put("turnout_struct_code",turnout_struct_code);
JSONObject j1=new JSONObject();
j1.put("tableData",tableData);
j1.put("bill_type",parm.getString("bill_type"));
j1.put("bill_code",parm.getString("bill_code"));
//新增出库单
String iostorinv_id=iOutBillService.insertDtl1(j1);
parm.put("iostorinv_id",iostorinv_id);
//
String stuct_code=iOutBillService.allDiv1(parm);
JSONObject j1=new JSONObject();
j1.put("tableData",tableData);
j1.put("bill_type",parm.getString("bill_type"));
j1.put("bill_code",parm.getString("bill_code"));
//新增出库单
String iostorinv_id=iOutBillService.insertDtl1(j1);
parm.put("iostorinv_id",iostorinv_id);
//
String stuct_code=iOutBillService.allDiv1(parm);
//生成出库任务
parm.put("point_code",stuct_code);
parm.put("region_code","CKQ");
iOutBillService.allSetPoint(parm);
//生成出库任务
parm.put("point_code",stuct_code);
parm.put("region_code","CKQ");
iOutBillService.allSetPoint(parm);
// data.put("bill_code",iostorinv_id);
// data.put("turnout_destination_code",pointCode);
result.setCode(String.valueOf(HttpStatus.OK.value()));
result.setMsg("出库任务生成成功");
result.setTotalElements(0);
JSONObject data=new JSONObject();
result.setData(data);
log.info("WMS出库返回参数参数为：-------------------" + result.toString());
result.setCode(String.valueOf(HttpStatus.OK.value()));
result.setMsg("出库任务生成成功");
result.setTotalElements(0);
JSONObject data = new JSONObject();
result.setData(data);
log.info("WMS出库返回参数参数为：-------------------" + result.toString());
}, "outBillTask", null);
return result;
}

2
nladmin-system/nlsso-server/src/main/resources/config/application.yml
View File

@@ -12,6 +12,8 @@ spring:
check-template-location: false
profiles:
active: prod
# active: dev
# active: prod
jackson:
time-zone: GMT+8730 885 969
data: