package com.zy.asrs.service.impl;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.core.common.BaseRes;
|
import com.core.common.Cools;
|
import com.core.common.DateUtils;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.entity.param.EmptyPlateOutParam;
|
import com.zy.asrs.entity.param.FullStoreParam;
|
import com.zy.asrs.entity.param.LocDetlAdjustParam;
|
import com.zy.asrs.entity.param.StockOutParam;
|
import com.zy.asrs.service.*;
|
import com.zy.asrs.utils.Utils;
|
import com.zy.asrs.utils.VersionUtils;
|
import com.zy.common.model.LocDetlDto;
|
import com.zy.common.model.LocTypeDto;
|
import com.zy.common.model.OutLocDto;
|
import com.zy.common.model.StartupDto;
|
import com.zy.common.properties.SlaveProperties;
|
import com.zy.common.service.CommonService;
|
import com.zy.ints.entity.WaitMatchk;
|
import com.zy.ints.service.IoCompleteService;
|
import com.zy.ints.service.WaitMatchkLogService;
|
import com.zy.ints.service.WaitMatchkService;
|
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.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
/**
|
* Created by vincent on 2020/6/11
|
*/
|
@Slf4j
|
@Service
|
public class WorkServiceImpl implements WorkService {
|
static int i =1;
|
|
// 工作号生成规则默认类型
|
private static final int DEFAULT_WORK_NO_TYPE = 0;
|
// 库位排号分配默认类别
|
private static final int DEFAULT_ROW_NO_TYPE = 1;
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private WrkDetlService wrkDetlService;
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private StaDescService staDescService;
|
@Autowired
|
private LocDetlService locDetlService;
|
@Autowired
|
private MatCodeService matCodeService;
|
@Autowired
|
private AdjDetlService adjDetlService;
|
@Autowired
|
private WrkMastLogService wrkMastLogService;
|
@Autowired
|
private WrkDetlLogService wrkDetlLogService;
|
@Autowired
|
private WaitMatchkService waitMatchkService;
|
@Autowired
|
private WaitMatchkLogService waitMatchkLogService;
|
@Autowired
|
private IoCompleteService ioCompleteService;
|
@Autowired
|
private SlaveProperties slaveProperties;
|
|
@Override
|
@Transactional
|
//入库
|
public String startupFullPutStore(FullStoreParam param, Long userId) {
|
// 参数非空判断
|
if (Cools.isEmpty(param.getDevpNo(), param.getList())) {
|
throw new CoolException(BaseRes.PARAM);
|
}
|
// 源站点状态检测
|
BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getDevpNo(), true);
|
// 生成工作号
|
int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
|
// 检索库位
|
List<String> matNos = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatNo).distinct().collect(Collectors.toList());
|
LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
|
locTypeDto.setLocType1((short) 1);
|
StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(),false, matNos,locTypeDto, 0);
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
|
wrkMast.setIoType(1); // 入出库状态：1.入库
|
wrkMast.setIoPri(13D); // 优先级：10
|
wrkMast.setCrnNo(dto.getCrnNo());
|
wrkMast.setSourceStaNo(dto.getSourceStaNo());
|
wrkMast.setStaNo(dto.getStaNo());
|
wrkMast.setLocNo(dto.getLocNo());
|
wrkMast.setBarcode(param.getBarcode()); // 托盘码
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("N");
|
wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 生成工作档明细
|
List<MatCodeCountDto> matDtos = new ArrayList<>();
|
param.getList().forEach(elem -> {
|
matDtos.add(new MatCodeCountDto(elem.getMatNo(), elem.getSupplier(), elem.getCount(),elem.getMemo(),elem.getSource(),elem.getVendor()));
|
});
|
wrkDetlService.createWorkDetail(workNo, matDtos, param.getBarcode(), userId);
|
// 更新源站点信息
|
sourceStaNo.setWrkNo(workNo);
|
sourceStaNo.setModiUser(userId);
|
sourceStaNo.setModiTime(new Date());
|
if (!basDevpService.updateById(sourceStaNo)){
|
throw new CoolException("更新源站失败");
|
}
|
// 更新目标库位状态
|
LocMast locMast = locMastService.selectById(dto.getLocNo());
|
if (locMast.getLocSts().equals("O")){
|
locMast.setLocSts("S"); // S.入库预约
|
locMast.setModiUser(userId);
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)){
|
throw new CoolException("改变库位状态失败");
|
}
|
} else {
|
throw new CoolException(dto.getLocNo()+"目标库位已被占用");
|
}
|
return dto.getLocNo();
|
}
|
|
@Override
|
@Transactional
|
public void startupFullTakeStore(StockOutParam param, Long userId) {
|
// 目标站点状态检测
|
BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
|
// 获取库位明细
|
List<LocDetlDto> locDetlDtos = new ArrayList<>();
|
for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
|
if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatNo(), paramLocDetl.getCount())) {
|
LocDetl sqlParam = new LocDetl();
|
sqlParam.setLocNo(paramLocDetl.getLocNo());
|
sqlParam.setMatNo(paramLocDetl.getMatNo());
|
LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
|
if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
|
}
|
}
|
if (!locDetlDtos.isEmpty()) {
|
// 启动出库开始 101.103出库
|
stockOut(staNo, locDetlDtos, null, userId);
|
} else {
|
throw new CoolException("库位产品不存在");
|
}
|
}
|
|
@Override
|
@Transactional
|
//出库作业
|
public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, Integer ioType, Long userId) {
|
|
// 合并同类项
|
Set<String> locNos = new HashSet<>();
|
locDetlDtos.forEach(dto -> locNos.add(dto.getLocDetl().getLocNo()));
|
List<OutLocDto> dtos = new ArrayList<>();
|
for (String locNo : locNos) {
|
List<LocDetlDto> list = new ArrayList<>();
|
Iterator<LocDetlDto> iterator = locDetlDtos.iterator();
|
while (iterator.hasNext()) {
|
LocDetlDto dto = iterator.next();
|
if (locNo.equals(dto.getLocDetl().getLocNo())) {
|
list.add(dto);
|
// iterator.remove();
|
}
|
}
|
dtos.add(new OutLocDto(locNo, list));
|
}
|
|
// 生成工作档
|
for (OutLocDto dto : dtos) {
|
|
// 判断入出库类型：101.全板出库 or 103.拣料出库
|
if (ioType == null) {
|
ioType = dto.isAll() ? 101 : 103;
|
}
|
// 获取库位
|
LocMast locMast = locMastService.selectById(dto.getLocNo());
|
// 获取路径
|
Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
|
.eq("type_no", ioType)
|
.eq("stn_no", staNo.getDevNo())
|
.eq("crn_no", locMast.getCrnNo());
|
StaDesc staDesc = staDescService.selectOne(wrapper);
|
if (Cools.isEmpty(staDesc)) {
|
throw new CoolException("出库路径不存在");
|
}
|
// 生成工作号
|
int rok;
|
if(ioType==103||ioType==107){
|
rok=2;
|
}else{
|
rok=1;
|
}
|
int workNo = commonService.getWorkNo(rok);
|
|
boolean reduce = false;
|
if(locMast.getCrnNo().equals(1) && dto.getLocNo().substring(0,2).equals("01")) {//1号货架才判断
|
// 当深库位出库时，查找对应的浅库位是否也有出库任务,如果有，就增加其优先级
|
if (Utils.isDeepLoc(slaveProperties, dto.getLocNo())) {
|
String shallowLoc = Utils.getShallowLoc(slaveProperties, dto.getLocNo());
|
if (locNos.contains(shallowLoc)) {
|
reduce = true;
|
}
|
}
|
|
// 深库位移库
|
if (!reduce) {
|
moveLocForDeepLoc(locMast.getCrnNo(), dto.getLocNo());
|
}
|
}
|
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
|
wrkMast.setIoType(ioType); // 入出库状态
|
wrkMast.setIoPri(reduce?13D:15D); // 优先级：13
|
wrkMast.setCrnNo(locMast.getCrnNo());
|
wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
|
wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
|
wrkMast.setSourceLocNo(dto.getLocNo()); // 源库位
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("N");
|
wrkMast.setAppeUser(userId); // 操作人员数据
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
if (!wrkMastService.insert(wrkMast)) {
|
throw new CoolException("保存工作档失败，出库库位号："+dto.getLocNo());
|
}
|
// 生成工作档明细
|
for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
|
MatCode matCode = matCodeService.selectById(detlDto.getLocDetl().getMatNo());
|
// 出库时，数量为0的直接忽略
|
if (detlDto.getCount()==null || detlDto.getCount() <= 0.0D) {continue;}
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.setWrkNo(workNo);
|
wrkDetl.setIoTime(new Date());
|
Double qty = ioType==101?detlDto.getLocDetl().getQty():detlDto.getCount();
|
wrkDetl.setQty(qty); // 数量
|
VersionUtils.setWrkDetl(wrkDetl, detlDto.getLocDetl()); // 版本控制
|
wrkDetl.setAppeTime(new Date());
|
wrkDetl.setAppeUser(userId);
|
wrkDetl.setModiTime(new Date());
|
wrkDetl.setModiUser(userId);
|
wrkDetl.setMemo(detlDto.getLocDetl().getMemo());
|
wrkDetl.setQtyBox(matCode.getStr6());
|
wrkDetl.setWeight(matCode.getWeight());
|
wrkDetl.setAllWeight(qty*matCode.getWeight()+30);
|
wrkDetl.setAllQty(qty*matCode.getStr6());
|
wrkDetl.setVendor(detlDto.getLocDetl().getVendor());
|
wrkDetl.setSource(detlDto.getLocDetl().getSource());
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
}
|
// 修改库位状态: F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
|
locMast = locMastService.selectById(dto.getLocNo());
|
if (locMast.getLocSts().equals("F")) {
|
locMast.setLocSts(ioType==101?"R":"P");
|
locMast.setModiUser(userId);
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("预约库位状态失败，库位号："+dto.getLocNo());
|
}
|
} else {
|
throw new CoolException(dto.getLocNo() + "库位不是在库状态");
|
}
|
|
if(ioType == 107) {
|
//获取当前时间戳
|
SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
|
String temp = sf.format(new Date());
|
//获取3位随机数
|
Random rand = new Random();
|
Integer r = rand.nextInt(900) + 100;
|
String billNo = temp + r;
|
//生成盘点通知档
|
for (LocDetlDto locDetlDto : locDetlDtos) {
|
// String replace = UUID.randomUUID().toString().replace("-", "");
|
LocDetl locDetl = locDetlDto.getLocDetl();
|
|
//////插入盘点档前，将通知档之前相同库位数据转历史档
|
List<WaitMatchk> waitMatchks = waitMatchkService.selectList(new EntityWrapper<WaitMatchk>().eq("loc_no",locDetl.getLocNo()));
|
for(WaitMatchk one : waitMatchks){
|
waitMatchkLogService.save(one.getBillNo(),one.getLocNo(),one.getMatNo());
|
waitMatchkService.delete(new EntityWrapper<WaitMatchk>().eq("bill_no",one.getBillNo()).eq("loc_no",one.getLocNo()).eq("mat_no",one.getMatNo()));
|
}
|
|
//生成盘点档
|
WaitMatchk waitMatchk = new WaitMatchk();
|
waitMatchk.setBillNo(billNo);//订单编号
|
waitMatchk.setLocNo(locDetl.getLocNo());//库位号
|
waitMatchk.setStockQty(locDetl.getQty());
|
waitMatchk.setMatNo(locDetl.getMatNo());//产品编号
|
waitMatchk.setMatName(locDetl.getMatName());//铲平名称
|
waitMatchk.setSeqNo(i);
|
// waitMatchk.setIoTime(new Date());
|
waitMatchk.setZpallet(locDetl.getZpallet());
|
waitMatchk.setAppeUser(userId); // 操作人员数据
|
waitMatchk.setAppeTime(new Date());
|
waitMatchk.setModiUser(userId);
|
waitMatchk.setModiTime(new Date());
|
if (!waitMatchkService.insert(waitMatchk)) {
|
throw new CoolException("保存盘点档失败");
|
}
|
i++;
|
}
|
}
|
|
}
|
}
|
|
@Override
|
@Transactional
|
//空板入库
|
public String emptyPlateIn(Integer devpNo, Long userId) {
|
// 源站点状态检测
|
BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
|
// 生成工作号
|
int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
|
// 检索库位
|
LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
|
locTypeDto.setLocType1((short) 1);
|
StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, true,null,locTypeDto, 0);
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
|
wrkMast.setIoType(10); // 入出库状态：10.空板入库
|
wrkMast.setIoPri(10D); // 优先级：10
|
wrkMast.setCrnNo(dto.getCrnNo());
|
wrkMast.setSourceStaNo(dto.getSourceStaNo());
|
wrkMast.setStaNo(dto.getStaNo());
|
wrkMast.setLocNo(dto.getLocNo());
|
wrkMast.setFullPlt("N"); // 满板
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("Y"); // 空板
|
wrkMast.setLinkMis("N");
|
wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 更新源站点信息
|
sourceStaNo.setWrkNo(workNo);
|
sourceStaNo.setModiUser(userId);
|
sourceStaNo.setModiTime(new Date());
|
if (!basDevpService.updateById(sourceStaNo)){
|
throw new CoolException("更新源站失败");
|
}
|
// 更新目标库位状态
|
LocMast locMast = locMastService.selectById(dto.getLocNo());
|
if (locMast.getLocSts().equals("O")){
|
locMast.setLocSts("S"); // S.入库预约
|
locMast.setModiUser(userId);
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)){
|
throw new CoolException("改变库位状态失败");
|
}
|
} else {
|
throw new CoolException(dto.getLocNo()+"目标库位已被占用");
|
}
|
return dto.getLocNo();
|
}
|
|
@Override
|
@Transactional
|
//空板出库
|
public void emptyPlateOut(EmptyPlateOutParam param, Long userId) {
|
if (Cools.isEmpty(param.getOutSite())) {
|
throw new CoolException("站点不存在");
|
}
|
for (String locNo : param.getLocNos()) {
|
// 获取工作号
|
int workNo = commonService.getWorkNo(1);
|
|
// 获取库位
|
LocMast locMast = locMastService.selectById(locNo);
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException(locNo+"库位不存在");
|
}
|
|
boolean reduce = false;
|
if(locMast.getCrnNo().equals(1) && locNo.substring(0,2).equals("01")) {//1号货架才判断
|
// 当深库位出库时，查找对应的浅库位是否也有出库任务,如果有，就增加其优先级
|
if (Utils.isDeepLoc(slaveProperties, locNo)) {
|
String shallowLoc = Utils.getShallowLoc(slaveProperties, locNo);
|
if (param.getLocNos().contains(shallowLoc)) {
|
reduce = true;
|
}
|
}
|
|
// 深库位移库
|
if (!reduce) {
|
moveLocForDeepLoc(locMast.getCrnNo(), locNo);
|
}
|
}
|
|
// 获取源站
|
Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
|
.eq("type_no", 110)
|
.eq("stn_no", param.getOutSite())
|
.eq("crn_no", locMast.getCrnNo());
|
StaDesc staDesc = staDescService.selectOne(wrapper);
|
Integer sourceStaNo = staDesc.getCrnStn();
|
if (Cools.isEmpty(sourceStaNo)) {
|
throw new CoolException("检索源站失败");
|
}
|
// 保存工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
|
wrkMast.setIoType(110); // 入出库状态： 110.空板出库
|
wrkMast.setIoPri(reduce?13D:15D);
|
wrkMast.setSourceStaNo(sourceStaNo); // 源站
|
wrkMast.setStaNo(param.getOutSite()); // 目标站
|
wrkMast.setCrnNo(locMast.getCrnNo());
|
wrkMast.setSourceLocNo(locNo); // 源库位
|
wrkMast.setFullPlt("N"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("Y"); // 空板
|
wrkMast.setLinkMis("N");
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 更新库位状态 D.空板 -> R.出库预约
|
if (locMast.getLocSts().equals("D")){
|
locMast.setLocSts("R");
|
locMast.setModiUser(userId);
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("更新库位状态失败");
|
}
|
}
|
// todo 更新站点信息（工作号）
|
}
|
}
|
|
@Override
|
@Transactional
|
//盘点出库
|
public void locCheckOut(StockOutParam param, Long userId) {
|
// 目标站点状态检测
|
BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
|
// 获取库位明细
|
List<LocDetlDto> locDetlDtos = new ArrayList<>();
|
for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
|
if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatNo())) {
|
LocDetl sqlParam = new LocDetl();
|
sqlParam.setLocNo(paramLocDetl.getLocNo());
|
sqlParam.setMatNo(paramLocDetl.getMatNo());
|
LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
|
if (null != one) locDetlDtos.add(new LocDetlDto(one, one.getQty()));
|
}
|
}
|
if (!locDetlDtos.isEmpty()) {
|
// 启动出库开始 107.盘点出库
|
stockOut(staNo, locDetlDtos, 107, userId);
|
} else {
|
throw new CoolException("库位产品不存在");
|
}
|
}
|
|
@Override
|
@Transactional
|
//移库
|
public void locMove(String sourceLocNo, String locNo, Long userId) {
|
LocMast sourceLoc = locMastService.selectById(sourceLocNo);
|
if (Cools.isEmpty(sourceLoc)){
|
throw new CoolException("未找到库位");
|
}
|
LocMast loc = locMastService.selectById(locNo);
|
if (Cools.isEmpty(loc)){
|
throw new CoolException("未找到库位");
|
}
|
if (!sourceLoc.getCrnNo().equals(loc.getCrnNo())) {
|
throw new CoolException("移转库位属于不同堆垛机");
|
}
|
// 获取工作号
|
int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
|
|
if(loc.getCrnNo().equals(1) && sourceLocNo.substring(0,2).equals("01")) {//1号货架才判断
|
// 当深库位出库时，查找对应的浅库位是否也有出库任务,如果有，就增加其优先级
|
if (Utils.isDeepLoc(slaveProperties, sourceLocNo)) {
|
String shallowLoc = Utils.getShallowLoc(slaveProperties, sourceLocNo);
|
LocMast locShallow = locMastService.selectById(shallowLoc);
|
if(!Cools.isEmpty(locShallow) && (locShallow.getLocSts().equals("F") || locShallow.getLocSts().equals("D"))){
|
moveLocForDeepLoc(loc.getCrnNo(), sourceLocNo);
|
}
|
}
|
}
|
|
// 保存工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
|
wrkMast.setIoType(11); // 入出库状态： 11.库格移载
|
wrkMast.setIoPri(10D);
|
wrkMast.setCrnNo(sourceLoc.getCrnNo());
|
wrkMast.setSourceLocNo(sourceLocNo); // 源库位
|
wrkMast.setLocNo(locNo); // 目标库位
|
wrkMast.setFullPlt("N"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D")?"Y":"N"); // 空板
|
wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
|
wrkMast.setLinkMis("N");
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 工作档明细保存
|
List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
|
for (LocDetl locDetl : locDetls) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.setWrkNo(workNo);
|
wrkDetl.setIoTime(new Date());
|
wrkDetl.setQty(locDetl.getQty());
|
VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
|
wrkDetl.setAppeTime(new Date());
|
wrkDetl.setAppeUser(userId);
|
wrkDetl.setModiTime(new Date());
|
wrkDetl.setModiUser(userId);
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
}
|
// 修改源库位状态
|
if (sourceLoc.getLocSts().equals("D") || sourceLoc.getLocSts().equals("F")) {
|
sourceLoc.setLocSts("R"); // R.出库预约
|
sourceLoc.setModiUser(userId);
|
sourceLoc.setModiTime(new Date());
|
if (!locMastService.updateById(sourceLoc)){
|
throw new CoolException("更新源库位状态失败");
|
}
|
} else {
|
throw new CoolException("源库位出库失败，状态："+sourceLoc.getLocSts$());
|
}
|
// 修改目标库位状态
|
if (loc.getLocSts().equals("O")) {
|
loc.setLocSts("S"); // S.入库预约
|
loc.setModiTime(new Date());
|
loc.setModiUser(userId);
|
if (!locMastService.updateById(loc)) {
|
throw new CoolException("更新目标库位状态失败");
|
}
|
} else {
|
throw new CoolException("移转失败，目标库位状态："+loc.getLocSts$());
|
}
|
}
|
|
@Override
|
@Transactional
|
public void completeWrkMast(String workNo, Long userId) {
|
WrkMast wrkMast = wrkMastService.selectById(workNo);
|
if (Cools.isEmpty(wrkMast)){
|
throw new CoolException(workNo+"工作档不存在");
|
}
|
if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 14) {
|
throw new CoolException("当前工作档已完成");
|
}
|
// 入库 + 库位转移
|
if (wrkMast.getWrkSts() < 4 || (wrkMast.getWrkSts() > 10 && wrkMast.getIoType()==11)) {
|
wrkMast.setWrkSts(4L);
|
// 出库
|
} else if (wrkMast.getWrkSts() > 10) {
|
wrkMast.setWrkSts(14L);
|
}
|
|
// 完成操作人员记录
|
wrkMast.setManuType("手动完成");
|
Date now = new Date();
|
wrkMast.setCrnStrTime(DateUtils.calculate(now, 1L, TimeUnit.SECONDS, true));
|
wrkMast.setCrnEndTime(now);
|
wrkMast.setModiTime(now);
|
wrkMast.setModiUser(userId);
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("修改工作档失败");
|
}
|
}
|
|
@Override
|
@Transactional
|
public void adjustLocDetl(LocDetlAdjustParam param, Long userId) {
|
//根据库位号找寻库位
|
LocMast locMast = locMastService.selectById(param.getLocNo());
|
//判断
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException("库位不存在");
|
}
|
//查询库位状态
|
if (locMast.getLocSts().equals("O") || locMast.getLocSts().equals("D")){
|
//更新库位状态
|
locMast.setLocSts("F");
|
// boolean b = locMastService.updateById(locMast);
|
if (!locMastService.updateById(locMast)){
|
throw new CoolException("更新库位状态失败");
|
}
|
}
|
|
for (LocDetlAdjustParam.LocDetlAdjust adjust : param.getList()) {
|
if (Cools.isEmpty(adjust.getMatNo())) {
|
throw new CoolException(BaseRes.PARAM);
|
}
|
LocDetl sqlParam = new LocDetl();
|
sqlParam.setLocNo(locMast.getLocNo());
|
sqlParam.setMatNo(adjust.getMatNo());
|
sqlParam.setSupplier(adjust.getSupplier());
|
LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
|
// 保存新库存明细
|
if (Cools.isEmpty(one)) {
|
if (adjust.getCount() == 0){
|
continue;
|
}
|
MatCode matCode = matCodeService.selectById(adjust.getMatNo());
|
LocDetl locDetl = new LocDetl();
|
locDetl.setLocNo(locMast.getLocNo());
|
locDetl.setQty(adjust.getCount()); // 数量
|
VersionUtils.setLocDetl(locDetl, matCode); // 版本控制
|
|
if (Cools.isEmpty(adjust.getSupplier())){
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
|
locDetl.setSupplier(sdf.format(new Date()));
|
}else {
|
locDetl.setSupplier(adjust.getSupplier());
|
}
|
|
|
locDetl.setModiUser(userId); // 操作人员信息
|
locDetl.setModiTime(new Date());
|
locDetl.setAppeUser(userId);
|
locDetl.setAppeTime(new Date());
|
locDetl.setZpallet(param.getZpallet());//托盘号
|
locDetl.setVendor(adjust.getVendor());
|
locDetl.setSource(adjust.getSource());
|
locDetl.setSupplier(adjust.getSupplier());
|
locDetl.setQtyBox(matCode.getStr6());
|
locDetl.setAllQty(matCode.getStr6()*adjust.getCount());
|
locDetl.setAllWeight(matCode.getWeight()*adjust.getCount()+30);
|
if (!locDetlService.insert(locDetl)) {
|
throw new CoolException("保存库存明细失败");
|
}
|
// 保存调整记录
|
AdjDetl adjDetl = new AdjDetl();
|
adjDetl.setLocNo(locDetl.getLocNo());
|
adjDetl.setMatNo(locDetl.getMatNo());
|
adjDetl.setOriQty(0.0D);
|
adjDetl.setAdjQty(adjust.getCount());
|
adjDetlService.save(adjDetl, userId);
|
// 修改原库存明细
|
} else {
|
// 如果数量修改，则更新库存明细
|
if (!adjust.getCount().equals(one.getQty())) {
|
// 当数量被修改为 0 时，直接清除库存明细
|
if (adjust.getCount() == 0) {
|
if (!locDetlService.delete(new EntityWrapper<>(one))) {
|
throw new CoolException("清除库存明细失败");
|
}
|
} else {
|
MatCode matCode = matCodeService.selectById(adjust.getMatNo());
|
LocDetl sqlParam1 = new LocDetl();
|
sqlParam1.setQty(adjust.getCount());
|
sqlParam1.setSupplier(adjust.getSupplier());
|
sqlParam1.setModiTime(new Date());
|
sqlParam1.setModiUser(userId);
|
sqlParam1.setVendor(adjust.getVendor());
|
sqlParam1.setSource(adjust.getSource());
|
sqlParam1.setSupplier(adjust.getSupplier());
|
sqlParam1.setQtyBox(matCode.getStr6());
|
sqlParam1.setAllQty(matCode.getStr6()*adjust.getCount());
|
sqlParam1.setAllWeight(matCode.getWeight()*adjust.getCount()+30);
|
if (!locDetlService.update(sqlParam1, new EntityWrapper<LocDetl>()
|
.eq("loc_no", locMast.getLocNo())
|
.eq("mat_no", adjust.getMatNo())
|
.eq("supplier",adjust.getSupplier()))) {
|
throw new CoolException("修改库存明细失败");
|
}
|
}
|
// 保存调整记录
|
AdjDetl adjDetl = new AdjDetl();
|
adjDetl.setLocNo(locMast.getLocNo());
|
adjDetl.setMatNo(adjust.getMatNo());
|
adjDetl.setOriQty(one.getQty());
|
adjDetl.setAdjQty(adjust.getCount());
|
adjDetlService.save(adjDetl, userId);
|
}
|
}
|
}
|
List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", param.getLocNo()));
|
if (locDetls.isEmpty()) {
|
locMast.setLocSts("D");
|
locMast.setModiUser(userId);
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("更新库位状态失败");
|
}
|
}
|
}
|
|
@Override
|
@Transactional
|
public void cancelWrkMast(String workNo, Long userId) {
|
WrkMast wrkMast = wrkMastService.selectById(workNo);
|
if (Cools.isEmpty(wrkMast)){
|
throw new CoolException(workNo+"工作档不存在");
|
}
|
String locNo = ""; // 待修改目标库位
|
String locSts = ""; // 待修改目标库位状态
|
// 入库取消（修改目标库位）
|
if (wrkMast.getWrkSts() < 4) {
|
locNo = wrkMast.getLocNo();
|
locSts = "O";
|
/**
|
* 库位转移
|
* 取消后 源库位 ==>> F.在库
|
* 目标库位 ===>> O.空库位
|
**/
|
if (wrkMast.getIoType() == 11) {
|
// 库位转移：源库位
|
LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException("取消库位转移失败，源库位不存在:"+ wrkMast.getSourceLocNo());
|
}
|
locMast.setLocSts("F");
|
locMast.setModiTime(new Date());
|
locMast.setModiUser(userId);
|
locMastService.updateById(locMast);
|
}
|
// 出库取消（修改源库位）
|
} else if (wrkMast.getWrkSts() > 10 && wrkMast.getWrkSts() != 14) {
|
locNo = wrkMast.getSourceLocNo();
|
// 出库 ===>> F.在库
|
if (wrkMast.getIoType() > 100 && wrkMast.getIoType() != 110) {
|
locSts = "F";
|
// 空板出库 ===>> D.空桶/空栈板
|
} else if (wrkMast.getIoType() == 110) {
|
locSts = "D";
|
// 库位转移 ===>> D.空桶/空栈板
|
} else if (wrkMast.getIoType() == 11) {
|
locSts = "F";
|
// 库位转移：目标库位
|
LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException("取消库位转移失败，目标库位不存在:"+ wrkMast.getSourceLocNo());
|
}
|
locMast.setLocSts("O");
|
locMast.setModiTime(new Date());
|
locMast.setModiUser(userId);
|
locMastService.updateById(locMast);
|
}
|
} else {
|
throw new CoolException("当前工作状态无法取消");
|
}
|
// 取消操作人员记录
|
wrkMast.setManuType("手动取消");
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(new Date());
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("取消工作档失败");
|
}
|
// 保存工作主档历史档
|
if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
|
throw new CoolException("保存工作历史档失败, workNo = " + wrkMast.getWrkNo());
|
}
|
// 删除工作主档
|
boolean wrkMastRes = wrkMastService.deleteById(wrkMast);
|
|
if (wrkMast.getIoType() != 10 && wrkMast.getIoType() != 110) {
|
// 保存工作明细档历史档
|
if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
|
throw new CoolException("保存工作明细历史档失败, workNo = " + wrkMast.getWrkNo());
|
}
|
// 删除工作档明细
|
boolean wrkDetlRes = wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no", workNo));
|
}
|
// 修改库位状态
|
LocMast locMast = locMastService.selectById(locNo);
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException("取消工作档失败，库位不存在:"+ locNo);
|
}
|
locMast.setLocSts(locSts);
|
locMast.setModiTime(new Date());
|
locMast.setModiUser(userId);
|
boolean locMastRes = locMastService.updateById(locMast);
|
if (!wrkMastRes || !locMastRes) {
|
throw new CoolException("保存数据失败");
|
}
|
}
|
|
@Override
|
@Transactional
|
public void pickWrkMast(String workNo, Long userId) {
|
WrkMast wrkMast = wrkMastService.selectById(workNo);
|
if (Cools.isEmpty(wrkMast)){
|
throw new CoolException(workNo+"工作档不存在");
|
}
|
// 入出库类型判断
|
if (wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) {
|
throw new CoolException("当前入出库类型无法进行操作");
|
}
|
// 工作状态判断
|
if (wrkMast.getWrkSts() < 11 || wrkMast.getWrkSts() == 15) {
|
throw new CoolException("当前工作状态无法进行操作");
|
}
|
// 保存工作明细档历史档
|
if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
|
throw new CoolException("保存工作明细档历史档失败");
|
}
|
// 保存工作主档历史档
|
if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
|
throw new CoolException("保存工作主档历史档失败");
|
}
|
// 获取目标站
|
Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
|
.eq("type_no", wrkMast.getIoType() - 50)
|
.eq("stn_no", wrkMast.getStaNo()) // 作业站点 = 拣料出库的目标站
|
.eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
|
StaDesc staDesc = staDescService.selectOne(wrapper);
|
if (Cools.isEmpty(staDesc)) {
|
throw new CoolException("入库路径不存在");
|
}
|
// 堆垛机站点(目标站)
|
Integer staNo = staDesc.getCrnStn();
|
// 更新工作档数据状态
|
wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
|
wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
|
wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
|
wrkMast.setStaNo(staNo); // 目标站
|
wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
|
wrkMast.setSourceLocNo(""); // 源库位清空
|
wrkMast.setModiTime(new Date());
|
wrkMast.setModiUser(userId);
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("更新工作档数据状态失败");
|
}
|
// 修改库位状态 Q.拣料/盘点/并板再入库
|
LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
|
locMast.setLocSts("Q");
|
locMast.setModiTime(new Date());
|
locMast.setModiUser(userId);
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("修改库位状态失败");
|
}
|
}
|
|
/**
|
* 因双深库位阻塞，对浅库位进行移转
|
*/
|
public void moveLocForDeepLoc(Integer crnNo, String locNo){
|
// 双深库位且浅库位有货，则需先对浅库位进行库位移转
|
if (Utils.isDeepLoc(slaveProperties, locNo)) {
|
String shallowLocNo = Utils.getShallowLoc(slaveProperties, locNo);
|
LocMast shallowLoc = locMastService.selectById(shallowLocNo);
|
// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
|
if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
|
WrkMast waitWrkMast = wrkMastService.selectByLocNo(shallowLocNo);
|
if (null == waitWrkMast) {
|
log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
|
throw new CoolException(shallowLocNo + "库位异常，未检索到相应工作档！");
|
} else {
|
waitWrkMast.setIoPri(15D);
|
waitWrkMast.setModiTime(new Date());
|
if (!wrkMastService.updateById(waitWrkMast)) {
|
log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
|
throw new CoolException("调整工作档优先级失败！工作号=" + waitWrkMast.getWrkNo());
|
}
|
}
|
} else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
|
// 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行)
|
List<Integer> rows = locMastService.queryDistinctRow(crnNo);
|
LocMast loc = null;
|
for (Integer row : rows) {
|
if (Utils.isDeepLoc(slaveProperties, row)) {
|
loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1(),shallowLoc.getLocType2(),shallowLoc.getLocType3());
|
if (null != loc) { break; }
|
}
|
}
|
if (null == loc) {
|
for (Integer row : rows) {
|
if (Utils.isShallowLoc(slaveProperties, row)) {
|
loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1(),shallowLoc.getLocType2(),shallowLoc.getLocType3());
|
if (null != loc) { break; }
|
}
|
}
|
}
|
if (null == loc) {
|
throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
|
}
|
|
// 获取工作号
|
int workNo = commonService.getWorkNo(0);
|
// 保存工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
|
wrkMast.setIoType(11); // 入出库状态： 11.库格移载
|
wrkMast.setIoPri(13D);
|
wrkMast.setCrnNo(crnNo);
|
wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
|
wrkMast.setLocNo(loc.getLocNo()); // 目标库位
|
wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D")?"Y":"N"); // 空板
|
wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
|
wrkMast.setLinkMis("N");
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiTime(new Date());
|
if (!wrkMastService.insert(wrkMast)) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 工作档明细保存
|
if (shallowLoc.getLocSts().equals("F")) {
|
List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
|
for (LocDetl locDetl : locDetls) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.setWrkNo(workNo);
|
wrkDetl.setIoTime(new Date());
|
wrkDetl.setQty(locDetl.getQty());
|
VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
|
wrkDetl.setAppeTime(new Date());
|
wrkDetl.setModiTime(new Date());
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作档明细失败");
|
}
|
}
|
}
|
// 修改源库位状态
|
if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
|
shallowLoc.setLocSts("R"); // R.出库预约
|
shallowLoc.setModiTime(new Date());
|
if (!locMastService.updateById(shallowLoc)){
|
throw new CoolException("更新源库位状态失败");
|
}
|
} else {
|
throw new CoolException("源库位出库失败");
|
}
|
// 修改目标库位状态
|
if (loc.getLocSts().equals("O")) {
|
loc.setLocSts("S"); // S.入库预约
|
loc.setModiTime(new Date());
|
if (!locMastService.updateById(loc)) {
|
throw new CoolException("更新目标库位状态失败");
|
}
|
} else {
|
throw new CoolException("移转失败");
|
}
|
}
|
}
|
}
|
|
}
|
