package com.zy.core.plugin.station;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.core.common.Cools;
|
import com.zy.asrs.domain.param.CreateInTaskParam;
|
import com.zy.asrs.domain.param.CreateOutTaskParam;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.service.*;
|
import com.zy.common.entity.FindCrnNoResult;
|
import com.zy.common.service.CommonService;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.News;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.dispatch.StationCommandDispatcher;
|
import com.zy.core.enums.*;
|
import com.zy.core.model.StationObjModel;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.plugin.store.StoreInTaskContext;
|
import com.zy.core.plugin.store.StoreInTaskGenerationService;
|
import com.zy.core.plugin.store.StoreInTaskPolicy;
|
import com.zy.core.task.MainProcessLane;
|
import com.zy.core.task.MainProcessTaskSubmitter;
|
import com.zy.core.thread.StationThread;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Random;
|
|
@Slf4j
|
@Component
|
public class FakeTaskGenerator implements StoreInTaskPolicy {
|
|
private static final long MAIN_DISPATCH_INTERVAL_MS = 200L;
|
|
private String fakeRealTaskRequestWms = "N";
|
private String fakeGenerateInTask = "Y";
|
private String fakeGenerateOutTask = "Y";
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private StationCommandDispatcher stationCommandDispatcher;
|
@Autowired
|
private MainProcessTaskSubmitter mainProcessTaskSubmitter;
|
@Autowired
|
private StoreInTaskGenerationService storeInTaskGenerationService;
|
|
public void setFakeRealTaskRequestWms(String fakeRealTaskRequestWms) {
|
this.fakeRealTaskRequestWms = fakeRealTaskRequestWms;
|
}
|
|
public void setFakeGenerateInTask(String fakeGenerateInTask) {
|
this.fakeGenerateInTask = fakeGenerateInTask;
|
}
|
|
public void setFakeGenerateOutTask(String fakeGenerateOutTask) {
|
this.fakeGenerateOutTask = fakeGenerateOutTask;
|
}
|
|
public void submitGenerateTasks() {
|
submitGenerateStoreTasks();
|
mainProcessTaskSubmitter.submitKeyedSerialTask(
|
MainProcessLane.FAKE_ASYNC, "generateFakeInTask", "generateFakeInTask",
|
MAIN_DISPATCH_INTERVAL_MS, this::generateFakeInTask);
|
mainProcessTaskSubmitter.submitKeyedSerialTask(
|
MainProcessLane.FAKE_ASYNC, "generateFakeOutTask", "generateFakeOutTask",
|
MAIN_DISPATCH_INTERVAL_MS, this::generateFakeOutTask);
|
}
|
|
private void submitGenerateStoreTasks() {
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
|
if (stationMap == null || stationMap.isEmpty()) {
|
continue;
|
}
|
|
List<StationObjModel> barcodeStations = getBarcodeStations(basDevp);
|
for (StationObjModel stationObjModel : barcodeStations) {
|
Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
|
if (stationId == null || !stationMap.containsKey(stationId)) {
|
continue;
|
}
|
if (!canRequestStoreIn(stationMap.get(stationId))) {
|
continue;
|
}
|
storeInTaskGenerationService.submitGenerateStoreTask(
|
this,
|
basDevp,
|
stationObjModel,
|
MainProcessLane.FAKE_GENERATE_STORE,
|
MAIN_DISPATCH_INTERVAL_MS,
|
() -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel)
|
);
|
}
|
}
|
}
|
|
// 生成仿真模拟入库任务
|
public void generateFakeInTask() {
|
if (fakeRealTaskRequestWms.equals("Y")) {
|
return;
|
}
|
|
if (!fakeGenerateInTask.equals("Y")) {
|
return;
|
}
|
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
|
|
List<StationObjModel> list = basDevp.getBarcodeStationList$();
|
for (StationObjModel model : list) {
|
Integer stationId = model.getStationId();
|
if (!stationMap.containsKey(stationId)) {
|
continue;
|
}
|
|
StationProtocol stationProtocol = stationMap.get(stationId);
|
if (stationProtocol == null) {
|
continue;
|
}
|
|
Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId);
|
if (object != null) {
|
continue;
|
}
|
|
// 满足自动、有物、有工作号，生成入库数据
|
if (stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() > 0) {
|
if (Cools.isEmpty(stationProtocol.getBarcode())) {
|
continue;
|
}
|
|
// 检测任务是否生成
|
List<WrkMast> wrkMasts = wrkMastService
|
.list(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
|
if (!wrkMasts.isEmpty()) {
|
continue;
|
}
|
|
List<LocMast> locMastList = locMastService
|
.list(new QueryWrapper<LocMast>().eq("loc_sts", String.valueOf(LocStsType.O)));
|
if (locMastList.isEmpty()) {
|
continue;
|
}
|
|
int nextInt = new Random().nextInt(locMastList.size());
|
LocMast locMast = locMastList.get(nextInt);
|
|
FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locMast.getLocNo());
|
if (findCrnNoResult == null) {
|
continue;
|
}
|
|
Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
|
if (targetStationId == null) {
|
continue;
|
}
|
|
CreateInTaskParam taskParam = new CreateInTaskParam();
|
taskParam.setTaskNo(String.valueOf(commonService.getWorkNo(WrkIoType.IN.id)));
|
taskParam.setSourceStaNo(stationId);
|
taskParam.setStaNo(targetStationId);
|
taskParam.setLocNo(locMast.getLocNo());
|
taskParam.setBarcode(stationProtocol.getBarcode());
|
WrkMast wrkMast = commonService.createInTask(taskParam);
|
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(),
|
stationId, stationId, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
continue;
|
}
|
stationCommandDispatcher.dispatch(basDevp.getDevpNo(), command, "fake-process", "fake-in-task");
|
redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId, "lock", 5);
|
}
|
}
|
}
|
}
|
|
// 生成仿真模拟出库任务
|
public void generateFakeOutTask() {
|
try {
|
if (fakeRealTaskRequestWms.equals("Y")) {
|
return;
|
}
|
|
if (!fakeGenerateOutTask.equals("Y")) {
|
return;
|
}
|
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
|
|
List<StationObjModel> list = basDevp.getOutStationList$();
|
for (StationObjModel entity : list) {
|
Integer stationId = entity.getStationId();
|
if (!stationMap.containsKey(stationId)) {
|
continue;
|
}
|
|
StationProtocol stationProtocol = stationMap.get(stationId);
|
if (stationProtocol == null) {
|
continue;
|
}
|
|
Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId);
|
if (object != null) {
|
return;
|
}
|
|
// 满足自动、无物、工作号0，生成出库数据
|
if (stationProtocol.isAutoing()
|
&& !stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() == 0) {
|
List<LocMast> locMastList = locMastService
|
.list(new QueryWrapper<LocMast>().eq("loc_sts", String.valueOf(LocStsType.F)));
|
if (locMastList.isEmpty()) {
|
continue;
|
}
|
|
LocMast locMast = locMastList.get(0);
|
|
CreateOutTaskParam taskParam = new CreateOutTaskParam();
|
taskParam.setTaskNo(String.valueOf(commonService.getWorkNo(WrkIoType.OUT.id)));
|
taskParam.setStaNo(stationId);
|
taskParam.setLocNo(locMast.getLocNo());
|
boolean result = commonService.createOutTask(taskParam);
|
redisUtil.set(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId, "lock", 10);
|
}
|
}
|
}
|
} catch (Exception e) {
|
log.error("generateFakeOutTask execute error", e);
|
}
|
}
|
|
private boolean canRequestStoreIn(StationProtocol stationProtocol) {
|
return stationProtocol != null
|
&& stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() > 0
|
&& !Cools.isEmpty(stationProtocol.getBarcode());
|
}
|
|
@Override
|
public boolean isEnabled() {
|
return !"N".equals(fakeRealTaskRequestWms);
|
}
|
|
@Override
|
public void onRequestPermitGranted(StoreInTaskContext context) {
|
redisUtil.set(getGenerateLockKey(context), "lock", 3);
|
}
|
|
@Override
|
public void afterTaskCreated(StoreInTaskContext context, WrkMast wrkMast) {
|
Integer stationId = context.getStationObjModel().getStationId();
|
StationCommand command = context.getStationThread().getCommand(StationCommandType.WRITE_INFO,
|
wrkMast.getWrkNo(), stationId, stationId, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
return;
|
}
|
stationCommandDispatcher.dispatch(context.getBasDevp().getDevpNo(), command, "fake-process", "write-info");
|
}
|
|
@Override
|
public String getGenerateLockKey(StoreInTaskContext context) {
|
return RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + context.getStationObjModel().getStationId();
|
}
|
}
|
