package com.zy.api.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.core.common.Cools;
|
import com.core.common.R;
|
import com.core.exception.CoolException;
|
import com.zy.api.controller.params.ChangeLocParams;
|
import com.zy.api.controller.params.ReassignLocParams;
|
import com.zy.api.controller.params.ReceviceTaskParams;
|
import com.zy.api.controller.params.StopOutTaskParams;
|
import com.zy.api.controller.params.WorkTaskParams;
|
import com.zy.api.entity.CrnProtocol;
|
import com.zy.api.entity.DeviceStatusVo;
|
import com.zy.api.entity.StationProtocol;
|
import com.zy.api.service.WcsApiService;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.service.*;
|
import com.zy.asrs.task.support.OutboundBatchSeqReleaseGuard;
|
import com.zy.asrs.utils.Utils;
|
import com.zy.common.constant.MesConstant;
|
import com.zy.common.model.LocTypeDto;
|
import com.zy.common.model.StartupDto;
|
import com.zy.common.model.CrnDepthRuleProfile;
|
import com.zy.common.model.enums.WorkNoType;
|
import com.zy.common.service.CommonService;
|
import com.zy.common.utils.HttpHandler;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class WcsApiServiceImpl implements WcsApiService {
|
private static final Long WCS_SYNC_USER = 9999L;
|
private static final String YES = "Y";
|
private static final String NO = "N";
|
private static final long OUT_LOCK_REPORT_PENDING_WRK_STS = 13L;
|
private static final long OUT_LOCK_REPORT_SUCCESS_WRK_STS = 21L;
|
private static final long OUT_LOCK_REPORT_FAIL_WRK_STS = 22L;
|
private static final long INBOUND_TASK_COMPLETE_WRK_STS = 4L;
|
private static final long INBOUND_FINISHED_WRK_STS = 5L;
|
private static final long INBOUND_ERP_REPORT_PENDING_WRK_STS = 16L;
|
private static final long OUTBOUND_TASK_COMPLETE_WRK_STS = 14L;
|
private static final long OUTBOUND_CRN_COMPLETE_WRK_STS = 25L;
|
private static final long OUTBOUND_STATION_COMPLETE_WRK_STS = 26L;
|
private static final String OUT_LOCK_REPORT_PENDING_FLAG = "P";
|
|
/** 同一 WCS 路径、同一单号下一组下发的任务条数上限 */
|
private static final int WCS_PUB_BATCH_SIZE = 20;
|
|
/** 三方接口统计：本系统调用 WCS 的 namespace 约定 */
|
private static final String NS_WMS_TO_WCS = "本系统请求WCS";
|
private static final String EMPTY_PALLET_MATNR = "emptyPallet";
|
private static final int EMPTY_PALLET_REASSIGN_TARGET_LEVEL = 8;
|
private static final short EMPTY_PALLET_REASSIGN_LOC_TYPE1 = 3;
|
private static final short EMPTY_PALLET_REASSIGN_LOC_TYPE2 = 0;
|
private static final int CHANGE_LOC_IO_TYPE = 5;
|
|
private static class ReassignCrnPool {
|
private final List<Integer> crnNos;
|
|
private ReassignCrnPool(List<Integer> crnNos) {
|
this.crnNos = crnNos;
|
}
|
}
|
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private WrkMastLogService wrkMastLogService;
|
@Autowired
|
private WorkService workService;
|
@Autowired
|
private WrkDetlService wrkDetlService;
|
@Autowired
|
private MatService matService;
|
@Autowired
|
private LocDetlService locDetlService;
|
@Value("${wcs.switch}")
|
private String switchValue;
|
|
@Value("${wcs.address.URL}")
|
private String wcs_address;
|
|
@Value("${wcs.address.createOutTask}")
|
private String getWcs_address;
|
|
@Value("${wcs.address.createInTask}")
|
private String createInTask;
|
|
@Value("${wcs.address.createLocMoveTask}")
|
private String createLocMoveTask;
|
|
@Value("${wcs.address.stopOutTask}")
|
private String stopOutTask;
|
@Value("${wcs.address.getDeviceStatus:/openapi/getDeviceStatus}")
|
private String getDeviceStatus;
|
@Value("${wcs.address.queryTask:/openapi/queryTask}")
|
private String queryTaskPath;
|
@Value("${wcs.status-sync.method:GET}")
|
private String deviceStatusMethod;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private BasCrnpService basCrnpService;
|
@Autowired
|
private ApiLogService apiLogService;
|
@Autowired
|
private OutboundBatchSeqReleaseGuard outboundBatchSeqReleaseGuard;
|
@Autowired
|
private BasCrnDepthRuleService basCrnDepthRuleService;
|
@Autowired
|
private RowLastnoService rowLastnoService;
|
|
|
/**
|
* 下发任务至WCS
|
*
|
* @param params
|
* @return com.core.common.R
|
* @author Ryan
|
* @date 2026/1/10 13:58
|
*/
|
@Override
|
public R pubWrkToWcs(WorkTaskParams params) {
|
if (params == null) {
|
return R.error("参数不能为空！！");
|
}
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", params.getTaskNo()));
|
String validateMsg = validatePubTask(params, wrkMast);
|
if (!Cools.isEmpty(validateMsg)) {
|
return R.error(validateMsg);
|
}
|
String batchBlockMsg = validateOutboundBatchSeqReady(params, wrkMast);
|
if (!Cools.isEmpty(batchBlockMsg)) {
|
return R.error(batchBlockMsg);
|
}
|
String url = resolveTaskPath(params);
|
String requestJson = JSON.toJSONString(params);
|
String response = null;
|
R r = R.ok();
|
Throwable wcsThrown = null;
|
boolean wcsBizOk = false;
|
try {
|
log.info("下发搬运任务给wcs="+JSON.toJSONString(params));
|
response = new HttpHandler.Builder()
|
.setUri(wcs_address)
|
.setPath(url)
|
.setHttps(wcs_address != null && wcs_address.startsWith("https://"))
|
.setTimeout(10, TimeUnit.SECONDS)
|
.setJson(requestJson)
|
.build()
|
.doPost();
|
JSONObject jsonObject = JSON.parseObject(response);
|
log.info("下发任务给wcs的返回值="+response);
|
Integer code = jsonObject.getInteger("code");
|
wcsBizOk = code != null && code == 200;
|
|
if (code==200) {
|
updateWrkMastAfterPublish(wrkMast);
|
//TODO 上报是否成功
|
}else {
|
r =R.error();
|
}
|
} catch (IOException e) {
|
wcsThrown = e;
|
throw new RuntimeException(e);
|
} finally {
|
logWcsToApiLog(url, requestJson, response, wcsThrown, wcsBizOk);
|
}
|
return r;
|
}
|
|
@Override
|
public R pubWrksToWcs(List<WorkTaskParams> paramsList) {
|
if (paramsList == null || paramsList.isEmpty()) {
|
return R.error("任务不能为空！！");
|
}
|
|
Map<String, WrkMast> wrkMastMap = getWrkMastMap(paramsList);
|
List<WorkTaskParams> accepted = new ArrayList<>();
|
List<String> skipMsgs = new ArrayList<>();
|
|
for (WorkTaskParams params : paramsList) {
|
if (params == null) {
|
skipMsgs.add("任务不能为空！！");
|
continue;
|
}
|
WrkMast wrkMast = wrkMastMap.get(params.getTaskNo());
|
String validateMsg = validatePubTask(params, wrkMast);
|
if (!Cools.isEmpty(validateMsg)) {
|
skipMsgs.add(buildTaskMsg(params, validateMsg));
|
continue;
|
}
|
accepted.add(params);
|
}
|
|
if (accepted.isEmpty()) {
|
return R.error(skipMsgs.isEmpty() ? "无可下发任务" : skipMsgs.get(0)).add(skipMsgs);
|
}
|
|
accepted = filterOutboundByContiguousPlt(accepted, wrkMastMap, skipMsgs);
|
if (accepted.isEmpty()) {
|
return R.error(skipMsgs.isEmpty() ? "无可下发任务" : skipMsgs.get(0)).add(skipMsgs);
|
}
|
|
accepted.sort(pubWcsSortComparator(wrkMastMap));
|
List<List<WorkTaskParams>> chunks = buildPubChunks(accepted, wrkMastMap);
|
|
int successCount = 0;
|
List<String> failMsgs = new ArrayList<>();
|
List<WorkTaskParams> lastSentChunk = null;
|
String skipGroupKey = null;
|
Set<String> blockedOutboundUserKeys = new HashSet<>();
|
|
for (List<WorkTaskParams> chunk : chunks) {
|
if (chunk == null || chunk.isEmpty()) {
|
continue;
|
}
|
WorkTaskParams head = chunk.get(0);
|
WrkMast headMast = wrkMastMap.get(head.getTaskNo());
|
String key = buildBatchGroupKey(head, headMast);
|
String outboundUserKey = buildOutboundUserKey(head, headMast);
|
|
if (skipGroupKey != null && skipGroupKey.equals(key)) {
|
continue;
|
}
|
if (outboundUserKey != null && blockedOutboundUserKeys.contains(outboundUserKey)) {
|
continue;
|
}
|
|
String batchBlockMsg = validateOutboundBatchSeqReady(chunk, wrkMastMap);
|
if (!Cools.isEmpty(batchBlockMsg)) {
|
skipMsgs.add(batchBlockMsg);
|
skipGroupKey = key;
|
if (outboundUserKey != null) {
|
blockedOutboundUserKeys.add(outboundUserKey);
|
}
|
continue;
|
}
|
|
if (!outboundChunkPredecessorPltReady(chunk, wrkMastMap)) {
|
skipGroupKey = key;
|
continue;
|
}
|
|
if (lastSentChunk != null) {
|
WorkTaskParams lastHead = lastSentChunk.get(0);
|
String lastKey = buildBatchGroupKey(lastHead, wrkMastMap.get(lastHead.getTaskNo()));
|
if (lastKey.equals(key)) {
|
if (!sameOrderNextChunkAllowed(lastSentChunk)) {
|
skipGroupKey = key;
|
continue;
|
}
|
}
|
if (!sleepOneMinuteBeforeNextChunk()) {
|
break;
|
}
|
}
|
|
int ok = postWcsBatchChunk(chunk, wrkMastMap, failMsgs);
|
if (ok <= 0) {
|
skipGroupKey = key;
|
continue;
|
}
|
successCount += ok;
|
lastSentChunk = chunk;
|
}
|
|
Map<String, Object> result = new HashMap<>();
|
result.put("successCount", successCount);
|
result.put("skipCount", skipMsgs.size());
|
result.put("failCount", failMsgs.size());
|
if (!skipMsgs.isEmpty()) {
|
result.put("skipMsgs", skipMsgs);
|
}
|
if (!failMsgs.isEmpty()) {
|
result.put("failMsgs", failMsgs);
|
}
|
|
if (successCount == 0) {
|
String msg = !failMsgs.isEmpty() ? failMsgs.get(0) : (skipMsgs.isEmpty() ? "WCS下发任务失败" : skipMsgs.get(0));
|
return R.error(msg).add(result);
|
}
|
return R.ok(failMsgs.isEmpty() && skipMsgs.isEmpty() ? "操作成功" : "部分任务下发成功").add(result);
|
}
|
|
private int postWcsBatchChunk(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap, List<String> failMsgs) {
|
if (chunk == null || chunk.isEmpty()) {
|
return 0;
|
}
|
String path = resolveTaskPath(chunk.get(0));
|
Map<String, Object> payload = new HashMap<>();
|
payload.put("taskList", buildTaskPayloads(chunk));
|
String requestJson = JSON.toJSONString(payload);
|
String response = null;
|
Throwable wcsThrown = null;
|
boolean wcsBizOk = false;
|
try {
|
log.info("批量下发搬运任务给wcs={}", requestJson);
|
response = new HttpHandler.Builder()
|
.setUri(wcs_address)
|
.setPath(path)
|
.setTimeout(60, TimeUnit.SECONDS)
|
.setJson(requestJson)
|
.build()
|
.doPost();
|
JSONObject jsonObject = JSON.parseObject(response == null ? "{}" : response);
|
log.info("批量下发任务给wcs的返回值={}", response);
|
Integer code = jsonObject.getInteger("code");
|
wcsBizOk = code != null && code == 200;
|
if (wcsBizOk) {
|
for (WorkTaskParams params : chunk) {
|
updateWrkMastAfterPublish(wrkMastMap.get(params.getTaskNo()));
|
}
|
return chunk.size();
|
}
|
String msg = jsonObject.getString("msg");
|
failMsgs.add("path=" + path + ", msg=" + (Cools.isEmpty(msg) ? "WCS下发任务失败" : msg));
|
log.error("批量下发任务给wcs失败, path:{}, request:{}, response:{}", path, requestJson, response);
|
} catch (IOException e) {
|
wcsThrown = e;
|
failMsgs.add("path=" + path + ", msg=" + e.getMessage());
|
log.error("批量下发任务给wcs异常, path:{}, request:{}, response:{}", path, requestJson, response, e);
|
} finally {
|
logWcsToApiLog(path, requestJson, response, wcsThrown, wcsBizOk);
|
}
|
return 0;
|
}
|
|
/**
|
* 出库：仅当单号、批次、序号均有效时做批次内跳号校验；无效时仍下发。入库/移库不处理。
|
*/
|
private List<WorkTaskParams> filterOutboundByContiguousPlt(List<WorkTaskParams> accepted, Map<String, WrkMast> wrkMastMap, List<String> skipMsgs) {
|
Map<String, Integer> reachCache = new HashMap<>();
|
List<WorkTaskParams> kept = new ArrayList<>();
|
for (WorkTaskParams p : accepted) {
|
if (!"out".equalsIgnoreCase(p.getType())) {
|
kept.add(p);
|
continue;
|
}
|
WrkMast w = wrkMastMap.get(p.getTaskNo());
|
String userNo = sortUserNoForPub(p, w);
|
String batchGroup = sortBatchGroupForPub(p, w);
|
Integer plt = sortPltForPub(p, w);
|
if (Cools.isEmpty(userNo) || plt == null || plt <= 0) {
|
kept.add(p);
|
continue;
|
}
|
String cacheKey = buildOutboundBatchCacheKey(userNo, batchGroup);
|
int maxReach = reachCache.computeIfAbsent(cacheKey, key -> wrkMastService.outboundSeqMaxContiguousPlt(userNo, batchGroup));
|
if (plt > maxReach) {
|
skipMsgs.add(buildTaskMsg(p, "出库序号跳号，跳过"));
|
continue;
|
}
|
kept.add(p);
|
}
|
return kept;
|
}
|
|
private List<List<WorkTaskParams>> buildPubChunks(List<WorkTaskParams> accepted, Map<String, WrkMast> wrkMastMap) {
|
List<List<WorkTaskParams>> chunks = new ArrayList<>();
|
int index = 0;
|
while (index < accepted.size()) {
|
WorkTaskParams head = accepted.get(index);
|
WrkMast headMast = wrkMastMap.get(head.getTaskNo());
|
String headGroupKey = buildBatchGroupKey(head, headMast);
|
List<WorkTaskParams> chunk = new ArrayList<>();
|
while (index < accepted.size() && chunk.size() < WCS_PUB_BATCH_SIZE) {
|
WorkTaskParams cur = accepted.get(index);
|
WrkMast curMast = wrkMastMap.get(cur.getTaskNo());
|
if (!headGroupKey.equals(buildBatchGroupKey(cur, curMast))) {
|
break;
|
}
|
chunk.add(cur);
|
index++;
|
}
|
chunks.add(chunk);
|
}
|
return chunks;
|
}
|
|
private boolean sleepOneMinuteBeforeNextChunk() {
|
try {
|
TimeUnit.MINUTES.sleep(1);
|
return true;
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("批量下发WCS组间等待被中断", e);
|
return false;
|
}
|
}
|
|
/**
|
* 同单同批下一组：优先 WCS queryTask；失败或无数据则主表已非 11 或已进历史表。
|
*/
|
private boolean sameOrderNextChunkAllowed(List<WorkTaskParams> lastSentChunk) {
|
if (lastSentChunk == null || lastSentChunk.isEmpty()) {
|
return false;
|
}
|
if (!Boolean.parseBoolean(String.valueOf(switchValue))) {
|
return true;
|
}
|
WorkTaskParams last = lastSentChunk.get(lastSentChunk.size() - 1);
|
if (last != null && !Cools.isEmpty(last.getTaskNo()) && wcsQueryTaskShowsTask(last.getTaskNo())) {
|
return true;
|
}
|
if (last != null && !Cools.isEmpty(last.getTaskNo())) {
|
log.info("WCS queryTask 无数据或失败，回退 WMS 主表/历史校验, taskNo={}", last.getTaskNo());
|
}
|
return previousChunkTasksReleasedInWms(lastSentChunk);
|
}
|
|
private boolean wcsQueryTaskShowsTask(String taskNo) {
|
Map<String, Object> body = new HashMap<>();
|
body.put("taskNo", taskNo);
|
try {
|
String response = new HttpHandler.Builder()
|
.setUri(wcs_address)
|
.setPath(queryTaskPath)
|
.setHttps(wcs_address != null && wcs_address.startsWith("https://"))
|
.setTimeout(60, TimeUnit.SECONDS)
|
.setJson(JSON.toJSONString(body))
|
.build()
|
.doPost();
|
JSONObject jo = JSON.parseObject(response == null ? "{}" : response);
|
Integer code = jo.getInteger("code");
|
return code != null && code == 200 && queryTaskDataNonEmpty(jo.get("data"));
|
} catch (IOException e) {
|
log.warn("WCS queryTask 异常, taskNo={}", taskNo, e);
|
return false;
|
}
|
}
|
|
/**
|
* 上一组每条：主表无则看历史表；主表有则 wrk_sts 不能仍为 11。
|
*/
|
private boolean previousChunkTasksReleasedInWms(List<WorkTaskParams> chunk) {
|
for (WorkTaskParams p : chunk) {
|
if (p == null || Cools.isEmpty(p.getTaskNo())) {
|
return false;
|
}
|
Integer wrkNo = Integer.valueOf(p.getTaskNo());
|
WrkMast m = wrkMastService.selectById(wrkNo);
|
if (m == null) {
|
int logCnt = wrkMastLogService.selectCount(new EntityWrapper<WrkMastLog>().eq("wrk_no", wrkNo));
|
if (logCnt <= 0) {
|
return false;
|
}
|
} else if (m.getWrkSts() != null && Objects.equals(m.getWrkSts(), 11L)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/**
|
* 出库每组下发前：本组有有效最小序号且>1 时，只校验「同单同批的最小序号-1」一档；序号全无则跳过本条件。
|
*/
|
private boolean outboundChunkPredecessorPltReady(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap) {
|
if (chunk == null || chunk.isEmpty()) {
|
return true;
|
}
|
WorkTaskParams head = chunk.get(0);
|
if (!"out".equalsIgnoreCase(head.getType())) {
|
return true;
|
}
|
WrkMast headMast = wrkMastMap.get(head.getTaskNo());
|
String userNo = sortUserNoForPub(head, headMast);
|
String batchGroup = sortBatchGroupForPub(head, headMast);
|
if (Cools.isEmpty(userNo)) {
|
return true;
|
}
|
int minPlt = Integer.MAX_VALUE;
|
for (WorkTaskParams p : chunk) {
|
if (!"out".equalsIgnoreCase(p.getType())) {
|
continue;
|
}
|
Integer plt = sortPltForPub(p, wrkMastMap.get(p.getTaskNo()));
|
if (plt != null && plt > 0 && plt < minPlt) {
|
minPlt = plt;
|
}
|
}
|
if (minPlt == Integer.MAX_VALUE || minPlt <= 1) {
|
return true;
|
}
|
return outboundPltSlotReleasedInWms(userNo, batchGroup, minPlt - 1);
|
}
|
|
private String validateOutboundBatchSeqReady(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap) {
|
if (chunk == null || chunk.isEmpty()) {
|
return null;
|
}
|
WorkTaskParams head = chunk.get(0);
|
return validateOutboundBatchSeqReady(head, wrkMastMap.get(head.getTaskNo()));
|
}
|
|
private String validateOutboundBatchSeqReady(WorkTaskParams params, WrkMast wrkMast) {
|
if (params == null || !"out".equalsIgnoreCase(params.getType())) {
|
return null;
|
}
|
if (wrkMast == null || !Objects.equals(wrkMast.getIoType(), 101)) {
|
return null;
|
}
|
return outboundBatchSeqReleaseGuard.validateReady(
|
sortUserNoForPub(params, wrkMast),
|
sortBatchGroupForPub(params, wrkMast));
|
}
|
|
private boolean outboundPltSlotReleasedInWms(String userNo, String batchSeq, int pltType) {
|
EntityWrapper<WrkMast> mastWrapper = new EntityWrapper<>();
|
mastWrapper.eq("user_no", userNo);
|
mastWrapper.eq("io_type", 101);
|
mastWrapper.eq("plt_type", pltType);
|
if (batchSeq == null) {
|
mastWrapper.isNull("batch_seq");
|
} else {
|
mastWrapper.eq("batch_seq", batchSeq);
|
}
|
List<WrkMast> rows = wrkMastService.selectList(mastWrapper);
|
if (rows != null && !rows.isEmpty()) {
|
for (WrkMast m : rows) {
|
if (m != null && m.getWrkSts() != null && Objects.equals(m.getWrkSts(), 11L)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
EntityWrapper<WrkMastLog> logWrapper = new EntityWrapper<>();
|
logWrapper.eq("user_no", userNo);
|
logWrapper.eq("io_type", 101);
|
logWrapper.eq("plt_type", pltType);
|
if (batchSeq == null) {
|
logWrapper.isNull("batch_seq");
|
} else {
|
logWrapper.eq("batch_seq", batchSeq);
|
}
|
int logCnt = wrkMastLogService.selectCount(logWrapper);
|
return logCnt > 0;
|
}
|
|
private static boolean queryTaskDataNonEmpty(Object data) {
|
if (data == null) {
|
return false;
|
}
|
if (data instanceof JSONArray) {
|
return !((JSONArray) data).isEmpty();
|
}
|
if (data instanceof Collection) {
|
return !((Collection<?>) data).isEmpty();
|
}
|
if (data instanceof String) {
|
String s = (String) data;
|
if (Cools.isEmpty(s)) {
|
return false;
|
}
|
JSONArray arr = JSON.parseArray(s);
|
return arr != null && !arr.isEmpty();
|
}
|
return true;
|
}
|
|
private Comparator<WorkTaskParams> pubWcsSortComparator(Map<String, WrkMast> wrkMastMap) {
|
return Comparator
|
.comparing((WorkTaskParams p) -> Optional.ofNullable(p.getType()).orElse(""), String.CASE_INSENSITIVE_ORDER)
|
.thenComparing(p -> sortUserNoForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(String::compareTo))
|
.thenComparing(p -> sortBatchGroupForPub(p, wrkMastMap.get(p.getTaskNo())), WcsApiServiceImpl::compareBatchSeqNatural)
|
.thenComparing(p -> sortPltForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(Integer::compareTo));
|
}
|
|
private static String sortUserNoForPub(WorkTaskParams p, WrkMast wrkMast) {
|
String userNo = wrkMast == null ? null : wrkMast.getUserNo();
|
if (Cools.isEmpty(userNo)) {
|
userNo = p.getBatch();
|
}
|
return Cools.isEmpty(userNo) ? null : userNo;
|
}
|
|
private static Integer sortPltForPub(WorkTaskParams p, WrkMast wrkMast) {
|
if (wrkMast != null && wrkMast.getPltType() != null) {
|
return wrkMast.getPltType();
|
}
|
return p.getBatchSeq();
|
}
|
|
private static String sortBatchGroupForPub(WorkTaskParams p, WrkMast wrkMast) {
|
if (wrkMast != null) {
|
return wrkMast.getBatchSeq();
|
}
|
return null;
|
}
|
|
private static String buildOutboundUserKey(WorkTaskParams params, WrkMast wrkMast) {
|
if (params == null || !"out".equalsIgnoreCase(params.getType())) {
|
return null;
|
}
|
String userNo = sortUserNoForPub(params, wrkMast);
|
if (Cools.isEmpty(userNo)) {
|
return null;
|
}
|
return resolveSafeKey(userNo);
|
}
|
|
private static int compareBatchSeqNatural(String left, String right) {
|
String safeLeft = normalizeBatchSeq(left);
|
String safeRight = normalizeBatchSeq(right);
|
int leftIndex = 0;
|
int rightIndex = 0;
|
while (leftIndex < safeLeft.length() && rightIndex < safeRight.length()) {
|
char leftChar = safeLeft.charAt(leftIndex);
|
char rightChar = safeRight.charAt(rightIndex);
|
if (Character.isDigit(leftChar) && Character.isDigit(rightChar)) {
|
int leftStart = leftIndex;
|
int rightStart = rightIndex;
|
while (leftIndex < safeLeft.length() && Character.isDigit(safeLeft.charAt(leftIndex))) {
|
leftIndex++;
|
}
|
while (rightIndex < safeRight.length() && Character.isDigit(safeRight.charAt(rightIndex))) {
|
rightIndex++;
|
}
|
String leftNumber = safeLeft.substring(leftStart, leftIndex);
|
String rightNumber = safeRight.substring(rightStart, rightIndex);
|
int compare = new BigInteger(leftNumber).compareTo(new BigInteger(rightNumber));
|
if (compare != 0) {
|
return compare;
|
}
|
compare = Integer.compare(leftNumber.length(), rightNumber.length());
|
if (compare != 0) {
|
return compare;
|
}
|
continue;
|
}
|
int compare = Character.compare(leftChar, rightChar);
|
if (compare != 0) {
|
return compare;
|
}
|
leftIndex++;
|
rightIndex++;
|
}
|
return Integer.compare(safeLeft.length(), safeRight.length());
|
}
|
|
private static String normalizeBatchSeq(String value) {
|
return Cools.isEmpty(value) ? "" : value;
|
}
|
|
private static String resolveSafeKey(String value) {
|
return Cools.isEmpty(value) ? "_EMPTY_" : value;
|
}
|
|
private static String buildOutboundBatchCacheKey(String userNo, String batchSeq) {
|
String safeUserNo = Cools.isEmpty(userNo) ? "_NO_USER_" : userNo;
|
String safeBatchSeq = Cools.isEmpty(batchSeq) ? "_NO_BATCH_" : batchSeq;
|
return safeUserNo + "#" + safeBatchSeq;
|
}
|
|
/**
|
* 堆垛机执行状态上报
|
*
|
* @param params
|
* @return com.core.common.R
|
* @author Ryan
|
* @date 2026/1/10 16:30
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R receviceTaskFromWcs(ReceviceTaskParams params) {
|
log.info("wcs任务反馈="+JSON.toJSONString(params));
|
if (Objects.isNull(params.getSuperTaskNo())) {
|
throw new CoolException("WMS任务号不能为空！！");
|
}
|
if (Objects.isNull(params.getNotifyType())) {
|
throw new CoolException("动作类型不能为空！！");
|
}
|
WrkMast mast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", params.getSuperTaskNo()));
|
if (Objects.isNull(mast)) {
|
// pakoutOrderPause 中止时，WMS 在 WCS 确认取消后会立即本地取消并归档任务。
|
// 如果 WCS 后续又补发 task_cancel 回调，此时当前工作档已不存在，按幂等成功处理。
|
if (isTaskCancelCallback(params) || isTaskCompleteAlreadyArchived(params)) {
|
return R.ok();
|
}
|
throw new CoolException("任务档不存在！！");
|
}
|
|
|
if (isOutboundCrnTaskRun(params)) {
|
// WCS出库任务开始：堆垛机开始执行出库任务，工作状态 12 -> 13。
|
if (isOutboundTask(mast) && Objects.equals(mast.getWrkSts(), 12L)) {
|
mast.setWrkSts(OUT_LOCK_REPORT_PENDING_WRK_STS);
|
mast.setExpTime(0D);
|
mast.setLogMk(OUT_LOCK_REPORT_PENDING_FLAG);
|
mast.setLogErrMemo(null);
|
mast.setLogErrTime(null);
|
mast.setModiTime(new Date());
|
if (!wrkMastService.updateById(mast)) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
}
|
} else if (isOutboundCrnTaskComplete(params)) {
|
// WCS出库任务完成：堆垛机出库任务执行完成，工作状态 -> 25。
|
if (isOutboundTask(mast) && canMarkOutboundCrnComplete(mast)) {
|
mast.setWrkSts(OUTBOUND_CRN_COMPLETE_WRK_STS);
|
mast.setModiTime(new Date());
|
if (!wrkMastService.updateById(mast)) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
}
|
} else if (isOutboundStationTaskRunComplete(params)) {
|
// WCS输送站点出库任务运行完成：托盘已到目的地，工作状态 -> 26。
|
if (isOutboundTask(mast) && canMarkOutboundStationComplete(mast)) {
|
mast.setWrkSts(OUTBOUND_STATION_COMPLETE_WRK_STS);
|
mast.setModiTime(new Date());
|
if (!wrkMastService.updateById(mast)) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
}
|
} else if (isTaskCompleteCallback(params)) {
|
//任务
|
boolean needUpdate = false;
|
applyTaskCompleteWeight(params, mast);
|
if (isInboundOrMoveTask(mast)) {
|
if (isInboundOrMoveTaskCompletionHandled(mast)) {
|
return R.ok();
|
}
|
mast.setWrkSts(INBOUND_TASK_COMPLETE_WRK_STS);
|
needUpdate = true;
|
} else if (isOutboundTask(mast) && canMarkOutboundTaskComplete(mast)) {
|
mast.setWrkSts(OUTBOUND_TASK_COMPLETE_WRK_STS);
|
if(Cools.isEmpty(mast.getStaNo())){
|
mast.setOveMk("Y");
|
}
|
needUpdate = true;
|
}
|
if (needUpdate && !wrkMastService.updateById(mast)) {
|
throw new CoolException("任务状态修改失败！！");
|
}
|
} else if (isTaskCancelCallback(params)) {
|
//wcs任务取消接口
|
workService.cancelWrkMast(String.valueOf(mast.getWrkNo()), 9955L);
|
}
|
return R.ok();
|
}
|
|
private boolean isTaskCompleteCallback(ReceviceTaskParams params) {
|
return params != null && "task_complete".equalsIgnoreCase(params.getMsgType());
|
}
|
|
private boolean isTaskCancelCallback(ReceviceTaskParams params) {
|
return params != null && "task_cancel".equalsIgnoreCase(params.getMsgType());
|
}
|
|
private boolean isInboundOrMoveTaskCompletionHandled(WrkMast mast) {
|
if (mast == null || mast.getWrkSts() == null) {
|
return false;
|
}
|
return Objects.equals(mast.getWrkSts(), INBOUND_TASK_COMPLETE_WRK_STS)
|
|| Objects.equals(mast.getWrkSts(), INBOUND_FINISHED_WRK_STS)
|
|| Objects.equals(mast.getWrkSts(), INBOUND_ERP_REPORT_PENDING_WRK_STS);
|
}
|
|
private boolean isTaskCompleteAlreadyArchived(ReceviceTaskParams params) {
|
if (!isTaskCompleteCallback(params) || Cools.isEmpty(params.getSuperTaskNo())) {
|
return false;
|
}
|
return wrkMastLogService.selectCount(new EntityWrapper<WrkMastLog>()
|
.eq("wrk_no", params.getSuperTaskNo())
|
.in("wrk_sts", Arrays.asList((int) INBOUND_FINISHED_WRK_STS, (int) INBOUND_ERP_REPORT_PENDING_WRK_STS))) > 0;
|
}
|
|
private boolean isInboundOrMoveTask(WrkMast mast) {
|
if (mast == null || mast.getIoType() == null) {
|
return false;
|
}
|
Integer ioType = mast.getIoType();
|
return Objects.equals(ioType, 1)
|
|| Objects.equals(ioType, 10)
|
|| Objects.equals(ioType, 11)
|
|| Objects.equals(ioType, CHANGE_LOC_IO_TYPE);
|
}
|
|
private void applyTaskCompleteWeight(ReceviceTaskParams params, WrkMast mast) {
|
if (params == null || mast == null || params.getWeight() == null) {
|
return;
|
}
|
mast.setScWeight(BigDecimal.valueOf(params.getWeight()));
|
}
|
|
private boolean isOutboundCrnTaskRun(ReceviceTaskParams params) {
|
return params != null
|
&& "Crn".equalsIgnoreCase(params.getNotifyType())
|
&& "crn_out_task_run".equalsIgnoreCase(params.getMsgType());
|
}
|
|
private boolean isOutboundCrnTaskComplete(ReceviceTaskParams params) {
|
return params != null
|
&& "Crn".equalsIgnoreCase(params.getNotifyType())
|
&& "crn_out_task_complete".equalsIgnoreCase(params.getMsgType());
|
}
|
|
private boolean isOutboundStationTaskRunComplete(ReceviceTaskParams params) {
|
return params != null
|
&& "Devp".equalsIgnoreCase(params.getNotifyType())
|
&& "station_out_task_run_complete".equalsIgnoreCase(params.getMsgType());
|
}
|
|
private boolean isOutboundTask(WrkMast mast) {
|
return mast != null && mast.getIoType() != null && (mast.getIoType() == 101 || mast.getIoType() == 110);
|
}
|
|
private boolean canMarkOutboundCrnComplete(WrkMast mast) {
|
if (mast == null || mast.getWrkSts() == null) {
|
return false;
|
}
|
return mast.getWrkSts() < 14
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS);
|
}
|
|
private boolean canMarkOutboundTaskComplete(WrkMast mast) {
|
if (mast == null || mast.getWrkSts() == null) {
|
return false;
|
}
|
return mast.getWrkSts() < 14
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS)
|
|| mast.getWrkSts().equals(OUTBOUND_CRN_COMPLETE_WRK_STS)
|
|| mast.getWrkSts().equals(OUTBOUND_STATION_COMPLETE_WRK_STS);
|
}
|
|
private boolean canMarkOutboundStationComplete(WrkMast mast) {
|
if (mast == null || mast.getWrkSts() == null) {
|
return false;
|
}
|
return mast.getWrkSts() < 14
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
|
|| mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS)
|
|| mast.getWrkSts().equals(OUTBOUND_CRN_COMPLETE_WRK_STS);
|
}
|
|
@Override
|
public R syncDeviceStatusFromWcs(boolean logOnFailure) {
|
if (!Boolean.parseBoolean(String.valueOf(switchValue))) {
|
return R.ok("WCS开关关闭");
|
}
|
String response = null;
|
try {
|
response = requestDeviceStatusFromWcs();
|
JSONObject jsonObject = JSON.parseObject(response == null ? "{}" : response);
|
Integer code = jsonObject.getInteger("code");
|
if (!Objects.equals(code, 200)) {
|
String msg = jsonObject.getString("msg");
|
return R.error(Cools.isEmpty(msg) ? "获取WCS设备状态失败" : msg);
|
}
|
JSONObject data = jsonObject.getJSONObject("data");
|
DeviceStatusVo deviceStatusVo = data == null
|
? new DeviceStatusVo()
|
: JSON.parseObject(data.toJSONString(), DeviceStatusVo.class);
|
|
int stationCount = syncStationStatus(deviceStatusVo.getStationList());
|
int crnCount = syncCrnStatus(deviceStatusVo.getCrnList());
|
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("stationCount", stationCount);
|
result.put("crnCount", crnCount);
|
log.info("同步WCS设备状态成功, stationCount={}, crnCount={}", stationCount, crnCount);
|
return R.ok("同步成功").add(result);
|
} catch (Exception e) {
|
if (logOnFailure) {
|
log.error("同步WCS设备状态异常, response={}", response, e);
|
} else {
|
log.debug("同步WCS设备状态异常, response={}", response, e);
|
}
|
return R.error("同步WCS设备状态失败: " + e.getMessage());
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R reassignInboundLoc(ReassignLocParams params) {
|
if (params == null) {
|
return R.error("参数不能为空！！");
|
}
|
if (Cools.isEmpty(params.getTaskNo())) {
|
return R.error("任务号不能为空！！");
|
}
|
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", params.getTaskNo()));
|
String validateMsg = validateReassignInboundTask(wrkMast);
|
if (!Cools.isEmpty(validateMsg)) {
|
return R.error(validateMsg);
|
}
|
|
LocMast currentLoc = locMastService.selectById(wrkMast.getLocNo());
|
if (Cools.isEmpty(currentLoc)) {
|
return R.error("当前目标库位不存在");
|
}
|
|
boolean emptyPallet = isReassignEmptyPallet(wrkMast);
|
LocTypeDto locTypeDto = buildReassignLocTypeDto(currentLoc, emptyPallet);
|
BasDevp sourceStation = basDevpService.selectById(wrkMast.getSourceStaNo());
|
if (Cools.isEmpty(sourceStation)) {
|
return R.error("源站未配置入库优先池");
|
}
|
List<ReassignCrnPool> poolOrder;
|
try {
|
poolOrder = buildReassignCrnPoolOrder(sourceStation, wrkMast.getCrnNo());
|
} catch (CoolException e) {
|
return R.error(e.getMessage());
|
}
|
if (Cools.isEmpty(poolOrder)) {
|
return R.error("源站未配置入库优先池");
|
}
|
|
StartupDto startupDto = null;
|
Integer targetLevel = resolveReassignTargetLevel(emptyPallet);
|
for (ReassignCrnPool pool : poolOrder) {
|
List<Integer> candidateCrnNos = buildReassignCandidateCrnNos(pool.crnNos, wrkMast.getCrnNo());
|
if (candidateCrnNos.isEmpty()) {
|
continue;
|
}
|
startupDto = commonService.findRun2InboundLocByCandidateCrnNos(
|
wrkMast.getSourceStaNo(), wrkMast.getIoType(), candidateCrnNos, locTypeDto, targetLevel);
|
if (startupDto != null && !Cools.isEmpty(startupDto.getLocNo())) {
|
break;
|
}
|
}
|
if (startupDto == null || Cools.isEmpty(startupDto.getLocNo())) {
|
return R.error("当前优先池没有可重新分配的空库位");
|
}
|
|
LocMast targetLoc = locMastService.selectById(startupDto.getLocNo());
|
if (Cools.isEmpty(targetLoc)) {
|
throw new CoolException("新目标库位不存在");
|
}
|
if (!"O".equals(targetLoc.getLocSts())) {
|
throw new CoolException(targetLoc.getLocNo() + "目标库位已被占用");
|
}
|
|
Date now = new Date();
|
updateReassignTargetLoc(targetLoc, wrkMast, currentLoc, now);
|
updateReassignWorkMast(wrkMast, startupDto, now);
|
releaseOldReservedLocIfNeeded(currentLoc, targetLoc.getLocNo(), now);
|
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("locNo", Utils.WMSLocToWCSLoc(targetLoc.getLocNo()));
|
return R.ok("操作成功").add(result);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R changeLoc(ChangeLocParams params) {
|
if (params == null || Cools.isEmpty(params.getLocNo())) {
|
return R.error("locNo不能为空");
|
}
|
String s = Utils.WCSLocToWMSLoc(params.getLocNo());
|
if (Cools.isEmpty(params.getLocNo())) {
|
return R.error("locNo<UNK>");
|
}
|
params.setLocNo(s);
|
LocMast sourceLoc = locMastService.selectById(params.getLocNo());
|
if (sourceLoc == null) {
|
return R.error("当前库位不存在");
|
}
|
CrnDepthRuleProfile profile = resolveChangeLocProfile(sourceLoc);
|
String validateMsg = validateChangeLocSource(sourceLoc, profile);
|
if (!Cools.isEmpty(validateMsg)) {
|
return R.error(validateMsg);
|
}
|
List<Integer> candidateRows = resolveChangeLocRows(params.getRow(), profile);
|
LocMast targetLoc = selectChangeLocTarget(sourceLoc, profile, candidateRows);
|
if (targetLoc == null) {
|
return R.error("当前堆垛机无可用移库目标位");
|
}
|
Integer workNo = commonService.getWorkNo(WorkNoType.PICK.type);
|
Date now = new Date();
|
createChangeLocTask(workNo, sourceLoc, targetLoc, now);
|
reserveChangeLocTargetLoc(targetLoc, sourceLoc, now);
|
reserveChangeLocSourceLoc(sourceLoc, now);
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("locNo", Utils.WMSLocToWCSLoc(targetLoc.getLocNo()));
|
result.put("taskNo", String.valueOf(workNo));
|
return R.ok("操作成功").add(result);
|
}
|
|
private CrnDepthRuleProfile resolveChangeLocProfile(LocMast sourceLoc) {
|
RowLastno rowLastno = rowLastnoService.selectById(3);
|
return basCrnDepthRuleService.resolveProfile(rowLastno, sourceLoc.getCrnNo(), sourceLoc.getRow1());
|
}
|
|
private String validateChangeLocSource(LocMast sourceLoc, CrnDepthRuleProfile profile) {
|
if (sourceLoc.getCrnNo() == null) {
|
return "当前库位未绑定堆垛机";
|
}
|
if (profile == null || !profile.isDoubleExtension()) {
|
return "当前堆垛机非双深库位，不支持移库";
|
}
|
if (sourceLoc.getRow1() == null || profile == null || !profile.isShallowRow(sourceLoc.getRow1())) {
|
return "当前库位不是浅库位";
|
}
|
if (!isChangeLocInStockLocSts(sourceLoc.getLocSts())) {
|
return "当前库位状态不允许移库";
|
}
|
return null;
|
}
|
|
private List<Integer> resolveChangeLocRows(List<Integer> requestRows, CrnDepthRuleProfile profile) {
|
if (!Cools.isEmpty(requestRows)) {
|
return requestRows.stream()
|
.filter(Objects::nonNull)
|
.distinct()
|
.collect(Collectors.toList());
|
}
|
return profile == null ? Collections.emptyList() : profile.getSearchRows();
|
}
|
|
private LocMast selectChangeLocTarget(LocMast sourceLoc, CrnDepthRuleProfile profile, List<Integer> candidateRows) {
|
List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
|
.eq("crn_no", sourceLoc.getCrnNo())
|
.eq("loc_type1",2)
|
.eq("loc_sts", "O")
|
.orderBy("row1", true)
|
.orderBy("lev1", true)
|
.orderBy("bay1", true));
|
if (Cools.isEmpty(locMasts)) {
|
return null;
|
}
|
// for (LocMast locMast : locMasts) {
|
// if (!isChangeLocRowAllowed(locMast, candidateRows)) {
|
// continue;
|
// }
|
// if (locMast.getRow1() != null && Utils.isDeepLoc(slaveProperties, locMast.getRow1())) {
|
// return locMast;
|
// }
|
// }
|
// for (LocMast locMast : locMasts) {
|
// if (!isChangeLocRowAllowed(locMast, candidateRows)) {
|
// continue;
|
// }
|
// if (locMast.getRow1() == null || !Utils.isShallowLoc(slaveProperties, locMast.getRow1())) {
|
// continue;
|
// }
|
// String deepLocNo = Utils.getDeepLoc(slaveProperties, locMast.getLocNo());
|
// LocMast deepLoc = locMastService.selectById(deepLocNo);
|
// if (deepLoc != null && ("F".equals(deepLoc.getLocSts()) || "D".equals(deepLoc.getLocSts()))) {
|
// return locMast;
|
// }
|
// }
|
LocMast shallowFallback = null;
|
for (LocMast locMast : locMasts) {
|
//排过滤
|
if (!isChangeLocRowAllowed(locMast, candidateRows)) {
|
continue;
|
}
|
//深位优先
|
if (isChangeLocDeepCandidate(locMast, profile)) {
|
return locMast;
|
}
|
//浅位兜底
|
if (shallowFallback == null && isChangeLocShallowFallbackCandidate(locMast, profile)) {
|
shallowFallback = locMast;
|
}
|
}
|
return shallowFallback;
|
}
|
|
private boolean isChangeLocRowAllowed(LocMast locMast, List<Integer> candidateRows) {
|
if (Cools.isEmpty(candidateRows)) {
|
return true;
|
}
|
return locMast.getRow1() != null && candidateRows.contains(locMast.getRow1());
|
}
|
|
private boolean isChangeLocDeepCandidate(LocMast locMast, CrnDepthRuleProfile profile) {
|
return locMast.getRow1() != null
|
&& profile != null
|
&& profile.isDeepRow(locMast.getRow1());
|
}
|
|
private boolean isChangeLocShallowFallbackCandidate(LocMast locMast, CrnDepthRuleProfile profile) {
|
if (locMast.getRow1() == null || profile == null || !profile.isShallowRow(locMast.getRow1())) {
|
return false;
|
}
|
Integer deepRow = profile.getPairedDeepRow(locMast.getRow1());
|
if (deepRow == null) {
|
return false;
|
}
|
LocMast deepLoc = locMastService.selectOne(new EntityWrapper<LocMast>()
|
.eq("crn_no", locMast.getCrnNo())
|
.eq("row1", deepRow)
|
.eq("bay1", locMast.getBay1())
|
.eq("lev1", locMast.getLev1()));
|
return deepLoc != null && isChangeLocInStockLocSts(deepLoc.getLocSts());
|
}
|
|
private boolean isChangeLocInStockLocSts(String locSts) {
|
return "F".equals(locSts) || "D".equals(locSts);
|
}
|
|
private void createChangeLocTask(Integer workNo, LocMast sourceLoc, LocMast targetLoc, Date now) {
|
List<LocDetl> sourceDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLoc.getLocNo()));
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(now);
|
wrkMast.setWrkSts(1L);
|
wrkMast.setIoType(11);
|
wrkMast.setIoPri(10D);
|
wrkMast.setCrnNo(sourceLoc.getCrnNo());
|
wrkMast.setSourceLocNo(sourceLoc.getLocNo());
|
wrkMast.setLocNo(targetLoc.getLocNo());
|
wrkMast.setFullPlt(Cools.isEmpty(sourceDetls) ? "N" : "Y");
|
wrkMast.setPicking("N");
|
wrkMast.setExitMk("N");
|
wrkMast.setEmptyMk("D".equals(sourceLoc.getLocSts()) ? "Y" : "N");
|
wrkMast.setBarcode(sourceLoc.getBarcode());
|
wrkMast.setLinkMis("N");
|
wrkMast.setMemo("CHANGE_LOC");
|
wrkMast.setAppeUser(WCS_SYNC_USER);
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiUser(WCS_SYNC_USER);
|
wrkMast.setModiTime(now);
|
if (!wrkMastService.insert(wrkMast)) {
|
throw new CoolException("保存工作档失败");
|
}
|
if (Cools.isEmpty(sourceDetls)) {
|
return;
|
}
|
for (LocDetl sourceDetl : sourceDetls) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.sync(sourceDetl);
|
wrkDetl.setWrkNo(workNo);
|
wrkDetl.setIoTime(now);
|
wrkDetl.setAnfme(sourceDetl.getAnfme());
|
wrkDetl.setAppeTime(now);
|
wrkDetl.setAppeUser(WCS_SYNC_USER);
|
wrkDetl.setModiTime(now);
|
wrkDetl.setModiUser(WCS_SYNC_USER);
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
}
|
}
|
|
private void reserveChangeLocTargetLoc(LocMast targetLoc, LocMast sourceLoc, Date now) {
|
targetLoc.setLocSts("S");
|
targetLoc.setBarcode(sourceLoc.getBarcode());
|
targetLoc.setScWeight(sourceLoc.getScWeight() == null ? BigDecimal.ZERO : sourceLoc.getScWeight());
|
targetLoc.setModiUser(WCS_SYNC_USER);
|
targetLoc.setModiTime(now);
|
if (!locMastService.updateById(targetLoc)) {
|
throw new CoolException("更新目标库位状态失败");
|
}
|
}
|
|
private void reserveChangeLocSourceLoc(LocMast sourceLoc, Date now) {
|
sourceLoc.setLocSts("R");
|
sourceLoc.setModiUser(WCS_SYNC_USER);
|
sourceLoc.setModiTime(now);
|
if (!locMastService.updateById(sourceLoc)) {
|
throw new CoolException("更新源库位状态失败");
|
}
|
}
|
|
private boolean requiresOutboundErpConfirm(WrkMast wrkMast) {
|
Integer ioType = wrkMast == null ? null : wrkMast.getIoType();
|
return ioType != null && (ioType == 101 || ioType == 103 || ioType == 104 || ioType == 107 || ioType == 110);
|
}
|
|
/**
|
* 校验单条任务是否满足下发前提。
|
* <p>
|
* 这里既校验接口必填项，也校验业务约束，例如：
|
* 1. 出库任务是否被暂停；
|
* 2. 需要 ERP 确认的出库任务是否已确认。
|
*/
|
private String validatePubTask(WorkTaskParams params, WrkMast wrkMast) {
|
if (params == null) {
|
return "参数不能为空！！";
|
}
|
if (Cools.isEmpty(params.getTaskNo())) {
|
return "任务号不能为空！！";
|
}
|
if (Cools.isEmpty(params.getBarcode())) {
|
return "托盘码不能为空！！";
|
}
|
if (Cools.isEmpty(params.getLocNo())) {
|
return "目标库位不能为空！！";
|
}
|
if (!Objects.isNull(wrkMast) && "out".equalsIgnoreCase(params.getType())) {
|
if ("Y".equalsIgnoreCase(wrkMast.getPauseMk())) {
|
return "task paused";
|
}
|
if (Objects.equals(wrkMast.getIoType(), 101) && Cools.isEmpty(wrkMast.getBatchSeq())) {
|
return "出库进仓编号(batchSeq)为空，跳过下发";
|
}
|
if (requiresOutboundErpConfirm(wrkMast) && !"Y".equalsIgnoreCase(wrkMast.getPdcType())) {
|
return "task not confirmed by erp";
|
}
|
}
|
return null;
|
}
|
|
private String validateReassignInboundTask(WrkMast wrkMast) {
|
if (wrkMast == null) {
|
return "任务不存在";
|
}
|
if (wrkMast.getIoType() == null || (wrkMast.getIoType() != 1 && wrkMast.getIoType() != 10)) {
|
return "当前任务不是入库任务";
|
}
|
if (!Objects.equals(wrkMast.getWrkSts(), 2L)) {
|
return "当前任务状态不允许重新分配入库位";
|
}
|
if (wrkMast.getCrnNo() == null) {
|
return "当前任务未分配堆垛机";
|
}
|
if (Cools.isEmpty(wrkMast.getLocNo())) {
|
return "当前任务未分配目标库位";
|
}
|
if (wrkMast.getSourceStaNo() == null) {
|
return "当前任务缺少源站信息";
|
}
|
return null;
|
}
|
|
private List<ReassignCrnPool> buildReassignCrnPoolOrder(BasDevp sourceStation, Integer currentCrnNo) {
|
List<Integer> firstPoolCrnNos = Utils.distinctCrnNos(sourceStation.getInFirstCrnCsv());
|
List<Integer> secondPoolCrnNos = excludeReassignPoolCrnNos(
|
Utils.distinctCrnNos(sourceStation.getInSecondCrnCsv()), firstPoolCrnNos);
|
if (Cools.isEmpty(firstPoolCrnNos) && Cools.isEmpty(secondPoolCrnNos)) {
|
throw new CoolException("源站未配置入库优先池");
|
}
|
boolean inFirstPool = firstPoolCrnNos.contains(currentCrnNo);
|
boolean inSecondPool = secondPoolCrnNos.contains(currentCrnNo);
|
if (!inFirstPool && !inSecondPool) {
|
throw new CoolException("当前任务堆垛机未配置在源站入库优先池");
|
}
|
List<ReassignCrnPool> poolOrder = new ArrayList<>();
|
if (inFirstPool) {
|
poolOrder.add(new ReassignCrnPool(firstPoolCrnNos));
|
poolOrder.add(new ReassignCrnPool(secondPoolCrnNos));
|
return poolOrder;
|
}
|
poolOrder.add(new ReassignCrnPool(secondPoolCrnNos));
|
poolOrder.add(new ReassignCrnPool(firstPoolCrnNos));
|
return poolOrder;
|
}
|
|
private List<Integer> excludeReassignPoolCrnNos(List<Integer> crnNos, List<Integer> excludedCrnNos) {
|
List<Integer> result = new ArrayList<>();
|
if (Cools.isEmpty(crnNos)) {
|
return result;
|
}
|
LinkedHashSet<Integer> excluded = new LinkedHashSet<>(Utils.distinctCrnNos(excludedCrnNos));
|
for (Integer crnNo : Utils.distinctCrnNos(crnNos)) {
|
if (crnNo == null || excluded.contains(crnNo)) {
|
continue;
|
}
|
result.add(crnNo);
|
}
|
return result;
|
}
|
|
private List<Integer> buildReassignCandidateCrnNos(List<Integer> poolCrnNos, Integer currentCrnNo) {
|
return buildReassignCrnSearchOrder(poolCrnNos, currentCrnNo);
|
}
|
|
private List<Integer> buildReassignCrnSearchOrder(List<Integer> poolCrnNos, Integer currentCrnNo) {
|
List<Integer> orderedCrnNos = Utils.distinctCrnNos(poolCrnNos);
|
Collections.sort(orderedCrnNos);
|
if (Cools.isEmpty(orderedCrnNos) || currentCrnNo == null) {
|
return orderedCrnNos;
|
}
|
List<Integer> searchOrder = new ArrayList<>();
|
for (int index = orderedCrnNos.size() - 1; index >= 0; index--) {
|
Integer crnNo = orderedCrnNos.get(index);
|
if (crnNo == null || crnNo >= currentCrnNo) {
|
continue;
|
}
|
searchOrder.add(crnNo);
|
}
|
for (int index = orderedCrnNos.size() - 1; index >= 0; index--) {
|
Integer crnNo = orderedCrnNos.get(index);
|
if (crnNo == null || crnNo <= 0 || crnNo.equals(currentCrnNo) || crnNo < currentCrnNo) {
|
continue;
|
}
|
searchOrder.add(crnNo);
|
}
|
return searchOrder;
|
}
|
|
private Integer resolveReassignTargetLevel(boolean emptyPallet) {
|
if (emptyPallet) {
|
return EMPTY_PALLET_REASSIGN_TARGET_LEVEL;
|
}
|
return null;
|
}
|
|
private boolean isReassignEmptyPallet(WrkMast wrkMast) {
|
if (wrkMast == null || wrkMast.getWrkNo() == null) {
|
return false;
|
}
|
List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
|
if (Cools.isEmpty(wrkDetls)) {
|
return false;
|
}
|
for (WrkDetl wrkDetl : wrkDetls) {
|
if (wrkDetl != null && EMPTY_PALLET_MATNR.equalsIgnoreCase(String.valueOf(wrkDetl.getMatnr()).trim())) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private LocTypeDto buildReassignLocTypeDto(LocMast currentLoc, boolean emptyPallet) {
|
LocTypeDto locTypeDto = new LocTypeDto();
|
if (emptyPallet) {
|
locTypeDto.setLocType1(EMPTY_PALLET_REASSIGN_LOC_TYPE1);
|
locTypeDto.setLocType2(EMPTY_PALLET_REASSIGN_LOC_TYPE2);
|
return locTypeDto;
|
}
|
if (currentLoc == null) {
|
return locTypeDto;
|
}
|
locTypeDto.setLocType1(normalizeLocType(currentLoc.getLocType1()));
|
locTypeDto.setLocType2(normalizeLocType(currentLoc.getLocType2()));
|
locTypeDto.setLocType3(normalizeLocType(currentLoc.getLocType3()));
|
return locTypeDto;
|
}
|
|
private Short normalizeLocType(Short locType) {
|
return locType == null || locType <= 0 ? null : locType;
|
}
|
|
private void updateReassignTargetLoc(LocMast targetLoc, WrkMast wrkMast, LocMast currentLoc, Date now) {
|
targetLoc.setLocSts("S");
|
targetLoc.setModiUser(WCS_SYNC_USER);
|
targetLoc.setModiTime(now);
|
if (!Cools.isEmpty(wrkMast.getBarcode())) {
|
targetLoc.setBarcode(wrkMast.getBarcode());
|
} else if (!Cools.isEmpty(currentLoc) && !Cools.isEmpty(currentLoc.getBarcode())) {
|
targetLoc.setBarcode(currentLoc.getBarcode());
|
} else {
|
targetLoc.setBarcode("");
|
}
|
if (wrkMast.getScWeight() != null) {
|
targetLoc.setScWeight(wrkMast.getScWeight());
|
} else if (!Cools.isEmpty(currentLoc) && currentLoc.getScWeight() != null) {
|
targetLoc.setScWeight(currentLoc.getScWeight());
|
} else {
|
targetLoc.setScWeight(BigDecimal.ZERO);
|
}
|
if (!locMastService.updateById(targetLoc)) {
|
throw new CoolException("改变库位状态失败");
|
}
|
}
|
|
private void updateReassignWorkMast(WrkMast wrkMast, StartupDto startupDto, Date now) {
|
wrkMast.setLocNo(startupDto.getLocNo());
|
wrkMast.setCrnNo(startupDto.getCrnNo());
|
if (startupDto.getStaNo() != null) {
|
wrkMast.setStaNo(startupDto.getStaNo());
|
}
|
wrkMast.setWrkSts(2L);
|
wrkMast.setModiUser(WCS_SYNC_USER);
|
wrkMast.setModiTime(now);
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("修改工作档失败");
|
}
|
}
|
|
private void releaseOldReservedLocIfNeeded(LocMast currentLoc, String newLocNo, Date now) {
|
if (currentLoc == null || Cools.isEmpty(currentLoc.getLocNo()) || currentLoc.getLocNo().equals(newLocNo)) {
|
return;
|
}
|
if (!"S".equals(currentLoc.getLocSts())) {
|
return;
|
}
|
currentLoc.setLocSts("O");
|
currentLoc.setBarcode("");
|
currentLoc.setScWeight(BigDecimal.ZERO);
|
currentLoc.setModiUser(WCS_SYNC_USER);
|
currentLoc.setModiTime(now);
|
if (!locMastService.updateById(currentLoc)) {
|
throw new CoolException("释放原目标库位失败");
|
}
|
}
|
|
/**
|
* 按任务类型选择 WCS 接口地址。
|
* in -> 入库接口
|
* out -> 出库接口
|
* move -> 移库接口
|
*/
|
private String resolveTaskPath(WorkTaskParams params) {
|
if (!Objects.isNull(params.getType()) && params.getType().equals("out")) {
|
return getWcs_address;
|
}
|
if (!Objects.isNull(params.getType()) && params.getType().equals("move")) {
|
return createLocMoveTask;
|
}
|
return createInTask;
|
}
|
|
/**
|
* WCS 下发成功后推进本地工作档状态。
|
* <p>
|
* 这里只处理“已下发”这一层状态，不处理设备执行完成状态；
|
* 设备执行完成依然以 WCS 回写为准。
|
*/
|
private void updateWrkMastAfterPublish(WrkMast wrkMast) {
|
if (Objects.isNull(wrkMast)) {
|
return;
|
}
|
if (wrkMast.getIoType()==1 || wrkMast.getIoType()==10 || wrkMast.getIoType()==11) {
|
wrkMast.setWrkSts(2L);
|
wrkMast.setModiTime(new Date());
|
wrkMastService.updateById(wrkMast);
|
}else if(wrkMast.getIoType()==2){
|
wrkMast.setWrkSts(2L);
|
wrkMast.setModiTime(new Date());
|
wrkMastService.updateById(wrkMast);
|
}else if (wrkMast.getIoType()==101 || wrkMast.getIoType()==110) {
|
wrkMast.setWrkSts(12L);
|
wrkMast.setModiTime(new Date());
|
wrkMastService.updateById(wrkMast);
|
}
|
}
|
|
/**
|
* 把本次待下发的 taskNo 批量映射成工作档，供后续校验、按 userNo 分组、状态回写复用。
|
*/
|
private Map<String, WrkMast> getWrkMastMap(List<WorkTaskParams> paramsList) {
|
List<String> taskNos = paramsList.stream()
|
.filter(Objects::nonNull)
|
.map(WorkTaskParams::getTaskNo)
|
.filter(taskNo -> !Cools.isEmpty(taskNo))
|
.distinct()
|
.collect(Collectors.toList());
|
if (taskNos.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_no", taskNos));
|
if (wrkMasts == null || wrkMasts.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
return wrkMasts.stream()
|
.filter(Objects::nonNull)
|
.collect(Collectors.toMap(mast -> String.valueOf(mast.getWrkNo()), mast -> mast, (left, right) -> left, LinkedHashMap::new));
|
}
|
|
/**
|
* 构造批量下发的分组键。
|
* <p>
|
* 分组规则：
|
* 1. 先按接口路径区分，避免不同任务类型混用同一个 WCS 接口；
|
* 2. 再按 userNo + batchSeq 区分，确保相同订单同批次的任务一起上报。
|
* <p>
|
* 正常情况下 userNo 取自 work_mast.user_no；
|
* batchSeq 取自 work_mast.batch_seq；如果当前没查到工作档，则只按 userNo 回退兼容已有调用。
|
*/
|
private String buildBatchGroupKey(WorkTaskParams params, WrkMast wrkMast) {
|
String path = resolveTaskPath(params);
|
String userNo = wrkMast == null ? null : wrkMast.getUserNo();
|
String batchGroup = wrkMast == null ? null : wrkMast.getBatchSeq();
|
if (Cools.isEmpty(userNo)) {
|
userNo = params.getBatch();
|
}
|
if (Cools.isEmpty(userNo)) {
|
userNo = "_NO_USER_";
|
}
|
String batchKey = Cools.isEmpty(batchGroup) ? "_NO_BATCH_" : batchGroup;
|
return path + "#" + userNo + "#" + batchKey;
|
}
|
|
/**
|
* 将一组业务参数转换成 WCS 批量接口的 tasks 数组。
|
*/
|
private List<Map<String, Object>> buildTaskPayloads(List<WorkTaskParams> tasks) {
|
List<Map<String, Object>> payloads = new ArrayList<>();
|
for (WorkTaskParams task : tasks) {
|
payloads.add(buildTaskPayload(task));
|
}
|
return payloads;
|
}
|
|
/**
|
* 组装单条任务的 WCS 请求体。
|
* 只放当前任务类型实际需要的字段；空字段不透传，避免给 WCS 造成歧义。
|
*/
|
private Map<String, Object> buildTaskPayload(WorkTaskParams params) {
|
Map<String, Object> task = new LinkedHashMap<>();
|
if (!Cools.isEmpty(params.getTaskNo())) {
|
task.put("taskNo", params.getTaskNo());
|
}
|
if (!Cools.isEmpty(params.getLocNo())) {
|
task.put("locNo", params.getLocNo());
|
}
|
if (!Cools.isEmpty(params.getSourceLocNo())) {
|
task.put("sourceLocNo", params.getSourceLocNo());
|
}
|
if (!Cools.isEmpty(params.getSourceStaNo())) {
|
task.put("sourceStaNo", params.getSourceStaNo());
|
}
|
if (!Cools.isEmpty(params.getBarcode())) {
|
task.put("barcode", params.getBarcode());
|
}
|
if (!Objects.isNull(params.getTaskPri())) {
|
task.put("taskPri", params.getTaskPri());
|
}
|
if (!Cools.isEmpty(params.getStaNo())) {
|
task.put("staNo", params.getStaNo());
|
}
|
boolean includeOutBatch = !"out".equalsIgnoreCase(params.getType())
|
|| (params.getBatchSeq() != null && params.getBatchSeq() > 0);
|
if (includeOutBatch && !Cools.isEmpty(params.getBatch())) {
|
task.put("batch", params.getBatch());
|
}
|
if (includeOutBatch && !Objects.isNull(params.getBatchSeq())) {
|
task.put("batchSeq", params.getBatchSeq());
|
}
|
return task;
|
}
|
|
/**
|
* 构造跳过/失败信息时统一带上 taskNo，便于排查具体是哪一条工作档未被下发。
|
*/
|
private String buildTaskMsg(WorkTaskParams params, String msg) {
|
if (params == null || Cools.isEmpty(params.getTaskNo())) {
|
return msg;
|
}
|
return "taskNo=" + params.getTaskNo() + ", msg=" + msg;
|
}
|
|
@Override
|
public R pauseOutTasks(List<HashMap<String,Object>> params) {
|
if (params == null || params.size() == 0) {
|
return R.ok("无任务需要取消");
|
}
|
if (!Boolean.parseBoolean(String.valueOf(switchValue))) {
|
return R.ok("WCS开关关闭");
|
}
|
HashMap<String,Object> map = new HashMap<>();
|
map.put("taskList", params);
|
String requestJson = JSON.toJSONString(map);
|
String response = null;
|
Throwable wcsThrown = null;
|
boolean wcsBizOk = false;
|
try {
|
log.info("调用WCS取消出库任务, request={}", requestJson);
|
response = new HttpHandler.Builder()
|
.setUri(wcs_address)
|
.setPath(stopOutTask)
|
// .setHttps(wcs_address != null && wcs_address.startsWith("https://"))
|
.setTimeout(10, TimeUnit.SECONDS)
|
.setJson(requestJson)
|
.build()
|
.doPost();
|
JSONObject jsonObject = JSON.parseObject(response == null ? "{}" : response);
|
log.info("WCS取消出库任务返回, response={}", response);
|
Integer code = jsonObject.getInteger("code");
|
wcsBizOk = code != null && Objects.equals(code, 200);
|
if (!wcsBizOk) {
|
String msg = jsonObject.getString("msg");
|
throw new CoolException(Cools.isEmpty(msg) ? "WCS取消出库任务失败" : msg);
|
}
|
return R.ok(Cools.isEmpty(jsonObject.getString("msg")) ? "操作成功" : jsonObject.getString("msg"));
|
} catch (IOException e) {
|
wcsThrown = e;
|
throw new CoolException("调用WCS取消出库任务失败: " + e.getMessage());
|
} finally {
|
logWcsToApiLog(stopOutTask, requestJson, response, wcsThrown, wcsBizOk);
|
}
|
}
|
|
private void logWcsToApiLog(String path, String requestJson, String response, Throwable thrown, boolean wcsBizOk) {
|
String fullUrl = (wcs_address == null ? "" : wcs_address) + (path == null ? "" : path);
|
boolean success = thrown == null && wcsBizOk;
|
String resp = response == null ? "" : response;
|
if (thrown != null && Cools.isEmpty(resp)) {
|
resp = thrown.getMessage() == null ? "" : thrown.getMessage();
|
}
|
apiLogService.save(NS_WMS_TO_WCS, fullUrl, "-", "-",
|
requestJson == null ? "" : requestJson, resp, success);
|
}
|
|
private String requestDeviceStatusFromWcs() throws IOException {
|
HttpHandler.Builder builder = new HttpHandler.Builder()
|
.setUri(wcs_address)
|
.setPath(getDeviceStatus)
|
.setTimeout(10, TimeUnit.SECONDS);
|
String method = Cools.isEmpty(deviceStatusMethod) ? "POST" : deviceStatusMethod.trim().toUpperCase(Locale.ROOT);
|
if ("POST".equals(method)) {
|
return builder.setJson("{}").build().doPost();
|
}
|
return builder.build().doGet();
|
}
|
|
private int syncStationStatus(List<StationProtocol> stationList) {
|
if (stationList == null || stationList.isEmpty()) {
|
return 0;
|
}
|
int count = 0;
|
Date now = new Date();
|
for (StationProtocol stationProtocol : stationList) {
|
if (stationProtocol == null || stationProtocol.getStationId() == null) {
|
continue;
|
}
|
BasDevp basDevp = basDevpService.selectById(stationProtocol.getStationId());
|
boolean isNew = Objects.isNull(basDevp);
|
if (isNew) {
|
basDevp = new BasDevp();
|
basDevp.setDevNo(stationProtocol.getStationId());
|
basDevp.setAppeUser(WCS_SYNC_USER);
|
basDevp.setAppeTime(now);
|
}
|
basDevp.setInEnable(toFlag(stationProtocol.isInEnable()));
|
basDevp.setOutEnable(toFlag(stationProtocol.isOutEnable()));
|
basDevp.setAutoing(toFlag(stationProtocol.isAutoing()));
|
basDevp.setLoading(toFlag(stationProtocol.isLoading()));
|
basDevp.setCanining(toFlag(stationProtocol.isEnableIn()));
|
basDevp.setCanouting(toFlag(!stationProtocol.isRunBlock()));
|
basDevp.setWrkNo(defaultZero(stationProtocol.getTaskNo()));
|
basDevp.setBarcode(normalizeText(stationProtocol.getBarcode()));
|
basDevp.setGrossWt(stationProtocol.getWeight() == null ? 0D : stationProtocol.getWeight());
|
basDevp.setModiUser(WCS_SYNC_USER);
|
basDevp.setModiTime(now);
|
if (isNew) {
|
if (!basDevpService.insert(basDevp)) {
|
throw new CoolException("新增站点状态失败, stationId=" + stationProtocol.getStationId());
|
}
|
} else if (!basDevpService.updateById(basDevp)) {
|
throw new CoolException("更新站点状态失败, stationId=" + stationProtocol.getStationId());
|
}
|
count++;
|
}
|
return count;
|
}
|
|
private int syncCrnStatus(List<CrnProtocol> crnList) {
|
if (crnList == null || crnList.isEmpty()) {
|
return 0;
|
}
|
int count = 0;
|
Date now = new Date();
|
for (CrnProtocol crnProtocol : crnList) {
|
if (crnProtocol == null || crnProtocol.getCrnNo() == null) {
|
continue;
|
}
|
BasCrnp basCrnp = basCrnpService.selectById(crnProtocol.getCrnNo());
|
boolean isNew = Objects.isNull(basCrnp);
|
if (isNew) {
|
basCrnp = new BasCrnp();
|
basCrnp.setCrnNo(crnProtocol.getCrnNo());
|
basCrnp.setInEnable(YES);
|
basCrnp.setOutEnable(YES);
|
basCrnp.setAppeUser(WCS_SYNC_USER);
|
basCrnp.setAppeTime(now);
|
}
|
// crn_sts 本地表存的是“堆垛机模式(手动/自动/电脑)”，因此必须写 mode，不能写 status。
|
basCrnp.setCrnSts(defaultZero(crnProtocol.getMode()));
|
basCrnp.setWrkNo(defaultZero(crnProtocol.getTaskNo()));
|
basCrnp.setBay(crnProtocol.getBay());
|
basCrnp.setLevel(crnProtocol.getLevel());
|
basCrnp.setCrnErr(crnProtocol.getAlarm() == null ? 0L : Long.valueOf(crnProtocol.getAlarm()));
|
basCrnp.setModiUser(WCS_SYNC_USER);
|
basCrnp.setModiTime(now);
|
if (isNew) {
|
if (!basCrnpService.insert(basCrnp)) {
|
throw new CoolException("新增堆垛机状态失败, crnNo=" + crnProtocol.getCrnNo());
|
}
|
} else if (!basCrnpService.updateById(basCrnp)) {
|
throw new CoolException("更新堆垛机状态失败, crnNo=" + crnProtocol.getCrnNo());
|
}
|
count++;
|
}
|
return count;
|
}
|
|
private Integer defaultZero(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
private String normalizeText(String value) {
|
return Cools.isEmpty(value) ? "" : value;
|
}
|
|
private String toFlag(boolean value) {
|
return value ? YES : NO;
|
}
|
|
}
|
