#

18516761980

2021-12-06 7203d67cfa3a2fc1cab9b8985dfd35c1797207b1

 src/main/java/com/zy/asrs/service/impl/WorkServiceImpl.java

@@ -12,15 +12,24 @@
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;
@@ -28,8 +37,10 @@
/**
 * 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;
@@ -58,9 +69,18 @@
    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())) {
@@ -72,7 +92,9 @@
        int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
        // 检索库位
        List<String> matNos = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatNo).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(), matNos);
        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);
@@ -136,25 +158,27 @@
        // 获取库位明细
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatNo(), paramLocDetl.getCount())) {
                LocDetl sqlParam = new LocDetl();
                sqlParam.setLocNo(paramLocDetl.getLocNo());
                sqlParam.setMatnr(paramLocDetl.getMatnr());
                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.出库
            // 启动出库开始 101.103出库
            stockOut(staNo, locDetlDtos, null, userId);
        } else {
            throw new CoolException("库位物料不存在");
            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()));
@@ -166,13 +190,15 @@
                LocDetlDto dto = iterator.next();
                if (locNo.equals(dto.getLocDetl().getLocNo())) {
                    list.add(dto);
                    iterator.remove();
//                    iterator.remove();
                }
            }
            dtos.add(new OutLocDto(locNo, list));
        }

        // 生成工作档
        for (OutLocDto dto : dtos) {

            // 判断入出库类型：101.全板出库 or 103.拣料出库
            if (ioType == null) {
                ioType = dto.isAll() ? 101 : 103;
@@ -189,7 +215,28 @@
                throw new CoolException("出库路径不存在");
            }
            // 生成工作号
            int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
            int rok;
            if(ioType==103||ioType==107){
                rok=2;
            }else{
                rok=1;
            }
            int workNo = commonService.getWorkNo(rok);

            // 当深库位出库时，查找对应的浅库位是否也有出库任务,如果有，就增加其优先级
            boolean reduce = false;
            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);
@@ -220,8 +267,8 @@
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setIoTime(new Date());
                Double anfme = ioType==101?detlDto.getLocDetl().getAnfme():detlDto.getCount();
                wrkDetl.setAnfme(anfme); // 数量
                Double qty = ioType==101?detlDto.getLocDetl().getQty():detlDto.getCount();
                wrkDetl.setQty(qty); // 数量
                VersionUtils.setWrkDetl(wrkDetl, detlDto.getLocDetl()); // 版本控制
                wrkDetl.setAppeTime(new Date());
                wrkDetl.setAppeUser(userId);
@@ -243,30 +290,75 @@
            } 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);
        // 检索库位
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, null);
        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(13D); // 优先级：10
        wrkMast.setIoPri(10D); // 优先级：10
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setFullPlt("N"); // 满板：Y
        wrkMast.setFullPlt("N"); // 满板
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
@@ -305,18 +397,20 @@

    @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(DEFAULT_WORK_NO_TYPE);
            int workNo = commonService.getWorkNo(1);
            // 获取库位
            LocMast locMast = locMastService.selectById(locNo);
            if (Cools.isEmpty(locMast)) {
                throw new CoolException(locNo+"库位不存在");
            }

            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
@@ -366,25 +460,26 @@

    @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.getMatnr())) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatNo())) {
                LocDetl sqlParam = new LocDetl();
                sqlParam.setLocNo(paramLocDetl.getLocNo());
                sqlParam.setMatnr(paramLocDetl.getMatnr());
                sqlParam.setMatNo(paramLocDetl.getMatNo());
                LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
                if (null != one) locDetlDtos.add(new LocDetlDto(one, one.getAnfme()));
                if (null != one) locDetlDtos.add(new LocDetlDto(one, one.getQty()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            // 启动出库开始 107.盘点出库
            stockOut(staNo, locDetlDtos, 107, userId);
        } else {
            throw new CoolException("库位物料不存在");
            throw new CoolException("库位产品不存在");
        }
    }

@@ -434,7 +529,7 @@
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(new Date());
            wrkDetl.setAnfme(locDetl.getAnfme());
            wrkDetl.setQty(locDetl.getQty());
            VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
            wrkDetl.setAppeTime(new Date());
            wrkDetl.setAppeUser(userId);
@@ -485,6 +580,9 @@
        } 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);
@@ -498,46 +596,59 @@
    @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.getMatnr())) {
            if (Cools.isEmpty(adjust.getMatNo())) {
                throw new CoolException(BaseRes.PARAM);
            }
            LocDetl sqlParam = new LocDetl();
            sqlParam.setLocNo(locMast.getLocNo());
            sqlParam.setMatnr(adjust.getMatnr());
            sqlParam.setMatNo(adjust.getMatNo());
            LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
            // 保存新库存明细
            if (Cools.isEmpty(one)) {
                if (adjust.getCount() == 0){
                    continue;
                }
                MatCode matCode = matCodeService.selectById(adjust.getMatnr());
                MatCode matCode = matCodeService.selectById(adjust.getMatNo());
                LocDetl locDetl = new LocDetl();
                locDetl.setLocNo(locMast.getLocNo());
                locDetl.setAnfme(adjust.getCount()); // 数量
                locDetl.setQty(adjust.getCount()); // 数量
                VersionUtils.setLocDetl(locDetl, matCode); // 版本控制
                locDetl.setModiUser(userId); // 操作人员信息
                locDetl.setModiTime(new Date());
                locDetl.setAppeUser(userId);
                locDetl.setAppeTime(new Date());
                locDetl.setZpallet(param.getZpallet());//托盘号
                if (!locDetlService.insert(locDetl)) {
                    throw new CoolException("保存库存明细失败");
                }
                // 保存调整记录
                AdjDetl adjDetl = new AdjDetl();
                adjDetl.setLocNo(locDetl.getLocNo());
                adjDetl.setMatNo(locDetl.getMatnr());
                adjDetl.setMatNo(locDetl.getMatNo());
                adjDetl.setOriQty(0.0D);
                adjDetl.setAdjQty(adjust.getCount());
                adjDetlService.save(adjDetl, userId);
            // 修改原库存明细
            } else {
                // 如果数量修改，则更新库存明细
                if (!adjust.getCount().equals(one.getAnfme())) {
                if (!adjust.getCount().equals(one.getQty())) {
                    // 当数量被修改为 0 时，直接清除库存明细
                    if (adjust.getCount() == 0) {
                        if (!locDetlService.delete(new EntityWrapper<>(one))) {
@@ -545,20 +656,20 @@
                        }
                    } else {
                        LocDetl sqlParam1 = new LocDetl();
                        sqlParam1.setAnfme(adjust.getCount());
                        sqlParam1.setQty(adjust.getCount());
                        sqlParam1.setModiTime(new Date());
                        sqlParam1.setModiUser(userId);
                        if (!locDetlService.update(sqlParam1, new EntityWrapper<LocDetl>()
                                .eq("loc_no", locMast.getLocNo())
                                .eq("matnr", adjust.getMatnr()))) {
                                .eq("mat_no", adjust.getMatNo()))) {
                            throw new CoolException("修改库存明细失败");
                        }
                    }
                    // 保存调整记录
                    AdjDetl adjDetl = new AdjDetl();
                    adjDetl.setLocNo(locMast.getLocNo());
                    adjDetl.setMatNo(adjust.getMatnr());
                    adjDetl.setOriQty(one.getAnfme());
                    adjDetl.setMatNo(adjust.getMatNo());
                    adjDetl.setOriQty(one.getQty());
                    adjDetl.setAdjQty(adjust.getCount());
                    adjDetlService.save(adjDetl, userId);
                }
@@ -629,10 +740,28 @@
        } 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);
        // 删除工作档明细
        boolean wrkDetlRes = wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no", workNo));

        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)) {
@@ -642,7 +771,7 @@
        locMast.setModiTime(new Date());
        locMast.setModiUser(userId);
        boolean locMastRes = locMastService.updateById(locMast);
        if (!wrkMastRes || !wrkDetlRes || !locMastRes) {
        if (!wrkMastRes || !locMastRes) {
            throw new CoolException("保存数据失败");
        }
    }
@@ -703,4 +832,111 @@
        }
    }

    /**
     * 因双深库位阻塞，对浅库位进行移转
     */
    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("移转失败");
                }
            }
        }
    }

}