package com.zy.core.utils.station;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.core.common.Cools;
|
import com.zy.asrs.entity.BasStationOpt;
|
import com.zy.asrs.service.BasStationOptService;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.enums.RedisKeyType;
|
import com.zy.core.enums.StationCommandType;
|
import com.zy.core.model.command.StationCommand;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Objects;
|
|
@Component
|
public class StationDispatchRuntimeStateSupport {
|
private static final int STATION_IDLE_TRACK_EXPIRE_SECONDS = 60 * 60;
|
private static final String IDLE_RECOVER_CLEARED_MEMO = "idleRecoverRerouteCleared";
|
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private BasStationOptService basStationOptService;
|
|
public StationTaskIdleTrack touchIdleTrack(Integer taskNo, Integer stationId) {
|
if (taskNo == null || taskNo <= 0 || stationId == null) {
|
return null;
|
}
|
long now = System.currentTimeMillis();
|
StationTaskIdleTrack idleTrack = loadIdleTrack(taskNo);
|
if (idleTrack == null || !Objects.equals(idleTrack.getStationId(), stationId)) {
|
idleTrack = new StationTaskIdleTrack(taskNo, stationId, now);
|
saveIdleTrack(idleTrack);
|
}
|
return idleTrack;
|
}
|
|
public StationTaskIdleTrack loadIdleTrack(Integer taskNo) {
|
if (taskNo == null || taskNo <= 0 || redisUtil == null) {
|
return null;
|
}
|
Object obj = redisUtil.get(RedisKeyType.STATION_TASK_IDLE_TRACK_.key + taskNo);
|
if (obj == null) {
|
return null;
|
}
|
try {
|
return JSON.parseObject(obj.toString(), StationTaskIdleTrack.class);
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
public void saveIdleTrack(StationTaskIdleTrack idleTrack) {
|
if (idleTrack == null || idleTrack.getTaskNo() == null || idleTrack.getTaskNo() <= 0 || redisUtil == null) {
|
return;
|
}
|
redisUtil.set(
|
RedisKeyType.STATION_TASK_IDLE_TRACK_.key + idleTrack.getTaskNo(),
|
JSON.toJSONString(idleTrack, SerializerFeature.DisableCircularReferenceDetect),
|
STATION_IDLE_TRACK_EXPIRE_SECONDS
|
);
|
}
|
|
public boolean hasRecentIssuedMoveCommand(Integer taskNo, Integer stationId, long thresholdMs) {
|
if (taskNo == null || taskNo <= 0 || stationId == null || thresholdMs <= 0L || basStationOptService == null) {
|
return false;
|
}
|
Date thresholdTime = new Date(System.currentTimeMillis() - thresholdMs);
|
List<BasStationOpt> optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
|
.select("id")
|
.eq("task_no", taskNo)
|
.eq("station_id", stationId)
|
.eq("mode", String.valueOf(StationCommandType.MOVE))
|
.eq("send", 1)
|
.ge("send_time", thresholdTime)
|
.orderByDesc("send_time")
|
.last("limit 1"));
|
return optList != null && !optList.isEmpty();
|
}
|
|
public int clearIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
|
Integer taskNo,
|
Integer stationId) {
|
if (basStationOptService == null) {
|
return 0;
|
}
|
List<BasStationOpt> optList;
|
try {
|
optList = listIssuedMoveCommandsDuringIdleStay(idleTrack, taskNo);
|
} catch (Exception e) {
|
return 0;
|
}
|
if (optList == null || optList.isEmpty()) {
|
return 0;
|
}
|
|
Date now = new Date();
|
String cleanupMemo = buildIdleRecoverClearedMemo(stationId);
|
int clearedCount = 0;
|
for (BasStationOpt opt : optList) {
|
if (opt == null || opt.getId() == null) {
|
continue;
|
}
|
opt.setSend(0);
|
opt.setUpdateTime(now);
|
opt.setMemo(appendCleanupMemo(opt.getMemo(), cleanupMemo));
|
clearedCount++;
|
}
|
if (clearedCount > 0) {
|
basStationOptService.updateBatchById(optList);
|
}
|
return clearedCount;
|
}
|
|
public boolean tryAcquireLock(String key, int seconds) {
|
if (redisUtil == null || isBlank(key)) {
|
return true;
|
}
|
Object lock = redisUtil.get(key);
|
if (lock != null) {
|
return false;
|
}
|
redisUtil.set(key, "lock", seconds);
|
return true;
|
}
|
|
public boolean tryAcquireOutOrderDispatchLock(Integer wrkNo, Integer stationId, int seconds) {
|
if (wrkNo == null || wrkNo <= 0 || stationId == null) {
|
return true;
|
}
|
return tryAcquireLock(RedisKeyType.STATION_OUT_ORDER_DISPATCH_LIMIT_.key + wrkNo + "_" + stationId, seconds);
|
}
|
|
public void signalSegmentReset(Integer taskNo, long waitMs) {
|
if (redisUtil == null || taskNo == null || taskNo <= 0) {
|
return;
|
}
|
String key = RedisKeyType.DEVICE_STATION_MOVE_RESET.key + taskNo;
|
redisUtil.set(key, "cancel", 3);
|
try {
|
if (waitMs > 0L) {
|
Thread.sleep(waitMs);
|
}
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
} catch (Exception ignore) {
|
}
|
redisUtil.del(key);
|
}
|
|
public StationCommand loadWatchCircleCommand(Integer wrkNo) {
|
if (wrkNo == null || wrkNo <= 0 || redisUtil == null) {
|
return null;
|
}
|
Object circleObj = redisUtil.get(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
|
if (circleObj == null) {
|
return null;
|
}
|
try {
|
return JSON.parseObject(circleObj.toString(), StationCommand.class);
|
} catch (Exception ignore) {
|
return null;
|
}
|
}
|
|
public void saveWatchCircleCommand(Integer wrkNo, StationCommand command) {
|
if (wrkNo == null || wrkNo <= 0 || command == null || redisUtil == null) {
|
return;
|
}
|
redisUtil.set(
|
RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo,
|
JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect),
|
60 * 60 * 24
|
);
|
}
|
|
public void clearWatchCircleCommand(Integer wrkNo) {
|
if (wrkNo == null || wrkNo <= 0 || redisUtil == null) {
|
return;
|
}
|
redisUtil.del(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
|
}
|
|
private List<BasStationOpt> listIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
|
Integer taskNo) {
|
if (idleTrack == null || taskNo == null || taskNo <= 0 || idleTrack.getFirstSeenTime() == null || basStationOptService == null) {
|
return Collections.emptyList();
|
}
|
List<BasStationOpt> optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
|
.select("id", "task_no", "send_time", "target_station_id", "memo", "send")
|
.eq("task_no", taskNo)
|
.eq("mode", String.valueOf(StationCommandType.MOVE))
|
.eq("send", 1)
|
.ge("send_time", new Date(idleTrack.getFirstSeenTime()))
|
.orderByAsc("send_time"));
|
if (optList == null || optList.isEmpty()) {
|
return Collections.emptyList();
|
}
|
return optList;
|
}
|
|
private String buildIdleRecoverClearedMemo(Integer stationId) {
|
if (stationId == null) {
|
return IDLE_RECOVER_CLEARED_MEMO;
|
}
|
return IDLE_RECOVER_CLEARED_MEMO + "(stationId=" + stationId + ")";
|
}
|
|
private String appendCleanupMemo(String memo, String cleanupMemo) {
|
if (Cools.isEmpty(cleanupMemo)) {
|
return memo;
|
}
|
if (Cools.isEmpty(memo)) {
|
return cleanupMemo;
|
}
|
if (memo.contains(cleanupMemo)) {
|
return memo;
|
}
|
return memo + " | " + cleanupMemo;
|
}
|
|
private boolean isBlank(String value) {
|
return value == null || value.trim().isEmpty();
|
}
|
}
|
