package com.vincent.rsf.server.manager.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.controller.erp.params.TaskInParam;
|
import com.vincent.rsf.server.api.entity.dto.InTaskMsgDto;
|
import com.vincent.rsf.server.api.service.WcsService;
|
import com.vincent.rsf.server.manager.controller.params.PakinItem;
|
import com.vincent.rsf.server.manager.controller.params.RcsTestParams;
|
import com.vincent.rsf.server.manager.controller.params.WaitPakinParam;
|
import com.vincent.rsf.server.manager.controller.params.LocToTaskParams;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.*;
|
import com.vincent.rsf.server.manager.mapper.RcsTestConfigMapper;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.common.constant.Constants;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.Random;
|
|
@Slf4j
|
@Service
|
public class RcsTestServiceImpl extends ServiceImpl<RcsTestConfigMapper, RcsTestConfig> implements RcsTestService {
|
|
@Autowired
|
private MatnrService matnrService;
|
|
@Autowired
|
private WaitPakinService waitPakinService;
|
|
@Autowired
|
private WcsService wcsService;
|
|
@Autowired
|
private TaskService taskService;
|
|
@Autowired
|
private LocService locService;
|
|
@Autowired
|
private LocItemService locItemService;
|
|
@Autowired
|
private DeviceSiteService deviceSiteService;
|
|
@Autowired
|
private BasStationService basStationService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R executeRcsTest(RcsTestParams params, Long userId) {
|
log.info("========== 开始执行RCS全流程自动测试 ==========");
|
Map<String, Object> result = new HashMap<>();
|
List<String> steps = new ArrayList<>();
|
|
try {
|
// 1. 加载配置（如果提供了configId）
|
RcsTestConfig config = null;
|
if (params.getConfigId() != null) {
|
config = this.getById(params.getConfigId());
|
if (config == null) {
|
throw new CoolException("配置不存在，配置ID：" + params.getConfigId());
|
}
|
// 使用配置中的参数覆盖请求参数
|
if (StringUtils.isBlank(params.getInboundStation()) && StringUtils.isNotBlank(config.getInboundStation())) {
|
params.setInboundStation(config.getInboundStation());
|
}
|
if (StringUtils.isBlank(params.getOutboundStation()) && StringUtils.isNotBlank(config.getOutboundStation())) {
|
params.setOutboundStation(config.getOutboundStation());
|
}
|
// 加载入库库位号数组
|
if ((params.getInboundLocNos() == null || params.getInboundLocNos().isEmpty())
|
&& StringUtils.isNotBlank(config.getInboundLocNos())) {
|
try {
|
params.setInboundLocNos(JSON.parseArray(config.getInboundLocNos(), String.class));
|
} catch (Exception e) {
|
log.warn("解析入库库位号数组失败: {}", e.getMessage());
|
}
|
}
|
// 兼容旧数据：如果inboundLocNos为空但locNo有值，使用locNo
|
if ((params.getInboundLocNos() == null || params.getInboundLocNos().isEmpty())
|
&& StringUtils.isNotBlank(config.getLocNo())) {
|
params.setInboundLocNos(Collections.singletonList(config.getLocNo()));
|
}
|
// 加载出库库位号数组
|
if ((params.getOutboundLocNos() == null || params.getOutboundLocNos().isEmpty())
|
&& StringUtils.isNotBlank(config.getOutboundLocNos())) {
|
try {
|
params.setOutboundLocNos(JSON.parseArray(config.getOutboundLocNos(), String.class));
|
} catch (Exception e) {
|
log.warn("解析出库库位号数组失败: {}", e.getMessage());
|
}
|
}
|
if (params.getCheckStock() == null && config.getCheckStock() != null) {
|
params.setCheckStock(config.getCheckStock() == 1);
|
}
|
if (StringUtils.isBlank(params.getInboundApiType()) && StringUtils.isNotBlank(config.getInboundApiType())) {
|
params.setInboundApiType(config.getInboundApiType());
|
}
|
if (params.getRandomMaterialCount() == null && config.getRandomMaterialCount() != null) {
|
params.setRandomMaterialCount(config.getRandomMaterialCount());
|
}
|
if (params.getAutoOutbound() == null && config.getAutoOutbound() != null) {
|
params.setAutoOutbound(config.getAutoOutbound() == 1);
|
}
|
if (params.getMatnrCodes() == null || params.getMatnrCodes().isEmpty()) {
|
if (StringUtils.isNotBlank(config.getMatnrCodes())) {
|
params.setMatnrCodes(JSON.parseArray(config.getMatnrCodes(), String.class));
|
}
|
}
|
}
|
|
// 2. 验证参数
|
// 出库测试不需要物料编号，只有入库测试或全流程测试才需要物料编号
|
// 如果 autoOutbound 为 true 且没有物料编号，说明是纯出库测试，跳过物料验证
|
boolean isPureOutboundTest = Boolean.TRUE.equals(params.getAutoOutbound())
|
&& (params.getMatnrCodes() == null || params.getMatnrCodes().isEmpty());
|
|
if (!isPureOutboundTest && (params.getMatnrCodes() == null || params.getMatnrCodes().isEmpty())) {
|
throw new CoolException("物料编号组不能为空！");
|
}
|
|
// 3. 处理入库流程（仅当非纯出库测试时）
|
String barcode = null;
|
String locNo = null;
|
String taskCode = null;
|
String requestedLocNo = null;
|
WaitPakin waitPakin = null;
|
|
if (!isPureOutboundTest) {
|
// 3.1 随机选择物料
|
List<String> selectedMatnrCodes = selectRandomMaterials(params.getMatnrCodes(), params.getRandomMaterialCount());
|
steps.add("随机选择物料：" + selectedMatnrCodes);
|
log.info("随机选择的物料：{}", selectedMatnrCodes);
|
|
// 3.2 查询物料信息
|
List<Matnr> matnrs = matnrService.list(new LambdaQueryWrapper<Matnr>()
|
.in(Matnr::getCode, selectedMatnrCodes));
|
if (matnrs.isEmpty()) {
|
throw new CoolException("未找到物料信息！");
|
}
|
steps.add("查询到物料数量：" + matnrs.size());
|
|
// 3.3 生成随机托盘码
|
barcode = generateBarcode();
|
steps.add("生成托盘码：" + barcode);
|
log.info("生成的托盘码：{}", barcode);
|
|
// 3.4 自动组托
|
WaitPakinParam waitPakinParam = new WaitPakinParam();
|
waitPakinParam.setBarcode(barcode);
|
List<PakinItem> pakinItems = new ArrayList<>();
|
for (Matnr matnr : matnrs) {
|
PakinItem item = new PakinItem();
|
item.setMatnrId(matnr.getId());
|
item.setReceiptQty(10.0 + Math.random() * 90); // 随机数量10-100
|
pakinItems.add(item);
|
}
|
waitPakinParam.setItems(pakinItems);
|
|
waitPakin = waitPakinService.mergeItems(waitPakinParam, userId);
|
if (waitPakin == null) {
|
throw new CoolException("组托失败，返回结果为空！");
|
}
|
steps.add("组托成功，组托编码：" + waitPakin.getCode());
|
log.info("组托成功，组托编码：{}，托盘码：{}", waitPakin.getCode(), barcode);
|
|
// 3.5 自动入库
|
String inboundStation = params.getInboundStation();
|
if (StringUtils.isBlank(inboundStation)) {
|
// 获取默认入库站点
|
List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getType, TaskType.TASK_TYPE_IN.type)
|
.last("limit 1"));
|
if (deviceSites.isEmpty()) {
|
throw new CoolException("未找到入库站点！");
|
}
|
inboundStation = deviceSites.get(0).getSite();
|
}
|
|
// 处理入库库位号：如果指定了多个，随机选择一个
|
List<String> inboundLocNos = params.getInboundLocNos();
|
if (inboundLocNos != null && !inboundLocNos.isEmpty()) {
|
// 验证库位是否存在
|
List<String> validLocNos = new ArrayList<>();
|
for (String locCode : inboundLocNos) {
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, locCode)
|
.eq(Loc::getDeleted, 0));
|
if (loc != null) {
|
validLocNos.add(locCode);
|
} else {
|
steps.add("警告：指定的入库库位号不存在：" + locCode);
|
}
|
}
|
|
if (!validLocNos.isEmpty()) {
|
// 随机选择一个库位
|
Collections.shuffle(validLocNos);
|
requestedLocNo = validLocNos.get(0);
|
if (validLocNos.size() > 1) {
|
steps.add("从" + validLocNos.size() + "个入库库位中随机选择：" + requestedLocNo);
|
} else {
|
steps.add("使用指定的入库库位号：" + requestedLocNo);
|
}
|
}
|
}
|
|
// 兼容旧参数：如果inboundLocNos为空但locNo有值
|
if (requestedLocNo == null && StringUtils.isNotBlank(params.getLocNo())) {
|
requestedLocNo = params.getLocNo();
|
}
|
|
if ("location_allocate".equals(params.getInboundApiType())) {
|
// 使用 location_allocate 接口（内部调用createInTask）
|
R allocateResult = wcsService.allocateLocation(barcode, inboundStation, 1);
|
if (allocateResult != null) {
|
Object dataObj = allocateResult.get("data");
|
if (dataObj != null) {
|
if (dataObj instanceof JSONObject) {
|
JSONObject data = (JSONObject) dataObj;
|
locNo = data.getString("locNo");
|
} else if (dataObj instanceof Map) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> data = (Map<String, Object>) dataObj;
|
locNo = (String) data.get("locNo");
|
}
|
}
|
}
|
if (StringUtils.isNotBlank(requestedLocNo) && !requestedLocNo.equals(locNo)) {
|
steps.add("使用location_allocate接口申请入库，系统分配库位号：" + locNo + "（用户指定：" + requestedLocNo + "）");
|
} else {
|
steps.add("使用location_allocate接口申请入库，库位号：" + (locNo != null ? locNo : "未分配"));
|
}
|
} else {
|
// 使用 create_in_task 接口
|
TaskInParam taskInParam = new TaskInParam();
|
taskInParam.setBarcode(barcode);
|
taskInParam.setSourceStaNo(inboundStation);
|
taskInParam.setIoType(TaskType.TASK_TYPE_IN.type);
|
taskInParam.setLocType1(1);
|
taskInParam.setUser(userId);
|
|
InTaskMsgDto inTaskMsgDto = wcsService.createInTask(taskInParam);
|
locNo = inTaskMsgDto.getLocNo();
|
taskCode = inTaskMsgDto.getWorkNo();
|
if (StringUtils.isNotBlank(requestedLocNo) && locNo != null && !requestedLocNo.equals(locNo)) {
|
steps.add("使用create_in_task接口创建入库任务，系统分配库位号：" + locNo + "（用户指定：" + requestedLocNo + "），任务编码：" + taskCode);
|
} else {
|
steps.add("使用create_in_task接口创建入库任务，库位号：" + (locNo != null ? locNo : "未分配") + "，任务编码：" + taskCode);
|
}
|
}
|
} else {
|
steps.add("纯出库测试，跳过物料选择、组托和入库流程");
|
}
|
|
result.put("barcode", barcode);
|
result.put("locNo", locNo);
|
result.put("requestedLocNo", requestedLocNo); // 记录用户指定的库位号
|
if (waitPakin != null) {
|
result.put("waitPakinCode", waitPakin.getCode());
|
}
|
if (taskCode != null) {
|
result.put("inboundTaskCode", taskCode);
|
}
|
|
// 8. 自动出库（如果配置了）
|
if (params.getAutoOutbound() != null && params.getAutoOutbound()) {
|
String outboundStation = params.getOutboundStation();
|
if (StringUtils.isBlank(outboundStation)) {
|
// 获取默认出库站点
|
List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getType, TaskType.TASK_TYPE_OUT.type)
|
.last("limit 1"));
|
if (!deviceSites.isEmpty()) {
|
outboundStation = deviceSites.get(0).getSite();
|
}
|
}
|
|
if (StringUtils.isNotBlank(outboundStation)) {
|
List<String> outboundLocNos = params.getOutboundLocNos();
|
List<Loc> selectedOutboundLocs = new ArrayList<>();
|
|
if (outboundLocNos != null && !outboundLocNos.isEmpty()) {
|
// 使用用户指定的出库库位号
|
for (String locCode : outboundLocNos) {
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, locCode)
|
.eq(Loc::getDeleted, 0));
|
if (loc != null) {
|
// 如果检查库存，验证是否有库存
|
if (params.getCheckStock() != null && params.getCheckStock()) {
|
List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocId, loc.getId()));
|
if (!locItems.isEmpty()) {
|
selectedOutboundLocs.add(loc);
|
}
|
} else {
|
// 不检查库存，直接添加
|
selectedOutboundLocs.add(loc);
|
}
|
}
|
}
|
|
if (selectedOutboundLocs.isEmpty()) {
|
steps.add("指定的出库库位号均无库存或不存在，跳过自动出库");
|
log.warn("指定的出库库位号均无库存或不存在，跳过自动出库");
|
}
|
} else {
|
// 没有指定出库库位号，查找有库存的库位
|
if (params.getCheckStock() != null && params.getCheckStock()) {
|
// 检查库存
|
List<Loc> locsWithStock = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
|
.last("limit 10"));
|
|
for (Loc loc : locsWithStock) {
|
List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocId, loc.getId()));
|
if (!locItems.isEmpty()) {
|
selectedOutboundLocs.add(loc);
|
}
|
}
|
|
if (selectedOutboundLocs.isEmpty()) {
|
steps.add("未找到有库存的库位，跳过自动出库");
|
log.warn("未找到有库存的库位，跳过自动出库");
|
}
|
} else {
|
// 不检查库存，随机选择一个库位（后续会使用固定模拟物料000267）
|
List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
|
.last("limit 10"));
|
if (!locs.isEmpty()) {
|
Collections.shuffle(locs);
|
selectedOutboundLocs.add(locs.get(0));
|
steps.add("不检查库存，随机选择库位：" + locs.get(0).getCode() + "，将使用固定模拟物料000267");
|
}
|
}
|
}
|
|
// 处理出库：随机选择单个或多个库位组合
|
if (!selectedOutboundLocs.isEmpty()) {
|
Random random = new Random();
|
// 随机决定：单库位出库 或 多库位组合出库（最多3个库位）
|
boolean useMultipleLocs = random.nextBoolean() && selectedOutboundLocs.size() > 1;
|
int locCount = useMultipleLocs
|
? Math.min(random.nextInt(selectedOutboundLocs.size()) + 1, 3)
|
: 1;
|
|
// 随机选择库位
|
Collections.shuffle(selectedOutboundLocs);
|
List<Loc> finalOutboundLocs = selectedOutboundLocs.subList(0, Math.min(locCount, selectedOutboundLocs.size()));
|
|
if (finalOutboundLocs.size() == 1) {
|
steps.add("随机选择单库位出库：" + finalOutboundLocs.get(0).getCode());
|
} else {
|
steps.add("随机选择" + finalOutboundLocs.size() + "个库位组合出库：" +
|
finalOutboundLocs.stream().map(Loc::getCode).collect(java.util.stream.Collectors.joining(", ")));
|
}
|
|
// 为每个库位生成出库任务
|
List<String> outboundTaskCodes = new ArrayList<>();
|
List<String> matnrCodes = params.getMatnrCodes();
|
boolean hasMatnrFilter = matnrCodes != null && !matnrCodes.isEmpty();
|
boolean checkStockFlag = params.getCheckStock() != null && params.getCheckStock();
|
|
for (Loc outboundLoc : finalOutboundLocs) {
|
try {
|
LocToTaskParams taskParams = new LocToTaskParams();
|
List<LocItem> locItems;
|
|
if (hasMatnrFilter && checkStockFlag) {
|
// 如果指定了物料组且检查库存，只查找包含这些物料的库存
|
List<String> matnrIds = new ArrayList<>();
|
for (String matnrCode : matnrCodes) {
|
Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>()
|
.eq(Matnr::getCode, matnrCode)
|
.eq(Matnr::getDeleted, 0)
|
.last("limit 1"));
|
if (matnr != null) {
|
matnrIds.add(String.valueOf(matnr.getId()));
|
}
|
}
|
|
if (!matnrIds.isEmpty()) {
|
// 将String列表转换为Long列表
|
List<Long> matnrIdLongs = new ArrayList<>();
|
for (String matnrIdStr : matnrIds) {
|
try {
|
matnrIdLongs.add(Long.parseLong(matnrIdStr));
|
} catch (NumberFormatException e) {
|
log.warn("物料ID格式错误: {}", matnrIdStr);
|
}
|
}
|
|
if (!matnrIdLongs.isEmpty()) {
|
locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocId, outboundLoc.getId())
|
.in(LocItem::getMatnrId, matnrIdLongs)
|
.last("limit 1"));
|
} else {
|
locItems = new ArrayList<>();
|
}
|
} else {
|
locItems = new ArrayList<>();
|
}
|
} else if (!checkStockFlag) {
|
// 不检查库存，使用固定模拟物料000267
|
Matnr fixedMatnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>()
|
.eq(Matnr::getCode, "000267")
|
.eq(Matnr::getDeleted, 0)
|
.last("limit 1"));
|
|
if (fixedMatnr != null) {
|
// 创建一个模拟的LocItem用于生成任务
|
locItems = new ArrayList<>();
|
LocItem mockLocItem = new LocItem();
|
mockLocItem.setLocId(outboundLoc.getId());
|
mockLocItem.setMatnrId(fixedMatnr.getId());
|
mockLocItem.setQty(1.0); // 默认数量
|
locItems.add(mockLocItem);
|
steps.add("不检查库存，使用固定模拟物料：000267");
|
} else {
|
// 如果找不到000267，尝试从库位中获取任意一个库存项
|
locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocId, outboundLoc.getId())
|
.last("limit 1"));
|
if (locItems.isEmpty()) {
|
steps.add("警告：库位 " + outboundLoc.getCode() + " 无库存，且未找到固定模拟物料000267");
|
}
|
}
|
} else {
|
// 检查库存但没有指定物料组，查找任意库存
|
locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocId, outboundLoc.getId())
|
.last("limit 1"));
|
}
|
|
if (!locItems.isEmpty()) {
|
taskParams.setItems(locItems);
|
taskParams.setSiteNo(outboundStation);
|
taskParams.setType(Constants.TASK_TYPE_OUT_STOCK);
|
taskParams.setTarLoc(outboundLoc.getCode());
|
|
locItemService.generateTask(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val, taskParams, userId);
|
steps.add("生成出库任务成功，源库位：" + outboundLoc.getCode() + "，目标站点：" + outboundStation);
|
log.info("生成出库任务成功，源库位：{}，目标站点：{}", outboundLoc.getCode(), outboundStation);
|
|
// 查询刚生成的任务并下发到RCS
|
List<Task> outTasks = taskService.list(new LambdaQueryWrapper<Task>()
|
.eq(Task::getOrgLoc, outboundLoc.getCode())
|
.eq(Task::getTargSite, outboundStation)
|
.eq(Task::getTaskStatus, TaskStsType.GENERATE_OUT.id)
|
.orderByDesc(Task::getCreateTime)
|
.last("limit 1"));
|
|
if (!outTasks.isEmpty()) {
|
taskService.pubTaskToWcs(outTasks);
|
outboundTaskCodes.add(outTasks.get(0).getTaskCode());
|
steps.add("出库任务已下发到RCS，任务编码：" + outTasks.get(0).getTaskCode());
|
}
|
} else {
|
steps.add("库位 " + outboundLoc.getCode() + " 无符合条件的库存，跳过生成出库任务");
|
}
|
} catch (Exception e) {
|
log.error("生成出库任务失败，库位：{}", outboundLoc.getCode(), e);
|
steps.add("生成出库任务失败，库位：" + outboundLoc.getCode() + "，错误：" + e.getMessage());
|
}
|
}
|
|
if (!outboundTaskCodes.isEmpty()) {
|
result.put("outboundTaskCodes", outboundTaskCodes);
|
result.put("outboundTaskCode", outboundTaskCodes.get(0)); // 兼容旧字段
|
}
|
}
|
}
|
}
|
|
result.put("steps", steps);
|
result.put("success", true);
|
log.info("========== RCS全流程自动测试完成 ==========");
|
return R.ok(result);
|
|
} catch (Exception e) {
|
log.error("========== RCS全流程自动测试失败 ==========", e);
|
steps.add("测试失败：" + e.getMessage());
|
result.put("steps", steps);
|
result.put("success", false);
|
result.put("error", e.getMessage());
|
return R.error("测试失败：" + e.getMessage()).add(result);
|
}
|
}
|
|
/**
|
* 随机选择物料
|
*/
|
private List<String> selectRandomMaterials(List<String> matnrCodes, Integer count) {
|
if (matnrCodes == null || matnrCodes.isEmpty()) {
|
return new ArrayList<>();
|
}
|
|
List<String> shuffled = new ArrayList<>(matnrCodes);
|
Collections.shuffle(shuffled);
|
|
int selectCount = Math.min(count != null ? count : 1, shuffled.size());
|
return shuffled.subList(0, selectCount);
|
}
|
|
/**
|
* 生成随机托盘码
|
*/
|
private String generateBarcode() {
|
return "TEST_" + System.currentTimeMillis() + "_" + (int)(Math.random() * 10000);
|
}
|
}
|
