package com.vincent.rsf.server.api.utils;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.Arith;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.SpringUtils;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.controller.params.TaskInParam;
|
import com.vincent.rsf.server.api.entity.dto.InTaskMsgDto;
|
import com.vincent.rsf.server.api.entity.dto.LocTypeDto;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.LocStsType;
|
import com.vincent.rsf.server.manager.enums.TaskStsType;
|
import com.vincent.rsf.server.manager.enums.TaskType;
|
import com.vincent.rsf.server.manager.service.*;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.RegEx;
|
import javax.annotation.Resource;
|
import java.util.List;
|
|
@Component
|
public class LocUtils {
|
|
public static final Logger logger = LoggerFactory.getLogger(LocUtils.class);
|
|
private static List<Integer> doubleLocs;
|
|
private static Boolean isDoubleDeep;
|
|
@Autowired
|
private SlaveProperties slavePropertie;
|
|
@PostConstruct
|
public void init() {
|
doubleLocs = slavePropertie.getDoubleLocs();
|
isDoubleDeep = slavePropertie.isDoubleDeep();
|
}
|
|
|
/**
|
* 获取 浅库位对应的深库位号
|
*/
|
public static String getDeepLoc(String shallowLoc) {
|
LocService locService = SpringUtils.getBean(LocService.class);
|
Loc shaLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, shallowLoc));
|
int row = shaLoc.getRow()-1;
|
boolean contains = doubleLocs.contains(row);
|
Loc deepLoc = null;
|
if (contains) {
|
deepLoc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getAreaId, shaLoc.getAreaId())
|
.eq(Loc::getRow, row)
|
.eq(Loc::getCol, shaLoc.getCol())
|
.eq(Loc::getLev, shaLoc.getLev())
|
);
|
}else {
|
deepLoc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getAreaId, shaLoc.getAreaId())
|
.eq(Loc::getRow, shaLoc.getRow()+1)
|
.eq(Loc::getCol, shaLoc.getCol())
|
.eq(Loc::getLev, shaLoc.getLev())
|
);
|
}
|
return deepLoc.getCode();
|
}
|
|
/**
|
* 获取 深库位对应的浅库位号
|
*/
|
public static String getShallowLoc(String deepLoc) {
|
LocService locService = SpringUtils.getBean(LocService.class);
|
Loc depLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, deepLoc));
|
int row;
|
if (depLoc.getRow() != 1) {
|
row = depLoc.getRow()-1;
|
} else {
|
row = depLoc.getRow();
|
}
|
boolean contains = doubleLocs.contains(row);
|
Loc shallowLoc = null;
|
if (!contains) {
|
shallowLoc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getAreaId, depLoc.getAreaId())
|
.eq(Loc::getRow, row)
|
.eq(Loc::getCol, depLoc.getCol())
|
.eq(Loc::getLev, depLoc.getLev())
|
);
|
}else {
|
shallowLoc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getAreaId, depLoc.getAreaId())
|
.eq(Loc::getRow, depLoc.getRow()+1)
|
.eq(Loc::getCol, depLoc.getCol())
|
.eq(Loc::getLev, depLoc.getLev())
|
);
|
}
|
return shallowLoc.getCode();
|
}
|
|
/**
|
* 判断是否为浅库位
|
*/
|
public static boolean isShallowLoc(String locNo) {
|
if (isDoubleDeep) {
|
int row = getRow(locNo);
|
return !doubleLocs.contains(row);
|
} else {
|
return false;
|
}
|
}
|
|
//获取站点对应的库类型
|
public static Long getAreaType(Integer sourceStaNo) {
|
DeviceBindService rowLastnoService = SpringUtils.getBean(DeviceBindService.class);
|
List<DeviceBind> deviceBinds = rowLastnoService.list(new LambdaQueryWrapper<DeviceBind>());
|
for (DeviceBind deviceBind : deviceBinds) {
|
String[] staNoList = deviceBind.getStaList().split(";");
|
for (String staNo : staNoList) {
|
if (staNo.equals(sourceStaNo.toString())) {
|
return deviceBind.getId();
|
}
|
}
|
}
|
return 0L;
|
}
|
|
//库位排号分配
|
public static int[] LocNecessaryParameters(DeviceBind deviceBind, Integer curRow, Integer crnNumber) {
|
return LocNecessaryParametersDoubleExtension(curRow, crnNumber); //已完善
|
}
|
|
//经典双伸库位, 获取双深排
|
public static int[] LocNecessaryParametersDoubleExtension( Integer curRow, Integer crnNumber) {
|
int[] necessaryParameters = new int[]{0, 0, 0, 0};
|
|
necessaryParameters[0] = crnNumber; // 轮询次数
|
//满板正常入库
|
if (curRow.equals(crnNumber * 4)) {
|
necessaryParameters[1] = 1; //curRow 最深库位排
|
necessaryParameters[2] = 1; //crnNo 堆垛机号
|
necessaryParameters[3] = 2; //nearRow 最浅库位排
|
} else if (curRow.equals(crnNumber * 4 - 3)) {
|
necessaryParameters[1] = 4; //curRow 最深库位排
|
necessaryParameters[2] = 1; //crnNo 堆垛机号
|
necessaryParameters[3] = 3; //nearRow 最浅库位排
|
} else {
|
curRow = curRow + 4;
|
if (curRow < 1 || curRow > (crnNumber * 4)) {
|
throw new CoolException("库位排号异常：排号：" + curRow);
|
}
|
if ((curRow - 1) % 4 == 0) {
|
necessaryParameters[1] = curRow; //curRow 最深库位排
|
necessaryParameters[2] = (curRow + 3) / 4; //crnNo 堆垛机号
|
necessaryParameters[3] = curRow + 1; //nearRow 最浅库位排
|
} else if (curRow % 4 == 0) {
|
necessaryParameters[1] = curRow; //curRow 最深库位排
|
necessaryParameters[2] = curRow / 4; //crnNo 堆垛机号
|
necessaryParameters[3] = curRow - 1; //nearRow 最浅库位排
|
} else {
|
throw new CoolException("库位排号异常：排号：" + curRow);
|
}
|
}
|
|
return necessaryParameters;
|
}
|
|
/**
|
* 通过库位号获取 排
|
*/
|
public static int getRow(String locNo) {
|
if (!Cools.isEmpty(locNo)) {
|
LocService locService = SpringUtils.getBean(LocService.class);
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, locNo));
|
if (null == loc) {
|
throw new RuntimeException("库位解析异常");
|
}
|
return loc.getRow();
|
}
|
throw new RuntimeException("库位解析异常");
|
}
|
|
/**
|
* 通过库位号获取 列
|
*/
|
public static int getBay(String locNo) {
|
if (!Cools.isEmpty(locNo)) {
|
return Integer.parseInt(locNo.substring(2, 5));
|
}
|
throw new RuntimeException("库位解析异常");
|
}
|
|
/**
|
* 通过库位号获取 层
|
*/
|
public static int getLev(String locNo) {
|
if (!Cools.isEmpty(locNo)) {
|
return Integer.parseInt(locNo.substring(5, 7));
|
}
|
throw new RuntimeException("库位解析异常");
|
}
|
|
/**
|
* 类型检测
|
* 完全检测
|
**/
|
public static boolean locMoveCheckLocTypeComplete(Loc loc, LocTypeDto dto) {
|
// 如果源库位是高库位，目标库位是低库位
|
return dto.getLocType1().equals(Integer.parseInt(loc.getType()));
|
}
|
|
public static String getCrnLoc() {
|
// SlaveProperties bean = SpringUtils.getBean(SlaveProperties.class);
|
System.out.println(doubleLocs);
|
|
return null;
|
}
|
|
|
public static String zerofill(String msg, Integer count) {
|
if (msg.length() == count) {
|
return msg;
|
} else if (msg.length() > count) {
|
return msg.substring(0, 16);
|
} else {
|
StringBuilder msgBuilder = new StringBuilder(msg);
|
for (int i = 0; i < count - msg.length(); i++) {
|
msgBuilder.insert(0, "0");
|
}
|
return msgBuilder.toString();
|
}
|
}
|
|
/**
|
* 获取堆垛机库位信息
|
* @param deviceBind
|
* @param area
|
* @param sourceStaNo
|
* @param matnr
|
* @param batch
|
* @param locTypeDto
|
* @param times
|
* @param ioType 作业类型（*必传参数）
|
* @return
|
*/
|
public static InTaskMsgDto getLocNoCrn(DeviceBind deviceBind, Long area, Integer sourceStaNo, String matnr, String batch, LocTypeDto locTypeDto, int times, Integer ioType) {
|
DeviceBindService deviceBindService = SpringUtils.getBean(DeviceBindService.class);
|
DeviceSiteService deviceSiteService = SpringUtils.getBean(DeviceSiteService.class);
|
LocService locService = SpringUtils.getBean(LocService.class);
|
LocItemService locItemService = SpringUtils.getBean(LocItemService.class);
|
|
if (Cools.isEmpty(matnr)) { //物料号
|
matnr = "";
|
}
|
if (Cools.isEmpty(batch)) { //批次
|
batch = "";
|
}
|
// 初始化参数
|
int channel = 0; //堆垛机号
|
int nearRow = 0; //最浅库位排
|
int curRow = 0; //最深库位排
|
int rowCount = 0; //轮询轮次
|
Loc loc = null; // 目标库位
|
|
InTaskMsgDto inTaskMsgDto = new InTaskMsgDto();
|
|
int sRow = deviceBind.getStartRow();
|
int eRow = deviceBind.getEndRow();
|
int deviceQty = deviceBind.getDeviceQty();
|
|
|
// ===============>>>> 开始执行
|
curRow = deviceBind.getCurrentRow();
|
|
//此程序用于优化堆垛机异常时的运行时间
|
for (int i = times; i <= deviceQty * 2; i++) {
|
int[] locNecessaryParameters = LocUtils.LocNecessaryParameters(deviceBind, curRow, deviceQty);
|
curRow = locNecessaryParameters[1];
|
channel = locNecessaryParameters[2];
|
rowCount = locNecessaryParameters[0];
|
nearRow = locNecessaryParameters[3];
|
break;
|
}
|
if (nearRow == 0) {
|
throw new CoolException("无可用堆垛机");
|
}
|
//入库靠近摆放
|
if (ioType == 1 && deviceBind.getBeSimilar().equals("1") && !Cools.isEmpty(matnr)) {
|
if (nearRow != curRow) {
|
List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>().eq(LocItem::getMatnrCode, matnr));
|
for (LocItem locItem : locItems) {
|
Loc loc1 = locService.getById(locItem.getLocId());
|
if (LocUtils.isShallowLoc(loc1.getCode())) {
|
continue;
|
}
|
String shallowLocNo = LocUtils.getShallowLoc(loc1.getCode());
|
// 检测目标库位是否为空库位
|
Loc shallowLoc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, shallowLocNo));
|
if (shallowLoc != null && shallowLoc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
|
if (LocUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
|
loc = shallowLoc;
|
channel = shallowLoc.getChannel();
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
// // 靠近摆放规则 --- 空托 //互通版
|
// if (ioType == 10 && deviceBind.getEmptySimilar().equals("1")) {
|
// List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
|
// .eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow).eq("whs_type", rowLastnoType.getType().longValue()));
|
// if (!locMasts.isEmpty()) {
|
// for (LocMast loc : locMasts) {
|
// if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
|
// continue;
|
// }
|
// String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
|
// // 检测目标库位是否为空库位
|
// LocMast shallowLoc = locMastService.selectById(shallowLocNo);
|
// if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
|
// if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
|
// if (basCrnpService.checkSiteError(shallowLoc.getCrnNo(), true)) {
|
// locMast = shallowLoc;
|
// crnNo = locMast.getCrnNo();
|
// break;
|
// }
|
// }
|
// }
|
// }
|
// }
|
// }
|
//查找路径
|
DeviceSite deviceSite = deviceSiteService.getOne(new LambdaQueryWrapper<DeviceSite>()
|
.eq(DeviceSite::getType, ioType)
|
.eq(DeviceSite::getSite, sourceStaNo)
|
.eq(DeviceSite::getChannel, channel)
|
);
|
if (Cools.isEmpty(deviceSite)) {
|
channel = 0;
|
} else {
|
inTaskMsgDto.setStaNo(Integer.parseInt(deviceSite.getDeviceSite()));
|
}
|
|
//更新当前排
|
deviceBind.setCurrentRow(curRow);
|
deviceBindService.updateById(deviceBind);
|
|
// 开始查找库位 ==============================>>
|
|
// 1.按规则查找库位
|
if (Cools.isEmpty(loc) && channel != 0) {
|
List<Loc> locMasts = null;
|
locMasts = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getRow, nearRow)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getType, locTypeDto.getLocType1())
|
.eq(Loc::getAreaId, area)
|
.orderByAsc(Loc::getLev)
|
.orderByAsc(Loc::getCol)
|
);
|
for (Loc locMast1 : locMasts) {
|
if (!LocUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
|
continue;
|
}
|
String shallowLoc = LocUtils.getDeepLoc(locMast1.getCode());
|
if ((ioType == TaskStsType.GENERATE_IN.id && deviceBind.getBeSimilar().equals("1"))) {
|
//相似物料打开，判断深库位有没有货，没货就放深库位，有货就不操作
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
if (!Cools.isEmpty(locMast2)) {
|
loc = locMast2;
|
break;
|
}
|
} else {
|
//相似物料关闭，判断深库位有没有货，有货就放浅库位，无货就不操作
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.in(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type, LocStsType.LOC_STS_TYPE_F.type)
|
.eq(Loc::getAreaId, area)
|
);
|
if (!Cools.isEmpty(locMast2)) {
|
loc = locMast1;
|
break;
|
} else {
|
locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
if (!Cools.isEmpty(locMast2)) {
|
loc = locMast2;
|
break;
|
}
|
}
|
}
|
}
|
if (Cools.isEmpty(loc) && deviceBind.getBeSimilar().equals("1")) {
|
for (Loc locMast1 : locMasts) {
|
if (!LocUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
|
continue;
|
}
|
if (deviceBind.getBeSimilar().equals("1")) {
|
String shallowLoc = LocUtils.getDeepLoc(locMast1.getCode());
|
Loc locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getAreaId, area)
|
);
|
if (!Cools.isEmpty(locMast2)) {
|
loc = locMast2;
|
break;
|
} else {
|
locMast2 = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getCode, shallowLoc)
|
.in(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type, LocStsType.LOC_STS_TYPE_D.type)
|
.eq(Loc::getAreaId, area)
|
);
|
if (!Cools.isEmpty(locMast2)) {
|
loc = locMast1;
|
break;
|
}
|
}
|
} else {
|
if (!Cools.isEmpty(locMast1)) {
|
loc = locMast1;
|
break;
|
}
|
}
|
}
|
}
|
}
|
//查询当前库位类型空库位 小于5个则locmast = null
|
List<Loc> locTypeLocMasts = locService.list(new LambdaQueryWrapper<Loc>()
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
|
.eq(Loc::getChannel, channel)
|
.eq(Loc::getType, locTypeDto.getLocType1())
|
.eq(Loc::getAreaId, area)
|
);
|
if (null != locTypeLocMasts && locTypeLocMasts.size() <= 5) {
|
loc = null;
|
}
|
// 递归查询
|
if (Cools.isEmpty(loc) || !loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
|
// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
|
if (times < rowCount * 2) {
|
times = times + 1;
|
return getLocNoCrn(deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, times, ioType);
|
|
}
|
// 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
|
if (locTypeDto.getLocType1() < 3) {
|
int i = locTypeDto.getLocType1() + 1;
|
locTypeDto.setLocType1(i);
|
return getLocNoCrn(deviceBind, area, sourceStaNo, matnr, batch, locTypeDto, 0, ioType);
|
}
|
throw new CoolException("没有空库位");
|
}
|
String locNo = loc.getCode();
|
|
// 返回dto
|
inTaskMsgDto.setDeviceNo(channel);
|
inTaskMsgDto.setSourceStaNo(sourceStaNo);
|
// inTaskMsgDto.setStaNo();
|
inTaskMsgDto.setLocNo(locNo);
|
return inTaskMsgDto;
|
}
|
|
|
}
|
