package com.zy.asrs.service.impl;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.core.common.BaseRes;
|
import com.core.common.Cools;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.entity.param.*;
|
import com.zy.asrs.service.*;
|
import com.zy.asrs.utils.CodeDetectionUtil;
|
import com.zy.common.model.DetlDto;
|
import com.zy.common.service.AgvCommonService;
|
import lombok.Synchronized;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
|
/**
|
* 移动端服务核心类
|
* Created by vincent on 2020/6/28
|
*/
|
@Slf4j
|
@Service
|
public class AgvMobileServiceImpl implements AgvMobileService {
|
|
@Autowired
|
private MatService matService;
|
@Autowired
|
private AgvWaitPakinService agvWaitPakinService;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private OrderDetlService orderDetlService;
|
@Autowired
|
private AgvBasDevpService agvBasDevpService;
|
@Autowired
|
private AgvLocDetlService agvLocDetlService;
|
@Autowired
|
private AgvWrkMastService agvWrkMastService;
|
@Autowired
|
private AgvWorkService agvWorkService;
|
@Autowired
|
private AgvWrkDetlService agvWrkDetlService;
|
@Autowired
|
private AgvLocMastService agvLocMastService;
|
@Autowired
|
private AgvCommonService agvCommonService;
|
@Autowired
|
private AgvWrkMastLogService agvWrkMastLogService;
|
@Autowired
|
private AgvWrkDetlLogService agvWrkDetlLogService;
|
|
|
/*
|
组托 + 绑定暂存位
|
*/
|
@Override
|
@Transactional
|
public String comb(CombParam param, Long userId) {
|
if (Cools.isEmpty(param.getBarcode(), param.getCombMats())) {
|
throw new CoolException(BaseRes.PARAM);
|
}
|
if (!CodeDetectionUtil.barcodeDetection(param.getBarcode())) {
|
throw new CoolException(param.getBarcode() + "货架码有误，请正确扫码！！！");
|
}
|
param.setContainerType(Short.valueOf(param.getBarcode().substring(0, 2)));
|
|
// //检查是否已存在相同的货架条码，存在则抛出异常
|
// if (agvWaitPakinService.selectCount(new EntityWrapper<AgvWaitPakin>().eq("supp_code", param.getBarcode())) > 0) {
|
// throw new CoolException(param.getBarcode() + "料想码已存在AGV入库通知档中");
|
// }
|
|
//检查库存是否有相同货架，存在则抛出异常
|
if (!Cools.isEmpty(agvLocDetlService.selectOne(new EntityWrapper<AgvLocDetl>().eq("supp_code", param.getBarcode())))) {
|
throw new CoolException(param.getBarcode() + "货架码已存在AGV库存明细中");
|
}
|
|
//检查库存是否有相同货架，存在则抛出异常
|
if (!Cools.isEmpty(agvLocMastService.selectOne(new EntityWrapper<AgvLocMast>().eq("barcode", param.getBarcode())))) {
|
throw new CoolException(param.getBarcode() + "货架码已存在AGV库存主档中");
|
}
|
|
//查看工作档是否有相同货架，存在则抛出异常
|
if (!Cools.isEmpty(agvWrkMastService.selectByContainerCode(param.getBarcode()))) {
|
throw new CoolException(param.getBarcode() + "货架码已存在AGV工作档中");
|
}
|
|
if (Cools.isEmpty(param.getOrderNo())) {
|
//无单组托
|
NoOrderComb(param, userId);
|
} else {
|
//有单组托
|
OrderComb(param, userId);
|
}
|
|
if (StringUtils.isEmpty(param.getLocno())) {
|
return "组托成功";
|
} else {
|
combBinding(param.getBarcode(), param.getLocno(), param.getContainerType());
|
return "组托成功，绑定站点成功";
|
}
|
|
}
|
|
/*
|
再次拣料
|
*/
|
@Override
|
@Transactional
|
public synchronized String pickAgain(PickParam pickParams, Long userId) {
|
Date now = new Date();
|
List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", pickParams.getLocNo()));
|
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("wrk_no", pickParams.getWrkNo()));
|
|
if (Cools.isEmpty(agvWrkMast)) {
|
return "失败，未查到工作主档，工作号：" + pickParams.getWrkNo();
|
}
|
for (PickParam.Pick pick : pickParams.getPicks()) {
|
if (pick.getCount().equals(0D)) continue;
|
|
Double count = 0.0D;
|
AgvWrkDetl agvWrkDetl = agvWrkDetlService.selectOne(new EntityWrapper<AgvWrkDetl>().eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()).eq("supp_code", pick.getSuppCode()));
|
|
if (Cools.isEmpty(agvWrkDetl)) {
|
agvWrkDetl = new AgvWrkDetl();
|
Mat mat = matService.selectByMatnr(pick.getMatnr());
|
if (Cools.isEmpty(mat)) {
|
throw new CoolException(pick.getMatnr() + "商品不存在");
|
}
|
agvWrkDetl.sync(mat);
|
agvWrkDetl.setWrkNo(pickParams.getWrkNo());
|
agvWrkDetl.setOrderNo(pick.getOrderNo());
|
agvWrkDetl.setIoTime(agvWrkMast.getIoTime());
|
agvWrkDetl.setAnfme(pick.getCount()); // 数量
|
agvWrkDetl.setSuppCode(pick.getSuppCode()); // 货架条码
|
agvWrkDetl.setAppeUser(userId);
|
agvWrkDetl.setAppeTime(now);
|
agvWrkDetl.setModiUser(userId);
|
agvWrkDetl.setModiTime(now);
|
agvWrkDetl.setThreeCode(pick.getThreeCode());
|
agvWrkDetlService.insert(agvWrkDetl);
|
} else {
|
Double anfme = agvWrkDetl.getAnfme() + pick.getCount();
|
agvWrkDetl.setIoTime(agvWrkMast.getIoTime());
|
agvWrkDetl.setAnfme(anfme);
|
agvWrkDetl.setModiTime(now);
|
agvWrkDetlService.update(agvWrkDetl, new EntityWrapper<AgvWrkDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("supp_code", pick.getSuppCode()));
|
|
}
|
// 库存校验
|
Optional<AgvLocDetl> first = agvLocDetls.stream().filter(agvLocDetl -> agvLocDetl.getThreeCode().equals(pick.getThreeCode()))
|
.filter(agvLocDetl -> agvLocDetl.getMatnr().equals(pick.getMatnr())).findFirst();
|
if (first.isPresent()) {
|
AgvLocDetl agvLocDetl = first.get();
|
if (agvLocDetl.getAnfme() < agvWrkDetl.getAnfme()) {
|
throw new CoolException("拣料数量不能大于库存数量");
|
}
|
} else {
|
throw new CoolException("拣料数量不能大于库存数量,存库不存在");
|
}
|
|
// 更新订单
|
OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("order_no", pick.getOrderNo()).eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()));
|
orderDetl.setQty(orderDetl.getQty() + pick.getCount());
|
if (!orderDetlService.update(orderDetl, new EntityWrapper<OrderDetl>().eq("order_no", pick.getOrderNo()).eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()))) {
|
throw new CoolException("修改订单明细失败，请联系管理员" + pick.getOrderNo() + pick.getMatnr());
|
}
|
Order order = orderService.selectByNo(orderDetl.getOrderNo());
|
if (order.getSettle() == 1) {
|
if (!orderService.updateSettle(order.getId(), 2L, userId)) {
|
throw new CoolException("再次拣料：更新订单状态失败！");
|
}
|
}
|
}
|
// 确认是否全部出库
|
double totleWrkdetl = 0.0;
|
double totleLocdetl = 0.0;
|
List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", pickParams.getWrkNo()));
|
for (AgvLocDetl agvLocDetl : agvLocDetls) {
|
totleLocdetl = totleLocdetl + agvLocDetl.getAnfme();
|
}
|
for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
|
totleWrkdetl = totleWrkdetl + agvWrkDetl.getAnfme();
|
}
|
if (totleWrkdetl >= totleLocdetl) {
|
agvWrkMast.setIoType(101);
|
agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", pickParams.getWrkNo()));
|
|
}
|
// agvLocDetls.size() == 1
|
|
|
return "拣料成功";
|
}
|
|
/*
|
AGV无单组托
|
*/
|
private void NoOrderComb(CombParam param, Long userId) {
|
List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param, null);
|
|
//用于统一一个货架下的入库通知档的生成时间
|
Date now = new Date();
|
detlDtos.forEach(detlDto -> {
|
syncWaitPakin(detlDto, "", param.getBarcode(), userId, now);
|
});
|
}
|
|
|
/*
|
AGV有单组托
|
*/
|
private void OrderComb(CombParam param, Long userId) {
|
//关联组托
|
Order order = orderService.selectByNo(param.getOrderNo());
|
if (Cools.isEmpty(order)) {
|
throw new CoolException("单据编号不存在");
|
}
|
//订单状态2以上为完成或者取消的订单
|
if (order.getSettle() > 2) {
|
throw new CoolException("单据编号已过期");
|
}
|
// 用于生成入库通知档所需参数
|
List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param, order);
|
//用于统一一个货架下的入库通知档的生成时间
|
Date now = new Date();
|
for (DetlDto detlDto : detlDtos) {
|
//同步生成入库通知档
|
syncWaitPakin(detlDto, order.getOrderNo(), param.getBarcode(), userId, now);
|
}
|
//修改单据状态为2.作业中
|
orderService.updateSettle(order.getId(), 2L, userId);
|
}
|
|
/*
|
根据PDA扫码所传的物料信息参数映射为DetlDto
|
*/
|
private List<DetlDto> mappingDetlDtoByCombMat(CombParam param, Order order) {
|
List<DetlDto> detlDtos = new ArrayList<>();
|
param.getCombMats().forEach(combMat -> {
|
|
if (!Cools.isEmpty(order)) {
|
//检查入库数量
|
checkOrderQty(order, combMat);
|
}
|
|
DetlDto detlDto = new DetlDto(combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(), combMat.getIsoseq(), combMat.getContainerCode(), param.getLocType(), combMat.getProcessSts());
|
//同一货架下相同物料信息和批号转为一个入库通知档
|
if (DetlDto.has(detlDtos, detlDto)) {
|
DetlDto one = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch(), detlDto.getCsocode(), detlDto.getIsoseq(), detlDto.getContainerCode());
|
assert one != null;
|
one.setAnfme(one.getAnfme() + detlDto.getAnfme());
|
} else {
|
detlDtos.add(detlDto);
|
}
|
});
|
|
return detlDtos;
|
}
|
|
/*
|
检查入库数量是否小于等于单据数量，合理则修改OrderDetl作业数量信息，否则抛出异常
|
*/
|
private void checkOrderQty(Order order, CombParam.CombMat combMat) {
|
// 订单明细数量校验，如果作业数量大于单据数量则抛出异常
|
OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getCsocode(), combMat.getIsoseq());
|
if (Cools.isEmpty(orderDetl)) {
|
throw new CoolException("未匹配到该单据下的物料");
|
}
|
if (combMat.getAnfme() > orderDetl.getEnableQty()) {
|
throw new CoolException(orderDetl.getMatnr() + "入库数量不合法");
|
}
|
// 修改订单明细数量
|
if (!orderDetlService.increase(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(), combMat.getIsoseq())) {
|
throw new CoolException("修改单据明细数量失败");
|
}
|
}
|
|
/*
|
同步生成AGV入库通知档数据
|
*/
|
private void syncWaitPakin(DetlDto detlDto, String orderNo, String zpallet, Long userId, Date now) {
|
Mat mat = matService.selectByMatnr(detlDto.getMatnr());
|
if (Cools.isEmpty(mat)) {
|
throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
|
}
|
OrderDetl orderDetl = orderDetlService.selectItem(orderNo, mat.getMatnr(), detlDto.getBatch(), detlDto.getCsocode());
|
AgvWaitPakin waitPakin = new AgvWaitPakin();
|
waitPakin.sync(mat);
|
if (orderDetl != null) {
|
waitPakin.setWeight(orderDetl.getWeight());
|
waitPakin.setVolume(orderDetl.getVolume());
|
}
|
waitPakin.setOrderNo(orderNo); // 单据编号
|
waitPakin.setBatch(detlDto.getBatch()); // 序列码
|
//waitPakin.setZpallet(zpallet); // 货架码
|
waitPakin.setSuppCode(zpallet); // 货架码
|
waitPakin.setIoStatus("N"); // 入出状态
|
waitPakin.setAnfme(detlDto.getAnfme()); // 数量
|
waitPakin.setStatus("Y"); // 状态
|
|
////销售订单号
|
waitPakin.setThreeCode(detlDto.getCsocode());
|
//销售订单行号
|
waitPakin.setDeadTime(detlDto.getIsoseq());
|
|
waitPakin.setLocType(detlDto.getLocType());
|
|
waitPakin.setProcessSts(detlDto.getProcessSts());
|
|
|
waitPakin.setAppeUser(userId);
|
waitPakin.setAppeTime(now);
|
waitPakin.setModiUser(userId);
|
waitPakin.setModiTime(now);
|
if (!agvWaitPakinService.insert(waitPakin)) {
|
throw new CoolException("保存入库通知档失败");
|
}
|
}
|
|
|
@Override
|
@Transactional
|
public void adjust(MobileAdjustParam param, Long userId) {
|
|
}
|
|
@Override
|
@Transactional
|
public void packComb(CombParam param, Long userId) {
|
|
}
|
|
@Override
|
public void combBinding(String barcode, String stationCode, Short containerType) {
|
|
AgvBasDevp agvBasDevp = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("dev_no", stationCode));
|
|
if (Cools.eq(agvBasDevp.getBarcode(), barcode)) {
|
return;
|
}
|
|
if (Cools.isEmpty(agvWaitPakinService.selectByContainerCode(barcode))) {
|
throw new CoolException("该货架未组托，无法绑定站点");
|
}
|
|
AgvBasDevp agvBasDevp1 = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("barcode", barcode));
|
|
if (!Cools.isEmpty(agvBasDevp1)) {
|
throw new CoolException(barcode + "已经绑定在" + agvBasDevp.getDevNo() + "站点");
|
}
|
|
if (agvBasDevp == null) {
|
throw new CoolException(stationCode + "站点信息错误");
|
}
|
if (!"O".equals(agvBasDevp.getLocSts())) {
|
throw new CoolException(stationCode + "该站点货位状态非空");
|
}
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", agvBasDevp.getDevNo()));
|
if (!Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException(stationCode + "该站点已被工作号为" + agvWrkMast.getWrkNo() + "占用，无法绑定");
|
}
|
|
agvBasDevp.setBarcode(barcode);
|
agvBasDevp.setLocSts("F");
|
agvBasDevp.setLocType2(containerType);
|
agvBasDevpService.update(agvBasDevp, (new EntityWrapper<AgvBasDevp>().eq("dev_no", stationCode)));
|
}
|
|
public List<AgvBasDevp> getAgvBasDevpByFloor(int floor) {
|
EntityWrapper<AgvBasDevp> wrapper = new EntityWrapper<>();
|
wrapper.eq("floor", floor).eq("cache_shelves", "Y").eq("loc_sts", "F");
|
List<AgvBasDevp> agvBasDevpList = agvBasDevpService.selectList(wrapper);
|
return agvBasDevpList.stream().filter(agvBasDevp -> {
|
return !Cools.isEmpty(agvWaitPakinService.selectByContainerCode(agvBasDevp.getBarcode()));
|
}).collect(Collectors.toList());
|
}
|
|
@Override
|
public void pakinEmpty(String devNo, boolean pakin) {
|
//当前站点信息
|
AgvBasDevp agvBasDevp = agvBasDevpService.selectById(devNo);
|
//寻找相同类型的库位
|
|
//生成空盘工作档
|
|
//更改库位状态以及站点状态
|
}
|
|
@Override
|
public void pakoutEmpty(String devNo) {
|
|
}
|
|
/*
|
手动移库
|
*/
|
@Override
|
@Transactional
|
public String handControlLocMove(LocMoveParam param, Long userId) {
|
String fl = String.valueOf(param.getFloor());
|
short floor = (short) Integer.parseInt(fl.substring(0, 1));
|
switch (param.getFloor()) {
|
case "1F01":
|
floor = 1;
|
break;
|
case "1F02":
|
floor = 4;
|
break;
|
case "2F":
|
floor = 2;
|
break;
|
case "3F":
|
floor = 3;
|
break;
|
}
|
Integer ioType = 0;
|
AgvLocMast agvLocMast = agvLocMastService.selectOne(new EntityWrapper<AgvLocMast>().eq("loc_no", param.getLocNo()));
|
if (Cools.isEmpty(agvLocMast)) {
|
throw new CoolException("当前库位为空，请检查库位！");
|
}
|
// if (agvLocMast.getLocSts() == "F") {
|
// return R.error("当前库位不为在库，或者空货架，不支持移库");
|
|
// 校验楼层
|
if (agvLocMast.getLocType1() != 3) { // 不为箱壳区域
|
if (agvLocMast.getFloor() != floor) {
|
throw new CoolException("当前库位不支持跨楼层转移");
|
} else {
|
ioType = 11;
|
}
|
} else {
|
if (agvLocMast.getFloor() != floor) {
|
if (agvLocMast.getFloor() == 1 && (floor == 2 || floor == 3)) {
|
throw new CoolException("当前库位请选择调拨单调拨！");
|
} else if ((agvLocMast.getFloor() == 2 || agvLocMast.getFloor() == 3) && (floor == 1 || floor == 4)) {
|
throw new CoolException("当前库位请选择调拨回流单回退！");
|
} else {
|
ioType = 12;
|
}
|
} else {
|
if (agvLocMast.getFloor() == 1) {
|
if (agvLocMast.getLev1() == 1 && floor == 1) {
|
ioType = 11;
|
} else {
|
ioType = 12;
|
}
|
} else {
|
ioType = 11;
|
}
|
}
|
}
|
Date now = new Date();
|
//查询工作档
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
|
if (!Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
|
}
|
//检索库位，选择合适的库位
|
AgvLocMast locMast = null;
|
if (floor == 1) {
|
locMast = agvCommonService.getLocNo(agvLocMast.getLocType1(), floor, true, false);
|
} else {
|
locMast = agvCommonService.getLocNo(agvLocMast.getLocType1(), floor, false, false);
|
}
|
|
// 目标楼层去 吸塑2楼
|
if (floor == 4) {
|
if (locMast.getLev1() == 1) {
|
throw new CoolException("吸塑一楼没有空库位可以移库！");
|
}
|
|
}
|
|
if (Cools.isEmpty(locMast)) {
|
throw new CoolException("当前楼层没有空库位");
|
}
|
//生成工作档
|
AgvWrkMast mast = new AgvWrkMast();
|
//工作状态
|
if (ioType == 121) {
|
mast.setWrkSts(11L);
|
} else {
|
mast.setWrkSts(201L);
|
}
|
//入出库类型
|
mast.setIoType(ioType);
|
mast.setIoTime(now);
|
//优先级
|
mast.setIoPri(300.0);
|
//源站点
|
mast.setSourceLocNo(agvLocMast.getLocNo());
|
//目标站点
|
mast.setLocNo(locMast.getLocNo());
|
//货架编码
|
mast.setBarcode(agvLocMast.getBarcode());
|
//货架类型
|
mast.setWhsType(30);
|
|
mast.setAppeUser(userId);
|
mast.setAppeTime(now);
|
mast.setModiUser(userId);
|
mast.setModiTime(now);
|
mast.setLogErrMemo("handControlLocMove");
|
if (!agvWrkMastService.insertByIncrease(mast)) {
|
throw new CoolException("保存工作档失败");
|
}
|
if (agvLocMast.getLocSts().equals("F")) {
|
AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", locMast.getLocNo()).eq("source_loc_no", agvLocMast.getLocNo()));
|
//生成工作档明细
|
List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
|
agvLocDetls.forEach(agvLocDetl -> {
|
AgvWrkDetl wrkDetl = new AgvWrkDetl();
|
wrkDetl.setWrkNo(mast1.getWrkNo());
|
wrkDetl.sync(agvLocDetl);
|
wrkDetl.setSuppCode(agvLocDetl.getSuppCode());
|
wrkDetl.setIoTime(now);
|
wrkDetl.setAppeUser(9527L);
|
wrkDetl.setAppeTime(now);
|
wrkDetl.setModiUser(9527L);
|
wrkDetl.setModiTime(now);
|
if (!agvWrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作明细失败");
|
}
|
});
|
}
|
|
// // 如果当前任务是箱壳二三楼回退一楼的 回滚调拨单
|
// if (ioType == 12 && locMast.getFloor() == 1 && floor != 4 && agvLocMast.getFloor() != 1) {
|
// List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
|
// for (AgvLocDetl agvLocDetl : agvLocDetls) {
|
// OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("three_code", agvLocDetl.getThreeCode()).eq("matnr", agvLocDetl.getMatnr()).eq("source", 33));
|
// if (Cools.isEmpty(orderDetl)) {
|
// throw new CoolException("当前物料的调拨单不存在！");
|
// }
|
// Order order = orderService.selectByNo(orderDetl.getOrderNo());
|
// if (Cools.isEmpty(order)) {
|
// throw new CoolException("当前物料的调拨单不存在！");
|
// }
|
// if (order.getSettle() == 4L) {
|
// if (!orderService.updateSettle(order.getId(),2L,userId)) {
|
// throw new CoolException("调拨单回滚异常!");
|
// }
|
// }
|
// orderDetl.setQty(orderDetl.getQty() - agvLocDetl.getAnfme());
|
// if (!orderDetlService.updateById(orderDetl)) {
|
// throw new CoolException("保存工作明细失败");
|
// }
|
// }
|
// }
|
//更新目标库位状态
|
updateAgvLocMast(agvLocMast, "P");
|
updateAgvLocMast(locMast, "Q");
|
return "ok";
|
}
|
|
/*
|
调拨离场
|
*/
|
@Override
|
@Transactional
|
@Synchronized
|
public String allocationOut(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("请输入货架码");
|
}
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", param.getDevNo()));
|
Integer oldWrkNo = agvWrkMast.getWrkNo();
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("工作档中没有此站点任务");
|
}
|
if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
|
throw new CoolException("当前货架码与任务不匹配");
|
}
|
if (!agvWrkMast.getWrkSts().equals(207L) && !agvWrkMast.getWrkSts().equals(205L)) {
|
throw new CoolException("当前工作状态:" + agvWrkMast.getWrkSts$() + "不符合离场条件");
|
}
|
if (agvWrkMast.getWrkSts().equals(205L)) {
|
// 库位 -- 接驳位 / 库位
|
if (agvWrkMast.getLocNo().substring(0, 2).equals("DB")) {
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getLocNo(), "F", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
// 接驳位 -- 库位
|
} else {
|
agvLocMastService.updateLocStsByLocNo(agvWrkMast.getLocNo(), "D", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
}
|
|
// 接驳位 -- 库位
|
if (agvWrkMast.getSourceLocNo().substring(0, 2).equals("DB")) {
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getSourceLocNo(), "O", "", (short) 0);
|
// 库位 -- 接驳位 / 库位
|
} else {
|
//修改源库位状态为O
|
agvLocMastService.updateLocStsByLocNo(agvWrkMast.getSourceLocNo(), "O", "", agvWrkMast.getWhsType().shortValue(), "", (short) 0);
|
//更新目标库位明细 101.出库 删除源库位库存明细
|
agvLocDetlService.delete(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvWrkMast.getSourceLocNo()));
|
}
|
}
|
|
//生成AGV工作历史档 + 生成AGV工作明细历史档
|
agvWrkMastLogService.save(agvWrkMast);
|
agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
|
//删除AGV工作档
|
agvWrkMastService.deleteById(agvWrkMast);
|
//生成工作档
|
AgvWrkMast wrkMast = createWrkMast(111, 210L, "", "", agvWrkMast.getBarcode(), now, userId, 30, agvWrkMast.getCrnNo());
|
// 更新工作明细
|
List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", agvWrkMast.getBarcode()));
|
for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
|
agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
|
// 保持工作档明细
|
agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
|
agvWrkDetl.setModiUser(userId);
|
agvWrkDetl.setModiTime(now);
|
agvWrkDetl.setIoTime(now);
|
if (!agvWrkDetlService.insert(agvWrkDetl)) {
|
throw new CoolException("保存工作明细失败");
|
}
|
}
|
// 更新站点状态
|
// agvLocMastService.updateLocStsByLocNo(agvWrkMast.getSourceLocNo(),"O","",null);
|
// 更新源库位状态
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getLocNo(), "O", "", agvWrkMast.getWhsType().shortValue());
|
|
//删除AGV工作明细档
|
agvWrkDetlService.delete(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", oldWrkNo));
|
return "ok";
|
}
|
|
/*
|
调拨进场
|
*/
|
@Override
|
@Transactional
|
public String allocationIn(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()));
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("暂无当前货架码的任务");
|
}
|
if (agvWrkMast.getIoType() != 111) {
|
throw new CoolException("非手动调拨任务，不支持次功能");
|
}
|
if (!Cools.isEmpty(agvWrkMast.getSourceLocNo())) {
|
throw new CoolException("当前货架码任有源库位，请确认");
|
}
|
AgvBasDevp agvBasDevp = agvBasDevpService.selectByDevNo(param.getDevNo());
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("工作档中没有此货架任务");
|
}
|
if (agvWrkMast.getCrnNo() != agvBasDevp.getFloor()) {
|
throw new CoolException("请移动到->" + agvWrkMast.getCrnNo() + "楼入库点入库");
|
}
|
AgvLocMast locNo = agvCommonService.getLocNo(3, 1, false, true);
|
//工作状态
|
agvWrkMast.setWrkSts(211L);
|
//入出库类型
|
agvWrkMast.setIoType(112);
|
agvWrkMast.setSourceLocNo(param.getDevNo());
|
agvWrkMast.setModiUser(userId);
|
agvWrkMast.setModiTime(now);
|
if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
|
throw new CoolException("更新工作档失败");
|
}
|
//
|
agvLocMastService.updateLocStsByLocNo(locNo.getLocNo(), "S", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
// 更新源库位状态
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "R", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
//删除AGV工作档
|
return "ok";
|
}
|
|
/*
|
空架离场
|
*/
|
@Override
|
@Transactional
|
@Synchronized
|
public String empOut(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("请输入货架码");
|
}
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
|
Integer oldWrkNo = agvWrkMast.getWrkNo();
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("工作档中没有此站点任务");
|
}
|
if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
|
throw new CoolException("当前货架码与任务不匹配");
|
}
|
agvWrkMast.setModiTime(new Date());
|
agvWrkMast.setWrkSts(213L);
|
agvWrkMast.setSourceLocNo("");
|
if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
|
throw new CoolException("更新工作档失败");
|
}
|
// 更新源库位状态
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "O", "", agvWrkMast.getWhsType().shortValue());
|
return "ok";
|
}
|
|
/*
|
空架进场
|
*/
|
@Override
|
@Transactional
|
@Synchronized
|
public String empIn(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()));
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("工作档中没有此站点任务");
|
}
|
if (agvWrkMast.getIoType() != 113) {
|
throw new CoolException("当前工作类型不能空架进场");
|
}
|
if (agvWrkMast.getWrkSts() != 213) {
|
throw new CoolException("当前工作类型不能空架进场");
|
}
|
agvWrkMast.setWrkSts(214L);
|
agvWrkMast.setModiTime(new Date());
|
agvWrkMast.setSourceLocNo(param.getDevNo());
|
if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
|
throw new CoolException("更新工作档失败");
|
}
|
// 更新源库位状态
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "F", param.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
return "ok";
|
}
|
|
/*
|
* 转手动回流
|
*/
|
@Override
|
@Transactional
|
public String handBack(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
|
agvWrkMast.setIoType(113);
|
agvWrkMast.setModiUser(userId);
|
agvWrkMast.setModiTime(now);
|
if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
|
throw new CoolException("更新工作档失败");
|
}
|
return "ok";
|
}
|
|
/*
|
* 确认加工完成
|
*/
|
@Override
|
@Transactional
|
public String processed(AgvMobileStartPakin param, Long userId) {
|
Date now = new Date();
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()).eq("loc_no", param.getDevNo()));
|
if (Cools.isEmpty(agvWrkMast)) {
|
throw new CoolException("暂无当前货架的工作档");
|
}
|
if (agvWrkMast.getWrkSts() != 205) {
|
throw new CoolException("当前任务未完成，请确认");
|
}
|
//生成AGV工作历史档 + 生成AGV工作明细历史档
|
agvWrkMastLogService.save(agvWrkMast);
|
agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
|
String sourceLocNo = agvWrkMast.getSourceLocNo();
|
AgvLocMast newLocMast = agvCommonService.getLocNo(3, 1, false, false);
|
agvWrkMast.setSourceLocNo(agvWrkMast.getLocNo());
|
agvWrkMast.setLocNo(newLocMast.getLocNo());
|
agvWrkMast.setIoType(57);
|
agvWrkMast.setWrkSts(201L);
|
agvWrkMast.setModiUser(userId);
|
agvWrkMast.setModiTime(now);
|
agvWrkMast.setIoTime(now);
|
|
|
if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
|
throw new CoolException("更新工作档失败");
|
}
|
|
// 更新源站点 + 目标库位状态 + 历史源库位
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "R", param.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
agvLocMastService.updateLocStsByLocNo(newLocMast.getLocNo(), "S", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
agvLocMastService.updateLocStsByLocNo(sourceLocNo, "O", "", (short) 30);
|
agvLocDetlService.delete(new EntityWrapper<AgvLocDetl>().eq("loc_no", sourceLocNo));
|
|
List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", param.getBarcode()));
|
agvWrkDetls.forEach(agvWrkDetl -> {
|
for (AgvWrkDetl wrkDetl : param.getWrkDetls()) {
|
if (wrkDetl.getMatnr().equals(agvWrkDetl.getMatnr()) && wrkDetl.getThreeCode().equals(agvWrkDetl.getThreeCode())) {
|
agvWrkDetl.setAnfme(wrkDetl.getAnfme());
|
break;
|
}
|
}
|
agvWrkDetl.setProcessSts(2);
|
agvWrkDetl.setOrderNo(agvWrkDetl.getOrderNo().substring(2));
|
agvWrkDetl.setModiUser(userId);
|
agvWrkDetl.setModiTime(now);
|
agvWrkDetl.setIoTime(now);
|
if (!agvWrkDetlService.update(agvWrkDetl, new EntityWrapper<AgvWrkDetl>()
|
.eq("matnr", agvWrkDetl.getMatnr())
|
.eq("three_code", agvWrkDetl.getThreeCode())
|
.eq("supp_code", param.getBarcode()))) {
|
throw new CoolException("更新工作明细失败");
|
}
|
});
|
return "ok";
|
}
|
|
|
/*
|
* 站点回退
|
*/
|
@Override
|
@Transactional
|
public String doBack(AgvMobileStartPakin param, Long userId) {
|
if (Cools.isEmpty(param.getBarcode()) || !CodeDetectionUtil.barcodeDetection(param.getBarcode())) {
|
throw new CoolException(param.getBarcode() + "货架码有误，请正确扫码！！！");
|
}
|
if (Cools.isEmpty(param.getDevNo()) || !CodeDetectionUtil.carCodeDetection(param.getDevNo())) {
|
throw new CoolException(param.getDevNo() + "小车地码有误，请正确扫码！！！");
|
}
|
Date now = new Date();
|
AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", param.getDevNo()));
|
AgvWrkMast agvWrkMastSource = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
|
if (!Cools.isEmpty(agvWrkMastSource)) {
|
throw new CoolException("当前站点已有退库任务");
|
}
|
Integer oldWrkNo = agvWrkMast.getWrkNo();
|
if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
|
throw new CoolException("回退任务的货架码与当前货架码不一致!");
|
}
|
if (agvWrkMast.getWrkSts() != 205) {
|
throw new CoolException("出库任务未完成!");
|
}
|
// 新建回退工作档
|
AgvWrkMast wrkMast = createWrkMast(58, 201L, agvWrkMast.getLocNo(), agvWrkMast.getSourceLocNo(), agvWrkMast.getBarcode(), now, userId, agvWrkMast.getWhsType(), 0);
|
// 更新接驳位，更新库位状态
|
agvLocMastService.updateLocStsByLocNo(wrkMast.getLocNo(), "S", wrkMast.getBarcode(), wrkMast.getWhsType().shortValue());
|
agvBasDevpService.updateLocStsAndBarcodeByDevNo(wrkMast.getSourceLocNo(), "R", wrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
|
// 更新工作明细
|
List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", agvWrkMast.getBarcode()));
|
for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
|
agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
|
// 保持工作档明细
|
agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
|
agvWrkDetl.setIoTime(now);
|
agvWrkDetl.setModiUser(userId);
|
agvWrkDetl.setModiTime(now);
|
if (!agvWrkDetlService.insert(agvWrkDetl)) {
|
throw new CoolException("保存工作明细失败");
|
}
|
// 同步订单数量
|
//OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("order_no", agvWrkDetl.getOrderNo()).in("source", 18, 31, 34));
|
List<OrderDetl> orderDetls = orderDetlService.selectList(new EntityWrapper<OrderDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("order_no", agvWrkDetl.getOrderNo()));
|
OrderDetl orderDetl = null;
|
if (orderDetls.isEmpty()) {
|
throw new CoolException("订单明细不存在");
|
} else if (orderDetls.size() > 1) {
|
for (OrderDetl detl : orderDetls) {
|
if (Cools.isEmpty(agvWrkDetl.getBatch()) && Cools.isEmpty(detl.getBatch())) {
|
orderDetl = detl;
|
} else if (!Cools.isEmpty(agvWrkDetl.getBatch()) && !Cools.isEmpty(detl.getBatch()) && agvWrkDetl.getBatch().equals(detl.getBatch())) {
|
orderDetl = detl;
|
}
|
}
|
if (orderDetl == null) {
|
throw new CoolException("订单明细不匹配");
|
}
|
} else {
|
orderDetl = orderDetls.get(0);
|
}
|
orderDetl.setQty(orderDetl.getQty() - agvWrkDetl.getAnfme());
|
if (!orderDetlService.updateById(orderDetl)) {
|
throw new CoolException("修改订单明细失败，请联系管理员" + orderDetl.getOrderNo() + orderDetl.getMatnr());
|
}
|
}
|
|
//生成AGV工作历史档 + 生成AGV工作明细历史档
|
agvWrkMastLogService.save(agvWrkMast);
|
agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
|
//删除AGV工作档
|
agvWrkMastService.deleteById(agvWrkMast);
|
//删除AGV工作明细档
|
agvWrkDetlService.delete(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", oldWrkNo));
|
return "ok";
|
}
|
|
/*
|
更新目标库位信息
|
*/
|
private void updateAgvLocMast(AgvLocMast locMast, String locSts) {
|
locMast.setLocSts(locSts);
|
agvLocMastService.updateById(locMast);
|
}
|
|
/*
|
生成工作档
|
*/
|
private AgvWrkMast createWrkMast(int ioType, long wrkSts, String sourceLocNo, String locNo, String barcode, Date now, Long userId, int containerType, int floor) {
|
AgvWrkMast wrkMast = new AgvWrkMast();
|
//工作状态
|
wrkMast.setWrkSts(wrkSts);
|
//入出库类型
|
wrkMast.setIoType(ioType);
|
wrkMast.setIoTime(now);
|
//优先级
|
wrkMast.setIoPri(300.0);
|
//源站点
|
wrkMast.setSourceLocNo(sourceLocNo);
|
//目标站点
|
wrkMast.setLocNo(locNo);
|
//货架编码
|
wrkMast.setBarcode(barcode);
|
//货架类型
|
wrkMast.setWhsType(containerType);
|
// 目标楼层
|
wrkMast.setCrnNo(floor);
|
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(now);
|
wrkMast.setLogErrMemo("doBack");
|
if (!agvWrkMastService.insertByIncrease(wrkMast)) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
wrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", locNo).eq("source_loc_no", sourceLocNo).eq("barcode", barcode).orderBy("modi_time", false));
|
|
return wrkMast;
|
}
|
|
}
|
