package com.vincent.rsf.server.api.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.controller.erp.params.SyncOrderParams;
|
import com.vincent.rsf.server.api.controller.erp.params.SyncOrdersItem;
|
import com.vincent.rsf.server.api.service.AgvService;
|
import com.vincent.rsf.server.api.service.ReceiveMsgService;
|
import com.vincent.rsf.server.manager.controller.params.WaitPakinParam;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.entity.param.AgvBindAndInTParam;
|
import com.vincent.rsf.server.manager.enums.LocStsType;
|
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
|
import com.vincent.rsf.server.manager.enums.StationTypeEnum;
|
import com.vincent.rsf.server.manager.enums.TaskType;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.manager.service.impl.DeviceSiteServiceImpl;
|
import com.vincent.rsf.server.manager.service.impl.MatnrServiceImpl;
|
import com.vincent.rsf.server.manager.utils.LocManageUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.Instant;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class AgvServiceImpl implements AgvService {
|
|
private static final String AGV_MISC_ORDER_PREFIX = "AGVT";
|
private static final DateTimeFormatter BATCH_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
|
|
@Autowired
|
private ReceiveMsgService receiveMsgService;
|
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private BasStationService basStationService;
|
@Autowired
|
private WaitPakinItemService waitPakinItemService;
|
@Autowired
|
private WarehouseAreasService warehouseAreasService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private BasContainerService basContainerService;
|
@Autowired
|
private DeviceSiteServiceImpl deviceSiteService;
|
@Autowired
|
private MatnrServiceImpl matnrService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R AGVBindAndInTaskStart(WaitPakinParam waitPakinPda, Long loginUserId) {
|
//先绑定
|
try{
|
getAGVStaBind(waitPakinPda);
|
} catch (CoolException e) {
|
log.error(e.getMessage());
|
}
|
//生成任务
|
AGVInTaskStart(waitPakinPda, loginUserId);
|
return R.ok();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R AGVBindAndInTaskStart(String barcode) {
|
//验证条码
|
boolean b = checkStaStatus(barcode);
|
if (!b) {
|
return R.error("条码未找到对应规则");
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean AGVBindAndInTaskStart(String barcode, String sta) {
|
//验证条码
|
checkStaStatus(barcode,sta);
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R AGVBindAndInTaskStartT(AgvBindAndInTParam param, Long loginUserId) {
|
if (Objects.isNull(param)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
if (Cools.isEmpty(param.getMatNr())) {
|
throw new CoolException("物料编码不能为空！！");
|
}
|
if (Cools.isEmpty(param.getPalletBarcode())) {
|
throw new CoolException("托盘码不能为空！！");
|
}
|
if (Cools.isEmpty(param.getPalletSta())) {
|
throw new CoolException("操作站点不能为空！！");
|
}
|
|
checkPalletBarcodeAvailable(param.getPalletBarcode());
|
|
Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>()
|
.eq(Matnr::getCode, param.getMatNr())
|
.last("limit 1"));
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("物料编码不存在：" + param.getMatNr());
|
}
|
|
long nowMillis = System.currentTimeMillis();
|
long nowSeconds = nowMillis / 1000;
|
String orderNo = buildAgvMiscOrderNo(param.getPalletBarcode(), nowMillis);
|
SyncOrderParams syncOrder = new SyncOrderParams()
|
.setWkType(SyncOrderParams.BusinessType.STK_MISCELLANEOUS)
|
.setType("in")
|
.setOrderNo(orderNo)
|
.setOrderInternalCode(nowMillis)
|
.setCreateTime(nowSeconds)
|
.setBusinessTime(nowSeconds)
|
.setAnfme(1.0)
|
.setOrderItems(Collections.singletonList(buildOrderItem(param, matnr, nowMillis, nowSeconds).setBarcode(param.getPalletBarcode())));
|
syncOrder.setStationId(param.getPalletSta());
|
R r = receiveMsgService.syncCheckOrder(Collections.singletonList(syncOrder), loginUserId);
|
if (!Objects.isNull(r) && Objects.equals(String.valueOf(r.get("code")), "200")) {
|
autoCallAgvInTask(param, loginUserId);
|
}
|
return R.ok(Cools.add("orderNo", orderNo).add("palletBarcode", param.getPalletBarcode()));
|
}
|
|
private void autoCallAgvInTask(AgvBindAndInTParam param, Long loginUserId) {
|
CompletableFuture.runAsync(() -> {
|
int retry = 0;
|
while (retry < 5) {
|
retry++;
|
try {
|
Thread.sleep(3000);
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, param.getPalletBarcode())
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
.last("limit 1"));
|
if (Objects.isNull(waitPakin)) {
|
continue;
|
}
|
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, param.getPalletSta())
|
.last("limit 1"));
|
if (Objects.isNull(basStation)) {
|
return;
|
}
|
// if (Objects.isNull(basStation) || Objects.isNull(basStation.getArea())) {
|
// return;
|
// }
|
|
WaitPakinParam waitPakinPda = new WaitPakinParam()
|
.setBarcode(param.getPalletBarcode())
|
.setStaNo(param.getPalletSta())
|
.setArea(param.getArea());
|
AGVBindAndInTaskStart(waitPakinPda, loginUserId);
|
return;
|
} catch (Exception ignored) {
|
}
|
}
|
});
|
}
|
|
private SyncOrdersItem buildOrderItem(AgvBindAndInTParam param, Matnr matnr, long uniqueSeed, long nowSeconds) {
|
String suffix = String.valueOf(uniqueSeed);
|
String batch = LocalDateTime.ofInstant(Instant.ofEpochSecond(nowSeconds), ZoneId.systemDefault())
|
.format(BATCH_FORMATTER);
|
SyncOrdersItem syncOrdersItem = new SyncOrdersItem()
|
.setModel(matnr.getModel())
|
.setAnfme(1.0)
|
.setUnit(matnr.getUnit())
|
.setBaseUnitId(matnr.getUnit())
|
.setPriceUnitId(matnr.getUnit())
|
.setBatch(batch)
|
.setPlanNo(AGV_MISC_ORDER_PREFIX + "-PLAN-" + suffix)
|
.setLineId(AGV_MISC_ORDER_PREFIX + "-LINE-" + suffix)
|
.setPlatItemId("1")
|
.setPalletId(param.getPalletBarcode());
|
syncOrdersItem.setMatnr(matnr.getCode());
|
syncOrdersItem.setMaktx(matnr.getName());
|
syncOrdersItem.setSpec(matnr.getSpec());
|
return syncOrdersItem;
|
}
|
|
private String buildAgvMiscOrderNo(String palletBarcode, long uniqueSeed) {
|
String cleanBarcode = palletBarcode.replaceAll("[^A-Za-z0-9]", "");
|
if (cleanBarcode.length() > 24) {
|
cleanBarcode = cleanBarcode.substring(cleanBarcode.length() - 24);
|
}
|
return AGV_MISC_ORDER_PREFIX + cleanBarcode + uniqueSeed;
|
}
|
|
private void checkPalletBarcodeAvailable(String palletBarcode) {
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, palletBarcode)
|
.last("limit 1"));
|
if (!Objects.isNull(waitPakin)) {
|
throw new CoolException("托盘码：" + palletBarcode + "已被组托单：" + waitPakin.getCode() + "使用！！");
|
}
|
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getBarcode, palletBarcode)
|
.last("limit 1"));
|
if (!Objects.isNull(basStation)) {
|
throw new CoolException("托盘码：" + palletBarcode + "已被站点：" + basStation.getStationName() + "绑定！！");
|
}
|
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getBarcode, palletBarcode)
|
.last("limit 1"));
|
if (!Objects.isNull(loc)) {
|
throw new CoolException("托盘码：" + palletBarcode + "已被库位：" + loc.getCode() + "使用！！");
|
}
|
}
|
|
@Override
|
public R getStaMsgSelect(Map<String, Object> params) {
|
String sta = params.get("sta").toString();
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("接驳位条码不能为空");
|
}
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
.eq(BasStation::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到接驳站点信息，请检查站点状态");
|
}
|
List<Long> ids = basStation.getCrossZoneArea().stream()
|
.map(Integer::longValue)
|
.collect(Collectors.toList());
|
// ids.add(basStation.getArea());
|
// if (basStation.getIsCrossZone() == 1) {
|
// String content = basStation.getCrossZoneArea().substring(1,.length() - 1);
|
// String[] parts = content.split(",");
|
// for (int i = 0; i < parts.length; i++) {
|
// ids.add(Long.parseLong(parts[i].trim()));
|
// }
|
// }
|
List<WarehouseAreas> warehouseAreasList = warehouseAreasService.list(new LambdaQueryWrapper<WarehouseAreas>()
|
.in(WarehouseAreas::getId, ids)
|
);
|
|
return R.ok(Cools
|
.add("barcode", basStation.getBarcode())
|
.add("warehouseAreasList", warehouseAreasList)
|
.add("area", basStation.getArea())
|
);
|
}
|
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R AGVInTaskStart(WaitPakinParam waitPakinPda, Long loginUserId) {
|
String sta = waitPakinPda.getStaNo();
|
String area = waitPakinPda.getArea();
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("起点不能为空");
|
}
|
if (Cools.isEmpty(area)) {
|
throw new CoolException("目标库区不能为空");
|
}
|
|
DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getSite, sta)
|
.eq(DeviceSite::getAreaIdEnd, Long.parseLong(area))
|
.eq(DeviceSite::getType, TaskType.TASK_TYPE_IN.type).last("limit 1"));
|
if (Cools.isEmpty(deviceSite)) {
|
throw new CoolException("无可用路径！！");
|
}
|
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
.eq(BasStation::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到起点站点信息，请检查站点状态");
|
}
|
if (Cools.isEmpty(basStation.getBarcode())) {
|
throw new CoolException("数据错误，接驳站无条码信息");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, basStation.getBarcode())
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("未找到组托数据,请检查状态");
|
}
|
String targetLoc = LocManageUtil.getTargetLoc(Long.parseLong(area));
|
|
taskService.generateAGVTasks(waitPakin, targetLoc, sta, deviceSite.getDeviceCode(),loginUserId);
|
if (!basStation.getType().equals(0)){
|
basStation.setUseStatus(LocStsType.LOC_STS_TYPE_R.type);
|
}
|
if (!basStationService.updateById(basStation)) {
|
throw new CoolException("更新站点状态失败");
|
}
|
|
return R.ok();
|
}
|
|
|
@Override
|
public R AGVStaUnBind(Map<String, Object> params) {
|
String sta = params.get("sta").toString();
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("接驳位条码不能为空");
|
}
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
.eq(BasStation::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到接驳站点信息，请检查站点状态");
|
}
|
if (Cools.isEmpty(basStation.getBarcode())) {
|
throw new CoolException("数据错误，接驳站无条码信息");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, basStation.getBarcode())
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("未找到组托数据,请检查状态");
|
}
|
basStation.setBarcode(null);
|
basStation.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
|
if (!basStationService.updateById(basStation)) {
|
throw new CoolException("更新站点状态失败");
|
}
|
return R.ok("解绑成功");
|
}
|
|
|
@Override
|
public R getStaBindList(Map<String, Object> params) {
|
String sta = params.get("sta").toString();
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("接驳位条码不能为空");
|
}
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
.eq(BasStation::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到接驳站点信息，请检查站点状态");
|
}
|
if (Cools.isEmpty(basStation.getBarcode())) {
|
throw new CoolException("数据错误，接驳站无条码信息");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, basStation.getBarcode())
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("未找到组托数据,请检查状态");
|
}
|
List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
if (Cools.isEmpty(waitPakinItems)) {
|
throw new CoolException("数据错误，未找到组托明细");
|
}
|
List<Long> ids = basStation.getCrossZoneArea().stream()
|
.map(Integer::longValue)
|
.collect(Collectors.toList());
|
// ids.add(basStation.getArea());
|
// if (basStation.getIsCrossZone() == 1) {
|
// String content = basStation.getCrossZoneArea().substring(1, basStation.getCrossZoneArea().length() - 1);
|
// String[] parts = content.split(",");
|
// for (int i = 0; i < parts.length; i++) {
|
// ids.add(Long.parseLong(parts[i].trim()));
|
// }
|
// }
|
List<WarehouseAreas> warehouseAreasList = warehouseAreasService.list(new LambdaQueryWrapper<WarehouseAreas>()
|
.in(WarehouseAreas::getId, ids)
|
);
|
|
return R.ok(Cools
|
.add("barcode", basStation.getBarcode())
|
.add("list", waitPakinItems)
|
.add("warehouseAreasList", warehouseAreasList)
|
.add("area", basStation.getArea())
|
);
|
}
|
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R getAGVStaBind(WaitPakinParam waitPakinPda) {
|
String barcode = waitPakinPda.getBarcode();
|
String sta = waitPakinPda.getStaNo();
|
//验证基础信息
|
BasStation basStation = checkStaStatus(barcode, sta,waitPakinPda.getArea());
|
//更新站点状态
|
if (!basStation.getType().equals(0)){
|
basStation.setUseStatus(LocStsType.LOC_STS_TYPE_F.type);
|
}
|
basStation.setBarcode(barcode);
|
if (!basStationService.updateById(basStation)) {
|
throw new CoolException("更新站点状态失败");
|
}
|
return R.ok("绑定成功");
|
}
|
|
|
private BasStation checkStaStatus(String barcode, String sta) {
|
if (Cools.isEmpty(barcode)) {
|
throw new CoolException("容器码不能为空");
|
}
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("站点信息不能为空");
|
}
|
|
BasStation isBarcodeSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getBarcode, barcode)
|
.last("limit 1")
|
);
|
if (!Cools.isEmpty(isBarcodeSta)) {
|
throw new CoolException("该条码已被" + isBarcodeSta.getStationName() + "站绑定");
|
}
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到站点信息");
|
}
|
if (!Cools.isEmpty(basStation.getContainerType())) {
|
List<Long> longs1 = basStation.getContainerType().stream()
|
.map(Integer::longValue)
|
.collect(Collectors.toList());
|
List<BasContainer> containers = basContainerService.list(
|
new LambdaQueryWrapper<BasContainer>()
|
.in(BasContainer::getContainerType, longs1)
|
);
|
boolean matches = false;
|
for (BasContainer container : containers) {
|
String codeType = container.getCodeType(); // 获取正则表达式
|
if (barcode.matches(codeType)) { // 判断条码是否符合这个正则
|
matches = true;
|
break; // 找到匹配的就退出循环
|
}
|
}
|
if (!matches) {
|
throw new CoolException("条码与站点不匹配");
|
}
|
} else {
|
throw new CoolException("数据异常：验证基础信息");
|
}
|
|
return basStation;
|
}
|
private BasStation checkStaStatus(String barcode, String sta,String area) {
|
if (Cools.isEmpty(barcode)) {
|
throw new CoolException("容器码不能为空");
|
}
|
if (Cools.isEmpty(sta)) {
|
throw new CoolException("接驳位条码不能为空");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, barcode)
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("容器码未找到组托信息,请检查组托状态");
|
}
|
BasStation isBarcodeSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getBarcode, barcode)
|
, false
|
);
|
if (!Cools.isEmpty(isBarcodeSta)) {
|
throw new CoolException("该条码已被" + isBarcodeSta.getStationName() + "站绑定");
|
}
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sta)
|
);
|
if (Cools.isEmpty(basStation)) {
|
throw new CoolException("未找到站点信息");
|
}
|
if (!basStation.getUseStatus().equals("O")) {
|
throw new CoolException("站点状态不为空闲");
|
}
|
if (basStation.getType().equals(StationTypeEnum.STATION_TYPE_MUTI.type)) {
|
throw new CoolException("站点为光电站点，禁止呼叫AGV");
|
}
|
|
if (!basStation.getCrossZoneArea().contains(Integer.parseInt(area))) {
|
throw new CoolException("当前站点不支持目标库区");
|
}
|
if (!Cools.isEmpty(basStation.getContainerType())) {
|
List<Long> longs1 = basStation.getContainerType().stream()
|
.map(Integer::longValue)
|
.collect(Collectors.toList());
|
List<BasContainer> containers = basContainerService.list(
|
new LambdaQueryWrapper<BasContainer>()
|
.in(BasContainer::getContainerType, longs1)
|
);
|
boolean matches = false;
|
boolean matches2 = true;
|
for (BasContainer container : containers) {
|
String codeType = container.getCodeType(); // 获取正则表达式
|
if (barcode.matches(codeType)) { // 判断条码是否符合这个正则
|
List<Integer> areaList2 = container.getAreasIds();
|
if (!areaList2.contains(Integer.valueOf(area))) {
|
matches2 = false;
|
continue;
|
}
|
matches = true;
|
break; // 找到匹配的就退出循环
|
}
|
}
|
// boolean matches = containers.stream()
|
// .map(BasContainer::getCodeType)
|
// .anyMatch(codeType -> barcode.matches(codeType));
|
if (!matches2) {
|
throw new CoolException("查询到的容器不支持目标库区");
|
}
|
if (!matches) {
|
throw new CoolException("容器与站点不匹配");
|
}
|
} else {
|
throw new CoolException("数据异常：验证基础信息");
|
}
|
|
return basStation;
|
}
|
private boolean checkStaStatus(String barcode) {
|
if (Cools.isEmpty(barcode)) {
|
throw new CoolException("容器码不能为空");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, barcode)
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("容器码未找到组托信息,请检查组托状态");
|
}
|
BasStation isBarcodeSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getBarcode, barcode)
|
, false
|
);
|
if (!Cools.isEmpty(isBarcodeSta)) {
|
throw new CoolException("该条码已被" + isBarcodeSta.getStationName() + "站绑定");
|
}
|
|
List<BasContainer> containers = basContainerService.list(
|
new LambdaQueryWrapper<BasContainer>());
|
boolean matches = false;
|
for (BasContainer container : containers) {
|
String codeType = container.getCodeType(); // 获取正则表达式
|
if (barcode.matches(codeType)) { // 判断条码是否符合这个正则
|
matches = true;
|
return true;
|
}
|
}
|
// boolean matches = containers.stream()
|
// .map(BasContainer::getCodeType)
|
// .anyMatch(codeType -> barcode.matches(codeType));
|
if (!matches) {
|
return false;
|
}
|
|
return true;
|
}
|
}
|
